aif2fl_getHwStatusAux.h

   1 /*  ============================================================================
   2  *   Copyright (c) Texas Instruments Incorporated 2008, 2009
   3  *
   4  *  Redistribution and use in source and binary forms, with or without
   5  *  modification, are permitted provided that the following conditions
   6  *  are met:
   7  *
   8  *    Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *
  11  *    Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  *    Neither the name of Texas Instruments Incorporated nor the names of
  17  *    its contributors may be used to endorse or promote products derived
  18  *    from this software without specific prior written permission.
  19  *
  20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  */
  33
  34 /** ============================================================================
  35  *   @file  aif2fl_getHwStatusAux.h
  36  *
  37  *   @brief  API Auxilary header file for Antenna Interface 2 set HW status
  38  *
  39  */
  40
  41 /* =============================================================================
  42  * Revision History
  43  * ===============
  44  *  03-Jun-2009 Albert  File Created.
  45 *  06-June-2015  Seb      File imported in the driver
  46  *
  47  * =============================================================================
  48  */
  49
  50 #ifndef _AIF2FLGETHWSTATUSAUX_H_
  51 #define _AIF2FLGETHWSTATUSAUX_H_
  52
  53 #include <ti/drv/aif2/aif2fl.h>
  54
  55 #ifdef __cplusplus
  56 extern "C" {
  57 #endif
  58
  59
  60 /**
  61  *  Get Hardware Status Functions of Antenna Interface 2
  62  */
  63
  64 /** ============================================================================
  65  *   @n@b Aif2Fl_getVersion
  66  *
  67  *   @b Description
  68  *   @n This function returns AIF2 version
  69  *
  70  *   @b Arguments
  71  *   @verbatim
  72
  73             hAif2        Handle to the aif2 instance
  74             version     Pointer to get the version instance.
  75
  76      @endverbatim
  77  *
  78  *   <b> Return Value </b>  None
  79  *
  80  *   <b> Pre Condition </b>
  81  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
  82  *   in that order before calling this function.
  83
  84  *
  85  *   <b> Post Condition </b>
  86  *   @n None
  87  *
  88  *   @b Reads
  89  *   @n AIF2_AIF2_PID_MINOR,AIF2_AIF2_PID_CUSTOM,AIF2_AIF2_PID_MAJOR,
  90  *        AIF2_AIF2_PID_RTL,AIF2_AIF2_PID_FUNC,AIF2_AIF2_PID_SCHEME
  91  *   @b Example
  92  *   @verbatim
  93         Aif2Fl_PidStatus   version;
  94         Aif2Fl_getVersion (hAif2,  &version);
  95      @endverbatim
  96  * ===========================================================================
  97  */
  98 static inline
  99 void Aif2Fl_getVersion (Aif2Fl_Handle   hAif2, Aif2Fl_PidStatus*   version)
 100 {
 101         uint32_t tmpReg;
 102         tmpReg = hAif2->regs->AIF2_PID;
 103         version->minor = CSL_FEXT(tmpReg, AIF2_AIF2_PID_MINOR);
 104         version->custom = CSL_FEXT(tmpReg, AIF2_AIF2_PID_CUSTOM);
 105         version->major = CSL_FEXT(tmpReg, AIF2_AIF2_PID_MAJOR);
 106         version->RTL = CSL_FEXT(tmpReg, AIF2_AIF2_PID_RTL);
 107         version->func = CSL_FEXT(tmpReg, AIF2_AIF2_PID_FUNC);
 108         version->scheme = CSL_FEXT(tmpReg, AIF2_AIF2_PID_SCHEME);
 109 }
 110
 111
 112 /** ============================================================================
 113  *   @n@b Aif2Fl_getVcStat
 114  *
 115  *   @b Description
 116  *   @n This function return the status of VC emu status
 117  *
 118  *   @b Arguments
 119  *   @verbatim
 120
 121            hAif2      Handle to the aif2 instance
 122
 123      @endverbatim
 124  *
 125  *   <b> Return Value </b>  uint16_t
 126  *   <b> Pre Condition </b>
 127  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 128  *   in that order before calling this function.
 129  *
 130  *   <b> Post Condition </b>
 131  *   @n None
 132  *
 133  *   @b Reads
 134  *   @n AIF2_VC_STAT_EMU_HALT
 135  *
 136  *
 137  *   @b Example
 138  *   @verbatim
 139         uint16_t emu_sts;
 140         emu_sts = Aif2Fl_getVcStat (hAif2);
 141      @endverbatim
 142  * ===========================================================================
 143  */
 144 static inline
 145 uint16_t Aif2Fl_getVcStat (
 146         Aif2Fl_Handle   hAif2
 147 )
 148 {
 149         return CSL_FEXT(hAif2->regs->VC_STAT, AIF2_VC_STAT_EMU_HALT);
 150 }
 151
 152
 153 /** ============================================================================
 154  *   @n@b Aif2Fl_getSdRxLinkStatus
 155  *
 156  *   @b Description
 157  *   @n This function return the status of SD Rx link status
 158  *
 159  *   @b Arguments
 160  *   @verbatim
 161
 162            hAif2      Handle to the aif2 instance
 163            Aif2Fl_SdRxStatus*       pSdRxStat
 164      @endverbatim
 165  *
 166  *   <b> Return Value </b> void
 167  *   <b> Pre Condition </b>
 168  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 169  *   in that order before calling this function.
 170  *
 171  *   <b> Post Condition </b>
 172  *   @n None
 173  *
 174  *   @b Reads
 175  *   @n  AIF2_SD_RX_STS_RXSYNC,AIF2_SD_RX_STS_RXLOSS_OF_SIGNAL,
 176  *         AIF2_SD_RX_STS_RXADAPT_DONE
 177  *   @b Example
 178  *   @verbatim
 179         Aif2Fl_SdRxStatus       SdRxStat;
 180         .....
 181         Aif2Fl_getSdRxLinkStatus (hAif2, &SdRxStat );
 182      @endverbatim
 183  * ===========================================================================
 184  */
 185 static inline
 186 void Aif2Fl_getSdRxLinkStatus (
 187         Aif2Fl_Handle   hAif2,
 188         Aif2Fl_SdRxStatus*       pSdRxStat
 189 )
 190 {
 191     pSdRxStat->sdRxSync = CSL_FEXT(hAif2->regs->SD_LK[hAif2->arg_link].SD_RX_STS,AIF2_SD_RX_STS_RXSYNC);
 192     pSdRxStat->sdRxLosDetect = CSL_FEXT(hAif2->regs->SD_LK[hAif2->arg_link].SD_RX_STS,AIF2_SD_RX_STS_RXLOSS_OF_SIGNAL);
 193 #ifdef K2
 194     pSdRxStat->sdRxAdaptDone = CSL_FEXT(hAif2->regs->SD_LK[hAif2->arg_link].SD_RX_STS,AIF2_SD_RX_STS_RXADAPT_DONE);
 195 #endif
 196 }
 197
 198 #ifndef K2
 199 /** ============================================================================
 200  *   @n@b Aif2Fl_getSdTxLinkStatus
 201  *
 202  *   @b Description
 203  *   @n This function return the status of SD Tx link status
 204  *
 205  *   @b Arguments
 206  *   @verbatim
 207
 208            hAif2      Handle to the aif2 instance
 209            Aif2Fl_SdTxStatus*       pSdTxStat
 210      @endverbatim
 211  *
 212  *   <b> Return Value </b> void
 213  *   <b> Pre Condition </b>
 214   *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 215  *   in that order before calling this function.
 216  *
 217  *   <b> Post Condition </b>
 218  *   @n None
 219  *
 220  *   @b Reads
 221  *   @n  AIF2_SD_TX_STS_TXBUS_BANDWIDTH,AIF2_SD_TX_STS_TXTEST_FAILURE
 222  *
 223  *   @b Example
 224  *   @verbatim
 225         Aif2Fl_SdTxStatus       SdTxStat;
 226         .....
 227         Aif2Fl_getSdTxLinkStatus (hAif2, &SdTxStat );
 228      @endverbatim
 229  * ===========================================================================
 230  */
 231 static inline
 232 void Aif2Fl_getSdTxLinkStatus (
 233         Aif2Fl_Handle   hAif2,
 234         Aif2Fl_SdTxStatus*       pSdTxStat
 235 )
 236 {
 237     pSdTxStat->sdTxBusWidth= CSL_FEXT(hAif2->regs->SD_LK[hAif2->arg_link].SD_TX_STS,AIF2_SD_TX_STS_TXBUS_BANDWIDTH);
 238     pSdTxStat->sdTxTestFail= CSL_FEXT(hAif2->regs->SD_LK[hAif2->arg_link].SD_TX_STS,AIF2_SD_TX_STS_TXTEST_FAILURE);
 239 }
 240 #endif
 241
 242 /** ============================================================================
 243  *   @n@b Aif2Fl_getSdB8PllLock
 244  *
 245  *   @b Description
 246  *   @n This function return the status of B8 PLL lock
 247  *
 248  *   @b Arguments
 249  *   @verbatim
 250
 251            hAif2      Handle to the aif2 instance
 252
 253      @endverbatim
 254  *
 255  *   <b> Return Value </b>  uint8_t
 256  *   <b> Pre Condition </b>
 257  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 258  *   in that order before calling this function.
 259  *
 260  *   <b> Post Condition </b>
 261  *   @n None
 262  *
 263  *   @b Reads
 264  *   @n AIF2_SD_PLL_B8_STS_B8PLL_LOCK
 265  *
 266  *
 267  *   @b Example
 268  *   @verbatim
 269         uint8_t lock_sts;
 270         lock_sts = Aif2Fl_getSdB8PllLock (hAif2);
 271      @endverbatim
 272  * ===========================================================================
 273  */
 274 static inline
 275 uint8_t Aif2Fl_getSdB8PllLock (
 276         Aif2Fl_Handle   hAif2
 277 )
 278 {
 279         return CSL_FEXT(hAif2->regs->SD_PLL_B8_STS, AIF2_SD_PLL_B8_STS_B8PLL_LOCK);
 280 }
 281
 282
 283 /** ============================================================================
 284  *   @n@b Aif2Fl_getSdB4PllLock
 285  *
 286  *   @b Description
 287  *   @n This function return the status of B4 PLL lock
 288  *
 289  *   @b Arguments
 290  *   @verbatim
 291
 292            hAif2      Handle to the aif2 instance
 293
 294      @endverbatim
 295  *
 296  *   <b> Return Value </b>  uint8_t
 297  *   <b> Pre Condition </b>
 298  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 299  *   in that order before calling this function.
 300  *
 301  *
 302  *   <b> Post Condition </b>
 303  *   @n None
 304  *
 305  *   @b Reads
 306  *   @n AIF2_SD_PLL_B4_STS_B4PLL_LOCK
 307  *
 308  *
 309  *   @b Example
 310  *   @verbatim
 311         uint8_t lock_sts;
 312         lock_sts = Aif2Fl_getSdB4PllLock (hAif2);
 313      @endverbatim
 314  * ===========================================================================
 315  */
 316 static inline
 317 uint8_t Aif2Fl_getSdB4PllLock (
 318         Aif2Fl_Handle   hAif2
 319 )
 320 {
 321         return CSL_FEXT(hAif2->regs->SD_PLL_B4_STS, AIF2_SD_PLL_B4_STS_B4PLL_LOCK);
 322 }
 323
 324
 325 /** ============================================================================
 326  *   @n@b Aif2Fl_getRmLinkStatus0
 327  *
 328  *   @b Description
 329  *   @n This function gets the  RM  link Status 0
 330  *
 331  *   @b Arguments
 332  *   @verbatim
 333            hAif2      Handle to the aif2 instance. should use arg_link to select link
 334            Aif2Fl_RmStatus0       Pointer to the RM link Status instance.
 335      @endverbatim
 336  *
 337  *   <b> Return Value </b>  None
 338  *   <b> Pre Condition </b>
 339  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 340  *   in that order before calling this function.
 341  *
 342  *   <b> Post Condition </b>
 343  *   @n None
 344  *
 345  *   @b Reads
 346  *   @n AIF2_RM_LK_STS0_SYNC_STATUS,AIF2_RM_LK_STS0_LOS,AIF2_RM_LK_STS0_NUM_LOS_DET,
 347  *        AIF2_RM_LK_STS0_LOC,AIF2_RM_LK_STS0_FIFO_OVF
 348  *
 349  *   @b Example
 350  *   @verbatim
 351          Aif2Fl_RmStatus0     RmStat;
 352          hAif2->arg_link = 1; //get link1 status
 353         Aif2Fl_getRmLinkStatus0 (hAif2, &RmStat);
 354      @endverbatim
 355  * ===========================================================================
 356  */
 357 static inline
 358 void Aif2Fl_getRmLinkStatus0 (
 359         Aif2Fl_Handle   hAif2,
 360         Aif2Fl_RmStatus0*    pRmStat
 361 )
 362 {
 363     pRmStat->rmSyncStatus = (Aif2Fl_RmSyncState)CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS0,AIF2_RM_LK_STS0_SYNC_STATUS);
 364     pRmStat->rmLos = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS0,AIF2_RM_LK_STS0_LOS);
 365     pRmStat->rmNumLosDetect = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS0,AIF2_RM_LK_STS0_NUM_LOS_DET);
 366     pRmStat->rmLoc = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS0,AIF2_RM_LK_STS0_LOC);
 367     pRmStat->rmFifoOverflow = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS0,AIF2_RM_LK_STS0_FIFO_OVF);
 368
 369 }
 370
 371
 372 /** ============================================================================
 373  *   @n@b Aif2Fl_getRmLinkStatus1
 374  *
 375  *   @b Description
 376  *   @n This function gets the  RM  link Status 1
 377  *
 378  *   @b Arguments
 379  *   @verbatim
 380            hAif2      Handle to the aif2 instance. should use arg_link to select link
 381            Aif2Fl_RmStatus1       Pointer to the RM link Status instance.
 382      @endverbatim
 383  *
 384  *   <b> Return Value </b>  None
 385  *   <b> Pre Condition </b>
 386  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 387  *   in that order before calling this function.
 388  *
 389  *   <b> Post Condition </b>
 390  *   @n None
 391  *
 392  *   @b Reads
 393  *   @n AIF2_RM_LK_STS1_NUM_LOS,AIF2_RM_LK_STS1_LCV_CNTR_VALUE
 394  *
 395  *
 396  *   @b Example
 397  *   @verbatim
 398          Aif2Fl_RmStatus1     RmStat;
 399          hAif2->arg_link = 1; //get link1 status
 400         Aif2Fl_getRmLinkStatus1 (hAif2, &RmStat);
 401      @endverbatim
 402  * ===========================================================================
 403  */
 404 static inline
 405 void Aif2Fl_getRmLinkStatus1 (
 406         Aif2Fl_Handle   hAif2,
 407         Aif2Fl_RmStatus1*    pRmStat
 408 )
 409 {
 410     pRmStat->rmNumLos = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS1,AIF2_RM_LK_STS1_NUM_LOS);
 411     pRmStat->rmLcvCountValue = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS1,AIF2_RM_LK_STS1_LCV_CNTR_VALUE);
 412
 413 }
 414
 415
 416 /** ============================================================================
 417  *   @n@b Aif2Fl_getRmLinkStatus2
 418  *
 419  *   @b Description
 420  *   @n This function gets the  RM  link Status 2
 421  *
 422  *   @b Arguments
 423  *   @verbatim
 424            hAif2      Handle to the aif2 instance. should use arg_link to select link
 425            Aif2Fl_RmStatus2       Pointer to the RM link Status instance.
 426      @endverbatim
 427  *
 428  *   <b> Return Value </b>  None
 429  *   <b> Pre Condition </b>
 430  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 431  *   in that order before calling this function.
 432  *
 433  *   <b> Post Condition </b>
 434  *   @n None
 435  *
 436  *   @b Reads
 437  *   @n AIF2_RM_LK_STS2_CLK_QUAL,AIF2_RM_LK_STS2_SCR_VALUE
 438  *
 439  *
 440  *   @b Example
 441  *   @verbatim
 442          Aif2Fl_RmStatus2     RmStat;
 443          hAif2->arg_link = 1; //get link1 status
 444         Aif2Fl_getRmLinkStatus2 (hAif2, &RmStat);
 445      @endverbatim
 446  * ===========================================================================
 447  */
 448 static inline
 449 void Aif2Fl_getRmLinkStatus2 (
 450         Aif2Fl_Handle   hAif2,
 451         Aif2Fl_RmStatus2*    pRmStat
 452 )
 453 {
 454     pRmStat->rmClockQuality = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS2,AIF2_RM_LK_STS2_CLK_QUAL);
 455     pRmStat->rmScrValue = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS2,AIF2_RM_LK_STS2_SCR_VALUE);
 456
 457 }
 458
 459 /** ============================================================================
 460  *   @n@b Aif2Fl_getRmLinkStatus3
 461  *
 462  *   @b Description
 463  *   @n This function gets the  RM  link Status 3
 464  *
 465  *   @b Arguments
 466  *   @verbatim
 467            hAif2      Handle to the aif2 instance. should use arg_link to select link
 468            Aif2Fl_RmStatus3       Pointer to the RM link Status instance.
 469      @endverbatim
 470  *
 471  *   <b> Return Value </b>  None
 472  *   <b> Pre Condition </b>
 473  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 474  *   in that order before calling this function.
 475  *
 476  *   <b> Post Condition </b>
 477  *   @n None
 478  *
 479  *   @b Reads
 480  *   @n AIF2_RM_LK_STS3_HFN,AIF2_RM_LK_STS3_BFN_LOW,AIF2_RM_LK_STS3_BFN_HIGH,
 481  *        AIF2_RM_LK_STS3_HFSYNC_STATE,AIF2_RM_LK_STS3_LOF_STATE
 482  *
 483  *   @b Example
 484  *   @verbatim
 485          Aif2Fl_RmStatus3     RmStat;
 486          hAif2->arg_link = 1; //get link1 status
 487         Aif2Fl_getRmLinkStatus3 (hAif2, &RmStat);
 488      @endverbatim
 489  * ===========================================================================
 490  */
 491 static inline
 492 void Aif2Fl_getRmLinkStatus3 (
 493         Aif2Fl_Handle   hAif2,
 494         Aif2Fl_RmStatus3*    pRmStat
 495 )
 496 {
 497     pRmStat->rmHfn = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS3,AIF2_RM_LK_STS3_HFN);
 498     pRmStat->rmBfnLow = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS3,AIF2_RM_LK_STS3_BFN_LOW);
 499     pRmStat->rmBfnHigh = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS3,AIF2_RM_LK_STS3_BFN_HIGH);
 500     pRmStat->rmHfsyncState = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS3,AIF2_RM_LK_STS3_HFSYNC_STATE);
 501     pRmStat->rmLofState = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS3,AIF2_RM_LK_STS3_LOF_STATE);
 502
 503 }
 504
 505
 506 /** ============================================================================
 507  *   @n@b Aif2Fl_getRmLinkStatus4
 508  *
 509  *   @b Description
 510  *   @n This function gets the  RM  link Status 4
 511  *
 512  *   @b Arguments
 513  *   @verbatim
 514            hAif2      Handle to the aif2 instance. should use arg_link to select link
 515            Aif2Fl_RmStatus4       Pointer to the RM link Status instance.
 516      @endverbatim
 517  *
 518  *   <b> Return Value </b>  None
 519  *   <b> Pre Condition </b>
 520  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 521  *   in that order before calling this function.
 522  *
 523  *   <b> Post Condition </b>
 524  *   @n None
 525  *
 526  *   @b Reads
 527  *   @n AIF2_RM_LK_STS4_L1_VERSION,AIF2_RM_LK_STS4_L1_START_UP,AIF2_RM_LK_STS4_L1_RCVD_RST,
 528  *        AIF2_RM_LK_STS4_L1_RCVD_RAI,AIF2_RM_LK_STS4_L1_RCVD_SDI,AIF2_RM_LK_STS4_L1_RCVD_LOS,
 529  *        AIF2_RM_LK_STS4_L1_RCVD_LOF,AIF2_RM_LK_STS4_L1_PNTR_P
 530  *   @b Example
 531  *   @verbatim
 532          Aif2Fl_RmStatus4     RmStat;
 533          hAif2->arg_link = 1; //get link1 status
 534         Aif2Fl_getRmLinkStatus4 (hAif2, &RmStat);
 535      @endverbatim
 536  * ===========================================================================
 537  */
 538 static inline
 539 void Aif2Fl_getRmLinkStatus4 (
 540         Aif2Fl_Handle   hAif2,
 541         Aif2Fl_RmStatus4*    pRmStat
 542 )
 543 {
 544     pRmStat->rmL1Version = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_VERSION);
 545     pRmStat->rmL1Startup = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_START_UP);
 546     pRmStat->rmL1RST = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_RCVD_RST);
 547     pRmStat->rmL1RAI = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_RCVD_RAI);
 548     pRmStat->rmL1SDI = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_RCVD_SDI);
 549     pRmStat->rmL1LOS = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_RCVD_LOS);
 550     pRmStat->rmL1LOF = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_RCVD_LOF);
 551     pRmStat->rmL1PointerP = CSL_FEXT(hAif2->regs->G_RM_LKS[hAif2->arg_link].RM_LK_STS4,AIF2_RM_LK_STS4_L1_PNTR_P);
 552
 553 }
 554
 555
 556 /** ============================================================================
 557  *   @n@b Aif2Fl_getTmCpriHfnStatus
 558  *
 559  *   @b Description
 560  *   @n This function return the status of TM CPRI HFN status
 561  *
 562  *   @b Arguments
 563  *   @verbatim
 564
 565            hAif2      Handle to the aif2 instance. should use arg_link to select link
 566
 567      @endverbatim
 568  *
 569  *   <b> Return Value </b>  uint8_t
 570  *   <b> Pre Condition </b>
 571  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 572  *   in that order before calling this function.
 573  *
 574  *
 575  *   <b> Post Condition </b>
 576  *   @n None
 577  *
 578  *   @b Reads
 579  *   @n AIF2_TM_LK_HFN_HFN
 580  *
 581  *
 582  *   @b Example
 583  *   @verbatim
 584         uint8_t hfn_sts;
 585         hAif2->arg_link = LINK1;
 586         hfn_sts = Aif2Fl_getTmCpriHfnStatus (hAif2);
 587      @endverbatim
 588  * ===========================================================================
 589  */
 590 static inline
 591 uint8_t Aif2Fl_getTmCpriHfnStatus (
 592         Aif2Fl_Handle   hAif2
 593 )
 594 {
 595         return CSL_FEXT(hAif2->regs->G_TM_LKS[hAif2->arg_link].TM_LK_HFN, AIF2_TM_LK_HFN_HFN);
 596 }
 597
 598
 599 /** ============================================================================
 600  *   @n@b Aif2Fl_getTmLinkStatus
 601  *
 602  *   @b Description
 603  *   @n This function gets the  TM  link Status
 604  *
 605  *   @b Arguments
 606  *   @verbatim
 607
 608            hAif2      Handle to the aif2 instance. should use arg_link to select link
 609            pTmStat       Pointer to the TM link Status instance.
 610
 611      @endverbatim
 612  *
 613  *   <b> Return Value </b>  None
 614  *   <b> Pre Condition </b>
 615  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 616  *   in that order before calling this function.
 617  *
 618  *   @n  None
 619  *
 620  *   <b> Post Condition </b>
 621  *   @n None
 622  *
 623  *   @b Reads
 624  *   @n AIF2_TM_LK_STAT_TM_FAIL,AIF2_TM_LK_STAT_FIFO_UNFL,
 625  *        AIF2_TM_LK_STAT_FRM_MISALIGN,AIF2_TM_LK_STAT_FRM_STATE
 626  *
 627  *   @b Example
 628  *   @verbatim
 629          Aif2Fl_TmStatus     TmStat;
 630          hAif2->arg_link = 1; //get Tm link1 status
 631         Aif2Fl_getTmLinkStatus (hAif2, &TmStat);
 632      @endverbatim
 633  * ===========================================================================
 634  */
 635 static inline
 636 void Aif2Fl_getTmLinkStatus (
 637         Aif2Fl_Handle   hAif2,
 638         Aif2Fl_TmStatus*    pTmStat
 639 )
 640 {
 641     pTmStat->tmFail = CSL_FEXT(hAif2->regs->G_TM_LKS[hAif2->arg_link].TM_LK_STAT,AIF2_TM_LK_STAT_TM_FAIL);
 642     pTmStat->tmFifoUnderflow = CSL_FEXT(hAif2->regs->G_TM_LKS[hAif2->arg_link].TM_LK_STAT,AIF2_TM_LK_STAT_FIFO_UNFL);
 643     pTmStat->tmFrameMisalign = CSL_FEXT(hAif2->regs->G_TM_LKS[hAif2->arg_link].TM_LK_STAT,AIF2_TM_LK_STAT_FRM_MISALIGN);
 644     pTmStat->tmFrameStatus = (Aif2Fl_TmSyncState)CSL_FEXT(hAif2->regs->G_TM_LKS[hAif2->arg_link].TM_LK_STAT,AIF2_TM_LK_STAT_FRM_STATE);
 645
 646 }
 647
 648
 649 /** ============================================================================
 650  *   @n@b Aif2Fl_getRtFifoDepthStatus
 651  *
 652  *   @b Description
 653  *   @n RT Internal FIFO depth Status.
 654  *
 655  *   @b Arguments
 656  *   @verbatim
 657            hAif2      Handle to the aif2 instance. should use arg_link to select link
 658      @endverbatim
 659  *
 660  *   <b> Return Value </b>  uint8_t
 661  *   <b> Pre Condition </b>
 662  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 663  *   in that order before calling this function.
 664  *
 665  *   <b> Post Condition </b>
 666  *   @n None
 667  *
 668  *   @b Reads
 669  *   @n AIF2_RT_LK_DPTH_RT_DEPTH
 670  *
 671  *   @b Example
 672  *   @verbatim
 673         uint8_t depth;
 674         hAif2->arg_link = LINK1;
 675         depth = Aif2Fl_getRtFifoDepthStatus (hAif2);
 676      @endverbatim
 677  * ===========================================================================
 678  */
 679 static inline
 680 uint8_t Aif2Fl_getRtFifoDepthStatus (
 681         Aif2Fl_Handle   hAif2
 682 )
 683 {
 684         return CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_LK_DPTH, AIF2_RT_LK_DPTH_RT_DEPTH);
 685 }
 686
 687
 688 /** ============================================================================
 689  *   @n@b Aif2Fl_getRtHeaderStatus
 690  *
 691  *   @b Description
 692  *   @n This function gets the  Retransmitter  link Status
 693  *
 694  *   @b Arguments
 695  *   @verbatim
 696            hAif2      Handle to the aif2 instance. should use arg_link to select link
 697            pRtStat       Pointer to the retransmitter header Status instance.
 698      @endverbatim
 699  *
 700  *   <b> Return Value </b>  None
 701  *   <b> Pre Condition </b>
 702  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 703  *   in that order before calling this function.
 704  *
 705  *   @n  None
 706  *
 707  *   <b> Post Condition </b>
 708  *   @n None
 709  *
 710  *   @b Reads
 711  *   @n AIF2_RT_HDR_ERR_DMA_CHAN,AIF2_RT_HDR_ERR_HDR_ERR
 712  *
 713  *   @b Example
 714  *   @verbatim
 715          Aif2Fl_RtHeaderStatus     RtStat;
 716          hAif2->arg_link = 1; //get Rt link1 status
 717         Aif2Fl_getRtHeaderStatus (hAif2, &RtStat);
 718      @endverbatim
 719  * ===========================================================================
 720  */
 721 static inline
 722 void Aif2Fl_getRtHeaderStatus (
 723         Aif2Fl_Handle   hAif2,
 724         Aif2Fl_RtHeaderStatus*    pRtStat
 725 )
 726 {
 727     pRtStat->HeaderError = CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_HDR_ERR,AIF2_RT_HDR_ERR_HDR_ERR);
 728     pRtStat->DmaChannel = CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_HDR_ERR,AIF2_RT_HDR_ERR_DMA_CHAN);
 729 }
 730
 731
 732 /** ============================================================================
 733  *   @n@b Aif2Fl_getRtLinkStatus
 734  *
 735  *   @b Description
 736  *   @n This function gets the  Retransmitter  link Status
 737  *
 738  *   @b Arguments
 739  *   @verbatim
 740
 741            hAif2      Handle to the aif2 instance. should use arg_link to select link
 742            pRtStat       Pointer to the retransmitter link Status instance.
 743
 744      @endverbatim
 745  *
 746  *   <b> Return Value </b>  None
 747  *   <b> Pre Condition </b>
 748  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 749  *   in that order before calling this function.
 750  *
 751  *   @n  None
 752  *
 753  *   <b> Post Condition </b>
 754  *   @n None
 755  *
 756  *   @b Reads
 757  *   @n AIF2_RT_LK_STAT_RT_HDR_ERR_STS,AIF2_RT_LK_STAT_RT_EM_STS,
 758  *        AIF2_RT_LK_STAT_RT_UNFL_STS,AIF2_RT_LK_STAT_RT_OVFL_STS,
 759  *        AIF2_RT_LK_STAT_RT_FRM_ERR_STS
 760  *   @b Example
 761  *   @verbatim
 762          Aif2Fl_RtStatus     RtStat;
 763          hAif2->arg_link = 1; //get Rt link1 status
 764         Aif2Fl_getRtLinkStatus (hAif2, &RtStat);
 765      @endverbatim
 766  * ===========================================================================
 767  */
 768 static inline
 769 void Aif2Fl_getRtLinkStatus (
 770         Aif2Fl_Handle   hAif2,
 771         Aif2Fl_RtStatus*    pRtStat
 772 )
 773 {
 774     pRtStat->rtHeaderError = CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_LK_STAT,AIF2_RT_LK_STAT_RT_HDR_ERR_STS);
 775     pRtStat->rtEmptyMessage = CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_LK_STAT,AIF2_RT_LK_STAT_RT_EM_STS);
 776     pRtStat->rtFifoUnderflow = CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_LK_STAT,AIF2_RT_LK_STAT_RT_UNFL_STS);
 777     pRtStat->rtFifoOverflow= CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_LK_STAT,AIF2_RT_LK_STAT_RT_OVFL_STS);
 778     pRtStat->rtFrameError= CSL_FEXT(hAif2->regs->G_RT_LKS[hAif2->arg_link].RT_LK_STAT,AIF2_RT_LK_STAT_RT_FRM_ERR_STS);
 779 }
 780
 781
 782 /** ============================================================================
 783  *   @n@b Aif2Fl_getPdChannelStatus
 784  *
 785  *   @b Description
 786  *   @n This function get PD 128 Channel Status.
 787  *
 788  *   @b Arguments
 789  *   @verbatim
 790            hAif2      Handle to the aif2 instance. should use arg_link to select link
 791            uint32_t*       Pointer to the PD channel Status instance.
 792      @endverbatim
 793  *
 794  *   <b> Return Value </b>  None
 795  *   <b> Pre Condition </b>
 796  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 797  *   in that order before calling this function.
 798  *
 799  *   @n  None
 800  *
 801  *   <b> Post Condition </b>
 802  *   @n None
 803  *
 804  *   @b Reads
 805  *   @n AIF2_PD_CHAN_STS_CHAN_ON
 806  *
 807  *   @b Example
 808  *   @verbatim
 809          uint32_t     PdChanStat[4];
 810
 811         Aif2Fl_getPdChannelStatus (hAif2, &PdChanStat);
 812      @endverbatim
 813  * ===========================================================================
 814  */
 815 static inline
 816 void Aif2Fl_getPdChannelStatus (
 817         Aif2Fl_Handle   hAif2,
 818         uint32_t*          ChanStat
 819 )
 820 {
 821     ChanStat[0] = CSL_FEXT(hAif2->regs->PD_CHAN_STS[0],AIF2_PD_CHAN_STS_CHAN_ON);
 822     ChanStat[1] = CSL_FEXT(hAif2->regs->PD_CHAN_STS[1],AIF2_PD_CHAN_STS_CHAN_ON);
 823     ChanStat[2] = CSL_FEXT(hAif2->regs->PD_CHAN_STS[2],AIF2_PD_CHAN_STS_CHAN_ON);
 824     ChanStat[3] = CSL_FEXT(hAif2->regs->PD_CHAN_STS[3],AIF2_PD_CHAN_STS_CHAN_ON);
 825 }
 826
 827
 828 /** ============================================================================
 829  *   @n@b Aif2Fl_getPdPacketStatus
 830  *
 831  *   @b Description
 832  *   @n This function get PD packet status for 128 Channels.
 833  *
 834  *   @b Arguments
 835  *   @verbatim
 836            hAif2      Handle to the aif2 instance. should use arg_link to select link
 837            uint32_t*       Pointer to the PD packet Status instance. bit 0: out packet  bit 1: in packet
 838      @endverbatim
 839  *
 840  *   <b> Return Value </b>  None
 841  *   <b> Pre Condition </b>
 842  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 843  *   in that order before calling this function.
 844  *
 845  *   @n  None
 846  *
 847  *   <b> Post Condition </b>
 848  *   @n None
 849  *
 850  *   @b Reads
 851  *   @n AIF2_PD_PKT_STS_CHAN_PKT
 852  *
 853  *   @b Example
 854  *   @verbatim
 855          uint32_t     PdPacketStat[4];
 856
 857         Aif2Fl_getPdPacketStatus (hAif2, &PdPacketStat);
 858      @endverbatim
 859  * ===========================================================================
 860  */
 861 static inline
 862 void Aif2Fl_getPdPacketStatus (
 863         Aif2Fl_Handle   hAif2,
 864         uint32_t*          PacketStat
 865 )
 866 {
 867     PacketStat[0] = CSL_FEXT(hAif2->regs->PD_PKT_STS[0],AIF2_PD_PKT_STS_CHAN_PKT);
 868     PacketStat[1] = CSL_FEXT(hAif2->regs->PD_PKT_STS[1],AIF2_PD_PKT_STS_CHAN_PKT);
 869     PacketStat[2] = CSL_FEXT(hAif2->regs->PD_PKT_STS[2],AIF2_PD_PKT_STS_CHAN_PKT);
 870     PacketStat[3] = CSL_FEXT(hAif2->regs->PD_PKT_STS[3],AIF2_PD_PKT_STS_CHAN_PKT);
 871 }
 872
 873
 874 /** ============================================================================
 875  *   @n@b Aif2Fl_getPeChannelStatus
 876  *
 877  *   @b Description
 878  *   @n This function get PE 128 Channel Status.
 879  *
 880  *   @b Arguments
 881  *   @verbatim
 882            hAif2      Handle to the aif2 instance. should use arg_link to select link
 883            uint32_t*       Pointer to the PE channel Status instance.
 884      @endverbatim
 885  *
 886  *   <b> Return Value </b>  None
 887  *   <b> Pre Condition </b>
 888  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 889  *   in that order before calling this function.
 890  *
 891  *   @n  None
 892  *
 893  *   <b> Post Condition </b>
 894  *   @n None
 895  *
 896  *   @b Reads
 897  *   @n AIF2_PE_CHAN_STS_CHAN_ON_STS
 898  *
 899  *   @b Example
 900  *   @verbatim
 901          uint32_t     PeChanStat[4];
 902
 903         Aif2Fl_getPeChannelStatus (hAif2, &PeChanStat);
 904      @endverbatim
 905  * ===========================================================================
 906  */
 907 static inline
 908 void Aif2Fl_getPeChannelStatus (
 909         Aif2Fl_Handle   hAif2,
 910         uint32_t*          ChanStat
 911 )
 912 {
 913     ChanStat[0] = CSL_FEXT(hAif2->regs->PE_CHAN_STS[0],AIF2_PE_CHAN_STS_CHAN_ON_STS);
 914     ChanStat[1] = CSL_FEXT(hAif2->regs->PE_CHAN_STS[1],AIF2_PE_CHAN_STS_CHAN_ON_STS);
 915     ChanStat[2] = CSL_FEXT(hAif2->regs->PE_CHAN_STS[2],AIF2_PE_CHAN_STS_CHAN_ON_STS);
 916     ChanStat[3] = CSL_FEXT(hAif2->regs->PE_CHAN_STS[3],AIF2_PE_CHAN_STS_CHAN_ON_STS);
 917 }
 918
 919
 920 /** ============================================================================
 921  *   @n@b Aif2Fl_getPePacketStatus
 922  *
 923  *   @b Description
 924  *   @n This function get PE packet status for 128 Channels.
 925  *
 926  *   @b Arguments
 927  *   @verbatim
 928            hAif2      Handle to the aif2 instance. should use arg_link to select link
 929            uint32_t*       Pointer to the PE packet Status instance. bit 0: out packet  bit 1: in packet
 930      @endverbatim
 931  *
 932  *   <b> Return Value </b>  None
 933  *   <b> Pre Condition </b>
 934  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 935  *   in that order before calling this function.
 936  *
 937  *   @n  None
 938  *
 939  *   <b> Post Condition </b>
 940  *   @n None
 941  *
 942  *   @b Reads
 943  *   @n AIF2_PE_PKT_STS_PKT_STS
 944  *
 945  *   @b Example
 946  *   @verbatim
 947          uint32_t     PePacketStat[4];
 948
 949         Aif2Fl_getPePacketStatus (hAif2, &PePacketStat);
 950      @endverbatim
 951  * ===========================================================================
 952  */
 953 static inline
 954 void Aif2Fl_getPePacketStatus (
 955         Aif2Fl_Handle   hAif2,
 956         uint32_t*          PacketStat
 957 )
 958 {
 959     PacketStat[0] = CSL_FEXT(hAif2->regs->PE_PKT_STS[0],AIF2_PE_PKT_STS_PKT_STS);
 960     PacketStat[1] = CSL_FEXT(hAif2->regs->PE_PKT_STS[1],AIF2_PE_PKT_STS_PKT_STS);
 961     PacketStat[2] = CSL_FEXT(hAif2->regs->PE_PKT_STS[2],AIF2_PE_PKT_STS_PKT_STS);
 962     PacketStat[3] = CSL_FEXT(hAif2->regs->PE_PKT_STS[3],AIF2_PE_PKT_STS_PKT_STS);
 963 }
 964
 965
 966  /** ============================================================================
 967  *   @n@b Aif2Fl_getInDbDebugOffsetData
 968  *
 969  *   @b Description
 970  *   @n Get Write and Read Offset Value at address in DB_IDB_DEBUG_OFS
 971  *
 972  *   @b Arguments
 973  *   @verbatim
 974
 975            hAif2            Handle to the aif2 instance
 976            uint8_t*          pointer to write and read offset data
 977      @endverbatim
 978  *
 979  *   <b> Return Value </b>  void
 980  *   <b> Pre Condition </b>
 981  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
 982  *   in that order before calling this function.
 983  *
 984  *
 985  *   <b> Post Condition </b>
 986  *   @n None
 987  *
 988  *   @b Reads
 989  *   @n  AIF2_DB_IDB_DEBUG_OFS_DAT_WOFF
 990  *
 991  *   @b Example
 992  *   @verbatim
 993         uint8_t  offset[2];
 994
 995         Aif2Fl_getInDbDebugOffsetData(hAif2, &offset[0]);
 996
 997         uint8_t write_offset = offset[0];
 998         uint8_t read_offset = offset[1];
 999      @endverbatim
1000  * ===========================================================================
1001  */
1002 static inline
1003 void Aif2Fl_getInDbDebugOffsetData (
1004         Aif2Fl_Handle   hAif2,
1005         uint8_t*                offset
1006 )
1007
1008 {
1009
1010      offset[0] = CSL_FEXT(hAif2->regs->DB_IDB_DEBUG_OFS_DAT,AIF2_DB_IDB_DEBUG_OFS_DAT_WOFF);
1011          offset[1] = CSL_FEXT(hAif2->regs->DB_IDB_DEBUG_OFS_DAT,AIF2_DB_IDB_DEBUG_OFS_DAT_ROFF);
1012 }
1013
1014
1015 /** ============================================================================
1016  *   @n@b Aif2Fl_getEDbDebugData
1017  *
1018  *   @b Description
1019  *   @n Get Debug data written to Egress DB RAM (128 bit)
1020  *
1021  *   @b Arguments
1022  *   @verbatim
1023
1024             hAif2    Handle to the aif2 instance
1025
1026             *uint32_t   pointer to 128 bit Debug data
1027
1028      @endverbatim
1029  *
1030  *   <b> Return Value </b>  void
1031  *
1032  *   <b> Pre Condition </b>
1033  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1034  *   in that order before calling this function.
1035  *
1036  *
1037  *   <b> Post Condition </b>
1038  *   @n None
1039  *
1040  *   @b Reads
1041  *   @n AIF2_DB_EDB_DEBUG_D0_DATA
1042  *
1043  *   @b Example
1044  *   @verbatim
1045         uint32_t    DebugData[4];
1046
1047         Aif2Fl_getEDbDebugData(hAif2, &DebugData[0]);
1048      @endverbatim
1049  * ===========================================================================
1050  */
1051 static inline
1052 void Aif2Fl_getEDbDebugData(
1053     Aif2Fl_Handle    hAif2,
1054     uint32_t*                debug_data
1055 )
1056 {
1057     debug_data[0] = CSL_FEXT(hAif2->regs->DB_EDB_DEBUG_D0, AIF2_DB_EDB_DEBUG_D0_DATA);
1058     debug_data[1] = CSL_FEXT(hAif2->regs->DB_EDB_DEBUG_D1, AIF2_DB_EDB_DEBUG_D1_DATA);
1059     debug_data[2] = CSL_FEXT(hAif2->regs->DB_EDB_DEBUG_D2, AIF2_DB_EDB_DEBUG_D2_DATA);
1060     debug_data[3] = CSL_FEXT(hAif2->regs->DB_EDB_DEBUG_D3, AIF2_DB_EDB_DEBUG_D3_DATA);
1061 }
1062
1063
1064
1065 /** ============================================================================
1066  *   @n@b Aif2Fl_getEDbDebugSideData
1067  *
1068  *   @b Description
1069  *   @n Get Egress DB debug side band data (sop, eop, xcnt only)
1070  *
1071  *   @b Arguments
1072  *   @verbatim
1073
1074             hAif2    Handle to the aif2 instance
1075
1076             Aif2Fl_DbSideData     Side data structure for debug
1077
1078      @endverbatim
1079  *
1080  *   <b> Return Value </b>  void
1081  *
1082  *   <b> Pre Condition </b>
1083  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1084  *   in that order before calling this function.
1085  *
1086  *
1087  *   <b> Post Condition </b>
1088  *   @n None
1089  *
1090  *   @b Reads
1091  *   @n
1092  *        AIF2_DB_EDB_DEBUG_SBND_SOP,AIF2_DB_EDB_DEBUG_SBND_EOP,
1093  *        AIF2_DB_EDB_DEBUG_SBND_XCNT,AIF2_DB_EDB_DEBUG_SBND_SYMBOL
1094  *
1095  *   @b Example
1096  *   @verbatim
1097         Aif2Fl_DbSideData   SideData;
1098
1099         Aif2Fl_getEDbDebugSideData(hAif2, &SideData);
1100
1101         SideData.bSop = ...;
1102         SideData.bEop = ...;
1103         SideData.xcnt = ...;
1104      @endverbatim
1105  * ===========================================================================
1106  */
1107 static inline
1108 void Aif2Fl_getEDbDebugSideData(
1109     Aif2Fl_Handle    hAif2,
1110     Aif2Fl_DbSideData*          side_data
1111 )
1112 {
1113      side_data->bSop =     CSL_FEXT(hAif2->regs->DB_IDB_DEBUG_SBND,AIF2_DB_EDB_DEBUG_SBND_SOP);
1114      side_data->bEop =     CSL_FEXT(hAif2->regs->DB_IDB_DEBUG_SBND,AIF2_DB_EDB_DEBUG_SBND_EOP);
1115      side_data->xcnt  =     CSL_FEXT(hAif2->regs->DB_IDB_DEBUG_SBND,AIF2_DB_EDB_DEBUG_SBND_XCNT);
1116      //side_data->Symbol=       CSL_FEXT(hAif2->regs->DB_IDB_DEBUG_SBND,AIF2_DB_EDB_DEBUG_SBND_SYMBOL);
1117 }
1118
1119  /** ============================================================================
1120  *   @n@b Aif2Fl_getEDbDebugOffsetData
1121  *
1122  *   @b Description
1123  *   @n Get Write and Read Offset Value at address in DB_EDB_DEBUG_OFS
1124  *
1125  *   @b Arguments
1126  *   @verbatim
1127            hAif2      Handle to the aif2 instance
1128            uint8_t *         ponter to write and read offset data
1129      @endverbatim
1130  *
1131  *   <b> Return Value </b>  void
1132  *   <b> Pre Condition </b>
1133  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1134  *   in that order before calling this function.
1135  *
1136  *
1137  *   <b> Post Condition </b>
1138  *   @n None
1139  *
1140  *   @b Reads
1141  *   @n  AIF2_DB_EDB_DEBUG_OFS_DAT_WOFF
1142  *
1143  *   @b Example
1144  *   @verbatim
1145         uint8_t  offset[2];
1146
1147         Aif2Fl_getEDbDebugOffsetData(hAif2, &offset[0]);
1148
1149         uint8_t write_offset = offset[0];
1150         uint8_t read_offset = offset[1];
1151      @endverbatim
1152  * ===========================================================================
1153  */
1154 static inline
1155 void Aif2Fl_getEDbDebugOffsetData (
1156         Aif2Fl_Handle   hAif2,
1157         uint8_t*                 offset
1158 )
1159
1160 {
1161         offset[0] = CSL_FEXT(hAif2->regs->DB_EDB_DEBUG_OFS_DAT,AIF2_DB_EDB_DEBUG_OFS_DAT_WOFF);
1162          offset[1] = CSL_FEXT(hAif2->regs->DB_EDB_DEBUG_OFS_DAT,AIF2_DB_EDB_DEBUG_OFS_DAT_ROFF);
1163 }
1164
1165
1166 /** ============================================================================
1167  *   @n@b Aif2Fl_getEgrEopCount
1168  *
1169  *   @b Description
1170  *   @n Get Egress EOP count from DB
1171  *
1172  *   @b Arguments
1173  *   @verbatim
1174            hAif2      Handle to the aif2 instance
1175      @endverbatim
1176  *
1177  *   <b> Return Value </b>  uint32
1178  *   <b> Pre Condition </b>
1179  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1180  *   in that order before calling this function.
1181  *
1182  *
1183  *   <b> Post Condition </b>
1184  *   @n None
1185  *
1186  *   @b Reads
1187  *   @n  AIF2_DB_EDB_EOP_CNT_EOP_CNT
1188  *
1189  *   @b Example
1190  *   @verbatim
1191         uint32_t  eop_cnt;
1192
1193         eop_cnt = Aif2Fl_getEgrEopCount(hAif2);
1194
1195      @endverbatim
1196  * ===========================================================================
1197  */
1198 static inline
1199 uint32_t Aif2Fl_getEgrEopCount (
1200         Aif2Fl_Handle   hAif2
1201 )
1202
1203 {
1204         return CSL_FEXT(hAif2->regs->DB_EDB_EOP_CNT ,AIF2_DB_EDB_EOP_CNT_EOP_CNT);
1205 }
1206
1207
1208 /** ============================================================================
1209  *   @n@b Aif2Fl_getIngrEopCount
1210  *
1211  *   @b Description
1212  *   @n Get Ingress EOP count
1213  *
1214  *   @b Arguments
1215  *   @verbatim
1216            hAif2      Handle to the aif2 instance
1217      @endverbatim
1218  *
1219  *   <b> Return Value </b>  uint32
1220  *   <b> Pre Condition </b>
1221  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1222  *   in that order before calling this function.
1223  *
1224  *
1225  *   <b> Post Condition </b>
1226  *   @n None
1227  *
1228  *   @b Reads
1229  *   @n  AIF2_AD_ISCH_EOP_CNT_EOP_CNT
1230  *
1231  *   @b Example
1232  *   @verbatim
1233         uint32_t  eop_cnt;
1234
1235         eop_cnt = Aif2Fl_getIngrEopCount(hAif2);
1236
1237      @endverbatim
1238  * ===========================================================================
1239  */
1240 static inline
1241 uint32_t Aif2Fl_getIngrEopCount (
1242         Aif2Fl_Handle   hAif2
1243 )
1244
1245 {
1246         return CSL_FEXT(hAif2->regs->AD_ISCH_EOP_CNT ,AIF2_AD_ISCH_EOP_CNT_EOP_CNT);
1247 }
1248
1249
1250 /** ============================================================================
1251  *   @n@b Aif2Fl_getAtLinkPiCapture
1252  *
1253  *   @b Description
1254  *   @n Get Aif2 timer Pi captured value for link
1255  *
1256  *   @b Arguments
1257  *   @verbatim
1258            hAif2      Handle to the aif2 instance    should use hAif2->arg_link to select link
1259      @endverbatim
1260  *
1261  *   <b> Return Value </b>  uint32_t
1262  *   <b> Pre Condition </b>
1263  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1264  *   in that order before calling this function.
1265  *
1266  *
1267  *   <b> Post Condition </b>
1268  *   @n None
1269  *
1270  *   @b Reads
1271  *   @n  AIF2_AT_PIVALUE_LK_PICAPTURED_VALUE
1272  *
1273  *   @b Example
1274  *   @verbatim
1275         uint32_t  pi;
1276         hAif2->arg_link = LINK0;
1277         pi = Aif2Fl_getAtLinkPiCapture(hAif2);
1278
1279      @endverbatim
1280  * ===========================================================================
1281  */
1282 static inline
1283 uint32_t Aif2Fl_getAtLinkPiCapture (
1284         Aif2Fl_Handle   hAif2
1285 )
1286 {
1287         return CSL_FEXT(hAif2->regs->PI_DATA[hAif2->arg_link].AT_PIVALUE_LK,AIF2_AT_PIVALUE_LK_PICAPTURED_VALUE);
1288 }
1289
1290
1291 /** ============================================================================
1292  *   @n@b Aif2Fl_getAtRadtCapture
1293  *
1294  *   @b Description
1295  *   @n Get Aif2 Rad timer captured clock, symbol, frame count value upon a phyt frame boundary
1296  *
1297  *   @b Arguments
1298  *   @verbatim
1299            hAif2      Handle to the aif2 instance
1300            Aif2Fl_AtCaptRadt    Radt clock, symbol and frame value structure
1301       @endverbatim
1302  *
1303  *   <b> Return Value </b>  void
1304  *   <b> Pre Condition </b>
1305  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1306  *   in that order before calling this function.
1307  *
1308  *
1309  *   <b> Post Condition </b>
1310  *   @n None
1311  *
1312  *   @b Reads
1313  *   @n  AIF2_AT_CAPTRADT_RADTCLOCKCOUNT_CAPTURE,AIF2_AT_CAPTRADT_RADTSYMBOLCOUNT_CAPTURE,
1314  *         AIF2_AT_CAPTRADT_RADTFRAMECOUNT_CAPTURE
1315  *   @b Example
1316  *   @verbatim
1317         Aif2Fl_AtCaptRadt  radt_count;
1318
1319         Aif2Fl_getAtRadtCapture(hAif2,&radt_count);
1320      @endverbatim
1321  * ===========================================================================
1322  */
1323 static inline
1324 void Aif2Fl_getAtRadtCapture (
1325         Aif2Fl_Handle   hAif2,
1326         Aif2Fl_AtCaptRadt*     radt
1327 )
1328 {
1329         radt->clock=  CSL_FEXT(hAif2->regs->AT_CAPTRADT, AIF2_AT_CAPTRADT_RADTCLOCKCOUNT_CAPTURE);
1330          radt->symbol=  CSL_FEXT(hAif2->regs->AT_CAPTRADT, AIF2_AT_CAPTRADT_RADTSYMBOLCOUNT_CAPTURE);
1331          radt->frame =  CSL_FEXT(hAif2->regs->AT_CAPTRADT, AIF2_AT_CAPTRADT_RADTFRAMECOUNT_CAPTURE);
1332 }
1333
1334  /** ============================================================================
1335  *   @n@b Aif2Fl_getAtRp1TypeCapture
1336  *
1337  *   @b Description
1338  *   @n Get Aif2 timer RP1 type capture value
1339  *
1340  *   @b Arguments
1341  *   @verbatim
1342            hAif2      Handle to the aif2 instance
1343      @endverbatim
1344  *
1345  *   <b> Return Value </b>  uint8_t
1346  *   <b> Pre Condition </b>
1347  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1348  *   in that order before calling this function.
1349  *
1350  *
1351  *   <b> Post Condition </b>
1352  *   @n None
1353  *
1354  *   @b Reads
1355  *   @n  AIF2_AT_RP1_TYPE_CAPTURE_RP1TYPE_CAPTURED
1356  *
1357  *   @b Example
1358  *   @verbatim
1359         uint8_t  type;
1360
1361         type = Aif2Fl_getAtRp1TypeCapture(hAif2);
1362
1363      @endverbatim
1364  * ===========================================================================
1365  */
1366 static inline
1367 uint8_t Aif2Fl_getAtRp1TypeCapture (
1368         Aif2Fl_Handle   hAif2
1369 )
1370 {
1371         return CSL_FEXT(hAif2->regs->AT_RP1_TYPE_CAPTURE,AIF2_AT_RP1_TYPE_CAPTURE_RP1TYPE_CAPTURED);
1372 }
1373
1374 /** ============================================================================
1375  *   @n@b Aif2Fl_getAtRp1TodCaptureLsb
1376  *
1377  *   @b Description
1378  *   @n Get Aif2 timer RP1 TOD capture value lsb
1379  *
1380  *   @b Arguments
1381  *   @verbatim
1382            hAif2      Handle to the aif2 instance
1383      @endverbatim
1384  *
1385  *   <b> Return Value </b>  uint32_t
1386  *   <b> Pre Condition </b>
1387  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1388  *   in that order before calling this function.
1389  *
1390  *
1391  *   <b> Post Condition </b>
1392  *   @n None
1393  *
1394  *   @b Reads
1395  *   @n  AIF2_AT_RP1_TOD_CAPTURE_L_RP1TOD_CAPTURE_LSBS
1396  *
1397  *   @b Example
1398  *   @verbatim
1399         uint32_t  tod_lo;
1400
1401         tod_lo = Aif2Fl_getAtRp1TodCaptureLsb(hAif2);
1402
1403      @endverbatim
1404  * ===========================================================================
1405  */
1406 static inline
1407 uint32_t Aif2Fl_getAtRp1TodCaptureLsb (
1408         Aif2Fl_Handle   hAif2
1409 )
1410 {
1411         return CSL_FEXT(hAif2->regs->AT_RP1_TOD_CAPTURE_L,AIF2_AT_RP1_TOD_CAPTURE_L_RP1TOD_CAPTURE_LSBS);
1412 }
1413
1414 /** ============================================================================
1415  *   @n@b Aif2Fl_getAtRp1TodCaptureMsb
1416  *
1417  *   @b Description
1418  *   @n Get Aif2 timer RP1 TOD capture value msb
1419  *
1420  *   @b Arguments
1421  *   @verbatim
1422            hAif2      Handle to the aif2 instance
1423      @endverbatim
1424  *
1425  *   <b> Return Value </b>  uint32_t
1426  *   <b> Pre Condition </b>
1427  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1428  *   in that order before calling this function.
1429  *
1430  *
1431  *   <b> Post Condition </b>
1432  *   @n None
1433  *
1434  *   @b Reads
1435  *   @n  AIF2_AT_RP1_TOD_CAPTURE_H_RP1TOD_CAPTURE_MSBS
1436  *
1437  *   @b Example
1438  *   @verbatim
1439         uint32_t  tod_hi;
1440
1441         tod_hi = Aif2Fl_getAtRp1TodCaptureMsb(hAif2);
1442
1443      @endverbatim
1444  * ===========================================================================
1445  */
1446 static inline
1447 uint32_t Aif2Fl_getAtRp1TodCaptureMsb (
1448         Aif2Fl_Handle   hAif2
1449 )
1450 {
1451         return CSL_FEXT(hAif2->regs->AT_RP1_TOD_CAPTURE_H,AIF2_AT_RP1_TOD_CAPTURE_H_RP1TOD_CAPTURE_MSBS);
1452 }
1453
1454 /** ============================================================================
1455  *   @n@b Aif2Fl_getAtRp1Rp3CaptureLsb
1456  *
1457  *   @b Description
1458  *   @n Get Aif2 timer RP1 RP3 capture value lsb
1459  *
1460  *   @b Arguments
1461  *   @verbatim
1462            hAif2      Handle to the aif2 instance
1463      @endverbatim
1464  *
1465  *   <b> Return Value </b>  uint32_t
1466  *   <b> Pre Condition </b>
1467  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1468  *   in that order before calling this function.
1469  *
1470  *
1471  *   <b> Post Condition </b>
1472  *   @n None
1473  *
1474  *   @b Reads
1475  *   @n  AIF2_AT_RP1_RP3_CAPTURE_L_RP1RP3_CAPTURE_LSBS
1476  *
1477  *   @b Example
1478  *   @verbatim
1479         uint32_t  RP3Lo;
1480
1481         RP3Lo = Aif2Fl_getAtRp1Rp3CaptureLsb(hAif2);
1482
1483      @endverbatim
1484  * ===========================================================================
1485  */
1486 static inline
1487 uint32_t Aif2Fl_getAtRp1Rp3CaptureLsb (
1488         Aif2Fl_Handle   hAif2
1489 )
1490 {
1491         return CSL_FEXT(hAif2->regs->AT_RP1_RP3_CAPTURE_L,AIF2_AT_RP1_RP3_CAPTURE_L_RP1RP3_CAPTURE_LSBS);
1492 }
1493
1494 /** ============================================================================
1495  *   @n@b Aif2Fl_getAtRp1Rp3CaptureMsb
1496  *
1497  *   @b Description
1498  *   @n Get Aif2 timer RP1 RP3 capture value msb
1499  *
1500  *   @b Arguments
1501  *   @verbatim
1502            hAif2      Handle to the aif2 instance
1503      @endverbatim
1504  *
1505  *   <b> Return Value </b>  uint32_t
1506  *   <b> Pre Condition </b>
1507  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1508  *   in that order before calling this function.
1509  *
1510  *
1511  *   <b> Post Condition </b>
1512  *   @n None
1513  *
1514  *   @b Reads
1515  *   @n  AIF2_AT_RP1_RP3_CAPTURE_H_RP1RP3_CAPTURE_MSBS
1516  *
1517  *   @b Example
1518  *   @verbatim
1519         uint32_t  RP3Hi;
1520
1521         RP3Hi = Aif2Fl_getAtRp1Rp3CaptureMsb(hAif2);
1522
1523      @endverbatim
1524  * ===========================================================================
1525  */
1526 static inline
1527 uint32_t Aif2Fl_getAtRp1Rp3CaptureMsb (
1528         Aif2Fl_Handle   hAif2
1529 )
1530 {
1531         return CSL_FEXT(hAif2->regs->AT_RP1_RP3_CAPTURE_H,AIF2_AT_RP1_RP3_CAPTURE_H_RP1RP3_CAPTURE_MSBS);
1532 }
1533
1534 /** ============================================================================
1535  *   @n@b Aif2Fl_getAtRp1RadCaptureLsb
1536  *
1537  *   @b Description
1538  *   @n Get Aif2 timer RP1 RAD capture value lsb
1539  *
1540  *   @b Arguments
1541  *   @verbatim
1542            hAif2      Handle to the aif2 instance
1543      @endverbatim
1544  *
1545  *   <b> Return Value </b>  uint32_t
1546  *   <b> Pre Condition </b>
1547  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1548  *   in that order before calling this function.
1549  *
1550  *
1551  *   <b> Post Condition </b>
1552  *   @n None
1553  *
1554  *   @b Reads
1555  *   @n  AIF2_AT_RP1_RAD_CAPTURE_L_RP1RADIO_SYSTEM_CAPTURE_LSBS
1556  *
1557  *   @b Example
1558  *   @verbatim
1559         uint32_t  RADLo;
1560
1561         RADLo = Aif2Fl_getAtRp1RadCaptureLsb(hAif2);
1562
1563      @endverbatim
1564  * ===========================================================================
1565  */
1566 static inline
1567 uint32_t Aif2Fl_getAtRp1RadCaptureLsb (
1568         Aif2Fl_Handle   hAif2
1569 )
1570 {
1571         return CSL_FEXT(hAif2->regs->AT_RP1_RAD_CAPTURE_L,AIF2_AT_RP1_RAD_CAPTURE_L_RP1RADIO_SYSTEM_CAPTURE_LSBS);
1572 }
1573
1574 /** ============================================================================
1575  *   @n@b Aif2Fl_getAtRp1RadCaptureMsb
1576  *
1577  *   @b Description
1578  *   @n Get Aif2 timer RP1 Radio system capture value msb
1579  *
1580  *   @b Arguments
1581  *   @verbatim
1582            hAif2      Handle to the aif2 instance
1583      @endverbatim
1584  *
1585  *   <b> Return Value </b>  uint32_t
1586  *   <b> Pre Condition </b>
1587  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1588  *   in that order before calling this function.
1589  *
1590  *
1591  *   <b> Post Condition </b>
1592  *   @n None
1593  *
1594  *   @b Reads
1595  *   @n  AIF2_AT_RP1_RAD_CAPTURE_H_RP1RADIO_SYSTEM_CAPTURE_MSBS
1596  *
1597  *   @b Example
1598  *   @verbatim
1599         uint32_t  RADHi;
1600
1601         RADHi = Aif2Fl_getAtRp1RadCaptureMsb(hAif2);
1602
1603      @endverbatim
1604  * ===========================================================================
1605  */
1606 static inline
1607 uint32_t Aif2Fl_getAtRp1RadCaptureMsb (
1608         Aif2Fl_Handle   hAif2
1609 )
1610 {
1611         return CSL_FEXT(hAif2->regs->AT_RP1_RAD_CAPTURE_H,AIF2_AT_RP1_RAD_CAPTURE_H_RP1RADIO_SYSTEM_CAPTURE_MSBS);
1612 }
1613
1614 /** ============================================================================
1615  *   @n@b Aif2Fl_getAtPhytClkCount
1616  *
1617  *   @b Description
1618  *   @n Get Aif2 Phy timer clock count value
1619  *
1620  *   @b Arguments
1621  *   @verbatim
1622            hAif2      Handle to the aif2 instance
1623       @endverbatim
1624  *
1625  *   <b> Return Value </b>  uint32_t
1626  *   <b> Pre Condition </b>
1627  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1628  *   in that order before calling this function.
1629  *
1630  *
1631  *   <b> Post Condition </b>
1632  *   @n None
1633  *
1634  *   @b Reads
1635  *   @n  AIF2_AT_PHYT_CLKCNT_VALUE_PHYTCLOCK_COUNT_VALUE
1636  *
1637  *   @b Example
1638  *   @verbatim
1639         uint32_t  count;
1640
1641         count = Aif2Fl_getAtPhytClkCount(hAif2);
1642
1643      @endverbatim
1644  * ===========================================================================
1645  */
1646 static inline
1647 uint32_t Aif2Fl_getAtPhytClkCount (
1648         Aif2Fl_Handle   hAif2
1649 )
1650 {
1651         return CSL_FEXT(hAif2->regs->AT_PHYT_CLKCNT_VALUE,AIF2_AT_PHYT_CLKCNT_VALUE_PHYTCLOCK_COUNT_VALUE);
1652 }
1653
1654 /** ============================================================================
1655  *   @n@b Aif2Fl_getAtPhytFrameLsb
1656  *
1657  *   @b Description
1658  *   @n Get Aif2 Phy timer frame count lsb value
1659  *
1660  *   @b Arguments
1661  *   @verbatim
1662            hAif2      Handle to the aif2 instance
1663       @endverbatim
1664  *
1665  *   <b> Return Value </b>  uint32_t
1666  *   <b> Pre Condition </b>
1667  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1668  *   in that order before calling this function.
1669  *
1670  *
1671  *   <b> Post Condition </b>
1672  *   @n None
1673  *
1674  *   @b Reads
1675  *   @n  AIF2_AT_PHYT_FRM_VALUE_LSBS_PHYTFRAME_VALUE_LSBS
1676  *
1677  *   @b Example
1678  *   @verbatim
1679         uint32_t  count;
1680
1681         count = Aif2Fl_getAtPhytFrameLsb(hAif2);
1682
1683      @endverbatim
1684  * ===========================================================================
1685  */
1686 static inline
1687 uint32_t Aif2Fl_getAtPhytFrameLsb (
1688         Aif2Fl_Handle   hAif2
1689 )
1690 {
1691         return CSL_FEXT(hAif2->regs->AT_PHYT_FRM_VALUE_LSBS, AIF2_AT_PHYT_FRM_VALUE_LSBS_PHYTFRAME_VALUE_LSBS);
1692 }
1693
1694 /** ============================================================================
1695  *   @n@b Aif2Fl_getAtPhytFrameMsb
1696  *
1697  *   @b Description
1698  *   @n Get Aif2 Phy timer frame count msb value
1699  *
1700  *   @b Arguments
1701  *   @verbatim
1702            hAif2      Handle to the aif2 instance
1703       @endverbatim
1704  *
1705  *   <b> Return Value </b>  uint32_t
1706  *   <b> Pre Condition </b>
1707  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1708  *   in that order before calling this function.
1709  *
1710  *
1711  *   <b> Post Condition </b>
1712  *   @n None
1713  *
1714  *   @b Reads
1715  *   @n  AIF2_AT_PHYT_FRM_VALUE_MSBS_PHYTFRAME_VALUE_MSBS
1716  *
1717  *   @b Example
1718  *   @verbatim
1719         uint32_t  count;
1720
1721         count = Aif2Fl_getAtPhytFrameMsb(hAif2);
1722
1723      @endverbatim
1724  * ===========================================================================
1725  */
1726 static inline
1727 uint32_t Aif2Fl_getAtPhytFrameMsb (
1728         Aif2Fl_Handle   hAif2
1729 )
1730 {
1731         return CSL_FEXT(hAif2->regs->AT_PHYT_FRM_VALUE_MSBS, AIF2_AT_PHYT_FRM_VALUE_MSBS_PHYTFRAME_VALUE_MSBS);
1732 }
1733
1734
1735 /** ============================================================================
1736  *   @n@b Aif2Fl_getAtRadtClkCount
1737  *
1738  *   @b Description
1739  *   @n Get Aif2 Rad timer clock count value
1740  *
1741  *   @b Arguments
1742  *   @verbatim
1743            hAif2      Handle to the aif2 instance
1744       @endverbatim
1745  *
1746  *   <b> Return Value </b>  uint32_t
1747  *   <b> Pre Condition </b>
1748  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1749  *   in that order before calling this function.
1750  *
1751  *
1752  *   <b> Post Condition </b>
1753  *   @n None
1754  *
1755  *   @b Reads
1756  *   @n  AIF2_AT_RADT_VALUE_LSBS_RADTCLOCK_COUNT_VALUE
1757  *
1758  *   @b Example
1759  *   @verbatim
1760         uint32_t  count;
1761
1762         count = Aif2Fl_getAtRadtClkCount(hAif2);
1763
1764      @endverbatim
1765  * ===========================================================================
1766  */
1767 static inline
1768 uint32_t Aif2Fl_getAtRadtClkCount (
1769         Aif2Fl_Handle   hAif2
1770 )
1771 {
1772         return CSL_FEXT(hAif2->regs->AT_RADT_VALUE_LSBS,AIF2_AT_RADT_VALUE_LSBS_RADTCLOCK_COUNT_VALUE);
1773 }
1774
1775 /** ============================================================================
1776  *   @n@b Aif2Fl_getAtRadtSymCount
1777  *
1778  *   @b Description
1779  *   @n Get Aif2 Rad timer symbol count value
1780  *
1781  *   @b Arguments
1782  *   @verbatim
1783            hAif2      Handle to the aif2 instance
1784       @endverbatim
1785  *
1786  *   <b> Return Value </b>  uint8_t
1787  *   <b> Pre Condition </b>
1788  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1789  *   in that order before calling this function.
1790  *
1791  *
1792  *   <b> Post Condition </b>
1793  *   @n None
1794  *
1795  *   @b Reads
1796  *   @n  AIF2_AT_RADT_VALUE_LSBS_RADTSYMBOL_COUNT_VALUE
1797  *
1798  *   @b Example
1799  *   @verbatim
1800         uint8_t  count;
1801
1802         count = Aif2Fl_getAtRadtSymCount(hAif2);
1803
1804      @endverbatim
1805  * ===========================================================================
1806  */
1807 static inline
1808 uint8_t Aif2Fl_getAtRadtSymCount (
1809         Aif2Fl_Handle   hAif2
1810 )
1811 {
1812         return CSL_FEXT(hAif2->regs->AT_RADT_VALUE_LSBS,AIF2_AT_RADT_VALUE_LSBS_RADTSYMBOL_COUNT_VALUE);
1813 }
1814
1815 /** ============================================================================
1816  *   @n@b Aif2Fl_getAtRadtFrameLsb
1817  *
1818  *   @b Description
1819  *   @n Get Aif2 Rad timer frame count lsb value
1820  *
1821  *   @b Arguments
1822  *   @verbatim
1823            hAif2      Handle to the aif2 instance
1824       @endverbatim
1825  *
1826  *   <b> Return Value </b>  uint32_t
1827  *   <b> Pre Condition </b>
1828  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1829  *   in that order before calling this function.
1830  *
1831  *
1832  *   <b> Post Condition </b>
1833  *   @n None
1834  *
1835  *   @b Reads
1836  *   @n  AIF2_AT_RADT_VALUE_MID_RADTFRAME_VALUE_LSBS
1837  *
1838  *   @b Example
1839  *   @verbatim
1840         uint32_t  count;
1841
1842         count = Aif2Fl_getAtRadtFrameLsb(hAif2);
1843
1844      @endverbatim
1845  * ===========================================================================
1846  */
1847 static inline
1848 uint32_t Aif2Fl_getAtRadtFrameLsb (
1849         Aif2Fl_Handle   hAif2
1850 )
1851 {
1852         return CSL_FEXT(hAif2->regs->AT_RADT_VALUE_MID, AIF2_AT_RADT_VALUE_MID_RADTFRAME_VALUE_LSBS);
1853 }
1854
1855 /** ============================================================================
1856  *   @n@b Aif2Fl_getAtRadtFrameMsb
1857  *
1858  *   @b Description
1859  *   @n Get Aif2 Rad timer frame count msb value
1860  *
1861  *   @b Arguments
1862  *   @verbatim
1863            hAif2      Handle to the aif2 instance
1864       @endverbatim
1865  *
1866  *   <b> Return Value </b>  uint32_t
1867  *   <b> Pre Condition </b>
1868  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1869  *   in that order before calling this function.
1870  *
1871  *
1872  *   <b> Post Condition </b>
1873  *   @n None
1874  *
1875  *   @b Reads
1876  *   @n  AIF2_AT_RADT_VALUE_MSBS_RADTFRAME_VALUE_MSBS
1877  *
1878  *   @b Example
1879  *   @verbatim
1880         uint32_t  count;
1881
1882         count = Aif2Fl_getAtRadtFrameMsb(hAif2);
1883
1884      @endverbatim
1885  * ===========================================================================
1886  */
1887 static inline
1888 uint32_t Aif2Fl_getAtRadtFrameMsb (
1889         Aif2Fl_Handle   hAif2
1890 )
1891 {
1892         return CSL_FEXT(hAif2->regs->AT_RADT_VALUE_MSBS, AIF2_AT_RADT_VALUE_MSBS_RADTFRAME_VALUE_MSBS);
1893 }
1894
1895 /** ============================================================================
1896  *   @n@b Aif2Fl_getAtUlRadtClkCount
1897  *
1898  *   @b Description
1899  *   @n Get Aif2 UL Rad timer clock count value
1900  *
1901  *   @b Arguments
1902  *   @verbatim
1903            hAif2      Handle to the aif2 instance
1904       @endverbatim
1905  *
1906  *   <b> Return Value </b>  uint32_t
1907  *   <b> Pre Condition </b>
1908  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1909  *   in that order before calling this function.
1910  *
1911  *
1912  *   <b> Post Condition </b>
1913  *   @n None
1914  *
1915  *   @b Reads
1916  *   @n  AIF2_AT_ULRADT_VALUE_LSBS_ULRADTCLOCK_COUNT_VALUE
1917  *
1918  *   @b Example
1919  *   @verbatim
1920         uint32_t  count;
1921
1922         count = Aif2Fl_getAtUlRadtClkCount(hAif2);
1923
1924      @endverbatim
1925  * ===========================================================================
1926  */
1927 static inline
1928 uint32_t Aif2Fl_getAtUlRadtClkCount (
1929         Aif2Fl_Handle   hAif2
1930 )
1931 {
1932         return CSL_FEXT(hAif2->regs->AT_ULRADT_VALUE_LSBS,AIF2_AT_ULRADT_VALUE_LSBS_ULRADTCLOCK_COUNT_VALUE);
1933 }
1934
1935 /** ============================================================================
1936  *   @n@b Aif2Fl_getAtUlRadtSymCount
1937  *
1938  *   @b Description
1939  *   @n Get Aif2 UL Rad timer symbol count value
1940  *
1941  *   @b Arguments
1942  *   @verbatim
1943            hAif2      Handle to the aif2 instance
1944       @endverbatim
1945  *
1946  *   <b> Return Value </b>  uint8_t
1947  *   <b> Pre Condition </b>
1948  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1949  *   in that order before calling this function.
1950  *
1951  *
1952  *   <b> Post Condition </b>
1953  *   @n None
1954  *
1955  *   @b Reads
1956  *   @n  AIF2_AT_ULRADT_VALUE_LSBS_ULRADTSYMBOL_COUNT_VALUE
1957  *
1958  *   @b Example
1959  *   @verbatim
1960         uint8_t  count;
1961
1962         count = Aif2Fl_getAtUlRadtSymCount(hAif2);
1963
1964      @endverbatim
1965  * ===========================================================================
1966  */
1967 static inline
1968 uint8_t Aif2Fl_getAtUlRadtSymCount (
1969         Aif2Fl_Handle   hAif2
1970 )
1971 {
1972         return CSL_FEXT(hAif2->regs->AT_ULRADT_VALUE_LSBS,AIF2_AT_ULRADT_VALUE_LSBS_ULRADTSYMBOL_COUNT_VALUE);
1973 }
1974
1975 /** ============================================================================
1976  *   @n@b Aif2Fl_getAtUlRadtFrameLsb
1977  *
1978  *   @b Description
1979  *   @n Get Aif2 UL Rad timer frame count lsb value
1980  *
1981  *   @b Arguments
1982  *   @verbatim
1983            hAif2      Handle to the aif2 instance
1984       @endverbatim
1985  *
1986  *   <b> Return Value </b>  uint32_t
1987  *   <b> Pre Condition </b>
1988  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
1989  *   in that order before calling this function.
1990  *
1991  *
1992  *   <b> Post Condition </b>
1993  *   @n None
1994  *
1995  *   @b Reads
1996  *   @n  AIF2_AT_ULRADT_VALUE_MID_ULRADTFRAME_VALUE_LSBS
1997  *
1998  *   @b Example
1999  *   @verbatim
2000         uint32_t  count;
2001
2002         count = Aif2Fl_getAtUlRadtFrameLsb(hAif2);
2003
2004      @endverbatim
2005  * ===========================================================================
2006  */
2007 static inline
2008 uint32_t Aif2Fl_getAtUlRadtFrameLsb (
2009         Aif2Fl_Handle   hAif2
2010 )
2011 {
2012         return CSL_FEXT(hAif2->regs->AT_ULRADT_VALUE_MID, AIF2_AT_ULRADT_VALUE_MID_ULRADTFRAME_VALUE_LSBS);
2013 }
2014
2015 /** ============================================================================
2016  *   @n@b Aif2Fl_getAtUlRadtFrameMsb
2017  *
2018  *   @b Description
2019  *   @n Get Aif2 UL Rad timer frame count msb value
2020  *
2021  *   @b Arguments
2022  *   @verbatim
2023            hAif2      Handle to the aif2 instance
2024       @endverbatim
2025  *
2026  *   <b> Return Value </b>  uint32_t
2027  *   <b> Pre Condition </b>
2028  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2029  *   in that order before calling this function.
2030  *
2031  *
2032  *   <b> Post Condition </b>
2033  *   @n None
2034  *
2035  *   @b Reads
2036  *   @n  AIF2_AT_ULRADT_VALUE_MSBS_ULRADTFRAME_VALUE_MSBS
2037  *
2038  *   @b Example
2039  *   @verbatim
2040         uint32_t  count;
2041
2042         count = Aif2Fl_getAtUlRadtFrameMsb(hAif2);
2043
2044      @endverbatim
2045  * ===========================================================================
2046  */
2047 static inline
2048 uint32_t Aif2Fl_getAtUlRadtFrameMsb (
2049         Aif2Fl_Handle   hAif2
2050 )
2051 {
2052         return CSL_FEXT(hAif2->regs->AT_ULRADT_VALUE_MSBS, AIF2_AT_ULRADT_VALUE_MSBS_ULRADTFRAME_VALUE_MSBS);
2053 }
2054
2055 /** ============================================================================
2056  *   @n@b Aif2Fl_getAtDlRadtClkCount
2057  *
2058  *   @b Description
2059  *   @n Get Aif2 DL Rad timer clock count value
2060  *
2061  *   @b Arguments
2062  *   @verbatim
2063            hAif2      Handle to the aif2 instance
2064       @endverbatim
2065  *
2066  *   <b> Return Value </b>  uint32_t
2067  *   <b> Pre Condition </b>
2068  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2069  *   in that order before calling this function.
2070  *
2071  *
2072  *   <b> Post Condition </b>
2073  *   @n None
2074  *
2075  *   @b Reads
2076  *   @n  AIF2_AT_DLRADT_VALUE_LSBS_DLRADTCLOCK_COUNT_VALUE
2077  *
2078  *   @b Example
2079  *   @verbatim
2080         uint32_t  count;
2081
2082         count = Aif2Fl_getAtDlRadtClkCount(hAif2);
2083
2084      @endverbatim
2085  * ===========================================================================
2086  */
2087 static inline
2088 uint32_t Aif2Fl_getAtDlRadtClkCount (
2089         Aif2Fl_Handle   hAif2
2090 )
2091 {
2092         return CSL_FEXT(hAif2->regs->AT_DLRADT_VALUE_LSBS,AIF2_AT_DLRADT_VALUE_LSBS_DLRADTCLOCK_COUNT_VALUE);
2093 }
2094
2095 /** ============================================================================
2096  *   @n@b Aif2Fl_getAtDlRadtSymCount
2097  *
2098  *   @b Description
2099  *   @n Get Aif2 DL Rad timer symbol count value
2100  *
2101  *   @b Arguments
2102  *   @verbatim
2103            hAif2      Handle to the aif2 instance
2104       @endverbatim
2105  *
2106  *   <b> Return Value </b>  uint8_t
2107  *   <b> Pre Condition </b>
2108  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2109  *   in that order before calling this function.
2110  *
2111  *
2112  *   <b> Post Condition </b>
2113  *   @n None
2114  *
2115  *   @b Reads
2116  *   @n  AIF2_AT_DLRADT_VALUE_LSBS_DLRADTSYMBOL_COUNT_VALUE
2117  *
2118  *   @b Example
2119  *   @verbatim
2120         uint8_t  count;
2121
2122         count = Aif2Fl_getAtDlRadtSymCount(hAif2);
2123
2124      @endverbatim
2125  * ===========================================================================
2126  */
2127 static inline
2128 uint8_t Aif2Fl_getAtDlRadtSymCount (
2129         Aif2Fl_Handle   hAif2
2130 )
2131 {
2132         return CSL_FEXT(hAif2->regs->AT_DLRADT_VALUE_LSBS,AIF2_AT_DLRADT_VALUE_LSBS_DLRADTSYMBOL_COUNT_VALUE);
2133 }
2134
2135 /** ============================================================================
2136  *   @n@b Aif2Fl_getAtDlRadtFrameLsb
2137  *
2138  *   @b Description
2139  *   @n Get Aif2 DL Rad timer frame count lsb value
2140  *
2141  *   @b Arguments
2142  *   @verbatim
2143            hAif2      Handle to the aif2 instance
2144       @endverbatim
2145  *
2146  *   <b> Return Value </b>  uint32_t
2147  *   <b> Pre Condition </b>
2148  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2149  *   in that order before calling this function.
2150  *
2151  *
2152  *   <b> Post Condition </b>
2153  *   @n None
2154  *
2155  *   @b Reads
2156  *   @n  AIF2_AT_DLRADT_VALUE_MID_DLRADTFRAME_VALUE_LSBS
2157  *
2158  *   @b Example
2159  *   @verbatim
2160         uint32_t  count;
2161
2162         count = Aif2Fl_getAtDlRadtFrameLsb(hAif2);
2163
2164      @endverbatim
2165  * ===========================================================================
2166  */
2167 static inline
2168 uint32_t Aif2Fl_getAtDlRadtFrameLsb (
2169         Aif2Fl_Handle   hAif2
2170 )
2171 {
2172         return CSL_FEXT(hAif2->regs->AT_DLRADT_VALUE_MID, AIF2_AT_DLRADT_VALUE_MID_DLRADTFRAME_VALUE_LSBS);
2173 }
2174
2175 /** ============================================================================
2176  *   @n@b Aif2Fl_getAtDlRadtFrameMsb
2177  *
2178  *   @b Description
2179  *   @n Get Aif2 DL Rad timer frame count msb value
2180  *
2181  *   @b Arguments
2182  *   @verbatim
2183            hAif2      Handle to the aif2 instance
2184       @endverbatim
2185  *
2186  *   <b> Return Value </b>  uint32_t
2187  *   <b> Pre Condition </b>
2188  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2189  *   in that order before calling this function.
2190  *
2191  *
2192  *   <b> Post Condition </b>
2193  *   @n None
2194  *
2195  *   @b Reads
2196  *   @n  AIF2_AT_DLRADT_VALUE_MSBS_DLRADTFRAME_VALUE_MSBS
2197  *
2198  *   @b Example
2199  *   @verbatim
2200         uint32_t  count;
2201
2202         count = Aif2Fl_getAtDlRadtFrameMsb(hAif2);
2203
2204      @endverbatim
2205  * ===========================================================================
2206  */
2207 static inline
2208 uint32_t Aif2Fl_getAtDlRadtFrameMsb (
2209         Aif2Fl_Handle   hAif2
2210 )
2211 {
2212         return CSL_FEXT(hAif2->regs->AT_DLRADT_VALUE_MSBS, AIF2_AT_DLRADT_VALUE_MSBS_DLRADTFRAME_VALUE_MSBS);
2213 }
2214
2215 /** ============================================================================
2216  *   @n@b Aif2Fl_getAtRadtWcdmaValue
2217  *
2218  *   @b Description
2219  *   @n Get Aif2 Rad timer wcdma count value
2220  *
2221  *   @b Arguments
2222  *   @verbatim
2223            hAif2      Handle to the aif2 instance
2224            Aif2Fl_AtWcdmaCount     WCDMA chip, slot and frame value structure
2225       @endverbatim
2226  *
2227  *   <b> Return Value </b>  void
2228  *   <b> Pre Condition </b>
2229  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2230  *   in that order before calling this function.
2231  *
2232  *
2233  *   <b> Post Condition </b>
2234  *   @n None
2235  *
2236  *   @b Reads
2237  *   @n  AIF2_AT_RADT_WCDMA_VALUE_CHIPVALUE,AIF2_AT_RADT_WCDMA_VALUE_SLOTVALUE,
2238  *         AIF2_AT_RADT_WCDMA_VALUE_FRAMEVALUE
2239  *   @b Example
2240  *   @verbatim
2241         Aif2Fl_AtWcdmaCount  wcdma_count;
2242
2243         Aif2Fl_getAtRadtWcdmaValue(hAif2,&wcdma_count);
2244
2245         wcdma_count.chip = ....
2246         wcdma_count.slot = .....
2247         wcdma_count.frame = ....
2248
2249      @endverbatim
2250  * ===========================================================================
2251  */
2252 static inline
2253 void Aif2Fl_getAtRadtWcdmaValue (
2254         Aif2Fl_Handle   hAif2,
2255         Aif2Fl_AtWcdmaCount*     wcdma
2256 )
2257 {
2258         wcdma->chip =  CSL_FEXT(hAif2->regs->AT_RADT_WCDMA_VALUE, AIF2_AT_RADT_WCDMA_VALUE_CHIPVALUE);
2259          wcdma->slot =  CSL_FEXT(hAif2->regs->AT_RADT_WCDMA_VALUE, AIF2_AT_RADT_WCDMA_VALUE_SLOTVALUE);
2260          wcdma->frame =  CSL_FEXT(hAif2->regs->AT_RADT_WCDMA_VALUE, AIF2_AT_RADT_WCDMA_VALUE_FRAMEVALUE);
2261 }
2262
2263 /** ============================================================================
2264  *   @n@b Aif2Fl_getAtUlRadtWcdmaValue
2265  *
2266  *   @b Description
2267  *   @n Get Aif2 Ul Rad timer wcdma count value
2268  *
2269  *   @b Arguments
2270  *   @verbatim
2271            hAif2      Handle to the aif2 instance
2272            Aif2Fl_AtWcdmaCount     WCDMA chip, slot and frame value structure
2273       @endverbatim
2274  *
2275  *   <b> Return Value </b>  void
2276  *   <b> Pre Condition </b>
2277  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2278  *   in that order before calling this function.
2279  *
2280  *
2281  *   <b> Post Condition </b>
2282  *   @n None
2283  *
2284  *   @b Reads
2285  *   @n  AIF2_AT_ULRADT_WCDMA_VALUE_CHIPVALUE,AIF2_AT_ULRADT_WCDMA_VALUE_SLOTVALUE,
2286  *         AIF2_AT_ULRADT_WCDMA_VALUE_FRAMEVALUE
2287  *   @b Example
2288  *   @verbatim
2289         Aif2Fl_AtWcdmaCount  wcdma_count;
2290
2291         Aif2Fl_getAtUlRadtWcdmaValue(hAif2,&wcdma_count);
2292
2293         wcdma_count.chip = ....
2294         wcdma_count.slot = .....
2295         wcdma_count.frame = ....
2296
2297      @endverbatim
2298  * ===========================================================================
2299  */
2300 static inline
2301 void Aif2Fl_getAtUlRadtWcdmaValue (
2302         Aif2Fl_Handle   hAif2,
2303         Aif2Fl_AtWcdmaCount*     wcdma
2304 )
2305 {
2306         wcdma->chip =  CSL_FEXT(hAif2->regs->AT_ULRADT_WCDMA_VALUE, AIF2_AT_ULRADT_WCDMA_VALUE_CHIPVALUE);
2307          wcdma->slot =  CSL_FEXT(hAif2->regs->AT_ULRADT_WCDMA_VALUE, AIF2_AT_ULRADT_WCDMA_VALUE_SLOTVALUE);
2308          wcdma->frame =  CSL_FEXT(hAif2->regs->AT_ULRADT_WCDMA_VALUE, AIF2_AT_ULRADT_WCDMA_VALUE_FRAMEVALUE);
2309 }
2310
2311 /** ============================================================================
2312  *   @n@b Aif2Fl_getAtDlRadtWcdmaValue
2313  *
2314  *   @b Description
2315  *   @n Get Aif2 Dl Rad timer wcdma count value
2316  *
2317  *   @b Arguments
2318  *   @verbatim
2319            hAif2      Handle to the aif2 instance
2320            Aif2Fl_AtWcdmaCount     WCDMA chip, slot and frame value structure
2321       @endverbatim
2322  *
2323  *   <b> Return Value </b>  void
2324  *   <b> Pre Condition </b>
2325  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2326  *   in that order before calling this function.
2327  *
2328  *
2329  *   <b> Post Condition </b>
2330  *   @n None
2331  *
2332  *   @b Reads
2333  *   @n  AIF2_AT_DLRADT_WCDMA_VALUE_CHIPVALUE,AIF2_AT_DLRADT_WCDMA_VALUE_SLOTVALUE,
2334  *         AIF2_AT_DLRADT_WCDMA_VALUE_FRAMEVALUE
2335  *   @b Example
2336  *   @verbatim
2337         Aif2Fl_AtWcdmaCount  wcdma_count;
2338
2339         Aif2Fl_getAtDlRadtWcdmaValue(hAif2,&wcdma_count);
2340
2341         wcdma_count.chip = ....
2342         wcdma_count.slot = .....
2343         wcdma_count.frame = ....
2344
2345      @endverbatim
2346  * ===========================================================================
2347  */
2348 static inline
2349 void Aif2Fl_getAtDlRadtWcdmaValue (
2350         Aif2Fl_Handle   hAif2,
2351         Aif2Fl_AtWcdmaCount*     wcdma
2352 )
2353 {
2354         wcdma->chip =  CSL_FEXT(hAif2->regs->AT_DLRADT_WCDMA_VALUE, AIF2_AT_DLRADT_WCDMA_VALUE_CHIPVALUE);
2355          wcdma->slot =  CSL_FEXT(hAif2->regs->AT_DLRADT_WCDMA_VALUE, AIF2_AT_DLRADT_WCDMA_VALUE_SLOTVALUE);
2356          wcdma->frame =  CSL_FEXT(hAif2->regs->AT_DLRADT_WCDMA_VALUE, AIF2_AT_DLRADT_WCDMA_VALUE_FRAMEVALUE);
2357 }
2358
2359
2360 /** ============================================================================
2361  *   @n@b Aif2Fl_getAtRadtTstampClkCount
2362  *
2363  *   @b Description
2364  *   @n Get Aif2 Rad timer time stamp count value
2365  *
2366  *   @b Arguments
2367  *   @verbatim
2368            hAif2      Handle to the aif2 instance
2369       @endverbatim
2370  *
2371  *   <b> Return Value </b>  uint32_t
2372  *   <b> Pre Condition </b>
2373  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2374  *   in that order before calling this function.
2375  *
2376  *
2377  *   <b> Post Condition </b>
2378  *   @n None
2379  *
2380  *   @b Reads
2381  *   @n  AIF2_AT_RADT_TSTAMP_VALUE_RADTTSTAMP_CLOCK_COUNTER_VALUE
2382  *
2383  *   @b Example
2384  *   @verbatim
2385         uint32_t  count;
2386
2387         count = Aif2Fl_getAtRadtTstampClkCount(hAif2);
2388
2389      @endverbatim
2390  * ===========================================================================
2391  */
2392 static inline
2393 uint32_t Aif2Fl_getAtRadtTstampClkCount (
2394         Aif2Fl_Handle   hAif2
2395 )
2396 {
2397         return CSL_FEXT(hAif2->regs->AT_RADT_TSTAMP_VALUE, AIF2_AT_RADT_TSTAMP_VALUE_RADTTSTAMP_CLOCK_COUNTER_VALUE);
2398 }
2399
2400 /** ============================================================================
2401  *   @n@b Aif2Fl_getAtGsmTcount
2402  *
2403  *   @b Description
2404  *   @n Get Aif2 GSM Tcount value
2405  *
2406  *   @b Arguments
2407  *   @verbatim
2408            hAif2      Handle to the aif2 instance
2409            Aif2Fl_AtWcdmaCount     WCDMA chip, slot and frame value structure
2410       @endverbatim
2411  *
2412  *   <b> Return Value </b>  void
2413  *   <b> Pre Condition </b>
2414  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2415  *   in that order before calling this function.
2416  *
2417  *
2418  *   <b> Post Condition </b>
2419  *   @n None
2420  *
2421  *   @b Reads
2422  *   @n  AIF2_AT_GSM_TCOUNT_VALUE_T1,AIF2_AT_GSM_TCOUNT_VALUE_T2,
2423  *         AIF2_AT_GSM_TCOUNT_VALUE_T3
2424  *   @b Example
2425  *   @verbatim
2426         Aif2Fl_AtGsmTCount  tcount;
2427
2428         Aif2Fl_getAtGsmTcount(hAif2,&tcount);
2429
2430         tcount.t1 = ....
2431         tcount.t2 = .....
2432         tcount.t3 = ....
2433
2434      @endverbatim
2435  * ===========================================================================
2436  */
2437 static inline
2438 void Aif2Fl_getAtGsmTcount (
2439         Aif2Fl_Handle   hAif2,
2440         Aif2Fl_AtGsmTCount*     tcount
2441 )
2442 {
2443         tcount->t1 =  CSL_FEXT(hAif2->regs->AT_GSM_TCOUNT_VALUE, AIF2_AT_GSM_TCOUNT_VALUE_T1);
2444          tcount->t2 =  CSL_FEXT(hAif2->regs->AT_GSM_TCOUNT_VALUE, AIF2_AT_GSM_TCOUNT_VALUE_T2);
2445          tcount->t3 =  CSL_FEXT(hAif2->regs->AT_GSM_TCOUNT_VALUE, AIF2_AT_GSM_TCOUNT_VALUE_T3);
2446 }
2447
2448
2449 /** ============================================================================
2450  *   @n@b Aif2Fl_getEeDbIntStatus
2451  *
2452  *   @b Description
2453  *   @n Get Aif2 EE DB interrupt  status value
2454  *
2455  *   @b Arguments
2456  *   @verbatim
2457            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
2458            Aif2Fl_EeDbInt
2459       @endverbatim
2460  *
2461  *   <b> Return Value </b>  void
2462  *   <b> Pre Condition </b>
2463  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2464  *   in that order before calling this function.
2465  *
2466  *   <b> Post Condition </b>
2467  *   @n None
2468  *
2469  *   @b Reads
2470  *   @n  AIF2_EE_DB_IRS_DB_EE_I_TRC_RAM_OVFL_ERR,       AIF2_EE_DB_IRS_DB_EE_I_TOKEN_OVFL_ERR,
2471  *         AIF2_EE_DB_IRS_DB_EE_I_FIFO_OVFL_ERR,              AIF2_EE_DB_IRS_DB_EE_I_PD2DB_FULL_ERR,
2472  *         AIF2_EE_DB_IRS_DB_EE_E_PS_AXC_ERR,                 AIF2_EE_DB_IRS_DB_EE_E_CD_DATA_ERR,
2473  *         AIF2_EE_DB_IRS_DB_EE_E_CD_DATA_TYPE_ERR;
2474  *
2475  *         AIF2_EE_DB_EN_EV0_DB_EE_I_TRC_RAM_OVFL_ERR,       AIF2_EE_DB_EN_EV0_DB_EE_I_TOKEN_OVFL_ERR,
2476  *         AIF2_EE_DB_EN_EV0_DB_EE_I_FIFO_OVFL_ERR,              AIF2_EE_DB_EN_EV0_DB_EE_I_PD2DB_FULL_ERR,
2477  *         AIF2_EE_DB_EN_EV0_DB_EE_E_PS_AXC_ERR,                 AIF2_EE_DB_EN_EV0_DB_EE_E_CD_DATA_ERR,
2478  *         AIF2_EE_DB_EN_EV0_DB_EE_E_CD_DATA_TYPE_ERR;
2479  *
2480  *         AIF2_EE_DB_EN_EV1_DB_EE_I_TRC_RAM_OVFL_ERR,       AIF2_EE_DB_EN_EV1_DB_EE_I_TOKEN_OVFL_ERR,
2481  *         AIF2_EE_DB_EN_EV1_DB_EE_I_FIFO_OVFL_ERR,              AIF2_EE_DB_EN_EV1_DB_EE_I_PD2DB_FULL_ERR,
2482  *         AIF2_EE_DB_EN_EV1_DB_EE_E_PS_AXC_ERR,                 AIF2_EE_DB_EN_EV1_DB_EE_E_CD_DATA_ERR,
2483  *         AIF2_EE_DB_EN_EV1_DB_EE_E_CD_DATA_TYPE_ERR;
2484  *
2485  *         AIF2_EE_DB_EN_STS_EV0_DB_EE_I_TRC_RAM_OVFL_ERR,       AIF2_EE_DB_EN_STS_EV0_DB_EE_I_TOKEN_OVFL_ERR,
2486  *         AIF2_EE_DB_EN_STS_EV0_DB_EE_I_FIFO_OVFL_ERR,              AIF2_EE_DB_EN_STS_EV0_DB_EE_I_PD2DB_FULL_ERR,
2487  *         AIF2_EE_DB_EN_STS_EV0_DB_EE_E_PS_AXC_ERR,                 AIF2_EE_DB_EN_STS_EV0_DB_EE_E_CD_DATA_ERR,
2488  *         AIF2_EE_DB_EN_STS_EV0_DB_EE_E_CD_DATA_TYPE_ERR;
2489  *
2490  *         AIF2_EE_DB_EN_STS_EV1_DB_EE_I_TRC_RAM_OVFL_ERR,       AIF2_EE_DB_EN_STS_EV1_DB_EE_I_TOKEN_OVFL_ERR,
2491  *         AIF2_EE_DB_EN_STS_EV1_DB_EE_I_FIFO_OVFL_ERR,              AIF2_EE_DB_EN_STS_EV1_DB_EE_I_PD2DB_FULL_ERR,
2492  *         AIF2_EE_DB_EN_STS_EV1_DB_EE_E_PS_AXC_ERR,                 AIF2_EE_DB_EN_STS_EV1_DB_EE_E_CD_DATA_ERR,
2493  *         AIF2_EE_DB_EN_STS_EV1_DB_EE_E_CD_DATA_TYPE_ERR;
2494  *   @b Example
2495  *   @verbatim
2496         Aif2Fl_EeDbInt  DbInt;
2497         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
2498
2499         Aif2Fl_getEeDbIntStatus(hAif2,&DbInt);
2500      @endverbatim
2501  * ===========================================================================
2502  */
2503 static inline
2504 void Aif2Fl_getEeDbIntStatus (
2505         Aif2Fl_Handle   hAif2,
2506         Aif2Fl_EeDbInt*     DbInt
2507 )
2508 {
2509         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
2510          DbInt->db_ee_i_trc_ram_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_IRS, AIF2_EE_DB_IRS_DB_EE_I_TRC_RAM_OVFL_ERR);
2511          DbInt->db_ee_i_token_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_IRS, AIF2_EE_DB_IRS_DB_EE_I_TOKEN_OVFL_ERR);
2512          DbInt->db_ee_i_fifo_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_IRS, AIF2_EE_DB_IRS_DB_EE_I_FIFO_OVFL_ERR);
2513          DbInt->db_ee_i_pd2db_full_err =  CSL_FEXT(hAif2->regs->EE_DB_IRS, AIF2_EE_DB_IRS_DB_EE_I_PD2DB_FULL_ERR);
2514          DbInt->db_ee_e_ps_axc_err =  CSL_FEXT(hAif2->regs->EE_DB_IRS, AIF2_EE_DB_IRS_DB_EE_E_PS_AXC_ERR);
2515          DbInt->db_ee_e_cd_data_err =  CSL_FEXT(hAif2->regs->EE_DB_IRS, AIF2_EE_DB_IRS_DB_EE_E_CD_DATA_ERR);
2516          DbInt->db_ee_e_cd_data_type_err=  CSL_FEXT(hAif2->regs->EE_DB_IRS, AIF2_EE_DB_IRS_DB_EE_E_CD_DATA_TYPE_ERR);
2517         }
2518          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
2519          DbInt->db_ee_i_trc_ram_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV0, AIF2_EE_DB_EN_EV0_DB_EE_I_TRC_RAM_OVFL_ERR);
2520          DbInt->db_ee_i_token_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV0, AIF2_EE_DB_EN_EV0_DB_EE_I_TOKEN_OVFL_ERR);
2521          DbInt->db_ee_i_fifo_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV0, AIF2_EE_DB_EN_EV0_DB_EE_I_FIFO_OVFL_ERR);
2522          DbInt->db_ee_i_pd2db_full_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV0, AIF2_EE_DB_EN_EV0_DB_EE_I_PD2DB_FULL_ERR);
2523          DbInt->db_ee_e_ps_axc_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV0, AIF2_EE_DB_EN_EV0_DB_EE_E_PS_AXC_ERR);
2524          DbInt->db_ee_e_cd_data_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV0, AIF2_EE_DB_EN_EV0_DB_EE_E_CD_DATA_ERR);
2525          DbInt->db_ee_e_cd_data_type_err=  CSL_FEXT(hAif2->regs->EE_DB_EN_EV0, AIF2_EE_DB_EN_EV0_DB_EE_E_CD_DATA_TYPE_ERR);
2526         }
2527          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
2528          DbInt->db_ee_i_trc_ram_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV1, AIF2_EE_DB_EN_EV1_DB_EE_I_TRC_RAM_OVFL_ERR);
2529          DbInt->db_ee_i_token_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV1, AIF2_EE_DB_EN_EV1_DB_EE_I_TOKEN_OVFL_ERR);
2530          DbInt->db_ee_i_fifo_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV1, AIF2_EE_DB_EN_EV1_DB_EE_I_FIFO_OVFL_ERR);
2531          DbInt->db_ee_i_pd2db_full_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV1, AIF2_EE_DB_EN_EV1_DB_EE_I_PD2DB_FULL_ERR);
2532          DbInt->db_ee_e_ps_axc_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV1, AIF2_EE_DB_EN_EV1_DB_EE_E_PS_AXC_ERR);
2533          DbInt->db_ee_e_cd_data_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_EV1, AIF2_EE_DB_EN_EV1_DB_EE_E_CD_DATA_ERR);
2534          DbInt->db_ee_e_cd_data_type_err=  CSL_FEXT(hAif2->regs->EE_DB_EN_EV1, AIF2_EE_DB_EN_EV1_DB_EE_E_CD_DATA_TYPE_ERR);
2535         }
2536          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
2537          DbInt->db_ee_i_trc_ram_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV0, AIF2_EE_DB_EN_STS_EV0_DB_EE_I_TRC_RAM_OVFL_ERR);
2538          DbInt->db_ee_i_token_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV0, AIF2_EE_DB_EN_STS_EV0_DB_EE_I_TOKEN_OVFL_ERR);
2539          DbInt->db_ee_i_fifo_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV0, AIF2_EE_DB_EN_STS_EV0_DB_EE_I_FIFO_OVFL_ERR);
2540          DbInt->db_ee_i_pd2db_full_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV0, AIF2_EE_DB_EN_STS_EV0_DB_EE_I_PD2DB_FULL_ERR);
2541          DbInt->db_ee_e_ps_axc_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV0, AIF2_EE_DB_EN_STS_EV0_DB_EE_E_PS_AXC_ERR);
2542          DbInt->db_ee_e_cd_data_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV0, AIF2_EE_DB_EN_STS_EV0_DB_EE_E_CD_DATA_ERR);
2543          DbInt->db_ee_e_cd_data_type_err=  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV0, AIF2_EE_DB_EN_STS_EV0_DB_EE_E_CD_DATA_TYPE_ERR);
2544         }
2545          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
2546          DbInt->db_ee_i_trc_ram_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV1, AIF2_EE_DB_EN_STS_EV1_DB_EE_I_TRC_RAM_OVFL_ERR);
2547          DbInt->db_ee_i_token_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV1, AIF2_EE_DB_EN_STS_EV1_DB_EE_I_TOKEN_OVFL_ERR);
2548          DbInt->db_ee_i_fifo_ovfl_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV1, AIF2_EE_DB_EN_STS_EV1_DB_EE_I_FIFO_OVFL_ERR);
2549          DbInt->db_ee_i_pd2db_full_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV1, AIF2_EE_DB_EN_STS_EV1_DB_EE_I_PD2DB_FULL_ERR);
2550          DbInt->db_ee_e_ps_axc_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV1, AIF2_EE_DB_EN_STS_EV1_DB_EE_E_PS_AXC_ERR);
2551          DbInt->db_ee_e_cd_data_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV1, AIF2_EE_DB_EN_STS_EV1_DB_EE_E_CD_DATA_ERR);
2552          DbInt->db_ee_e_cd_data_type_err =  CSL_FEXT(hAif2->regs->EE_DB_EN_STS_EV1, AIF2_EE_DB_EN_STS_EV1_DB_EE_E_CD_DATA_TYPE_ERR);
2553         }
2554
2555 }
2556
2557
2558 /** ============================================================================
2559  *   @n@b Aif2Fl_getEeAdIntStatus
2560  *
2561  *   @b Description
2562  *   @n Get Aif2 EE AD interrupt  status value
2563  *
2564  *   @b Arguments
2565  *   @verbatim
2566            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
2567            Aif2Fl_EeAdInt
2568       @endverbatim
2569  *
2570  *   <b> Return Value </b>  void
2571  *   <b> Pre Condition </b>
2572  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2573  *   in that order before calling this function.
2574  *
2575  *   <b> Post Condition </b>
2576  *   @n None
2577  *
2578  *   @b Reads
2579  *   @n  AIF2_EE_AD_IRS_AD_EE_I_CD_DATA_ERR,       AIF2_EE_AD_IRS_AD_EE_E_CD_SCH_ERR,
2580  *         AIF2_EE_AD_IRS_AD_EE_I_DMA_0_ERR,            AIF2_EE_AD_IRS_AD_EE_I_DMA_1_ERR,
2581  *         AIF2_EE_AD_IRS_AD_EE_I_DMA_2_ERR,            AIF2_EE_AD_IRS_AD_EE_E_DMA_0_ERR,
2582  *         AIF2_EE_AD_IRS_AD_EE_E_DMA_1_ERR,            AIF2_EE_AD_IRS_AD_EE_E_DMA_2_ERR;
2583  *
2584  *         AIF2_EE_AD_EN_EV0_AD_EE_I_CD_DATA_ERR,       AIF2_EE_AD_EN_EV0_AD_EE_E_CD_SCH_ERR,
2585  *         AIF2_EE_AD_EN_EV0_AD_EE_I_DMA_0_ERR,            AIF2_EE_AD_EN_EV0_AD_EE_I_DMA_1_ERR,
2586  *         AIF2_EE_AD_EN_EV0_AD_EE_I_DMA_2_ERR,            AIF2_EE_AD_EN_EV0_AD_EE_E_DMA_0_ERR,
2587  *         AIF2_EE_AD_EN_EV0_AD_EE_E_DMA_1_ERR,            AIF2_EE_AD_EN_EV0_AD_EE_E_DMA_2_ERR;
2588  *
2589  *         AIF2_EE_AD_EN_EV1_AD_EE_I_CD_DATA_ERR,       AIF2_EE_AD_EN_EV1_AD_EE_E_CD_SCH_ERR,
2590  *         AIF2_EE_AD_EN_EV1_AD_EE_I_DMA_0_ERR,            AIF2_EE_AD_EN_EV1_AD_EE_I_DMA_1_ERR,
2591  *         AIF2_EE_AD_EN_EV1_AD_EE_I_DMA_2_ERR,            AIF2_EE_AD_EN_EV1_AD_EE_E_DMA_0_ERR,
2592  *         AIF2_EE_AD_EN_EV1_AD_EE_E_DMA_1_ERR,            AIF2_EE_AD_EN_EV1_AD_EE_E_DMA_2_ERR;
2593  *
2594  *         AIF2_EE_AD_EN_STS_EV0_AD_EE_I_CD_DATA_ERR,       AIF2_EE_AD_EN_STS_EV0_AD_EE_E_CD_SCH_ERR,
2595  *         AIF2_EE_AD_EN_STS_EV0_AD_EE_I_DMA_0_ERR,            AIF2_EE_AD_EN_STS_EV0_AD_EE_I_DMA_1_ERR,
2596  *         AIF2_EE_AD_EN_STS_EV0_AD_EE_I_DMA_2_ERR,            AIF2_EE_AD_EN_STS_EV0_AD_EE_E_DMA_0_ERR,
2597  *         AIF2_EE_AD_EN_STS_EV0_AD_EE_E_DMA_1_ERR,            AIF2_EE_AD_EN_STS_EV0_AD_EE_E_DMA_2_ERR;
2598  *
2599  *         AIF2_EE_AD_EN_STS_EV1_AD_EE_I_CD_DATA_ERR,       AIF2_EE_AD_EN_STS_EV1_AD_EE_E_CD_SCH_ERR,
2600  *         AIF2_EE_AD_EN_STS_EV1_AD_EE_I_DMA_0_ERR,            AIF2_EE_AD_EN_STS_EV1_AD_EE_I_DMA_1_ERR,
2601  *         AIF2_EE_AD_EN_STS_EV1_AD_EE_I_DMA_2_ERR,            AIF2_EE_AD_EN_STS_EV1_AD_EE_E_DMA_0_ERR,
2602  *         AIF2_EE_AD_EN_STS_EV1_AD_EE_E_DMA_1_ERR,            AIF2_EE_AD_EN_STS_EV1_AD_EE_E_DMA_2_ERR;
2603  *   @b Example
2604  *   @verbatim
2605         Aif2Fl_EeAdInt  AdInt;
2606         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
2607
2608         Aif2Fl_getEeAdIntStatus(hAif2,&AdInt);
2609      @endverbatim
2610  * ===========================================================================
2611  */
2612 static inline
2613 void Aif2Fl_getEeAdIntStatus (
2614         Aif2Fl_Handle   hAif2,
2615         Aif2Fl_EeAdInt*     AdInt
2616 )
2617 {
2618         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
2619          AdInt->ad_ee_i_cd_data_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_I_CD_DATA_ERR);
2620          AdInt->ad_ee_e_cd_sch_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_E_CD_SCH_ERR);
2621          AdInt->ad_ee_i_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_I_DMA_0_ERR);
2622          AdInt->ad_ee_i_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_I_DMA_1_ERR);
2623          AdInt->ad_ee_i_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_I_DMA_2_ERR);
2624          AdInt->ad_ee_e_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_E_DMA_0_ERR);
2625          AdInt->ad_ee_e_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_E_DMA_1_ERR);
2626          AdInt->ad_ee_e_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_IRS, AIF2_EE_AD_IRS_AD_EE_E_DMA_2_ERR);
2627         }
2628          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
2629          AdInt->ad_ee_i_cd_data_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_I_CD_DATA_ERR);
2630          AdInt->ad_ee_e_cd_sch_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_E_CD_SCH_ERR);
2631          AdInt->ad_ee_i_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_I_DMA_0_ERR);
2632          AdInt->ad_ee_i_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_I_DMA_1_ERR);
2633          AdInt->ad_ee_i_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_I_DMA_2_ERR);
2634          AdInt->ad_ee_e_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_E_DMA_0_ERR);
2635          AdInt->ad_ee_e_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_E_DMA_1_ERR);
2636          AdInt->ad_ee_e_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV0, AIF2_EE_AD_EN_EV0_AD_EE_E_DMA_2_ERR);
2637         }
2638          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
2639          AdInt->ad_ee_i_cd_data_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_I_CD_DATA_ERR);
2640          AdInt->ad_ee_e_cd_sch_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_E_CD_SCH_ERR);
2641          AdInt->ad_ee_i_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_I_DMA_0_ERR);
2642          AdInt->ad_ee_i_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_I_DMA_1_ERR);
2643          AdInt->ad_ee_i_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_I_DMA_2_ERR);
2644          AdInt->ad_ee_e_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_E_DMA_0_ERR);
2645          AdInt->ad_ee_e_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_E_DMA_1_ERR);
2646          AdInt->ad_ee_e_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_EV1, AIF2_EE_AD_EN_EV1_AD_EE_E_DMA_2_ERR);
2647         }
2648          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
2649          AdInt->ad_ee_i_cd_data_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_I_CD_DATA_ERR);
2650          AdInt->ad_ee_e_cd_sch_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_E_CD_SCH_ERR);
2651          AdInt->ad_ee_i_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_I_DMA_0_ERR);
2652          AdInt->ad_ee_i_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_I_DMA_1_ERR);
2653          AdInt->ad_ee_i_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_I_DMA_2_ERR);
2654          AdInt->ad_ee_e_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_E_DMA_0_ERR);
2655          AdInt->ad_ee_e_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_E_DMA_1_ERR);
2656          AdInt->ad_ee_e_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV0, AIF2_EE_AD_EN_STS_EV0_AD_EE_E_DMA_2_ERR);
2657         }
2658          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
2659          AdInt->ad_ee_i_cd_data_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_I_CD_DATA_ERR);
2660          AdInt->ad_ee_e_cd_sch_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_E_CD_SCH_ERR);
2661          AdInt->ad_ee_i_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_I_DMA_0_ERR);
2662          AdInt->ad_ee_i_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_I_DMA_1_ERR);
2663          AdInt->ad_ee_i_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_I_DMA_2_ERR);
2664          AdInt->ad_ee_e_dma_0_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_E_DMA_0_ERR);
2665          AdInt->ad_ee_e_dma_1_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_E_DMA_1_ERR);
2666          AdInt->ad_ee_e_dma_2_err =  CSL_FEXT(hAif2->regs->EE_AD_EN_STS_EV1, AIF2_EE_AD_EN_STS_EV1_AD_EE_E_DMA_2_ERR);
2667         }
2668
2669 }
2670
2671
2672 /** ============================================================================
2673  *   @n@b Aif2Fl_getEeCdIntStatus
2674  *
2675  *   @b Description
2676  *   @n Get Aif2 EE CD(PKTDMA) interrupt  status value
2677  *
2678  *   @b Arguments
2679  *   @verbatim
2680            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
2681            Aif2Fl_EeCdInt
2682       @endverbatim
2683  *
2684  *   <b> Return Value </b>  void
2685  *   <b> Pre Condition </b>
2686  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2687  *   in that order before calling this function.
2688  *
2689  *   <b> Post Condition </b>
2690  *   @n None
2691  *
2692  *   @b Reads
2693  *   @n  AIF2_EE_CD_IRS_CD_EE_SOP_DESC_STARVE_ERR,       AIF2_EE_CD_IRS_CD_EE_MOP_DESC_STARVE_ERR;
2694  *
2695  *         AIF2_EE_CD_EN_EV_CD_EE_SOP_DESC_STARVE_ERR,       AIF2_EE_CD_EN_EV_CD_EE_MOP_DESC_STARVE_ERR;
2696  *
2697  *         AIF2_EE_CD_EN_STS_EV_CD_EE_SOP_DESC_STARVE_ERR,       AIF2_EE_CD_EN_STS_EV_CD_EE_MOP_DESC_STARVE_ERR;
2698  *
2699  *   @b Example
2700  *   @verbatim
2701         Aif2Fl_EeCdInt  CdInt;
2702         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
2703
2704         Aif2Fl_getEeCdIntStatus(hAif2,&CdInt);
2705      @endverbatim
2706  * ===========================================================================
2707  */
2708 static inline
2709 void Aif2Fl_getEeCdIntStatus (
2710         Aif2Fl_Handle   hAif2,
2711         Aif2Fl_EeCdInt*     CdInt
2712 )
2713 {
2714         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
2715          CdInt->cd_ee_sop_desc_starve_err =  CSL_FEXT(hAif2->regs->EE_CD_IRS, AIF2_EE_CD_IRS_CD_EE_SOP_DESC_STARVE_ERR);
2716          CdInt->cd_ee_mop_desc_starve_err =  CSL_FEXT(hAif2->regs->EE_CD_IRS, AIF2_EE_CD_IRS_CD_EE_MOP_DESC_STARVE_ERR);
2717         }
2718          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
2719         CdInt->cd_ee_sop_desc_starve_err =  CSL_FEXT(hAif2->regs->EE_CD_EN_EV, AIF2_EE_CD_EN_EV_CD_EE_SOP_DESC_STARVE_ERR);
2720          CdInt->cd_ee_mop_desc_starve_err =  CSL_FEXT(hAif2->regs->EE_CD_EN_EV, AIF2_EE_CD_EN_EV_CD_EE_MOP_DESC_STARVE_ERR);
2721         }
2722          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
2723         CdInt->cd_ee_sop_desc_starve_err =  CSL_FEXT(hAif2->regs->EE_CD_EN_STS_EV, AIF2_EE_CD_EN_STS_EV_CD_EE_SOP_DESC_STARVE_ERR);
2724          CdInt->cd_ee_mop_desc_starve_err =  CSL_FEXT(hAif2->regs->EE_CD_EN_STS_EV, AIF2_EE_CD_EN_STS_EV_CD_EE_MOP_DESC_STARVE_ERR);
2725         }
2726
2727 }
2728
2729
2730 /** ============================================================================
2731  *   @n@b Aif2Fl_getEeSdIntStatus
2732  *
2733  *   @b Description
2734  *   @n Get Aif2 EE SD interrupt  status value
2735  *
2736  *   @b Arguments
2737  *   @verbatim
2738            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
2739            Aif2Fl_EeSdInt
2740       @endverbatim
2741  *
2742  *   <b> Return Value </b>  void
2743  *   <b> Pre Condition </b>
2744  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2745  *   in that order before calling this function.
2746  *
2747  *   <b> Post Condition </b>
2748  *   @n None
2749  *
2750  *   @b Reads
2751  *   @n  AIF2_EE_SD_IRS_SD_EE_STSPLL_B4_ERR,       AIF2_EE_SD_IRS_SD_EE_STSPLL_B8_ERR;
2752  *
2753  *       AIF2_EE_SD_EN_EV0_SD_EE_STSPLL_B4_ERR,       AIF2_EE_SD_EN_EV0_SD_EE_STSPLL_B8_ERR;
2754  *       AIF2_EE_SD_EN_STS_EV0_SD_EE_STSPLL_B4_ERR,    AIF2_EE_SD_EN_STS_EV0_SD_EE_STSPLL_B8_ERR;
2755  *
2756  *       AIF2_EE_SD_EN_EV1_SD_EE_STSPLL_B4_ERR,       AIF2_EE_SD_EN_EV1_SD_EE_STSPLL_B8_ERR;
2757  *       AIF2_EE_SD_EN_STS_EV1_SD_EE_STSPLL_B4_ERR,    AIF2_EE_SD_EN_STS_EV1_SD_EE_STSPLL_B8_ERR;
2758  *   @b Example
2759  *   @verbatim
2760         Aif2Fl_EeSdInt  SdInt;
2761         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
2762
2763         Aif2Fl_getEeSdIntStatus(hAif2,&SdInt);
2764      @endverbatim
2765  * ===========================================================================
2766  */
2767 static inline
2768 void Aif2Fl_getEeSdIntStatus (
2769         Aif2Fl_Handle   hAif2,
2770         Aif2Fl_EeSdInt*     SdInt
2771 )
2772 {
2773         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
2774          SdInt->sd_ee_stspll_b4_err =  CSL_FEXT(hAif2->regs->EE_SD_IRS, AIF2_EE_SD_IRS_SD_EE_STSPLL_B4_ERR);
2775          SdInt->sd_ee_stspll_b8_err =  CSL_FEXT(hAif2->regs->EE_SD_IRS, AIF2_EE_SD_IRS_SD_EE_STSPLL_B8_ERR);
2776         }
2777          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
2778          SdInt->sd_ee_stspll_b4_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_EV0, AIF2_EE_SD_EN_EV0_SD_EE_STSPLL_B4_ERR);
2779          SdInt->sd_ee_stspll_b8_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_EV0, AIF2_EE_SD_EN_EV0_SD_EE_STSPLL_B8_ERR);
2780         }
2781          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
2782      SdInt->sd_ee_stspll_b4_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_STS_EV0, AIF2_EE_SD_EN_STS_EV0_SD_EE_STSPLL_B4_ERR);
2783          SdInt->sd_ee_stspll_b8_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_STS_EV0, AIF2_EE_SD_EN_STS_EV0_SD_EE_STSPLL_B8_ERR);
2784         }
2785          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
2786          SdInt->sd_ee_stspll_b4_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_EV1, AIF2_EE_SD_EN_EV1_SD_EE_STSPLL_B4_ERR);
2787          SdInt->sd_ee_stspll_b8_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_EV1, AIF2_EE_SD_EN_EV1_SD_EE_STSPLL_B8_ERR);
2788         }
2789          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
2790      SdInt->sd_ee_stspll_b4_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_STS_EV1, AIF2_EE_SD_EN_STS_EV1_SD_EE_STSPLL_B4_ERR);
2791          SdInt->sd_ee_stspll_b8_err =  CSL_FEXT(hAif2->regs->EE_SD_EN_STS_EV1, AIF2_EE_SD_EN_STS_EV1_SD_EE_STSPLL_B8_ERR);
2792         }
2793 }
2794
2795
2796 /** ============================================================================
2797  *   @n@b Aif2Fl_getEeVcIntStatus
2798  *
2799  *   @b Description
2800  *   @n Get Aif2 EE VC interrupt  status value
2801  *
2802  *   @b Arguments
2803  *   @verbatim
2804            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
2805            Aif2Fl_EeVcInt
2806       @endverbatim
2807  *
2808  *   <b> Return Value </b>  void
2809  *   <b> Pre Condition </b>
2810  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2811  *   in that order before calling this function.
2812  *
2813  *   <b> Post Condition </b>
2814  *   @n None
2815  *
2816  *   @b Reads
2817  *   @n  AIF2_EE_VC_IRS_VC_EE_VBUS_ERR;  AIF2_EE_VC_EN_EV0_VC_EE_VBUS_ERR;
2818  *         AIF2_EE_VC_EN_STS_EV0_VC_EE_VBUS_ERR;  AIF2_EE_VC_EN_EV1_VC_EE_VBUS_ERR;
2819  *         AIF2_EE_VC_EN_STS_EV1_VC_EE_VBUS_ERR
2820  *   @b Example
2821  *   @verbatim
2822         Aif2Fl_EeVcInt  VcInt;
2823         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
2824
2825         Aif2Fl_getEeVcIntStatus(hAif2,&VcInt);
2826      @endverbatim
2827  * ===========================================================================
2828  */
2829 static inline
2830 void Aif2Fl_getEeVcIntStatus (
2831         Aif2Fl_Handle   hAif2,
2832         Aif2Fl_EeVcInt*     VcInt
2833 )
2834 {
2835         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS)
2836          VcInt->vc_ee_vbus_err =  CSL_FEXT(hAif2->regs->EE_VC_IRS, AIF2_EE_VC_IRS_VC_EE_VBUS_ERR);
2837          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0)
2838          VcInt->vc_ee_vbus_err =  CSL_FEXT(hAif2->regs->EE_VC_EN_EV0, AIF2_EE_VC_EN_EV0_VC_EE_VBUS_ERR);
2839          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0)
2840         VcInt->vc_ee_vbus_err =  CSL_FEXT(hAif2->regs->EE_VC_EN_STS_EV0, AIF2_EE_VC_EN_STS_EV0_VC_EE_VBUS_ERR);
2841          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1)
2842          VcInt->vc_ee_vbus_err =  CSL_FEXT(hAif2->regs->EE_VC_EN_EV1, AIF2_EE_VC_EN_EV1_VC_EE_VBUS_ERR);
2843          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1)
2844         VcInt->vc_ee_vbus_err =  CSL_FEXT(hAif2->regs->EE_VC_EN_STS_EV1, AIF2_EE_VC_EN_STS_EV1_VC_EE_VBUS_ERR);
2845 }
2846
2847
2848 /** ============================================================================
2849  *   @n@b Aif2Fl_getEeAif2RunStatus
2850  *
2851  *   @b Description
2852  *   @n Get Aif2 EE AIF2 run status value
2853  *
2854  *   @b Arguments
2855  *   @verbatim
2856            hAif2      Handle to the aif2 instance
2857            Aif2Fl_EeAif2Run
2858       @endverbatim
2859  *
2860  *   <b> Return Value </b>  void
2861  *   <b> Pre Condition </b>
2862  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2863  *   in that order before calling this function.
2864  *
2865  *   <b> Post Condition </b>
2866  *   @n None
2867  *
2868  *   @b Reads
2869  *   @n  AIF2_EE_AIF2_RUN_STS_AIF2_PHY_RUN,  AIF2_EE_AIF2_RUN_STS_AIF2_GLOBAL_RUN;
2870  *
2871  *   @b Example
2872  *   @verbatim
2873         Aif2Fl_EeAif2Run  Aif2Run;
2874
2875         Aif2Fl_getEeAif2RunStatus(hAif2,&Aif2Run);
2876      @endverbatim
2877  * ===========================================================================
2878  */
2879 static inline
2880 void Aif2Fl_getEeAif2RunStatus (
2881         Aif2Fl_Handle   hAif2,
2882         Aif2Fl_EeAif2Run*     Aif2Run
2883 )
2884 {
2885          Aif2Run->aif2_phy_run =  CSL_FEXT(hAif2->regs->EE_AIF2_RUN_STS, AIF2_EE_AIF2_RUN_STS_AIF2_PHY_RUN);
2886          Aif2Run->aif2_global_run =  CSL_FEXT(hAif2->regs->EE_AIF2_RUN_STS, AIF2_EE_AIF2_RUN_STS_AIF2_GLOBAL_RUN);
2887 }
2888
2889
2890 /** ============================================================================
2891  *   @n@b Aif2Fl_getEeAif2Origination
2892  *
2893  *   @b Description
2894  *   @n Get Aif2 EE error or alarm origination status
2895  *
2896  *   @b Arguments
2897  *   @verbatim
2898            hAif2      Handle to the aif2 instance
2899            Aif2Fl_EeOrigin
2900       @endverbatim
2901  *
2902  *   <b> Return Value </b>  void
2903  *   <b> Pre Condition </b>
2904  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2905  *   in that order before calling this function.
2906  *
2907  *   <b> Post Condition </b>
2908  *   @n None
2909  *
2910  *   @b Reads
2911  *   @n  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A0,  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B0,
2912  *         AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A1,  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B1,
2913  *         AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A2,  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B2,
2914  *         AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A3,  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B3,
2915  *         AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A4,  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B4,
2916  *         AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A5,  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B5,
2917  *         AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A0,  AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B0,
2918  *         AIF2_EE_ERR_ALRM_ORGN_AT_EN_STS,AIF2_EE_ERR_ALRM_ORGN_SD_EN_STS,
2919  *         AIF2_EE_ERR_ALRM_ORGN_DB_EN_STS,AIF2_EE_ERR_ALRM_ORGN_AD_EN_STS,
2920  *         AIF2_EE_ERR_ALRM_ORGN_VC_EN_STS
2921  *   @b Example
2922  *   @verbatim
2923         Aif2Fl_EeOrigin  Aif2Origin;
2924
2925         Aif2Fl_getEeAif2Origination(hAif2,&Aif2Origin);
2926      @endverbatim
2927  * ===========================================================================
2928  */
2929 static inline
2930 void Aif2Fl_getEeAif2Origination (
2931         Aif2Fl_Handle   hAif2,
2932         Aif2Fl_EeOrigin*     Aif2Origin
2933 )
2934 {
2935          Aif2Origin->lk_en_sts_a0=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A0);
2936          Aif2Origin->lk_en_sts_b0=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B0);
2937          Aif2Origin->lk_en_sts_a1=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A1);
2938          Aif2Origin->lk_en_sts_b1=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B1);
2939          Aif2Origin->lk_en_sts_a2=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A2);
2940          Aif2Origin->lk_en_sts_b2=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B2);
2941          Aif2Origin->lk_en_sts_a3=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A3);
2942          Aif2Origin->lk_en_sts_b3=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B3);
2943          Aif2Origin->lk_en_sts_a4=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A4);
2944          Aif2Origin->lk_en_sts_b4=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B4);
2945          Aif2Origin->lk_en_sts_a5=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_A5);
2946          Aif2Origin->lk_en_sts_b5=  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_LK_EN_STS_B5);
2947          Aif2Origin->at_en_sts =  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_AT_EN_STS);
2948          Aif2Origin->sd_en_sts =  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_SD_EN_STS);
2949          Aif2Origin->db_en_sts =  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_DB_EN_STS);
2950          Aif2Origin->ad_en_sts =  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_AD_EN_STS);
2951          Aif2Origin->cd_en_sts =  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_CD_EN_STS);
2952          Aif2Origin->vc_en_sts =  CSL_FEXT(hAif2->regs->EE_ERR_ALRM_ORGN, AIF2_EE_ERR_ALRM_ORGN_VC_EN_STS);
2953 }
2954
2955
2956 /** ============================================================================
2957  *   @n@b Aif2Fl_getEeLinkAIntStatus
2958  *
2959  *   @b Description
2960  *   @n Get Aif2 EE Link A interrupt  status value
2961  *
2962  *   @b Arguments
2963  *   @verbatim
2964            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function and hAif2->arg_link to select link
2965            Aif2Fl_EeLinkAInt
2966       @endverbatim
2967  *
2968  *   <b> Return Value </b>  void
2969  *   <b> Pre Condition </b>
2970  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
2971  *   in that order before calling this function.
2972  *
2973  *   <b> Post Condition </b>
2974  *   @n None
2975  *
2976  *   @b Reads
2977  *   @n  AIF2_EE_LK_IRS_A_RM_EE_SYNC_STATUS_CHANGE_ERR,      AIF2_EE_LK_IRS_A_RM_EE_NUM_LOS_DET_ERR,
2978  *         AIF2_EE_LK_IRS_A_RM_EE_LCV_DET_ERR,                            AIF2_EE_LK_IRS_A_RM_EE_FRAME_BNDRY_DET_ERR,
2979  *         AIF2_EE_LK_IRS_A_RM_EE_BLOCK_BNDRY_DET_ERR,            AIF2_EE_LK_IRS_A_RM_EE_MISSING_K28P5_ERR,
2980  *         AIF2_EE_LK_IRS_A_RM_EE_MISSING_K28P7_ERR,                 AIF2_EE_LK_IRS_A_RM_EE_K30P7_DET_ERR,
2981  *         AIF2_EE_LK_IRS_A_RM_EE_LOC_DET_ERR,                           AIF2_EE_LK_IRS_A_RM_EE_RX_FIFO_OVF_ERR,
2982  *         AIF2_EE_LK_IRS_A_RM_EE_RCVD_LOS_ERR,                         AIF2_EE_LK_IRS_A_RM_EE_RCVD_LOF_ERR,
2983  *         AIF2_EE_LK_IRS_A_RM_EE_RCVD_RAI_ERR,                         AIF2_EE_LK_IRS_A_RM_EE_RCVD_SDI_ERR,
2984  *         AIF2_EE_LK_IRS_A_RM_EE_LOS_ERR,                                   AIF2_EE_LK_IRS_A_RM_EE_LOF_ERR,
2985  *         AIF2_EE_LK_IRS_A_RM_EE_HFNSYNC_STATE_ERR,                AIF2_EE_LK_IRS_A_RM_EE_LOF_STATE_ERR,
2986  *         AIF2_EE_LK_IRS_A_TM_EE_FRM_MISALIGN_ERR,                   AIF2_EE_LK_IRS_A_TM_EE_FIFO_STARVE_ERR;
2987  *
2988  *         AIF2_EE_LK_EN_A_EV0_RM_EE_SYNC_STATUS_CHANGE_ERR,      AIF2_EE_LK_EN_A_EV0_RM_EE_NUM_LOS_DET_ERR,
2989  *         AIF2_EE_LK_EN_A_EV0_RM_EE_LCV_DET_ERR,                            AIF2_EE_LK_EN_A_EV0_RM_EE_FRAME_BNDRY_DET_ERR,
2990  *         AIF2_EE_LK_EN_A_EV0_RM_EE_BLOCK_BNDRY_DET_ERR,            AIF2_EE_LK_EN_A_EV0_RM_EE_MISSING_K28P5_ERR,
2991  *         AIF2_EE_LK_EN_A_EV0_RM_EE_MISSING_K28P7_ERR,                 AIF2_EE_LK_EN_A_EV0_RM_EE_K30P7_DET_ERR,
2992  *         AIF2_EE_LK_EN_A_EV0_RM_EE_LOC_DET_ERR,                           AIF2_EE_LK_EN_A_EV0_RM_EE_RX_FIFO_OVF_ERR,
2993  *         AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_LOS_ERR,                         AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_LOF_ERR,
2994  *         AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_RAI_ERR,                         AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_SDI_ERR,
2995  *         AIF2_EE_LK_EN_A_EV0_RM_EE_LOS_ERR,                                   AIF2_EE_LK_EN_A_EV0_RM_EE_LOF_ERR,
2996  *         AIF2_EE_LK_EN_A_EV0_RM_EE_HFNSYNC_STATE_ERR,                AIF2_EE_LK_EN_A_EV0_RM_EE_LOF_STATE_ERR,
2997  *         AIF2_EE_LK_EN_A_EV0_TM_EE_FRM_MISALIGN_ERR,                   AIF2_EE_LK_EN_A_EV0_TM_EE_FIFO_STARVE_ERR;
2998  *
2999  *         AIF2_EE_LK_EN_A_EV1_RM_EE_SYNC_STATUS_CHANGE_ERR,      AIF2_EE_LK_EN_A_EV1_RM_EE_NUM_LOS_DET_ERR,
3000  *         AIF2_EE_LK_EN_A_EV1_RM_EE_LCV_DET_ERR,                            AIF2_EE_LK_EN_A_EV1_RM_EE_FRAME_BNDRY_DET_ERR,
3001  *         AIF2_EE_LK_EN_A_EV1_RM_EE_BLOCK_BNDRY_DET_ERR,            AIF2_EE_LK_EN_A_EV1_RM_EE_MISSING_K28P5_ERR,
3002  *         AIF2_EE_LK_EN_A_EV1_RM_EE_MISSING_K28P7_ERR,                 AIF2_EE_LK_EN_A_EV1_RM_EE_K30P7_DET_ERR,
3003  *         AIF2_EE_LK_EN_A_EV1_RM_EE_LOC_DET_ERR,                           AIF2_EE_LK_EN_A_EV1_RM_EE_RX_FIFO_OVF_ERR,
3004  *         AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_LOS_ERR,                         AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_LOF_ERR,
3005  *         AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_RAI_ERR,                         AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_SDI_ERR,
3006  *         AIF2_EE_LK_EN_A_EV1_RM_EE_LOS_ERR,                                   AIF2_EE_LK_EN_A_EV1_RM_EE_LOF_ERR,
3007  *         AIF2_EE_LK_EN_A_EV1_RM_EE_HFNSYNC_STATE_ERR,                AIF2_EE_LK_EN_A_EV1_RM_EE_LOF_STATE_ERR,
3008  *         AIF2_EE_LK_EN_A_EV1_TM_EE_FRM_MISALIGN_ERR,                   AIF2_EE_LK_EN_A_EV1_TM_EE_FIFO_STARVE_ERR;
3009  *
3010  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_SYNC_STATUS_CHANGE_ERR,      AIF2_EE_LK_EN_STS_A_EV0_RM_EE_NUM_LOS_DET_ERR,
3011  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LCV_DET_ERR,                            AIF2_EE_LK_EN_STS_A_EV0_RM_EE_FRAME_BNDRY_DET_ERR,
3012  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_BLOCK_BNDRY_DET_ERR,            AIF2_EE_LK_EN_STS_A_EV0_RM_EE_MISSING_K28P5_ERR,
3013  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_MISSING_K28P7_ERR,                 AIF2_EE_LK_EN_STS_A_EV0_RM_EE_K30P7_DET_ERR,
3014  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOC_DET_ERR,                           AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RX_FIFO_OVF_ERR,
3015  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_LOS_ERR,                         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_LOF_ERR,
3016  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_RAI_ERR,                         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_SDI_ERR,
3017  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOS_ERR,                                   AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOF_ERR,
3018  *         AIF2_EE_LK_EN_STS_A_EV0_RM_EE_HFNSYNC_STATE_ERR,                AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOF_STATE_ERR,
3019  *         AIF2_EE_LK_EN_STS_A_EV0_TM_EE_FRM_MISALIGN_ERR,                   AIF2_EE_LK_EN_STS_A_EV0_TM_EE_FIFO_STARVE_ERR;
3020  *
3021  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_SYNC_STATUS_CHANGE_ERR,      AIF2_EE_LK_EN_STS_A_EV1_RM_EE_NUM_LOS_DET_ERR,
3022  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LCV_DET_ERR,                            AIF2_EE_LK_EN_STS_A_EV1_RM_EE_FRAME_BNDRY_DET_ERR,
3023  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_BLOCK_BNDRY_DET_ERR,            AIF2_EE_LK_EN_STS_A_EV1_RM_EE_MISSING_K28P5_ERR,
3024  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_MISSING_K28P7_ERR,                 AIF2_EE_LK_EN_STS_A_EV1_RM_EE_K30P7_DET_ERR,
3025  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOC_DET_ERR,                           AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RX_FIFO_OVF_ERR,
3026  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_LOS_ERR,                         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_LOF_ERR,
3027  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_RAI_ERR,                         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_SDI_ERR,
3028  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOS_ERR,                                   AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOF_ERR,
3029  *         AIF2_EE_LK_EN_STS_A_EV1_RM_EE_HFNSYNC_STATE_ERR,                AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOF_STATE_ERR,
3030  *         AIF2_EE_LK_EN_STS_A_EV1_TM_EE_FRM_MISALIGN_ERR,                   AIF2_EE_LK_EN_STS_A_EV1_TM_EE_FIFO_STARVE_ERR;
3031  *   @b Example
3032  *   @verbatim
3033         Aif2Fl_EeLinkAInt  LinkAInt;
3034         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
3035         hAif2->arg_link = 0;//link0
3036
3037         Aif2Fl_getEeLinkAIntStatus(hAif2,&LinkAInt);
3038      @endverbatim
3039  * ===========================================================================
3040  */
3041 static inline
3042 void Aif2Fl_getEeLinkAIntStatus (
3043         Aif2Fl_Handle   hAif2,
3044         Aif2Fl_EeLinkAInt*     LinkAInt
3045 )
3046 {
3047         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
3048          LinkAInt->rm_ee_sync_status_change_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_SYNC_STATUS_CHANGE_ERR);
3049          LinkAInt->rm_ee_num_los_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_NUM_LOS_DET_ERR);
3050          LinkAInt->rm_ee_lcv_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_LCV_DET_ERR);
3051          LinkAInt->rm_ee_frame_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_FRAME_BNDRY_DET_ERR);
3052          LinkAInt->rm_ee_block_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_BLOCK_BNDRY_DET_ERR);
3053          LinkAInt->rm_ee_missing_k28p5_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_MISSING_K28P5_ERR);
3054          LinkAInt->rm_ee_missing_k28p7_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_MISSING_K28P7_ERR);
3055          LinkAInt->rm_ee_k30p7_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_K30P7_DET_ERR);
3056          LinkAInt->rm_ee_loc_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_LOC_DET_ERR);
3057          LinkAInt->rm_ee_rx_fifo_ovf_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_RX_FIFO_OVF_ERR);
3058          LinkAInt->rm_ee_rcvd_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_RCVD_LOS_ERR);
3059          LinkAInt->rm_ee_rcvd_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_RCVD_LOF_ERR);
3060          LinkAInt->rm_ee_rcvd_rai_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_RCVD_RAI_ERR);
3061          LinkAInt->rm_ee_rcvd_sdi_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_RCVD_SDI_ERR);
3062          LinkAInt->rm_ee_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_LOS_ERR);
3063          LinkAInt->rm_ee_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_LOF_ERR);
3064          LinkAInt->rm_ee_hfnsync_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_HFNSYNC_STATE_ERR);
3065          LinkAInt->rm_ee_lof_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_RM_EE_LOF_STATE_ERR);
3066          LinkAInt->tm_ee_frm_misalign_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_TM_EE_FRM_MISALIGN_ERR);
3067          LinkAInt->tm_ee_fifo_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_A, AIF2_EE_LK_IRS_A_TM_EE_FIFO_STARVE_ERR);
3068         }
3069          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
3070          LinkAInt->rm_ee_sync_status_change_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_SYNC_STATUS_CHANGE_ERR);
3071          LinkAInt->rm_ee_num_los_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_NUM_LOS_DET_ERR);
3072          LinkAInt->rm_ee_lcv_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_LCV_DET_ERR);
3073          LinkAInt->rm_ee_frame_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_FRAME_BNDRY_DET_ERR);
3074          LinkAInt->rm_ee_block_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_BLOCK_BNDRY_DET_ERR);
3075          LinkAInt->rm_ee_missing_k28p5_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_MISSING_K28P5_ERR);
3076          LinkAInt->rm_ee_missing_k28p7_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_MISSING_K28P7_ERR);
3077          LinkAInt->rm_ee_k30p7_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_K30P7_DET_ERR);
3078          LinkAInt->rm_ee_loc_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_LOC_DET_ERR);
3079          LinkAInt->rm_ee_rx_fifo_ovf_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_RX_FIFO_OVF_ERR);
3080          LinkAInt->rm_ee_rcvd_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_LOS_ERR);
3081          LinkAInt->rm_ee_rcvd_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_LOF_ERR);
3082          LinkAInt->rm_ee_rcvd_rai_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_RAI_ERR);
3083          LinkAInt->rm_ee_rcvd_sdi_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_RCVD_SDI_ERR);
3084          LinkAInt->rm_ee_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_LOS_ERR);
3085          LinkAInt->rm_ee_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_LOF_ERR);
3086          LinkAInt->rm_ee_hfnsync_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_HFNSYNC_STATE_ERR);
3087          LinkAInt->rm_ee_lof_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_RM_EE_LOF_STATE_ERR);
3088          LinkAInt->tm_ee_frm_misalign_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_TM_EE_FRM_MISALIGN_ERR);
3089          LinkAInt->tm_ee_fifo_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV0, AIF2_EE_LK_EN_A_EV0_TM_EE_FIFO_STARVE_ERR);
3090         }
3091          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
3092          LinkAInt->rm_ee_sync_status_change_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_SYNC_STATUS_CHANGE_ERR);
3093          LinkAInt->rm_ee_num_los_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_NUM_LOS_DET_ERR);
3094          LinkAInt->rm_ee_lcv_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_LCV_DET_ERR);
3095          LinkAInt->rm_ee_frame_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_FRAME_BNDRY_DET_ERR);
3096          LinkAInt->rm_ee_block_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_BLOCK_BNDRY_DET_ERR);
3097          LinkAInt->rm_ee_missing_k28p5_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_MISSING_K28P5_ERR);
3098          LinkAInt->rm_ee_missing_k28p7_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_MISSING_K28P7_ERR);
3099          LinkAInt->rm_ee_k30p7_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_K30P7_DET_ERR);
3100          LinkAInt->rm_ee_loc_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_LOC_DET_ERR);
3101          LinkAInt->rm_ee_rx_fifo_ovf_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_RX_FIFO_OVF_ERR);
3102          LinkAInt->rm_ee_rcvd_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_LOS_ERR);
3103          LinkAInt->rm_ee_rcvd_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_LOF_ERR);
3104          LinkAInt->rm_ee_rcvd_rai_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_RAI_ERR);
3105          LinkAInt->rm_ee_rcvd_sdi_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_RCVD_SDI_ERR);
3106          LinkAInt->rm_ee_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_LOS_ERR);
3107          LinkAInt->rm_ee_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_LOF_ERR);
3108          LinkAInt->rm_ee_hfnsync_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_HFNSYNC_STATE_ERR);
3109          LinkAInt->rm_ee_lof_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_RM_EE_LOF_STATE_ERR);
3110          LinkAInt->tm_ee_frm_misalign_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_TM_EE_FRM_MISALIGN_ERR);
3111          LinkAInt->tm_ee_fifo_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_A_EV1, AIF2_EE_LK_EN_A_EV1_TM_EE_FIFO_STARVE_ERR);
3112         }
3113          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
3114          LinkAInt->rm_ee_sync_status_change_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_SYNC_STATUS_CHANGE_ERR);
3115          LinkAInt->rm_ee_num_los_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_NUM_LOS_DET_ERR);
3116          LinkAInt->rm_ee_lcv_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LCV_DET_ERR);
3117          LinkAInt->rm_ee_frame_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_FRAME_BNDRY_DET_ERR);
3118          LinkAInt->rm_ee_block_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_BLOCK_BNDRY_DET_ERR);
3119          LinkAInt->rm_ee_missing_k28p5_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_MISSING_K28P5_ERR);
3120          LinkAInt->rm_ee_missing_k28p7_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_MISSING_K28P7_ERR);
3121          LinkAInt->rm_ee_k30p7_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_K30P7_DET_ERR);
3122          LinkAInt->rm_ee_loc_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOC_DET_ERR);
3123          LinkAInt->rm_ee_rx_fifo_ovf_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RX_FIFO_OVF_ERR);
3124          LinkAInt->rm_ee_rcvd_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_LOS_ERR);
3125          LinkAInt->rm_ee_rcvd_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_LOF_ERR);
3126          LinkAInt->rm_ee_rcvd_rai_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_RAI_ERR);
3127          LinkAInt->rm_ee_rcvd_sdi_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_RCVD_SDI_ERR);
3128          LinkAInt->rm_ee_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOS_ERR);
3129          LinkAInt->rm_ee_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOF_ERR);
3130          LinkAInt->rm_ee_hfnsync_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_HFNSYNC_STATE_ERR);
3131          LinkAInt->rm_ee_lof_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_RM_EE_LOF_STATE_ERR);
3132          LinkAInt->tm_ee_frm_misalign_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_TM_EE_FRM_MISALIGN_ERR);
3133          LinkAInt->tm_ee_fifo_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV0, AIF2_EE_LK_EN_STS_A_EV0_TM_EE_FIFO_STARVE_ERR);
3134         }
3135          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
3136          LinkAInt->rm_ee_sync_status_change_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_SYNC_STATUS_CHANGE_ERR);
3137          LinkAInt->rm_ee_num_los_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_NUM_LOS_DET_ERR);
3138          LinkAInt->rm_ee_lcv_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LCV_DET_ERR);
3139          LinkAInt->rm_ee_frame_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_FRAME_BNDRY_DET_ERR);
3140          LinkAInt->rm_ee_block_bndry_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_BLOCK_BNDRY_DET_ERR);
3141          LinkAInt->rm_ee_missing_k28p5_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_MISSING_K28P5_ERR);
3142          LinkAInt->rm_ee_missing_k28p7_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_MISSING_K28P7_ERR);
3143          LinkAInt->rm_ee_k30p7_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_K30P7_DET_ERR);
3144          LinkAInt->rm_ee_loc_det_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOC_DET_ERR);
3145          LinkAInt->rm_ee_rx_fifo_ovf_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RX_FIFO_OVF_ERR);
3146          LinkAInt->rm_ee_rcvd_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_LOS_ERR);
3147          LinkAInt->rm_ee_rcvd_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_LOF_ERR);
3148          LinkAInt->rm_ee_rcvd_rai_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_RAI_ERR);
3149          LinkAInt->rm_ee_rcvd_sdi_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_RCVD_SDI_ERR);
3150          LinkAInt->rm_ee_los_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOS_ERR);
3151          LinkAInt->rm_ee_lof_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOF_ERR);
3152          LinkAInt->rm_ee_hfnsync_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_HFNSYNC_STATE_ERR);
3153          LinkAInt->rm_ee_lof_state_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_RM_EE_LOF_STATE_ERR);
3154          LinkAInt->tm_ee_frm_misalign_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_TM_EE_FRM_MISALIGN_ERR);
3155          LinkAInt->tm_ee_fifo_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_A_EV1, AIF2_EE_LK_EN_STS_A_EV1_TM_EE_FIFO_STARVE_ERR);
3156         }
3157
3158 }
3159
3160
3161 /** ============================================================================
3162  *   @n@b Aif2Fl_getEeLinkBIntStatus
3163  *
3164  *   @b Description
3165  *   @n Get Aif2 EE Link B interrupt  status value
3166  *
3167  *   @b Arguments
3168  *   @verbatim
3169            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function and hAif2->arg_link to select link
3170            Aif2Fl_EeLinkBInt
3171       @endverbatim
3172  *
3173  *   <b> Return Value </b>  void
3174  *   <b> Pre Condition </b>
3175  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
3176  *   in that order before calling this function.
3177  *
3178  *   <b> Post Condition </b>
3179  *   @n None
3180  *
3181  *   @b Reads
3182  *   @n  AIF2_EE_LK_IRS_B_PD_EE_EOP_ERR,                           AIF2_EE_LK_IRS_B_PD_EE_CRC_ERR,
3183  *         AIF2_EE_LK_IRS_B_PD_EE_CPRI_FRAME_ERR,              AIF2_EE_LK_IRS_B_PD_EE_AXC_FAIL_ERR,
3184  *         AIF2_EE_LK_IRS_B_PD_EE_SOP_ERR,                           AIF2_EE_LK_IRS_B_PD_EE_OBSAI_FRM_ERR,
3185  *         AIF2_EE_LK_IRS_B_PD_EE_WR2DB_ERR,                      AIF2_EE_LK_IRS_B_PE_EE_MODRULE_ERR,
3186  *         AIF2_EE_LK_IRS_B_PE_EE_SYM_ERR,                           AIF2_EE_LK_IRS_B_PE_EE_MF_FIFO_OVERFLOW_ERR,
3187  *         AIF2_EE_LK_IRS_B_PE_EE_MF_FIFO_UNDERFLOW_ERR, AIF2_EE_LK_IRS_B_PE_EE_DB_STARVE_ERR,
3188  *         AIF2_EE_LK_IRS_B_PE_EE_RT_IF_ERR,                         AIF2_EE_LK_IRS_B_PE_EE_PKT_STARVE_ERR,
3189  *         AIF2_EE_LK_IRS_B_RT_EE_FRM_ERR,                           AIF2_EE_LK_IRS_B_RT_EE_OVFL_ERR,
3190  *         AIF2_EE_LK_IRS_B_RT_EE_UNFL_ERR,                          AIF2_EE_LK_IRS_B_RT_EE_EM_ERR,
3191  *         AIF2_EE_LK_IRS_B_RT_EE_HDR_ERR;
3192  *
3193  *         AIF2_EE_LK_EN_B_EV0_PD_EE_EOP_ERR,                          AIF2_EE_LK_EN_B_EV0_PD_EE_CRC_ERR,
3194  *         AIF2_EE_LK_EN_B_EV0_PD_EE_CPRI_FRAME_ERR,             AIF2_EE_LK_EN_B_EV0_PD_EE_AXC_FAIL_ERR,
3195  *         AIF2_EE_LK_EN_B_EV0_PD_EE_SOP_ERR,                          AIF2_EE_LK_EN_B_EV0_PD_EE_OBSAI_FRM_ERR,
3196  *         AIF2_EE_LK_EN_B_EV0_PD_EE_WR2DB_ERR,                     AIF2_EE_LK_EN_B_EV0_PE_EE_MODRULE_ERR,
3197  *         AIF2_EE_LK_EN_B_EV0_PE_EE_SYM_ERR,                           AIF2_EE_LK_EN_B_EV0_PE_EE_MF_FIFO_OVERFLOW_ERR,
3198  *         AIF2_EE_LK_EN_B_EV0_PE_EE_MF_FIFO_UNDERFLOW_ERR, AIF2_EE_LK_EN_B_EV0_PE_EE_DB_STARVE_ERR,
3199  *         AIF2_EE_LK_EN_B_EV0_PE_EE_RT_IF_ERR,                         AIF2_EE_LK_EN_B_EV0_PE_EE_PKT_STARVE_ERR,
3200  *         AIF2_EE_LK_EN_B_EV0_RT_EE_FRM_ERR,                           AIF2_EE_LK_EN_B_EV0_RT_EE_OVFL_ERR,
3201  *         AIF2_EE_LK_EN_B_EV0_RT_EE_UNFL_ERR,                          AIF2_EE_LK_EN_B_EV0_RT_EE_EM_ERR,
3202  *         AIF2_EE_LK_EN_B_EV0_RT_EE_HDR_ERR;
3203  *
3204  *         AIF2_EE_LK_EN_B_EV1_PD_EE_EOP_ERR,                           AIF2_EE_LK_EN_B_EV1_PD_EE_CRC_ERR,
3205  *         AIF2_EE_LK_EN_B_EV1_PD_EE_CPRI_FRAME_ERR,              AIF2_EE_LK_EN_B_EV1_PD_EE_AXC_FAIL_ERR,
3206  *         AIF2_EE_LK_EN_B_EV1_PD_EE_SOP_ERR,                           AIF2_EE_LK_EN_B_EV1_PD_EE_OBSAI_FRM_ERR,
3207  *         AIF2_EE_LK_EN_B_EV1_PD_EE_WR2DB_ERR,                      AIF2_EE_LK_EN_B_EV1_PE_EE_MODRULE_ERR,
3208  *         AIF2_EE_LK_EN_B_EV1_PE_EE_SYM_ERR,                           AIF2_EE_LK_EN_B_EV1_PE_EE_MF_FIFO_OVERFLOW_ERR,
3209  *         AIF2_EE_LK_EN_B_EV1_PE_EE_MF_FIFO_UNDERFLOW_ERR, AIF2_EE_LK_EN_B_EV1_PE_EE_DB_STARVE_ERR,
3210  *         AIF2_EE_LK_EN_B_EV1_PE_EE_RT_IF_ERR,                         AIF2_EE_LK_EN_B_EV1_PE_EE_PKT_STARVE_ERR,
3211  *         AIF2_EE_LK_EN_B_EV1_RT_EE_FRM_ERR,                           AIF2_EE_LK_EN_B_EV1_RT_EE_OVFL_ERR,
3212  *         AIF2_EE_LK_EN_B_EV1_RT_EE_UNFL_ERR,                          AIF2_EE_LK_EN_B_EV1_RT_EE_EM_ERR,
3213  *         AIF2_EE_LK_EN_B_EV1_RT_EE_HDR_ERR;
3214  *
3215  *         AIF2_EE_LK_EN_STS_B_EV0_PD_EE_EOP_ERR,                           AIF2_EE_LK_EN_STS_B_EV0_PD_EE_CRC_ERR,
3216  *         AIF2_EE_LK_EN_STS_B_EV0_PD_EE_CPRI_FRAME_ERR,              AIF2_EE_LK_EN_STS_B_EV0_PD_EE_AXC_FAIL_ERR,
3217  *         AIF2_EE_LK_EN_STS_B_EV0_PD_EE_SOP_ERR,                           AIF2_EE_LK_EN_STS_B_EV0_PD_EE_OBSAI_FRM_ERR,
3218  *         AIF2_EE_LK_EN_STS_B_EV0_PD_EE_WR2DB_ERR,                      AIF2_EE_LK_EN_STS_B_EV0_PE_EE_MODRULE_ERR,
3219  *         AIF2_EE_LK_EN_STS_B_EV0_PE_EE_SYM_ERR,                           AIF2_EE_LK_EN_STS_B_EV0_PE_EE_MF_FIFO_OVERFLOW_ERR,
3220  *         AIF2_EE_LK_EN_STS_B_EV0_PE_EE_MF_FIFO_UNDERFLOW_ERR, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_DB_STARVE_ERR,
3221  *         AIF2_EE_LK_EN_STS_B_EV0_PE_EE_RT_IF_ERR,                         AIF2_EE_LK_EN_STS_B_EV0_PE_EE_PKT_STARVE_ERR,
3222  *         AIF2_EE_LK_EN_STS_B_EV0_RT_EE_FRM_ERR,                           AIF2_EE_LK_EN_STS_B_EV0_RT_EE_OVFL_ERR,
3223  *         AIF2_EE_LK_EN_STS_B_EV0_RT_EE_UNFL_ERR,                          AIF2_EE_LK_EN_STS_B_EV0_RT_EE_EM_ERR,
3224  *         AIF2_EE_LK_EN_STS_B_EV0_RT_EE_HDR_ERR;
3225  *
3226  *         AIF2_EE_LK_EN_STS_B_EV1_PD_EE_EOP_ERR,                           AIF2_EE_LK_EN_STS_B_EV1_PD_EE_CRC_ERR,
3227  *         AIF2_EE_LK_EN_STS_B_EV1_PD_EE_CPRI_FRAME_ERR,              AIF2_EE_LK_EN_STS_B_EV1_PD_EE_AXC_FAIL_ERR,
3228  *         AIF2_EE_LK_EN_STS_B_EV1_PD_EE_SOP_ERR,                           AIF2_EE_LK_EN_STS_B_EV1_PD_EE_OBSAI_FRM_ERR,
3229  *         AIF2_EE_LK_EN_STS_B_EV1_PD_EE_WR2DB_ERR,                      AIF2_EE_LK_EN_STS_B_EV1_PE_EE_MODRULE_ERR,
3230  *         AIF2_EE_LK_EN_STS_B_EV1_PE_EE_SYM_ERR,                           AIF2_EE_LK_EN_STS_B_EV1_PE_EE_MF_FIFO_OVERFLOW_ERR,
3231  *         AIF2_EE_LK_EN_STS_B_EV1_PE_EE_MF_FIFO_UNDERFLOW_ERR, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_DB_STARVE_ERR,
3232  *         AIF2_EE_LK_EN_STS_B_EV1_PE_EE_RT_IF_ERR,                         AIF2_EE_LK_EN_STS_B_EV1_PE_EE_PKT_STARVE_ERR,
3233  *         AIF2_EE_LK_EN_STS_B_EV1_RT_EE_FRM_ERR,                           AIF2_EE_LK_EN_STS_B_EV1_RT_EE_OVFL_ERR,
3234  *         AIF2_EE_LK_EN_STS_B_EV1_RT_EE_UNFL_ERR,                          AIF2_EE_LK_EN_STS_B_EV1_RT_EE_EM_ERR,
3235  *         AIF2_EE_LK_EN_STS_B_EV1_RT_EE_HDR_ERR;
3236  *   @b Example
3237  *   @verbatim
3238         Aif2Fl_EeLinkBInt  LinkBInt;
3239         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
3240         hAif2->arg_link = 0;//link0
3241
3242         Aif2Fl_getEeLinkBIntStatus(hAif2,&LinkBInt);
3243      @endverbatim
3244  * ===========================================================================
3245  */
3246 static inline
3247 void Aif2Fl_getEeLinkBIntStatus (
3248         Aif2Fl_Handle   hAif2,
3249         Aif2Fl_EeLinkBInt*     LinkBInt
3250 )
3251 {
3252         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
3253          LinkBInt->pd_ee_eop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PD_EE_EOP_ERR);
3254          LinkBInt->pd_ee_crc_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PD_EE_CRC_ERR);
3255          LinkBInt->pd_ee_cpri_frame_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PD_EE_CPRI_FRAME_ERR);
3256          LinkBInt->pd_ee_axc_fail_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PD_EE_AXC_FAIL_ERR);
3257          LinkBInt->pd_ee_sop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PD_EE_SOP_ERR);
3258          LinkBInt->pd_ee_obsai_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PD_EE_OBSAI_FRM_ERR);
3259          LinkBInt->pd_ee_wr2db_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PD_EE_WR2DB_ERR);
3260          LinkBInt->pe_ee_modrule_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PE_EE_MODRULE_ERR);
3261          LinkBInt->pe_ee_sym_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PE_EE_SYM_ERR);
3262          LinkBInt->pe_ee_mf_fifo_overflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PE_EE_MF_FIFO_OVERFLOW_ERR);
3263          LinkBInt->pe_ee_mf_fifo_underflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PE_EE_MF_FIFO_UNDERFLOW_ERR);
3264          LinkBInt->pe_ee_db_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PE_EE_DB_STARVE_ERR);
3265          LinkBInt->pe_ee_rt_if_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PE_EE_RT_IF_ERR);
3266          LinkBInt->pe_ee_pkt_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_PE_EE_PKT_STARVE_ERR);
3267          LinkBInt->rt_ee_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_RT_EE_FRM_ERR);
3268          LinkBInt->rt_ee_ovfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_RT_EE_OVFL_ERR);
3269          LinkBInt->rt_ee_unfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_RT_EE_UNFL_ERR);
3270          LinkBInt->rt_ee_em_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_RT_EE_EM_ERR);
3271          LinkBInt->rt_ee_hdr_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_IRS_B, AIF2_EE_LK_IRS_B_RT_EE_HDR_ERR);
3272         }
3273          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
3274          LinkBInt->pd_ee_eop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PD_EE_EOP_ERR);
3275          LinkBInt->pd_ee_crc_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PD_EE_CRC_ERR);
3276          LinkBInt->pd_ee_cpri_frame_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PD_EE_CPRI_FRAME_ERR);
3277          LinkBInt->pd_ee_axc_fail_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PD_EE_AXC_FAIL_ERR);
3278          LinkBInt->pd_ee_sop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PD_EE_SOP_ERR);
3279          LinkBInt->pd_ee_obsai_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PD_EE_OBSAI_FRM_ERR);
3280          LinkBInt->pd_ee_wr2db_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PD_EE_WR2DB_ERR);
3281          LinkBInt->pe_ee_modrule_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PE_EE_MODRULE_ERR);
3282          LinkBInt->pe_ee_sym_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PE_EE_SYM_ERR);
3283          LinkBInt->pe_ee_mf_fifo_overflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PE_EE_MF_FIFO_OVERFLOW_ERR);
3284          LinkBInt->pe_ee_mf_fifo_underflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PE_EE_MF_FIFO_UNDERFLOW_ERR);
3285          LinkBInt->pe_ee_db_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PE_EE_DB_STARVE_ERR);
3286          LinkBInt->pe_ee_rt_if_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PE_EE_RT_IF_ERR);
3287          LinkBInt->pe_ee_pkt_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_PE_EE_PKT_STARVE_ERR);
3288          LinkBInt->rt_ee_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_RT_EE_FRM_ERR);
3289          LinkBInt->rt_ee_ovfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_RT_EE_OVFL_ERR);
3290          LinkBInt->rt_ee_unfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_RT_EE_UNFL_ERR);
3291          LinkBInt->rt_ee_em_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_RT_EE_EM_ERR);
3292          LinkBInt->rt_ee_hdr_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV0, AIF2_EE_LK_EN_B_EV0_RT_EE_HDR_ERR);
3293         }
3294          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
3295          LinkBInt->pd_ee_eop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PD_EE_EOP_ERR);
3296          LinkBInt->pd_ee_crc_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PD_EE_CRC_ERR);
3297          LinkBInt->pd_ee_cpri_frame_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PD_EE_CPRI_FRAME_ERR);
3298          LinkBInt->pd_ee_axc_fail_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PD_EE_AXC_FAIL_ERR);
3299          LinkBInt->pd_ee_sop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PD_EE_SOP_ERR);
3300          LinkBInt->pd_ee_obsai_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PD_EE_OBSAI_FRM_ERR);
3301          LinkBInt->pd_ee_wr2db_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PD_EE_WR2DB_ERR);
3302          LinkBInt->pe_ee_modrule_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PE_EE_MODRULE_ERR);
3303          LinkBInt->pe_ee_sym_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PE_EE_SYM_ERR);
3304          LinkBInt->pe_ee_mf_fifo_overflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PE_EE_MF_FIFO_OVERFLOW_ERR);
3305          LinkBInt->pe_ee_mf_fifo_underflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PE_EE_MF_FIFO_UNDERFLOW_ERR);
3306          LinkBInt->pe_ee_db_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PE_EE_DB_STARVE_ERR);
3307          LinkBInt->pe_ee_rt_if_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PE_EE_RT_IF_ERR);
3308          LinkBInt->pe_ee_pkt_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_PE_EE_PKT_STARVE_ERR);
3309          LinkBInt->rt_ee_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_RT_EE_FRM_ERR);
3310          LinkBInt->rt_ee_ovfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_RT_EE_OVFL_ERR);
3311          LinkBInt->rt_ee_unfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_RT_EE_UNFL_ERR);
3312          LinkBInt->rt_ee_em_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_RT_EE_EM_ERR);
3313          LinkBInt->rt_ee_hdr_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_B_EV1, AIF2_EE_LK_EN_B_EV1_RT_EE_HDR_ERR);
3314         }
3315          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
3316          LinkBInt->pd_ee_eop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PD_EE_EOP_ERR);
3317          LinkBInt->pd_ee_crc_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PD_EE_CRC_ERR);
3318          LinkBInt->pd_ee_cpri_frame_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PD_EE_CPRI_FRAME_ERR);
3319          LinkBInt->pd_ee_axc_fail_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PD_EE_AXC_FAIL_ERR);
3320          LinkBInt->pd_ee_sop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PD_EE_SOP_ERR);
3321          LinkBInt->pd_ee_obsai_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PD_EE_OBSAI_FRM_ERR);
3322          LinkBInt->pd_ee_wr2db_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PD_EE_WR2DB_ERR);
3323          LinkBInt->pe_ee_modrule_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_MODRULE_ERR);
3324          LinkBInt->pe_ee_sym_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_SYM_ERR);
3325          LinkBInt->pe_ee_mf_fifo_overflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_MF_FIFO_OVERFLOW_ERR);
3326          LinkBInt->pe_ee_mf_fifo_underflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_MF_FIFO_UNDERFLOW_ERR);
3327          LinkBInt->pe_ee_db_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_DB_STARVE_ERR);
3328          LinkBInt->pe_ee_rt_if_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_RT_IF_ERR);
3329          LinkBInt->pe_ee_pkt_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_PE_EE_PKT_STARVE_ERR);
3330          LinkBInt->rt_ee_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_RT_EE_FRM_ERR);
3331          LinkBInt->rt_ee_ovfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_RT_EE_OVFL_ERR);
3332          LinkBInt->rt_ee_unfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_RT_EE_UNFL_ERR);
3333          LinkBInt->rt_ee_em_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_RT_EE_EM_ERR);
3334          LinkBInt->rt_ee_hdr_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV0, AIF2_EE_LK_EN_STS_B_EV0_RT_EE_HDR_ERR);
3335         }
3336          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
3337          LinkBInt->pd_ee_eop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PD_EE_EOP_ERR);
3338          LinkBInt->pd_ee_crc_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PD_EE_CRC_ERR);
3339          LinkBInt->pd_ee_cpri_frame_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PD_EE_CPRI_FRAME_ERR);
3340          LinkBInt->pd_ee_axc_fail_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PD_EE_AXC_FAIL_ERR);
3341          LinkBInt->pd_ee_sop_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PD_EE_SOP_ERR);
3342          LinkBInt->pd_ee_obsai_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PD_EE_OBSAI_FRM_ERR);
3343          LinkBInt->pd_ee_wr2db_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PD_EE_WR2DB_ERR);
3344          LinkBInt->pe_ee_modrule_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_MODRULE_ERR);
3345          LinkBInt->pe_ee_sym_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_SYM_ERR);
3346          LinkBInt->pe_ee_mf_fifo_overflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_MF_FIFO_OVERFLOW_ERR);
3347          LinkBInt->pe_ee_mf_fifo_underflow_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_MF_FIFO_UNDERFLOW_ERR);
3348          LinkBInt->pe_ee_db_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_DB_STARVE_ERR);
3349          LinkBInt->pe_ee_rt_if_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_RT_IF_ERR);
3350          LinkBInt->pe_ee_pkt_starve_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_PE_EE_PKT_STARVE_ERR);
3351          LinkBInt->rt_ee_frm_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_RT_EE_FRM_ERR);
3352          LinkBInt->rt_ee_ovfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_RT_EE_OVFL_ERR);
3353          LinkBInt->rt_ee_unfl_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_RT_EE_UNFL_ERR);
3354          LinkBInt->rt_ee_em_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_RT_EE_EM_ERR);
3355          LinkBInt->rt_ee_hdr_err=  CSL_FEXT(hAif2->regs->EE_LK[hAif2->arg_link].EE_LK_EN_STS_B_EV1, AIF2_EE_LK_EN_STS_B_EV1_RT_EE_HDR_ERR);
3356         }
3357
3358 }
3359
3360
3361 /** ============================================================================
3362  *   @n@b Aif2Fl_getEeAtIntStatus
3363  *
3364  *   @b Description
3365  *   @n Get Aif2 EE AT interrupt  status value
3366  *
3367  *   @b Arguments
3368  *   @verbatim
3369            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
3370            Aif2Fl_EeAtInt
3371       @endverbatim
3372  *
3373  *   <b> Return Value </b>  void
3374  *   <b> Pre Condition </b>
3375  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
3376  *   in that order before calling this function.
3377  *
3378  *   <b> Post Condition </b>
3379  *   @n None
3380  *
3381  *   @b Reads
3382  *   @n  AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_SYS_RCVD_ERR,       AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_RP3_RCVD_ERR,
3383  *         AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_TOD_RCVD_ERR,       AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_UNSEL_ERR,
3384  *         AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_SPARE_ERR,              AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_RSVD_ERR,
3385  *         AIF2_EE_AT_IRS_AT_EE_RP1_BIT_WIDTH_ERR,                AIF2_EE_AT_IRS_AT_EE_RP1_CRC_ERR,
3386  *         AIF2_EE_AT_IRS_AT_EE_RP1_RP3_ERR,                           AIF2_EE_AT_IRS_AT_EE_RP1_SYS_ERR,
3387  *         AIF2_EE_AT_IRS_AT_EE_PI0_ERR,AIF2_EE_AT_IRS_AT_EE_PI1_ERR,AIF2_EE_AT_IRS_AT_EE_PI2_ERR,
3388  *         AIF2_EE_AT_IRS_AT_EE_PI3_ERR,AIF2_EE_AT_IRS_AT_EE_PI4_ERR,AIF2_EE_AT_IRS_AT_EE_PI5_ERR,
3389  *         AIF2_EE_AT_IRS_AT_EE_PHYT_SYNC_ERR,                      AIF2_EE_AT_IRS_AT_EE_RADT_SYNC_ERR;
3390  *
3391  *         AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_SYS_RCVD_ERR,       AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_RP3_RCVD_ERR,
3392  *         AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_TOD_RCVD_ERR,       AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_UNSEL_ERR,
3393  *         AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_SPARE_ERR,              AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_RSVD_ERR,
3394  *         AIF2_EE_AT_EN_EV0_AT_EE_RP1_BIT_WIDTH_ERR,                AIF2_EE_AT_EN_EV0_AT_EE_RP1_CRC_ERR,
3395  *         AIF2_EE_AT_EN_EV0_AT_EE_RP1_RP3_ERR,                           AIF2_EE_AT_EN_EV0_AT_EE_RP1_SYS_ERR,
3396  *         AIF2_EE_AT_EN_EV0_AT_EE_PI0_ERR,AIF2_EE_AT_EN_EV0_AT_EE_PI1_ERR,AIF2_EE_AT_EN_EV0_AT_EE_PI2_ERR,
3397  *         AIF2_EE_AT_EN_EV0_AT_EE_PI3_ERR,AIF2_EE_AT_EN_EV0_AT_EE_PI4_ERR,AIF2_EE_AT_EN_EV0_AT_EE_PI5_ERR,
3398  *         AIF2_EE_AT_EN_EV0_AT_EE_PHYT_SYNC_ERR,                      AIF2_EE_AT_EN_EV0_AT_EE_RADT_SYNC_ERR;
3399  *
3400  *         AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_SYS_RCVD_ERR,       AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_RP3_RCVD_ERR,
3401  *         AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_TOD_RCVD_ERR,       AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_UNSEL_ERR,
3402  *         AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_SPARE_ERR,              AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_RSVD_ERR,
3403  *         AIF2_EE_AT_EN_EV1_AT_EE_RP1_BIT_WIDTH_ERR,                AIF2_EE_AT_EN_EV1_AT_EE_RP1_CRC_ERR,
3404  *         AIF2_EE_AT_EN_EV1_AT_EE_RP1_RP3_ERR,                           AIF2_EE_AT_EN_EV1_AT_EE_RP1_SYS_ERR,
3405  *         AIF2_EE_AT_EN_EV1_AT_EE_PI0_ERR,AIF2_EE_AT_EN_EV1_AT_EE_PI1_ERR,AIF2_EE_AT_EN_EV1_AT_EE_PI2_ERR,
3406  *         AIF2_EE_AT_EN_EV1_AT_EE_PI3_ERR,AIF2_EE_AT_EN_EV1_AT_EE_PI4_ERR,AIF2_EE_AT_EN_EV1_AT_EE_PI5_ERR,
3407  *         AIF2_EE_AT_EN_EV1_AT_EE_PHYT_SYNC_ERR,                      AIF2_EE_AT_EN_EV1_AT_EE_RADT_SYNC_ERR;
3408  *
3409  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_SYS_RCVD_ERR,       AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_RP3_RCVD_ERR,
3410  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_TOD_RCVD_ERR,       AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_UNSEL_ERR,
3411  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_SPARE_ERR,              AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_RSVD_ERR,
3412  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_BIT_WIDTH_ERR,                AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_CRC_ERR,
3413  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_RP3_ERR,                           AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_SYS_ERR,
3414  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_PI0_ERR,AIF2_EE_AT_EN_STS_EV0_AT_EE_PI1_ERR,AIF2_EE_AT_EN_STS_EV0_AT_EE_PI2_ERR,
3415  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_PI3_ERR,AIF2_EE_AT_EN_STS_EV0_AT_EE_PI4_ERR,AIF2_EE_AT_EN_STS_EV0_AT_EE_PI5_ERR,
3416  *         AIF2_EE_AT_EN_STS_EV0_AT_EE_PHYT_SYNC_ERR,                      AIF2_EE_AT_EN_STS_EV0_AT_EE_RADT_SYNC_ERR;
3417  *
3418  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_SYS_RCVD_ERR,       AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_RP3_RCVD_ERR,
3419  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_TOD_RCVD_ERR,       AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_UNSEL_ERR,
3420  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_SPARE_ERR,              AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_RSVD_ERR,
3421  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_BIT_WIDTH_ERR,                AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_CRC_ERR,
3422  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_RP3_ERR,                           AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_SYS_ERR,
3423  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_PI0_ERR,AIF2_EE_AT_EN_STS_EV1_AT_EE_PI1_ERR,AIF2_EE_AT_EN_STS_EV1_AT_EE_PI2_ERR,
3424  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_PI3_ERR,AIF2_EE_AT_EN_STS_EV1_AT_EE_PI4_ERR,AIF2_EE_AT_EN_STS_EV1_AT_EE_PI5_ERR,
3425  *         AIF2_EE_AT_EN_STS_EV1_AT_EE_PHYT_SYNC_ERR,                      AIF2_EE_AT_EN_STS_EV1_AT_EE_RADT_SYNC_ERR;
3426  *   @b Example
3427  *   @verbatim
3428         Aif2Fl_EeAtInt  AtInt;
3429         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
3430
3431         Aif2Fl_getEeAtIntStatus(hAif2,&AtInt);
3432      @endverbatim
3433  * ===========================================================================
3434  */
3435 static inline
3436 void Aif2Fl_getEeAtIntStatus (
3437         Aif2Fl_Handle   hAif2,
3438         Aif2Fl_EeAtInt*     AtInt
3439 )
3440 {
3441         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
3442          AtInt->at_ee_rp1_type_sys_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_SYS_RCVD_ERR);
3443          AtInt->at_ee_rp1_type_rp3_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_RP3_RCVD_ERR);
3444          AtInt->at_ee_rp1_type_tod_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_TOD_RCVD_ERR);
3445          AtInt->at_ee_rp1_type_unsel_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_UNSEL_ERR);
3446          AtInt->at_ee_rp1_type_spare_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_SPARE_ERR);
3447          AtInt->at_ee_rp1_type_rsvd_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_TYPE_RSVD_ERR);
3448          AtInt->at_ee_rp1_bit_width_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_BIT_WIDTH_ERR);
3449          AtInt->at_ee_rp1_crc_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_CRC_ERR);
3450          AtInt->at_ee_rp1_rp3_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_RP3_ERR);
3451          AtInt->at_ee_rp1_sys_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RP1_SYS_ERR);
3452          AtInt->at_ee_pi0_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_PI0_ERR);
3453          AtInt->at_ee_pi1_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_PI1_ERR);
3454          AtInt->at_ee_pi2_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_PI2_ERR);
3455          AtInt->at_ee_pi3_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_PI3_ERR);
3456          AtInt->at_ee_pi4_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_PI4_ERR);
3457          AtInt->at_ee_pi5_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_PI5_ERR);
3458          AtInt->at_ee_phyt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_PHYT_SYNC_ERR);
3459          AtInt->at_ee_radt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_IRS, AIF2_EE_AT_IRS_AT_EE_RADT_SYNC_ERR);
3460         }
3461          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
3462          AtInt->at_ee_rp1_type_sys_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_SYS_RCVD_ERR);
3463          AtInt->at_ee_rp1_type_rp3_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_RP3_RCVD_ERR);
3464          AtInt->at_ee_rp1_type_tod_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_TOD_RCVD_ERR);
3465          AtInt->at_ee_rp1_type_unsel_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_UNSEL_ERR);
3466          AtInt->at_ee_rp1_type_spare_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_SPARE_ERR);
3467          AtInt->at_ee_rp1_type_rsvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_TYPE_RSVD_ERR);
3468          AtInt->at_ee_rp1_bit_width_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_BIT_WIDTH_ERR);
3469          AtInt->at_ee_rp1_crc_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_CRC_ERR);
3470          AtInt->at_ee_rp1_rp3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_RP3_ERR);
3471          AtInt->at_ee_rp1_sys_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RP1_SYS_ERR);
3472          AtInt->at_ee_pi0_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_PI0_ERR);
3473          AtInt->at_ee_pi1_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_PI1_ERR);
3474          AtInt->at_ee_pi2_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_PI2_ERR);
3475          AtInt->at_ee_pi3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_PI3_ERR);
3476          AtInt->at_ee_pi4_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_PI4_ERR);
3477          AtInt->at_ee_pi5_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_PI5_ERR);
3478          AtInt->at_ee_phyt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_PHYT_SYNC_ERR);
3479          AtInt->at_ee_radt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV0, AIF2_EE_AT_EN_EV0_AT_EE_RADT_SYNC_ERR);
3480         }
3481          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
3482          AtInt->at_ee_rp1_type_sys_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_SYS_RCVD_ERR);
3483          AtInt->at_ee_rp1_type_rp3_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_RP3_RCVD_ERR);
3484          AtInt->at_ee_rp1_type_tod_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_TOD_RCVD_ERR);
3485          AtInt->at_ee_rp1_type_unsel_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_UNSEL_ERR);
3486          AtInt->at_ee_rp1_type_spare_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_SPARE_ERR);
3487          AtInt->at_ee_rp1_type_rsvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_TYPE_RSVD_ERR);
3488          AtInt->at_ee_rp1_bit_width_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_BIT_WIDTH_ERR);
3489          AtInt->at_ee_rp1_crc_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_CRC_ERR);
3490          AtInt->at_ee_rp1_rp3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_RP3_ERR);
3491          AtInt->at_ee_rp1_sys_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RP1_SYS_ERR);
3492          AtInt->at_ee_pi0_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_PI0_ERR);
3493          AtInt->at_ee_pi1_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_PI1_ERR);
3494          AtInt->at_ee_pi2_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_PI2_ERR);
3495          AtInt->at_ee_pi3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_PI3_ERR);
3496          AtInt->at_ee_pi4_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_PI4_ERR);
3497          AtInt->at_ee_pi5_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_PI5_ERR);
3498          AtInt->at_ee_phyt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_PHYT_SYNC_ERR);
3499          AtInt->at_ee_radt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_EV1, AIF2_EE_AT_EN_EV1_AT_EE_RADT_SYNC_ERR);
3500         }
3501          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
3502          AtInt->at_ee_rp1_type_sys_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_SYS_RCVD_ERR);
3503          AtInt->at_ee_rp1_type_rp3_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_RP3_RCVD_ERR);
3504          AtInt->at_ee_rp1_type_tod_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_TOD_RCVD_ERR);
3505          AtInt->at_ee_rp1_type_unsel_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_UNSEL_ERR);
3506          AtInt->at_ee_rp1_type_spare_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_SPARE_ERR);
3507          AtInt->at_ee_rp1_type_rsvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_TYPE_RSVD_ERR);
3508          AtInt->at_ee_rp1_bit_width_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_BIT_WIDTH_ERR);
3509          AtInt->at_ee_rp1_crc_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_CRC_ERR);
3510          AtInt->at_ee_rp1_rp3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_RP3_ERR);
3511          AtInt->at_ee_rp1_sys_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RP1_SYS_ERR);
3512          AtInt->at_ee_pi0_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_PI0_ERR);
3513          AtInt->at_ee_pi1_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_PI1_ERR);
3514          AtInt->at_ee_pi2_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_PI2_ERR);
3515          AtInt->at_ee_pi3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_PI3_ERR);
3516          AtInt->at_ee_pi4_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_PI4_ERR);
3517          AtInt->at_ee_pi5_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_PI5_ERR);
3518          AtInt->at_ee_phyt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_PHYT_SYNC_ERR);
3519          AtInt->at_ee_radt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV0, AIF2_EE_AT_EN_STS_EV0_AT_EE_RADT_SYNC_ERR);
3520         }
3521          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
3522          AtInt->at_ee_rp1_type_sys_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_SYS_RCVD_ERR);
3523          AtInt->at_ee_rp1_type_rp3_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_RP3_RCVD_ERR);
3524          AtInt->at_ee_rp1_type_tod_rcvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_TOD_RCVD_ERR);
3525          AtInt->at_ee_rp1_type_unsel_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_UNSEL_ERR);
3526          AtInt->at_ee_rp1_type_spare_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_SPARE_ERR);
3527          AtInt->at_ee_rp1_type_rsvd_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_TYPE_RSVD_ERR);
3528          AtInt->at_ee_rp1_bit_width_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_BIT_WIDTH_ERR);
3529          AtInt->at_ee_rp1_crc_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_CRC_ERR);
3530          AtInt->at_ee_rp1_rp3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_RP3_ERR);
3531          AtInt->at_ee_rp1_sys_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RP1_SYS_ERR);
3532          AtInt->at_ee_pi0_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_PI0_ERR);
3533          AtInt->at_ee_pi1_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_PI1_ERR);
3534          AtInt->at_ee_pi2_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_PI2_ERR);
3535          AtInt->at_ee_pi3_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_PI3_ERR);
3536          AtInt->at_ee_pi4_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_PI4_ERR);
3537          AtInt->at_ee_pi5_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_PI5_ERR);
3538          AtInt->at_ee_phyt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_PHYT_SYNC_ERR);
3539          AtInt->at_ee_radt_sync_err=  CSL_FEXT(hAif2->regs->EE_AT_EN_STS_EV1, AIF2_EE_AT_EN_STS_EV1_AT_EE_RADT_SYNC_ERR);
3540         }
3541
3542 }
3543
3544
3545 /** ============================================================================
3546  *   @n@b Aif2Fl_getEePdIntStatus
3547  *
3548  *   @b Description
3549  *   @n Get Aif2 EE PD common interrupt  status value
3550  *
3551  *   @b Arguments
3552  *   @verbatim
3553            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
3554            Aif2Fl_EePdInt
3555       @endverbatim
3556  *
3557  *   <b> Return Value </b>  void
3558  *   <b> Pre Condition </b>
3559  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
3560  *   in that order before calling this function.
3561  *
3562  *   <b> Post Condition </b>
3563  *   @n None
3564  *
3565  *   @b Reads
3566  *   @n  AIF2_EE_PD_COMMON_IRS_PD_EE_TS_WDOG_ERR;AIF2_EE_PD_COMMON_EN_EV0_PD_EE_TS_WDOG_ERR;
3567  *         AIF2_EE_PD_COMMON_EN_EV1_PD_EE_TS_WDOG_ERR;AIF2_EE_PD_COMMON_EN_STS_EV0_PD_EE_TS_WDOG_ERR;
3568  *         AIF2_EE_PD_COMMON_EN_STS_EV1_PD_EE_TS_WDOG_ERR;
3569  *   @b Example
3570  *   @verbatim
3571         Aif2Fl_EePdInt  PdInt;
3572         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
3573
3574         Aif2Fl_getEePdIntStatus(hAif2,&PdInt);
3575      @endverbatim
3576  * ===========================================================================
3577  */
3578 static inline
3579 void Aif2Fl_getEePdIntStatus (
3580         Aif2Fl_Handle   hAif2,
3581         Aif2Fl_EePdInt*     PdInt
3582 )
3583 {
3584         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
3585          PdInt->pd_ee_ts_wdog_err=  CSL_FEXT(hAif2->regs->EE_PD_COMMON_IRS, AIF2_EE_PD_COMMON_IRS_PD_EE_TS_WDOG_ERR);
3586         }
3587          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
3588          PdInt->pd_ee_ts_wdog_err=  CSL_FEXT(hAif2->regs->EE_PD_COMMON_EN_EV0, AIF2_EE_PD_COMMON_EN_EV0_PD_EE_TS_WDOG_ERR);
3589         }
3590          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
3591          PdInt->pd_ee_ts_wdog_err=  CSL_FEXT(hAif2->regs->EE_PD_COMMON_EN_EV1, AIF2_EE_PD_COMMON_EN_EV1_PD_EE_TS_WDOG_ERR);
3592         }
3593          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
3594          PdInt->pd_ee_ts_wdog_err=  CSL_FEXT(hAif2->regs->EE_PD_COMMON_EN_STS_EV0, AIF2_EE_PD_COMMON_EN_STS_EV0_PD_EE_TS_WDOG_ERR);
3595         }
3596          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
3597          PdInt->pd_ee_ts_wdog_err=  CSL_FEXT(hAif2->regs->EE_PD_COMMON_EN_STS_EV1, AIF2_EE_PD_COMMON_EN_STS_EV1_PD_EE_TS_WDOG_ERR);
3598         }
3599
3600 }
3601
3602
3603 /** ============================================================================
3604  *   @n@b Aif2Fl_getEePeIntStatus
3605  *
3606  *   @b Description
3607  *   @n Get Aif2 EE PE common interrupt  status value
3608  *
3609  *   @b Arguments
3610  *   @verbatim
3611            hAif2      Handle to the aif2 instance     use hAif2->ee_arg to select function
3612            Aif2Fl_EePeInt
3613       @endverbatim
3614  *
3615  *   <b> Return Value </b>  void
3616  *   <b> Pre Condition </b>
3617  *   @n  Both @a Aif2Fl_init() and @a Aif2Fl_open() must be called successfully
3618  *   in that order before calling this function.
3619  *
3620  *   <b> Post Condition </b>
3621  *   @n None
3622  *
3623  *   @b Reads
3624  *   @n  AIF2_EE_PE_COMMON_IRS_PE_EE_RD2DB_ERR,AIF2_EE_PE_COMMON_IRS_PE_EE_TOKEN_REQ_OVFL_ERR,
3625  *         AIF2_EE_PE_COMMON_IRS_PE_EE_TOKEN_WR_ERR,AIF2_EE_PE_COMMON_IRS_PE_EE_DAT_REQ_OVFL_ERR;
3626  *         AIF2_EE_PE_COMMON_EN_EV0_PE_EE_RD2DB_ERR,AIF2_EE_PE_COMMON_EN_EV0_PE_EE_TOKEN_REQ_OVFL_ERR,
3627  *         AIF2_EE_PE_COMMON_EN_EV0_PE_EE_TOKEN_WR_ERR,AIF2_EE_PE_COMMON_EN_EV0_PE_EE_DAT_REQ_OVFL_ERR;
3628  *         AIF2_EE_PE_COMMON_EN_EV1_PE_EE_RD2DB_ERR,AIF2_EE_PE_COMMON_EN_EV1_PE_EE_TOKEN_REQ_OVFL_ERR,
3629  *         AIF2_EE_PE_COMMON_EN_EV1_PE_EE_TOKEN_WR_ERR,AIF2_EE_PE_COMMON_EN_EV1_PE_EE_DAT_REQ_OVFL_ERR;
3630  *        AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_RD2DB_ERR,AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_TOKEN_REQ_OVFL_ERR,
3631  *        AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_TOKEN_WR_ERR,AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_DAT_REQ_OVFL_ERR;
3632  *        AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_RD2DB_ERR,AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_TOKEN_REQ_OVFL_ERR,
3633  *        AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_TOKEN_WR_ERR,AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_DAT_REQ_OVFL_ERR;
3634  *   @b Example
3635  *   @verbatim
3636         Aif2Fl_EePeInt  PeInt;
3637         hAif2->ee_arg = AIF2FL_EE_INT_RAW_STATUS;
3638
3639         Aif2Fl_getEePeIntStatus(hAif2,&PeInt);
3640      @endverbatim
3641  * ===========================================================================
3642  */
3643 static inline
3644 void Aif2Fl_getEePeIntStatus (
3645         Aif2Fl_Handle   hAif2,
3646         Aif2Fl_EePeInt*     PeInt
3647 )
3648 {
3649         if(hAif2->ee_arg == AIF2FL_EE_INT_RAW_STATUS){
3650          PeInt->pe_ee_rd2db_err =               CSL_FEXT(hAif2->regs->EE_PE_COMMON_IRS, AIF2_EE_PE_COMMON_IRS_PE_EE_RD2DB_ERR);
3651          PeInt->pe_ee_token_req_ovfl_err =  CSL_FEXT(hAif2->regs->EE_PE_COMMON_IRS, AIF2_EE_PE_COMMON_IRS_PE_EE_TOKEN_REQ_OVFL_ERR);
3652          PeInt->pe_ee_token_wr_err =          CSL_FEXT(hAif2->regs->EE_PE_COMMON_IRS, AIF2_EE_PE_COMMON_IRS_PE_EE_TOKEN_WR_ERR);
3653          PeInt->pe_ee_dat_req_ovfl_err =     CSL_FEXT(hAif2->regs->EE_PE_COMMON_IRS, AIF2_EE_PE_COMMON_IRS_PE_EE_DAT_REQ_OVFL_ERR);
3654         }
3655          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV0){
3656          PeInt->pe_ee_rd2db_err =               CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV0, AIF2_EE_PE_COMMON_EN_EV0_PE_EE_RD2DB_ERR);
3657          PeInt->pe_ee_token_req_ovfl_err =  CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV0, AIF2_EE_PE_COMMON_EN_EV0_PE_EE_TOKEN_REQ_OVFL_ERR);
3658          PeInt->pe_ee_token_wr_err =          CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV0, AIF2_EE_PE_COMMON_EN_EV0_PE_EE_TOKEN_WR_ERR);
3659          PeInt->pe_ee_dat_req_ovfl_err =     CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV0, AIF2_EE_PE_COMMON_EN_EV0_PE_EE_DAT_REQ_OVFL_ERR);
3660         }
3661          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_EV1){
3662          PeInt->pe_ee_rd2db_err =               CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV1, AIF2_EE_PE_COMMON_EN_EV1_PE_EE_RD2DB_ERR);
3663          PeInt->pe_ee_token_req_ovfl_err =  CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV1, AIF2_EE_PE_COMMON_EN_EV1_PE_EE_TOKEN_REQ_OVFL_ERR);
3664          PeInt->pe_ee_token_wr_err =          CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV1, AIF2_EE_PE_COMMON_EN_EV1_PE_EE_TOKEN_WR_ERR);
3665          PeInt->pe_ee_dat_req_ovfl_err =     CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_EV1, AIF2_EE_PE_COMMON_EN_EV1_PE_EE_DAT_REQ_OVFL_ERR);
3666         }
3667          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV0){
3668          PeInt->pe_ee_rd2db_err =               CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV0, AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_RD2DB_ERR);
3669          PeInt->pe_ee_token_req_ovfl_err =  CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV0, AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_TOKEN_REQ_OVFL_ERR);
3670          PeInt->pe_ee_token_wr_err =          CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV0, AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_TOKEN_WR_ERR);
3671          PeInt->pe_ee_dat_req_ovfl_err =     CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV0, AIF2_EE_PE_COMMON_EN_STS_EV0_PE_EE_DAT_REQ_OVFL_ERR);
3672         }
3673          else if(hAif2->ee_arg == AIF2FL_EE_INT_EN_STATUS_EV1){
3674          PeInt->pe_ee_rd2db_err =               CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV1, AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_RD2DB_ERR);
3675          PeInt->pe_ee_token_req_ovfl_err =  CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV1, AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_TOKEN_REQ_OVFL_ERR);
3676          PeInt->pe_ee_token_wr_err =          CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV1, AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_TOKEN_WR_ERR);
3677          PeInt->pe_ee_dat_req_ovfl_err =     CSL_FEXT(hAif2->regs->EE_PE_COMMON_EN_STS_EV1, AIF2_EE_PE_COMMON_EN_STS_EV1_PE_EE_DAT_REQ_OVFL_ERR);
3678         }
3679
3680 }
3681
3682
3683
3684 #ifdef __cplusplus
3685 }
3686 #endif
3687 #endif /* Aif2Fl_getHwStatusAUX_H_ */
3688
3689