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