pasrc/test_dsp/io/test/frame_work.c

   1
   2 #include <stdio.h>
   3 #include <xdc/runtime/Error.h>
   4 #include "../io/ioPhy.h"
   5 #include "../io/ioBuff.h"
   6 #include "frame_work.h"
   7 #include <ti/sysbios/io/IOM.h>  // for definition of Ptr
   8 #include "audioStreamProc_common.h"
   9 #include "mcasp_cfg.h"
  10 #include "ioConfig.h"
  11
  12 #ifdef IO_LOOPBACK_TEST
  13
  14 fwInst_t fwInst;
  15
  16 /* Handle to heap object */
  17 //extern HeapMem_Handle heapHandle;
  18 //extern HeapMem_Handle HEAP_EXTERNAL;
  19 extern HeapMem_Handle heapMemDdr3;
  20 extern HeapMem_Handle heapMemL2Sram;
  21
  22 /* McASP channel handles */
  23 extern Ptr hMcaspTxChan;
  24 extern Ptr hMcaspRxChan;
  25
  26 Ptr databuf[NUM_BUFS];
  27
  28 extern Int PAF_ASIT_ioCompCreate(PAF_AST_IoInp *pIoInp, int numInp, IHeap_Handle iHeapHandle);
  29 extern Int PAF_ASOT_ioCompCreate(PAF_AST_IoOut *pIoOut, int numOut, IHeap_Handle iHeapHandle);
  30
  31 void ioCompsCreate()
  32 {
  33     int errLineNum;
  34     IHeap_Handle iheap;
  35
  36     iheap = HeapMem_Handle_to_xdc_runtime_IHeap(heapMemDdr3);
  37
  38     /* I/O components memory for input - only 1 input for standalone test */
  39     errLineNum = PAF_ASIT_ioCompCreate(&fwInst.ioInp, 1, iheap);
  40     if(errLineNum)
  41     {
  42         printf("Memory allocation fails for input I/O components!\n");
  43         exit(0);
  44     }
  45
  46     /* I/O components memory for output  - only 1 output for standalone test  */
  47     errLineNum = PAF_ASOT_ioCompCreate(&fwInst.ioOut, 1, iheap);
  48     if(errLineNum)
  49     {
  50         printf("Memory allocation fails for output I/O components!\n");
  51         exit(0);
  52     }
  53 }
  54
  55 extern Ptr txBuf[NUM_BUFS];
  56 extern Ptr rxBuf[NUM_BUFS];
  57 extern Ptr procBuf;
  58
  59 void ioBuffersCreate(void)
  60 {
  61     Error_Block  eb;
  62     uint32_t     count = 0;
  63     IHeap_Handle iheap;
  64     void *io_mempool_in;
  65     void *io_mempool_out;
  66
  67     iheap = HeapMem_Handle_to_xdc_runtime_IHeap(heapMemDdr3);
  68     Error_init(&eb);
  69
  70 #ifdef USE_IO_COMPONENTS
  71     /* Allocate memory for audio input memory pool                          */
  72     io_mempool_in = Memory_calloc(iheap, INPUT_BUFF_SIZE, BUFALIGN, &eb);
  73     if(NULL == io_mempool_in){
  74       System_printf("\r\nMEM_calloc for io_mempool_in failed.\n");
  75       exit(0);
  76     }
  77     fwInst.iomem_pool_input_base = io_mempool_in;
  78     fwInst.iomem_pool_input_size = INPUT_BUFF_SIZE;
  79
  80     /* Allocate buffers for audio data processing                           */
  81     for(count = 0; count < (NUM_BUFS); count ++)
  82     {
  83         databuf[count] = Memory_calloc(iheap, INPUT_FRAME_SIZE_PCM * 4,
  84                                        BUFALIGN, &eb);
  85         if(NULL == databuf[count]) {
  86             System_printf("\r\nMEM_calloc failed.\n");
  87             exit(0);
  88         }
  89     }
  90
  91     /* Allocate memory for audio output memory pool                          */
  92     io_mempool_out = Memory_calloc(iheap, OUTPUT_BUFF_SIZE, BUFALIGN, &eb);
  93     if(NULL == io_mempool_out){
  94       System_printf("\r\nMEM_calloc for io_mempool_out failed.\n");
  95       exit(0);
  96     }
  97     fwInst.iomem_pool_output_base = io_mempool_out;
  98     fwInst.iomem_pool_output_size = OUTPUT_BUFF_SIZE;
  99
 100 #else
 101     /* Allocate buffers for the McASP data exchanges */
 102     for(count = 0; count < NUM_BUFS; count++)
 103     {
 104         rxBuf[count] = Memory_calloc(iheap, INPUT_FRAME_SIZE_PCM,
 105                                      BUFALIGN, &eb);
 106         if(NULL == rxBuf[count])
 107         {
 108             IFPRINT(platform_write("\r\nMEM_calloc failed for Rx\n"));
 109         }
 110     }
 111
 112     /* Allocate buffers for the McASP data exchanges */
 113     for(count = 0; count < NUM_BUFS; count++)
 114     {
 115         txBuf[count] = Memory_calloc(iheap, INPUT_FRAME_SIZE_PCM,
 116                                      BUFALIGN, &eb);
 117         if(NULL == txBuf[count])
 118         {
 119             IFPRINT(platform_write("\r\nMEM_calloc failed for Tx\n"));
 120         }
 121     }
 122
 123     procBuf = Memory_calloc(iheap, INPUT_FRAME_SIZE_PCM, BUFALIGN, &eb);
 124 #endif
 125
 126 } /* ioBuffersCreate */
 127
 128 void audioIoCreate(void)
 129 {
 130 #ifdef USE_IO_COMPONENTS
 131     ioCompsCreate();
 132 #endif
 133
 134     ioBuffersCreate();
 135 }
 136
 137 extern const MdUns iecFrameLength[23];
 138
 139 void ioCompsInitInput()
 140 {
 141     ioDataParam_t  ioDataCfg;
 142     ioBuffParams_t ioBuffParams;
 143     ioPhyParams_t  ioPhyParams;
 144
 145     ioBuffParams.base         = fwInst.iomem_pool_input_base;
 146     ioBuffParams.size         = fwInst.iomem_pool_input_size;
 147     ioBuffParams.sync         = IOBUFF_WRITE_SYNC;
 148     ioBuffParams.nominalDelay = INPUT_FRAME_SIZE_DEF*NUM_DELAY_BUFS_INPUT;
 149     if(ioBuffInit(fwInst.ioInp.hIoBuff, &ioBuffParams) != IOBUFF_NOERR) {
 150       printf("Input ioBuffInit error!\n");
 151       exit(0);
 152     }
 153
 154     ioPhyParams.ioBuffHandle    = fwInst.ioInp.hIoBuff;
 155 #ifdef INPUT_PCM_ONLY
 156     ioPhyParams.xferFrameSize   = INPUT_FRAME_SIZE_PCM;
 157 #else
 158     ioPhyParams.xferFrameSize   = INPUT_FRAME_SIZE_DEF;
 159 #endif
 160     ioPhyParams.mcaspChanHandle = hMcaspRxChan;
 161     ioPhyParams.ioBuffOp        = IOPHY_IOBUFFOP_WRITE;
 162     if(ioPhyInit(fwInst.ioInp.hIoPhy, &ioPhyParams) != IOPHY_NOERR) {
 163       printf("Input ioPhyInit error!\n");
 164       exit(0);
 165     }
 166
 167     ioDataCfg.ioBuffHandle         = fwInst.ioInp.hIoBuff;
 168     ioDataCfg.unknownSourceTimeOut = 30720; //30720;
 169     ioDataCfg.frameLengthsIEC      = (uint_least16_t *)&iecFrameLength[0];
 170     ioDataCfg.frameLengthPCM       = INPUT_FRAME_SIZE_PCM / WORD_SIZE_PCM;
 171     ioDataCfg.frameLengthDef       = INPUT_FRAME_SIZE_DEF / WORD_SIZE_BITSTREAM;
 172     ioDataCfg.ibMode               = 0;
 173     ioDataCfg.zeroRunRestart       = 300;
 174     ioDataCfg.zeroRunTrigger       = 20;
 175
 176     if(ioDataInit(fwInst.ioInp.hIoData, &ioDataCfg) != IODATA_NO_ERR) {
 177         printf("Input ioDataInit error!\n");
 178         exit(0);
 179     }
 180
 181 } /* ioCompsInitInput */
 182
 183 void ioCompsInitOutput()
 184 {
 185     ioBuffParams_t ioBuffParams;
 186     ioPhyParams_t  ioPhyParams;
 187
 188     ioBuffParams.base         = fwInst.iomem_pool_output_base;
 189     ioBuffParams.size         = fwInst.iomem_pool_output_size;
 190     ioBuffParams.sync         = IOBUff_READ_SYNC;
 191     ioBuffParams.nominalDelay = OUTPUT_FRAME_SIZE*NUM_DELAY_BUFS_OUTPUT;
 192     if(ioBuffInit(fwInst.ioOut.hIoBuff, &ioBuffParams) != IOBUFF_NOERR) {
 193       printf("Output ioBuffInit error!\n");
 194       exit(0);
 195     }
 196
 197     ioPhyParams.ioBuffHandle    = fwInst.ioOut.hIoBuff;
 198     ioPhyParams.xferFrameSize   = OUTPUT_FRAME_SIZE;
 199     ioPhyParams.mcaspChanHandle = hMcaspTxChan;
 200     ioPhyParams.ioBuffOp        = IOPHY_IOBUFFOP_READ;
 201     if(ioPhyInit(fwInst.ioOut.hIoPhy, &ioPhyParams) != IOPHY_NOERR) {
 202       printf("Output ioPhyInit error!\n");
 203       exit(0);
 204     }
 205 } /* ioCompsInitOutput */
 206
 207
 208 #endif //#ifdef IO_LOOPBACK_TEST
 209