* values are correct then a 0 is returned.                                 *
\****************************************************************************/
Int32
checkResults(Uint32 *actual ,Uint32 *reference, Uint32 size, 
        Uint32 nbValidBitsInLastWord) 
{
Uint32 i;
Uint32 mismatch=0;
Uint32 lastActualWord = actual[size-1];
Uint32 lastRefWord = reference[size-1];
    
    /* Directly compare received values to reference values for 32 valid    */
    /* bits.                                                                */
    for (i=0; i<size-1; i++) {
      if (actual[i]!=reference[i]) {
        mismatch++;
        break;
      } /* end if actual != reference */
    } /* end for i */
    
    /* Compare received values to reference values on a bit-by-bit basis    */
    /* for the last decision values, if < 32.                               */
    if (!mismatch) {    
      for (i=0; i<nbValidBitsInLastWord; i++) {
        if (((lastActualWord>>i)& 0x1) != ((lastRefWord>>i)&0x1)) {
          mismatch++;
          i=size-1;
          break;
        } /* end if */
      } /* end for i */
    } /* end if !mismatch */

    if (mismatch)
      return(i+1);  /* return index for 1st error that occured. */
                    /* Index will range from 1 to framelength   */
    else return(0); /* No error */

} /* end checkResults() */


/****************************************************************************\
 * edmaIsr: EDMA interrupt service routine. The tcpDone flag is set to one  *
 * and all EDMA handles are closed, freeing them for use on the next        *
 * iteration.                                                               *
\****************************************************************************/
interrupt void
edmaIsr(void)  
{ 
    tcpDone = EDMA_intTest(tcc); /* Set TCP completion flag                 */
    EDMA_intClear(tcc);          /* Clear the interrupt in the CIPR         */
    EDMA_intDisable(tcc);        /* Disable the interrupt in the CIER       */
    EDMA_intFree(tcc);           /* Free the TCC value to the system        */
    EDMA_intClear(tccApriori);   /* Clear the interrupt in the CIPR         */
    EDMA_intFree(tccApriori);    /* Free the TCC value to the system        */
    EDMA_close(hEdmaRevt);       /* Close the extrinsics data EDMA channel  */
    EDMA_close(hEdmaXevt);       /* Close the IC values EDMA channel        */
    EDMA_disableChaining(hEdmaApriori); /* Disable chaining for Apriori Ch  */
    EDMA_close(hEdmaApriori);    /* Close the apriori data EDMA channel     */
    EDMA_freeTable(hEdmaSysPar); /* Close the systematics and parities EDMA */
                                 /*   channel                               */
    EDMA_freeTable(hEdmaNull);   /* Close the NULL EDMA channel             */

} /* 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(TCP_UserData *userData, TCP_UserData *xabData,
        TCP_Params *tcpParameters, Uint16 *interleaverTable,
        TCP_ExtrinsicData *extrinsics, TCP_ExtrinsicData *apriori,
        Uint32 numSubFrame)
{
EDMA_Config edmaConfig;
TCP_ConfigIc *configIc;
Uint16 index;
int useApriori = 0;
Uint32 prologSize = tcpParameters->prologSize;

    if (tcpParameters->map) useApriori = 1;
    
    /* Completely reset the EDMA */
    EDMA_resetAll();
    
    /* Configure CPU interrupts */
    intConfig();
    
    /* Calculate the TCP IC values */
    configIc = (TCP_ConfigIc *)memalign(2 * sizeof(Uint32),
               NB_32BITWORD_INPUT_PARAMS * sizeof(Uint32));
    TCP_genIc(tcpParameters, xabData, configIc);
      
    /* Open handles to the EDMA channels */
    hEdmaRevt    = EDMA_open(EDMA_CHA_TCPREVT, EDMA_OPEN_RESET);
    hEdmaXevt    = EDMA_open(EDMA_CHA_TCPXEVT, EDMA_OPEN_RESET);
    
    if (useApriori){
      tccApriori = EDMA_intAlloc(-1);
      hEdmaApriori = EDMA_open(tccApriori,  EDMA_OPEN_RESET);
    } /* end if useApriori */
    
    EDMA_allocTableEx(1, &hEdmaSysPar);
    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)NB_32BITWORD_INPUT_PARAMS;
    edmaConfig.dst = (Uint32)TCP_ICMEM_ADDR;
    edmaConfig.idx = 0;
    edmaConfig.rld = 0;
    EDMA_config(hEdmaXevt, &edmaConfig);
    EDMA_link(hEdmaXevt, hEdmaSysPar);
        
    /* Configure channel parameters for TCP apriori data */
    if (useApriori) {
      edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                       EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_IDX,
                       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)(apriori) - prologSize;
      edmaConfig.cnt = EDMA_CNT_RMK(numSubFrame - 1, tcpParameters->numApriori);
      edmaConfig.dst = (Uint32)TCP_APMEM_ADDR;
      index = tcpParameters->subFrameLen - 2 * prologSize;
      edmaConfig.idx = EDMA_IDX_RMK(index, 4);
      EDMA_config(hEdmaApriori, &edmaConfig);
      EDMA_link(hEdmaApriori, hEdmaNull);
    } /* end if useApriori */
    
    /* Configure channel parameters for sys and parity data */
    if (useApriori) {
      edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                       EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_IDX,
                       EDMA_OPT_2DD_NO,               EDMA_OPT_DUM_NONE,
                       EDMA_OPT_TCINT_YES,            EDMA_OPT_TCC_OF(tccApriori),
                       EDMA_OPT_TCCM_DEFAULT,         EDMA_OPT_ATCINT_YES,
                       EDMA_OPT_ATCC_OF(tccApriori),  EDMA_OPT_PDTS_DISABLE,
                       EDMA_OPT_PDTD_DISABLE,         EDMA_OPT_LINK_YES,
                       EDMA_OPT_FS_YES);
    } /* end if useApriori */
    else {
      edmaConfig.opt = EDMA_OPT_RMK(EDMA_OPT_PRI_LOW, EDMA_OPT_ESIZE_32BIT,
                       EDMA_OPT_2DS_NO,               EDMA_OPT_SUM_IDX,
                       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);
    } /* end else if !useApriori */
    
    edmaConfig.cnt = EDMA_CNT_RMK(numSubFrame - 1, tcpParameters->numSysPar);
    edmaConfig.dst = (Uint32)TCP_SPMEM_ADDR;
    if (tcpParameters->rate == TCP_RATE_1_4) {
      edmaConfig.src = (Uint32)(userData) - ((5 * prologSize) >> 1);
      index = (20 * (tcpParameters->subFrameLen - 2 * \
                     tcpParameters->prologSize)) >> 3;
    } /* end if rate = 1/4 */
    else {
      edmaConfig.src = (Uint32)(userData) - 2 * prologSize;
      index = 2 * (tcpParameters->subFrameLen - 2 * tcpParameters->prologSize);
    } /* end else if rate = 1/2 or 1/3 */
    edmaConfig.idx = EDMA_IDX_RMK(index, 4);
    EDMA_config(hEdmaSysPar, &edmaConfig);
    EDMA_link(hEdmaSysPar, hEdmaNull);

    /* Configure channel parameters for extrinsics data */
    tcc = EDMA_intAlloc(-1);

    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_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)TCP_EXMEM_ADDR;
    edmaConfig.cnt = EDMA_CNT_RMK(numSubFrame - 1, tcpParameters->numExt);
    edmaConfig.dst = (Uint32)extrinsics;
    edmaConfig.idx = 0;
    EDMA_config(hEdmaRevt, &edmaConfig);
    EDMA_link(hEdmaRevt, hEdmaNull);

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

} /* end submitEdma() */


/******************************************************************************\
* End of main.c
\******************************************************************************/