2 * Copyright (C) 2004-2007 Freescale Semiconductor, Inc.
4 * See file CREDITS for list of people who contributed to this
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of
10 * the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 /*Main C file for multi-channel DMA API. */
27 #ifdef CONFIG_FSLDMAFEC
30 #include <MCD_tasksInit.h>
31 #include <MCD_progCheck.h>
33 /********************************************************************/
34 /* This is an API-internal pointer to the DMA's registers */
38 * These are the real and model task tables as generated by the
41 extern TaskTableEntry MCD_realTaskTableSrc[NCHANNELS];
42 extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS];
45 * However, this (usually) gets relocated to on-chip SRAM, at which
46 * point we access them as these tables
48 volatile TaskTableEntry *MCD_taskTable;
49 TaskTableEntry *MCD_modelTaskTable;
52 * MCD_chStatus[] is an array of status indicators for remembering
53 * whether a DMA has ever been attempted on each channel, pausing
56 static int MCD_chStatus[NCHANNELS] = {
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 MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA,
60 MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA
63 /* Prototypes for local functions */
64 static void MCD_memcpy(int *dest, int *src, u32 size);
65 static void MCD_resmActions(int channel);
68 * Buffer descriptors used for storage of progress info for single Dmas
69 * Also used as storage for the DMA for CRCs for single DMAs
70 * Otherwise, the DMA does not parse these buffer descriptors
73 extern MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
75 MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
77 MCD_bufDesc *MCD_relocBuffDesc;
79 /* Defines for the debug control register's functions */
80 #define DBG_CTL_COMP1_TASK (0x00002000)
81 #define DBG_CTL_ENABLE (DBG_CTL_AUTO_ARM | \
85 #define DBG_CTL_DISABLE (DBG_CTL_AUTO_ARM | \
88 #define DBG_KILL_ALL_STAT (0xFFFFFFFF)
90 /* Offset to context save area where progress info is stored */
91 #define CSAVE_OFFSET 10
93 /* Defines for Byte Swapping */
94 #define MCD_BYTE_SWAP_KILLER 0xFFF8888F
95 #define MCD_NO_BYTE_SWAP_ATALL 0x00040000
97 /* Execution Unit Identifiers */
98 #define MAC 0 /* legacy - not used */
99 #define LUAC 1 /* legacy - not used */
100 #define CRC 2 /* legacy - not used */
101 #define LURC 3 /* Logic Unit with CRC */
103 /* Task Identifiers */
104 #define TASK_CHAINNOEU 0
105 #define TASK_SINGLENOEU 1
106 #ifdef MCD_INCLUDE_EU
107 #define TASK_CHAINEU 2
108 #define TASK_SINGLEEU 3
112 #define TASK_CHAINEU 0
113 #define TASK_SINGLEEU 1
119 * Structure to remember which variant is on which channel
122 typedef struct MCD_remVariants_struct MCD_remVariant;
123 struct MCD_remVariants_struct {
124 int remDestRsdIncr[NCHANNELS]; /* -1,0,1 */
125 int remSrcRsdIncr[NCHANNELS]; /* -1,0,1 */
126 s16 remDestIncr[NCHANNELS]; /* DestIncr */
127 s16 remSrcIncr[NCHANNELS]; /* srcIncr */
128 u32 remXferSize[NCHANNELS]; /* xferSize */
131 /* Structure to remember the startDma parameters for each channel */
132 MCD_remVariant MCD_remVariants;
133 /********************************************************************/
134 /* Function: MCD_initDma
135 * Purpose: Initializes the DMA API by setting up a pointer to the DMA
136 * registers, relocating and creating the appropriate task
137 * structures, and setting up some global settings
139 * dmaBarAddr - pointer to the multichannel DMA registers
140 * taskTableDest - location to move DMA task code and structs to
141 * flags - operational parameters
143 * MCD_TABLE_UNALIGNED if taskTableDest is not 512-byte aligned
146 extern u32 MCD_funcDescTab0[];
148 int MCD_initDma(dmaRegs * dmaBarAddr, void *taskTableDest, u32 flags)
151 TaskTableEntry *entryPtr;
153 /* setup the local pointer to register set */
154 MCD_dmaBar = dmaBarAddr;
156 /* do we need to move/create a task table */
157 if ((flags & MCD_RELOC_TASKS) != 0) {
160 /*int *tablePtr = taskTableDest;TBD */
161 int varTabsOffset, funcDescTabsOffset, contextSavesOffset;
162 int taskDescTabsOffset;
163 int taskTableSize, varTabsSize, funcDescTabsSize,
169 /* check if physical address is aligned on 512 byte boundary */
170 if (((u32) taskTableDest & 0x000001ff) != 0)
171 return (MCD_TABLE_UNALIGNED);
173 /* set up local pointer to task Table */
174 MCD_taskTable = taskTableDest;
177 * Create a task table:
178 * - compute aligned base offsets for variable tables and
179 * function descriptor tables, then
180 * - loop through the task table and setup the pointers
181 * - copy over model task table with the the actual task
185 taskTableSize = NCHANNELS * sizeof(TaskTableEntry);
186 /* align variable tables to size */
187 varTabsOffset = taskTableSize + (u32) taskTableDest;
188 if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0)
190 (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE);
191 /* align function descriptor tables */
192 varTabsSize = NCHANNELS * VAR_TAB_SIZE;
193 funcDescTabsOffset = varTabsOffset + varTabsSize;
195 if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0)
197 (funcDescTabsOffset +
198 FUNCDESC_TAB_SIZE) & (~FUNCDESC_TAB_SIZE);
200 funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE;
201 contextSavesOffset = funcDescTabsOffset + funcDescTabsSize;
202 contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE);
204 taskTableSize + varTabsSize + funcDescTabsSize +
207 /* zero the thing out */
208 fixedPtr = (u32 *) taskTableDest;
209 for (i = 0; i < (fixedSize / 4); i++)
212 entryPtr = (TaskTableEntry *) MCD_taskTable;
213 /* set up fixed pointers */
214 for (i = 0; i < NCHANNELS; i++) {
215 /* update ptr to local value */
216 entryPtr[i].varTab = (u32) varTabsOffset;
217 entryPtr[i].FDTandFlags =
218 (u32) funcDescTabsOffset | MCD_TT_FLAGS_DEF;
219 entryPtr[i].contextSaveSpace = (u32) contextSavesOffset;
220 varTabsOffset += VAR_TAB_SIZE;
221 #ifdef MCD_INCLUDE_EU
222 /* if not there is only one, just point to the
224 funcDescTabsOffset += FUNCDESC_TAB_SIZE;
226 contextSavesOffset += CONTEXT_SAVE_SIZE;
228 /* copy over the function descriptor table */
229 for (i = 0; i < FUNCDESC_TAB_NUM; i++) {
230 MCD_memcpy((void *)(entryPtr[i].
231 FDTandFlags & ~MCD_TT_FLAGS_MASK),
232 (void *)MCD_funcDescTab0, FUNCDESC_TAB_SIZE);
235 /* copy model task table to where the context saves stuff
237 MCD_modelTaskTable = (TaskTableEntry *) contextSavesOffset;
239 MCD_memcpy((void *)MCD_modelTaskTable,
240 (void *)MCD_modelTaskTableSrc,
241 NUMOFVARIANTS * sizeof(TaskTableEntry));
243 /* point to local version of model task table */
244 entryPtr = MCD_modelTaskTable;
245 taskDescTabsOffset = (u32) MCD_modelTaskTable +
246 (NUMOFVARIANTS * sizeof(TaskTableEntry));
248 /* copy actual task code and update TDT ptrs in local
250 for (i = 0; i < NUMOFVARIANTS; i++) {
252 entryPtr[i].TDTend - entryPtr[i].TDTstart + 4;
253 MCD_memcpy((void *)taskDescTabsOffset,
254 (void *)entryPtr[i].TDTstart,
256 entryPtr[i].TDTstart = (u32) taskDescTabsOffset;
257 taskDescTabsOffset += taskDescTabSize;
258 entryPtr[i].TDTend = (u32) taskDescTabsOffset - 4;
260 #ifdef MCD_INCLUDE_EU
261 /* Tack single DMA BDs onto end of code so API controls
262 where they are since DMA might write to them */
264 (MCD_bufDesc *) (entryPtr[NUMOFVARIANTS - 1].TDTend + 4);
266 /* DMA does not touch them so they can be wherever and we
267 don't need to waste SRAM on them */
268 MCD_relocBuffDesc = MCD_singleBufDescs;
271 /* point the would-be relocated task tables and the
272 buffer descriptors to the ones the linker generated */
274 if (((u32) MCD_realTaskTableSrc & 0x000001ff) != 0)
275 return (MCD_TABLE_UNALIGNED);
277 /* need to add code to make sure that every thing else is
278 aligned properly TBD. this is problematic if we init
279 more than once or after running tasks, need to add
280 variable to see if we have aleady init'd */
281 entryPtr = MCD_realTaskTableSrc;
282 for (i = 0; i < NCHANNELS; i++) {
283 if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0) ||
285 FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0))
286 return (MCD_TABLE_UNALIGNED);
289 MCD_taskTable = MCD_realTaskTableSrc;
290 MCD_modelTaskTable = MCD_modelTaskTableSrc;
291 MCD_relocBuffDesc = MCD_singleBufDescs;
294 /* Make all channels as totally inactive, and remember them as such: */
296 MCD_dmaBar->taskbar = (u32) MCD_taskTable;
297 for (i = 0; i < NCHANNELS; i++) {
298 MCD_dmaBar->taskControl[i] = 0x0;
299 MCD_chStatus[i] = MCD_NO_DMA;
302 /* Set up pausing mechanism to inactive state: */
303 /* no particular values yet for either comparator registers */
304 MCD_dmaBar->debugComp1 = 0;
305 MCD_dmaBar->debugComp2 = 0;
306 MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
307 MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT;
309 /* enable or disable commbus prefetch, really need an ifdef or
310 something to keep from trying to set this in the 8220 */
311 if ((flags & MCD_COMM_PREFETCH_EN) != 0)
312 MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH;
314 MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH;
319 /*********************** End of MCD_initDma() ***********************/
321 /********************************************************************/
322 /* Function: MCD_dmaStatus
323 * Purpose: Returns the status of the DMA on the requested channel
324 * Arguments: channel - channel number
325 * Returns: Predefined status indicators
327 int MCD_dmaStatus(int channel)
331 if ((channel < 0) || (channel >= NCHANNELS))
332 return (MCD_CHANNEL_INVALID);
334 tcrValue = MCD_dmaBar->taskControl[channel];
335 if ((tcrValue & TASK_CTL_EN) == 0) { /* nothing running */
336 /* if last reported with task enabled */
337 if (MCD_chStatus[channel] == MCD_RUNNING
338 || MCD_chStatus[channel] == MCD_IDLE)
339 MCD_chStatus[channel] = MCD_DONE;
340 } else { /* something is running */
342 /* There are three possibilities: paused, running or idle. */
343 if (MCD_chStatus[channel] == MCD_RUNNING
344 || MCD_chStatus[channel] == MCD_IDLE) {
345 MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
346 /* This register is selected to know which initiator is
347 actually asserted. */
348 if ((MCD_dmaBar->ptdDebug >> channel) & 0x1)
349 MCD_chStatus[channel] = MCD_RUNNING;
351 MCD_chStatus[channel] = MCD_IDLE;
352 /* do not change the status if it is already paused. */
355 return MCD_chStatus[channel];
358 /******************** End of MCD_dmaStatus() ************************/
360 /********************************************************************/
361 /* Function: MCD_startDma
362 * Ppurpose: Starts a particular kind of DMA
364 * srcAddr - the channel on which to run the DMA
365 * srcIncr - the address to move data from, or buffer-descriptor address
366 * destAddr - the amount to increment the source address per transfer
367 * destIncr - the address to move data to
368 * dmaSize - the amount to increment the destination address per transfer
369 * xferSize - the number bytes in of each data movement (1, 2, or 4)
370 * initiator - what device initiates the DMA
371 * priority - priority of the DMA
372 * flags - flags describing the DMA
373 * funcDesc - description of byte swapping, bit swapping, and CRC actions
374 * srcAddrVirt - virtual buffer descriptor address TBD
375 * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
378 int MCD_startDma(int channel, s8 * srcAddr, s16 srcIncr, s8 * destAddr,
379 s16 destIncr, u32 dmaSize, u32 xferSize, u32 initiator,
380 int priority, u32 flags, u32 funcDesc
381 #ifdef MCD_NEED_ADDR_TRANS
386 int srcRsdIncr, destRsdIncr;
390 #ifdef MCD_INCLUDE_EU
394 if ((channel < 0) || (channel >= NCHANNELS))
395 return (MCD_CHANNEL_INVALID);
397 /* tbd - need to determine the proper response to a bad funcDesc when
398 not including EU functions, for now, assign a benign funcDesc, but
399 maybe should return an error */
400 #ifndef MCD_INCLUDE_EU
401 funcDesc = MCD_FUNC_NOEU1;
405 printf("startDma:Setting up params\n");
407 /* Set us up for task-wise priority. We don't technically need to do
408 this on every start, but since the register involved is in the same
409 longword as other registers that users are in control of, setting
410 it more than once is probably preferable. That since the
411 documentation doesn't seem to be completely consistent about the
412 nature of the PTD control register. */
413 MCD_dmaBar->ptdControl |= (u16) 0x8000;
415 /* Not sure what we need to keep here rtm TBD */
417 /* Calculate additional parameters to the regular DMA calls. */
418 srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0);
419 destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0);
421 xferSizeIncr = (xferSize & 0xffff) | 0x20000000;
423 /* Remember for each channel which variant is running. */
424 MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr;
425 MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr;
426 MCD_remVariants.remDestIncr[channel] = destIncr;
427 MCD_remVariants.remSrcIncr[channel] = srcIncr;
428 MCD_remVariants.remXferSize[channel] = xferSize;
432 (int *)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET +
435 #ifdef MCD_INCLUDE_EU
436 /* may move this to EU specific calls */
438 (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00);
439 /* Modify the LURC's normal and byte-residue-loop functions according
441 realFuncArray[(LURC * 16)] = xferSize == 4 ?
442 funcDesc : xferSize == 2 ?
443 funcDesc & 0xfffff00f : funcDesc & 0xffff000f;
444 realFuncArray[(LURC * 16 + 1)] =
445 (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL;
447 /* Write the initiator field in the TCR, and also set the
448 initiator-hold bit. Note that,due to a hardware quirk, this could
449 collide with an MDE access to the initiator-register file, so we
450 have to verify that the write reads back correctly. */
452 MCD_dmaBar->taskControl[channel] =
453 (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
455 while (((MCD_dmaBar->taskControl[channel] & 0x1fff) !=
456 ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM))
457 && (tcrCount < 1000)) {
459 /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020; */
460 MCD_dmaBar->taskControl[channel] =
461 (initiator << 8) | TASK_CTL_HIPRITSKEN |
465 MCD_dmaBar->priority[channel] = (u8) priority & PRIORITY_PRI_MASK;
466 /* should be albe to handle this stuff with only one write to ts reg
468 if (channel < 8 && channel >= 0) {
469 MCD_dmaBar->taskSize0 &= ~(0xf << (7 - channel) * 4);
470 MCD_dmaBar->taskSize0 |=
471 (xferSize & 3) << (((7 - channel) * 4) + 2);
472 MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel) * 4);
474 MCD_dmaBar->taskSize1 &= ~(0xf << (15 - channel) * 4);
475 MCD_dmaBar->taskSize1 |=
476 (xferSize & 3) << (((15 - channel) * 4) + 2);
477 MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel) * 4);
480 /* setup task table flags/options which mostly control the line
482 MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK;
483 MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags);
485 if (flags & MCD_FECTX_DMA) {
486 /* TDTStart and TDTEnd */
487 MCD_taskTable[channel].TDTstart =
488 MCD_modelTaskTable[TASK_FECTX].TDTstart;
489 MCD_taskTable[channel].TDTend =
490 MCD_modelTaskTable[TASK_FECTX].TDTend;
491 MCD_startDmaENetXmit(srcAddr, srcAddr, destAddr, MCD_taskTable,
493 } else if (flags & MCD_FECRX_DMA) {
494 /* TDTStart and TDTEnd */
495 MCD_taskTable[channel].TDTstart =
496 MCD_modelTaskTable[TASK_FECRX].TDTstart;
497 MCD_taskTable[channel].TDTend =
498 MCD_modelTaskTable[TASK_FECRX].TDTend;
499 MCD_startDmaENetRcv(srcAddr, srcAddr, destAddr, MCD_taskTable,
501 } else if (flags & MCD_SINGLE_DMA) {
502 /* this buffer descriptor is used for storing off initial
503 parameters for later progress query calculation and for the
504 DMA to write the resulting checksum. The DMA does not use
505 this to determine how to operate, that info is passed with
507 MCD_relocBuffDesc[channel].srcAddr = srcAddr;
508 MCD_relocBuffDesc[channel].destAddr = destAddr;
510 /* definitely not its final value */
511 MCD_relocBuffDesc[channel].lastDestAddr = destAddr;
513 MCD_relocBuffDesc[channel].dmaSize = dmaSize;
514 MCD_relocBuffDesc[channel].flags = 0; /* not used */
515 MCD_relocBuffDesc[channel].csumResult = 0; /* not used */
516 MCD_relocBuffDesc[channel].next = 0; /* not used */
518 /* Initialize the progress-querying stuff to show no
520 ((volatile int *)MCD_taskTable[channel].
521 contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr;
522 ((volatile int *)MCD_taskTable[channel].
523 contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr;
524 ((volatile int *)MCD_taskTable[channel].
525 contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
526 ((volatile int *)MCD_taskTable[channel].
527 contextSaveSpace)[CURRBD + CSAVE_OFFSET] =
528 (u32) & (MCD_relocBuffDesc[channel]);
529 /* tbd - need to keep the user from trying to call the EU
530 routine when MCD_INCLUDE_EU is not defined */
531 if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) {
532 /* TDTStart and TDTEnd */
533 MCD_taskTable[channel].TDTstart =
534 MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart;
535 MCD_taskTable[channel].TDTend =
536 MCD_modelTaskTable[TASK_SINGLENOEU].TDTend;
537 MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr,
538 destIncr, dmaSize, xferSizeIncr,
540 &(MCD_relocBuffDesc[channel]),
541 cSave, MCD_taskTable, channel);
543 /* TDTStart and TDTEnd */
544 MCD_taskTable[channel].TDTstart =
545 MCD_modelTaskTable[TASK_SINGLEEU].TDTstart;
546 MCD_taskTable[channel].TDTend =
547 MCD_modelTaskTable[TASK_SINGLEEU].TDTend;
548 MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr,
549 destIncr, dmaSize, xferSizeIncr,
551 &(MCD_relocBuffDesc[channel]),
552 cSave, MCD_taskTable, channel);
554 } else { /* chained DMAS */
555 /* Initialize the progress-querying stuff to show no
558 /* (!defined(MCD_NEED_ADDR_TRANS)) */
559 ((volatile int *)MCD_taskTable[channel].
560 contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
561 = (int)((MCD_bufDesc *) srcAddr)->srcAddr;
562 ((volatile int *)MCD_taskTable[channel].
563 contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
564 = (int)((MCD_bufDesc *) srcAddr)->destAddr;
566 /* if using address translation, need the virtual addr of the
568 ((volatile int *)MCD_taskTable[channel].
569 contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
570 = (int)((MCD_bufDesc *) srcAddrVirt)->srcAddr;
571 ((volatile int *)MCD_taskTable[channel].
572 contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
573 = (int)((MCD_bufDesc *) srcAddrVirt)->destAddr;
575 ((volatile int *)MCD_taskTable[channel].
576 contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
577 ((volatile int *)MCD_taskTable[channel].
578 contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr;
580 if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) {
581 /*TDTStart and TDTEnd */
582 MCD_taskTable[channel].TDTstart =
583 MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart;
584 MCD_taskTable[channel].TDTend =
585 MCD_modelTaskTable[TASK_CHAINNOEU].TDTend;
586 MCD_startDmaChainNoEu((int *)srcAddr, srcIncr,
589 MCD_taskTable, channel);
591 /*TDTStart and TDTEnd */
592 MCD_taskTable[channel].TDTstart =
593 MCD_modelTaskTable[TASK_CHAINEU].TDTstart;
594 MCD_taskTable[channel].TDTend =
595 MCD_modelTaskTable[TASK_CHAINEU].TDTend;
596 MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr,
597 xferSize, xferSizeIncr, cSave,
598 MCD_taskTable, channel);
601 MCD_chStatus[channel] = MCD_IDLE;
605 /************************ End of MCD_startDma() *********************/
607 /********************************************************************/
608 /* Function: MCD_XferProgrQuery
609 * Purpose: Returns progress of DMA on requested channel
610 * Arguments: channel - channel to retrieve progress for
611 * progRep - pointer to user supplied MCD_XferProg struct
612 * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
615 * MCD_XferProgrQuery() upon completing or after aborting a DMA, or
616 * while the DMA is in progress, this function returns the first
617 * DMA-destination address not (or not yet) used in the DMA. When
618 * encountering a non-ready buffer descriptor, the information for
619 * the last completed descriptor is returned.
621 * MCD_XferProgQuery() has to avoid the possibility of getting
622 * partially-updated information in the event that we should happen
623 * to query DMA progress just as the DMA is updating it. It does that
624 * by taking advantage of the fact context is not saved frequently for
625 * the most part. We therefore read it at least twice until we get the
626 * same information twice in a row.
628 * Because a small, but not insignificant, amount of time is required
629 * to write out the progress-query information, especially upon
630 * completion of the DMA, it would be wise to guarantee some time lag
631 * between successive readings of the progress-query information.
634 /* How many iterations of the loop below to execute to stabilize values */
637 int MCD_XferProgrQuery(int channel, MCD_XferProg * progRep)
639 MCD_XferProg prevRep;
640 int again; /* true if we are to try again to ge
641 consistent results */
642 int i; /* used as a time-waste counter */
643 int destDiffBytes; /* Total no of bytes that we think actually
645 int numIterations; /* number of iterations */
646 int bytesNotXfered; /* bytes that did not get xfered. */
647 s8 *LWAlignedInitDestAddr, *LWAlignedCurrDestAddr;
648 int subModVal, addModVal; /* Mode values to added and subtracted
649 from the final destAddr */
651 if ((channel < 0) || (channel >= NCHANNELS))
652 return (MCD_CHANNEL_INVALID);
654 /* Read a trial value for the progress-reporting values */
655 prevRep.lastSrcAddr =
656 (s8 *) ((volatile int *)MCD_taskTable[channel].
657 contextSaveSpace)[SRCPTR + CSAVE_OFFSET];
658 prevRep.lastDestAddr =
659 (s8 *) ((volatile int *)MCD_taskTable[channel].
660 contextSaveSpace)[DESTPTR + CSAVE_OFFSET];
662 ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT +
664 prevRep.currBufDesc =
665 (MCD_bufDesc *) ((volatile int *)MCD_taskTable[channel].
666 contextSaveSpace)[CURRBD + CSAVE_OFFSET];
667 /* Repeatedly reread those values until they match previous values: */
669 /* Waste a little bit of time to ensure stability: */
670 for (i = 0; i < STABTIME; i++) {
671 /* make sure this loop does something so that it
672 doesn't get optimized out */
675 /* Check them again: */
676 progRep->lastSrcAddr =
677 (s8 *) ((volatile int *)MCD_taskTable[channel].
678 contextSaveSpace)[SRCPTR + CSAVE_OFFSET];
679 progRep->lastDestAddr =
680 (s8 *) ((volatile int *)MCD_taskTable[channel].
681 contextSaveSpace)[DESTPTR + CSAVE_OFFSET];
683 ((volatile int *)MCD_taskTable[channel].
684 contextSaveSpace)[DCOUNT + CSAVE_OFFSET];
685 progRep->currBufDesc =
686 (MCD_bufDesc *) ((volatile int *)MCD_taskTable[channel].
687 contextSaveSpace)[CURRBD + CSAVE_OFFSET];
688 /* See if they match: */
689 if (prevRep.lastSrcAddr != progRep->lastSrcAddr
690 || prevRep.lastDestAddr != progRep->lastDestAddr
691 || prevRep.dmaSize != progRep->dmaSize
692 || prevRep.currBufDesc != progRep->currBufDesc) {
693 /* If they don't match, remember previous values and
695 prevRep.lastSrcAddr = progRep->lastSrcAddr;
696 prevRep.lastDestAddr = progRep->lastDestAddr;
697 prevRep.dmaSize = progRep->dmaSize;
698 prevRep.currBufDesc = progRep->currBufDesc;
702 } while (again == MCD_TRUE);
704 /* Update the dCount, srcAddr and destAddr */
705 /* To calculate dmaCount, we consider destination address. C
706 overs M1,P1,Z for destination */
707 switch (MCD_remVariants.remDestRsdIncr[channel]) {
711 lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) -
714 ((int)progRep->currBufDesc->
715 destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
716 LWAlignedInitDestAddr =
717 (progRep->currBufDesc->destAddr) - addModVal;
718 LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal;
719 destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr;
721 (destDiffBytes / MCD_remVariants.remDestIncr[channel]) *
722 (MCD_remVariants.remDestIncr[channel]
723 + MCD_remVariants.remXferSize[channel]);
725 destDiffBytes - bytesNotXfered + addModVal - subModVal;
728 progRep->lastDestAddr = progRep->currBufDesc->destAddr;
731 /* This value has to be subtracted from the final
732 calculated dCount. */
734 ((int)progRep->currBufDesc->
735 destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
736 /* These bytes are already in lastDestAddr. */
739 lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) -
741 LWAlignedInitDestAddr =
742 (progRep->currBufDesc->destAddr) - subModVal;
743 LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal;
744 destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr);
746 (LWAlignedCurrDestAddr -
747 LWAlignedInitDestAddr) /
748 MCD_remVariants.remDestIncr[channel];
750 numIterations * (MCD_remVariants.remDestIncr[channel]
751 - MCD_remVariants.remXferSize[channel]);
752 progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
758 /* This covers M1,P1,Z for source */
759 switch (MCD_remVariants.remSrcRsdIncr[channel]) {
761 progRep->lastSrcAddr =
762 progRep->currBufDesc->srcAddr +
763 (MCD_remVariants.remSrcIncr[channel] *
764 (progRep->dmaSize / MCD_remVariants.remXferSize[channel]));
767 progRep->lastSrcAddr = progRep->currBufDesc->srcAddr;
770 progRep->lastSrcAddr =
771 progRep->currBufDesc->srcAddr +
772 (MCD_remVariants.remSrcIncr[channel] *
773 (progRep->dmaSize / MCD_remVariants.remXferSize[channel]));
782 /******************* End of MCD_XferProgrQuery() ********************/
784 /********************************************************************/
785 /* MCD_resmActions() does the majority of the actions of a DMA resume.
786 * It is called from MCD_killDma() and MCD_resumeDma(). It has to be
787 * a separate function because the kill function has to negate the task
788 * enable before resuming it, but the resume function has to do nothing
789 * if there is no DMA on that channel (i.e., if the enable bit is 0).
791 static void MCD_resmActions(int channel)
793 MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
794 MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus;
795 /* This register is selected to know which initiator is
796 actually asserted. */
797 MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
799 if ((MCD_dmaBar->ptdDebug >> channel) & 0x1)
800 MCD_chStatus[channel] = MCD_RUNNING;
802 MCD_chStatus[channel] = MCD_IDLE;
805 /********************* End of MCD_resmActions() *********************/
807 /********************************************************************/
808 /* Function: MCD_killDma
809 * Purpose: Halt the DMA on the requested channel, without any
810 * intention of resuming the DMA.
811 * Arguments: channel - requested channel
812 * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
815 * A DMA may be killed from any state, including paused state, and it
816 * always goes to the MCD_HALTED state even if it is killed while in
817 * the MCD_NO_DMA or MCD_IDLE states.
819 int MCD_killDma(int channel)
821 /* MCD_XferProg progRep; */
823 if ((channel < 0) || (channel >= NCHANNELS))
824 return (MCD_CHANNEL_INVALID);
826 MCD_dmaBar->taskControl[channel] = 0x0;
827 MCD_resumeDma(channel);
829 * This must be after the write to the TCR so that the task doesn't
830 * start up again momentarily, and before the status assignment so
831 * as to override whatever MCD_resumeDma() may do to the channel
834 MCD_chStatus[channel] = MCD_HALTED;
837 * Update the current buffer descriptor's lastDestAddr field
839 * MCD_XferProgrQuery (channel, &progRep);
840 * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
845 /************************ End of MCD_killDma() **********************/
847 /********************************************************************/
848 /* Function: MCD_continDma
849 * Purpose: Continue a DMA which as stopped due to encountering an
850 * unready buffer descriptor.
851 * Arguments: channel - channel to continue the DMA on
852 * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
855 * This routine does not check to see if there is a task which can
856 * be continued. Also this routine should not be used with single DMAs.
858 int MCD_continDma(int channel)
860 if ((channel < 0) || (channel >= NCHANNELS))
861 return (MCD_CHANNEL_INVALID);
863 MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN;
864 MCD_chStatus[channel] = MCD_RUNNING;
869 /********************** End of MCD_continDma() **********************/
871 /*********************************************************************
872 * MCD_pauseDma() and MCD_resumeDma() below use the DMA's debug unit
873 * to freeze a task and resume it. We freeze a task by breakpointing
874 * on the stated task. That is, not any specific place in the task,
875 * but any time that task executes. In particular, when that task
876 * executes, we want to freeze that task and only that task.
878 * The bits of the debug control register influence interrupts vs.
879 * breakpoints as follows:
880 * - Bits 14 and 0 enable or disable debug functions. If enabled, you
881 * will get the interrupt but you may or may not get a breakpoint.
882 * - Bits 2 and 1 decide whether you also get a breakpoint in addition
885 * The debug unit can do these actions in response to either internally
886 * detected breakpoint conditions from the comparators, or in response
887 * to the external breakpoint pin, or both.
888 * - Bits 14 and 1 perform the above-described functions for
889 * internally-generated conditions, i.e., the debug comparators.
890 * - Bits 0 and 2 perform the above-described functions for external
891 * conditions, i.e., the breakpoint external pin.
893 * Note that, although you "always" get the interrupt when you turn
894 * the debug functions, the interrupt can nevertheless, if desired, be
895 * masked by the corresponding bit in the PTD's IMR. Note also that
896 * this means that bits 14 and 0 must enable debug functions before
897 * bits 1 and 2, respectively, have any effect.
899 * NOTE: It's extremely important to not pause more than one DMA channel
901 ********************************************************************/
903 /********************************************************************/
904 /* Function: MCD_pauseDma
905 * Purpose: Pauses the DMA on a given channel (if any DMA is running
908 * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
910 int MCD_pauseDma(int channel)
912 /* MCD_XferProg progRep; */
914 if ((channel < 0) || (channel >= NCHANNELS))
915 return (MCD_CHANNEL_INVALID);
917 if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) {
918 MCD_dmaBar->debugComp1 = channel;
919 MCD_dmaBar->debugControl =
920 DBG_CTL_ENABLE | (1 << (channel + 16));
921 MCD_chStatus[channel] = MCD_PAUSED;
924 * Update the current buffer descriptor's lastDestAddr field
926 * MCD_XferProgrQuery (channel, &progRep);
927 * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
933 /************************* End of MCD_pauseDma() ********************/
935 /********************************************************************/
936 /* Function: MCD_resumeDma
937 * Purpose: Resumes the DMA on a given channel (if any DMA is
938 * running on that channel).
939 * Arguments: channel - channel on which to resume DMA
940 * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
942 int MCD_resumeDma(int channel)
944 if ((channel < 0) || (channel >= NCHANNELS))
945 return (MCD_CHANNEL_INVALID);
947 if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN)
948 MCD_resmActions(channel);
953 /************************ End of MCD_resumeDma() ********************/
955 /********************************************************************/
956 /* Function: MCD_csumQuery
957 * Purpose: Provide the checksum after performing a non-chained DMA
958 * Arguments: channel - channel to report on
959 * csum - pointer to where to write the checksum/CRC
960 * Returns: MCD_ERROR if the channel is invalid, else MCD_OK
965 int MCD_csumQuery(int channel, u32 * csum)
967 #ifdef MCD_INCLUDE_EU
968 if ((channel < 0) || (channel >= NCHANNELS))
969 return (MCD_CHANNEL_INVALID);
971 *csum = MCD_relocBuffDesc[channel].csumResult;
978 /*********************** End of MCD_resumeDma() *********************/
980 /********************************************************************/
981 /* Function: MCD_getCodeSize
982 * Purpose: Provide the size requirements of the microcoded tasks
983 * Returns: Size in bytes
985 int MCD_getCodeSize(void)
987 #ifdef MCD_INCLUDE_EU
994 /********************** End of MCD_getCodeSize() ********************/
996 /********************************************************************/
997 /* Function: MCD_getVersion
998 * Purpose: Provide the version string and number
999 * Arguments: longVersion - user supplied pointer to a pointer to a char
1000 * which points to the version string
1001 * Returns: Version number and version string (by reference)
1003 char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)";
1004 #define MCD_REV_MAJOR 0x00
1005 #define MCD_REV_MINOR 0x03
1007 int MCD_getVersion(char **longVersion)
1009 *longVersion = MCD_versionString;
1010 return ((MCD_REV_MAJOR << 8) | MCD_REV_MINOR);
1013 /********************** End of MCD_getVersion() *********************/
1015 /********************************************************************/
1016 /* Private version of memcpy()
1017 * Note that everything this is used for is longword-aligned.
1019 static void MCD_memcpy(int *dest, int *src, u32 size)
1023 for (i = 0; i < size; i += sizeof(int), dest++, src++)
1026 #endif /* CONFIG_FSLDMAFEC */