Update DDP,MAT-THD,and OAR submodules, update for PASDK-215 (Harmony 1.3)
[processor-sdk/performance-audio-sr.git] / pasdk / test_dsp / sap / sap.c
2 /*
3 Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
4 All rights reserved.
6 * Redistribution and use in source and binary forms, with or without 
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the
16 * distribution.
17 *
18 * Neither the name of Texas Instruments Incorporated nor the names of
19 * its contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 */
36 //
37 //
38 // SIO driver implementation for audio I/O using McASP.
39 //
40 //
41 //
43 #ifndef SAP_CACHE_SUPPORT
44   // if you rebuild dap.c in your project without this defined, 
45   // the result is quite hard to find:  Occasional glitches in the sound.
46   #define SAP_CACHE_SUPPORT  // typically defined in the project
47 #endif
49 #ifdef SAP_CACHE_SUPPORT
50 #include <ti/sysbios/hal/Cache.h>
51 #endif
53 #include <stdlib.h>
54 #include <stdio.h>
55 #include <string.h> //memset
57 #include <xdc/std.h>
59 #include "sap.h"
61 #include <ti/sdo/edma3/drv/edma3_drv.h>
62 #include <ti/sdo/edma3/drv/src/edma3.h>
63 #include <ti/sdo/edma3/rm/edma3_rm.h>
64 #include <ti/sdo/edma3/drv/sample/bios6_edma3_drv_sample.h>
66 #include <ti/csl/cslr_device.h>
68 #define EDMA_HINV NULL
70 #ifdef SAP_PORT_MCASP
71 #include "sap_mcasp.h"
72 #else
73 #error "No port defined"
74 #endif
76 #include <pafsio.h>
78 // This works to set a breakpoint
79 #define SW_BREAKPOINT       asm( " SWBP 0" );
80 /* Software Breakpoint to Code Composer */
81 // SW_BREAKPOINT;
83 // global allocated in bios_edma3_drv_sample_init.c
84 extern EDMA3_DRV_Handle hEdma0;
85 extern EDMA3_DRV_Handle hEdma1;
87 int gStartError;
88 int gIsrCnt;
89 int gIsrElseCnt;
90 int gIsrErrCnt;
91 int gIsrRunCnt;
92 int gIsrNotRunCnt;
93 int gisrOutput;
95 typedef xdc_Short MdInt;
97 void swapHdmi(Ptr, int);
99 #define TEST_MULTICHANNEL
102 #ifdef TEST_MULTICHANNEL
103 #define SAP_UNDER_LEN 4
104 //#define SAP_UNDER_LEN 1024 // GJ: experiment
105 #else
106 #define SAP_UNDER_LEN 1024
107 #endif
108 int sap_UNDER[SAP_UNDER_LEN]; // used for underrun
109 int sap_OVER = 0;     // used for overrun
110 void DJDBG_SAP_EDMA_dumpParams(int tag_place)
112         unsigned int *ptrPARAM_BASE = (unsigned int *)0x02704000;
113         unsigned int *ptrPARAM0x18 = (unsigned int *)0x02704300; // ((*((EDMA3_CCRL_Regs *) 0x02700000)).PARAMENTRY)[24]
114         unsigned int *ptrPARAM0x19 = (unsigned int *)0x02704320; // ((*((EDMA3_CCRL_Regs *) 0x02700000)).PARAMENTRY)[24]
116         Log_info5("PARAM0x18a(%d): 0x%x 0x%x 0x%x 0x%x", tag_place, ptrPARAM0x18[0], ptrPARAM0x18[1], ptrPARAM0x18[2], ptrPARAM0x18[3]);
117         Log_info5("PARAM0x18b(%d): 0x%x 0x%x 0x%x 0x%x", tag_place, ptrPARAM0x18[4], ptrPARAM0x18[5], ptrPARAM0x18[6], ptrPARAM0x18[7]);
119         Log_info5("PARAM0x19a(%d): 0x%x 0x%x 0x%x 0x%x", tag_place, ptrPARAM0x19[0], ptrPARAM0x19[1], ptrPARAM0x19[2], ptrPARAM0x19[3]);
120         Log_info5("PARAM0x19b(%d): 0x%x 0x%x 0x%x 0x%x", tag_place, ptrPARAM0x19[4], ptrPARAM0x19[5], ptrPARAM0x19[6], ptrPARAM0x19[7]);
121     //Log_info1("TCC0: ERR reg %x", *((unsigned int *)0x02760120)); //DJDBG
123 // .............................................................................
124 // notes:
125 //  . add control function to PORT table
126 //  . how to handle DMA/PORT specifics in parameter entries
127 //      can assume numSers = numChans is general and can be applied by DMA
128 //      same for wordSize?
129 //  . why are two idle stages needed (seems like 1 is enough)?
131 // .............................................................................
132 // only one global variable, not static so that DMA and port functions
133 // can access. We cant just store the address in devExt since the ISR has
134 // no context.
136 SAP_DriverObject sapDrv;
138 // needed since SAP_watchDog is called before SAP_init
139 Int SAP_initialized = 0;
141 //Int  SAP_close(DEV2_Handle);
142 Int  SAP_ctrl(DEV2_Handle, Uns, Arg);
143 Int  SAP_idle(DEV2_Handle, Bool);
144 Int  SAP_issue(DEV2_Handle);
145 Int  SAP_open(DEV2_Handle, String);
146 void SAP_isrCallback (Uint32 tcc, EDMA3_RM_TccStatus status, Ptr context);
147 //Bool SAP_ready(DEV2_Handle, SEM_Handle);
148 Int  SAP_reclaim(DEV2_Handle);
149 Int  SAP_shutdown(DEV2_Handle);
150 Int  SAP_start(DEV2_Handle);
151 Int  SAP_config(DEV2_Handle device, const SAP_Params *pParams);
152 Int  SAP_EDMA_setupParam (DEV2_Handle device, XDAS_UInt32 targetEdma, XDAS_UInt32 childEdma, unsigned int addr, unsigned int size);
153 Int  SAP_EDMA_setupXfer (DEV2_Handle device, XDAS_UInt32 targetEdma, XDAS_UInt32 parentEdma, XDAS_UInt32 childEdma, DEV2_Frame *pFrame);
155 // .............................................................................
157 // .............................................................................
159 SAP_DMA_Fxns SAP_EDMA_FXNS =
161         SAP_EDMA_setupParam,
162         SAP_EDMA_setupXfer,
163 };
166 SAP_Fxns SAP_FXNS =
168     NULL, //SAP_close, -- remove for IROM since not using
169     SAP_ctrl,
170     SAP_idle,
171     SAP_issue,
172     SAP_open,
173     NULL, //SAP_ready, -- remove for IROM since not using
174     SAP_reclaim,
175     SAP_shutdown,
176     SAP_start,
177     SAP_config,
179 #ifdef SAP_PORT_MCASP
180     (SAP_PORT_Fxns *) &SAP_MCASP_FXNS,
181 #endif
182 #ifdef SAP_DMA_EDMA
183     (SAP_DMA_Fxns *) &SAP_EDMA_FXNS,
184 #endif
185 };
187 // -----------------------------------------------------------------------------
188 // This function is not in the driver function table.
189 // Must be pointed at in GUI config tool.
190 //
191 Void SAP_init (Void)
193     DEV2_Device  *entry;
194     SAP_Fxns    *pFxns;
196     //TRACE_GEN((&TR_MOD, "SAP_init.%d", __LINE__));
198     // find function table pointer (used by SAP_XX_FTABLE_init macros)
199     DEV2_match(SAP_NAME, &entry);
200     if (entry == NULL) {
201         Log_error1 ("SAP", SIO2_ENODEV);
202         return;
203     }
204     pFxns = (SAP_Fxns *) entry->fxns;
206     //SAP_DMA_FTABLE_init ();
207     SAP_PORT_FTABLE_init ();
209     sapDrv.numDevices = 0;
210     SAP_initialized = 1;
212     return;
213 } // SAP_init
215 // -----------------------------------------------------------------------------
217 Int SAP_ctrl (DEV2_Handle device, Uns code, Arg arg)
219     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)device->object;
220     const SAP_Params *pParams;
221     Int result = SIO2_OK;
222     EDMA3_DRV_Handle    hEdma;
223     //TRACE_GEN((&TR_MOD, "SAP_ctrl.%d (0x%x) code = 0x%x", __LINE__, device, code));
225     switch (code) {
227 /* .......................................................................... */
229         case PAF_SIO_CONTROL_MUTE:
230         case PAF_SIO_CONTROL_UNMUTE:
231             pParams = pDevExt->pParams;
232             if (pParams == NULL)
233                 return SIO2_OK;
235             if (pParams->sio.control != NULL)
236                 result = pParams->sio.control (device, (const PAF_SIO_Params *)pParams, code, arg);
237             break;
239 /* .......................................................................... */
241         case PAF_SIO_CONTROL_OPEN:
242             if (pDevExt->runState)
243                 return SIO2_EBUSY;
245             if (!( pParams = (const SAP_Params *) arg ))
246                 return SIO2_OK;
248             if (result = SAP_FTABLE_config (device, pParams))
249                 return result;
251             if (pParams->sio.control && (result = pParams->sio.control (device, (const PAF_SIO_Params *)pParams, code, arg)))
252                 return result;
254             break;
256 /* .......................................................................... */
258         case PAF_SIO_CONTROL_CLOSE:
259             if (pDevExt->runState)
260                 return SIO2_EBUSY;
262             if (pDevExt->pParams == NULL)
263                                 return SIO2_EINVAL;
265             pParams = pDevExt->pParams;
267                         if (pParams->sio.moduleNum == 0)
268                                 hEdma = hEdma0;
269                         else if (pParams->sio.moduleNum == 1 || pParams->sio.moduleNum == 2)
270                                 hEdma = hEdma1;
271             if (pDevExt->activeEdma != EDMA_HINV) {
272                                 EDMA3_DRV_freeChannel (hEdma, pDevExt->activeEdma);
273                             pDevExt->activeEdma = EDMA_HINV;
274                         }
276             if (!(pParams = pDevExt->pParams))
277                 return SIO2_OK;
279             if (pParams->sio.control && (result = pParams->sio.control (device, (const PAF_SIO_Params *)pParams, code, arg)))
280                 return result;
282             result = SAP_PORT_FTABLE_close (device);
283             if (result)
284                 return result;
286             pDevExt->pParams = NULL;
287             break;
289 /* .......................................................................... */
291         case PAF_SIO_CONTROL_GET_WORDSIZE:
292                 if (!arg)
293                                 return SIO2_EINVAL;
294                         *((int *) arg) = pDevExt->edmaWordSize;
295             break;
297         case PAF_SIO_CONTROL_SET_WORDSIZE:
298             // defer to DMA processing
299                 // currently only supported for input
300                         if (device->mode != DEV2_INPUT)
301                                 return SIO2_EINVAL;
303                         // can't be running
304                         if (pDevExt->runState)
305                                 return SIO2_EBUSY;
307                         // driver only supports 2 or 4 bytes
308                    if ((arg != 2) && (arg != 4))
309                                 return SIO2_EINVAL;
311                         // return success for unconfigured devices?
312                         if (!pDevExt->pParams)
313                                 return SIO2_OK;
315                         // ask platform if size is supported
316                         pParams = pDevExt->pParams;
317                         if (pDevExt->pParams->sio.control && (result = pDevExt->pParams->sio.control (device, (const PAF_SIO_Params *)pParams, code, arg)))
318                                 return result;
320                         pDevExt->edmaWordSize = arg;
321                         break;
323         case PAF_SIO_CONTROL_GET_PRECISION:
324             if (arg == 0)
325                 return SIO2_EINVAL;
327             pParams = pDevExt->pParams;
328             if (pParams == NULL)
329                 return( SIO2_EINVAL );
331             *((int *) arg) = pParams->sio.precision;
332             break;
334         case PAF_SIO_CONTROL_GET_NUMCHANNELS:
335             if (arg == 0)
336                 return SIO2_EINVAL;
338             *((int *) arg) = pDevExt->numSlots * pDevExt->numSers;
339             break;
341         case PAF_SIO_CONTROL_SET_RATEX:
342             pParams = pDevExt->pParams;
343             if (pParams == NULL)
344                 return SIO2_OK ;
346             if (pParams->sio.control == NULL)
347                 return SIO2_EINVAL;
349             result = pParams->sio.control( device, (const PAF_SIO_Params *)pParams, PAF_SIO_CONTROL_SET_RATEX, arg);
350             break;
352 /* .......................................................................... */
354         case PAF_SIO_CONTROL_IDLE:
355             pParams = pDevExt->pParams;
356             if (pParams == NULL)
357                 return SIO2_OK ;
359             if (pParams->sio.control == NULL)
360                 return SIO2_EINVAL;
362             result = pParams->sio.control( device, (const PAF_SIO_Params *)pParams, PAF_SIO_CONTROL_IDLE, arg);
363             break;
365         case PAF_SIO_CONTROL_IDLE_WITH_CLOCKS:
366             // 1. Here we are intentionally not using SIO_Idle() and
367             //    leaving the Tx clock running. We need this to avoid DAC noise,
368             //    as well as provide a DIT clock when using digital output.
369             if (device->mode != DEV2_OUTPUT || pDevExt->pParams == NULL)
370                 return SIO2_EINVAL;
372             pParams = pDevExt->pParams;
374             if (pParams->sio.moduleNum == 0)
375                 hEdma = hEdma0;
376             else if (pParams->sio.moduleNum == 1 || pParams->sio.moduleNum == 2)
377                                 hEdma = hEdma1;
379             result = SAP_FTABLE_shutdown (device);
380             if (result)
381                 return result;
383             Log_info0 ("SAP PAF_SIO_CONTROL_IDLE_WITH_CLOCKS; PAF_SIO_ERROR_IDLE_STAGE1");
384             pDevExt->errorState = PAF_SIO_ERROR_IDLE_STAGE1;
386 #if 1
387             //DJDBG, if below enableTransfer() is commented, input side continuous working.
388      if (pDevExt->activeEdma != EDMA_HINV) {
389                 //EDMA3_DRV_disableTransfer (hEdma0, pDevExt->activeEdma, EDMA3_DRV_TRIG_MODE_EVENT);
390             //if(*((unsigned int *)0x02701000) & 0x01000000) *((unsigned int *)0x02701008) = 0x01000000; //Clear pending even in bit 24! //DJDBG
391             EDMA3_DRV_enableTransfer (hEdma, pDevExt->activeEdma, EDMA3_DRV_TRIG_MODE_EVENT);
392      }
393 #endif
394             //TRACE_GEN((&TR_MOD, "SAP_ctrl.%d: (0x%x) errorState = PAF_SIO_ERROR_IDLE_STAGE1 0x%x.", __LINE__, device, PAF_SIO_ERROR_IDLE_STAGE1));
396             break;
398 /* .......................................................................... */
400         case PAF_SIO_CONTROL_GET_INPUT_STATUS:
401             // needs to be attached
402             pParams = pDevExt->pParams;
403             if (pParams == NULL)
404                 return SIO2_OK;
406             if (pParams->sio.control == NULL)
407                 return SIO2_EINVAL;
409             result = pParams->sio.control( device, (const PAF_SIO_Params *)pParams, code, arg );
410             break;
412         case PAF_SIO_CONTROL_WATCHDOG:
413             pParams = pDevExt->pParams;
414             if (pParams == NULL)
415                 return SIO2_OK;
416             if (pParams->sio.control && (result = pParams->sio.control (device, (const PAF_SIO_Params *)pParams, code, arg)))
417                 return result;
418             break;
419             
420 /* .......................................................................... */
422         // Timing stats specific to DMA engine
423         case PAF_SIO_CONTROL_ENABLE_STATS:
424         case PAF_SIO_CONTROL_DISABLE_STATS:
425         case PAF_SIO_CONTROL_GET_STATS:
426         case PAF_SIO_CONTROL_GET_NUM_EVENTS:
427         case PAF_SIO_CONTROL_GET_NUM_REMAINING:
428             //result = SAP_DMA_FTABLE_ctrl (device, code, arg);
429             // TRACE_VERBOSE((&TR_MOD, "SAP_ctrl: (0x%x) code 0x%x.  result 0x%x.", device, code, result));
430             break;
432 /* .......................................................................... */
434         case PAF_SIO_CONTROL_SET_DITSTATUS:
435             if(device->mode == DEV2_OUTPUT)
436             {
437                 const SAP_Params *pParams = pDevExt->pParams;
438                 MCASP_Handle hPort = sapMcaspDrv.hPort[pParams->sio.moduleNum];
439                 volatile Uint32 *base = (volatile Uint32 *)(hPort->baseAddr);
440                 MCASP_ConfigXmt *pTxConfig = (MCASP_ConfigXmt *)pParams->sio.pConfig;
441                 int encSelect = *((int *) arg);
443                 // HACK -- determine DIT need by FXWID
444                 if (((pTxConfig->afsxctl & _MCASP_AFSXCTL_FXWID_MASK)>> _MCASP_AFSXCTL_FXWID_SHIFT) == MCASP_AFSXCTL_FXWID_BIT)
445                 {
446                     if ( (encSelect == 0x13) ||
447                          (encSelect == 0xa)  || 
448                          (encSelect == 0x6)) // DTE, DDE, MPE 
449                     {
450                         base[_MCASP_DITCSRA0_OFFSET] |= 2;
451                         base[_MCASP_DITCSRB0_OFFSET] |= 2;
452                     }
453                     else
454                     {
455                         base[_MCASP_DITCSRA0_OFFSET] &= 0xfffffffd;
456                         base[_MCASP_DITCSRB0_OFFSET] &= 0xfffffffd;
457                     }
458                 }
460                 pParams = pDevExt->pParams;
461                 if (pParams == NULL)
462                     return SIO2_OK;
464                 if (pParams->sio.control != NULL)
465                     result = pParams->sio.control (device, (const PAF_SIO_Params *)pParams, code, arg);
466             }
467             break;
469 /* .......................................................................... */
471     }
473     return result;
474 } // SAP_ctrl
476 // -----------------------------------------------------------------------------
478 Int SAP_idle (DEV2_Handle device, Bool flush)
480     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)device->object;
481     Int result = SIO2_OK;
482     EDMA3_DRV_Handle hEdma;
484     // do nothing if already idled or unattached
485     if ((!pDevExt->runState) || (pDevExt->pParams == NULL))
486         return result;
488         if (pDevExt->pParams->sio.moduleNum == 0)
489                 hEdma = hEdma0;
490         else if (pDevExt->pParams->sio.moduleNum == 1 || pDevExt->pParams->sio.moduleNum == 2)
491                 hEdma = hEdma1;
493     // reset serial port -- stop generating sync events
494     result = SAP_PORT_FTABLE_reset (device);
495     if (result)
496     {
497         //TRACE_VERBOSE((&TR_MOD, "%s.%d: SAP_PORT_FTABLE_reset returned %d.\n", __FUNCTION__, __LINE__, result));
498         return result;
499     }
501     pDevExt->shutDown = 0; // force shutdown to run
502     result = SAP_FTABLE_shutdown (device);
503     if (result)
504     {
505         //TRACE_VERBOSE((&TR_MOD, "%s.%d: SAP_FTABLE_shutdown returned %d.\n", __FUNCTION__, __LINE__, result));
506         return result;
507     }
509     Log_info0("SAP_idle:Before EDMA3_DRV_disableTransfer");
511     // disable interrupts and EDMA servicing
512    if (pDevExt->activeEdma != EDMA_HINV)
513            EDMA3_DRV_disableTransfer (hEdma, pDevExt->activeEdma, EDMA3_DRV_TRIG_MODE_EVENT);
515     pDevExt->numQueued = 0;
517     // signal stopped
518     pDevExt->runState = 0;
520     // reset errorState
521     pDevExt->errorState = PAF_SIO_ERROR_NONE;
522     //TRACE_VERBOSE((&TR_MOD, "SAP_ctrl.%d: errorState = PAF_SIO_ERROR_NONE 0x%x.", __LINE__, PAF_SIO_ERROR_NONE));
524     // place call to physical device
525     if ((pDevExt->pParams != NULL) && (pDevExt->pParams->sio.control != NULL))
526         result = pDevExt->pParams->sio.control(device, (const PAF_SIO_Params *)pDevExt->pParams, PAF_SIO_CONTROL_IDLE, 0);
528     return result;
529 } // SAP_idle
531 // -----------------------------------------------------------------------------
533 Int SAP_start (DEV2_Handle device)
535     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)device->object;
536     DEV2_Frame *pFrame;
537     int result;
538     EDMA3_DRV_Handle hEdma;
540     //TRACE_GEN((&TR_MOD, "SAP_start.%d (0x%x)", __LINE__, device));
542     // signal we have started
543     //    we change the state here since we have already moved a frame from the 
544     //    todevice queue to the xferQue. If an error occurs during one of the 
545     //    following resets/enables then we need to have runState !=0 in order
546     //    for SAP_idle to properly cleanup. Moreover, the following resets/enables
547     //    do not (and are now required not to) depend on runState being 0.
548     //pDevExt->runState = 1;
549     // Assume todevice queue is not empty -- how else could we be here?
550     pFrame = (DEV2_Frame *) Queue_get (device->todevice);
552     // inidicate this xfer did not use param entry - just the active one
553     pFrame->misc = NULL;
554     if (pDevExt->pParams->sio.moduleNum == 0)
555         hEdma = hEdma0;
556     else if (pDevExt->pParams->sio.moduleNum == 1 || pDevExt->pParams->sio.moduleNum == 2)
557                 hEdma = hEdma1;
559     // non-atomic functions since not running yet.
560     Queue_enqueue (Queue_handle(&pDevExt->xferQue), (Queue_Elem *)pFrame);
562     // initialize count
563     pDevExt->numQueued = 1;
565     result = SAP_PORT_FTABLE_reset (device);
566     if (result)
567     {
568         //TRACE_VERBOSE((&TR_MOD, "%s.%d: SAP_PORT_FTABLE_reset returned %d.\n", __FUNCTION__, __LINE__, result));
569         return result;
570     }
572     // enable DMA processing
574     // config active xfer for this buffer
575     result = SAP_EDMA_setupXfer(device, pDevExt->activeEdma, EDMA_HINV, pDevExt->errorEdma, pFrame);
577     //Log_info3("SAP_start.%d, pDevExt->activeEdma 0x%x (pDevExt->errorEdma = 0x%x)",
578       //              __LINE__, pDevExt->activeEdma, pDevExt->errorEdma);
579         // signal we have started -- this must come before last enable to prevent a race
580         // condition where the initial EDMA transfer is very small (e.g. due to startClocks)
581         // and completes before any further instructions in this thread are executed.
582         // This comes before the EDMA enable since, if the # of samples is 1, then the EDMA
583         // will be serviced and generate an interrupt even before the McASP is enabled.
584         pDevExt->runState = 1;
585         pDevExt->shutDown = 0;
586         //Log_info0 ("SAP_start runState=1 & ENABLE TRANSFERS");
587         // enable interrupts and event servicing for this channel
588         EDMA3_DRV_enableTransfer (hEdma, pDevExt->activeEdma, EDMA3_DRV_TRIG_MODE_EVENT);
590     // enable peripheral
591     result = SAP_PORT_FTABLE_enable (device);
593     if (result)
594     {
595         //TRACE_VERBOSE((&TR_MOD, "%s.%d: SAP_PORT_FTABLE_enable returned %d.\n", __FUNCTION__, __LINE__, result));
596         return result;
597     }
599     return SIO2_OK;
600 } // SAP_start
602 int gDmaParamsarray[17][3];
603 int gDmaParamsidx=0;
604 // -----------------------------------------------------------------------------
606 Int SAP_issue (DEV2_Handle device)
608     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)device->object;
609     DEV2_Frame *pFrame;
610     Int result;
611     SAP_EDMA_Param *pParam;
612     XDAS_UInt32 parentEdma;
614     //TRACE_GEN((&TR_MOD, "SAP_issue.%d (0x%x)", __LINE__, device));
616     if ((device->mode == DEV2_OUTPUT) && (pDevExt->errorState >= PAF_SIO_ERROR_ERRBUF_XFER))
617     {
618         /*TRACE_TERSE((&TR_MOD, "SAP_issue.%d, errorState 0x%x (PAF_SIO_ERROR_ERRBUF_XFER = 0x%x)",
619             __LINE__, pDevExt->errorState, PAF_SIO_ERROR_ERRBUF_XFER));*/
620         Log_info3("SAP_issue.%d, PAF_SIO_ERROR_ERRBUF_XFER = 0x%x, mode = 0x%x)",
621                 __LINE__, PAF_SIO_ERROR_ERRBUF_XFER, device->mode );
622         return SIO2_EBADIO;
623     }
625     if ((device->mode == DEV2_INPUT) && pDevExt->errorState)
626         {
627                 Log_info1("SAP_issue: Input Error Trap, with errorState = 0x%x", pDevExt->errorState);
628             return SIO2_EBADIO;
629         }
631     // if not yet running then configure active xfer and start
632     if (pDevExt->runState == 0)
633         return (SAP_FTABLE_start(device));
635     // .........................................................................
636     // here if running
638     // disable device interrupts
639     // TODO: is there an API to just disable the IER bit for this tcc?
640     unsigned int key = Hwi_disable ();
641        /* determine parent EDMA
642           if no xfers in queue and we are running then must be in the
643           error state so link to active channel otherwise link to last
644           transfer queued.
645        */
647        /* here we assume after Tx SIO_idle or overrun, the user
648           will issue, at least, back-to-back issue requests so
649           there should be no problem here.
650        */
651        if ((pDevExt->numQueued <= 1) && (pDevExt->errorState != 2))
652            parentEdma = pDevExt->activeEdma;
653        else {
654            // if here then xferQue has more than one element so ok to use tail
655            // last scheduled transfer must be queue->prev
656            DEV2_Frame *tail = (DEV2_Frame *) Queue_prev ((Queue_Elem *)&pDevExt->xferQue);
657            parentEdma = ((SAP_EDMA_Param *) tail->misc)->hEdmaParam;
658        }
660     // get frame and parameter table to use; ints off => non-atomic OK
661     //     dont need to check for empty queues since were here then todevice
662     //     must have a frame placed there by the SIO_issue layer.
663     //     paramQue must be valid since it is accessed the same as todevice.
664     //     (indirectly -- isr places used items onto paramQue and fromdevice que
665     //      at the same time)
666     // set misc argument to pParam so get enqueue later
667     //pFrame = (DEV2_Frame *) Queue_dequeue (device->todevice);
668     pFrame = Queue_dequeue (device->todevice);
669     pParam = (SAP_EDMA_Param *) Queue_dequeue (Queue_handle(&pDevExt->paramQue));
671    /* if (pFrame->addr == NULL)
672                 SW_BREAKPOINT; */
673     if (pParam->hEdmaParam == NULL)
674         Log_info0("SAP_issue: hEdma value is NULL");
675     // set misc argument to pParam so get enqueue later
676     pFrame->misc = (Arg) pParam;
678     // place on holder queue, ints off => non-atomic OK
679     Queue_enqueue (Queue_handle(&pDevExt->xferQue), (Queue_Elem *) pFrame);
680     if (pFrame->addr) {
681                 if (device->mode == DEV2_INPUT)
682                         Cache_inv (pFrame->addr, pFrame->size, Cache_Type_ALL, TRUE);
683                 else
684                         Cache_wbInv (pFrame->addr, pFrame->size, Cache_Type_ALL, TRUE);
685         }
687     // increment count
688     pDevExt->numQueued += 1;
690     result = SAP_EDMA_setupXfer (device, pParam->hEdmaParam, parentEdma, pDevExt->errorEdma, pFrame);
691     //Log_info4("SAP_issue.%d, EDMA_setupXfer: Target EDMA: 0x%x, Parent Edma: 0x%x Error Edma: 0x%x",
692     //                __LINE__, pParam->hEdma, parentEdma, pDevExt->errorEdma);
694     /*if ((device->mode != DEV2_INPUT) && (gDmaParamsidx <=16))
695         {
696         gDmaParamsarray[gDmaParamsidx][0] = pParam->hEdma;
697                 gDmaParamsarray[gDmaParamsidx][1] = parentEdma;
698                 gDmaParamsarray[gDmaParamsidx++][2] = gisrOutput;
699         } */
701         if ((pDevExt->errorState == PAF_SIO_ERROR_IDLE_STAGE1) && (device->mode == DEV2_OUTPUT))
702                 pDevExt->errorState = PAF_SIO_ERROR_NONE;
704         pDevExt->shutDown = 0;
706     // special case enables when not yet started
707     if (pDevExt->runState == 0) {
708         result = SAP_FTABLE_start (device);
709         if (result) {
710             //SAP_DMA_FTABLE_unlock (device);
711                   Hwi_enable ();
712             return result;
713         }
714     }
715     Hwi_restore (key); //DJDBG
717     return result;
718 } // SAP_issue
720 // -----------------------------------------------------------------------------
722 void swapHdmi(Ptr Input, int size)
725         MdInt L0, L1, L2, L3, R0, R1, R2, R3 = 0;
726         MdInt *p1, *p2;
727         int i=0;
729         for (i=0; i< size; i+=16)
730         {
731                         p1 = (MdInt *)&Input[i];
732                         p2 = p1;
734                         L0 = *p1++;
735                         L1 = *p1++;
736                         L2 = *p1++;
737                         L3 = *p1++;
738                         R0 = *p1++;
739                         R1 = *p1++;
740                         R2 = *p1++;
741                         R3 = *p1++;
743                         *p2++ = L0;
744                         *p2++ = R0;
745                         *p2++ = L1;
746                         *p2++ = R1;
747                         *p2++ = L2;
748                         *p2++ = R2;
749                         *p2++ = L3;
750                         *p2++ = R3;
752         }
754         Log_info3("SAP: Exiting swapHdmi with Frame->Addr: 0x%x, p1->addr: 0x%x, p2->addr: 0x%x ", (MdInt *)Input, p1, p2);
756         /**p2++ = 0xF872;
757         *p2++ = 0x4E1F;
758         *p2++ = 0x0016;
759         *p2++ = 0xEFF0;
760         *p2++ = 0x079E;
761         *p2++ = 0x0003;
762         *p2++ = 0x8401;
763         *p2++ = 0x0101; */
765         return;
768 Int SAP_reclaim (DEV2_Handle device)
770     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)(device->object);
771     Int result, i, oldMask;
772 #ifdef SAP_CACHE_SUPPORT
773     DEV2_Frame *pFrame;
774 #endif
776     //TRACE_GEN((&TR_MOD, "SAP_reclaim.%d (0x%x)", __LINE__, device));
778     // must be running and  error free 
779     if ((!pDevExt->runState) || (pDevExt->errorState))
780     {
781         //TRACE_GEN((&TR_MOD, "SAP_reclaim.%d, not runState: 0x%x", __LINE__, pDevExt->errorState));
782         return SIO2_EBADIO;
783     }
785     // idle if necessary
786         if (pDevExt->errorState == PAF_SIO_ERROR_FATAL) {
787             DEV2_idle (device, 1);
788             return SIO2_EBADIO;
789         }
791        // Log_info0("SAP_reclaim: Before SEM Pend");
793     // wait for ISR to signal block completion
794     //TRACE_VERBOSE((&TR_MOD, "SAP_reclaim.%d wait for ISR to signal block completion", __LINE__));
795     if (!Semaphore_pend(pDevExt->sync, device->timeout))
796     {
797         Log_info0("SAP_reclaim, SYS_ETIMEOUT");
798         return SIO2_ETIMEOUT;
799     }
800     //Log_info1("SAP_reclaim: After SEM Pend for mode: 0x%x", device->mode);
802     // return error (owner must idle)
803     if (pDevExt->errorState == PAF_SIO_ERROR_FATAL)
804     {
805         DEV2_idle (device, 1);
806         //TRACE_TERSE((&TR_MOD, "SAP_reclaim.%d, PAF_SIO_ERROR_FATAL: 0x%x", __LINE__, pDevExt->errorState));
807         return PAF_SIO_ERROR_FATAL;
808     }
810 #ifdef SAP_CACHE_SUPPORT
811     // invalidate CACHE region if input -- use clean since
812     //    Dont clean if was for fill.
813     // since pend returned we know that head of fromdevice is valid
814     pFrame = Queue_head (device->fromdevice);
815     Log_info2("SAP: Inside SAP_Reclaim with From Device Frame->Addr: 0x%x and Frame->Size: %d", pFrame->addr, pFrame->size);
816     if ((device->mode == DEV2_INPUT) && (pFrame->addr != NULL))
817     {
818         if(pDevExt->edmaWordSize == 2 && pDevExt->numSers == 4)
819         {
820             Cache_inv (pFrame->addr, pFrame->size, Cache_Type_ALL, 0);
821             Cache_wait();
822                 //note: size here is in # of bytes, so incrementing by 4X32b words ( or 8X16b)
823                         //for(i=0; i<(pFrame->size)/(4*4); i+=16)
824                         //{
825                 // Hwi_disable commented since it used to affect other interrupts
826                 // max HWI disable duration ~1ms observed
827                     //oldMask = Hwi_disable ();
828                                 swapHdmi(pFrame->addr, pFrame->size);
829                                 //Hwi_restore(oldMask);
831                         Cache_wb (pFrame->addr, pFrame->size, Cache_Type_ALL, 0);
832                         Cache_wait();
833                         //}
834         }
835     }
837 #endif
838     /*if ((device->mode == DEV2_OUTPUT) && (pFrame->addr == NULL))
839         SW_BREAKPOINT; */
841     //TRACE_VERBOSE((&TR_MOD, "SAP_reclaim.%d, exit SIO2_OK", __LINE__));
842     return SIO2_OK;
843 } // SAP_reclaim
846 // -----------------------------------------------------------------------------
848 Int SAP_open (DEV2_Handle device, String name)
850     SAP_DeviceExtension   *pDevExt;
851     DEV2_Device            *entry;
852     Int                    oldMask, result;
853     Error_Block                         eb;
854     //TRACE_GEN((&TR_MOD, "SAP_open.%d (0x%x)", __LINE__, device));
856     // check SIO mode 
857     if ((device->mode != DEV2_INPUT) && (device->mode != DEV2_OUTPUT))
858         return SIO2_EMODE;
860     // allocate memory for device extension
861     device->object = NULL;
862     pDevExt = (SAP_DeviceExtension *) Memory_alloc (device->bufSeg, (sizeof(SAP_DeviceExtension)+3)/4*4, 4, &eb);
863     if (pDevExt == NULL)
864     {
865         printf("%s.%d:  MEM_alloc failed.\n", __FUNCTION__, __LINE__);
866         //TRACE_TERSE((&TR_MOD, "%s.%d:  MEM_alloc failed.\n", __FUNCTION__, __LINE__));
867         asm( " SWBP 0" );  // SW Breakpoint
868         return SIO2_EALLOC;
869     }
870     device->object = (Ptr)pDevExt;
872     // inits
873     pDevExt->device = device;
874     pDevExt->sync = NULL;
875     pDevExt->pParams = NULL;
876     pDevExt->runState = 0;  // not yet started
877     pDevExt->errorState = PAF_SIO_ERROR_NONE;
878     pDevExt->shutDown = 1;
879     pDevExt->numQueued = 0;
880     pDevExt->activeEdma = EDMA_HINV;
881     pDevExt->errorEdma = EDMA_HINV;
882     pDevExt->firstTCC = 0;
883     pDevExt->optLevel = 0;
884     pDevExt->numParamSetup = 0;
885     pDevExt->numEdmaParams = 4;
887     // use dev match to fetch function table pointer for SAP
888     DEV2_match(SAP_NAME, &entry);
889     if (entry == NULL) {
890         Log_error1("SAP", SIO2_ENODEV);
891         return SIO2_ENODEV;
892     }
893     pDevExt->pFxns = (SAP_Fxns *) entry->fxns;
895     // create semaphore for device
896     pDevExt->sync = Semaphore_create (0, NULL, NULL);
897     if (pDevExt->sync == NULL)
898     {
899         //TRACE_TERSE((&TR_MOD, "%s.%d: create semaphore for device failed.\n", __FUNCTION__, __LINE__));
900         return SIO2_EALLOC;
901     }
903     // queue inits
904     Queue_construct (&pDevExt->xferQue, NULL);
905     Queue_construct (&pDevExt->paramQue, NULL);
907     // update driver global (need to protect context)
908     if (sapDrv.numDevices >= MAX_SAP_DEVICES)
909     {
910         /*TRACE_TERSE((&TR_MOD, "%s.%d: add device failure: no. of devices = %d; need to increase MAX_SAP_DEVICES.\n",
911             __FUNCTION__, __LINE__, dapDrv.numDevices));*/
912         SW_BREAKPOINT;
913     }
914     oldMask = Hwi_disable ();
915     sapDrv.device[sapDrv.numDevices] = device;
916     pDevExt->deviceNum = sapDrv.numDevices++;
917     Hwi_restore (oldMask);
919     // PORT init
920     result = SAP_PORT_FTABLE_open (device);
921     if (result)
922     {
923         //TRACE_TERSE((&TR_MOD, "%s.%d: SAP_PORT_FTABLE_open returned %d.\n", __FUNCTION__, __LINE__, result));
924         return result;
925     }
927     return result;
928 } // SAP_open
930 // -----------------------------------------------------------------------------
932 Int SAP_config (DEV2_Handle device, const SAP_Params *pParams)
934     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)device->object;
935     Int                  result, Que_num, i;
936     EDMA3_DRV_Result     edmaResult;
937     Uint32                                      reqTcc;
938     EDMA3_DRV_Handle    hEdma;
939     Log_info2("SAP_config.%d (0x%x)", __LINE__, device);
941     // cannot configure if transfer started
942     if (pDevExt->runState == 1)
943         return SIO2_EBADIO;
945     // save pointer to config structure in device extension. here so that
946     //   forthcoming functions can use/modify config structure.
947     pDevExt->pParams = pParams;
948     pDevExt->edmaWordSize = pParams->sio.wordSize;
950     // allocate Port resources.
951     //    This must come before DMA configuration
952     result = SAP_PORT_FTABLE_alloc (device);
953     if (result)
954     {
955         Log_info3("%s.%d: SAP_PORT_FTABLE_alloc returned %d.\n", (xdc_IArg) __FUNCTION__, __LINE__, result);
956         return result;
957     }
959     // .............................................................................
960     // EDMA configuration
962     // DA10x McASP0 Specific
963     if (pParams->sio.moduleNum == 0)
964     {
965         hEdma = hEdma0;
966         if (device->mode == DEV2_INPUT)
967         {
968                 Que_num = 0;
969                 pDevExt->activeEdma = CSL_EDMACC_0_McASP_0_REVT;
970         }
971         else
972         {
973                 Que_num = 1;
974                 pDevExt->activeEdma = CSL_EDMACC_0_McASP_0_XEVT;
975         }
976     }
977     // DA10x McASP1 Specific
978     else if (pParams->sio.moduleNum == 1)
979     {
980         hEdma = hEdma1;
981         if (device->mode == DEV2_INPUT)
982                 {
983                 Que_num = 0;
984                 pDevExt->activeEdma = CSL_EDMACC_1_McASP_1_REVT;
985                 }
986                 else
987                 {
988                         Que_num = 1;
989                         pDevExt->activeEdma = CSL_EDMACC_1_McASP_1_XEVT;
990                 }
991     }
992     // DA10x McASP2 Specific
993     else if (pParams->sio.moduleNum == 2)
994     {
995         hEdma = hEdma1;
996         if (device->mode == DEV2_INPUT)
997                 {
998                         Que_num = 0;
999                         pDevExt->activeEdma = CSL_EDMACC_1_McASP_2_REVT;
1000                 }
1001                 else
1002                 {
1003                         Que_num = 1;
1004                         pDevExt->activeEdma = CSL_EDMACC_1_McASP_2_XEVT;
1005                 }
1006     }
1009     for (i=0; i < pDevExt->numEdmaParams; i++) {
1011         reqTcc = EDMA3_DRV_TCC_ANY;
1012         pDevExt->edmaParams[i].hEdmaParam = EDMA3_DRV_LINK_CHANNEL;
1013         edmaResult = EDMA3_DRV_requestChannel (
1014                 hEdma,
1015             &pDevExt->edmaParams[i].hEdmaParam,
1016             &reqTcc,
1017             (EDMA3_RM_EventQueue) Que_num,
1018             SAP_isrCallback,
1019             (void *) device);
1021         if (edmaResult != EDMA3_DRV_SOK)
1022             return SIO2_EALLOC;
1024         //not running => can use non-atomic functions
1025         Queue_enqueue (Queue_handle(&pDevExt->paramQue), (Queue_Elem *)&pDevExt->edmaParams[i]);
1027     }
1029     reqTcc = EDMA3_DRV_TCC_ANY;
1030         pDevExt->errorEdma = EDMA3_DRV_LINK_CHANNEL;
1031         edmaResult = EDMA3_DRV_requestChannel (
1032             hEdma,
1033             &pDevExt->errorEdma,
1034             &reqTcc,
1035             (EDMA3_RM_EventQueue)Que_num,
1036             SAP_isrCallback,
1037             (void *) device);
1038         if (edmaResult != EDMA3_DRV_SOK)
1039             return SIO2_EALLOC;
1041         // allocate edma channel -- also disable and clear the interrupt
1044         pDevExt->firstTCC = pDevExt->activeEdma ;
1045         edmaResult = EDMA3_DRV_requestChannel (
1046                 hEdma,
1047                 &pDevExt->activeEdma,
1048                 &pDevExt->firstTCC,
1049                 (EDMA3_RM_EventQueue) 0,
1050                 SAP_isrCallback,
1051                 (void *) device);
1052         if (edmaResult != EDMA3_DRV_SOK)
1053                     {
1054                         Log_info3("%s.%d: SAP_DMA_FTABLE_alloc returned %d.\n", (xdc_IArg)__FUNCTION__, __LINE__, edmaResult);
1055                         return SIO2_EALLOC;
1056                     }
1058         // Configure error transfer
1059         //   make cnt same as # of channels in order to maintain alignment
1060         //   and the error transfer small so that we never have to wait
1061         //   long for it to complete and trigger a linked transfer. This is
1062         //   important for establishing output timing when we are idling with
1063         //   clocks still running. Is fine for Rx as well.
1064         result = SAP_DMA_FTABLE_setupParam (device, pDevExt->errorEdma, pDevExt->errorEdma, NULL, pDevExt->edmaWordSize * pDevExt->numSers);
1066         Log_info3("%s.%d: Exiting SAP_alloc for %d.\n", (xdc_IArg)__FUNCTION__, __LINE__, pDevExt->activeEdma);
1068     return SIO2_OK;
1069 } // SAP_config
1071 // -----------------------------------------------------------------------------
1073 Int SAP_shutdown (DEV2_Handle device)
1075     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)(device->object);
1076     SIO2_Handle stream = (SIO2_Handle) device;
1077     DEV2_Frame *pFrame;
1078     Int result,i;
1079     EDMA3_DRV_Handle hEdma;
1080     //TRACE_GEN((&TR_MOD, "SAP_shutdown.%d (0x%x)", __LINE__, device));
1082     if (pDevExt->shutDown)
1083         return SIO2_EBADIO;
1085     if (pDevExt->pParams == NULL)
1086         return SIO2_EINVAL;
1088     if (pDevExt->pParams->sio.moduleNum == 0)
1089         hEdma = hEdma0;
1090     else if (pDevExt->pParams->sio.moduleNum == 1 || pDevExt->pParams->sio.moduleNum == 2)
1091         hEdma = hEdma1;
1092     if (pDevExt->activeEdma != EDMA_HINV)
1093         EDMA3_DRV_disableTransfer (hEdma, pDevExt->activeEdma, EDMA3_DRV_TRIG_MODE_EVENT);
1095     // reset queues
1096     while (!Queue_empty(device->todevice)) {
1097        // place oustanding requests onto holding queue
1098        pFrame = (DEV2_Frame *) Queue_dequeue (device->todevice);
1099        Queue_enqueue (Queue_handle(&pDevExt->xferQue), (Queue_Elem *) pFrame);
1100     }
1102     while (!Queue_empty(Queue_handle(&pDevExt->xferQue))) {
1103         // pull frame from holding queue and place on user queue
1104         pFrame = (DEV2_Frame *) Queue_dequeue (Queue_handle(&pDevExt->xferQue));
1105         Queue_enqueue (device->fromdevice, (Queue_Elem *) pFrame);
1106     }
1109     while (!Queue_empty(Queue_handle(&pDevExt->paramQue)))
1110         Queue_dequeue (Queue_handle(&pDevExt->paramQue));
1112     // not running => can use non-atomic functions
1113     for (i=0; i < pDevExt->numEdmaParams; i++)
1114         Queue_enqueue (Queue_handle(&pDevExt->paramQue), (Queue_Elem *) &pDevExt->edmaParams[i]);
1116     // reset counter
1117     pDevExt->numQueued = 0;
1119     // make sure active is linked to error
1120         EDMA3_DRV_linkChannel (hEdma, pDevExt->activeEdma, pDevExt->errorEdma);
1122     // think this is better (from SIO_idle for standard model )
1123     // refill frame list -- so user needn't call reclaim, which may cause Rx underrun.
1124     while (!Queue_empty(device->fromdevice)) {
1125         /* place oustanding requests onto holding queue */
1126         pFrame = (DEV2_Frame *) Queue_dequeue (device->fromdevice);
1127         Queue_enqueue (Queue_handle(&stream->framelist), (Queue_Elem *) pFrame);
1128     }
1129     Semaphore_reset (pDevExt->sync, 0);
1130     
1131     pDevExt->shutDown = 1;
1132     pDevExt->numParamSetup = 0;
1133     
1134     /*result = SAP_DMA_FTABLE_unlock (device);
1135     if (result)
1136     {
1137         //TRACE_TERSE((&TR_MOD, "%s.%d: SAP_DMA_FTABLE_unlock returned %d.\n", __FUNCTION__, __LINE__, result));
1138         return result;
1139     } */
1141     return SIO2_OK;
1142 } // SAP_shutdown
1144 // -----------------------------------------------------------------------------
1145 int gSapWatchDogThrottle = 0; //DJDBG
1146 Void SAP_watchDog (Void)
1148     DEV2_Handle device;
1149     SAP_DeviceExtension *pDevExt;
1150     int i, oldMask, result;
1152     //Log_info2("SAP_watchDog.%d (0x%x)", __LINE__, device);
1154     // do nothing if SAP_init not yet called
1155     if (!SAP_initialized)
1156     {
1157         Log_info2("%s.%d: SAP_init not yet called.\n", __FUNCTION__, __LINE__);
1158         return;
1159     }
1161     // protect context
1162     Task_disable (); // needed since we may call SEM_post
1163     // Hwi_disable commented since it used to affect other interrupts
1164     // max HWI disable duration ~4ms observed
1165     //oldMask = Hwi_disable ();
1167     //TRACE_VERBOSE((&TR_MOD, "%s.%d: devices loop, numDevices = %d", __FUNCTION__, __LINE__, dapDrv.numDevices));
1169     for (i=0; i < sapDrv.numDevices; i++) {
1170         device  = sapDrv.device[i];
1172         //TRACE_VERBOSE((&TR_MOD, "%s.%d, devices loop start, device = 0x%x", __FUNCTION__, __LINE__, device));
1174         pDevExt = (SAP_DeviceExtension *) device->object;
1176         // do nothing if not running
1177         if (!pDevExt->runState)
1178             continue;
1180         // call board specific watchdog
1181         // TODO: handle return value
1182         SIO2_ctrl (device, PAF_SIO_CONTROL_WATCHDOG, NULL);
1183         
1184         // if port layer returns error then must need to clean up
1185         result = SAP_PORT_FTABLE_watchDog (device);
1186         if (result) {
1187             // set errorState which will force owner thread
1188             //   to clean up via SIO_idle()
1189             pDevExt->errorState = PAF_SIO_ERROR_FATAL;
1190             //TRACE_TERSE((&TR_MOD, "SAP_watchDog.%d, PAF_SIO_ERROR_FATAL: 0x%x", __LINE__, pDevExt->errorState));
1191            /* if(gSapWatchDogThrottle == 0) //DJDBG
1192             {
1193                Log_info3("SAP_watchDog.%d (0x%x); THROTTLED result = 0x%x", __LINE__, device, result);
1194             }
1195             gSapWatchDogThrottle ++;
1196             if(gSapWatchDogThrottle > 10) gSapWatchDogThrottle = 0; */
1197             // if outstanding pend then post to free owner thead
1198             if (!Semaphore_pend(pDevExt->sync, 0))
1199                 Semaphore_post (pDevExt->sync);
1200         }
1201     }
1203     // renable interrupts and task manager.
1204     // If we posted to the semaphore then the TSK_enable call will lead to
1205     // an immediate task switch to the associated audio thread.
1206     //Hwi_restore (oldMask);
1207     Task_enable ();
1209 } // SAP_watchDog
1211 // -----------------------------------------------------------------------------
1212 // Assumes that EDMA3 dispatcher handles TCC clearing.
1214 void SAP_isrCallback (Uint32 tcc, EDMA3_RM_TccStatus status, Ptr context)
1216     DEV2_Handle                 device;
1217     SAP_DeviceExtension       *pDevExt;
1218     DEV2_Frame                 *pFrame;
1219     unsigned int               opt;
1220     EDMA3_DRV_Handle                    hEdma;
1222     // could be here after Tx idle/overrun and this is the interrupt
1223     // for the last occuring error transfer so there is no transfer
1224     // to release, we just clear the int and exit.
1226     device = (DEV2_Handle) context;
1227     pDevExt = (SAP_DeviceExtension *)(device->object);
1228     if (pDevExt->pParams == NULL)
1229         return SIO2_EINVAL;
1231     if (pDevExt->pParams->sio.moduleNum == 0)
1232         hEdma = hEdma0;
1233     else if (pDevExt->pParams->sio.moduleNum == 1 || pDevExt->pParams->sio.moduleNum == 2)
1234         hEdma = hEdma1;
1236     if ((pDevExt->runState == 1) && !pDevExt->errorState) {
1237         // if here then an interrupt occured due to errorEdma or valid
1238         // transfer, we assume the xfer is long enough so it will not complete
1239         // before we are finished here.
1241         // if last transfer was valid then complete it
1242         if (!Queue_empty(Queue_handle(&pDevExt->xferQue))) {
1244             // pull frame from holding queue
1245             pFrame = (DEV2_Frame *) Queue_dequeue (Queue_handle(&pDevExt->xferQue));
1247             // if used param entry then return it to queue
1248             if (pFrame->misc != NULL)
1249             {
1250                 Queue_enqueue (Queue_handle(&pDevExt->paramQue), (Ptr) pFrame->misc);
1251                 if (device->mode == 1)
1252                         gisrOutput+=100;
1253             }
1255             // decrement count
1256             pDevExt->numQueued -= 1;
1257             gIsrCnt++;
1258             if (device->mode == 1)
1259                 gisrOutput++;
1261             // place frame onto user queue and signal user thread
1262             Queue_enqueue (device->fromdevice, (Ptr) pFrame);
1264             Log_info2("Before SEM_post for device: 0x%x gIsrOutput: %d", device->mode, gisrOutput);
1265             // signal user thread
1266             Semaphore_post (pDevExt->sync);
1267 #if 0
1268             if(gIsrCnt > 10) { //DJDBG
1269                Log_info1("SAP isrCallback enough interrupts! %d", gIsrCnt);
1271             }
1272 #endif
1273         }
1274         else
1275                 gIsrElseCnt++;
1277         // determine if currently transferring buffer is valid based on interrupt enable bit
1278         // only valid transfers will generate interrupts
1279         EDMA3_DRV_getPaRAMEntry (hEdma, pDevExt->activeEdma, EDMA3_DRV_PARAM_ENTRY_OPT, &opt);
1281         if (!(opt & EDMA3_DRV_OPT_TCINTEN_SET_MASK (1)))
1282         {
1283                 gIsrErrCnt++;
1284                 pDevExt->errorState = PAF_SIO_ERROR_ERRBUF_XFER;
1285         }
1287     } // runState
1288     else
1289     {
1290                 if (pDevExt->runState != 1)
1291                         gIsrRunCnt++;
1292                 else
1293                         gIsrNotRunCnt++;
1294     }
1296     return;
1297 } //SAP_isrCallback
1299 // -----------------------------------------------------------------------------
1301 Int SAP_EDMA_setupXfer (DEV2_Handle device, XDAS_UInt32 targetEdma, XDAS_UInt32 parentEdma, XDAS_UInt32 childEdma, DEV2_Frame *pFrame)
1303     EDMA3_DRV_Handle            hEdma;
1304     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)device->object;
1305 //     int mcbspNum = pDevExt->pParams->sio.moduleNum;
1307         if (pDevExt->pParams == NULL)
1308                 return SIO2_EINVAL;
1310             if (pDevExt->pParams->sio.moduleNum == 0)
1311                 hEdma = hEdma0;
1312             else if (pDevExt->pParams->sio.moduleNum == 1 || pDevExt->pParams->sio.moduleNum == 2)
1313                 hEdma = hEdma1;
1315     // TODO: shouldn't this just be tcc interrupt disable?
1316     // at least until linkage phase...
1317     unsigned int key = Hwi_disable (); //DJDBG
1319     if(targetEdma == NULL)
1320     {
1321         Log_info0("targetEdma is NULL");
1322     }
1323     // configure transfer
1324     if(pFrame->addr == NULL) //DJDBG
1325     {
1326         Log_info0("pFrame has NULL address?");
1327     }
1328     SAP_DMA_FTABLE_setupParam (device, targetEdma, childEdma, pFrame->addr, pFrame->size);
1330     if (parentEdma != EDMA_HINV)
1331         EDMA3_DRV_linkChannel (hEdma, parentEdma, targetEdma);
1334     Hwi_restore (key); //DJDBG
1336     return SIO2_OK;
1337 } // SAP_setupXfer
1339 // -----------------------------------------------------------------------------
1340 // Configure EDMA3 parameter entry
1342 Int SAP_EDMA_setupParam (DEV2_Handle device, XDAS_UInt32 targetEdma, XDAS_UInt32 childEdma, unsigned int addr, unsigned int size)
1344     SAP_DeviceExtension *pDevExt = (SAP_DeviceExtension *)device->object;
1345     EDMA3_DRV_Handle            hEdma;
1346     EDMA3_DRV_PaRAMRegs  edmaConfig;
1348     if (pDevExt->pParams == NULL)
1349                 return SIO2_EINVAL;
1351         if (pDevExt->pParams->sio.moduleNum == 0)
1352                 hEdma = hEdma0;
1353         else if (pDevExt->pParams->sio.moduleNum == 1 || pDevExt->pParams->sio.moduleNum == 2)
1354                 hEdma = hEdma1;
1355     MCASP_Handle hPort = sapMcaspDrv.hPort[pDevExt->pParams->sio.moduleNum];
1356     volatile Uint32 *base = (volatile Uint32 *)(hPort->baseAddr);
1358    //Log_info3("%s.%d: Entered SAP_EDMA_setupParam for Target: 0x%x.\n", (xdc_IArg)__FUNCTION__, __LINE__, targetEdma);
1360     // Init opt parameter to 0 which, without being overriden, configures as:
1361     //    A synchronized transfer (no FIFO mode on src or dst)
1362     //    no chaining or intermediate interrupts
1363     //    param is not static
1364     //    normal completion
1365     //    don't generate an interrupt (overriden below for regular xfers)
1366     edmaConfig.opt = 0;
1368     // not transferring blocks so c index is 0
1369     edmaConfig.destCIdx = 0;
1370     edmaConfig.srcCIdx = 0;
1372     edmaConfig.opt |= EDMA3_DRV_OPT_SYNCDIM_SET_MASK (EDMA3_DRV_SYNC_AB); //DJDBG!
1373     if (device->mode == DEV2_OUTPUT) {
1374       //edmaConfig.opt |= EDMA3_DRV_OPT_DAM_SET_MASK (EDMA3_DRV_ADDR_MODE_FIFO); //DJDBG!!!
1375       edmaConfig.opt |= 2;
1376     }
1377     else {
1378         //edmaConfig.opt |= EDMA3_DRV_OPT_SAM_SET_MASK (EDMA3_DRV_ADDR_MODE_FIFO); //DJDBG!!!
1379         //edmaConfig.opt |= 1;
1380     }
1382     // if regular transfer then enable interrupt with tcc code
1383     if (targetEdma != pDevExt->errorEdma) {
1384         edmaConfig.opt |= EDMA3_DRV_OPT_SYNCDIM_SET_MASK (EDMA3_DRV_SYNC_AB);
1385         edmaConfig.opt |= EDMA3_DRV_OPT_TCINTEN_SET_MASK (1);
1386         edmaConfig.opt |= EDMA3_DRV_OPT_TCC_SET_MASK (pDevExt->firstTCC);
1387     }
1390     edmaConfig.aCnt = 4;
1391         edmaConfig.bCnt = pDevExt->numSers;
1392         edmaConfig.cCnt = size/(edmaConfig.aCnt * edmaConfig.bCnt);
1393     edmaConfig.bCntReload = edmaConfig.bCnt;
1396     // handle direction specific requirements
1397     if (device->mode == DEV2_INPUT) {
1398         edmaConfig.srcBIdx  = 0;
1399                 edmaConfig.srcAddr  = (unsigned int) (hPort->rbufAddr);
1401         if (addr) {
1402             edmaConfig.destBIdx = pDevExt->edmaWordSize;
1403             edmaConfig.destAddr = addr;
1404             edmaConfig.destCIdx  = pDevExt->edmaWordSize * pDevExt->numSers ;
1405             if(pDevExt->edmaWordSize == 2)
1406                 edmaConfig.cCnt= (size)/((edmaConfig.aCnt * edmaConfig.bCnt)/2);        // GJ: Account for additional 2-bytes.
1407         }
1408         else {
1409                 //if(pDevExt->edmaWordSize == 2)
1410                 //edmaConfig.srcAddr= (unsigned int)edmaConfig.srcAddr+ 2;
1411             edmaConfig.destBIdx = 0;
1412             edmaConfig.destAddr = (unsigned int) &sap_OVER;
1413         }
1414     }
1415     else {
1416         edmaConfig.destBIdx = 0;
1417         edmaConfig.destAddr = (unsigned int) (hPort->xbufAddr);
1419         if (addr) {
1420             edmaConfig.srcBIdx  = pDevExt->edmaWordSize;
1421             edmaConfig.srcCIdx  = pDevExt->edmaWordSize * pDevExt->numSers ;
1422             edmaConfig.srcAddr  = addr;
1423             Edma3_CacheFlush ((unsigned int) addr, (size+3)/4);
1424         }
1425         else {
1426             edmaConfig.srcBIdx  = 0;
1427             edmaConfig.srcAddr  = (unsigned int) &sap_UNDER[0];
1428 #if 1
1429             //edmaConfig.cCnt = (SAP_UNDER_LEN * sizeof(int))/(edmaConfig.aCnt * edmaConfig.bCnt); //DJDBG
1430             edmaConfig.cCnt = 512; //DJDBG, if underrun have frame of silence
1431 #endif
1432         }
1433     }
1434     edmaConfig.srcAddr  = (unsigned int) getGlobalAddr(edmaConfig.srcAddr);
1435     edmaConfig.destAddr  = (unsigned int) getGlobalAddr(edmaConfig.destAddr);
1437     //Log_info3("SAP: Inside SAP_EDMA_setupParam with targetEdma = 0x%x linked to childEdma = 0x%x & dest-addr: 0x%x", targetEdma, childEdma, edmaConfig.destAddr);
1439     EDMA3_DRV_setPaRAM (hEdma, targetEdma, &edmaConfig);
1441     // link child xfer
1442     if (childEdma != EDMA_HINV)
1443         EDMA3_DRV_linkChannel (hEdma, targetEdma, childEdma);
1445     return SIO2_OK;
1446 } //SAP_setupParam