05be7b4f542cecdaf5e8680efbba3a10cebb1ed3
[processor-sdk/performance-audio-sr.git] / pasrc / test_dsp / framework / audioStreamInpProcNewIO.c
2 /*
3 Copyright (c) 2018, 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  *  ======== audioStreamInpProcNewIo.c ========
38  */
39 #include <xdc/runtime/Log.h>
40 #include <ti/sysbios/BIOS.h>
41 #include <xdc/runtime/Error.h>
42 #include <ti/sysbios/knl/Event.h>
44 #include "procsdk_audio_typ.h"
45 #include "audioStreamInpProc.h"
46 #include "audioStreamProc_common.h"
47 #include "aspMsg_common.h"
48 #include "aspMsg_master.h"
49 #include "asperr.h"
50 #include "common.h"
52 #include "aud.h"
53 #include "aud_audio.h"
54 #include "mcasp_cfg.h"
55 #include "ioConfig.h"    //TODO: remove this header
56 #include "ioBuff.h"
57 #include "ioPhy.h"
58 #include "ioData.h"
60 #include <pa_i13_evmk2g_io_a.h>
62 #define STRIDE_WORST_CASE 32  // 4-byte (32-bit) word, 2 slots, 4 serializers
64 //#define DEBUG_SKIP_DECODING
66 #define SYNC_PC_MASK         0x1F
67 #define SYNC_SUBTYPE_MASK    0x700
68 #define SYNC_SUBTYPE_SHIFT   8
69 #define SYNC_SUBTYPE_DTSHD   0x11
70 #define SYNC_DDP             0x15
71 #define SYNC_THD             0x16
73 #define IEC_HEADER_LENGTH    4
75 #define INPUT_SWITCH_HANGOVER 8
77 //table needed until PAF_SOURCE is reordered to match IEC numbering
78 const SmUns IECpafSource[23] =
79 {
80     PAF_SOURCE_UNKNOWN,  // 0: IEC NULL Type
81     PAF_SOURCE_AC3,      // 1: Comments on 1-15 match IEC 61937 part 2.
82     PAF_SOURCE_UNKNOWN,  // 2: IEC reserved
83     PAF_SOURCE_UNKNOWN,  // 3: IEC pause
84     PAF_SOURCE_UNKNOWN,  // 4: MPEG 1 layer 1
85     PAF_SOURCE_MP3,      // 5: MPEG layer 2 or 3
86     PAF_SOURCE_UNKNOWN,  // 6: MPEG 2 data with extension
87     PAF_SOURCE_AAC,      // 7: MPEG-2 AAC ADTS
88     PAF_SOURCE_UNKNOWN,  // 8: MPEG 2 layer 1 low sampling frequency
89     PAF_SOURCE_UNKNOWN,  // 9: MPEG 2 layer 2 or 3 low sampling frequency
90     PAF_SOURCE_UNKNOWN,  // 10: reserved
91     PAF_SOURCE_DTS,      // 11: DTS type 1 (11 bit: 512 sample repeat period)
92     PAF_SOURCE_DTS12,    // 12: DTS type 2 (12 bit: 1024 sample repeat period)
93     PAF_SOURCE_DTS13,    // 13: DTS type 3 (13 bit: 2048 sample repeat period)
94     PAF_SOURCE_DTS14,    // 14: ATRAC
95     PAF_SOURCE_UNKNOWN,  // 15: ATRAC 2/3
96     PAF_SOURCE_THD,      // 16
97     PAF_SOURCE_DTSHD,    // 17
98     PAF_SOURCE_WMA9PRO,  // 18
99     PAF_SOURCE_UNKNOWN,  // 19
100     PAF_SOURCE_UNKNOWN,  // 20
101     PAF_SOURCE_DDP,      // 21
102     PAF_SOURCE_THD,      // 22
103 };
105 /*
106  * Functions defined in other files and to be put into proper header files
107  */
108 extern Void taskAsipFxnInit(const PAF_ASIT_Params *pP,const PAF_ASIT_Patchs *pQ);
111 // avoid including sap_d10.h, which would cause symbol redefinition
112 // warning (MCASP_PFUNC_XXX)
113 //extern XDAS_Int32 D10_init(void * pD10Params);
114 extern XDAS_Int32 D10_initClkMux(void *pD10Params);
115 extern XDAS_Int32 D10_RxControl(const void *pD10RxParams,
116                                 XDAS_Int32 code, XDAS_Int32 arg);
117 extern Aud_STATUS D10_initHDMI(void);
119 /*
120  * Functions only used in this file
121  */
122 int asitPrepareProcessing();
123 int asitIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo);
124 void asitProcInit(PAF_AST_IoInp  *pInp, asipDecProc_t *pDec);
125 void asitIoPhyPrime(PAF_AST_IoInp *pInpIo);
126 void asitPhyTransferComplete(PAF_AST_IoInp * pInpIo);
127 void asitPhyTransferStart(PAF_AST_IoInp *pInpIo);
128 Int asitRecfgPhyXfer(PAF_AST_IoInp *pInp, size_t xferSize);
130 // Select Input devices
131 Int asitSelectDevices(
132     const PAF_ASIT_Patchs *pQ, 
133     PAF_AST_Config *pAstCfg, 
134     PAF_AST_IoInp *pInp
135 );
137 Int asitUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
138                           PAF_InpBufConfig *pInpBuf);
140 Int asitSourceDetection(const PAF_ASIT_Params *pP,
141                         const PAF_ASIT_Patchs *pQ,
142                         PAF_ASIT_Config       *pAsitCfg);
144 Int asitDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
145                      ioDataAutoDetStat_t *autoDetStatus);
146 Int asitUpdateIoComps(const PAF_ASIT_Params *pP, PAF_AST_Config *pAstCfg,
147                       PAF_AST_IoInp  *pInp, ioDataAutoDetStat_t *autoDetStatus);
148 Int asitBypassIoData(PAF_AST_IoInp *pInp);
149 Int asitPcmTransition(PAF_ASIT_Config *pAsitCfg);
151 void asitUpdateInpBufConfig(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp);
152 Int asitInputDataProcess(PAF_AST_IoInp *pInp, ioDataAutoDetStat_t *pAutoDetStats);
154 UInt asitEventsToDecMsg(UInt asitEvents);
155 void asitErrorHandling(PAF_ASIT_Config *pAsitCfg, Int asitErr);
156 Int asitEvtErrCheck(UInt actualEvents, UInt expectedEvents);
158 void asitPostInfoEvent();
159 void asitPostDecEvent();
161 /*
162  * variables/structures to be put into proper global structures
163  */
164 extern PAF_ASIT_Config gPAF_ASIT_config;
165 extern const MdUns iecFrameLength[23];
166 extern Ptr hMcaspRxChan;
168 // temp for simulation
169 //#define ASIT_ALL_EVENTS (  ASIT_EVTMSK_INPDATA \
170 //                         + ASIT_EVTMSK_INFOACK \
171 //                         + ASIT_EVTMSK_DECACK )
172 #define ASIT_ALL_EVENTS (  ASIT_EVTMSK_INPDATA \
173                          + ASIT_EVTMSK_RXACK )
175 // temp for simulation
176 //#define ASIT_DEC_EVENTS (  ASIT_EVTMSK_INPDATA \
177 //                         + ASIT_EVTMSK_INFOACK \
178 //                         + ASIT_EVTMSK_DECACK )
179 #define ASIT_DEC_EVENTS (  ASIT_EVTMSK_INPDATA \
180                          + ASIT_EVTMSK_RXACK )
182 #define ASIP_DEBUG
184 #ifdef ASIP_DEBUG
185 /* define the following as global variables for easy debugging */
186 int asipLoopCount1, asipLoopCount2;
187 Int asipErrno;
188 Int inputReadyForProcessing;
190 // debug
191 #include "evmc66x_gpio_dbg.h"
192 #endif
194 Event_Handle gAsitEvtHandle;            // ASIT event handle
195 Int eventsOn;                           // flag indicating whether to process events
197 SyncEvent_Handle gAsitSyncEvtHandle;    // ASIT Sync event handle
199 /*
200  *  ======== taskAsipFxn ========
201  *  Audio Stream Input Processing task function
202  */
203 #ifndef PASDK_SIO_DEV
204 #ifndef IO_LOOPBACK_TEST
205 Void taskAsipFxn(                  // ASIP task function for new I/O
206 #else
207 Void taskAsipFxn_NewIO_Not_Used(   // not used for loopback test
208 #endif
209 #else
210 Void taskAsipFxn_NewIO_Not_USED(   // not used for SIO/DEV based I/O
211 #endif
212     const PAF_ASIT_Params *pP,
213         const PAF_ASIT_Patchs *pQ)
215     PAF_ASIT_Config *pAsitCfg;      /* ASIT configuration pointer */
216     PAF_AST_Config  *pAstCfg;       /* AST Common (shared) configuration pointer */
217     PAF_AST_IoInp *pInp;            /* Input I/O components */
218     Int as;                         /* Audio Stream Number (1, 2, etc.) */
219     Int z;                          /* input/encode/stream/decode/output counter */
220     Int zMI;
221 #ifndef ASIP_DEBUG
222 int asipLoopCount1, asipLoopCount2;
223 Int asipErrno;
224 Int inputReadyForProcessing;
225 #endif
226     Int asitErr;
227     UInt events;
228 //    Int eventsOn;
229 //    Error_Block  eb;
231     Log_info0("Enter taskAsipFxn()");
233     taskAsipFxnInit(pP, pQ);  // initialization of input task
234     
235     //
236     // Audio Stream Input Task Configuration (*pAsitCfg):
237     //
238     pAsitCfg = &gPAF_ASIT_config;       // initialize pointer to task configuration
239     pAstCfg  = pAsitCfg->pAstCfg;       // pointer to AST common (shared) configuration
241     /* Set Audio Stream Number (1, 2, etc.) */
242     as = pAstCfg->as;
244     //
245     // Determine decoder and stream indices associated with the master input
246     //
247     zMI  = pP->zone.master;
248     pInp = &pAsitCfg->pIoInp[zMI];        // pointer to input I/O components
250     for (z=STREAM1; z < STREAMN; z++)
251     {
252         TRACE_VERBOSE1("TaskAsip: AS%d: running", as+z);
253     }
255     Log_info0("TaskAsip: Entering Main Loop.");
257     //
258     // Main processing loop
259     //
260     asipLoopCount1 = 0;
261     asipLoopCount2 = 0;
262     asitErr = ASIT_NO_ERR;
264     // The events_on flag will be removed if the RESTART state is changed to
265     // event-based scheduling instead of polling
266     eventsOn = FALSE;
268         // Increase ASIP priority level one more over ASOP
269     Task_setPri(pAsitCfg->taskHandle, Task_getPri(pAsitCfg->taskHandle)+1);
271     for (;;)
272     {
273         asipLoopCount1++;
275         if(eventsOn) {
276             events = Event_pend(gAsitEvtHandle, ASIT_EVTMSK_NONE, ASIT_ALL_EVENTS,
277                                 BIOS_WAIT_FOREVER);
278         }
279         switch (pInp->asipState)
280         {
281         case ASIT_RESET:    // No events pending in this state
282             // Indicate decoder no decoding yet
283             pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_NONE);
285             // 5 system tick, or 5 msec. Should remove this later when implementing
286             // event based scheduling.
287             Task_sleep(5);
289             inputReadyForProcessing = asitPrepareProcessing(pP, pQ, pAsitCfg, &asipErrno);
290             if (inputReadyForProcessing) {
291                 TRACE_VERBOSE0("TaskAsip: Input is ready. Initialize I/O components.");
292                 // Input is ready for processing, so we initialize the I/O components.
293                 // Note that the I/O components init. and I/O PHY prime are performed only
294                 // at the first time. This should be changed later - init. and prime
295                 // should be done whenever input interface has changed.
296                 asitErr = asitIoCompsInit(&pAstCfg->xInp[zMI], pInp);
298                 // Initialize ASIT processing
299                 asitProcInit(pInp, &pAsitCfg->inpDec);
300                 pInp->asipState = ASIT_SOURCE_DETECTION;
301                 eventsOn = TRUE;   // turn on events pending
302                 TRACE_VERBOSE0("TaskAsip: turn on events and go to source detection.");
303             }
304             break;
306         case ASIT_SOURCE_DETECTION:
307             // Source unknown - to detect & identify source
308             if(events == ASIT_EVTMSK_INPDATA) {  
309                 // Only this event is expected. If any other event, it's error.
310                 // Input data is ready - perform source detection.
311                 // New state will be decided inside the function
312                 asitErr = asitSourceDetection(pP, pQ, pAsitCfg);
314                 if(asitErr == ASIT_AUTODET_TIME_OUT) {
315                     // Should restart if new interface is selected.
316                     TRACE_VERBOSE0("TaskAsip: auto-detection time out.");
317                 }
318             }
319             else {
320                 //Error checking & debug
321                 asitErr = asitEvtErrCheck(events, ASIT_EVTMSK_INPDATA);
322             }
324             break;
326         case ASIT_PCM_TRANSITION:
327             // Source is PCM - transition to PCM decoding
328             if(events == ASIT_EVTMSK_INPDATA) {
329                 // Only this event is expected. If any other event, it's error.
330                 // Input data is ready - transition to PCM decoding
331                 // New state will be decided inside the function
332                 asitErr = asitPcmTransition(pAsitCfg);
333             }
334             else {
335                 //Error checking & debug
336                 asitErr = asitEvtErrCheck(events, ASIT_EVTMSK_INPDATA);
337             }
338             break;
340         case ASIT_DECODE_PROCESSING:
341             if(events & ASIT_DEC_EVENTS) {
342                 
343 #if 1 // debug 
344                 if (events & ASIT_EVTMSK_INPDATA)
345                 {
346                     // shows timing of Input (Rx McASP EDMA)
347                     // ADC B5
348                     {
349                         static Uint8 toggleState = 0;
350                         if (toggleState == 0)
351                             GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_99);
352                         else
353                             GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_99);
354                         toggleState = ~(toggleState);
355                     }
356                 }
357 #endif           
358                 
359                 // Decode processing for either PCM or bitstream
360                 // New state will be decided inside the function
361                 asitErr = asitDecodeProcessing(pP, pQ, pAsitCfg, events);
362             }
363             else {
364                 //Error checking & debug
365                 asitErr = asitEvtErrCheck(events, ASIT_DEC_EVENTS);
366             }
367             break;
369         default:
370             break;
371         }
373         if(asitErr) {
374             asitErrorHandling(pAsitCfg, asitErr);
376             if(pInp->asipState == ASIT_RESET) {
377                 eventsOn = FALSE;
378             }
380             asitErr = ASIT_NO_ERR;
381         }
383     }  // for (;;)
385 }  /* taskAsipFxn */
388 /*===========================================================================
389  * ASIT Processing Preparation
390  * Output:
391  *        - return        TRUE (input is ready) or FALSE (input is not ready)
392  *        - *asipErrno    Error number
393 ============================================================================*/
394 Int asitPrepareProcessing(const PAF_ASIT_Params *pP,
395                           const PAF_ASIT_Patchs *pQ,
396                           PAF_ASIT_Config       *pC,
397                           Int                   *asipErrno)
399     Int as, zMS, zMI, zMD;
400     Int sourceConfig, mode;
401     PAF_AST_Config  *pAstCfg;
402     PAF_AST_IoInp *pInp;            /* I/O components for input */
404     pAstCfg  = pC->pAstCfg;         // pointer to AST common (shared) configuration
405     as  = pAstCfg->as;
406     zMI = pP->zone.master;
407     zMD = pAstCfg->masterDec;
408     zMS = pAstCfg->masterStr;
409     pInp = pC->pIoInp;              // pointer to input I/O components
411     *asipErrno = 0;
413     // Select source and initialize physical layer / HW interface
414     *asipErrno = asitSelectDevices(pQ, pAstCfg, pInp);
415     if (*asipErrno) {
416         TRACE_TERSE2("asitSelectDevices returned asipErrno = 0x%04x at line %d. AS%d",
417                      *asipErrno, as+zMS);
418         return FALSE;    // Input is not ready for processing due to error
419     }
421     // If no master input selected then we don't know what may be at the input,
422     // so set to unknown and skip any remaining processing
423     if (!pInp[zMI].pRxParams) {
424         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
425                            (Int8)PAF_SOURCE_UNKNOWN, GATEMP_INDEX_DEC);
427         TRACE_VERBOSE1("TaskAsip: AS%d: No input selected...", as+zMS);
428         return FALSE;    // No error, but input is not ready for processing
429     }
431     // If here then we have a valid input so query its status
432     *asipErrno = asitUpdateInputStatus(pInp[zMI].pRxParams,
433                                    &pAstCfg->xInp[zMI].inpBufStatus,
434                                    &pAstCfg->xInp[zMI].inpBufConfig);
435     if(*asipErrno) {
436         TRACE_VERBOSE1("TaskAsip: updateInputStatus returns 0x%x", *asipErrno);
437         return FALSE;   // Input is not ready for processing due to error
438     }
440     // If master decoder is not enabled, or the input is unlocked, then do nothing
441     mode = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.mode),
442                                   GATEMP_INDEX_DEC);
443     if (!mode || !pAstCfg->xInp[zMI].inpBufStatus.lock)
444     {
445         TRACE_VERBOSE0("TaskAsip: Not locked, continue");
446         return FALSE;  // No error, but input is not ready for processing
447     }
449     // Check selected source: sourceSelect is set by another task, AIP or AFP
450     sourceConfig = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
451                                           GATEMP_INDEX_DEC);
452     // If no source selected then do nothing
453     if(sourceConfig == PAF_SOURCE_NONE) {
454         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
455                            (Int8)PAF_SOURCE_NONE, GATEMP_INDEX_DEC);
456         TRACE_VERBOSE1("TaskAsip: AS%d: no source selected, continue", as+zMS);
457         return FALSE;  // No error, but input is not ready for processing
458     }
460     // If we want pass processing then proceed directly
461     if (sourceConfig == PAF_SOURCE_PASS)
462     {
463         TRACE_VERBOSE1("TaskAsip: AS%d: Pass processing ...", as+zMS);
464         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
465                            (Int8)PAF_SOURCE_PASS, GATEMP_INDEX_DEC);
467         pP->fxns->sourceDecode(pP, pQ, pC, PAF_SOURCE_PASS);
468         if (pP->fxns->passProcessing) {
469             *asipErrno = pP->fxns->passProcessing(pP, pQ, pC, NULL);
470         }
471         else {
472             TRACE_TERSE2("TaskAsip: AS%d: Pass Processing not supported, asipErrno 0x%x",
473                          as+zMS, ASPERR_PASS);
474             *asipErrno = ASPERR_PASS;
475         }
477         TRACE_VERBOSE0("TaskAsip: continue");
478         return FALSE;  // Error or not, input is not ready for processing
479     }
481     // No error and input processing is ready
482     return TRUE;
483 } /* asitPrepareProcessing */
486 /*===========================================================================
487  * ASIT Source Detection:
488  *     ASIT processing for input source identification:
489  *     - mark I/O PHY transfer completion
490  *     - run auto-detection via I/O DATA in asitInputDataProcess
491  *     - mark I/O DATA read completion
492  *     - check auto-detection status and take corresponding actions if either
493  *       PCM or bitstream is identified:
494  *       - decide input source
495  *       - update I/O components
496  *       - reconfigure McASP LLD if it is PCM
497  *     - start next I/O PHY transfer
498 ============================================================================*/
499 Int asitSourceDetection(const PAF_ASIT_Params *pP,
500                         const PAF_ASIT_Patchs *pQ,
501                         PAF_ASIT_Config       *pAsitCfg)
503     PAF_AST_Config  *pAstCfg;
504     PAF_AST_IoInp *pInp;                // I/O components for input
505     Int zMD, mcaspErr, asitErr;
506     ioDataAutoDetStat_t autoDetStatus;
508     pAstCfg  = pAsitCfg->pAstCfg;               // pointer to AST common (shared) configuration
509     zMD = pAstCfg->masterDec;
510     pInp = &pAsitCfg->pIoInp[zMD];              // pointer to input I/O components
512     // Marks I/O PHY transfer and I/O BUFF write complete
513     asitPhyTransferComplete(pInp);
515     // Process input data - either searching SYNC for PCM or checking SYNC for bitstream
516     asitErr = asitInputDataProcess(pInp, &autoDetStatus);
517     if(asitErr != ASIT_NO_ERR) {
518         // Even though there is error, still need to start next transfer to
519         // maintain McASP transfer, before returning error.
520         asitPhyTransferStart(pInp);
522         return asitErr;
523     }
525     // Mark input data read complete
526     ioDataReadComplete(pInp->hIoData);
528     if(autoDetStatus.syncTimeOut) {
529         return ASIT_AUTODET_TIME_OUT;
530     }
531     // Check if bitstream or PCM is detected
532     else if(   autoDetStatus.syncState == IODATA_SYNC_BITSTREAM
533        || autoDetStatus.syncState == IODATA_SYNC_PCM) {
534         // Decide input source and inform decoder
535         asitErr = asitDecideSource(pAstCfg, pInp, &autoDetStatus);
536         if(asitErr != ASIT_NO_ERR) {
537             return asitErr;
538         }
539         else {
540             // Update I/O components and input buffer config
541             asitUpdateIoComps(pP, pAstCfg, pInp, &autoDetStatus);
543             // set to unknown so that we can ensure, for IOS purposes, that
544             // sourceDecode = NONE iff we are in this top level state machine
545             // and specifically not in decodeProcessing
546 #ifndef DEBUG_SKIP_DECODING
547             pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_UNKNOWN);
548 #endif
550             if(autoDetStatus.syncState == IODATA_SYNC_BITSTREAM) {
551                 // Input is bit stream: go to decoding
552                 pInp->asipState = ASIT_DECODE_PROCESSING;
553                 TRACE_VERBOSE0("Bit stream detected. Go to decoding. ");
554             }
555             else  {
556                 // Input is PCM: stop swapping data
557                 pInp->swapData = FALSE;
559                 // Reconfigure McASP LLD to transfer 32-bit unpacked data
560                 mcaspErr = mcaspRecfgWordWidth(pInp->hMcaspChan, Mcasp_WordLength_32);
561                 if(mcaspErr != Aud_EOK) {
562                     return ASIT_ERR_MCASP_CFG;
563                 }
565                 // Adjust I/O BUFF delay and read pointer - to make sure read pointers
566                 // always point to PCM data from 1st I2S (out of 4 for HDMI 4xI2S)
567                 ioBuffAdjustDelay(pInp->hIoBuff, pInp->phyXferSize);
569                 // Mute decoder output during PCM transition
570                 pAstCfg->xInp[zMD].inpBufConfig.deliverZeros = TRUE;
572                 // Go to transition state to switch to PCM
573                 pInp->asipState = ASIT_PCM_TRANSITION;
574                 TRACE_VERBOSE0("PCM stream detected. Go to PCM transition. ");
575             }
576         }
577     }
578     else {
579         // SYNC search ongoing, no action is needed
580     }
582     // Start next transfer
583     asitPhyTransferStart(pInp);
585     return (ASIT_NO_ERR);
586 }  /* asitSourceDetection */
589 /*===========================================================================
590     //
591     // which will cause all 0's in one McASP LLD transfer. This will
592     // be detected as loss of SYNC by auto detection. To prevent that,
593     // skip I/O DATA process for hangover period so that this all 0's
594     // frame will not be seen by auto-detection. Also, playing out PCM
595     // needs to be skipped as well, to prevent from playing out garbage
596     // (16-bit packed data).
597  *
598  * ASIT Transition to PCM decoding.
599  *     When PCM is detected, McASP LLD will be reconfigured to transmit 32-bit
600  *     words, which will modify the RFMT register. This will cause all 0's in
601  *     one McASP LLD transfer, which would be detected as loss of SYNC by auto
602  *     detection (performed by I/O DATA). To prevent that, skip I/O DATA process
603  *     for hangover period so that this all-0's frame will not be seen by the
604  *     auto-detection.
605  *
606  *     In addition, playing out PCM should be skipped as well to prevent from
607  *     playing out the 16-bit packed data that's still in the input buffer.
608  *
609  *     This function does the following:
610  *     - mark I/O PHY transfer completion
611  *     - bypass I/O DATA
612  *     - start next I/O PHY transfer
613 ============================================================================*/
614 Int asitPcmTransition(PAF_ASIT_Config *pAsitCfg)
616     Int asitErr;
617     PAF_AST_IoInp *pInp;                  // I/O components for input
618     Int zMD;
620     zMD = pAsitCfg->pAstCfg->masterDec;   // pointer to AST common (shared) configuration
621     pInp = &pAsitCfg->pIoInp[zMD];        // pointer to input I/O components
623     // Marks I/O PHY transfer and I/O BUFF write complete
624     asitPhyTransferComplete(pInp);
626     // Bypass I/O data processing due to McASP LLD work around
627     // (refer to comments inside the function)
628     asitErr = asitBypassIoData(pInp);
630     pInp->pcmSwitchHangOver--;
631     if(pInp->pcmSwitchHangOver == 0) {
632         pInp->asipState = ASIT_DECODE_PROCESSING;
634         // Unmute decoder output after PCM transition
635         pAsitCfg->pAstCfg->xInp[zMD].inpBufConfig.deliverZeros = FALSE;
636     }
637     else {
638         ; // stay in this state
639     }
641     // Start next transfer
642     asitPhyTransferStart(pInp);
644     return asitErr;
646 } /* asitPcmTransition */
648 /*============================================================================
649  * ASIT Bypass I/O DATA Processing
650  *     This function bypasses the I/O DATA processing. It maintains the read
651  *     operation of I/O BUFF by directly calling I/O BUFF APIs. When I/O DATA
652  *     is not bypassed, I/O BUFF read operation is invoked by I/O DATA.
653  *
654 ============================================================================*/
655 Int asitBypassIoData(PAF_AST_IoInp *pInp)
657     void *buff1, *buff2;
658     size_t size1, size2;
660     // Get read pointers (or sub-buffers) of the input buffer
661     if (ioBuffGetReadPtrs(pInp->hIoBuff, pInp->phyXferSize,
662                           &buff1, &size1, &buff2, &size2)
663         == IOBUFF_ERR_UNDERFLOW) {
664         pInp->numUnderflow += 1;
666         // Return since there is no enough data to process
667         return ASIT_ERR_INPBUF_UNDERFLOW;
668     }
670     ioBuffReadComplete(pInp->hIoBuff, buff1, size1);
672     if(buff2 != NULL) {
673         ioBuffReadComplete(pInp->hIoBuff, buff2, size2);
674     }
676     return ASIT_NO_ERR;
677 } /* asitBypassIoData */
680 /*============================================================================
681  * ASIT Decode Processing
682  *     This function performs the decode processing and does the following based
683  *     on the ASIT events:
684  *     - initialize the decode processing if it is the first time
685  *     - if there is ASIT INPUT DATA event (ASIT_EVTMSK_INPDATA):
686  *        - mark I/O PHY transfer completion
687  *        - run auto-detection via I/O DATA in asitInputDataProcess
688  *        - check auto-detection status and take corresponding actions if SYNC
689  *          is lost.
690  *        - start next I/O PHY transfer
691  *     - map ASIT events to decoding messages
692  *     - invoke decDecodeFsm() and pass the mapped decoding messages
693  *     - if there is ASIT DECODE ACK event (ASIT_EVTMSK_DECACK)
694  *        - mark I/O DATA read completion
695  *     - error handling
696 ============================================================================*/
697 Int asitDecodeProcessing(const PAF_ASIT_Params *pP,
698                          const PAF_ASIT_Patchs *pQ,
699                          PAF_ASIT_Config       *pAsitCfg,
700                          UInt asitEvents)
702     Int asitErr, decErr;
703     PAF_AST_IoInp *pInp;                  // I/O components for input
704     AspMsgMaster_Handle hAspMsgMaster;    // ASIT message master handle
705     asipDecProc_t *pDec;
706     ioDataAutoDetStat_t autoDetStatus;
707     Int zMD;
708     UInt decMsg;
709     Int status;
711     zMD = pAsitCfg->pAstCfg->masterDec;         // pointer to AST common (shared) configuration
712     pInp = &pAsitCfg->pIoInp[zMD];              // pointer to input I/O components
713     hAspMsgMaster = pAsitCfg->hAspMsgMaster;    // get ASIT message master handle
714     pDec = &pAsitCfg->inpDec;
716     // Initialization for decode processing when this function is called the first time
717 #ifndef DEBUG_SKIP_DECODING
718     if(!pDec->initDone) {
719         // Initialize decoder
720         decDecodeInit(pP, pAsitCfg, pInp->sourceSelect);
722         pDec->initDone = TRUE;
723     }
724 #endif
726     // Process input data if this is a data ready message
727     if(asitEvents & ASIT_EVTMSK_INPDATA) {
728         TRACE_TERSE0("asitDecodeProcessing: process input data.");
730         // Marks I/O PHY transfer and I/O BUFF write complete
731         asitPhyTransferComplete(pInp);
733         // Process input data - either search SYNC for PCM or check SYNC for bitstream
734         asitErr = asitInputDataProcess(pInp, &autoDetStatus);
736         if(asitErr == ASIT_NO_ERR) {
737             ioDataReadComplete(pInp->hIoData);
739             // Check if SYNC is maintained or lost (stream stops or format changes)
740             if(autoDetStatus.syncState == IODATA_SYNC_NONE) {
741                 // SYNC lost: change I/O PHY transfer size to default for auto-detection
742                 //asitErr = asitRecfgPhyXfer(pInp, INPUT_FRAME_SIZE_DEF);
743                 //if(asitErr != ASIT_NO_ERR) {
744                 //    return asitErr;
745                 //}
747                 // Inform decoder to complete the decoding of previous frame - is this good?
748                 pInp->sourceSelect = PAF_SOURCE_NONE;
749                 pInp->numFrameReceived    = 0;    // for debugging
750                 pInp->numPcmFrameReceived = 0;    // for debugging
751                 TRACE_TERSE0("asitDecodeProcessing: SYNC lost.");
753 #ifdef DEBUG_SKIP_DECODING
754                 asitErr = ASIT_ERR_DECODE_QUIT;
755 #endif
756             }
757             else {
758                 if(autoDetStatus.syncState == IODATA_SYNC_PCM) {
759                     pInp->numPcmFrameReceived += 1;  // for debugging
760                 }
761                 else {
762                     pInp->numFrameReceived += 1;     // for debugging
763                 }
765                 // Communicate input stream information to decoder through input
766                 // buffer configuration -- this was moved inside decDecodeFsm
767                 //asitUpdateInpBufConfig(pAsitCfg->pAstCfg, pInp);
769                 // Start next transfer
770                 asitPhyTransferStart(pInp);
771             }
773             // Start next transfer
774             //asitPhyTransferStart(pInp);
776 #ifdef DEBUG_SKIP_DECODING
777             return asitErr;
778 #endif
779         }
780         else if(asitErr == ASIT_ERR_INPBUF_UNDERFLOW) {
781             TRACE_TERSE0("asitDecodeProcessing: Input buffer underflows.");
783             // When input buffer underflows, it is not an error but decoding needs
784             // to be skipped as there is not enough data in the buffer.
785             asitPhyTransferStart(pInp);
787             return asitErr;
788         }
789         else {
790             // Inform decoder to complete the decoding of previous frame - is this good?
791             pInp->sourceSelect = PAF_SOURCE_NONE;
792             pInp->numFrameReceived    = 0;    // for debugging
793             pInp->numPcmFrameReceived = 0;    // for debugging
794             TRACE_TERSE1("asitDecodeProcessing: asitInputDataProcess error: %d", asitErr);
796 #ifdef DEBUG_SKIP_DECODING
797             return ASIT_ERR_DECODE_QUIT;
798 #endif
799         }
800     } /* ASIT_EVTMSK_INPDATA */
801 #ifdef DEBUG_SKIP_DECODING
802     else {
803         TRACE_TERSE0("asitDecodeProcessing: events error.");
804         return ASIT_ERR_EVENTS;
805     }
806 #endif
808 #ifndef DEBUG_SKIP_DECODING
809     // Map ASIT events to decode messages
810     decMsg = asitEventsToDecMsg(asitEvents);
812     // Pass messages (corresponding to events) to decode FSM
813     decErr = decDecodeFsm(pP, pQ, pAsitCfg, pInp->sourceSelect, decMsg);
815     // Mark I/O DATA read complete if decoder indicates decoding is done.
816     if((asitEvents & ASIT_EVTMSK_DECACK)) {  // DECACK -> decoding done
817         //ioDataReadComplete(pInp->hIoData);
818     }
820     if(decErr != DEC_NO_ERR) {
821         TRACE_VERBOSE0("TaskAsip: send DEC_EXIT message to slave decoder.");
823         // Send dec exit message to slave decoder
824         status = AspMsgSnd(hAspMsgMaster, ASP_SLAVE_DEC_EXIT, NULL);
825         if (status != ASP_MSG_NO_ERR)
826         {
827             TRACE_VERBOSE0("TaskAsip: error in sending DEC_EXIT message");
828             SW_BREAKPOINT;
829         }
830         status = AspMsgRcvAck(hAspMsgMaster, ASP_MASTER_DEC_EXIT_DONE, NULL, TRUE);
831         if (status != ASP_MSG_NO_ERR) 
832         {
833             TRACE_VERBOSE0("TaskAsip: error in sending DEC_EXIT message");
834             SW_BREAKPOINT;
835         }
837         return ASIT_ERR_DECODE_QUIT;  // This is not necessarily an error
838     }
839     else {
840         return ASIT_NO_ERR;
841     }
842 #endif
843 }  /* asitDecodeProcessing */
846 /*============================================================================
847  * ASIT Input Data Processing:
848  *    - invoke ioDataProcess() to inspect input data for
849  *       - initial auto-detection,  or
850  *       - background scanning for PCM data, or
851  *       - SYNC check for bitstream
852  *    - return auto-detection status (SYNC detected, SYNC loss, etc)
853 ============================================================================*/
854 Int asitInputDataProcess(PAF_AST_IoInp *pInp, ioDataAutoDetStat_t *pAutoDetStats)
856     Int ioDataErr, retVal;
857     ioDataCtl_t ioDataCtl;
859     // Perform auto-detection inside I/O DATA component
860     ioDataErr = ioDataProcess(pInp->hIoData);
862     if(ioDataErr == IODATA_NO_ERR) {
863         // Normal operation - check auto-detection status
864         ioDataCtl.code = IODATA_CTL_GET_AUTODET_STATUS;
865         ioDataControl(pInp->hIoData, &ioDataCtl);
867         *pAutoDetStats = ioDataCtl.param.autoDetStats;
869         retVal = ASIT_NO_ERR;
870     }
871     else if(ioDataErr == IODATA_ERR_IOBUF_UNDERFLOW) {
872         // Input buffer underflows - there is no enough data to process.
873         // This is not error and no action is needed.
874         pInp->numUnderflow += 1; // debug
876         retVal = ASIT_ERR_INPBUF_UNDERFLOW;
877     }
878     else {
879         // Something is wrong: print error log and return
880         //printf("IODATA processing error!\n");
881         retVal = ASIT_ERR_INPDATA_PROC;
882     }
884     return retVal;
885 } /* asitInputDataProcess */
887 /*============================================================================
888  * Mapping ASIT Events to Decoding Messages
889 ============================================================================*/
890 UInt asitEventsToDecMsg(UInt asitEvents)
892     UInt decMsg = 0;
894     if (asitEvents & ASIT_EVTMSK_INPDATA) {
895         // Input data event
896         decMsg |= DEC_MSGMSK_INPDATA;
897     }
899     // temp, simulation
900     //if(asitEvents & ASIT_EVTMSK_INFOACK) {
901     //    decMsg |= DEC_MSGMSK_INFOACK;
902     //}
904     // temp, simulation
905     //if(asitEvents & ASIT_EVTMSK_DECACK) {
906     //    decMsg |= DEC_MSGMSK_DECACK;
907     //}
909     if (asitEvents & ASIT_EVTMSK_RXACK)
910     {
911        // Receive acknowledge message event
912         decMsg |= DEC_MSGMSK_RXACK;
913     }
914     
915     return decMsg;
916 } /* asitEventsToDecMsg */
918 /*===========================================================================
919  * Initialize I/O components for input processing
920 ============================================================================*/
921 int asitIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo)
923     ioBuffParams_t ioBuffParams;
924     ioPhyParams_t  ioPhyParams;
925     ioDataParam_t  ioDataCfg;
926     ioPhyCtl_t     ioPhyCtl;
928     if (pInpIo->hMcaspChan != NULL)
929     {
930         //pInpIo->phyXferSize = INPUT_FRAME_SIZE_DEF;
931         pInpIo->phyXferSize = pInpIo->stride * NUM_CYCLE_PER_FRAME_DEF * WORD_SIZE_BITSTREAM;
933         if (pInpIo->firstTimeInit) {
934             TRACE_VERBOSE0("Initialize I/O BUFF and I/O PHY.");
935             ioBuffParams.base         = pInpBuf->inpBufConfig.base.pVoid;
936             ioBuffParams.size         = pInpBuf->inpBufConfig.allocation / STRIDE_WORST_CASE
937                                                                          * STRIDE_WORST_CASE;
938             ioBuffParams.sync         = IOBUFF_WRITE_SYNC;
939             ioBuffParams.nominalDelay = pInpIo->phyXferSize;
940             if (ioBuffInit(pInpIo->hIoBuff, &ioBuffParams) != IOBUFF_NOERR) {
941                 return (ASIT_ERR_IOBUFF_INIT);   // to remove magic number
942             }
944             ioPhyParams.ioBuffHandle    = pInpIo->hIoBuff;
945             ioPhyParams.xferFrameSize   = pInpIo->phyXferSize;
946             ioPhyParams.mcaspChanHandle = pInpIo->hMcaspChan;
947             ioPhyParams.ioBuffOp        = IOPHY_IOBUFFOP_WRITE;
948             if (ioPhyInit(pInpIo->hIoPhy, &ioPhyParams) != IOPHY_NOERR) {
949                 return (ASIT_ERR_IOPHY_INIT);   // to remove magic number
950             }
952             pInpIo->numPrimeXfers = NUM_PRIME_XFERS;
953         }
955         /* Reinitialize I/O DATA every time when ASIT restarts */
956         TRACE_VERBOSE0("Initialize I/O DATA.");
957         ioDataCfg.ioBuffHandle         = pInpIo->hIoBuff;
958         ioDataCfg.unknownSourceTimeOut = pInpBuf->inpBufConfig.pBufStatus->unknownTimeout;
959         ioDataCfg.frameLengthsIEC      = (uint_least16_t *)&iecFrameLength[0];
960         ioDataCfg.frameLengthPCM       = pInpIo->stride * NUM_CYCLE_PER_FRAME_DEF;
961         ioDataCfg.frameLengthDef       = pInpIo->stride * NUM_CYCLE_PER_FRAME_DEF;
962         ioDataCfg.ibMode               = pInpBuf->inpBufConfig.pBufStatus->mode;
963         ioDataCfg.zeroRunRestart       = pInpBuf->inpBufConfig.pBufStatus->zeroRunRestart;
964         ioDataCfg.zeroRunTrigger       = pInpBuf->inpBufConfig.pBufStatus->zeroRunTrigger;
966         if (ioDataInit(pInpIo->hIoData, &ioDataCfg) != IODATA_NO_ERR) {
967             return (ASIT_ERR_IODATA_INIT);   // to remove magic number
968         }
970         if (pInpIo->firstTimeInit) {
971             /* Initialize I/O BUFF and I/O PHY only when input interface changes. */
972             TRACE_VERBOSE0("Prime I/O PHY.");
974             // Start I/O physical layer by priming McASP LLD for input
975             asitIoPhyPrime(pInpIo);
977             pInpIo->firstTimeInit = FALSE;
978         }
979         else {
980             // Reconfigure I/O PHY transfer size
981             ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
982             ioPhyCtl.params.xferFrameSize = pInpIo->phyXferSize;
983             ioPhyControl(pInpIo->hIoPhy, &ioPhyCtl);
984     #if 0
985             // If previous stream before reset was PCM, reconfigure McASP LLD to receive 16-bit packed bits
986             if (!pInpIo->swapData) {
987                 Int mcaspErr;
988                 mcaspErr = mcaspRecfgWordWidth(pInpIo->hMcaspChan, Mcasp_WordLength_16);
989                 if(mcaspErr != Aud_EOK) {
990                     return ASIT_ERR_MCASP_CFG;
991                 }
993                 // Start swapping data
994                 pInpIo->swapData = TRUE;
995                 TRACE_VERBOSE0("Reconfigure McASP word length and start swapping data.");
996             }
997     #endif
998             // Start PHY transfer
999             TRACE_VERBOSE0("Start I/O PHY transfer.");
1000             asitPhyTransferStart(pInpIo);
1001         }
1002     }
1004     return 0;
1005 } /* asitIoCompsInit */
1007 /*======================================================================================
1008  *  This function initializes ASIT processing
1009  *====================================================================================*/
1010 void asitProcInit(PAF_AST_IoInp  *pInp, asipDecProc_t *pDec)
1012 //    pInp->swapData = TRUE;
1013     pInp->pcmSwitchHangOver = INPUT_SWITCH_HANGOVER;
1014     pDec->initDone = FALSE;
1015     pInp->numFrameReceived    = 0;    // for debugging
1016     pInp->numPcmFrameReceived = 0;    // for debugging
1019 /*======================================================================================
1020  *  I/O physical layer prime operation required by McASP LLD
1021  *====================================================================================*/
1022 void asitIoPhyPrime(PAF_AST_IoInp *pInp)
1024     Int32        count;
1026     for(count = 0; count < pInp->numPrimeXfers; count++)
1027     {
1028         ioPhyXferSubmit(pInp->hIoPhy);
1029 #ifdef ASIP_DEBUG
1030         //pInp->numXferStart++;
1031 #endif
1032     }
1033 } /* asitIoPhyPrime */
1036 /*======================================================================================
1037  *  This function marks the I/O PHY transfer as complete
1038  *====================================================================================*/
1039 void asitPhyTransferComplete(PAF_AST_IoInp * pInpIo)
1041     // Mark underlining I/O BUFF write complete and swap data if needed
1042     ioPhyXferComplete(pInpIo->hIoPhy, pInpIo->swapData);
1043 } /* asitPhyTransferComplete */
1045 #if 0
1046 Int asitRecfgPhyXfer(PAF_AST_IoInp *pInp, size_t xferSize)
1048     ioPhyCtl_t ioPhyCtl;
1049     Int mcaspErr;
1051     ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
1052     ioPhyCtl.params.xferFrameSize = xferSize;
1053     ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
1055     pInp->phyXferSize  = ioPhyCtl.params.xferFrameSize;
1057     if(!pInp->swapData) {
1058         // If it was PCM, reconfigure McASP LLD to receive 16-bit packed bits
1059         mcaspErr = mcaspRecfgWordWidth(pInp->hMcaspChan, Mcasp_WordLength_16);
1060         if(mcaspErr != Aud_EOK) {
1061             return ASIT_ERR_MCASP_CFG;
1062         }
1064         // Start swapping data
1065         pInp->swapData = TRUE;
1066     }
1068     return ASIT_NO_ERR;
1070 } /* asitRecfgPhyXfer */
1071 #endif
1073 /*======================================================================================
1074  *  McASP LLD call back function
1075  *====================================================================================*/
1076 void asipMcaspCallback(void* arg, MCASP_Packet *mcasp_packet)
1078     /* post semaphore */
1079     if(mcasp_packet->arg == IOPHY_XFER_FINAL) {
1080         //Semaphore_post(asipSemRx);
1081         Event_post(gAsitEvtHandle, ASIT_EVTMSK_INPDATA);
1082         //Log_info0("asipMcaspCallback: final packet - event posted.\n");
1083     } else {
1084         //Log_info0("asipMcaspCallback: intermediate packet.\n");
1085         ;    // intermediate packet due to buffer wrapping around
1086     }
1089 /*======================================================================================
1090  *  This function checks if McASP Rx for input overruns
1091  *====================================================================================*/
1092 int asipCheckMcaspRxOverrun(Ptr mcaspChanHandle)
1094     Mcasp_errCbStatus mcaspErrStat;
1096     mcaspControlChan(mcaspChanHandle, Mcasp_IOCTL_CHAN_QUERY_ERROR_STATS, &mcaspErrStat);
1098     return (mcaspErrStat.isRcvOvrRunOrTxUndRunErr);
1101 #if 0
1102 /*======================================================================================
1103  *  This function restarts McASP LLD channel for input
1104  *====================================================================================*/
1105 void asipMcaspRxRestart(PAF_AST_IoInp *pInpIo)
1107     mcaspRxReset();
1108     mcaspRxCreate();
1110 #endif
1112 /*======================================================================================
1113  *  This function starts an I/O PHY transfer
1114  *====================================================================================*/
1115 void asitPhyTransferStart(PAF_AST_IoInp *pInpIo)
1117     Int ioPhyErr;
1119     if(asipCheckMcaspRxOverrun(pInpIo->hMcaspChan)) {
1120 #ifdef ASIP_DEBUG
1121         pInpIo->numInputOverrun++;
1122 #endif
1123         //asipMcaspRxRestart(pInpIo);
1124         System_abort("\nMcASP for input overruns! %d!\n");
1125     }
1126     else {
1127         //TRACE_VERBOSE0("asitPhyTransferStart: submit a transfer");
1128         ioPhyErr = ioPhyXferSubmit(pInpIo->hIoPhy);
1129         //if(ioPhyXferSubmit(pInpIo->hIoPhy)==IOPHY_ERR_BUFF_OVERFLOW) {
1130         if(ioPhyErr!=IOPHY_NOERR){
1131             printf("\n I/O PHY ioPhyXferSubmit fails with error %d!\n", ioPhyErr);
1132             // Input buffer overflows!
1133             //printf("\nInput buffer overflows!\n");
1134             exit(0);
1135         }
1136         else {
1137             // Input buffer operates normally
1138             ;
1139         }
1140 #ifdef ASIP_DEBUG
1141         //pInpIo->numXferStart++;
1142 #endif
1143     }
1146 // Indicates whether Input has been selected
1147 Int d10Initialized = 0;
1149 //extern Aud_STATUS mcaspAudioConfig(void);
1150 //extern void McaspDevice_init(void);
1152 /*======================================================================================
1153  *  This function initializes HW interface and selects the right device for input
1154  *====================================================================================*/
1155 Int asitSelectDevices(
1156     const PAF_ASIT_Patchs *pQ, 
1157     PAF_AST_Config *pAstCfg, 
1158     PAF_AST_IoInp *pInp
1161     Int32 status;
1162     Aud_STATUS audStatus;
1163     const PAF_SIO_Params *pInPrms;
1164     mcaspLLDconfig *pLldCfg;
1165     mcaspLLDconfig *pReqLldCfg;
1166     Ptr mcaspChanHandle;
1167     Int zMD;
1168     Int interface;
1169     const PAF_SIO_Params *pD10Params;
1170     UInt postedEvents;
1172     zMD = pAstCfg->masterDec;
1173     
1174     interface = pAstCfg->xInp[zMD].inpBufStatus.sioSelect; // obtain SIO select for input
1175     
1176     if (interface >= 0)
1177     {
1178         // Positive value for interface: new Input SIO update request has been received via alpha command.
1179         // Negative value for interface: no new Input SIO update request has been received,
1180         //                               previous requests have been processed.
1181         
1182         // check for valid index into device array
1183         if (interface >= pQ->devinp->n)    // DEVINP_N
1184         {
1185             interface = 0; // treat as device InNone
1186         }
1187         
1188         //
1189         // Deactivate currently active interface
1190         //
1191         if (pInp->hMcaspChan != NULL)   // non-NULL McASP LLD channel handle indicates there's an active interface
1192         {
1193             d10Initialized = 0; // indicate no Input selected
1194             
1195             // Reset channel
1196             status = mcaspControlChan(pInp->hMcaspChan, MCASP_CHAN_RESET, NULL);   // Rx reset channel
1197             //status = mcaspControlChan(pInp->hMcaspChan, MCASP_DEVICE_RESET, NULL); // Reset Tx/Rx channel
1198             if (status != MCASP_COMPLETED)
1199             {
1200                 Log_info0("asitSelectDevices(): McASP channel reset failed!\n");
1201                 return ASIP_ERR_MCASP_CFG;            
1202             }
1203             
1204             // Delete McASP LLD channel
1205             status = mcaspDeleteChan(pInp->hMcaspChan);
1206             if (status != MCASP_COMPLETED)
1207             {
1208                 Log_info0("asitSelectDevices(): McASP channel deletion failed!\n");
1209                 return ASIP_ERR_MCASP_CFG;
1210             }
1211             
1212             // Clear (drop) already posted Input data events
1213             postedEvents = Event_getPostedEvents(gAsitEvtHandle);
1214             while ((postedEvents & ASIT_EVTMSK_INPDATA) != 0)
1215             {
1216                 Event_pend(gAsitEvtHandle, ASIT_EVTMSK_NONE, ASIT_EVTMSK_INPDATA, 0);
1217                 postedEvents = Event_getPostedEvents(gAsitEvtHandle);
1218             }
1220             pInp->hMcaspChan = NULL;        // reset active McASP LLD handle
1221             if (pInp->pRxParams != NULL)    // sanity check, pInp->pRxParams should be non NULL if pInp->hMcaspChan is non NULL
1222             {
1223                 pInPrms = (const PAF_SIO_Params *)pInp->pRxParams;
1224                 pLldCfg = (mcaspLLDconfig *)pInPrms->sio.pConfig; // get pointer to active McASP LLD configuration
1225                 pLldCfg->hMcaspChan = NULL; // reset McASP LLD handle for active McASP LLD configuration
1226                 pInp->pRxParams = NULL;     // reset pointer to active D10 parameters
1227             }
1228             else 
1229             {
1230                 // This is a programming error
1231                 SW_BREAKPOINT;  // debug
1232             }
1233         }
1235         //
1236         // Activate requested interface
1237         //
1238         pD10Params = (const PAF_SIO_Params *)pQ->devinp->x[interface];  // get D10 parameters for selected interface
1239         if (pD10Params != NULL)
1240         {
1241             //
1242             // Requested device is other than InNone
1243             //
1244             if((interface == DEVINP_HDMI) || (interface == DEVINP_HDMI_STEREO))
1245             {
1246                 D10_initHDMI();
1247             }
1248             
1249             // Initialize Tx clock mux
1250             D10_initClkMux((void *)pD10Params);
1251                 
1252             pReqLldCfg = (mcaspLLDconfig *)pD10Params->sio.pConfig;
1253             if (pReqLldCfg->hMcaspChan == NULL)
1254             {
1255                 // Create McASP LLD channel
1256                 mcaspChanHandle = NULL;
1257                 audStatus = mcasplldChanCreate(pReqLldCfg, &mcaspChanHandle);
1258                 if (audStatus != Aud_EOK) 
1259                 {
1260                     Log_info0("asitSelectDevices(): McASP channel creation failed!\n");
1261                     return ASIP_ERR_MCASP_CFG;
1262                 }
1263                 
1264                 pReqLldCfg->hMcaspChan = mcaspChanHandle;   // set McASP LLD handle for requested McASP LLD configuration
1265                 pInp->pRxParams = (const void *)pD10Params; // set pointer to active D10 parameters
1266                 pInp->hMcaspChan = pReqLldCfg->hMcaspChan;  // set active McASP LLD handle
1267                 
1268                 // configure stride according to selected McASP LLD configuration
1269                 pInp->stride = pReqLldCfg->mcaspChanParams->noOfSerRequested * 
1270                     pReqLldCfg->mcaspChanParams->noOfChannels;
1271                 
1272                 pInp->firstTimeInit = TRUE; // set flag for IO Phy & Buff initialization
1273                 
1274                 d10Initialized = 1; // indicate Input selected
1275             }
1276         }
1277         else
1278         {
1279             //
1280             // Requested device is InNone
1281             //
1282             pInp->hMcaspChan = NULL;    // reset active McASP LLD handle
1283             pInp->pRxParams = NULL;     // reset pointer to active D10 parameters
1284         }
1285         
1286         // indicate SIO update request processed
1287         pAstCfg->xInp[zMD].inpBufStatus.sioSelect = interface | 0x80;
1288     }
1290     if (pInp->hMcaspChan != NULL)       // non NULL indicates there's an active interface
1291     {
1292         if (pInp->pRxParams != NULL)    // sanity check, this should be non NULL if pInp->hMcaspChan is non NULL
1293         {
1294             pInPrms = (const PAF_SIO_Params *)pInp->pRxParams;
1295             pLldCfg = (mcaspLLDconfig *)pInPrms->sio.pConfig;   // get currently active McASP LLD configuration
1296             if (pLldCfg != NULL)        // sanity check, this should be non NULL if pInp->hMcaspChan is non NULL
1297             {
1298                 // Configure McASP to receive 16/32-bit data according to default configuration
1299                 mcaspRecfgWordWidth(pInp->hMcaspChan, pLldCfg->mcaspChanParams->wordWidth);
1300                 
1301                 // Set flag to swap HDMI data if it is 4xI2S and word length is 16
1302                 if ((pLldCfg->mcaspChanParams->wordWidth == Mcasp_WordLength_16) &&
1303                     (pLldCfg->mcaspChanParams->noOfSerRequested == 4)) 
1304                 {
1305                     pInp->swapData = TRUE;
1306                 }
1307                 else 
1308                 {
1309                     pInp->swapData = FALSE;
1310                 }
1311             }
1312             else
1313             {
1314                 // This is a programming error
1315                 SW_BREAKPOINT;  // debug
1316             }
1318         }
1319         else
1320         {
1321             // This is a programming error
1322             SW_BREAKPOINT;  // debug
1323         }
1324     }
1325     
1326     return ASIP_NO_ERR;
1327 }  /* asitSelectDevices */
1329 /*======================================================================================
1330  *  This function updates input status
1331  *====================================================================================*/
1332 Int asitUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
1333                           PAF_InpBufConfig *pInpBuf)
1335     Int asipErrno;
1337     PAF_SIO_InputStatus inputStatus;
1339     // initialize all values to unknown so that device specific
1340     //   driver layer need only fill in those entries that it is aware of.
1341     //   This allows extensibility of the structure without requiring users
1342     //   to re-code.
1343     inputStatus.lock = 0;
1344     inputStatus.sampleRateData = PAF_SAMPLERATE_UNKNOWN;
1345     inputStatus.sampleRateMeasured = PAF_SAMPLERATE_UNKNOWN;
1346     inputStatus.nonaudio = PAF_IEC_AUDIOMODE_UNKNOWN;
1347     inputStatus.emphasis = PAF_IEC_PREEMPHASIS_UNKNOWN;
1349     //more configuration is needed to abstract out D10
1350     asipErrno = D10_RxControl(pRxParams,
1351                           (Uns)PAF_SIO_CONTROL_GET_INPUT_STATUS,
1352                           (Arg) &inputStatus);
1353     if (asipErrno) {
1354         return asipErrno;
1355     }
1356     pStatus->sampleRateData = inputStatus.sampleRateData;
1357     pStatus->sampleRateMeasured = inputStatus.sampleRateMeasured;
1358     pStatus->nonaudio = inputStatus.nonaudio;
1359     pStatus->emphasisData = inputStatus.emphasis;
1361     // if MSB of override clear then use as reported lock
1362     // if = 0x80 then use default [0x81]
1363     // if = 0x81 then use measured (from device)
1364     // others not defined or implemented
1365     if ((pStatus->lockOverride & (XDAS_Int8)0x80) == 0)
1366         pStatus->lock = pStatus->lockOverride;
1367     else if (pStatus->lockOverride == (XDAS_Int8)0x80)
1368         pStatus->lock = inputStatus.lock;
1369     else if (pStatus->lockOverride == (XDAS_Int8)0x81)
1370         pStatus->lock = inputStatus.lock;
1372     // if MSB of override clear then use it as sample rate for system,
1373     // if = 0x80 then use default [0x82]
1374     // if = 0x81 then use data
1375     // if = 0x82 then use measured
1376     // others not defined or implemented
1377     if ((pStatus->sampleRateOverride & (XDAS_Int8)0x80) == 0)
1378         pStatus->sampleRateStatus = pStatus->sampleRateOverride;
1379     else if (pStatus->sampleRateOverride == (XDAS_Int8)0x80)
1380         pStatus->sampleRateStatus = pStatus->sampleRateMeasured;
1381     else if (pStatus->sampleRateOverride == (XDAS_Int8)0x81)
1382         pStatus->sampleRateStatus = pStatus->sampleRateData;
1383     else if (pStatus->sampleRateOverride == (XDAS_Int8)0x82)
1384         pStatus->sampleRateStatus = pStatus->sampleRateMeasured;
1386     // Update emphasis status:
1387     if ((pStatus->emphasisOverride & (XDAS_Int8)0x80) == 0) {
1388         if (pStatus->emphasisData == PAF_IEC_PREEMPHASIS_YES)
1389             pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_YES;
1390         else
1391             pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_NO;
1392     }
1393     else if (pStatus->emphasisOverride ==
1394              (XDAS_Int8 )(0x80+PAF_IEC_PREEMPHASIS_YES))
1395         pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_YES;
1396     else /* IBEmphasisOverrideNo or other */
1397         pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_NO;
1399     // Update precision control
1400     pInpBuf->precision = pStatus->precisionInput =
1401         pStatus->precisionOverride < 0
1402         ? pStatus->precisionDefault
1403         : pStatus->precisionOverride > 0
1404         ? pStatus->precisionOverride
1405         : pStatus->precisionDetect > 0
1406         ? pStatus->precisionDetect
1407         : pStatus->precisionDefault;
1409     return 0;
1413 /*==============================================================================
1414  * This function updates input buffer config based on frame information provided
1415  * by I/O DATA.
1416  ==============================================================================*/
1417 void asitUpdateInpBufConfig(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp)
1419     PAF_InpBufConfig *pBufConfig;
1420     ioDataCtl_t ioDataCtl;
1422     /* Get information for reading input data */
1423     ioDataCtl.code = IODATA_CTL_GET_INPBUFFINFO;
1424     ioDataControl(pInp->hIoData, &ioDataCtl);
1426     if(ioDataCtl.param.dataReadInfo.frameSize != pInp->phyXferSize) {
1427         // Fatal error!
1428         TRACE_VERBOSE0("TaskAsip: error in updating I/O");
1429         SW_BREAKPOINT;
1430     }
1432     pBufConfig = &(pAstCfg->xInp[pAstCfg->masterDec].inpBufConfig);
1434     //JXTODO: do we need to gate here?
1435     //key = GateMP_enter(gateHandle);
1437     pBufConfig->base.pVoid   = ioDataCtl.param.dataReadInfo.buffBase;
1438     pBufConfig->sizeofBuffer = ioDataCtl.param.dataReadInfo.buffSize;
1439     pBufConfig->pntr.pSmInt  = ioDataCtl.param.dataReadInfo.startAddress;
1441     // Leave the gate
1442     //GateMP_leave(gateHandle, key);
1444     TRACE_TERSE2("Frame start address: 0x%x., preamble: 0x%x",
1445                  (UInt)ioDataCtl.param.dataReadInfo.startAddress,
1446                  *(UInt *)ioDataCtl.param.dataReadInfo.startAddress);
1449 /*==============================================================================
1450  * Decide source after SYNC is found, i.e. either bitstream preamble is detected
1451  * or it times out to PCM.
1452  ==============================================================================*/
1453 Int asitDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp, 
1454                      ioDataAutoDetStat_t *autoDetStatus)
1456     Int sourceConfig, sourceSelect, sourceProgram;
1457     Int zMD;
1458     char asipMsgBuf[ASP_MSG_BUF_LEN];
1459     Int status;
1461     // Get the configured source
1462     zMD = pAstCfg->masterDec;
1463     sourceConfig = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
1464                                           GATEMP_INDEX_DEC);
1466     if(autoDetStatus->syncState == IODATA_SYNC_PCM) {
1467         if (sourceConfig == PAF_SOURCE_DSD1 || sourceConfig == PAF_SOURCE_DSD2 ||
1468             sourceConfig == PAF_SOURCE_DSD3) {
1469             sourceProgram = sourceConfig;
1470         }
1471         else {
1472             sourceProgram = PAF_SOURCE_PCM;
1473         }
1474     }
1476     if(autoDetStatus->syncState == IODATA_SYNC_BITSTREAM) {
1477         uint_least16_t pc = autoDetStatus->streamInfo.IEC_PC;
1478         sourceProgram = IECpafSource[pc];
1479     }
1481     // write the decided source program to memory
1482     sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram), sourceProgram,
1483                        GATEMP_INDEX_DEC);
1485     // now that we have some input classification, and possibly an outstanding
1486     // input frame, we determine whether or not to call decodeProcessing and with
1487     // what decAlg.
1488     sourceSelect = PAF_SOURCE_NONE;
1490     switch (sourceConfig)
1491     {
1492         // If autodetecting, decoding everything, and input is something
1493         // (i.e. bitstream or PCM) then decode.
1494         case PAF_SOURCE_AUTO:
1495             if (sourceProgram >= PAF_SOURCE_PCM)  {
1496                 sourceSelect = sourceProgram; // use whatever from autodet
1497             }
1498             break;
1500         // If autodetecting, decoding only PCM, and input is PCM then decode.
1501         case PAF_SOURCE_PCMAUTO:
1502             if (sourceProgram == PAF_SOURCE_PCM) {
1503                 // only expect autodet to give PAF_SOURCE_PCM, otherwise set to NONE
1504                 sourceSelect = sourceProgram;
1505             }
1506             break;
1508         // If autodetecting, decoding only bitstreams, and input is a bitstream then decode.
1509         case PAF_SOURCE_BITSTREAM:
1510             if (sourceProgram >= PAF_SOURCE_AC3) {
1511                 sourceSelect = sourceProgram;
1512             }
1513             break;
1515         // If autodetecting, decoding only DTS, and input is DTS then decode.
1516         case PAF_SOURCE_DTSALL:
1517             switch (sourceProgram)
1518             {
1519                 case PAF_SOURCE_DTS11:
1520                 case PAF_SOURCE_DTS12:
1521                 case PAF_SOURCE_DTS13:
1522                 case PAF_SOURCE_DTS14:
1523                 case PAF_SOURCE_DTS16:
1524                 case PAF_SOURCE_DTSHD:
1525                     sourceSelect = sourceProgram;
1526                     break;
1527             }
1528             break;
1530         // All others, e.g., force modes, fall through to here.
1531         // If user made specific selection then program must match select.
1532         // (NB: this compare relies on ordering of PAF_SOURCE)
1533         default:
1534             sourceSelect = sourceConfig;
1535             if ((sourceSelect >= PAF_SOURCE_PCM) && (sourceSelect <= PAF_SOURCE_N)) {
1536                 if (sourceProgram != sourceSelect) {
1537                     sourceSelect = PAF_SOURCE_NONE;
1538                 }
1539             }
1540             break;
1541     }
1543     // if we didn't find any matches then skip
1544     if (sourceSelect == PAF_SOURCE_NONE) {
1545         TRACE_VERBOSE0("TaskAsip: no matching source type, continue");
1546         return ASIT_ERR_NO_MATCHING_SOURCE;
1547     }
1549 #ifndef DEBUG_SKIP_DECODING
1550     // send source select message to slave
1551     *(Int32 *)&asipMsgBuf[0] = sourceSelect;
1552     status = AspMsgSnd(gPAF_ASIT_config.hAspMsgMaster, ASP_SLAVE_DEC_SOURCE_SELECT, asipMsgBuf);
1553     if (status != ASP_MSG_NO_ERR) 
1554     {
1555         TRACE_VERBOSE0("TaskAsip: error in sending SOURCE_SELECT message");
1556         SW_BREAKPOINT;
1557     }
1558     status = AspMsgRcvAck(gPAF_ASIT_config.hAspMsgMaster, ASP_MASTER_DEC_SOURCE_SELECT_DONE, NULL, TRUE);
1559     if (status != ASP_MSG_NO_ERR)
1560     {
1561         TRACE_VERBOSE0("TaskAsip: error in receiving SOURCE_SELECT ack message");
1562         SW_BREAKPOINT;
1563     }
1564 #endif
1566     pInp->sourceSelect  = sourceSelect;
1567     pInp->sourceProgram = sourceProgram;
1569     return ASIT_NO_ERR;
1570 } /* asitDecideSource */
1572 /*==============================================================================
1573  * After SYNC is found, i.e. either bitstream preamble is detected or it times
1574  * out to PCM, update input buffer config and I/o components accordingly.
1575  ==============================================================================*/
1576 Int asitUpdateIoComps(const PAF_ASIT_Params *pP, PAF_AST_Config *pAstCfg,
1577                       PAF_AST_IoInp  *pInp, ioDataAutoDetStat_t *autoDetStatus)
1579     Int sourceConfig;
1580     Int zMD, deliverZeros;
1581     int ioFrameLength, decFrameLength;
1582     PAF_InpBufConfig *pBufConfig;
1583     ioPhyCtl_t  ioPhyCtl;
1584     ioDataCtl_t ioDataCtl;
1586     zMD = pAstCfg->masterDec;
1587     pBufConfig = &pAstCfg->xInp[zMD].inpBufConfig;
1589     // Compute decoder frame length based on source selection
1590     decFrameLength = getFrameLengthSourceSel(pP, pInp->sourceSelect);
1592     pAstCfg->xDec[zMD].decodeControl.frameLength  = decFrameLength;
1593     pAstCfg->xDec[zMD].decodeInStruct.sampleCount = decFrameLength;
1594     pAstCfg->xDec[zMD].decodeControl.sampleRate   = PAF_SAMPLERATE_UNKNOWN;
1596     // Decide frame length for I/O DATA and I/O PHY
1597     if(autoDetStatus->syncState == IODATA_SYNC_PCM) {
1598         // For PCM, I/O frame length is decode frame length multiplied by stride
1599         ioFrameLength = decFrameLength * pInp->stride;
1601         pBufConfig->sizeofElement = WORD_SIZE_PCM;
1602         pBufConfig->frameLength   = pBufConfig->lengthofData = ioFrameLength;
1604         // Configure I/O DATA PCM frame length
1605         ioDataCtl.code = IODATA_CTL_SET_PCM_FRAME_LENGTH;
1606         ioDataCtl.param.frameLengthPcm = ioFrameLength;
1607         ioDataControl(pInp->hIoData, &ioDataCtl);
1609         // Change I/O PHY transfer size to PCM frame size
1610         pInp->phyXferSize = ioFrameLength*(WORD_SIZE_PCM);
1612         // Adjust I/O BUFF delay and read pointer - to make sure read pointers always point to
1613         // PCM data from 1st I2S (out of 4 for HDMI 4xI2S)
1614         // Adjust delay and don't mark input buffer as read complete
1615         //ioBuffAdjustDelay(pInp->hIoBuff, pInp->phyXferSize);
1617         // Stop swapping data
1618         //pInp->swapData = FALSE;
1619     }
1620     else {
1621         // For bitstream, I/O frame length is the frame length of the bitstream
1622         pBufConfig->sizeofElement = WORD_SIZE_BITSTREAM;
1623         pBufConfig->frameLength   = autoDetStatus->streamInfo.frameLength;
1624         pBufConfig->lengthofData  = autoDetStatus->streamInfo.dataLength;
1625         ioFrameLength = autoDetStatus->streamInfo.frameLength;
1627         // Change I/O PHY transfer size to bitstream frame size
1628         pInp->phyXferSize = ioFrameLength*(WORD_SIZE_BITSTREAM);
1629     }
1631     pBufConfig->stride = pInp->stride;   // common for PCM and bitstream
1633     // Configure I/O PHY transfer size
1634     ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
1635     ioPhyCtl.params.xferFrameSize = pInp->phyXferSize;
1636     ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
1638     // Decide if zeros should be delivered based on the configured source
1639     sourceConfig = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
1640                                           GATEMP_INDEX_DEC);
1642     // temporary - does ARM use hRxSio or just check if it is not NULL?
1643     pAstCfg->xInp[zMD].hRxSio = pInp->hIoData;
1644     pAstCfg->xInp[zMD].pInpBuf = &(pAstCfg->xInp[zMD].inpBufConfig);
1646     return ASIT_NO_ERR;
1647 } /* asitUpdateIoComps */
1649 #if 0
1650 #ifndef IO_LOOPBACK_TEST
1651 #if OUTPUT_FRAME_LENGTH == INPUT_FRAME_LENGTH
1652 U8 pcmbuf[OUTPUT_FRAME_SIZE];
1653 #else
1654 #error Input frame length is not equal to output frame length!
1655 #endif
1657 Int rxDecodePcm(PAF_AST_IoInp  *pInp)
1659     ioDataCtl_t ioDataCtl;
1660     void *buffBase;
1661     void *dataStartAddress;
1662     size_t buffSize, frameSize, size1, size2;
1664     /* Get information for reading input data */
1665     ioDataCtl.code = IODATA_CTL_GET_INPBUFFINFO;
1666     ioDataControl(pInp->hIoData, &ioDataCtl);
1668     buffBase = ioDataCtl.param.dataReadInfo.buffBase;
1669     buffSize = ioDataCtl.param.dataReadInfo.buffSize;
1670     dataStartAddress = ioDataCtl.param.dataReadInfo.startAddress;
1671     frameSize        = ioDataCtl.param.dataReadInfo.frameSize;
1673     // Copy PCM data to output buffer
1674     if(((size_t)dataStartAddress+frameSize) <= ((size_t)buffBase+buffSize)) {
1675         // Input buffer doesn't wrap around
1676         Cache_inv(dataStartAddress, frameSize, Cache_Type_ALL, TRUE);
1677         memcpy((void *)&pcmbuf[0], dataStartAddress, frameSize);
1678     }
1679     else {
1680         // Input buffer wraps around
1681         size1 = (size_t)buffBase + buffSize - (size_t)dataStartAddress;
1682         size2 = frameSize - size1;
1683         Cache_inv(dataStartAddress, size1, Cache_Type_ALL, TRUE);
1684         memcpy((void *)&pcmbuf[0], dataStartAddress, size1);
1686         Cache_inv(buffBase, size2, Cache_Type_ALL, TRUE);
1687         memcpy((void *)&pcmbuf[size1], buffBase, size2);
1688     }
1691     return ASIT_NO_ERR;
1695 Int rxDecodePlayZero(PAF_AST_IoInp  *pInp)
1697     return ASIT_NO_ERR;
1699 #endif
1701 #endif
1703 Int asitEvtErrCheck(UInt actualEvents, UInt expectedEvents)
1705     TRACE_VERBOSE2("ASIT events error: actual events are: %d, expected events are: %d.",
1706                    actualEvents, expectedEvents);
1708     return ASIT_ERR_EVENTS;
1711 void asitErrorHandling(PAF_ASIT_Config *pAsitCfg, Int asitErr)
1713     //UInt events;
1715     if(asitErr == ASIT_ERR_INPBUF_UNDERFLOW) {
1716         TRACE_VERBOSE0("ASIT error handling: input buffer underflows. No actions needed.");
1717     }
1719     if(asitErr == ASIT_AUTODET_TIME_OUT) {
1720         pAsitCfg->pIoInp[0].asipState = ASIT_RESET;
1721         pAsitCfg->pIoInp[0].numAsitRestart++;
1722         TRACE_VERBOSE1("ASIT error %d handling finished. Go to state ASIT_RESET.", asitErr);
1723     }
1724     
1725     if(asitErr == ASIT_ERR_DECODE_QUIT) {
1726         TRACE_VERBOSE0("ASIT error handling: DECODE_QUIT - clear INPDATA event.");
1727 #if 0
1728         // Pend on INPTDATA event that should have been posted before decoding quits.
1729         events = Event_pend(asitEvent, ASIT_EVTMSK_NONE, ASIT_EVTMSK_INPDATA,
1730                             BIOS_WAIT_FOREVER);
1732         // Marks I/O PHY transfer and I/O BUFF write complete
1733         asitPhyTransferComplete(&pAsitCfg->pIoInp[0]);
1735         // Keep I/O BUFF read pointers going
1736         asitBypassIoData(&pAsitCfg->pIoInp[0]);
1737 #endif
1738         pAsitCfg->pIoInp[0].asipState = ASIT_RESET;
1739         pAsitCfg->pIoInp[0].numAsitRestart++;
1740         TRACE_VERBOSE1("ASIT error %d handling finished. Go to state ASIT_RESET.", asitErr);
1741     }
1743     if(asitErr == ASIT_ERR_EVENTS) {
1744         pAsitCfg->pIoInp[0].asipState = ASIT_RESET;
1745         pAsitCfg->pIoInp[0].numAsitRestart++;
1746         TRACE_VERBOSE1("ASIT error %d handling: events error. Go to state ASIT_RESET.", asitErr);
1747     }
1749     return;
1750 }  /* asitErrorHandling */
1753 //////////////////////////////////////////////////////////////////////////////
1754 void asitPostInfoEvent()
1756     Event_post(gAsitEvtHandle, ASIT_EVTMSK_INFOACK);
1759 void asitPostDecEvent()
1761     Event_post(gAsitEvtHandle, ASIT_EVTMSK_DECACK);
1763 //////////////////////////////////////////////////////////////////////////////
1765 /* Nothing past this line */