]>
Commit | Line | Data |
---|---|---|
ce09fc49 TL |
1 | /* |
2 | * Copyright (C) 2004-2007 Freescale Semiconductor, Inc. | |
3 | * | |
1a459660 | 4 | * SPDX-License-Identifier: GPL-2.0+ |
ce09fc49 TL |
5 | */ |
6 | ||
7 | /*Main C file for multi-channel DMA API. */ | |
8 | ||
9 | #include <common.h> | |
10 | ||
ce09fc49 TL |
11 | #include <MCD_dma.h> |
12 | #include <MCD_tasksInit.h> | |
13 | #include <MCD_progCheck.h> | |
14 | ||
15 | /********************************************************************/ | |
16 | /* This is an API-internal pointer to the DMA's registers */ | |
17 | dmaRegs *MCD_dmaBar; | |
18 | ||
19 | /* | |
20 | * These are the real and model task tables as generated by the | |
21 | * build process | |
22 | */ | |
23 | extern TaskTableEntry MCD_realTaskTableSrc[NCHANNELS]; | |
24 | extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS]; | |
25 | ||
26 | /* | |
27 | * However, this (usually) gets relocated to on-chip SRAM, at which | |
28 | * point we access them as these tables | |
29 | */ | |
30 | volatile TaskTableEntry *MCD_taskTable; | |
31 | TaskTableEntry *MCD_modelTaskTable; | |
32 | ||
33 | /* | |
34 | * MCD_chStatus[] is an array of status indicators for remembering | |
35 | * whether a DMA has ever been attempted on each channel, pausing | |
36 | * status, etc. | |
37 | */ | |
38 | static int MCD_chStatus[NCHANNELS] = { | |
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 | MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA | |
43 | }; | |
44 | ||
45 | /* Prototypes for local functions */ | |
46 | static void MCD_memcpy(int *dest, int *src, u32 size); | |
47 | static void MCD_resmActions(int channel); | |
48 | ||
49 | /* | |
50 | * Buffer descriptors used for storage of progress info for single Dmas | |
51 | * Also used as storage for the DMA for CRCs for single DMAs | |
52 | * Otherwise, the DMA does not parse these buffer descriptors | |
53 | */ | |
54 | #ifdef MCD_INCLUDE_EU | |
55 | extern MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; | |
56 | #else | |
57 | MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; | |
58 | #endif | |
59 | MCD_bufDesc *MCD_relocBuffDesc; | |
60 | ||
61 | /* Defines for the debug control register's functions */ | |
62 | #define DBG_CTL_COMP1_TASK (0x00002000) | |
63 | #define DBG_CTL_ENABLE (DBG_CTL_AUTO_ARM | \ | |
64 | DBG_CTL_BREAK | \ | |
65 | DBG_CTL_INT_BREAK | \ | |
66 | DBG_CTL_COMP1_TASK) | |
67 | #define DBG_CTL_DISABLE (DBG_CTL_AUTO_ARM | \ | |
68 | DBG_CTL_INT_BREAK | \ | |
69 | DBG_CTL_COMP1_TASK) | |
70 | #define DBG_KILL_ALL_STAT (0xFFFFFFFF) | |
71 | ||
72 | /* Offset to context save area where progress info is stored */ | |
73 | #define CSAVE_OFFSET 10 | |
74 | ||
75 | /* Defines for Byte Swapping */ | |
76 | #define MCD_BYTE_SWAP_KILLER 0xFFF8888F | |
77 | #define MCD_NO_BYTE_SWAP_ATALL 0x00040000 | |
78 | ||
79 | /* Execution Unit Identifiers */ | |
80 | #define MAC 0 /* legacy - not used */ | |
81 | #define LUAC 1 /* legacy - not used */ | |
82 | #define CRC 2 /* legacy - not used */ | |
83 | #define LURC 3 /* Logic Unit with CRC */ | |
84 | ||
85 | /* Task Identifiers */ | |
86 | #define TASK_CHAINNOEU 0 | |
87 | #define TASK_SINGLENOEU 1 | |
88 | #ifdef MCD_INCLUDE_EU | |
89 | #define TASK_CHAINEU 2 | |
90 | #define TASK_SINGLEEU 3 | |
91 | #define TASK_FECRX 4 | |
92 | #define TASK_FECTX 5 | |
93 | #else | |
94 | #define TASK_CHAINEU 0 | |
95 | #define TASK_SINGLEEU 1 | |
96 | #define TASK_FECRX 2 | |
97 | #define TASK_FECTX 3 | |
98 | #endif | |
99 | ||
100 | /* | |
101 | * Structure to remember which variant is on which channel | |
102 | * TBD- need this? | |
103 | */ | |
104 | typedef struct MCD_remVariants_struct MCD_remVariant; | |
105 | struct MCD_remVariants_struct { | |
106 | int remDestRsdIncr[NCHANNELS]; /* -1,0,1 */ | |
107 | int remSrcRsdIncr[NCHANNELS]; /* -1,0,1 */ | |
108 | s16 remDestIncr[NCHANNELS]; /* DestIncr */ | |
109 | s16 remSrcIncr[NCHANNELS]; /* srcIncr */ | |
110 | u32 remXferSize[NCHANNELS]; /* xferSize */ | |
111 | }; | |
112 | ||
113 | /* Structure to remember the startDma parameters for each channel */ | |
114 | MCD_remVariant MCD_remVariants; | |
115 | /********************************************************************/ | |
116 | /* Function: MCD_initDma | |
117 | * Purpose: Initializes the DMA API by setting up a pointer to the DMA | |
118 | * registers, relocating and creating the appropriate task | |
119 | * structures, and setting up some global settings | |
120 | * Arguments: | |
121 | * dmaBarAddr - pointer to the multichannel DMA registers | |
122 | * taskTableDest - location to move DMA task code and structs to | |
123 | * flags - operational parameters | |
124 | * Return Value: | |
125 | * MCD_TABLE_UNALIGNED if taskTableDest is not 512-byte aligned | |
126 | * MCD_OK otherwise | |
127 | */ | |
128 | extern u32 MCD_funcDescTab0[]; | |
129 | ||
130 | int MCD_initDma(dmaRegs * dmaBarAddr, void *taskTableDest, u32 flags) | |
131 | { | |
132 | int i; | |
133 | TaskTableEntry *entryPtr; | |
134 | ||
135 | /* setup the local pointer to register set */ | |
136 | MCD_dmaBar = dmaBarAddr; | |
137 | ||
138 | /* do we need to move/create a task table */ | |
139 | if ((flags & MCD_RELOC_TASKS) != 0) { | |
140 | int fixedSize; | |
141 | u32 *fixedPtr; | |
142 | /*int *tablePtr = taskTableDest;TBD */ | |
143 | int varTabsOffset, funcDescTabsOffset, contextSavesOffset; | |
144 | int taskDescTabsOffset; | |
145 | int taskTableSize, varTabsSize, funcDescTabsSize, | |
146 | contextSavesSize; | |
147 | int taskDescTabSize; | |
148 | ||
149 | int i; | |
150 | ||
151 | /* check if physical address is aligned on 512 byte boundary */ | |
152 | if (((u32) taskTableDest & 0x000001ff) != 0) | |
153 | return (MCD_TABLE_UNALIGNED); | |
154 | ||
155 | /* set up local pointer to task Table */ | |
156 | MCD_taskTable = taskTableDest; | |
157 | ||
158 | /* | |
159 | * Create a task table: | |
160 | * - compute aligned base offsets for variable tables and | |
161 | * function descriptor tables, then | |
162 | * - loop through the task table and setup the pointers | |
163 | * - copy over model task table with the the actual task | |
164 | * descriptor tables | |
165 | */ | |
166 | ||
167 | taskTableSize = NCHANNELS * sizeof(TaskTableEntry); | |
168 | /* align variable tables to size */ | |
169 | varTabsOffset = taskTableSize + (u32) taskTableDest; | |
170 | if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0) | |
171 | varTabsOffset = | |
172 | (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE); | |
173 | /* align function descriptor tables */ | |
174 | varTabsSize = NCHANNELS * VAR_TAB_SIZE; | |
175 | funcDescTabsOffset = varTabsOffset + varTabsSize; | |
176 | ||
177 | if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0) | |
178 | funcDescTabsOffset = | |
179 | (funcDescTabsOffset + | |
180 | FUNCDESC_TAB_SIZE) & (~FUNCDESC_TAB_SIZE); | |
181 | ||
182 | funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE; | |
183 | contextSavesOffset = funcDescTabsOffset + funcDescTabsSize; | |
184 | contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE); | |
185 | fixedSize = | |
186 | taskTableSize + varTabsSize + funcDescTabsSize + | |
187 | contextSavesSize; | |
188 | ||
189 | /* zero the thing out */ | |
190 | fixedPtr = (u32 *) taskTableDest; | |
191 | for (i = 0; i < (fixedSize / 4); i++) | |
192 | fixedPtr[i] = 0; | |
193 | ||
194 | entryPtr = (TaskTableEntry *) MCD_taskTable; | |
195 | /* set up fixed pointers */ | |
196 | for (i = 0; i < NCHANNELS; i++) { | |
197 | /* update ptr to local value */ | |
198 | entryPtr[i].varTab = (u32) varTabsOffset; | |
199 | entryPtr[i].FDTandFlags = | |
200 | (u32) funcDescTabsOffset | MCD_TT_FLAGS_DEF; | |
201 | entryPtr[i].contextSaveSpace = (u32) contextSavesOffset; | |
202 | varTabsOffset += VAR_TAB_SIZE; | |
203 | #ifdef MCD_INCLUDE_EU | |
204 | /* if not there is only one, just point to the | |
205 | same one */ | |
206 | funcDescTabsOffset += FUNCDESC_TAB_SIZE; | |
207 | #endif | |
208 | contextSavesOffset += CONTEXT_SAVE_SIZE; | |
209 | } | |
210 | /* copy over the function descriptor table */ | |
211 | for (i = 0; i < FUNCDESC_TAB_NUM; i++) { | |
212 | MCD_memcpy((void *)(entryPtr[i]. | |
213 | FDTandFlags & ~MCD_TT_FLAGS_MASK), | |
214 | (void *)MCD_funcDescTab0, FUNCDESC_TAB_SIZE); | |
215 | } | |
216 | ||
217 | /* copy model task table to where the context saves stuff | |
218 | leaves off */ | |
219 | MCD_modelTaskTable = (TaskTableEntry *) contextSavesOffset; | |
220 | ||
221 | MCD_memcpy((void *)MCD_modelTaskTable, | |
222 | (void *)MCD_modelTaskTableSrc, | |
223 | NUMOFVARIANTS * sizeof(TaskTableEntry)); | |
224 | ||
225 | /* point to local version of model task table */ | |
226 | entryPtr = MCD_modelTaskTable; | |
227 | taskDescTabsOffset = (u32) MCD_modelTaskTable + | |
228 | (NUMOFVARIANTS * sizeof(TaskTableEntry)); | |
229 | ||
230 | /* copy actual task code and update TDT ptrs in local | |
231 | model task table */ | |
232 | for (i = 0; i < NUMOFVARIANTS; i++) { | |
233 | taskDescTabSize = | |
234 | entryPtr[i].TDTend - entryPtr[i].TDTstart + 4; | |
235 | MCD_memcpy((void *)taskDescTabsOffset, | |
236 | (void *)entryPtr[i].TDTstart, | |
237 | taskDescTabSize); | |
238 | entryPtr[i].TDTstart = (u32) taskDescTabsOffset; | |
239 | taskDescTabsOffset += taskDescTabSize; | |
240 | entryPtr[i].TDTend = (u32) taskDescTabsOffset - 4; | |
241 | } | |
242 | #ifdef MCD_INCLUDE_EU | |
243 | /* Tack single DMA BDs onto end of code so API controls | |
244 | where they are since DMA might write to them */ | |
245 | MCD_relocBuffDesc = | |
246 | (MCD_bufDesc *) (entryPtr[NUMOFVARIANTS - 1].TDTend + 4); | |
247 | #else | |
248 | /* DMA does not touch them so they can be wherever and we | |
249 | don't need to waste SRAM on them */ | |
250 | MCD_relocBuffDesc = MCD_singleBufDescs; | |
251 | #endif | |
252 | } else { | |
253 | /* point the would-be relocated task tables and the | |
254 | buffer descriptors to the ones the linker generated */ | |
255 | ||
256 | if (((u32) MCD_realTaskTableSrc & 0x000001ff) != 0) | |
257 | return (MCD_TABLE_UNALIGNED); | |
258 | ||
259 | /* need to add code to make sure that every thing else is | |
260 | aligned properly TBD. this is problematic if we init | |
261 | more than once or after running tasks, need to add | |
262 | variable to see if we have aleady init'd */ | |
263 | entryPtr = MCD_realTaskTableSrc; | |
264 | for (i = 0; i < NCHANNELS; i++) { | |
265 | if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0) || | |
266 | ((entryPtr[i]. | |
267 | FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0)) | |
268 | return (MCD_TABLE_UNALIGNED); | |
269 | } | |
270 | ||
271 | MCD_taskTable = MCD_realTaskTableSrc; | |
272 | MCD_modelTaskTable = MCD_modelTaskTableSrc; | |
273 | MCD_relocBuffDesc = MCD_singleBufDescs; | |
274 | } | |
275 | ||
276 | /* Make all channels as totally inactive, and remember them as such: */ | |
277 | ||
278 | MCD_dmaBar->taskbar = (u32) MCD_taskTable; | |
279 | for (i = 0; i < NCHANNELS; i++) { | |
280 | MCD_dmaBar->taskControl[i] = 0x0; | |
281 | MCD_chStatus[i] = MCD_NO_DMA; | |
282 | } | |
283 | ||
284 | /* Set up pausing mechanism to inactive state: */ | |
285 | /* no particular values yet for either comparator registers */ | |
286 | MCD_dmaBar->debugComp1 = 0; | |
287 | MCD_dmaBar->debugComp2 = 0; | |
288 | MCD_dmaBar->debugControl = DBG_CTL_DISABLE; | |
289 | MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT; | |
290 | ||
291 | /* enable or disable commbus prefetch, really need an ifdef or | |
292 | something to keep from trying to set this in the 8220 */ | |
293 | if ((flags & MCD_COMM_PREFETCH_EN) != 0) | |
294 | MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH; | |
295 | else | |
296 | MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH; | |
297 | ||
298 | return (MCD_OK); | |
299 | } | |
300 | ||
301 | /*********************** End of MCD_initDma() ***********************/ | |
302 | ||
303 | /********************************************************************/ | |
304 | /* Function: MCD_dmaStatus | |
305 | * Purpose: Returns the status of the DMA on the requested channel | |
306 | * Arguments: channel - channel number | |
307 | * Returns: Predefined status indicators | |
308 | */ | |
309 | int MCD_dmaStatus(int channel) | |
310 | { | |
311 | u16 tcrValue; | |
312 | ||
313 | if ((channel < 0) || (channel >= NCHANNELS)) | |
314 | return (MCD_CHANNEL_INVALID); | |
315 | ||
316 | tcrValue = MCD_dmaBar->taskControl[channel]; | |
317 | if ((tcrValue & TASK_CTL_EN) == 0) { /* nothing running */ | |
318 | /* if last reported with task enabled */ | |
319 | if (MCD_chStatus[channel] == MCD_RUNNING | |
320 | || MCD_chStatus[channel] == MCD_IDLE) | |
321 | MCD_chStatus[channel] = MCD_DONE; | |
322 | } else { /* something is running */ | |
323 | ||
324 | /* There are three possibilities: paused, running or idle. */ | |
325 | if (MCD_chStatus[channel] == MCD_RUNNING | |
326 | || MCD_chStatus[channel] == MCD_IDLE) { | |
327 | MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; | |
328 | /* This register is selected to know which initiator is | |
329 | actually asserted. */ | |
330 | if ((MCD_dmaBar->ptdDebug >> channel) & 0x1) | |
331 | MCD_chStatus[channel] = MCD_RUNNING; | |
332 | else | |
333 | MCD_chStatus[channel] = MCD_IDLE; | |
334 | /* do not change the status if it is already paused. */ | |
335 | } | |
336 | } | |
337 | return MCD_chStatus[channel]; | |
338 | } | |
339 | ||
340 | /******************** End of MCD_dmaStatus() ************************/ | |
341 | ||
342 | /********************************************************************/ | |
343 | /* Function: MCD_startDma | |
344 | * Ppurpose: Starts a particular kind of DMA | |
345 | * Arguments: | |
346 | * srcAddr - the channel on which to run the DMA | |
347 | * srcIncr - the address to move data from, or buffer-descriptor address | |
348 | * destAddr - the amount to increment the source address per transfer | |
349 | * destIncr - the address to move data to | |
350 | * dmaSize - the amount to increment the destination address per transfer | |
351 | * xferSize - the number bytes in of each data movement (1, 2, or 4) | |
352 | * initiator - what device initiates the DMA | |
353 | * priority - priority of the DMA | |
354 | * flags - flags describing the DMA | |
355 | * funcDesc - description of byte swapping, bit swapping, and CRC actions | |
356 | * srcAddrVirt - virtual buffer descriptor address TBD | |
357 | * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK | |
358 | */ | |
359 | ||
360 | int MCD_startDma(int channel, s8 * srcAddr, s16 srcIncr, s8 * destAddr, | |
361 | s16 destIncr, u32 dmaSize, u32 xferSize, u32 initiator, | |
362 | int priority, u32 flags, u32 funcDesc | |
363 | #ifdef MCD_NEED_ADDR_TRANS | |
364 | s8 * srcAddrVirt | |
365 | #endif | |
366 | ) | |
367 | { | |
368 | int srcRsdIncr, destRsdIncr; | |
369 | int *cSave; | |
370 | short xferSizeIncr; | |
371 | int tcrCount = 0; | |
372 | #ifdef MCD_INCLUDE_EU | |
373 | u32 *realFuncArray; | |
374 | #endif | |
375 | ||
376 | if ((channel < 0) || (channel >= NCHANNELS)) | |
377 | return (MCD_CHANNEL_INVALID); | |
378 | ||
379 | /* tbd - need to determine the proper response to a bad funcDesc when | |
380 | not including EU functions, for now, assign a benign funcDesc, but | |
381 | maybe should return an error */ | |
382 | #ifndef MCD_INCLUDE_EU | |
383 | funcDesc = MCD_FUNC_NOEU1; | |
384 | #endif | |
385 | ||
386 | #ifdef MCD_DEBUG | |
387 | printf("startDma:Setting up params\n"); | |
388 | #endif | |
389 | /* Set us up for task-wise priority. We don't technically need to do | |
390 | this on every start, but since the register involved is in the same | |
391 | longword as other registers that users are in control of, setting | |
392 | it more than once is probably preferable. That since the | |
393 | documentation doesn't seem to be completely consistent about the | |
394 | nature of the PTD control register. */ | |
395 | MCD_dmaBar->ptdControl |= (u16) 0x8000; | |
396 | ||
397 | /* Not sure what we need to keep here rtm TBD */ | |
398 | #if 1 | |
399 | /* Calculate additional parameters to the regular DMA calls. */ | |
400 | srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0); | |
401 | destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0); | |
402 | ||
403 | xferSizeIncr = (xferSize & 0xffff) | 0x20000000; | |
404 | ||
405 | /* Remember for each channel which variant is running. */ | |
406 | MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr; | |
407 | MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr; | |
408 | MCD_remVariants.remDestIncr[channel] = destIncr; | |
409 | MCD_remVariants.remSrcIncr[channel] = srcIncr; | |
410 | MCD_remVariants.remXferSize[channel] = xferSize; | |
411 | #endif | |
412 | ||
413 | cSave = | |
414 | (int *)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET + | |
415 | CURRBD; | |
416 | ||
417 | #ifdef MCD_INCLUDE_EU | |
418 | /* may move this to EU specific calls */ | |
419 | realFuncArray = | |
420 | (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00); | |
421 | /* Modify the LURC's normal and byte-residue-loop functions according | |
422 | to parameter. */ | |
423 | realFuncArray[(LURC * 16)] = xferSize == 4 ? | |
424 | funcDesc : xferSize == 2 ? | |
425 | funcDesc & 0xfffff00f : funcDesc & 0xffff000f; | |
426 | realFuncArray[(LURC * 16 + 1)] = | |
427 | (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL; | |
428 | #endif | |
429 | /* Write the initiator field in the TCR, and also set the | |
430 | initiator-hold bit. Note that,due to a hardware quirk, this could | |
431 | collide with an MDE access to the initiator-register file, so we | |
432 | have to verify that the write reads back correctly. */ | |
433 | ||
434 | MCD_dmaBar->taskControl[channel] = | |
435 | (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM; | |
436 | ||
437 | while (((MCD_dmaBar->taskControl[channel] & 0x1fff) != | |
438 | ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM)) | |
439 | && (tcrCount < 1000)) { | |
440 | tcrCount++; | |
441 | /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020; */ | |
442 | MCD_dmaBar->taskControl[channel] = | |
443 | (initiator << 8) | TASK_CTL_HIPRITSKEN | | |
444 | TASK_CTL_HLDINITNUM; | |
445 | } | |
446 | ||
447 | MCD_dmaBar->priority[channel] = (u8) priority & PRIORITY_PRI_MASK; | |
448 | /* should be albe to handle this stuff with only one write to ts reg | |
449 | - tbd */ | |
450 | if (channel < 8 && channel >= 0) { | |
451 | MCD_dmaBar->taskSize0 &= ~(0xf << (7 - channel) * 4); | |
452 | MCD_dmaBar->taskSize0 |= | |
453 | (xferSize & 3) << (((7 - channel) * 4) + 2); | |
454 | MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel) * 4); | |
455 | } else { | |
456 | MCD_dmaBar->taskSize1 &= ~(0xf << (15 - channel) * 4); | |
457 | MCD_dmaBar->taskSize1 |= | |
458 | (xferSize & 3) << (((15 - channel) * 4) + 2); | |
459 | MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel) * 4); | |
460 | } | |
461 | ||
462 | /* setup task table flags/options which mostly control the line | |
463 | buffers */ | |
464 | MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK; | |
465 | MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags); | |
466 | ||
467 | if (flags & MCD_FECTX_DMA) { | |
468 | /* TDTStart and TDTEnd */ | |
469 | MCD_taskTable[channel].TDTstart = | |
470 | MCD_modelTaskTable[TASK_FECTX].TDTstart; | |
471 | MCD_taskTable[channel].TDTend = | |
472 | MCD_modelTaskTable[TASK_FECTX].TDTend; | |
f6a30908 TL |
473 | MCD_startDmaENetXmit((char *)srcAddr, (char *)srcAddr, |
474 | (char *)destAddr, MCD_taskTable, | |
ce09fc49 TL |
475 | channel); |
476 | } else if (flags & MCD_FECRX_DMA) { | |
477 | /* TDTStart and TDTEnd */ | |
478 | MCD_taskTable[channel].TDTstart = | |
479 | MCD_modelTaskTable[TASK_FECRX].TDTstart; | |
480 | MCD_taskTable[channel].TDTend = | |
481 | MCD_modelTaskTable[TASK_FECRX].TDTend; | |
f6a30908 TL |
482 | MCD_startDmaENetRcv((char *)srcAddr, (char *)srcAddr, |
483 | (char *)destAddr, MCD_taskTable, | |
ce09fc49 TL |
484 | channel); |
485 | } else if (flags & MCD_SINGLE_DMA) { | |
486 | /* this buffer descriptor is used for storing off initial | |
487 | parameters for later progress query calculation and for the | |
488 | DMA to write the resulting checksum. The DMA does not use | |
489 | this to determine how to operate, that info is passed with | |
490 | the init routine */ | |
491 | MCD_relocBuffDesc[channel].srcAddr = srcAddr; | |
492 | MCD_relocBuffDesc[channel].destAddr = destAddr; | |
493 | ||
494 | /* definitely not its final value */ | |
495 | MCD_relocBuffDesc[channel].lastDestAddr = destAddr; | |
496 | ||
497 | MCD_relocBuffDesc[channel].dmaSize = dmaSize; | |
498 | MCD_relocBuffDesc[channel].flags = 0; /* not used */ | |
499 | MCD_relocBuffDesc[channel].csumResult = 0; /* not used */ | |
500 | MCD_relocBuffDesc[channel].next = 0; /* not used */ | |
501 | ||
502 | /* Initialize the progress-querying stuff to show no | |
503 | progress: */ | |
504 | ((volatile int *)MCD_taskTable[channel]. | |
505 | contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr; | |
506 | ((volatile int *)MCD_taskTable[channel]. | |
507 | contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr; | |
508 | ((volatile int *)MCD_taskTable[channel]. | |
509 | contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; | |
510 | ((volatile int *)MCD_taskTable[channel]. | |
511 | contextSaveSpace)[CURRBD + CSAVE_OFFSET] = | |
512 | (u32) & (MCD_relocBuffDesc[channel]); | |
513 | /* tbd - need to keep the user from trying to call the EU | |
514 | routine when MCD_INCLUDE_EU is not defined */ | |
515 | if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) { | |
516 | /* TDTStart and TDTEnd */ | |
517 | MCD_taskTable[channel].TDTstart = | |
518 | MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart; | |
519 | MCD_taskTable[channel].TDTend = | |
520 | MCD_modelTaskTable[TASK_SINGLENOEU].TDTend; | |
f6a30908 TL |
521 | MCD_startDmaSingleNoEu((char *)srcAddr, srcIncr, |
522 | (char *)destAddr, destIncr, | |
523 | (int)dmaSize, xferSizeIncr, | |
ce09fc49 TL |
524 | flags, (int *) |
525 | &(MCD_relocBuffDesc[channel]), | |
526 | cSave, MCD_taskTable, channel); | |
527 | } else { | |
528 | /* TDTStart and TDTEnd */ | |
529 | MCD_taskTable[channel].TDTstart = | |
530 | MCD_modelTaskTable[TASK_SINGLEEU].TDTstart; | |
531 | MCD_taskTable[channel].TDTend = | |
532 | MCD_modelTaskTable[TASK_SINGLEEU].TDTend; | |
f6a30908 TL |
533 | MCD_startDmaSingleEu((char *)srcAddr, srcIncr, |
534 | (char *)destAddr, destIncr, | |
535 | (int)dmaSize, xferSizeIncr, | |
ce09fc49 TL |
536 | flags, (int *) |
537 | &(MCD_relocBuffDesc[channel]), | |
538 | cSave, MCD_taskTable, channel); | |
539 | } | |
540 | } else { /* chained DMAS */ | |
541 | /* Initialize the progress-querying stuff to show no | |
542 | progress: */ | |
543 | #if 1 | |
544 | /* (!defined(MCD_NEED_ADDR_TRANS)) */ | |
545 | ((volatile int *)MCD_taskTable[channel]. | |
546 | contextSaveSpace)[SRCPTR + CSAVE_OFFSET] | |
547 | = (int)((MCD_bufDesc *) srcAddr)->srcAddr; | |
548 | ((volatile int *)MCD_taskTable[channel]. | |
549 | contextSaveSpace)[DESTPTR + CSAVE_OFFSET] | |
550 | = (int)((MCD_bufDesc *) srcAddr)->destAddr; | |
551 | #else | |
552 | /* if using address translation, need the virtual addr of the | |
553 | first buffdesc */ | |
554 | ((volatile int *)MCD_taskTable[channel]. | |
555 | contextSaveSpace)[SRCPTR + CSAVE_OFFSET] | |
556 | = (int)((MCD_bufDesc *) srcAddrVirt)->srcAddr; | |
557 | ((volatile int *)MCD_taskTable[channel]. | |
558 | contextSaveSpace)[DESTPTR + CSAVE_OFFSET] | |
559 | = (int)((MCD_bufDesc *) srcAddrVirt)->destAddr; | |
560 | #endif | |
561 | ((volatile int *)MCD_taskTable[channel]. | |
562 | contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; | |
563 | ((volatile int *)MCD_taskTable[channel]. | |
564 | contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr; | |
565 | ||
566 | if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) { | |
567 | /*TDTStart and TDTEnd */ | |
568 | MCD_taskTable[channel].TDTstart = | |
569 | MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart; | |
570 | MCD_taskTable[channel].TDTend = | |
571 | MCD_modelTaskTable[TASK_CHAINNOEU].TDTend; | |
572 | MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, | |
573 | destIncr, xferSize, | |
574 | xferSizeIncr, cSave, | |
575 | MCD_taskTable, channel); | |
576 | } else { | |
577 | /*TDTStart and TDTEnd */ | |
578 | MCD_taskTable[channel].TDTstart = | |
579 | MCD_modelTaskTable[TASK_CHAINEU].TDTstart; | |
580 | MCD_taskTable[channel].TDTend = | |
581 | MCD_modelTaskTable[TASK_CHAINEU].TDTend; | |
582 | MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr, | |
583 | xferSize, xferSizeIncr, cSave, | |
584 | MCD_taskTable, channel); | |
585 | } | |
586 | } | |
587 | MCD_chStatus[channel] = MCD_IDLE; | |
588 | return (MCD_OK); | |
589 | } | |
590 | ||
591 | /************************ End of MCD_startDma() *********************/ | |
592 | ||
593 | /********************************************************************/ | |
594 | /* Function: MCD_XferProgrQuery | |
595 | * Purpose: Returns progress of DMA on requested channel | |
596 | * Arguments: channel - channel to retrieve progress for | |
597 | * progRep - pointer to user supplied MCD_XferProg struct | |
598 | * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK | |
599 | * | |
600 | * Notes: | |
601 | * MCD_XferProgrQuery() upon completing or after aborting a DMA, or | |
602 | * while the DMA is in progress, this function returns the first | |
603 | * DMA-destination address not (or not yet) used in the DMA. When | |
604 | * encountering a non-ready buffer descriptor, the information for | |
605 | * the last completed descriptor is returned. | |
606 | * | |
607 | * MCD_XferProgQuery() has to avoid the possibility of getting | |
608 | * partially-updated information in the event that we should happen | |
609 | * to query DMA progress just as the DMA is updating it. It does that | |
610 | * by taking advantage of the fact context is not saved frequently for | |
611 | * the most part. We therefore read it at least twice until we get the | |
612 | * same information twice in a row. | |
613 | * | |
614 | * Because a small, but not insignificant, amount of time is required | |
615 | * to write out the progress-query information, especially upon | |
616 | * completion of the DMA, it would be wise to guarantee some time lag | |
617 | * between successive readings of the progress-query information. | |
618 | */ | |
619 | ||
620 | /* How many iterations of the loop below to execute to stabilize values */ | |
621 | #define STABTIME 0 | |
622 | ||
623 | int MCD_XferProgrQuery(int channel, MCD_XferProg * progRep) | |
624 | { | |
625 | MCD_XferProg prevRep; | |
626 | int again; /* true if we are to try again to ge | |
627 | consistent results */ | |
628 | int i; /* used as a time-waste counter */ | |
629 | int destDiffBytes; /* Total no of bytes that we think actually | |
630 | got xfered. */ | |
631 | int numIterations; /* number of iterations */ | |
632 | int bytesNotXfered; /* bytes that did not get xfered. */ | |
633 | s8 *LWAlignedInitDestAddr, *LWAlignedCurrDestAddr; | |
634 | int subModVal, addModVal; /* Mode values to added and subtracted | |
635 | from the final destAddr */ | |
636 | ||
637 | if ((channel < 0) || (channel >= NCHANNELS)) | |
638 | return (MCD_CHANNEL_INVALID); | |
639 | ||
640 | /* Read a trial value for the progress-reporting values */ | |
641 | prevRep.lastSrcAddr = | |
642 | (s8 *) ((volatile int *)MCD_taskTable[channel]. | |
643 | contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; | |
644 | prevRep.lastDestAddr = | |
645 | (s8 *) ((volatile int *)MCD_taskTable[channel]. | |
646 | contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; | |
647 | prevRep.dmaSize = | |
648 | ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + | |
649 | CSAVE_OFFSET]; | |
650 | prevRep.currBufDesc = | |
651 | (MCD_bufDesc *) ((volatile int *)MCD_taskTable[channel]. | |
652 | contextSaveSpace)[CURRBD + CSAVE_OFFSET]; | |
653 | /* Repeatedly reread those values until they match previous values: */ | |
654 | do { | |
655 | /* Waste a little bit of time to ensure stability: */ | |
656 | for (i = 0; i < STABTIME; i++) { | |
657 | /* make sure this loop does something so that it | |
658 | doesn't get optimized out */ | |
659 | i += i >> 2; | |
660 | } | |
661 | /* Check them again: */ | |
662 | progRep->lastSrcAddr = | |
663 | (s8 *) ((volatile int *)MCD_taskTable[channel]. | |
664 | contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; | |
665 | progRep->lastDestAddr = | |
666 | (s8 *) ((volatile int *)MCD_taskTable[channel]. | |
667 | contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; | |
668 | progRep->dmaSize = | |
669 | ((volatile int *)MCD_taskTable[channel]. | |
670 | contextSaveSpace)[DCOUNT + CSAVE_OFFSET]; | |
671 | progRep->currBufDesc = | |
672 | (MCD_bufDesc *) ((volatile int *)MCD_taskTable[channel]. | |
673 | contextSaveSpace)[CURRBD + CSAVE_OFFSET]; | |
674 | /* See if they match: */ | |
675 | if (prevRep.lastSrcAddr != progRep->lastSrcAddr | |
676 | || prevRep.lastDestAddr != progRep->lastDestAddr | |
677 | || prevRep.dmaSize != progRep->dmaSize | |
678 | || prevRep.currBufDesc != progRep->currBufDesc) { | |
679 | /* If they don't match, remember previous values and | |
680 | try again: */ | |
681 | prevRep.lastSrcAddr = progRep->lastSrcAddr; | |
682 | prevRep.lastDestAddr = progRep->lastDestAddr; | |
683 | prevRep.dmaSize = progRep->dmaSize; | |
684 | prevRep.currBufDesc = progRep->currBufDesc; | |
685 | again = MCD_TRUE; | |
686 | } else | |
687 | again = MCD_FALSE; | |
688 | } while (again == MCD_TRUE); | |
689 | ||
690 | /* Update the dCount, srcAddr and destAddr */ | |
691 | /* To calculate dmaCount, we consider destination address. C | |
692 | overs M1,P1,Z for destination */ | |
693 | switch (MCD_remVariants.remDestRsdIncr[channel]) { | |
694 | case MINUS1: | |
695 | subModVal = | |
696 | ((int)progRep-> | |
697 | lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - | |
698 | 1); | |
699 | addModVal = | |
700 | ((int)progRep->currBufDesc-> | |
701 | destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); | |
702 | LWAlignedInitDestAddr = | |
703 | (progRep->currBufDesc->destAddr) - addModVal; | |
704 | LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal; | |
705 | destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr; | |
706 | bytesNotXfered = | |
707 | (destDiffBytes / MCD_remVariants.remDestIncr[channel]) * | |
708 | (MCD_remVariants.remDestIncr[channel] | |
709 | + MCD_remVariants.remXferSize[channel]); | |
710 | progRep->dmaSize = | |
711 | destDiffBytes - bytesNotXfered + addModVal - subModVal; | |
712 | break; | |
713 | case ZERO: | |
714 | progRep->lastDestAddr = progRep->currBufDesc->destAddr; | |
715 | break; | |
716 | case PLUS1: | |
717 | /* This value has to be subtracted from the final | |
718 | calculated dCount. */ | |
719 | subModVal = | |
720 | ((int)progRep->currBufDesc-> | |
721 | destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); | |
722 | /* These bytes are already in lastDestAddr. */ | |
723 | addModVal = | |
724 | ((int)progRep-> | |
725 | lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - | |
726 | 1); | |
727 | LWAlignedInitDestAddr = | |
728 | (progRep->currBufDesc->destAddr) - subModVal; | |
729 | LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal; | |
730 | destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr); | |
731 | numIterations = | |
732 | (LWAlignedCurrDestAddr - | |
733 | LWAlignedInitDestAddr) / | |
734 | MCD_remVariants.remDestIncr[channel]; | |
735 | bytesNotXfered = | |
736 | numIterations * (MCD_remVariants.remDestIncr[channel] | |
737 | - MCD_remVariants.remXferSize[channel]); | |
738 | progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal; | |
739 | break; | |
740 | default: | |
741 | break; | |
742 | } | |
743 | ||
744 | /* This covers M1,P1,Z for source */ | |
745 | switch (MCD_remVariants.remSrcRsdIncr[channel]) { | |
746 | case MINUS1: | |
747 | progRep->lastSrcAddr = | |
748 | progRep->currBufDesc->srcAddr + | |
749 | (MCD_remVariants.remSrcIncr[channel] * | |
750 | (progRep->dmaSize / MCD_remVariants.remXferSize[channel])); | |
751 | break; | |
752 | case ZERO: | |
753 | progRep->lastSrcAddr = progRep->currBufDesc->srcAddr; | |
754 | break; | |
755 | case PLUS1: | |
756 | progRep->lastSrcAddr = | |
757 | progRep->currBufDesc->srcAddr + | |
758 | (MCD_remVariants.remSrcIncr[channel] * | |
759 | (progRep->dmaSize / MCD_remVariants.remXferSize[channel])); | |
760 | break; | |
761 | default: | |
762 | break; | |
763 | } | |
764 | ||
765 | return (MCD_OK); | |
766 | } | |
767 | ||
768 | /******************* End of MCD_XferProgrQuery() ********************/ | |
769 | ||
770 | /********************************************************************/ | |
771 | /* MCD_resmActions() does the majority of the actions of a DMA resume. | |
772 | * It is called from MCD_killDma() and MCD_resumeDma(). It has to be | |
773 | * a separate function because the kill function has to negate the task | |
774 | * enable before resuming it, but the resume function has to do nothing | |
775 | * if there is no DMA on that channel (i.e., if the enable bit is 0). | |
776 | */ | |
777 | static void MCD_resmActions(int channel) | |
778 | { | |
779 | MCD_dmaBar->debugControl = DBG_CTL_DISABLE; | |
780 | MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus; | |
781 | /* This register is selected to know which initiator is | |
782 | actually asserted. */ | |
783 | MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; | |
784 | ||
785 | if ((MCD_dmaBar->ptdDebug >> channel) & 0x1) | |
786 | MCD_chStatus[channel] = MCD_RUNNING; | |
787 | else | |
788 | MCD_chStatus[channel] = MCD_IDLE; | |
789 | } | |
790 | ||
791 | /********************* End of MCD_resmActions() *********************/ | |
792 | ||
793 | /********************************************************************/ | |
794 | /* Function: MCD_killDma | |
795 | * Purpose: Halt the DMA on the requested channel, without any | |
796 | * intention of resuming the DMA. | |
797 | * Arguments: channel - requested channel | |
798 | * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK | |
799 | * | |
800 | * Notes: | |
801 | * A DMA may be killed from any state, including paused state, and it | |
802 | * always goes to the MCD_HALTED state even if it is killed while in | |
803 | * the MCD_NO_DMA or MCD_IDLE states. | |
804 | */ | |
805 | int MCD_killDma(int channel) | |
806 | { | |
807 | /* MCD_XferProg progRep; */ | |
808 | ||
809 | if ((channel < 0) || (channel >= NCHANNELS)) | |
810 | return (MCD_CHANNEL_INVALID); | |
811 | ||
812 | MCD_dmaBar->taskControl[channel] = 0x0; | |
813 | MCD_resumeDma(channel); | |
814 | /* | |
815 | * This must be after the write to the TCR so that the task doesn't | |
816 | * start up again momentarily, and before the status assignment so | |
817 | * as to override whatever MCD_resumeDma() may do to the channel | |
818 | * status. | |
819 | */ | |
820 | MCD_chStatus[channel] = MCD_HALTED; | |
821 | ||
822 | /* | |
823 | * Update the current buffer descriptor's lastDestAddr field | |
824 | * | |
825 | * MCD_XferProgrQuery (channel, &progRep); | |
826 | * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; | |
827 | */ | |
828 | return (MCD_OK); | |
829 | } | |
830 | ||
831 | /************************ End of MCD_killDma() **********************/ | |
832 | ||
833 | /********************************************************************/ | |
834 | /* Function: MCD_continDma | |
835 | * Purpose: Continue a DMA which as stopped due to encountering an | |
836 | * unready buffer descriptor. | |
837 | * Arguments: channel - channel to continue the DMA on | |
838 | * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK | |
839 | * | |
840 | * Notes: | |
841 | * This routine does not check to see if there is a task which can | |
842 | * be continued. Also this routine should not be used with single DMAs. | |
843 | */ | |
844 | int MCD_continDma(int channel) | |
845 | { | |
846 | if ((channel < 0) || (channel >= NCHANNELS)) | |
847 | return (MCD_CHANNEL_INVALID); | |
848 | ||
849 | MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN; | |
850 | MCD_chStatus[channel] = MCD_RUNNING; | |
851 | ||
852 | return (MCD_OK); | |
853 | } | |
854 | ||
855 | /********************** End of MCD_continDma() **********************/ | |
856 | ||
857 | /********************************************************************* | |
858 | * MCD_pauseDma() and MCD_resumeDma() below use the DMA's debug unit | |
859 | * to freeze a task and resume it. We freeze a task by breakpointing | |
860 | * on the stated task. That is, not any specific place in the task, | |
861 | * but any time that task executes. In particular, when that task | |
862 | * executes, we want to freeze that task and only that task. | |
863 | * | |
864 | * The bits of the debug control register influence interrupts vs. | |
865 | * breakpoints as follows: | |
866 | * - Bits 14 and 0 enable or disable debug functions. If enabled, you | |
867 | * will get the interrupt but you may or may not get a breakpoint. | |
868 | * - Bits 2 and 1 decide whether you also get a breakpoint in addition | |
869 | * to an interrupt. | |
870 | * | |
871 | * The debug unit can do these actions in response to either internally | |
872 | * detected breakpoint conditions from the comparators, or in response | |
873 | * to the external breakpoint pin, or both. | |
874 | * - Bits 14 and 1 perform the above-described functions for | |
875 | * internally-generated conditions, i.e., the debug comparators. | |
876 | * - Bits 0 and 2 perform the above-described functions for external | |
877 | * conditions, i.e., the breakpoint external pin. | |
878 | * | |
879 | * Note that, although you "always" get the interrupt when you turn | |
880 | * the debug functions, the interrupt can nevertheless, if desired, be | |
881 | * masked by the corresponding bit in the PTD's IMR. Note also that | |
882 | * this means that bits 14 and 0 must enable debug functions before | |
883 | * bits 1 and 2, respectively, have any effect. | |
884 | * | |
885 | * NOTE: It's extremely important to not pause more than one DMA channel | |
886 | * at a time. | |
887 | ********************************************************************/ | |
888 | ||
889 | /********************************************************************/ | |
890 | /* Function: MCD_pauseDma | |
891 | * Purpose: Pauses the DMA on a given channel (if any DMA is running | |
892 | * on that channel). | |
893 | * Arguments: channel | |
894 | * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK | |
895 | */ | |
896 | int MCD_pauseDma(int channel) | |
897 | { | |
898 | /* MCD_XferProg progRep; */ | |
899 | ||
900 | if ((channel < 0) || (channel >= NCHANNELS)) | |
901 | return (MCD_CHANNEL_INVALID); | |
902 | ||
903 | if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) { | |
904 | MCD_dmaBar->debugComp1 = channel; | |
905 | MCD_dmaBar->debugControl = | |
906 | DBG_CTL_ENABLE | (1 << (channel + 16)); | |
907 | MCD_chStatus[channel] = MCD_PAUSED; | |
908 | ||
909 | /* | |
910 | * Update the current buffer descriptor's lastDestAddr field | |
911 | * | |
912 | * MCD_XferProgrQuery (channel, &progRep); | |
913 | * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; | |
914 | */ | |
915 | } | |
916 | return (MCD_OK); | |
917 | } | |
918 | ||
919 | /************************* End of MCD_pauseDma() ********************/ | |
920 | ||
921 | /********************************************************************/ | |
922 | /* Function: MCD_resumeDma | |
923 | * Purpose: Resumes the DMA on a given channel (if any DMA is | |
924 | * running on that channel). | |
925 | * Arguments: channel - channel on which to resume DMA | |
926 | * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK | |
927 | */ | |
928 | int MCD_resumeDma(int channel) | |
929 | { | |
930 | if ((channel < 0) || (channel >= NCHANNELS)) | |
931 | return (MCD_CHANNEL_INVALID); | |
932 | ||
933 | if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) | |
934 | MCD_resmActions(channel); | |
935 | ||
936 | return (MCD_OK); | |
937 | } | |
938 | ||
939 | /************************ End of MCD_resumeDma() ********************/ | |
940 | ||
941 | /********************************************************************/ | |
942 | /* Function: MCD_csumQuery | |
943 | * Purpose: Provide the checksum after performing a non-chained DMA | |
944 | * Arguments: channel - channel to report on | |
945 | * csum - pointer to where to write the checksum/CRC | |
946 | * Returns: MCD_ERROR if the channel is invalid, else MCD_OK | |
947 | * | |
948 | * Notes: | |
949 | * | |
950 | */ | |
951 | int MCD_csumQuery(int channel, u32 * csum) | |
952 | { | |
953 | #ifdef MCD_INCLUDE_EU | |
954 | if ((channel < 0) || (channel >= NCHANNELS)) | |
955 | return (MCD_CHANNEL_INVALID); | |
956 | ||
957 | *csum = MCD_relocBuffDesc[channel].csumResult; | |
958 | return (MCD_OK); | |
959 | #else | |
960 | return (MCD_ERROR); | |
961 | #endif | |
962 | } | |
963 | ||
964 | /*********************** End of MCD_resumeDma() *********************/ | |
965 | ||
966 | /********************************************************************/ | |
967 | /* Function: MCD_getCodeSize | |
968 | * Purpose: Provide the size requirements of the microcoded tasks | |
969 | * Returns: Size in bytes | |
970 | */ | |
971 | int MCD_getCodeSize(void) | |
972 | { | |
973 | #ifdef MCD_INCLUDE_EU | |
974 | return (0x2b5c); | |
975 | #else | |
976 | return (0x173c); | |
977 | #endif | |
978 | } | |
979 | ||
980 | /********************** End of MCD_getCodeSize() ********************/ | |
981 | ||
982 | /********************************************************************/ | |
983 | /* Function: MCD_getVersion | |
984 | * Purpose: Provide the version string and number | |
985 | * Arguments: longVersion - user supplied pointer to a pointer to a char | |
986 | * which points to the version string | |
987 | * Returns: Version number and version string (by reference) | |
988 | */ | |
989 | char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)"; | |
990 | #define MCD_REV_MAJOR 0x00 | |
991 | #define MCD_REV_MINOR 0x03 | |
992 | ||
993 | int MCD_getVersion(char **longVersion) | |
994 | { | |
995 | *longVersion = MCD_versionString; | |
996 | return ((MCD_REV_MAJOR << 8) | MCD_REV_MINOR); | |
997 | } | |
998 | ||
999 | /********************** End of MCD_getVersion() *********************/ | |
1000 | ||
1001 | /********************************************************************/ | |
1002 | /* Private version of memcpy() | |
1003 | * Note that everything this is used for is longword-aligned. | |
1004 | */ | |
1005 | static void MCD_memcpy(int *dest, int *src, u32 size) | |
1006 | { | |
1007 | u32 i; | |
1008 | ||
1009 | for (i = 0; i < size; i += sizeof(int), dest++, src++) | |
1010 | *dest = *src; | |
1011 | } |