drivers/dma/MCD_dmaApi.c

   1 /*
   2  * Copyright (C) 2004-2007 Freescale Semiconductor, Inc.
   3  *
   4  * See file CREDITS for list of people who contributed to this
   5  * project.
   6  *
   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.
  11  *
  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.
  16  *
  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,
  20  * MA 02111-1307 USA
  21  */
  22
  23 /*Main C file for multi-channel DMA API. */
  24
  25 #include <common.h>
  26
  27 #ifdef CONFIG_FSLDMAFEC
  28
  29 #include <MCD_dma.h>
  30 #include <MCD_tasksInit.h>
  31 #include <MCD_progCheck.h>
  32
  33 /********************************************************************/
  34 /* This is an API-internal pointer to the DMA's registers */
  35 dmaRegs *MCD_dmaBar;
  36
  37 /*
  38  * These are the real and model task tables as generated by the
  39  * build process
  40  */
  41 extern TaskTableEntry MCD_realTaskTableSrc[NCHANNELS];
  42 extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS];
  43
  44 /*
  45  * However, this (usually) gets relocated to on-chip SRAM, at which
  46  * point we access them as these tables
  47  */
  48 volatile TaskTableEntry *MCD_taskTable;
  49 TaskTableEntry *MCD_modelTaskTable;
  50
  51 /*
  52  * MCD_chStatus[] is an array of status indicators for remembering
  53  * whether a DMA has ever been attempted on each channel, pausing
  54  * status, etc.
  55  */
  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
  61 };
  62
  63 /* Prototypes for local functions */
  64 static void MCD_memcpy(int *dest, int *src, u32 size);
  65 static void MCD_resmActions(int channel);
  66
  67 /*
  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
  71  */
  72 #ifdef MCD_INCLUDE_EU
  73 extern MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
  74 #else
  75 MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
  76 #endif
  77 MCD_bufDesc *MCD_relocBuffDesc;
  78
  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       | \
  82                                  DBG_CTL_BREAK          | \
  83                                  DBG_CTL_INT_BREAK      | \
  84                                  DBG_CTL_COMP1_TASK)
  85 #define DBG_CTL_DISABLE         (DBG_CTL_AUTO_ARM       | \
  86                                  DBG_CTL_INT_BREAK      | \
  87                                  DBG_CTL_COMP1_TASK)
  88 #define DBG_KILL_ALL_STAT       (0xFFFFFFFF)
  89
  90 /* Offset to context save area where progress info is stored */
  91 #define CSAVE_OFFSET            10
  92
  93 /* Defines for Byte Swapping */
  94 #define MCD_BYTE_SWAP_KILLER    0xFFF8888F
  95 #define MCD_NO_BYTE_SWAP_ATALL  0x00040000
  96
  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 */
 102
 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
 109 #define TASK_FECRX              4
 110 #define TASK_FECTX              5
 111 #else
 112 #define TASK_CHAINEU            0
 113 #define TASK_SINGLEEU           1
 114 #define TASK_FECRX              2
 115 #define TASK_FECTX              3
 116 #endif
 117
 118 /*
 119  * Structure to remember which variant is on which channel
 120  * TBD- need this?
 121  */
 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 */
 129 };
 130
 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
 138  * Arguments:
 139  *  dmaBarAddr    - pointer to the multichannel DMA registers
 140  *  taskTableDest - location to move DMA task code and structs to
 141  *  flags         - operational parameters
 142  * Return Value:
 143  *  MCD_TABLE_UNALIGNED if taskTableDest is not 512-byte aligned
 144  *  MCD_OK otherwise
 145  */
 146 extern u32 MCD_funcDescTab0[];
 147
 148 int MCD_initDma(dmaRegs * dmaBarAddr, void *taskTableDest, u32 flags)
 149 {
 150         int i;
 151         TaskTableEntry *entryPtr;
 152
 153         /* setup the local pointer to register set */
 154         MCD_dmaBar = dmaBarAddr;
 155
 156         /* do we need to move/create a task table */
 157         if ((flags & MCD_RELOC_TASKS) != 0) {
 158                 int fixedSize;
 159                 u32 *fixedPtr;
 160                 /*int *tablePtr = taskTableDest;TBD */
 161                 int varTabsOffset, funcDescTabsOffset, contextSavesOffset;
 162                 int taskDescTabsOffset;
 163                 int taskTableSize, varTabsSize, funcDescTabsSize,
 164                     contextSavesSize;
 165                 int taskDescTabSize;
 166
 167                 int i;
 168
 169                 /* check if physical address is aligned on 512 byte boundary */
 170                 if (((u32) taskTableDest & 0x000001ff) != 0)
 171                         return (MCD_TABLE_UNALIGNED);
 172
 173                 /* set up local pointer to task Table */
 174                 MCD_taskTable = taskTableDest;
 175
 176                 /*
 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
 182                  *   descriptor tables
 183                  */
 184
 185                 taskTableSize = NCHANNELS * sizeof(TaskTableEntry);
 186                 /* align variable tables to size */
 187                 varTabsOffset = taskTableSize + (u32) taskTableDest;
 188                 if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0)
 189                         varTabsOffset =
 190                             (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE);
 191                 /* align function descriptor tables */
 192                 varTabsSize = NCHANNELS * VAR_TAB_SIZE;
 193                 funcDescTabsOffset = varTabsOffset + varTabsSize;
 194
 195                 if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0)
 196                         funcDescTabsOffset =
 197                             (funcDescTabsOffset +
 198                              FUNCDESC_TAB_SIZE) & (~FUNCDESC_TAB_SIZE);
 199
 200                 funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE;
 201                 contextSavesOffset = funcDescTabsOffset + funcDescTabsSize;
 202                 contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE);
 203                 fixedSize =
 204                     taskTableSize + varTabsSize + funcDescTabsSize +
 205                     contextSavesSize;
 206
 207                 /* zero the thing out */
 208                 fixedPtr = (u32 *) taskTableDest;
 209                 for (i = 0; i < (fixedSize / 4); i++)
 210                         fixedPtr[i] = 0;
 211
 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
 223                            same one */
 224                         funcDescTabsOffset += FUNCDESC_TAB_SIZE;
 225 #endif
 226                         contextSavesOffset += CONTEXT_SAVE_SIZE;
 227                 }
 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);
 233                 }
 234
 235                 /* copy model task table to where the context saves stuff
 236                    leaves off */
 237                 MCD_modelTaskTable = (TaskTableEntry *) contextSavesOffset;
 238
 239                 MCD_memcpy((void *)MCD_modelTaskTable,
 240                            (void *)MCD_modelTaskTableSrc,
 241                            NUMOFVARIANTS * sizeof(TaskTableEntry));
 242
 243                 /* point to local version of model task table */
 244                 entryPtr = MCD_modelTaskTable;
 245                 taskDescTabsOffset = (u32) MCD_modelTaskTable +
 246                     (NUMOFVARIANTS * sizeof(TaskTableEntry));
 247
 248                 /* copy actual task code and update TDT ptrs in local
 249                    model task table */
 250                 for (i = 0; i < NUMOFVARIANTS; i++) {
 251                         taskDescTabSize =
 252                             entryPtr[i].TDTend - entryPtr[i].TDTstart + 4;
 253                         MCD_memcpy((void *)taskDescTabsOffset,
 254                                    (void *)entryPtr[i].TDTstart,
 255                                    taskDescTabSize);
 256                         entryPtr[i].TDTstart = (u32) taskDescTabsOffset;
 257                         taskDescTabsOffset += taskDescTabSize;
 258                         entryPtr[i].TDTend = (u32) taskDescTabsOffset - 4;
 259                 }
 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 */
 263                 MCD_relocBuffDesc =
 264                     (MCD_bufDesc *) (entryPtr[NUMOFVARIANTS - 1].TDTend + 4);
 265 #else
 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;
 269 #endif
 270         } else {
 271                 /* point the would-be relocated task tables and the
 272                    buffer descriptors to the ones the linker generated */
 273
 274                 if (((u32) MCD_realTaskTableSrc & 0x000001ff) != 0)
 275                         return (MCD_TABLE_UNALIGNED);
 276
 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) ||
 284                             ((entryPtr[i].
 285                               FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0))
 286                                 return (MCD_TABLE_UNALIGNED);
 287                 }
 288
 289                 MCD_taskTable = MCD_realTaskTableSrc;
 290                 MCD_modelTaskTable = MCD_modelTaskTableSrc;
 291                 MCD_relocBuffDesc = MCD_singleBufDescs;
 292         }
 293
 294         /* Make all channels as totally inactive, and remember them as such: */
 295
 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;
 300         }
 301
 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;
 308
 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;
 313         else
 314                 MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH;
 315
 316         return (MCD_OK);
 317 }
 318
 319 /*********************** End of MCD_initDma() ***********************/
 320
 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
 326  */
 327 int MCD_dmaStatus(int channel)
 328 {
 329         u16 tcrValue;
 330
 331         if ((channel < 0) || (channel >= NCHANNELS))
 332                 return (MCD_CHANNEL_INVALID);
 333
 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 */
 341
 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;
 350                         else
 351                                 MCD_chStatus[channel] = MCD_IDLE;
 352                         /* do not change the status if it is already paused. */
 353                 }
 354         }
 355         return MCD_chStatus[channel];
 356 }
 357
 358 /******************** End of MCD_dmaStatus() ************************/
 359
 360 /********************************************************************/
 361 /* Function:    MCD_startDma
 362  * Ppurpose:    Starts a particular kind of DMA
 363  * Arguments:
 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
 376  */
 377
 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
 382                  s8 * srcAddrVirt
 383 #endif
 384     )
 385 {
 386         int srcRsdIncr, destRsdIncr;
 387         int *cSave;
 388         short xferSizeIncr;
 389         int tcrCount = 0;
 390 #ifdef MCD_INCLUDE_EU
 391         u32 *realFuncArray;
 392 #endif
 393
 394         if ((channel < 0) || (channel >= NCHANNELS))
 395                 return (MCD_CHANNEL_INVALID);
 396
 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;
 402 #endif
 403
 404 #ifdef MCD_DEBUG
 405         printf("startDma:Setting up params\n");
 406 #endif
 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;
 414
 415         /* Not sure what we need to keep here rtm TBD */
 416 #if 1
 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);
 420
 421         xferSizeIncr = (xferSize & 0xffff) | 0x20000000;
 422
 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;
 429 #endif
 430
 431         cSave =
 432             (int *)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET +
 433             CURRBD;
 434
 435 #ifdef MCD_INCLUDE_EU
 436         /* may move this to EU specific calls */
 437         realFuncArray =
 438             (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00);
 439         /* Modify the LURC's normal and byte-residue-loop functions according
 440            to parameter. */
 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;
 446 #endif
 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. */
 451
 452         MCD_dmaBar->taskControl[channel] =
 453             (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
 454
 455         while (((MCD_dmaBar->taskControl[channel] & 0x1fff) !=
 456                 ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM))
 457                && (tcrCount < 1000)) {
 458                 tcrCount++;
 459                 /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020; */
 460                 MCD_dmaBar->taskControl[channel] =
 461                     (initiator << 8) | TASK_CTL_HIPRITSKEN |
 462                     TASK_CTL_HLDINITNUM;
 463         }
 464
 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
 467            - tbd */
 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);
 473         } else {
 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);
 478         }
 479
 480         /* setup task table flags/options which mostly control the line
 481            buffers */
 482         MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK;
 483         MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags);
 484
 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,
 492                                      channel);
 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,
 500                                     channel);
 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
 506                    the init routine */
 507                 MCD_relocBuffDesc[channel].srcAddr = srcAddr;
 508                 MCD_relocBuffDesc[channel].destAddr = destAddr;
 509
 510                 /* definitely not its final value */
 511                 MCD_relocBuffDesc[channel].lastDestAddr = destAddr;
 512
 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 */
 517
 518                 /* Initialize the progress-querying stuff to show no
 519                    progress: */
 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,
 539                                                flags, (int *)
 540                                                &(MCD_relocBuffDesc[channel]),
 541                                                cSave, MCD_taskTable, channel);
 542                 } else {
 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,
 550                                              flags, (int *)
 551                                              &(MCD_relocBuffDesc[channel]),
 552                                              cSave, MCD_taskTable, channel);
 553                 }
 554         } else {                /* chained DMAS */
 555                 /* Initialize the progress-querying stuff to show no
 556                    progress: */
 557 #if 1
 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;
 565 #else
 566                 /* if using address translation, need the virtual addr of the
 567                    first buffdesc */
 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;
 574 #endif
 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;
 579
 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,
 587                                               destIncr, xferSize,
 588                                               xferSizeIncr, cSave,
 589                                               MCD_taskTable, channel);
 590                 } else {
 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);
 599                 }
 600         }
 601         MCD_chStatus[channel] = MCD_IDLE;
 602         return (MCD_OK);
 603 }
 604
 605 /************************ End of MCD_startDma() *********************/
 606
 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
 613  *
 614  * Notes:
 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.
 620  *
 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.
 627  *
 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.
 632  */
 633
 634 /* How many iterations of the loop below to execute to stabilize values */
 635 #define STABTIME 0
 636
 637 int MCD_XferProgrQuery(int channel, MCD_XferProg * progRep)
 638 {
 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
 644                                    got xfered. */
 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 */
 650
 651         if ((channel < 0) || (channel >= NCHANNELS))
 652                 return (MCD_CHANNEL_INVALID);
 653
 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];
 661         prevRep.dmaSize =
 662             ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT +
 663                                                                       CSAVE_OFFSET];
 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: */
 668         do {
 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 */
 673                         i += i >> 2;
 674                 }
 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];
 682                 progRep->dmaSize =
 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
 694                            try again: */
 695                         prevRep.lastSrcAddr = progRep->lastSrcAddr;
 696                         prevRep.lastDestAddr = progRep->lastDestAddr;
 697                         prevRep.dmaSize = progRep->dmaSize;
 698                         prevRep.currBufDesc = progRep->currBufDesc;
 699                         again = MCD_TRUE;
 700                 } else
 701                         again = MCD_FALSE;
 702         } while (again == MCD_TRUE);
 703
 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]) {
 708         case MINUS1:
 709                 subModVal =
 710                     ((int)progRep->
 711                      lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) -
 712                                       1);
 713                 addModVal =
 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;
 720                 bytesNotXfered =
 721                     (destDiffBytes / MCD_remVariants.remDestIncr[channel]) *
 722                     (MCD_remVariants.remDestIncr[channel]
 723                      + MCD_remVariants.remXferSize[channel]);
 724                 progRep->dmaSize =
 725                     destDiffBytes - bytesNotXfered + addModVal - subModVal;
 726                 break;
 727         case ZERO:
 728                 progRep->lastDestAddr = progRep->currBufDesc->destAddr;
 729                 break;
 730         case PLUS1:
 731                 /* This value has to be subtracted from the final
 732                    calculated dCount. */
 733                 subModVal =
 734                     ((int)progRep->currBufDesc->
 735                      destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
 736                 /* These bytes are already in lastDestAddr. */
 737                 addModVal =
 738                     ((int)progRep->
 739                      lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) -
 740                                       1);
 741                 LWAlignedInitDestAddr =
 742                     (progRep->currBufDesc->destAddr) - subModVal;
 743                 LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal;
 744                 destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr);
 745                 numIterations =
 746                     (LWAlignedCurrDestAddr -
 747                      LWAlignedInitDestAddr) /
 748                     MCD_remVariants.remDestIncr[channel];
 749                 bytesNotXfered =
 750                     numIterations * (MCD_remVariants.remDestIncr[channel]
 751                                      - MCD_remVariants.remXferSize[channel]);
 752                 progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
 753                 break;
 754         default:
 755                 break;
 756         }
 757
 758         /* This covers M1,P1,Z for source */
 759         switch (MCD_remVariants.remSrcRsdIncr[channel]) {
 760         case MINUS1:
 761                 progRep->lastSrcAddr =
 762                     progRep->currBufDesc->srcAddr +
 763                     (MCD_remVariants.remSrcIncr[channel] *
 764                      (progRep->dmaSize / MCD_remVariants.remXferSize[channel]));
 765                 break;
 766         case ZERO:
 767                 progRep->lastSrcAddr = progRep->currBufDesc->srcAddr;
 768                 break;
 769         case PLUS1:
 770                 progRep->lastSrcAddr =
 771                     progRep->currBufDesc->srcAddr +
 772                     (MCD_remVariants.remSrcIncr[channel] *
 773                      (progRep->dmaSize / MCD_remVariants.remXferSize[channel]));
 774                 break;
 775         default:
 776                 break;
 777         }
 778
 779         return (MCD_OK);
 780 }
 781
 782 /******************* End of MCD_XferProgrQuery() ********************/
 783
 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).
 790  */
 791 static void MCD_resmActions(int channel)
 792 {
 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;
 798
 799         if ((MCD_dmaBar->ptdDebug >> channel) & 0x1)
 800                 MCD_chStatus[channel] = MCD_RUNNING;
 801         else
 802                 MCD_chStatus[channel] = MCD_IDLE;
 803 }
 804
 805 /********************* End of MCD_resmActions() *********************/
 806
 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
 813  *
 814  * Notes:
 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.
 818  */
 819 int MCD_killDma(int channel)
 820 {
 821         /* MCD_XferProg progRep; */
 822
 823         if ((channel < 0) || (channel >= NCHANNELS))
 824                 return (MCD_CHANNEL_INVALID);
 825
 826         MCD_dmaBar->taskControl[channel] = 0x0;
 827         MCD_resumeDma(channel);
 828         /*
 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
 832          * status.
 833          */
 834         MCD_chStatus[channel] = MCD_HALTED;
 835
 836         /*
 837          * Update the current buffer descriptor's lastDestAddr field
 838          *
 839          * MCD_XferProgrQuery (channel, &progRep);
 840          * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
 841          */
 842         return (MCD_OK);
 843 }
 844
 845 /************************ End of MCD_killDma() **********************/
 846
 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
 853  *
 854  * Notes:
 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.
 857  */
 858 int MCD_continDma(int channel)
 859 {
 860         if ((channel < 0) || (channel >= NCHANNELS))
 861                 return (MCD_CHANNEL_INVALID);
 862
 863         MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN;
 864         MCD_chStatus[channel] = MCD_RUNNING;
 865
 866         return (MCD_OK);
 867 }
 868
 869 /********************** End of MCD_continDma() **********************/
 870
 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.
 877  *
 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
 883  *   to an interrupt.
 884  *
 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.
 892  *
 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.
 898  *
 899  * NOTE: It's extremely important to not pause more than one DMA channel
 900  *  at a time.
 901  ********************************************************************/
 902
 903 /********************************************************************/
 904 /* Function:    MCD_pauseDma
 905  * Purpose:     Pauses the DMA on a given channel (if any DMA is running
 906  *              on that channel).
 907  * Arguments:   channel
 908  * Returns:     MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK
 909  */
 910 int MCD_pauseDma(int channel)
 911 {
 912         /* MCD_XferProg progRep; */
 913
 914         if ((channel < 0) || (channel >= NCHANNELS))
 915                 return (MCD_CHANNEL_INVALID);
 916
 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;
 922
 923                 /*
 924                  * Update the current buffer descriptor's lastDestAddr field
 925                  *
 926                  * MCD_XferProgrQuery (channel, &progRep);
 927                  * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
 928                  */
 929         }
 930         return (MCD_OK);
 931 }
 932
 933 /************************* End of MCD_pauseDma() ********************/
 934
 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
 941  */
 942 int MCD_resumeDma(int channel)
 943 {
 944         if ((channel < 0) || (channel >= NCHANNELS))
 945                 return (MCD_CHANNEL_INVALID);
 946
 947         if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN)
 948                 MCD_resmActions(channel);
 949
 950         return (MCD_OK);
 951 }
 952
 953 /************************ End of MCD_resumeDma() ********************/
 954
 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
 961  *
 962  * Notes:
 963  *
 964  */
 965 int MCD_csumQuery(int channel, u32 * csum)
 966 {
 967 #ifdef MCD_INCLUDE_EU
 968         if ((channel < 0) || (channel >= NCHANNELS))
 969                 return (MCD_CHANNEL_INVALID);
 970
 971         *csum = MCD_relocBuffDesc[channel].csumResult;
 972         return (MCD_OK);
 973 #else
 974         return (MCD_ERROR);
 975 #endif
 976 }
 977
 978 /*********************** End of MCD_resumeDma() *********************/
 979
 980 /********************************************************************/
 981 /* Function:    MCD_getCodeSize
 982  * Purpose:     Provide the size requirements of the microcoded tasks
 983  * Returns:     Size in bytes
 984  */
 985 int MCD_getCodeSize(void)
 986 {
 987 #ifdef MCD_INCLUDE_EU
 988         return (0x2b5c);
 989 #else
 990         return (0x173c);
 991 #endif
 992 }
 993
 994 /********************** End of MCD_getCodeSize() ********************/
 995
 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)
1002  */
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
1006
1007 int MCD_getVersion(char **longVersion)
1008 {
1009         *longVersion = MCD_versionString;
1010         return ((MCD_REV_MAJOR << 8) | MCD_REV_MINOR);
1011 }
1012
1013 /********************** End of MCD_getVersion() *********************/
1014
1015 /********************************************************************/
1016 /* Private version of memcpy()
1017  * Note that everything this is used for is longword-aligned.
1018  */
1019 static void MCD_memcpy(int *dest, int *src, u32 size)
1020 {
1021         u32 i;
1022
1023         for (i = 0; i < size; i += sizeof(int), dest++, src++)
1024                 *dest = *src;
1025 }
1026 #endif                          /* CONFIG_FSLDMAFEC */