pasdk/test_dsp/framework/audioStreamInpProcNewIO.c

   1
   2 /*
   3 Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
   4 All rights reserved.
   5
   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 */
  35
  36 /*
  37  *  ======== audioStreamInpProcNewIo.c ========
  38  */
  39 #include <xdc/runtime/Log.h>
  40 #include <ti/sysbios/BIOS.h>
  41
  42 #include "audioStreamInpProc.h"
  43 #include "audioStreamProc_common.h"
  44 #include "asperr.h"
  45
  46 #include "audk2g.h"
  47 #include "audk2g_audio.h"
  48 #include "mcasp_cfg.h"
  49 #include "ioConfig.h"    //TODO: remove this header
  50 #include "ioBuff.h"
  51 #include "ioPhy.h"
  52 #include "ioData.h"
  53
  54
  55
  56 #define SYNC_PC_MASK         0x1F
  57 #define SYNC_SUBTYPE_MASK    0x700
  58 #define SYNC_SUBTYPE_SHIFT   8
  59 #define SYNC_SUBTYPE_DTSHD   0x11
  60 #define SYNC_DDP             0x15
  61 #define SYNC_THD             0x16
  62
  63 #define IEC_HEADER_LENGTH    4
  64
  65
  66 //table needed until PAF_SOURCE is reordered to match IEC numbering
  67 const SmUns IECpafSource[23] =
  68 {
  69     PAF_SOURCE_UNKNOWN,  // 0: IEC NULL Type
  70     PAF_SOURCE_AC3,      // 1: Comments on 1-15 match IEC 61937 part 2.
  71     PAF_SOURCE_UNKNOWN,  // 2: IEC reserved
  72     PAF_SOURCE_UNKNOWN,  // 3: IEC pause
  73     PAF_SOURCE_UNKNOWN,  // 4: MPEG 1 layer 1
  74     PAF_SOURCE_MP3,      // 5: MPEG layer 2 or 3
  75     PAF_SOURCE_UNKNOWN,  // 6: MPEG 2 data with extension
  76     PAF_SOURCE_AAC,      // 7: MPEG-2 AAC ADTS
  77     PAF_SOURCE_UNKNOWN,  // 8: MPEG 2 layer 1 low sampling frequency
  78     PAF_SOURCE_UNKNOWN,  // 9: MPEG 2 layer 2 or 3 low sampling frequency
  79     PAF_SOURCE_UNKNOWN,  // 10: reserved
  80     PAF_SOURCE_DTS,      // 11: DTS type 1 (11 bit: 512 sample repeat period)
  81     PAF_SOURCE_DTS12,    // 12: DTS type 2 (12 bit: 1024 sample repeat period)
  82     PAF_SOURCE_DTS13,    // 13: DTS type 3 (13 bit: 2048 sample repeat period)
  83     PAF_SOURCE_DTS14,    // 14: ATRAC
  84     PAF_SOURCE_UNKNOWN,  // 15: ATRAC 2/3
  85     PAF_SOURCE_THD,      // 16
  86     PAF_SOURCE_DTSHD,    // 17
  87     PAF_SOURCE_WMA9PRO,  // 18
  88     PAF_SOURCE_UNKNOWN,  // 19
  89     PAF_SOURCE_UNKNOWN,  // 20
  90     PAF_SOURCE_DDP,      // 21
  91     PAF_SOURCE_THD,      // 22
  92 };
  93
  94 /*
  95  * Functions defined in other files and to be put into proper header files
  96  */
  97 extern Void taskAsipFxnInit(const PAF_ASIT_Params *pP,const PAF_ASIT_Patchs *pQ);
  98
  99
 100 // avoid including sap_d10.h, which would cause symbol redefinition
 101 // warning (MCASP_PFUNC_XXX)
 102 extern XDAS_Int32 D10_init();
 103 extern XDAS_Int32 D10_RxControl(const void *pD10RxParams,
 104                                 XDAS_Int32 code, XDAS_Int32 arg);
 105
 106 /*
 107  * Functions only used in this file
 108  */
 109 int asipPrepareProcessing();
 110 int asipIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo);
 111 void asipProcInit(PAF_AST_IoInp  *pInp);
 112 void asipIoPhyPrime(PAF_AST_IoInp *pInpIo);
 113 void asipPhyTransferPend(void);
 114 void asipPhyTransferComplete(PAF_AST_IoInp * pInpIo);
 115 void asipPhyTransferStart(PAF_AST_IoInp *pInpIo);
 116 Int asipSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp);
 117 Int asipUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
 118                           PAF_InpBufConfig *pInpBuf);
 119
 120 Int asipProcessing(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp);
 121 void asipErrorHandling(PAF_AST_Config *pAstCfg, int asipErrno);
 122
 123 /*
 124  * variables/structures to be put into proper global structures
 125  */
 126 extern Semaphore_Handle asipSemRx;
 127 extern PAF_ASIT_Config gPAF_ASIT_config;
 128
 129 enum
 130 {
 131     ASIP_SOURCE_DETECTION,
 132     ASIP_DECODE_BITSTREAM,
 133     ASIP_SWITCH_TO_PCM,
 134     ASIP_DECODE_PCM
 135 };
 136
 137 enum
 138 {
 139     ASIP_INPUT_PREPARATION,
 140     ASIP_INPUT_PROCESSING
 141 };
 142
 143 #define ASIP_DEBUG
 144
 145 #ifdef ASIP_DEBUG
 146 /* define the following as global variables for easy debugging */
 147 int asipLoopCount1, asipLoopCount2;
 148 Int asipErrno;
 149 Int inputReadyForProcessing;
 150 #endif
 151
 152 /*
 153  *  ======== taskAsipFxn ========
 154  *  Audio Stream Input Processing task function
 155  */
 156 #ifndef PASDK_SIO_DEV
 157 #ifndef IO_LOOPBACK_TEST
 158 Void taskAsipFxn(                  // ASIP task function for new I/O
 159 #else
 160 Void taskAsipFxn_NewIO_Not_Used(   // not used for loopback test
 161 #endif
 162 #else
 163 Void taskAsipFxn_NewIO_Not_USED(   // not used for SIO/DEV based I/O
 164 #endif
 165     const PAF_ASIT_Params *pP,
 166         const PAF_ASIT_Patchs *pQ)
 167 {
 168     PAF_ASIT_Config *pAsitCfg;      /* ASIT configuration pointer */
 169     PAF_AST_Config  *pAstCfg;       /* AST Common (shared) configuration pointer */
 170     PAF_AST_IoInp *pInp;            /* Input I/O components */
 171     Int as;                         /* Audio Stream Number (1, 2, etc.) */
 172     Int z;                          /* input/encode/stream/decode/output counter */
 173     Int zMI;
 174 #ifndef ASIP_DEBUG
 175 int asipLoopCount1, asipLoopCount2;
 176 Int asipErrno;
 177 Int inputReadyForProcessing;
 178 #endif
 179
 180     Log_info0("Enter taskAsipFxn()");
 181
 182     taskAsipFxnInit(pP, pQ);  // initialization of input task
 183
 184     //
 185     // Audio Stream Input Task Configuration (*pAsitCfg):
 186     //
 187     pAsitCfg = &gPAF_ASIT_config;       // initialize pointer to task configuration
 188     pAstCfg  = pAsitCfg->pAstCfg;       // pointer to AST common (shared) configuration
 189     pInp     = pAsitCfg->pIoInp;        // pointer to input I/O components
 190
 191     /* Set Audio Stream Number (1, 2, etc.) */
 192     as = pAstCfg->as;
 193
 194     //
 195     // Determine decoder and stream indices associated with the master input
 196     //
 197     zMI = pP->zone.master;
 198
 199     pInp[zMI].numPrimeXfers = NUM_PRIME_XFERS;
 200     //asipInitDebug(&pInp[zMI]);
 201
 202     for (z=STREAM1; z < STREAMN; z++)
 203     {
 204         TRACE_VERBOSE1("TaskAsip: AS%d: running", as+z);
 205     }
 206
 207     TRACE_TERSE0("TaskAsip: Entering Main Loop.");
 208
 209 #if 0
 210     // Wait until input device is ready - change this to event based scheduling
 211     asipErrno = 0;
 212     while (!inputReadyForProcessing)
 213     {
 214         // Indicate decoder no decoding yet
 215         pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_NONE);
 216
 217         Task_sleep(5);  // 5 system tick, or 5 msec. Should remove this later when implementing event based scheduling.
 218
 219         inputReadyForProcessing = asipPrepareProcessing(pP, pQ, pAsitCfg, &asipErrno);
 220
 221         if(asipErrno) {
 222             asipErrorHandling(pAstCfg, asipErrno);
 223         }
 224     }
 225
 226     // .....................................................................
 227     // At this point we have an enabled input and want to decode something.
 228     // If no decoder selected then do nothing. Need to reset the sourceProgram, since
 229     // when no decoder is selected there are no calls to IB
 230     asipErrno = asipIoCompsInit(&pAstCfg->xInp[zMI], &pInp[zMI]);
 231     if(asipErrno) {
 232         printf("ASIP IO components init error!\n");
 233         exit(0);
 234     }
 235
 236     asipProcInit(&pInp[zMI]);
 237
 238     // start I/O physical layer by priming McASP LLD for input
 239     asipIoPhyPrime(&pInp[zMI]);
 240
 241     //
 242     // Main processing loop
 243     //
 244     asipErrno = 0;
 245     for (;;)
 246     {
 247         // Pending on I/O PHY transfer
 248         asipPhyTransferPend();
 249
 250         // Marks I/O PHY transfer and I/O BUFF write complete
 251         asipPhyTransferComplete(&pInp[zMI]);
 252
 253         // Main function to process input data
 254         asipErrno = asipProcessing(pAstCfg, &pInp[zMI]);
 255
 256         // Start next transfer
 257         asipPhyTransferStart(&pInp[zMI]);
 258
 259         if(asipErrno) {
 260             asipErrorHandling(pAstCfg, asipErrno);
 261         }
 262     }
 263 #endif
 264
 265 #if 0
 266     //
 267     // Main processing loop
 268     //
 269     asipLoopCount1 = 0;
 270     asipLoopCount2 = 0;
 271     asipErrno = 0;
 272     inputReadyForProcessing = FALSE;
 273     for (;;)
 274     {
 275         asipLoopCount1++;
 276
 277         if(asipErrno) {
 278             asipErrorHandling(pAstCfg, asipErrno);
 279
 280             inputReadyForProcessing = FALSE;
 281         }
 282
 283         // Wait until input device is ready - change this to event based scheduling
 284         if(!inputReadyForProcessing) {
 285             // Indicate decoder no decoding yet
 286             pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_NONE);
 287
 288             // 5 system tick, or 5 msec. Should remove this later when implementing
 289             // event based scheduling.
 290             Task_sleep(5);
 291
 292             inputReadyForProcessing = asipPrepareProcessing(pP, pQ, pAsitCfg, &asipErrno);
 293
 294             if (inputReadyForProcessing) {
 295                 // Input is ready for processing, so we initialize the I/O components
 296                 asipIoCompsInit(&pAstCfg->xInp[zMI], &pInp[zMI]);
 297
 298                 // Initialize ASIP processing
 299                 asipProcInit(&pInp[zMI]);
 300
 301                 // Start I/O physical layer by priming McASP LLD for input
 302                 asipIoPhyPrime(&pInp[zMI]);
 303             }
 304             else {
 305                 // Input is not ready, so go back to the beginning of the loop
 306                 continue;
 307             }
 308         }  /* if(!inputReadyForProcessing) */
 309
 310         // Pending on I/O PHY transfer
 311         asipPhyTransferPend();
 312
 313         // Marks I/O PHY transfer and I/O BUFF write complete
 314         asipPhyTransferComplete(&pInp[zMI]);
 315
 316         // Main function to process input data
 317         asipErrno = asipProcessing(pAstCfg, &pInp[zMI]);
 318
 319         // Start next transfer
 320         asipPhyTransferStart(&pInp[zMI]);
 321
 322         asipLoopCount2++;
 323     }  // for (;;)
 324 #endif
 325
 326     //
 327     // Main processing loop
 328     //
 329     asipLoopCount1 = 0;
 330     asipLoopCount2 = 0;
 331     asipErrno = 0;
 332     inputReadyForProcessing = FALSE;
 333     pInp->asipState = ASIP_INPUT_PREPARATION;
 334
 335     for (;;)
 336     {
 337         asipLoopCount1++;
 338
 339         switch (pInp->asipState)
 340         {
 341         case ASIP_INPUT_PREPARATION:
 342             // Indicate decoder no decoding yet
 343             pP->fxns->sourceDecode(pP, pQ, pAsitCfg, PAF_SOURCE_NONE);
 344
 345             // 5 system tick, or 5 msec. Should remove this later when implementing
 346             // event based scheduling.
 347             Task_sleep(5);
 348
 349             inputReadyForProcessing = asipPrepareProcessing(pP, pQ, pAsitCfg, &asipErrno);
 350
 351             if (inputReadyForProcessing) {
 352                 // Input is ready for processing, so we initialize the I/O components
 353                 asipIoCompsInit(&pAstCfg->xInp[zMI], &pInp[zMI]);
 354
 355                 // Initialize ASIP processing
 356                 asipProcInit(&pInp[zMI]);
 357
 358                 // Start I/O physical layer by priming McASP LLD for input
 359                 asipIoPhyPrime(&pInp[zMI]);
 360
 361                 pInp->asipState = ASIP_INPUT_PROCESSING;
 362             }
 363             break;
 364
 365         case ASIP_INPUT_PROCESSING:
 366             // Pending on I/O PHY transfer
 367             asipPhyTransferPend();
 368
 369             // Marks I/O PHY transfer and I/O BUFF write complete
 370             asipPhyTransferComplete(&pInp[zMI]);
 371
 372             // Main function to process input data
 373             asipErrno = asipProcessing(pAstCfg, &pInp[zMI]);
 374
 375             // Start next transfer
 376             asipPhyTransferStart(&pInp[zMI]);
 377
 378             if(asipErrno) {
 379                 asipErrorHandling(pAstCfg, asipErrno);
 380
 381                 pInp->asipState = ASIP_INPUT_PREPARATION;
 382             }
 383
 384             break;
 385
 386         default:
 387             break;
 388         }
 389     }  // for (;;)
 390
 391 }  /* taskAsipFxn */
 392
 393 extern const MdUns iecFrameLength[23];
 394 extern Ptr hMcaspRxChan;
 395 #define STRIDE_WORST_CASE 32  // 4-byte (32-bit) word, 2 slots, 4 serializers
 396
 397
 398 /*===========================================================================
 399  * ASIP processing preparation
 400  * Output:
 401  *        - return        TRUE (input is ready) or FALSE (input is not ready)
 402  *        - *asipErrno        Error number
 403 ============================================================================*/
 404 Int asipPrepareProcessing(const PAF_ASIT_Params *pP,
 405                           const PAF_ASIT_Patchs *pQ,
 406                           PAF_ASIT_Config       *pC,
 407                           Int                   *asipErrno)
 408 {
 409     Int as, zMS, zMI, zMD;
 410     Int sourceConfig, mode;
 411     PAF_AST_Config  *pAstCfg;
 412     PAF_AST_IoInp *pInp;            /* I/O components for input */
 413
 414     pAstCfg  = pC->pAstCfg;         // pointer to AST common (shared) configuration
 415     as  = pAstCfg->as;
 416     zMI = pP->zone.master;
 417     zMD = pAstCfg->masterDec;
 418     zMS = pAstCfg->masterStr;
 419     pInp = pC->pIoInp;              // pointer to input I/O components
 420
 421     *asipErrno = 0;
 422
 423     // Select source and initialize physical layer / HW interface
 424     *asipErrno = asipSelectDevices(pQ, pInp);
 425     if (*asipErrno) {
 426         TRACE_TERSE2("TaskAsip: selectDevices returned asipErrno = 0x%04x at line %d. AS%d", *asipErrno, as+zMS);
 427         return FALSE;    // Input is not ready for processing due to error
 428     }
 429
 430     // If no master input selected then we don't know what may be at the input,
 431     // so set to unknown and skip any remaining processing
 432     if (!pInp[zMI].pRxParams) {
 433         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
 434                            (Int8)PAF_SOURCE_UNKNOWN, GATEMP_INDEX_DEC);
 435
 436         TRACE_VERBOSE1("TaskAsip: AS%d: No input selected...", as+zMS);
 437         return FALSE;    // No error, but input is not ready for processing
 438     }
 439
 440     // If here then we have a valid input so query its status
 441     *asipErrno = asipUpdateInputStatus(pInp[zMI].pRxParams,
 442                                    &pAstCfg->xInp[zMI].inpBufStatus,
 443                                    &pAstCfg->xInp[zMI].inpBufConfig);
 444     if(*asipErrno) {
 445         TRACE_VERBOSE1("TaskAsip: updateInputStatus returns 0x%x", *asipErrno);
 446         return FALSE;   // Input is not ready for processing due to error
 447     }
 448
 449     // If master decoder is not enabled, or the input is unlocked, then do nothing
 450     mode = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.mode),
 451                                   GATEMP_INDEX_DEC);
 452     if (!mode || !pAstCfg->xInp[zMI].inpBufStatus.lock)
 453     {
 454         TRACE_VERBOSE0("TaskAsip: Not locked, continue");
 455         return FALSE;  // No error, but input is not ready for processing
 456     }
 457
 458     // Check selected source: sourceSelect is set by another task, AIP or AFP
 459     sourceConfig = (Int)sharedMemReadInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceSelect),
 460                                           GATEMP_INDEX_DEC);
 461     // If no source selected then do nothing
 462     if(sourceConfig == PAF_SOURCE_NONE) {
 463         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
 464                            (Int8)PAF_SOURCE_NONE, GATEMP_INDEX_DEC);
 465         TRACE_VERBOSE1("TaskAsip: AS%d: no source selected, continue", as+zMS);
 466         return FALSE;  // No error, but input is not ready for processing
 467     }
 468
 469     // If we want pass processing then proceed directly
 470     if (sourceConfig == PAF_SOURCE_PASS)
 471     {
 472         TRACE_VERBOSE1("TaskAsip: AS%d: Pass processing ...", as+zMS);
 473         sharedMemWriteInt8(&(pAstCfg->xDec[zMD].decodeStatus.sourceProgram),
 474                            (Int8)PAF_SOURCE_PASS, GATEMP_INDEX_DEC);
 475
 476         pP->fxns->sourceDecode(pP, pQ, pC, PAF_SOURCE_PASS);
 477         if (pP->fxns->passProcessing) {
 478             *asipErrno = pP->fxns->passProcessing(pP, pQ, pC, NULL);
 479         }
 480         else {
 481             TRACE_TERSE2("TaskAsip: AS%d: Pass Processing not supported, asipErrno 0x%x", as+zMS, ASPERR_PASS);
 482             *asipErrno = ASPERR_PASS;
 483         }
 484
 485         TRACE_VERBOSE0("TaskAsip: continue");
 486         return FALSE;  // Error or not, input is not ready for processing
 487     }
 488
 489     // No error and input processing is ready
 490     return TRUE;
 491 } /* asipPrepareProcessing */
 492
 493 /*===========================================================================
 494  * Initialize I/O components for input processing
 495 ============================================================================*/
 496 int asipIoCompsInit(PAF_AST_InpBuf * pInpBuf, PAF_AST_IoInp * pInpIo)
 497 {
 498     // Initialize I/O BUFF and I/O PHY components for input task
 499     ioBuffParams_t ioBuffParams;
 500     ioPhyParams_t  ioPhyParams;
 501     ioDataParam_t  ioDataCfg;
 502
 503     ioBuffParams.base         = pInpBuf->inpBufConfig.base.pVoid;
 504     ioBuffParams.size         = pInpBuf->inpBufConfig.allocation/STRIDE_WORST_CASE*STRIDE_WORST_CASE;
 505     ioBuffParams.sync         = IOBUFF_WRITE_SYNC;
 506     ioBuffParams.nominalDelay = INPUT_FRAME_SIZE_DEF;
 507     if(ioBuffInit(pInpIo->hIoBuff, &ioBuffParams) != IOBUFF_NOERR) {
 508         return (-1);   // to remove magic number
 509     }
 510
 511     ioPhyParams.ioBuffHandle    = pInpIo->hIoBuff;
 512     ioPhyParams.xferFrameSize   = INPUT_FRAME_SIZE_DEF;
 513     ioPhyParams.mcaspChanHandle = hMcaspRxChan;
 514     ioPhyParams.ioBuffOp        = IOPHY_IOBUFFOP_WRITE;
 515     if(ioPhyInit(pInpIo->hIoPhy, &ioPhyParams) != IOPHY_NOERR) {
 516         return (-1);   // to remove magic number
 517     }
 518
 519     ioDataCfg.ioBuffHandle         = pInpIo->hIoBuff;
 520     ioDataCfg.unknownSourceTimeOut = pInpBuf->inpBufConfig.pBufStatus->unknownTimeout;
 521     ioDataCfg.frameLengthsIEC      = (uint_least16_t *)&iecFrameLength[0];
 522     ioDataCfg.frameLengthPCM       = INPUT_FRAME_SIZE_PCM / WORD_SIZE_PCM;
 523     ioDataCfg.frameLengthDef       = INPUT_FRAME_SIZE_DEF / WORD_SIZE_BITSTREAM;
 524     ioDataCfg.ibMode               = pInpBuf->inpBufConfig.pBufStatus->mode;
 525     ioDataCfg.zeroRunRestart       = pInpBuf->inpBufConfig.pBufStatus->zeroRunRestart;
 526     ioDataCfg.zeroRunTrigger       = pInpBuf->inpBufConfig.pBufStatus->zeroRunTrigger;
 527
 528     if(ioDataInit(pInpIo->hIoData, &ioDataCfg) != IODATA_NO_ERR) {
 529         return (-1);   // to remove magic number
 530     }
 531
 532     pInpIo->phyXferSize    = ioPhyParams.xferFrameSize;
 533     pInpIo->switchHangOver = 0;
 534     pInpIo->syncState      = IODATA_SYNC_NONE;
 535
 536     return 0;
 537 } /* asipIoCompsInit */
 538
 539 /*======================================================================================
 540  *  This function initializes ASIP processing
 541  *====================================================================================*/
 542 void asipProcInit(PAF_AST_IoInp  *pInp)
 543 {
 544     pInp->swapData = SWAP_INPUT_DATA;
 545     pInp->asipProcState = ASIP_SOURCE_DETECTION;
 546     pInp->switchHangOver = 0;
 547 }
 548
 549 /*======================================================================================
 550  *  I/O physical layer prime operation required by McASP LLD
 551  *====================================================================================*/
 552 void asipIoPhyPrime(PAF_AST_IoInp *pInp)
 553 {
 554     Int32        count;
 555
 556     for(count = 0; count < pInp->numPrimeXfers; count++)
 557     {
 558         ioPhyXferSubmit(pInp->hIoPhy);
 559 #ifdef ASIP_DEBUG
 560         //pInp->numXferStart++;
 561 #endif
 562     }
 563 } /* asipIoPhyPrime */
 564
 565 /*======================================================================================
 566  *  This function pends on I/O PHY transfer for the input task
 567  *====================================================================================*/
 568 void asipPhyTransferPend()
 569 {
 570     // asipSemRx needs to be placed into some data structure
 571     Semaphore_pend(asipSemRx, BIOS_WAIT_FOREVER);
 572 } /* asipPhyTransferPend */
 573
 574 /*======================================================================================
 575  *  This function marks the I/O PHY transfer as complete
 576  *====================================================================================*/
 577 void asipPhyTransferComplete(PAF_AST_IoInp * pInpIo)
 578 {
 579     // Mark underlining I/O BUFF write complete and swap data if needed
 580     ioPhyXferComplete(pInpIo->hIoPhy, pInpIo->swapData);
 581 } /* asipPhyTransferComplete */
 582
 583
 584 /*======================================================================================
 585  *  McASP LLD call back function
 586  *====================================================================================*/
 587 void asipMcaspCallback(void* arg, MCASP_Packet *mcasp_packet)
 588 {
 589     /* post semaphore */
 590     if(mcasp_packet->arg == IOPHY_XFER_FINAL) {
 591         Semaphore_post(asipSemRx);
 592     } else {
 593         ;    // intermediate packet due to buffer wrapping around
 594     }
 595 }
 596
 597 /*======================================================================================
 598  *  This function checks if McASP Rx for input overruns
 599  *====================================================================================*/
 600 int asipCheckMcaspRxOverrun(void)
 601 {
 602     Mcasp_errCbStatus mcaspErrStat;
 603
 604     mcaspControlChan(hMcaspRxChan, Mcasp_IOCTL_CHAN_QUERY_ERROR_STATS, &mcaspErrStat);
 605
 606     return (mcaspErrStat.isRcvOvrRunOrTxUndRunErr);
 607 }
 608
 609 /*======================================================================================
 610  *  This function restarts McASP LLD channel for input
 611  *====================================================================================*/
 612 void asipMcaspRxRestart(void)
 613 {
 614     mcaspRxReset();
 615     mcaspRxCreate();
 616 }
 617
 618 /*======================================================================================
 619  *  This function starts an I/O PHY transfer
 620  *====================================================================================*/
 621 void asipPhyTransferStart(PAF_AST_IoInp *pInpIo)
 622 {
 623     if(asipCheckMcaspRxOverrun()) {
 624 #ifdef ASIP_DEBUG
 625         pInpIo->numInputOverrun++;
 626 #endif
 627         asipMcaspRxRestart();
 628     }
 629     else {
 630         if(ioPhyXferSubmit(pInpIo->hIoPhy)==IOPHY_ERR_BUFF_OVERFLOW) {
 631             // Input buffer overflows!
 632             printf("\nInput buffer overflows!\n");
 633             exit(0);
 634         }
 635         else {
 636             // Input buffer operates normally
 637             ;
 638         }
 639 #ifdef ASIP_DEBUG
 640         //pInpIo->numXferStart++;
 641 #endif
 642     }
 643 }
 644
 645 Int d10Initialized = 0;
 646 //extern Audk2g_STATUS mcaspAudioConfig(void);
 647 extern void McaspDevice_init(void);
 648
 649 /*======================================================================================
 650  *  This function initializes HW interface and selects the right device for input
 651  *====================================================================================*/
 652 Int asipSelectDevices(const PAF_ASIT_Patchs *pQ, PAF_AST_IoInp *pInp)
 653 {
 654     Audk2g_STATUS status;
 655
 656     //more configuration is needed to abstract out D10
 657     if(!d10Initialized) {
 658         /* Initialize McASP HW details */
 659         McaspDevice_init();
 660
 661         D10_init();
 662
 663 #ifdef INPUT_SPDIF
 664         // Input is DIR
 665         status = audk2g_AudioSelectClkSrc(AUDK2G_AUDIO_CLK_SRC_DIR);
 666 #else
 667         // Input is HDMI
 668         status = audk2g_AudioSelectClkSrc(AUDK2G_AUDIO_CLK_SRC_I2S);
 669 #endif
 670         if(status != Audk2g_EOK) {
 671             Log_info0("audk2g_AudioSelectClkSrc Failed!\n");
 672         }
 673         audk2g_delay(50000); // Without delay between these 2 calls system aborts.
 674
 675         /* Initialize McASP module */
 676         status = mcaspAudioConfig(); //defined in newio\fw\mcasp_cfg.c
 677         if(status != Audk2g_EOK) {
 678             TRACE_TERSE0("McASP Configuration Failed!\n");
 679         }
 680
 681         d10Initialized = 1;
 682     }
 683
 684     /////////////// TODO: HW interface selection and initialization //////////////
 685 #ifdef IO_HW_INTERFACE
 686     pInp->pRxParams = pQ->devinp->x[IO_HW_INTERFACE];
 687 #else
 688     pInp->pRxParams = NULL;
 689 #endif
 690
 691     return 0;
 692 }  /* asipSelectDevices */
 693
 694 /*======================================================================================
 695  *  This function updates input status
 696  *====================================================================================*/
 697 Int asipUpdateInputStatus(const void *pRxParams, PAF_InpBufStatus *pStatus,
 698                           PAF_InpBufConfig *pInpBuf)
 699 {
 700     Int asipErrno;
 701
 702     PAF_SIO_InputStatus inputStatus;
 703
 704     // initialize all values to unknown so that device specific
 705     //   driver layer need only fill in those entries that it is aware of.
 706     //   This allows extensibility of the structure without requiring users
 707     //   to re-code.
 708     inputStatus.lock = 0;
 709     inputStatus.sampleRateData = PAF_SAMPLERATE_UNKNOWN;
 710     inputStatus.sampleRateMeasured = PAF_SAMPLERATE_UNKNOWN;
 711     inputStatus.nonaudio = PAF_IEC_AUDIOMODE_UNKNOWN;
 712     inputStatus.emphasis = PAF_IEC_PREEMPHASIS_UNKNOWN;
 713
 714     //more configuration is needed to abstract out D10
 715     asipErrno = D10_RxControl(pRxParams,
 716                           (Uns)PAF_SIO_CONTROL_GET_INPUT_STATUS,
 717                           (Arg) &inputStatus);
 718     if (asipErrno)
 719         return asipErrno;
 720     pStatus->sampleRateData = inputStatus.sampleRateData;
 721     pStatus->sampleRateMeasured = inputStatus.sampleRateMeasured;
 722     pStatus->nonaudio = inputStatus.nonaudio;
 723     pStatus->emphasisData = inputStatus.emphasis;
 724
 725     // if MSB of override clear then use as reported lock
 726     // if = 0x80 then use default [0x81]
 727     // if = 0x81 then use measured (from device)
 728     // others not defined or implemented
 729     if ((pStatus->lockOverride & (XDAS_Int8)0x80) == 0)
 730         pStatus->lock = pStatus->lockOverride;
 731     else if (pStatus->lockOverride == (XDAS_Int8)0x80)
 732         pStatus->lock = inputStatus.lock;
 733     else if (pStatus->lockOverride == (XDAS_Int8)0x81)
 734         pStatus->lock = inputStatus.lock;
 735
 736     // if MSB of override clear then use it as sample rate for system,
 737     // if = 0x80 then use default [0x82]
 738     // if = 0x81 then use data
 739     // if = 0x82 then use measured
 740     // others not defined or implemented
 741     if ((pStatus->sampleRateOverride & (XDAS_Int8)0x80) == 0)
 742         pStatus->sampleRateStatus = pStatus->sampleRateOverride;
 743     else if (pStatus->sampleRateOverride == (XDAS_Int8)0x80)
 744         pStatus->sampleRateStatus = pStatus->sampleRateMeasured;
 745     else if (pStatus->sampleRateOverride == (XDAS_Int8)0x81)
 746         pStatus->sampleRateStatus = pStatus->sampleRateData;
 747     else if (pStatus->sampleRateOverride == (XDAS_Int8)0x82)
 748         pStatus->sampleRateStatus = pStatus->sampleRateMeasured;
 749
 750     // Update emphasis status:
 751     if ((pStatus->emphasisOverride & (XDAS_Int8)0x80) == 0) {
 752         if (pStatus->emphasisData == PAF_IEC_PREEMPHASIS_YES)
 753             pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_YES;
 754         else
 755             pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_NO;
 756     }
 757     else if (pStatus->emphasisOverride ==
 758              (XDAS_Int8 )(0x80+PAF_IEC_PREEMPHASIS_YES))
 759         pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_YES;
 760     else /* IBEmphasisOverrideNo or other */
 761         pStatus->emphasisStatus = PAF_IEC_PREEMPHASIS_NO;
 762
 763     // Update precision control
 764     pInpBuf->precision = pStatus->precisionInput =
 765         pStatus->precisionOverride < 0
 766         ? pStatus->precisionDefault
 767         : pStatus->precisionOverride > 0
 768         ? pStatus->precisionOverride
 769         : pStatus->precisionDetect > 0
 770         ? pStatus->precisionDetect
 771         : pStatus->precisionDefault;
 772
 773     return 0;
 774 }
 775
 776
 777 /*=============================================================================
 778  *  Main function of ASIP processing
 779  *============================================================================*/
 780 #define INPUT_SWITCH_HANGOVER 8
 781
 782 Int asipProcessing(PAF_AST_Config *pAstCfg, PAF_AST_IoInp  *pInp)
 783 {
 784     int autoDetstatus, syncState;
 785     Audk2g_STATUS mcaspStatus;
 786
 787     ioDataCtl_t ioDataCtl;
 788     ioPhyCtl_t  ioPhyCtl;
 789
 790     if(pInp->asipProcState == ASIP_SWITCH_TO_PCM) {
 791         // When switching to PCM, McASP RFMT register will be modified,
 792         // which will cause all 0's in one McASP LLD transfer. This will
 793         // be detected as loss of SYNC by auto detection. To prevent that,
 794         // skip I/O DATA process for hangover period so that this all 0's
 795         // frame will not be seen by auto-detection. Also, playing out PCM
 796         // needs to be skipped as well, to prevent from playing out garbage
 797         // (16-bit packed data).
 798         void *buff1, *buff2;
 799         size_t size1, size2;
 800
 801         // Get read pointers (or sub-buffers) of the input buffer
 802         if (ioBuffGetReadPtrs(pInp->hIoBuff, pInp->phyXferSize,
 803                               &buff1, &size1, &buff2, &size2)
 804             == IOBUFF_ERR_UNDERFLOW) {
 805             //printf("Input buffer underflows during switch hangover!\n");
 806             return ASIP_ERR_SWITCH_TO_PCM;
 807         }
 808
 809         ioBuffReadComplete(pInp->hIoBuff, buff1, size1);
 810
 811         if(buff2 != NULL) {
 812             ioBuffReadComplete(pInp->hIoBuff, buff2, size2);
 813         }
 814     }
 815     else {
 816         // Perform auto-detection when not switching
 817         autoDetstatus = ioDataProcess(pInp->hIoData);
 818         if(autoDetstatus == IODATA_ERR_IOBUF_UNDERFLOW) {
 819             // Input buffer underflows - no action is needed
 820             //printf("Input buffer underflows.\n");
 821             pInp->numUnderflow += 1;
 822
 823             // Return since there is no enough data to process
 824             return ASIP_NO_ERR;
 825         }
 826         else if(autoDetstatus != IODATA_NO_ERR) {
 827             // Something run happens: print error log and return
 828             //printf("IODATA processing error!\n");
 829             return ASIP_ERR_AUTO_DETECION;
 830         }
 831         else {
 832             // Normal operation - check auto-detection status
 833             ioDataCtl.code = IODATA_CTL_GET_AUTODET_STATUS;
 834             ioDataControl(pInp->hIoData, &ioDataCtl);
 835
 836             syncState = ioDataCtl.param.autoDetStats.syncState;
 837         }
 838     }
 839
 840     switch(pInp->asipProcState)
 841     {
 842     case ASIP_SOURCE_DETECTION:
 843         // zero out the output buffer
 844         rxDecodePlayZero(pInp);
 845
 846         ioDataReadComplete(pInp->hIoData);
 847
 848         if(syncState == IODATA_SYNC_BITSTREAM) {
 849             // Change I/O PHY transfer size to be the same as the bitstream frame size
 850             int frameSize;
 851             uint_least16_t pc = ioDataCtl.param.autoDetStats.bitStreamInfo & SYNC_PC_MASK; //0x001F
 852             frameSize = iecFrameLength[pc] * WORD_SIZE_BITSTREAM;
 853
 854             ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
 855             ioPhyCtl.params.xferFrameSize = frameSize;
 856             ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
 857             pInp->phyXferSize = ioPhyCtl.params.xferFrameSize;
 858
 859             pInp->asipProcState = ASIP_DECODE_BITSTREAM;
 860             pInp->numFrameReceived = 1;
 861         }
 862         else if(syncState == IODATA_SYNC_PCM) {
 863             // reconfigure McASP LLD to transfer 32-bit unpacked data
 864             mcaspStatus = mcaspRecfgWordWidth(hMcaspRxChan, Mcasp_WordLength_32);
 865             if(mcaspStatus != Audk2g_EOK) {
 866                 return ASIP_ERR_MCASP_CFG;
 867             }
 868
 869             // Change I/O PHY transfer size to PCM frame size
 870             ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
 871             ioPhyCtl.params.xferFrameSize = INPUT_FRAME_SIZE_PCM;
 872             ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
 873             pInp->phyXferSize = ioPhyCtl.params.xferFrameSize;
 874
 875             // Adjust I/O BUFF delay and read pointer - to make sure read pointers always point to
 876             // PCM data from 1st I2S (out of 4 for HDMI 4xI2S)
 877             // Adjust delay and don't mark input buffer as read complete
 878             ioBuffAdjustDelay(pInp->hIoBuff, pInp->phyXferSize);
 879
 880             // Stop swapping data
 881             pInp->swapData = FALSE;
 882
 883             // Go to transition state to switch to PCM
 884             pInp->asipProcState = ASIP_SWITCH_TO_PCM;
 885             pInp->switchHangOver = INPUT_SWITCH_HANGOVER;
 886
 887             pInp->numPcmFrameReceived = 0;
 888         }
 889         else {
 890             // Source is still unknown - take no action
 891             ;
 892         }
 893         break;
 894
 895     case ASIP_DECODE_BITSTREAM:
 896         if (syncState == IODATA_SYNC_NONE) {
 897             // Change I/O PHY transfer size to default
 898             ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
 899             ioPhyCtl.params.xferFrameSize = INPUT_FRAME_SIZE_DEF;
 900             ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
 901             pInp->phyXferSize  = ioPhyCtl.params.xferFrameSize;
 902
 903             pInp->numFrameReceived = 0;
 904             pInp->asipProcState  = ASIP_SOURCE_DETECTION;
 905         }
 906         else {
 907             pInp->numFrameReceived += 1;
 908
 909             rxDecodeBitStream(pInp);
 910
 911             ioDataReadComplete(pInp->hIoData);
 912         }
 913         break;
 914
 915     case ASIP_SWITCH_TO_PCM:
 916         // zero out the output buffer
 917         rxDecodePlayZero(pInp);
 918
 919         pInp->switchHangOver--;
 920         if(pInp->switchHangOver == 0) {
 921             pInp->asipProcState = ASIP_DECODE_PCM;
 922             // send message to decoder
 923         }
 924         break;
 925
 926     case ASIP_DECODE_PCM:
 927         if (syncState == IODATA_SYNC_NONE) {
 928             // reconfigure McASP LLD to receive 16-bit packed bits
 929             mcaspStatus = mcaspRecfgWordWidth(hMcaspRxChan, Mcasp_WordLength_16);
 930             if(mcaspStatus != Audk2g_EOK) {
 931                 return ASIP_ERR_MCASP_CFG;
 932             }
 933
 934             // Change I/O PHY transfer size to default
 935             ioPhyCtl.code = IOPHY_CTL_FRAME_SIZE;
 936             ioPhyCtl.params.xferFrameSize = INPUT_FRAME_SIZE_DEF;
 937             ioPhyControl(pInp->hIoPhy, &ioPhyCtl);
 938             pInp->phyXferSize  = ioPhyCtl.params.xferFrameSize;
 939
 940             // Start swapping data
 941             pInp->swapData = TRUE;
 942             pInp->numPcmFrameReceived = 0;
 943
 944             pInp->asipProcState = ASIP_SOURCE_DETECTION;
 945         }
 946         else {
 947             pInp->numPcmFrameReceived += 1;
 948
 949             rxDecodePcm(pInp);
 950
 951             ioDataReadComplete(pInp->hIoData);
 952         }
 953
 954         break;
 955
 956     default:
 957         break;
 958     }
 959
 960     return 0;
 961 } /* asipProcessing */
 962
 963 #ifndef IO_LOOPBACK_TEST
 964 Int rxDecodePcm(PAF_AST_IoInp  *pInp)
 965 {
 966     return ASIP_NO_ERR;
 967 }
 968
 969 Int rxDecodeBitStream(PAF_AST_IoInp  *pInp)
 970 {
 971     return ASIP_NO_ERR;
 972 }
 973
 974 Int rxDecodePlayZero(PAF_AST_IoInp  *pInp)
 975 {
 976     return ASIP_NO_ERR;
 977 }
 978 #endif
 979
 980 void asipErrorHandling(PAF_AST_Config *pAstCfg, int asipErrno)
 981 {
 982
 983 }
 984
 985 /* Nothing past this line */