* and all EDMA handles are closed, freeing them for use on the next        *
 * iteration.                                                               *
\****************************************************************************/
void
hwiEdma(void)  
{ 
    LOG_message("Starting EDMA ISR",0);
    EDMA_intClear(tcc);          /* Clear the interrupt in the CIPR         */
    EDMA_intFree(tcc);           /* Free the TCC value to the system        */
    EDMA_close(hEdmaRevt);       /* Close the hard decisions EDMA channel   */
    EDMA_close(hEdmaXevt);       /* Close the IC values EDMA channel        */
    EDMA_freeTable(hEdmaBrMet);  /* Close the branch metrics EDMA channel   */
    EDMA_freeTable(hEdmaOutPar); /* Close the output parameters EDMA channel*/
    EDMA_freeTable(hEdmaNull);   /* Close the NULL EDMA channel             */
    SEM_post(&semVcpDone);       /* Post semaphore reporting that processing*/
                                 /*   is done                               */
    LOG_message("Finishing EDMA ISR",0);

} /* end edmaIsr */


/****************************************************************************\
 * submitEdma: The EDMA is programmed to service the user channel. The IC   *
 * values are configured and all EDMA parameters are calculated here.       *
\****************************************************************************/
void
submitEdma(VCP_UserData *userData, VCP_Params *vcpParameters,
           Uint32 **decisions, Uint32 **outParms, VCP_ConfigIc **configIc,
           Uint32 *numDec)
{
EDMA_Config edmaConfig;
Uint32 frameLen  = vcpParameters->frameLen;
Uint32 constLen  = vcpParameters->constLen;
Uint32 rate      = vcpParameters->rate;
Uint32 symx      = vcpParameters->bmBuffLen;
Uint32 symr      = vcpParameters->decBuffLen;
Uint32 decision  = vcpParameters->decision;
Uint32 traceBack = vcpParameters->traceBack;
Uint32 numBm, length, elCount, numFrames;
Uint32 *decAddr;

    /* Allocate transfer completion code */
    tcc = EDMA_intAlloc(-1);

    /* Allocate memory for IC Values */
    *configIc = MEM_alloc(ISRAM, VCP_NUM_IC * sizeof(Uint32), 2 * sizeof(Uint32));
    
    /* Calculate the VCP IC values */
    VCP_genIc(vcpParameters, *configIc);
      
    /* Open handles to the EDMA channels */
    hEdmaRevt    = EDMA_open(EDMA_CHA_VCPREVT, EDMA_OPEN_RESET);
    hEdmaXevt    = EDMA_open(EDMA_CHA_VCPXEVT, EDMA_OPEN_RESET);
    EDMA_allocTableEx(1, &hEdmaBrMet);
    EDMA_allocTableEx(1, &hEdmaOutPar);
    EDMA_allocTableEx(1, &hEdmaNull);
    EDMA_reset(hEdmaNull);

    /* Configure channel parameters for IC registers */
    edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                     EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_INC,
                     EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_INC,
                     EDMA_OPT_TCINT_NO,             EDMA_OPT_TCC_DEFAULT,
                     EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_NO,
                     EDMA_OPT_ATCC_DEFAULT,         EDMA_OPT_PDTS_DISABLE,
                     EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                     EDMA_OPT_FS_YES);

    edmaConfig.src = (Uint32)*configIc;
    edmaConfig.cnt = (Uint32)VCP_NUM_IC;
    edmaConfig.dst = (Uint32)VCP_ICMEM_ADDR;
    edmaConfig.idx = 0;
    edmaConfig.rld = 0;
    EDMA_config(hEdmaXevt, &edmaConfig);
    EDMA_link(hEdmaXevt, hEdmaBrMet);
        
    /* Configure channel parameters for branch metrics data */
    numBm = 1 << (rate - 1);                /* number of Branch Metrics   */
    length = frameLen + constLen - 1;       /* calculate the frame length */
    numFrames = VCP_normalCeil(length, 4 * symx);/* number of sub frames  */
    
    length = VCP_ceil(length, 2)<<2;        /* Find frame length used     */
    if (symx < length) elCount = symx * numBm; /* Select the smaller count*/
    else elCount = length * numBm;          /* symbols per evt or framelen*/
    
    edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                     EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_INC,
                     EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_NONE,
                     EDMA_OPT_TCINT_NO,             EDMA_OPT_TCC_DEFAULT,
                     EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_NO,
                     EDMA_OPT_ATCC_DEFAULT,         EDMA_OPT_PDTS_DISABLE,
                     EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                     EDMA_OPT_FS_YES);

    edmaConfig.src = (Uint32)userData;
    edmaConfig.cnt = EDMA_CNT_RMK(numFrames - 1, elCount);
    edmaConfig.dst = (Uint32)VCP_BMMEM_ADDR;
    EDMA_config(hEdmaBrMet, &edmaConfig);
    EDMA_link(hEdmaBrMet, hEdmaNull);

    /* Configure channel parameters for decision data */
    if ((decision == VCP_DECISION_HARD) && (traceBack == VCP_TRACEBACK_TAILED)){
      edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                       EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_NONE,
                       EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_DEC,
                       EDMA_OPT_TCINT_NO,             EDMA_OPT_TCC_DEFAULT,
                       EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_NO,
                       EDMA_OPT_ATCC_DEFAULT,         EDMA_OPT_PDTS_DISABLE,
                       EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                       EDMA_OPT_FS_YES);
      if (64 * symr < frameLen) elCount = 64 * symr;
      else elCount = frameLen;
      elCount = 2 * VCP_ceil(elCount, 6);
      numFrames = VCP_normalCeil(frameLen, 64 * symr);
    } /* end if Hard decisions */
    else if ((decision == VCP_DECISION_HARD) && !(traceBack == VCP_TRACEBACK_TAILED)){
      edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                       EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_NONE,
                       EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_INC,
                       EDMA_OPT_TCINT_NO,             EDMA_OPT_TCC_DEFAULT,
                       EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_NO,
                       EDMA_OPT_ATCC_DEFAULT,         EDMA_OPT_PDTS_DISABLE,
                       EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                       EDMA_OPT_FS_YES);
      if (64 * symr < frameLen) elCount = 64 * symr;
      else elCount = frameLen;
      elCount = 2 * VCP_ceil(elCount, 6);
      numFrames = VCP_normalCeil(frameLen, 64 * symr);
    } /* end if Hard decisions */
    else if (traceBack == VCP_TRACEBACK_TAILED) { /* Soft Dec and Tailed TB */
      edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                       EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_NONE,
                       EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_DEC,
                       EDMA_OPT_TCINT_NO,             EDMA_OPT_TCC_DEFAULT,
                       EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_NO,
                       EDMA_OPT_ATCC_DEFAULT,         EDMA_OPT_PDTS_DISABLE,
                       EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                       EDMA_OPT_FS_YES);
      if (symr < frameLen) elCount = 4 * symr;
      else elCount = frameLen;
      elCount = 2 * VCP_ceil(elCount, 2);
      numFrames = VCP_normalCeil(frameLen, 4 * symr);
    } /* end if Soft decisions and tailed traceback mode */
    else { /* Soft Dec and either convergent or mixed traceback */
      edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                       EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_NONE,
                       EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_INC,
                       EDMA_OPT_TCINT_NO,             EDMA_OPT_TCC_DEFAULT,
                       EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_NO,
                       EDMA_OPT_ATCC_DEFAULT,         EDMA_OPT_PDTS_DISABLE,
                       EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                       EDMA_OPT_FS_YES);
      elCount = 2 * symr;
      numFrames = VCP_normalCeil(frameLen, 4 * symr);
    } /* end else if Soft decisions and convergent or mixed traceback */
    *numDec = numFrames * elCount;
    *decisions = MEM_alloc(ISRAM, *numDec * sizeof(Uint32), 2 * sizeof(Uint32));
    decAddr = *decisions;
    if (traceBack == VCP_TRACEBACK_TAILED){
      decAddr = &decAddr[*numDec - 1];
      if((decision == VCP_DECISION_HARD) && (frameLen > 1024)) { 
        *decisions = decAddr - ((VCP_ceil(frameLen, 6)) << 1) + 1;
      } /* end if VCP_DECISION_HARD */
      else if ((decision == VCP_DECISION_SOFT) && (frameLen > 64)) {
        *decisions = decAddr - ((VCP_ceil(frameLen, 2)) << 1) + 1;
      } /* end if VCP_DECISION_SOFT */
    } /* end if VCP_TRACEBACK_TAILED) */
    
    edmaConfig.src = (Uint32)VCP_HDMEM_ADDR;
    edmaConfig.cnt = EDMA_CNT_RMK(numFrames - 1, elCount);
    edmaConfig.dst = (Uint32)decAddr;
    EDMA_config(hEdmaRevt, &edmaConfig);
    EDMA_link(hEdmaRevt, hEdmaOutPar);

    /* Configure channel parameters for VCP output parameters */
    *outParms = MEM_alloc(ISRAM, VCP_NUM_OP * sizeof(Uint32), 2 * sizeof(Uint32));
    edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                     EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_INC,
                     EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_INC,
                     EDMA_OPT_TCINT_YES,            EDMA_OPT_TCC_OF(tcc),
                     EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_NO,
                     EDMA_OPT_ATCC_DEFAULT,         EDMA_OPT_PDTS_DISABLE,
                     EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                     EDMA_OPT_FS_YES);
    edmaConfig.src = (Uint32)VCP_OPMEM_ADDR;
    edmaConfig.cnt = (Uint32)VCP_NUM_OP;
    edmaConfig.dst = (Uint32)*outParms;
    EDMA_config(hEdmaOutPar, &edmaConfig);
    EDMA_link(hEdmaOutPar, hEdmaNull);

    /* Enable the TCC to generate a CPU interrupt */
    EDMA_intEnable(tcc);
    
    /* Enable the transmit and receive channels */
    EDMA_enableChannel(hEdmaRevt);
    EDMA_enableChannel(hEdmaXevt);

} /* end submitEdma() */