Merge branch 'dev_pasdk_frank_pasdk516AsotRefactoring' into dev_pasdk_pasdk29Integration
[processor-sdk/performance-audio-sr.git] / pasdk / test_dsp / framework / audioStreamInpProcNewIO.c
index 3afb532b2621401c4e757f293791bfe528f29b3e..3db43196fd95135dd0c57e1df4c8330596d30a81 100644 (file)
@@ -38,6 +38,8 @@ All rights reserved.
  */
 #include <xdc/runtime/Log.h>
 #include <ti/sysbios/BIOS.h>
+#include <xdc/runtime/Error.h>
+#include <ti/sysbios/knl/Event.h>
 
 #include "procsdk_audio_typ.h"
 #include "audioStreamInpProc.h"
@@ -58,6 +60,8 @@ All rights reserved.
 
 #define STRIDE_WORST_CASE 32  // 4-byte (32-bit) word, 2 slots, 4 serializers
 
+//#define DEBUG_SKIP_DECODING
+
 #define SYNC_PC_MASK         0x1F
 #define SYNC_SUBTYPE_MASK    0x700
 #define SYNC_SUBTYPE_SHIFT   8
@@ -112,46 +116,64 @@ extern XDAS_Int32 D10_RxControl(const void *pD10RxParams,
 /*
  * Functions only used in this file
  */
-int asipPrepareProcessing();
-int asipIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo);
-void asipProcInit(PAF_AST_IoInp  *pInp, asipDecProc_t *pDec);
-void asipIoPhyPrime(PAF_AST_IoInp *pInpIo);
-void asipPhyTransferPend(void);
-void asipPhyTransferComplete(PAF_AST_IoInp * pInpIo);
-void asipPhyTransferStart(PAF_AST_IoInp *pInpIo);
-Int asipSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp);
-Int asipUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
+int asitPrepareProcessing();
+int asitIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo);
+void asitProcInit(PAF_AST_IoInp  *pInp, asipDecProc_t *pDec);
+void asitIoPhyPrime(PAF_AST_IoInp *pInpIo);
+void asitPhyTransferComplete(PAF_AST_IoInp * pInpIo);
+void asitPhyTransferStart(PAF_AST_IoInp *pInpIo);
+Int asitRecfgPhyXfer(PAF_AST_IoInp *pInp, size_t xferSize);
+Int asitSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp);
+Int asitUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
                           PAF_InpBufConfig *pInpBuf);
 
-//Int asipDecideSource(const PAF_ASIT_Params *pP, PAF_AST_Config *pAstCfg, asipDecProc_t *pDec);
-Int asipProcessing(const PAF_ASIT_Params *pP,
-                   const PAF_ASIT_Patchs *pQ,
-                   PAF_ASIT_Config *pAsitCfg);
-void asipErrorHandling(PAF_AST_Config *pAstCfg, int asipErrno);
+Int asitSourceDetection(const PAF_ASIT_Params *pP,
+                        const PAF_ASIT_Patchs *pQ,
+                        PAF_ASIT_Config       *pAsitCfg);
+
+Int asitDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
+                     ioDataAutoDetStat_t *autoDetStatus);
+Int asitUpdateIoComps(const PAF_ASIT_Params *pP, PAF_AST_Config *pAstCfg,
+                      PAF_AST_IoInp  *pInp, ioDataAutoDetStat_t *autoDetStatus);
+Int asitBypassIoData(PAF_AST_IoInp *pInp);
+Int asitPcmTransition(PAF_ASIT_Config *pAsitCfg);
+
+void asitUpdateInpBufConfig(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp);
+Int asitInputDataProcess(PAF_AST_IoInp *pInp, ioDataAutoDetStat_t *pAutoDetStats);
+
+UInt asitEventsToDecMsg(UInt asitEvents);
+void asitErrorHandling(PAF_ASIT_Config *pAsitCfg, Int asitErr);
+Int asitEvtErrCheck(UInt actualEvents, UInt expectedEvents);
+
+void asitPostInfoEvent();
+void asitPostDecEvent();
 
 /*
  * variables/structures to be put into proper global structures
  */
-extern Semaphore_Handle asipSemRx;
 extern PAF_ASIT_Config gPAF_ASIT_config;
 extern const MdUns iecFrameLength[23];
 extern Ptr hMcaspRxChan;
 
-
-enum
-{
-    ASIP_SOURCE_DETECTION,
-    ASIP_DECODE,
-    ASIP_SWITCH_TO_PCM,
+enum {
+    ASIT_RESET,
+    ASIT_SOURCE_DETECTION,
+    ASIT_PCM_TRANSITION,
+    ASIT_DECODE_PROCESSING
 };
 
-enum
-{
-    ASIP_INPUT_PREPARATION,
-    ASIP_INPUT_PROCESSING
-};
+#define ASIT_EVTMSK_NONE        0x0
+#define ASIT_EVTMSK_INPDATA     0x1
+#define ASIT_EVTMSK_INFOACK     0x2
+#define ASIT_EVTMSK_DECACK      0x4
 
+#define ASIT_ALL_EVENTS (  ASIT_EVTMSK_INPDATA \
+                         + ASIT_EVTMSK_INFOACK \
+                         + ASIT_EVTMSK_DECACK )
 
+#define ASIT_DEC_EVENTS (  ASIT_EVTMSK_INPDATA \
+                         + ASIT_EVTMSK_INFOACK \
+                         + ASIT_EVTMSK_DECACK )
 
 #define ASIP_DEBUG
 
@@ -165,6 +187,9 @@ Int inputReadyForProcessing;
 #include "evmc66x_gpio_dbg.h"
 #endif
 
+Event_Handle asitEvent;
+Int eventsOn;
+
 /*
  *  ======== taskAsipFxn ========
  *  Audio Stream Input Processing task function
@@ -192,13 +217,21 @@ int asipLoopCount1, asipLoopCount2;
 Int asipErrno;
 Int inputReadyForProcessing;
 #endif
-
-    Int firstTimeInit = TRUE;
+    Int asitErr;
+    UInt events;
+//    Int eventsOn;
+    Error_Block  eb;
 
     Log_info0("Enter taskAsipFxn()");
 
     taskAsipFxnInit(pP, pQ);  // initialization of input task
     
+    Error_init(&eb);          // initialize error block
+
+    asitEvent = Event_create(NULL, &eb);
+    if (asitEvent == NULL) {
+        System_abort("Event create failed");
+    }
     //
     // Audio Stream Input Task Configuration (*pAsitCfg):
     //
@@ -219,23 +252,33 @@ Int inputReadyForProcessing;
         TRACE_VERBOSE1("TaskAsip: AS%d: running", as+z);
     }
 
-    TRACE_TERSE0("TaskAsip: Entering Main Loop.");
+    Log_info0("TaskAsip: Entering Main Loop.");
 
     //
     // Main processing loop
     //
     asipLoopCount1 = 0;
     asipLoopCount2 = 0;
-    asipErrno = 0;
-    pInp->asipState = ASIP_INPUT_PREPARATION;
+    asitErr = ASIT_NO_ERR;
+    pInp->asipState = ASIT_RESET;
+    pInp->firstTimeInit = TRUE;
+    pInp->numAsitRestart = 0;
+
+    // The events_on flag will be removed if the RESTART state is changed to
+    // event-based scheduling instead of polling
+    eventsOn = FALSE;
 
     for (;;)
     {
         asipLoopCount1++;
 
+        if(eventsOn) {
+            events = Event_pend(asitEvent, ASIT_EVTMSK_NONE, ASIT_ALL_EVENTS,
+                                BIOS_WAIT_FOREVER);
+        }
         switch (pInp->asipState)
         {
-        case ASIP_INPUT_PREPARATION:
+        case ASIT_RESET:    // No events pending in this state
             // Indicate decoder no decoding yet
             pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_NONE);
 
@@ -243,76 +286,90 @@ Int inputReadyForProcessing;
             // event based scheduling.
             Task_sleep(5);
 
-            inputReadyForProcessing = asipPrepareProcessing(pP, pQ, pAsitCfg, &asipErrno);
+            inputReadyForProcessing = asitPrepareProcessing(pP, pQ, pAsitCfg, &asipErrno);
             if (inputReadyForProcessing) {
+                TRACE_VERBOSE0("TaskAsip: Input is ready. Initialize I/O components.");
                 // Input is ready for processing, so we initialize the I/O components.
-                // Note that the I/O components init. and I/O PHY prime are performed only at the
-                // first time. This should be changed later - init. and prime should be done whenever
-                // input interface has changed.
-                if(firstTimeInit) {
-                    asipIoCompsInit(&pAstCfg->xInp[zMI], pInp);
-
-                    // Start I/O physical layer by priming McASP LLD for input
-                    asipIoPhyPrime(pInp);
-
-                    firstTimeInit = FALSE;
-                }
-
-                // Initialize ASIP processing
-                asipProcInit(pInp, &pAsitCfg->inpDec);
-
-                pInp->asipState = ASIP_INPUT_PROCESSING;
+                // Note that the I/O components init. and I/O PHY prime are performed only
+                // at the first time. This should be changed later - init. and prime
+                // should be done whenever input interface has changed.
+                asitErr = asitIoCompsInit(&pAstCfg->xInp[zMI], pInp);
+
+                // Initialize ASIT processing
+                asitProcInit(pInp, &pAsitCfg->inpDec);
+                pInp->asipState = ASIT_SOURCE_DETECTION;
+                eventsOn = TRUE;   // turn on events pending
+                TRACE_VERBOSE0("TaskAsip: turn on events and go to source detection.");
             }
             break;
 
-        case ASIP_INPUT_PROCESSING:
-            // Pending on I/O PHY transfer
-            asipPhyTransferPend();
-
-#if 1 // (***) FL: shows timing of Input (Rx McASP EDMA) after decoding has started (autodet complete)
-            // (***) debug // B5
-            {
-                static Uint8 toggleState = 0;
-                if (toggleState == 0)
-                    GPIOSetOutput(GPIO_PORT_0, GPIO_PIN_99);
-                else
-                    GPIOClearOutput(GPIO_PORT_0, GPIO_PIN_99);
-                toggleState = ~(toggleState);
+        case ASIT_SOURCE_DETECTION:
+            // Source unknown - to detect & identify source
+            if(events == ASIT_EVTMSK_INPDATA) {  
+                // Only this event is expected. If any other event, it's error.
+                // Input data is ready - perform source detection.
+                // New state will be decided inside the function
+                asitErr = asitSourceDetection(pP, pQ, pAsitCfg);
+            }
+            else {
+                //Error checking & debug
+                asitErr = asitEvtErrCheck(events, ASIT_EVTMSK_INPDATA);
             }
-#endif            
-            
-            // Marks I/O PHY transfer and I/O BUFF write complete
-            asipPhyTransferComplete(pInp);
-
-            // Main function to process input data
-            asipErrno = asipProcessing(pP, pQ, pAsitCfg);
-
-            // Start next transfer
-            asipPhyTransferStart(pInp);
 
-            if(asipErrno) {
-                asipErrorHandling(pAstCfg, asipErrno);
+            break;
 
-                pInp->asipState = ASIP_INPUT_PREPARATION;
+        case ASIT_PCM_TRANSITION:
+            // Source is PCM - transition to PCM decoding
+            if(events == ASIT_EVTMSK_INPDATA) {
+                // Only this event is expected. If any other event, it's error.
+                // Input data is ready - transition to PCM decoding
+                // New state will be decided inside the function
+                asitErr = asitPcmTransition(pAsitCfg);
+            }
+            else {
+                //Error checking & debug
+                asitErr = asitEvtErrCheck(events, ASIT_EVTMSK_INPDATA);
             }
+            break;
 
+        case ASIT_DECODE_PROCESSING:
+            if(events & ASIT_DEC_EVENTS) {
+                // Decode processing for either PCM or bitstream
+                // New state will be decided inside the function
+                asitErr = asitDecodeProcessing(pP, pQ, pAsitCfg, events);
+            }
+            else {
+                //Error checking & debug
+                asitErr = asitEvtErrCheck(events, ASIT_DEC_EVENTS);
+            }
             break;
 
         default:
             break;
         }
+
+        if(asitErr) {
+            asitErrorHandling(pAsitCfg, asitErr);
+
+            if(pInp->asipState == ASIT_RESET) {
+                eventsOn = FALSE;
+            }
+
+            asitErr = ASIT_NO_ERR;
+        }
+
     }  // for (;;)
 
 }  /* taskAsipFxn */
 
 
 /*===========================================================================
- * ASIP processing preparation
+ * ASIT Processing Preparation
  * Output:
  *        - return        TRUE (input is ready) or FALSE (input is not ready)
- *        - *asipErrno        Error number
+ *        - *asipErrno    Error number
 ============================================================================*/
-Int asipPrepareProcessing(const PAF_ASIT_Params *pP,
+Int asitPrepareProcessing(const PAF_ASIT_Params *pP,
                           const PAF_ASIT_Patchs *pQ,
                           PAF_ASIT_Config       *pC,
                           Int                   *asipErrno)
@@ -332,9 +389,10 @@ Int asipPrepareProcessing(const PAF_ASIT_Params *pP,
     *asipErrno = 0;
 
     // Select source and initialize physical layer / HW interface
-    *asipErrno = asipSelectDevices(pQ, pInp);
+    *asipErrno = asitSelectDevices(pQ, pInp);
     if (*asipErrno) {
-        TRACE_TERSE2("TaskAsip: selectDevices returned asipErrno = 0x%04x at line %d. AS%d", *asipErrno, as+zMS);
+        TRACE_TERSE2("asitSelectDevices returned asipErrno = 0x%04x at line %d. AS%d",
+                     *asipErrno, as+zMS);
         return FALSE;    // Input is not ready for processing due to error
     }
 
@@ -349,7 +407,7 @@ Int asipPrepareProcessing(const PAF_ASIT_Params *pP,
     }
 
     // If here then we have a valid input so query its status
-    *asipErrno = asipUpdateInputStatus(pInp[zMI].pRxParams,
+    *asipErrno = asitUpdateInputStatus(pInp[zMI].pRxParams,
                                    &pAstCfg->xInp[zMI].inpBufStatus,
                                    &pAstCfg->xInp[zMI].inpBufConfig);
     if(*asipErrno) {
@@ -389,7 +447,8 @@ Int asipPrepareProcessing(const PAF_ASIT_Params *pP,
             *asipErrno = pP->fxns->passProcessing(pP, pQ, pC, NULL);
         }
         else {
-            TRACE_TERSE2("TaskAsip: AS%d: Pass Processing not supported, asipErrno 0x%x", as+zMS, ASPERR_PASS);
+            TRACE_TERSE2("TaskAsip: AS%d: Pass Processing not supported, asipErrno 0x%x",
+                         as+zMS, ASPERR_PASS);
             *asipErrno = ASPERR_PASS;
         }
 
@@ -399,34 +458,437 @@ Int asipPrepareProcessing(const PAF_ASIT_Params *pP,
 
     // No error and input processing is ready
     return TRUE;
-} /* asipPrepareProcessing */
+} /* asitPrepareProcessing */
+
+
+/*===========================================================================
+ * ASIT Source Detection:
+ *     ASIT processing for input source identification:
+ *     - mark I/O PHY transfer completion
+ *     - run auto-detection via I/O DATA in asitInputDataProcess
+ *     - mark I/O DATA read completion
+ *     - check auto-detection status and take corresponding actions if either
+ *       PCM or bitstream is identified:
+ *       - decide input source
+ *       - update I/O components
+ *       - reconfigure McASP LLD if it is PCM
+ *     - start next I/O PHY transfer
+============================================================================*/
+Int asitSourceDetection(const PAF_ASIT_Params *pP,
+                        const PAF_ASIT_Patchs *pQ,
+                        PAF_ASIT_Config       *pAsitCfg)
+{
+    PAF_AST_Config  *pAstCfg;
+    PAF_AST_IoInp *pInp;            /* I/O components for input */
+    Int zMD, mcaspErr, asitErr;
+    ioDataAutoDetStat_t autoDetStatus;
+
+    pAstCfg  = pAsitCfg->pAstCfg;         // pointer to AST common (shared) configuration
+    zMD = pAstCfg->masterDec;
+    pInp = &pAsitCfg->pIoInp[zMD];        // pointer to input I/O components
+
+    // Marks I/O PHY transfer and I/O BUFF write complete
+    asitPhyTransferComplete(pInp);
+
+    // Process input data - either searching SYNC for PCM or checking SYNC for bitstream
+    asitErr = asitInputDataProcess(pInp, &autoDetStatus);
+    if(asitErr != ASIT_NO_ERR) {
+        // Even though there is error, still need to start next transfer to
+        // maintain McASP transfer.
+        asitPhyTransferStart(pInp);
+
+        return asitErr;
+    }
+
+    // Mark input data read complete
+    ioDataReadComplete(pInp->hIoData);
+
+    // Check if bitstream or PCM is detected
+    if(   autoDetStatus.syncState == IODATA_SYNC_BITSTREAM
+       || autoDetStatus.syncState == IODATA_SYNC_PCM) {
+        // Decide input source and inform decoder
+        asitErr = asitDecideSource(pAstCfg, pInp, &autoDetStatus);
+        if(asitErr != ASIT_NO_ERR) {
+            return asitErr;
+        }
+        else {
+            // Update I/O components and input buffer config
+            asitUpdateIoComps(pP, pAstCfg, pInp, &autoDetStatus);
+
+            // set to unknown so that we can ensure, for IOS purposes, that
+            // sourceDecode = NONE iff we are in this top level state machine
+            // and specifically not in decodeProcessing
+#ifndef DEBUG_SKIP_DECODING
+            pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_UNKNOWN);
+#endif
+
+            if(autoDetStatus.syncState == IODATA_SYNC_BITSTREAM) {
+                // Input is bit stream: go to decoding
+                pInp->asipState = ASIT_DECODE_PROCESSING;
+            }
+            else  {
+                // Input is PCM: stop swapping data
+                pInp->swapData = FALSE;
+
+                // Reconfigure McASP LLD to transfer 32-bit unpacked data
+                mcaspErr = mcaspRecfgWordWidth(pInp->hMcaspChan, Mcasp_WordLength_32);
+                if(mcaspErr != Audk2g_EOK) {
+                    return ASIT_ERR_MCASP_CFG;
+                }
+
+                // Adjust I/O BUFF delay and read pointer - to make sure read pointers
+                // always point to PCM data from 1st I2S (out of 4 for HDMI 4xI2S)
+                ioBuffAdjustDelay(pInp->hIoBuff, pInp->phyXferSize);
+
+                // Go to transition state to switch to PCM
+                pInp->asipState = ASIT_PCM_TRANSITION;
+            }
+        }
+    }
+
+    // Start next transfer
+    asitPhyTransferStart(pInp);
+
+    return (ASIT_NO_ERR);
+}  /* asitSourceDetection */
+
+
+/*===========================================================================
+    //
+    // which will cause all 0's in one McASP LLD transfer. This will
+    // be detected as loss of SYNC by auto detection. To prevent that,
+    // skip I/O DATA process for hangover period so that this all 0's
+    // frame will not be seen by auto-detection. Also, playing out PCM
+    // needs to be skipped as well, to prevent from playing out garbage
+    // (16-bit packed data).
+ *
+ * ASIT Transition to PCM decoding.
+ *     When PCM is detected, McASP LLD will be reconfigured to transmit 32-bit
+ *     words, which will modify the RFMT register. This will cause all 0's in
+ *     one McASP LLD transfer, which would be detected as loss of SYNC by auto
+ *     detection (performed by I/O DATA). To prevent that, skip I/O DATA process
+ *     for hangover period so that this all-0's frame will not be seen by the
+ *     auto-detection.
+ *
+ *     In addition, playing out PCM should be skipped as well to prevent from
+ *     playing out the 16-bit packed data that's still in the input buffer.
+ *
+ *     This function does the following:
+ *     - mark I/O PHY transfer completion
+ *     - bypass I/O DATA
+ *     - start next I/O PHY transfer
+============================================================================*/
+Int asitPcmTransition(PAF_ASIT_Config *pAsitCfg)
+{
+    Int asitErr;
+    PAF_AST_IoInp *pInp;                  // I/O components for input
+    Int zMD;
+
+    zMD = pAsitCfg->pAstCfg->masterDec;   // pointer to AST common (shared) configuration
+    pInp = &pAsitCfg->pIoInp[zMD];        // pointer to input I/O components
+
+    // Marks I/O PHY transfer and I/O BUFF write complete
+    asitPhyTransferComplete(pInp);
+
+    // Bypass I/O data processing due to McASP LLD work around
+    // (refer to comments inside the function)
+    asitErr = asitBypassIoData(pInp);
+
+    pInp->pcmSwitchHangOver--;
+    if(pInp->pcmSwitchHangOver == 0) {
+        pInp->asipState = ASIT_DECODE_PROCESSING;
+    }
+    else {
+        ; // stay in this state
+    }
+
+    // Start next transfer
+    asitPhyTransferStart(pInp);
+
+    return asitErr;
+
+} /* asitPcmTransition */
+
+/*============================================================================
+ * ASIT Bypass I/O DATA Processing
+ *     This function bypasses the I/O DATA processing. It maintains the read
+ *     operation of I/O BUFF by directly calling I/O BUFF APIs. When I/O DATA
+ *     is not bypassed, I/O BUFF read operation is invoked by I/O DATA.
+ *
+============================================================================*/
+Int asitBypassIoData(PAF_AST_IoInp *pInp)
+{
+    void *buff1, *buff2;
+    size_t size1, size2;
+
+    // Get read pointers (or sub-buffers) of the input buffer
+    if (ioBuffGetReadPtrs(pInp->hIoBuff, pInp->phyXferSize,
+                          &buff1, &size1, &buff2, &size2)
+        == IOBUFF_ERR_UNDERFLOW) {
+        pInp->numUnderflow += 1;
+
+        // Return since there is no enough data to process
+        return ASIT_ERR_INPBUF_UNDERFLOW;
+    }
+
+    ioBuffReadComplete(pInp->hIoBuff, buff1, size1);
+
+    if(buff2 != NULL) {
+        ioBuffReadComplete(pInp->hIoBuff, buff2, size2);
+    }
+
+    return ASIP_NO_ERR;
+} /* asitBypassIoData */
+
+
+/*============================================================================
+ * ASIT Decode Processing
+ *     This function performs the decode processing and does the following based
+ *     on the ASIT events:
+ *     - initialize the decode processing if it is the first time
+ *     - if there is ASIT INPUT DATA event (ASIT_EVTMSK_INPDATA):
+ *        - mark I/O PHY transfer completion
+ *        - run auto-detection via I/O DATA in asitInputDataProcess
+ *        - check auto-detection status and take corresponding actions if SYNC
+ *          is lost.
+ *        - start next I/O PHY transfer
+ *     - map ASIT events to decoding messages
+ *     - invoke decDecodeFsm() and pass the mapped decoding messages
+ *     - if there is ASIT DECODE ACK event (ASIT_EVTMSK_DECACK)
+ *        - mark I/O DATA read completion
+ *     - error handling
+============================================================================*/
+Int asitDecodeProcessing(const PAF_ASIT_Params *pP,
+                         const PAF_ASIT_Patchs *pQ,
+                         PAF_ASIT_Config       *pAsitCfg,
+                         UInt asitEvents)
+{
+    Int asitErr, decErr;
+    PAF_AST_IoInp *pInp;                  // I/O components for input
+    asipDecProc_t *pDec;
+    ioDataAutoDetStat_t autoDetStatus;
+    Int zMD;
+    UInt decMsg;
+
+    zMD = pAsitCfg->pAstCfg->masterDec;   // pointer to AST common (shared) configuration
+    pInp = &pAsitCfg->pIoInp[zMD];        // pointer to input I/O components
+    pDec = &pAsitCfg->inpDec;
+
+    // Initialization for decode processing when this function is called the first time
+#ifndef DEBUG_SKIP_DECODING
+    if(!pDec->initDone) {
+        // Initialize decoder
+        decDecodeInit(pP, pAsitCfg, pInp->sourceSelect);
+
+        pDec->initDone = TRUE;
+    }
+#endif
+
+    // Process input data if this is a data ready message
+    if(asitEvents & ASIT_EVTMSK_INPDATA) {
+        TRACE_TERSE0("asitDecodeProcessing: process input data.");
+
+        // Marks I/O PHY transfer and I/O BUFF write complete
+        asitPhyTransferComplete(pInp);
+
+        // Process input data - either search SYNC for PCM or check SYNC for bitstream
+        asitErr = asitInputDataProcess(pInp, &autoDetStatus);
+
+        if(asitErr == ASIT_NO_ERR) {
+            ioDataReadComplete(pInp->hIoData);
+
+            // Check if SYNC is maintained or lost (stream stops or format changes)
+            if(autoDetStatus.syncState == IODATA_SYNC_NONE) {
+                // SYNC lost: change I/O PHY transfer size to default for auto-detection
+                //asitErr = asitRecfgPhyXfer(pInp, INPUT_FRAME_SIZE_DEF);
+                //if(asitErr != ASIT_NO_ERR) {
+                //    return asitErr;
+                //}
+
+                // Inform decoder to complete the decoding of previous frame - is this good?
+                pInp->sourceSelect = PAF_SOURCE_NONE;
+                pInp->numFrameReceived = 0;    // for debugging
+                TRACE_TERSE0("asitDecodeProcessing: SYNC lost.");
+
+#ifdef DEBUG_SKIP_DECODING
+                asitErr = ASIT_ERR_DECODE_QUIT;
+#endif
+            }
+            else {
+                pInp->numFrameReceived += 1;    // for debugging
+
+                // Communicate input stream information to decoder through input
+                // buffer configuration
+                asitUpdateInpBufConfig(pAsitCfg->pAstCfg, pInp);
+
+                // Start next transfer
+                asitPhyTransferStart(pInp);
+            }
+
+            // Start next transfer
+            //asitPhyTransferStart(pInp);
+
+#ifdef DEBUG_SKIP_DECODING
+            return asitErr;
+#endif
+        }
+        else if(asitErr == ASIT_ERR_INPBUF_UNDERFLOW) {
+            TRACE_TERSE0("asitDecodeProcessing: Input buffer underflows.");
+
+            // When input buffer underflows, it is not an error but decoding needs
+            // to be skipped as there is not enough data in the buffer.
+            asitPhyTransferStart(pInp);
+
+            return asitErr;
+        }
+        else {
+            // Inform decoder to complete the decoding of previous frame - is this good?
+            pInp->sourceSelect = PAF_SOURCE_NONE;
+            pInp->numFrameReceived = 0;    // for debugging
+            TRACE_TERSE1("asitDecodeProcessing: asitInputDataProcess error: %d", asitErr);
+
+#ifdef DEBUG_SKIP_DECODING
+            return ASIT_ERR_DECODE_QUIT;
+#endif
+        }
+    } /* ASIT_EVTMSK_INPDATA */
+#ifdef DEBUG_SKIP_DECODING
+    else {
+        TRACE_TERSE0("asitDecodeProcessing: events error.");
+        return ASIT_ERR_EVENTS;
+    }
+#endif
+
+#ifndef DEBUG_SKIP_DECODING
+    // Map ASIT events to decode messages
+    decMsg = asitEventsToDecMsg(asitEvents);
+
+    // Pass messages (corresponding to events) to decode FSM
+    decErr = decDecodeFsm(pP, pQ, pAsitCfg, pInp->sourceSelect, decMsg);
+
+    // Mark I/O DATA read complete if decoder indicates decoding is done.
+    if((asitEvents & ASIT_EVTMSK_DECACK)) {  // DECACK -> decoding done
+        //ioDataReadComplete(pInp->hIoData);
+    }
+
+    if(decErr != DEC_NO_ERR) {
+        TRACE_VERBOSE0("TaskAsip: send DEC_EXIT message to slave decoder.");
+
+        // Send dec exit message to slave decoder
+        if( AspMsgSend(ASP_SLAVE_DEC_EXIT, ASP_MASTER_DEC_EXIT_DONE, NULL, NULL)
+            != ASP_MSG_NO_ERR) {
+            TRACE_VERBOSE0("TaskAsip: error in sending DEC_EXIT message");
+            SW_BREAKPOINT;
+        }
+
+        return ASIT_ERR_DECODE_QUIT;  // This is not necessarily an error
+    }
+    else {
+        return ASIT_NO_ERR;
+    }
+#endif
+}  /* asitDecodeProcessing */
+
+
+/*============================================================================
+ * ASIT Input Data Processing:
+ *    - invoke ioDataProcess() to inspect input data for
+ *       - initial auto-detection,  or
+ *       - background scanning for PCM data, or
+ *       - SYNC check for bitstream
+ *    - return auto-detection status (SYNC detected, SYNC loss, etc)
+============================================================================*/
+Int asitInputDataProcess(PAF_AST_IoInp *pInp, ioDataAutoDetStat_t *pAutoDetStats)
+{
+    Int ioDataErr, retVal;
+    ioDataCtl_t ioDataCtl;
+
+    // Perform auto-detection inside I/O DATA component
+    ioDataErr = ioDataProcess(pInp->hIoData);
+
+    if(ioDataErr == IODATA_NO_ERR) {
+        // Normal operation - check auto-detection status
+        ioDataCtl.code = IODATA_CTL_GET_AUTODET_STATUS;
+        ioDataControl(pInp->hIoData, &ioDataCtl);
+
+        *pAutoDetStats = ioDataCtl.param.autoDetStats;
+
+        retVal = ASIT_NO_ERR;
+    }
+    else if(ioDataErr == IODATA_ERR_IOBUF_UNDERFLOW) {
+        // Input buffer underflows - there is no enough data to process.
+        // This is not error and no action is needed.
+        pInp->numUnderflow += 1; // debug
+
+        retVal = ASIT_ERR_INPBUF_UNDERFLOW;
+    }
+    else {
+        // Something is wrong: print error log and return
+        //printf("IODATA processing error!\n");
+        retVal = ASIT_ERR_INPDATA_PROC;
+    }
+
+    return retVal;
+} /* asitInputDataProcess */
+
+/*============================================================================
+ * Mapping ASIT Events to Decoding Messages
+============================================================================*/
+UInt asitEventsToDecMsg(UInt asitEvents)
+{
+    UInt decMsg = 0;
+
+    if(asitEvents & ASIT_EVTMSK_INPDATA) {
+        decMsg |= DEC_MSGMSK_INPDATA;
+    }
+
+    if(asitEvents & ASIT_EVTMSK_INFOACK) {
+        decMsg |= DEC_MSGMSK_INFOACK;
+    }
+
+    if(asitEvents & ASIT_EVTMSK_DECACK) {
+        decMsg |= DEC_MSGMSK_DECACK;
+    }
+
+    return decMsg;
+} /* asitEventsToDecMsg */
 
 /*===========================================================================
  * Initialize I/O components for input processing
 ============================================================================*/
-int asipIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo)
+int asitIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo)
 {
-    // Initialize I/O BUFF and I/O PHY components for input task
     ioBuffParams_t ioBuffParams;
     ioPhyParams_t  ioPhyParams;
     ioDataParam_t  ioDataCfg;
+    ioPhyCtl_t     ioPhyCtl;
+
+    pInpIo->phyXferSize = INPUT_FRAME_SIZE_DEF;
+
+    if(pInpIo->firstTimeInit) {
+        TRACE_VERBOSE0("Initialize I/O BUFF and I/O PHY.");
+        ioBuffParams.base         = pInpBuf->inpBufConfig.base.pVoid;
+        ioBuffParams.size         = pInpBuf->inpBufConfig.allocation / STRIDE_WORST_CASE
+                                                                     * STRIDE_WORST_CASE;
+        ioBuffParams.sync         = IOBUFF_WRITE_SYNC;
+        ioBuffParams.nominalDelay = INPUT_FRAME_SIZE_DEF;
+        if(ioBuffInit(pInpIo->hIoBuff, &ioBuffParams) != IOBUFF_NOERR) {
+            return (ASIT_ERR_IOBUFF_INIT);   // to remove magic number
+        }
 
-    ioBuffParams.base         = pInpBuf->inpBufConfig.base.pVoid;
-    ioBuffParams.size         = pInpBuf->inpBufConfig.allocation/STRIDE_WORST_CASE*STRIDE_WORST_CASE;
-    ioBuffParams.sync         = IOBUFF_WRITE_SYNC;
-    ioBuffParams.nominalDelay = INPUT_FRAME_SIZE_DEF;
-    if(ioBuffInit(pInpIo->hIoBuff, &ioBuffParams) != IOBUFF_NOERR) {
-        return (-1);   // to remove magic number
-    }
+        ioPhyParams.ioBuffHandle    = pInpIo->hIoBuff;
+        ioPhyParams.xferFrameSize   = pInpIo->phyXferSize;
+        ioPhyParams.mcaspChanHandle = pInpIo->hMcaspChan;
+        ioPhyParams.ioBuffOp        = IOPHY_IOBUFFOP_WRITE;
+        if(ioPhyInit(pInpIo->hIoPhy, &ioPhyParams) != IOPHY_NOERR) {
+            return (ASIT_ERR_IOPYH_INIT);   // to remove magic number
+        }
 
-    ioPhyParams.ioBuffHandle    = pInpIo->hIoBuff;
-    ioPhyParams.xferFrameSize   = INPUT_FRAME_SIZE_DEF;
-    ioPhyParams.mcaspChanHandle = pInpIo->hMcaspChan;
-    ioPhyParams.ioBuffOp        = IOPHY_IOBUFFOP_WRITE;
-    if(ioPhyInit(pInpIo->hIoPhy, &ioPhyParams) != IOPHY_NOERR) {
-        return (-1);   // to remove magic number
+        pInpIo->numPrimeXfers = NUM_PRIME_XFERS;
     }
 
+    /* Reinitialize I/O DATA every time when ASIT restarts */
+    TRACE_VERBOSE0("Initialize I/O DATA.");
     ioDataCfg.ioBuffHandle         = pInpIo->hIoBuff;
     ioDataCfg.unknownSourceTimeOut = pInpBuf->inpBufConfig.pBufStatus->unknownTimeout;
     ioDataCfg.frameLengthsIEC      = (uint_least16_t *)&iecFrameLength[0];
@@ -437,33 +899,60 @@ int asipIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo)
     ioDataCfg.zeroRunTrigger       = pInpBuf->inpBufConfig.pBufStatus->zeroRunTrigger;
 
     if(ioDataInit(pInpIo->hIoData, &ioDataCfg) != IODATA_NO_ERR) {
-        return (-1);   // to remove magic number
+        return (ASIT_ERR_IODATA_INIT);   // to remove magic number
+    }
+
+    if(pInpIo->firstTimeInit) {
+        /* Initialize I/O BUFF and I/O PHY only when input interface changes. */
+        TRACE_VERBOSE0("Prime I/O PHY.");
+
+        // Start I/O physical layer by priming McASP LLD for input
+        asitIoPhyPrime(pInpIo);
+
+        pInpIo->firstTimeInit = FALSE;
     }
+    else {
+        // Reconfigure I/O PHY transfer size
+        ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
+        ioPhyCtl.params.xferFrameSize = pInpIo->phyXferSize;
+        ioPhyControl(pInpIo->hIoPhy, &ioPhyCtl);
+
+        // If previous stream before reset was PCM, reconfigure McASP LLD to receive 16-bit packed bits
+        if(!pInpIo->swapData) {
+            Int mcaspErr;
+            mcaspErr = mcaspRecfgWordWidth(pInpIo->hMcaspChan, Mcasp_WordLength_16);
+            if(mcaspErr != Audk2g_EOK) {
+                return ASIT_ERR_MCASP_CFG;
+            }
 
-    pInpIo->numPrimeXfers  = NUM_PRIME_XFERS;
-    pInpIo->phyXferSize    = ioPhyParams.xferFrameSize;
-    //pInpIo->switchHangOver = 0;
-    pInpIo->preSyncState   = IODATA_SYNC_NONE;
+            // Start swapping data
+            pInpIo->swapData = TRUE;
+            TRACE_VERBOSE0("Reconfigure McASP word length and start swapping data.");
+        }
+
+        // Start PHY transfer
+        TRACE_VERBOSE0("Start I/O PHY transfer.");
+        asitPhyTransferStart(pInpIo);
+    }
 
     return 0;
-} /* asipIoCompsInit */
+} /* asitIoCompsInit */
 
 /*======================================================================================
- *  This function initializes ASIP processing
+ *  This function initializes ASIT processing
  *====================================================================================*/
-void asipProcInit(PAF_AST_IoInp  *pInp, asipDecProc_t *pDec)
+void asitProcInit(PAF_AST_IoInp  *pInp, asipDecProc_t *pDec)
 {
-    pInp->swapData = SWAP_INPUT_DATA;
-    pInp->asipProcState = ASIP_SOURCE_DETECTION;
-    //pInp->switchHangOver = 0;
-
+    pInp->swapData = TRUE;
+    pInp->pcmSwitchHangOver = INPUT_SWITCH_HANGOVER;
     pDec->initDone = FALSE;
+    pInp->numFrameReceived = 0;
 }
 
 /*======================================================================================
  *  I/O physical layer prime operation required by McASP LLD
  *====================================================================================*/
-void asipIoPhyPrime(PAF_AST_IoInp *pInp)
+void asitIoPhyPrime(PAF_AST_IoInp *pInp)
 {
     Int32        count;
 
@@ -474,26 +963,43 @@ void asipIoPhyPrime(PAF_AST_IoInp *pInp)
         //pInp->numXferStart++;
 #endif
     }
-} /* asipIoPhyPrime */
+} /* asitIoPhyPrime */
 
-/*======================================================================================
- *  This function pends on I/O PHY transfer for the input task
- *====================================================================================*/
-void asipPhyTransferPend()
-{
-    // asipSemRx needs to be placed into some data structure
-    Semaphore_pend(asipSemRx, BIOS_WAIT_FOREVER);
-} /* asipPhyTransferPend */
 
 /*======================================================================================
  *  This function marks the I/O PHY transfer as complete
  *====================================================================================*/
-void asipPhyTransferComplete(PAF_AST_IoInp * pInpIo)
+void asitPhyTransferComplete(PAF_AST_IoInp * pInpIo)
 {
     // Mark underlining I/O BUFF write complete and swap data if needed
     ioPhyXferComplete(pInpIo->hIoPhy, pInpIo->swapData);
-} /* asipPhyTransferComplete */
+} /* asitPhyTransferComplete */
+
+Int asitRecfgPhyXfer(PAF_AST_IoInp *pInp, size_t xferSize)
+{
+    ioPhyCtl_t ioPhyCtl;
+    Int mcaspErr;
+
+    ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
+    ioPhyCtl.params.xferFrameSize = xferSize;
+    ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
+
+    pInp->phyXferSize  = ioPhyCtl.params.xferFrameSize;
+
+    if(!pInp->swapData) {
+        // If it was PCM, reconfigure McASP LLD to receive 16-bit packed bits
+        mcaspErr = mcaspRecfgWordWidth(pInp->hMcaspChan, Mcasp_WordLength_16);
+        if(mcaspErr != Audk2g_EOK) {
+            return ASIT_ERR_MCASP_CFG;
+        }
+
+        // Start swapping data
+        pInp->swapData = TRUE;
+    }
+
+    return ASIT_NO_ERR;
 
+} /* asitRecfgPhyXfer */
 
 /*======================================================================================
  *  McASP LLD call back function
@@ -502,7 +1008,8 @@ void asipMcaspCallback(void* arg, MCASP_Packet *mcasp_packet)
 {
     /* post semaphore */
     if(mcasp_packet->arg == IOPHY_XFER_FINAL) {
-        Semaphore_post(asipSemRx);
+        //Semaphore_post(asipSemRx);
+        Event_post(asitEvent, ASIT_EVTMSK_INPDATA);
     } else {
         ;    // intermediate packet due to buffer wrapping around
     }
@@ -532,8 +1039,10 @@ void asipMcaspRxRestart(void)
 /*======================================================================================
  *  This function starts an I/O PHY transfer
  *====================================================================================*/
-void asipPhyTransferStart(PAF_AST_IoInp *pInpIo)
+void asitPhyTransferStart(PAF_AST_IoInp *pInpIo)
 {
+    Int ioPhyErr;
+
     if(asipCheckMcaspRxOverrun(pInpIo->hMcaspChan)) {
 #ifdef ASIP_DEBUG
         pInpIo->numInputOverrun++;
@@ -541,9 +1050,12 @@ void asipPhyTransferStart(PAF_AST_IoInp *pInpIo)
         asipMcaspRxRestart();
     }
     else {
-        if(ioPhyXferSubmit(pInpIo->hIoPhy)==IOPHY_ERR_BUFF_OVERFLOW) {
+        ioPhyErr = ioPhyXferSubmit(pInpIo->hIoPhy);
+        //if(ioPhyXferSubmit(pInpIo->hIoPhy)==IOPHY_ERR_BUFF_OVERFLOW) {
+        if(ioPhyErr!=IOPHY_NOERR){
+            printf("\n I/O PHY ioPhyXferSubmit fails with error %d!\n", ioPhyErr);
             // Input buffer overflows!
-            printf("\nInput buffer overflows!\n");
+            //printf("\nInput buffer overflows!\n");
             exit(0);
         }
         else {
@@ -563,7 +1075,7 @@ extern void McaspDevice_init(void);
 /*======================================================================================
  *  This function initializes HW interface and selects the right device for input
  *====================================================================================*/
-Int asipSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp)
+Int asitSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp)
 {
     Audk2g_STATUS status;
 
@@ -583,7 +1095,7 @@ Int asipSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp)
 #endif
         if(status != Audk2g_EOK) {
             Log_info0("audk2g_AudioSelectClkSrc Failed!\n");
-            return ASIP_ERR_D10_CFG;
+            return ASIT_ERR_D10_CFG;
         }
         audk2g_delay(50000); // Without delay between these 2 calls system aborts.
 
@@ -591,7 +1103,7 @@ Int asipSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp)
         status = mcaspAudioConfig(); //defined in newio\fw\mcasp_cfg.c
         if(status != Audk2g_EOK) {
             Log_info0("McASP Configuration Failed!\n");
-            return ASIP_ERR_MCASP_CFG;
+            return ASIT_ERR_MCASP_CFG;
         }
 
         pInp->hMcaspChan = hMcaspRxChan;
@@ -607,12 +1119,12 @@ Int asipSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp)
 #endif
 
     return 0;
-}  /* asipSelectDevices */
+}  /* asitSelectDevices */
 
 /*======================================================================================
  *  This function updates input status
  *====================================================================================*/
-Int asipUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
+Int asitUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
                           PAF_InpBufConfig *pInpBuf)
 {
     Int asipErrno;
@@ -693,7 +1205,11 @@ Int asipUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
 }
 
 
-void asipUpdateInpBufConfig(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp)
+/*==============================================================================
+ * This function updates input buffer config based on frame information provided
+ * by I/O DATA.
+ ==============================================================================*/
+void asitUpdateInpBufConfig(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp)
 {
     PAF_InpBufConfig *pBufConfig;
     ioDataCtl_t ioDataCtl;
@@ -710,7 +1226,7 @@ void asipUpdateInpBufConfig(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp)
 
     pBufConfig = &(pAstCfg->xInp[pAstCfg->masterDec].inpBufConfig);
 
-    //JXTODO: do we need to gate here? - No, since ARM won't read until it receives message
+    //JXTODO: do we need to gate here?
     //key = GateMP_enter(gateHandle);
 
     pBufConfig->base.pVoid   = ioDataCtl.param.dataReadInfo.buffBase;
@@ -719,13 +1235,17 @@ void asipUpdateInpBufConfig(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp)
 
     // Leave the gate
     //GateMP_leave(gateHandle, key);
+
+    TRACE_TERSE2("Frame start address: 0x%x., preamble: 0x%x",
+                 (UInt)ioDataCtl.param.dataReadInfo.startAddress,
+                 *(UInt *)ioDataCtl.param.dataReadInfo.startAddress);
 }
 
 /*==============================================================================
  * Decide source after SYNC is found, i.e. either bitstream preamble is detected
  * or it times out to PCM.
  ==============================================================================*/
-Int asipDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
+Int asitDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
                      ioDataAutoDetStat_t *autoDetStatus)
 {
     Int sourceConfig, sourceSelect, sourceProgram;
@@ -734,7 +1254,8 @@ Int asipDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
 
     // Get the configured source
     zMD = pAstCfg->masterDec;
-    sourceConfig = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect), GATEMP_INDEX_DEC);
+    sourceConfig = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
+                                          GATEMP_INDEX_DEC);
 
     if(autoDetStatus->syncState == IODATA_SYNC_PCM) {
         if (sourceConfig == PAF_SOURCE_DSD1 || sourceConfig == PAF_SOURCE_DSD2 ||
@@ -752,7 +1273,8 @@ Int asipDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
     }
 
     // write the decided source program to memory
-    sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram), sourceProgram, GATEMP_INDEX_DEC);
+    sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram), sourceProgram,
+                       GATEMP_INDEX_DEC);
 
     // now that we have some input classification, and possibly an outstanding
     // input frame, we determine whether or not to call decodeProcessing and with
@@ -772,7 +1294,8 @@ Int asipDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
         // If autodetecting, decoding only PCM, and input is PCM then decode.
         case PAF_SOURCE_PCMAUTO:
             if (sourceProgram == PAF_SOURCE_PCM) {
-                sourceSelect = sourceProgram;  // only expect autodet to give PAF_SOURCE_PCM, otherwise set to NONE
+                // only expect autodet to give PAF_SOURCE_PCM, otherwise set to NONE
+                sourceSelect = sourceProgram;
             }
             break;
 
@@ -814,10 +1337,10 @@ Int asipDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
     // if we didn't find any matches then skip
     if (sourceSelect == PAF_SOURCE_NONE) {
         TRACE_VERBOSE0("TaskAsip: no matching source type, continue");
-        return ASIP_ERR_NO_MATCHING_SOURCE;
+        return ASIT_ERR_NO_MATCHING_SOURCE;
     }
 
-#ifndef PCM_LOOPBACK_TEST
+#ifndef DEBUG_SKIP_DECODING
     // send source select message to slave
     *(Int32 *)&asipMsgBuf[0] = sourceSelect;
     if(AspMsgSend(ASP_SLAVE_DEC_SOURCE_SELECT, ASP_MASTER_DEC_SOURCE_SELECT_DONE,
@@ -830,8 +1353,8 @@ Int asipDecideSource(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp,
     pInp->sourceSelect  = sourceSelect;
     pInp->sourceProgram = sourceProgram;
 
-    return ASIP_NO_ERR;
-} /* asipDecideSource */
+    return ASIT_NO_ERR;
+} /* asitDecideSource */
 
 /*==============================================================================
  * After SYNC is found, i.e. either bitstream preamble is detected or it times
@@ -879,24 +1402,25 @@ Int asitUpdateIoComps(const PAF_ASIT_Params *pP, PAF_AST_Config *pAstCfg,
         //ioBuffAdjustDelay(pInp->hIoBuff, pInp->phyXferSize);
 
         // Stop swapping data
-        pInp->swapData = FALSE;
+        //pInp->swapData = FALSE;
     }
     else {
         // For bitstream, I/O frame length is the frame length of the bitstream
         uint_least16_t pc = autoDetStatus->bitStreamInfo & SYNC_PC_MASK; //0x001F
         ioFrameLength = iecFrameLength[pc];
 
-        /*
-                if (pc == 0x11 && DTSHDSubType == 3 && (PAF_ASP_sampleRateHzTable[pBufConfig->pBufStatus->sampleRateStatus][PAF_SAMPLERATEHZ_STD] <=48000.0))
-                    pDevExt->sourceProgram = PAF_SOURCE_DXP;    // LBR is 23
-
-                if (pc == 1)
-                    pDevExt->elementSize = 4288;
-                else if (pc == 0x11) {
-                    pDevExt->frameLength = (pDevExt->pIECFrameLength[pc] << DTSHDSubType);
-                    pDevExt->lengthofData = pDevExt->frameLength;
-                }
-        */
+/*
+        if(   (pc == 0x11) && (DTSHDSubType == 3)
+           && (PAF_ASP_sampleRateHzTable[pBufConfig->pBufStatus->sampleRateStatus][PAF_SAMPLERATEHZ_STD] <=48000.0))
+            pDevExt->sourceProgram = PAF_SOURCE_DXP;    // LBR is 23
+
+        if (pc == 1)
+            pDevExt->elementSize = 4288;
+        else if (pc == 0x11) {
+            pDevExt->frameLength = (pDevExt->pIECFrameLength[pc] << DTSHDSubType);
+            pDevExt->lengthofData = pDevExt->frameLength;
+        }
+*/
 
         pBufConfig->sizeofElement = WORD_SIZE_BITSTREAM;
         pBufConfig->frameLength   = ioFrameLength;
@@ -934,237 +1458,13 @@ Int asitUpdateIoComps(const PAF_ASIT_Params *pP, PAF_AST_Config *pAstCfg,
     }
 
     //JXTODO: decide what to do with hRxSio
-    pAstCfg->xInp[zMD].hRxSio = pInp->hIoData; //temporary - does ARM use hRxSio or just check if it is not NULL?
+    //temporary - does ARM use hRxSio or just check if it is not NULL?
+    pAstCfg->xInp[zMD].hRxSio = pInp->hIoData;
     pAstCfg->xInp[zMD].pInpBuf = &(pAstCfg->xInp[zMD].inpBufConfig);
 
-    return ASIP_NO_ERR;
+    return ASIT_NO_ERR;
 } /* asitUpdateIoComps */
 
-Int asipBypassIoData(PAF_AST_IoInp *pInp)
-{
-    // When switching to PCM, McASP RFMT register will be modified,
-    // which will cause all 0's in one McASP LLD transfer. This will
-    // be detected as loss of SYNC by auto detection. To prevent that,
-    // skip I/O DATA process for hangover period so that this all 0's
-    // frame will not be seen by auto-detection. Also, playing out PCM
-    // needs to be skipped as well, to prevent from playing out garbage
-    // (16-bit packed data).
-    void *buff1, *buff2;
-    size_t size1, size2;
-
-    // Get read pointers (or sub-buffers) of the input buffer
-    if (ioBuffGetReadPtrs(pInp->hIoBuff, pInp->phyXferSize,
-                          &buff1, &size1, &buff2, &size2)
-        == IOBUFF_ERR_UNDERFLOW) {
-        pInp->numUnderflow += 1;
-
-        // Return since there is no enough data to process
-        return ASIP_NO_ERR;
-    }
-
-    ioBuffReadComplete(pInp->hIoBuff, buff1, size1);
-
-    if(buff2 != NULL) {
-        ioBuffReadComplete(pInp->hIoBuff, buff2, size2);
-    }
-
-    return ASIP_NO_ERR;
-}
-
-/*=============================================================================
- *  Main function of ASIP processing
- *============================================================================*/
-Int asipProcessing(const PAF_ASIT_Params *pP,
-                   const PAF_ASIT_Patchs *pQ,
-                   PAF_ASIT_Config *pAsitCfg)
-
-{
-    PAF_AST_Config  *pAstCfg;
-    int ioDataStatus, asipStatus, zMI;
-    ioDataAutoDetStat_t autoDetStatus;
-    Audk2g_STATUS mcaspStatus;
-    ioDataCtl_t ioDataCtl;
-    ioPhyCtl_t  ioPhyCtl;
-    PAF_AST_IoInp *pInp;            /* Input I/O components */
-
-    pAstCfg = pAsitCfg->pAstCfg;
-    zMI  = pAstCfg->masterDec;
-    pInp = &pAsitCfg->pIoInp[zMI]; // pointer to input I/O components
-
-    if(pInp->asipProcState == ASIP_SWITCH_TO_PCM) {
-        // Bypass I/O data processing due to McASP LLD work around
-        // (refer to comments inside the function)
-        asipStatus = asipBypassIoData(pInp);
-        if(asipStatus != ASIP_NO_ERR) {
-            return asipStatus;
-        }
-    }
-    else {
-        // Perform auto-detection when not switching
-        ioDataStatus = ioDataProcess(pInp->hIoData);
-        if(ioDataStatus == IODATA_ERR_IOBUF_UNDERFLOW) {
-            // Input buffer underflows - no action is needed
-            pInp->numUnderflow += 1;
-
-            // Return since there is no enough data to process
-            return ASIP_NO_ERR;
-        }
-        else if(ioDataStatus != IODATA_NO_ERR) {
-            // Something is wrong: print error log and return
-            //printf("IODATA processing error!\n");
-            return ASIP_ERR_AUTO_DETECION;
-        }
-        else {
-            // Normal operation - check auto-detection status
-            ioDataCtl.code = IODATA_CTL_GET_AUTODET_STATUS;
-            ioDataControl(pInp->hIoData, &ioDataCtl);
-
-            autoDetStatus = ioDataCtl.param.autoDetStats;
-        }
-    }
-
-    switch(pInp->asipProcState)
-    {
-    case ASIP_SOURCE_DETECTION:
-        // zero out the output buffer
-        rxDecodePlayZero(pInp);
-
-        // Mark I/O DATA read complete as auto-detection finishes reading input data now.
-        ioDataReadComplete(pInp->hIoData);
-
-        if(   autoDetStatus.syncState == IODATA_SYNC_BITSTREAM
-           || autoDetStatus.syncState == IODATA_SYNC_PCM) {
-            // Decide input source and inform decoder
-            asipStatus = asipDecideSource(pAstCfg, pInp, &autoDetStatus);
-            if(asipStatus != ASIP_NO_ERR) {
-                return asipStatus;
-            }
-            else {
-                // Update I/O components and input buffer config
-                asitUpdateIoComps(pP, pAstCfg, pInp, &autoDetStatus);
-
-                // set to unknown so that we can ensure, for IOS purposes, that sourceDecode = NONE
-                // iff we are in this top level state machine and specifically not in decodeProcessing
-#ifndef PCM_LOOPBACK_TEST
-                pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_UNKNOWN);
-#endif
-
-                if(autoDetStatus.syncState == IODATA_SYNC_BITSTREAM) {
-                    // Input is bit stream: go to decoding
-                    pInp->asipProcState = ASIP_DECODE;
-                    //pInp->numFrameReceived = 1;
-                }
-                else  {
-                    // Input is PCM: stop swapping data
-                    pInp->swapData = FALSE;
-
-                    // Reconfigure McASP LLD to transfer 32-bit unpacked data
-                    mcaspStatus = mcaspRecfgWordWidth(pInp->hMcaspChan, Mcasp_WordLength_32);
-                    if(mcaspStatus != Audk2g_EOK) {
-                        return ASIP_ERR_MCASP_CFG;
-                    }
-
-                    // Adjust I/O BUFF delay and read pointer - to make sure read pointers always point to
-                    // PCM data from 1st I2S (out of 4 for HDMI 4xI2S)
-                    ioBuffAdjustDelay(pInp->hIoBuff, pInp->phyXferSize);
-
-                    // Go to transition state to switch to PCM
-                    pInp->asipProcState = ASIP_SWITCH_TO_PCM;
-                    pInp->pcmSwitchHangOver = INPUT_SWITCH_HANGOVER;
-                    //pInp->numPcmFrameReceived = 0;
-                }
-            }
-
-            pInp->numFrameReceived = 0;
-            pInp->preSyncState = autoDetStatus.syncState;
-        }
-        else {
-            // Source is still unknown - take no action
-            ;
-        }
-        break;
-
-    case ASIP_SWITCH_TO_PCM:
-        // zero out the output buffer
-        rxDecodePlayZero(pInp);
-
-        pInp->pcmSwitchHangOver--;
-        if(pInp->pcmSwitchHangOver == 0) {
-            pInp->asipProcState = ASIP_DECODE;
-        }
-        break;
-
-    case ASIP_DECODE:
-        if(autoDetStatus.syncState == IODATA_SYNC_NONE) {
-            // SYNC lost: change I/O PHY transfer size to default for auto-detection
-            ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
-            ioPhyCtl.params.xferFrameSize = INPUT_FRAME_SIZE_DEF;
-            ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
-            pInp->phyXferSize  = ioPhyCtl.params.xferFrameSize;
-
-            if(pInp->preSyncState == IODATA_SYNC_PCM) {
-                // If it was PCM, reconfigure McASP LLD to receive 16-bit packed bits
-                mcaspStatus = mcaspRecfgWordWidth(pInp->hMcaspChan, Mcasp_WordLength_16);
-                if(mcaspStatus != Audk2g_EOK) {
-                    return ASIP_ERR_MCASP_CFG;
-                }
-
-                // Start swapping data
-                pInp->swapData = TRUE;
-            }
-
-            // Inform decoder to complete decoding previous frame
-            pInp->sourceSelect = PAF_SOURCE_NONE;
-
-            pInp->numFrameReceived = 0;
-            pInp->asipProcState  = ASIP_SOURCE_DETECTION;
-        }
-        else {
-            pInp->numFrameReceived += 1;    // for debugging
-
-            // Communicate input stream information to decoder through input buffer configuration
-            asipUpdateInpBufConfig(pAstCfg, pInp);
-        }
-
-#ifndef PCM_LOOPBACK_TEST
-        asipStatus = asipDecodeProcessing(pP, pQ, pAsitCfg, pInp->sourceSelect);
-        if(asipStatus != ASIP_NO_ERR) {
-
-            // send dec exit message to slave
-            if( AspMsgSend(ASP_SLAVE_DEC_EXIT, ASP_MASTER_DEC_EXIT_DONE, NULL, NULL)
-                != ASP_MSG_NO_ERR)
-            {
-                TRACE_VERBOSE0("TaskAsip: error in sending DEC_EXIT message");
-                SW_BREAKPOINT;
-            }
-
-            return asipStatus;
-        }
-#else
-        if(autoDetStatus.syncState == IODATA_SYNC_PCM) {
-            rxDecodePcm(pInp);     // for PCM loopback testing
-        }
-#endif
-        // Mark I/O DATA read complete as decoder finishes reading input now.
-        ioDataReadComplete(pInp->hIoData);
-
-        break;
-
-    default:
-        break;
-    }
-
-    return 0;
-} /* asipProcessing */
-
-/*======================================================================================
- *  This function decides the input source based on auto-detection information.
- *====================================================================================*/
-//Int asipDecideSource(const PAF_ASIT_Params *pP, PAF_AST_Config *pAstCfg, asipDecProc_t *pDec)
-//{
-
-//}
-
 
 #ifndef IO_LOOPBACK_TEST
 #if OUTPUT_FRAME_LENGTH == INPUT_FRAME_LENGTH
@@ -1207,24 +1507,70 @@ Int rxDecodePcm(PAF_AST_IoInp  *pInp)
     }
 
 
-    return ASIP_NO_ERR;
+    return ASIT_NO_ERR;
 }
 
-Int rxDecodeBitStream(PAF_AST_IoInp  *pInp)
+
+Int rxDecodePlayZero(PAF_AST_IoInp  *pInp)
 {
-    return ASIP_NO_ERR;
+    return ASIT_NO_ERR;
 }
+#endif
 
-
-Int rxDecodePlayZero(PAF_AST_IoInp  *pInp)
+Int asitEvtErrCheck(UInt actualEvents, UInt expectedEvents)
 {
-    return ASIP_NO_ERR;
+    TRACE_VERBOSE2("ASIT events error: actual events are: %d, expected events are: %d.",
+                   actualEvents, expectedEvents);
+
+    return ASIT_ERR_EVENTS;
 }
+
+void asitErrorHandling(PAF_ASIT_Config *pAsitCfg, Int asitErr)
+{
+    UInt events;
+
+    if(asitErr == ASIT_ERR_INPBUF_UNDERFLOW) {
+        TRACE_VERBOSE0("ASIT error handling: input buffer underflows. No actions needed.");
+    }
+
+    if(asitErr == ASIT_ERR_DECODE_QUIT) {
+        TRACE_VERBOSE0("ASIT error handling: DECODE_QUIT - clear INPDATA event.");
+#if 0
+        // Pend on INPTDATA event that should have been posted before decoding quits.
+        events = Event_pend(asitEvent, ASIT_EVTMSK_NONE, ASIT_EVTMSK_INPDATA,
+                            BIOS_WAIT_FOREVER);
+
+        // Marks I/O PHY transfer and I/O BUFF write complete
+        asitPhyTransferComplete(&pAsitCfg->pIoInp[0]);
+
+        // Keep I/O BUFF read pointers going
+        asitBypassIoData(&pAsitCfg->pIoInp[0]);
 #endif
+        pAsitCfg->pIoInp[0].asipState = ASIT_RESET;
+        pAsitCfg->pIoInp[0].numAsitRestart++;
+        TRACE_VERBOSE0("ASIT error handling finished. Go to state ASIT_RESET.");
+    }
+
+    if(asitErr == ASIT_ERR_EVENTS) {
+        pAsitCfg->pIoInp[0].asipState = ASIT_RESET;
+        pAsitCfg->pIoInp[0].numAsitRestart++;
+        TRACE_VERBOSE0("ASIT error handling: events error. Go to state ASIT_RESET.");
+    }
+
+    return;
+}  /* asitErrorHandling */
+
 
-void asipErrorHandling(PAF_AST_Config *pAstCfg, int asipErrno)
+//////////////////////////////////////////////////////////////////////////////
+void asitPostInfoEvent()
 {
+    Event_post(asitEvent, ASIT_EVTMSK_INFOACK);
+}
 
+void asitPostDecEvent()
+{
+    Event_post(asitEvent, ASIT_EVTMSK_DECACK);
 }
+//////////////////////////////////////////////////////////////////////////////
 
 /* Nothing past this line */