packages/ti/drv/udma/src/udma_rm.c

   1 /*
   2  *  Copyright (c) Texas Instruments Incorporated 2018
   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  *  \file udma_rm.c
  35  *
  36  *  \brief File containing the UDMA driver Resource Manager (RM)
  37  *  abstraction functions.
  38  *
  39  */
  40
  41 /* ========================================================================== */
  42 /*                             Include Files                                  */
  43 /* ========================================================================== */
  44
  45 #include <ti/drv/udma/src/udma_priv.h>
  46
  47 /* ========================================================================== */
  48 /*                           Macros & Typedefs                                */
  49 /* ========================================================================== */
  50
  51 /* None */
  52
  53 /* ========================================================================== */
  54 /*                         Structure Declarations                             */
  55 /* ========================================================================== */
  56
  57 /* None */
  58
  59 /* ========================================================================== */
  60 /*                          Function Declarations                             */
  61 /* ========================================================================== */
  62
  63 static int32_t Udma_rmCheckResLeak(Udma_DrvHandle drvHandle,
  64                                    const uint32_t *allocFlag,
  65                                    uint32_t numRes,
  66                                    uint32_t arrSize);
  67
  68 /* ========================================================================== */
  69 /*                            Global Variables                                */
  70 /* ========================================================================== */
  71
  72 /* None */
  73
  74 /* ========================================================================== */
  75 /*                          Function Definitions                              */
  76 /* ========================================================================== */
  77
  78 int32_t Udma_rmInit(Udma_DrvHandle drvHandle)
  79 {
  80     int32_t             retVal = UDMA_SOK;
  81     uint32_t            i, offset, bitPos, bitMask;
  82     uint32_t            utcId;
  83     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
  84
  85     /* Check if the default config has any overlap */
  86     if(FALSE == drvHandle->initPrms.skipRmOverlapCheck)
  87     {
  88         retVal = Udma_rmCheckDefaultCfg();
  89     }
  90
  91     if(UDMA_SOK == retVal)
  92     {
  93         /* Mark all resources as free */
  94         for(i = 0U; i < rmInitPrms->numBlkCopyCh; i++)
  95         {
  96             offset = i >> 5U;
  97             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_CH_ARR_SIZE);
  98             bitPos = i - (offset << 5U);
  99             bitMask = (uint32_t) 1U << bitPos;
 100             drvHandle->blkCopyChFlag[offset] |= bitMask;
 101         }
 102         for(i = 0U; i < rmInitPrms->numBlkCopyHcCh; i++)
 103         {
 104             offset = i >> 5U;
 105             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE);
 106             bitPos = i - (offset << 5U);
 107             bitMask = (uint32_t) 1U << bitPos;
 108             drvHandle->blkCopyHcChFlag[offset] |= bitMask;
 109         }
 110         for(i = 0U; i < rmInitPrms->numBlkCopyUhcCh; i++)
 111         {
 112             offset = i >> 5U;
 113             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE);
 114             bitPos = i - (offset << 5U);
 115             bitMask = (uint32_t) 1U << bitPos;
 116             drvHandle->blkCopyUhcChFlag[offset] |= bitMask;
 117         }
 118         for(i = 0U; i < rmInitPrms->numTxCh; i++)
 119         {
 120             offset = i >> 5U;
 121             Udma_assert(drvHandle, offset < UDMA_RM_TX_CH_ARR_SIZE);
 122             bitPos = i - (offset << 5U);
 123             bitMask = (uint32_t) 1U << bitPos;
 124             drvHandle->txChFlag[offset] |= bitMask;
 125         }
 126         for(i = 0U; i < rmInitPrms->numRxCh; i++)
 127         {
 128             offset = i >> 5U;
 129             Udma_assert(drvHandle, offset < UDMA_RM_RX_CH_ARR_SIZE);
 130             bitPos = i - (offset << 5U);
 131             bitMask = (uint32_t) 1U << bitPos;
 132             drvHandle->rxChFlag[offset] |= bitMask;
 133         }
 134         for(i = 0U; i < rmInitPrms->numTxHcCh; i++)
 135         {
 136             offset = i >> 5U;
 137             Udma_assert(drvHandle, offset < UDMA_RM_TX_HC_CH_ARR_SIZE);
 138             bitPos = i - (offset << 5U);
 139             bitMask = (uint32_t) 1U << bitPos;
 140             drvHandle->txHcChFlag[offset] |= bitMask;
 141         }
 142         for(i = 0U; i < rmInitPrms->numRxHcCh; i++)
 143         {
 144             offset = i >> 5U;
 145             Udma_assert(drvHandle, offset < UDMA_RM_RX_HC_CH_ARR_SIZE);
 146             bitPos = i - (offset << 5U);
 147             bitMask = (uint32_t) 1U << bitPos;
 148             drvHandle->rxHcChFlag[offset] |= bitMask;
 149         }
 150         for(i = 0U; i < rmInitPrms->numTxUhcCh; i++)
 151         {
 152             offset = i >> 5U;
 153             Udma_assert(drvHandle, offset < UDMA_RM_TX_UHC_CH_ARR_SIZE);
 154             bitPos = i - (offset << 5U);
 155             bitMask = (uint32_t) 1U << bitPos;
 156             drvHandle->txUhcChFlag[offset] |= bitMask;
 157         }
 158         for(i = 0U; i < rmInitPrms->numRxUhcCh; i++)
 159         {
 160             offset = i >> 5U;
 161             Udma_assert(drvHandle, offset < UDMA_RM_RX_UHC_CH_ARR_SIZE);
 162             bitPos = i - (offset << 5U);
 163             bitMask = (uint32_t) 1U << bitPos;
 164             drvHandle->rxUhcChFlag[offset] |= bitMask;
 165         }
 166         for(utcId = 0U; utcId < UDMA_NUM_UTC_INSTANCE; utcId++)
 167         {
 168             for(i = 0U; i < rmInitPrms->numUtcCh[utcId]; i++)
 169             {
 170                 offset = i >> 5U;
 171                 Udma_assert(drvHandle, offset < UDMA_RM_UTC_CH_ARR_SIZE);
 172                 bitPos = i - (offset << 5U);
 173                 bitMask = (uint32_t) 1U << bitPos;
 174                 drvHandle->utcChFlag[utcId][offset] |= bitMask;
 175             }
 176         }
 177         for(i = 0U; i < rmInitPrms->numFreeRing; i++)
 178         {
 179             offset = i >> 5U;
 180             Udma_assert(drvHandle, offset < UDMA_RM_FREE_RING_ARR_SIZE);
 181             bitPos = i - (offset << 5U);
 182             bitMask = (uint32_t) 1U << bitPos;
 183             drvHandle->freeRingFlag[offset] |= bitMask;
 184         }
 185         for(i = 0U; i < rmInitPrms->numFreeFlow; i++)
 186         {
 187             offset = i >> 5U;
 188             Udma_assert(drvHandle, offset < UDMA_RM_FREE_FLOW_ARR_SIZE);
 189             bitPos = i - (offset << 5U);
 190             bitMask = (uint32_t) 1U << bitPos;
 191             drvHandle->freeFlowFlag[offset] |= bitMask;
 192         }
 193         for(i = 0U; i < rmInitPrms->numGlobalEvent; i++)
 194         {
 195             offset = i >> 5U;
 196             Udma_assert(drvHandle, offset < UDMA_RM_GLOBAL_EVENT_ARR_SIZE);
 197             bitPos = i - (offset << 5U);
 198             bitMask = (uint32_t) 1U << bitPos;
 199             drvHandle->globalEventFlag[offset] |= bitMask;
 200         }
 201         for(i = 0U; i < rmInitPrms->numVintr; i++)
 202         {
 203             offset = i >> 5U;
 204             Udma_assert(drvHandle, offset < UDMA_RM_VINTR_ARR_SIZE);
 205             bitPos = i - (offset << 5U);
 206             bitMask = (uint32_t) 1U << bitPos;
 207             drvHandle->vintrFlag[offset] |= bitMask;
 208         }
 209         for(i = 0U; i < rmInitPrms->numIrIntr; i++)
 210         {
 211             offset = i >> 5U;
 212             Udma_assert(drvHandle, offset < UDMA_RM_CORE_INTR_ARR_SIZE);
 213             bitPos = i - (offset << 5U);
 214             bitMask = (uint32_t) 1U << bitPos;
 215             drvHandle->coreIntrFlag[offset] |= bitMask;
 216         }
 217         for(i = 0U; i < rmInitPrms->numProxy; i++)
 218         {
 219             offset = i >> 5U;
 220             Udma_assert(drvHandle, offset < UDMA_RM_PROXY_ARR_SIZE);
 221             bitPos = i - (offset << 5U);
 222             bitMask = (uint32_t) 1U << bitPos;
 223             drvHandle->proxyFlag[offset] |= bitMask;
 224         }
 225         for(i = 0U; i < rmInitPrms->numRingMon; i++)
 226         {
 227             offset = i >> 5U;
 228             Udma_assert(drvHandle, offset < UDMA_RM_RING_MON_ARR_SIZE);
 229             bitPos = i - (offset << 5U);
 230             bitMask = (uint32_t) 1U << bitPos;
 231             drvHandle->ringMonFlag[offset] |= bitMask;
 232         }
 233     }
 234
 235     return (retVal);
 236 }
 237
 238 int32_t Udma_rmDeinit(Udma_DrvHandle drvHandle)
 239 {
 240     int32_t             retVal = UDMA_SOK;
 241     uint32_t            utcId;
 242     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 243
 244     retVal += Udma_rmCheckResLeak(
 245                   drvHandle,
 246                   &drvHandle->blkCopyChFlag[0U],
 247                   rmInitPrms->numBlkCopyCh,
 248                   UDMA_RM_BLK_COPY_CH_ARR_SIZE);
 249     retVal += Udma_rmCheckResLeak(
 250                   drvHandle,
 251                   &drvHandle->blkCopyHcChFlag[0U],
 252                   rmInitPrms->numBlkCopyHcCh,
 253                   UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE);
 254     retVal += Udma_rmCheckResLeak(
 255                   drvHandle,
 256                   &drvHandle->blkCopyUhcChFlag[0U],
 257                   rmInitPrms->numBlkCopyUhcCh,
 258                   UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE);
 259     retVal += Udma_rmCheckResLeak(
 260                   drvHandle,
 261                   &drvHandle->txChFlag[0U],
 262                   rmInitPrms->numTxCh,
 263                   UDMA_RM_TX_CH_ARR_SIZE);
 264     retVal += Udma_rmCheckResLeak(
 265                   drvHandle,
 266                   &drvHandle->txHcChFlag[0U],
 267                   rmInitPrms->numTxHcCh,
 268                   UDMA_RM_TX_HC_CH_ARR_SIZE);
 269     retVal += Udma_rmCheckResLeak(
 270                   drvHandle,
 271                   &drvHandle->txUhcChFlag[0U],
 272                   rmInitPrms->numTxUhcCh,
 273                   UDMA_RM_TX_UHC_CH_ARR_SIZE);
 274     retVal += Udma_rmCheckResLeak(
 275                   drvHandle,
 276                   &drvHandle->rxChFlag[0U],
 277                   rmInitPrms->numRxCh,
 278                   UDMA_RM_RX_CH_ARR_SIZE);
 279     retVal += Udma_rmCheckResLeak(
 280                   drvHandle,
 281                   &drvHandle->rxHcChFlag[0U],
 282                   rmInitPrms->numRxHcCh,
 283                   UDMA_RM_RX_HC_CH_ARR_SIZE);
 284     retVal += Udma_rmCheckResLeak(
 285                   drvHandle,
 286                   &drvHandle->rxUhcChFlag[0U],
 287                   rmInitPrms->numRxUhcCh,
 288                   UDMA_RM_RX_UHC_CH_ARR_SIZE);
 289     for(utcId = 0U; utcId < UDMA_NUM_UTC_INSTANCE; utcId++)
 290     {
 291         retVal += Udma_rmCheckResLeak(
 292                       drvHandle,
 293                       &drvHandle->utcChFlag[utcId][0U],
 294                       rmInitPrms->numUtcCh[utcId],
 295                       UDMA_RM_UTC_CH_ARR_SIZE);
 296     }
 297     retVal += Udma_rmCheckResLeak(
 298                   drvHandle,
 299                   &drvHandle->freeRingFlag[0U],
 300                   rmInitPrms->numFreeRing,
 301                   UDMA_RM_FREE_RING_ARR_SIZE);
 302     retVal += Udma_rmCheckResLeak(
 303                   drvHandle,
 304                   &drvHandle->freeFlowFlag[0U],
 305                   rmInitPrms->numFreeFlow,
 306                   UDMA_RM_FREE_FLOW_ARR_SIZE);
 307     retVal += Udma_rmCheckResLeak(
 308                   drvHandle,
 309                   &drvHandle->globalEventFlag[0U],
 310                   rmInitPrms->numGlobalEvent,
 311                   UDMA_RM_GLOBAL_EVENT_ARR_SIZE);
 312     retVal += Udma_rmCheckResLeak(
 313                   drvHandle,
 314                   &drvHandle->vintrFlag[0U],
 315                   rmInitPrms->numVintr,
 316                   UDMA_RM_VINTR_ARR_SIZE);
 317     retVal += Udma_rmCheckResLeak(
 318                   drvHandle,
 319                   &drvHandle->coreIntrFlag[0U],
 320                   rmInitPrms->numIrIntr,
 321                   UDMA_RM_CORE_INTR_ARR_SIZE);
 322     retVal += Udma_rmCheckResLeak(
 323                   drvHandle,
 324                   &drvHandle->proxyFlag[0U],
 325                   rmInitPrms->numProxy,
 326                   UDMA_RM_PROXY_ARR_SIZE);
 327     retVal += Udma_rmCheckResLeak(
 328                   drvHandle,
 329                   &drvHandle->ringMonFlag[0U],
 330                   rmInitPrms->numRingMon,
 331                   UDMA_RM_RING_MON_ARR_SIZE);
 332
 333     return (retVal);
 334 }
 335
 336 uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 337 {
 338     uint32_t            i, offset, bitPos, bitMask;
 339     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 340     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 341
 342     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 343     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 344
 345     if(UDMA_DMA_CH_ANY == preferredChNum)
 346     {
 347         /* Search and allocate from Blk Copy channel pool */
 348         for(i = 0U; i < rmInitPrms->numBlkCopyCh; i++)
 349         {
 350             offset = i >> 5U;
 351             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_CH_ARR_SIZE);
 352             bitPos = i - (offset << 5U);
 353             bitMask = (uint32_t) 1U << bitPos;
 354             if((drvHandle->blkCopyChFlag[offset] & bitMask) == bitMask)
 355             {
 356                 drvHandle->blkCopyChFlag[offset] &= ~bitMask;
 357                 chNum = i + rmInitPrms->startBlkCopyCh;  /* Add start offset */
 358                 break;
 359             }
 360         }
 361     }
 362     else
 363     {
 364         /* Allocate specific Block Copy channel if free */
 365         /* Array bound check */
 366         if((preferredChNum >= rmInitPrms->startBlkCopyCh) &&
 367            (preferredChNum < (rmInitPrms->startBlkCopyCh + rmInitPrms->numBlkCopyCh)))
 368         {
 369             i = preferredChNum - rmInitPrms->startBlkCopyCh;
 370             offset = i >> 5U;
 371             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_CH_ARR_SIZE);
 372             bitPos = i - (offset << 5U);
 373             bitMask = (uint32_t) 1U << bitPos;
 374             if((drvHandle->blkCopyChFlag[offset] & bitMask) == bitMask)
 375             {
 376                 drvHandle->blkCopyChFlag[offset] &= ~bitMask;
 377                 chNum = preferredChNum;
 378             }
 379         }
 380     }
 381
 382     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 383     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 384
 385     return (chNum);
 386 }
 387
 388 void Udma_rmFreeBlkCopyCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 389 {
 390     uint32_t            i, offset, bitPos, bitMask;
 391     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 392
 393     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 394     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 395
 396     Udma_assert(drvHandle, chNum >= (rmInitPrms->startBlkCopyCh));
 397     Udma_assert(drvHandle,
 398         chNum < (rmInitPrms->startBlkCopyCh + rmInitPrms->numBlkCopyCh));
 399     i = chNum - rmInitPrms->startBlkCopyCh;
 400     offset = i >> 5U;
 401     Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_CH_ARR_SIZE);
 402     bitPos = i - (offset << 5U);
 403     bitMask = (uint32_t) 1U << bitPos;
 404     Udma_assert(drvHandle,
 405         (drvHandle->blkCopyChFlag[offset] & bitMask) == 0U);
 406     drvHandle->blkCopyChFlag[offset] |= bitMask;
 407
 408     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 409     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 410
 411     return;
 412 }
 413
 414 uint32_t Udma_rmAllocBlkCopyHcCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 415 {
 416     uint32_t            i, offset, bitPos, bitMask;
 417     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 418     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 419
 420     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 421     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 422
 423     if(UDMA_DMA_CH_ANY == preferredChNum)
 424     {
 425         /* Search and allocate from Blk Copy high capacity channel pool */
 426         for(i = 0U; i < rmInitPrms->numBlkCopyHcCh; i++)
 427         {
 428             offset = i >> 5U;
 429             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE);
 430             bitPos = i - (offset << 5U);
 431             bitMask = (uint32_t) 1U << bitPos;
 432             if((drvHandle->blkCopyHcChFlag[offset] & bitMask) == bitMask)
 433             {
 434                 drvHandle->blkCopyHcChFlag[offset] &= ~bitMask;
 435                 chNum = i + rmInitPrms->startBlkCopyHcCh;  /* Add start offset */
 436                 break;
 437             }
 438         }
 439     }
 440     else
 441     {
 442         /* Allocate specific Block Copy channel if free */
 443         /* Array bound check */
 444         if((preferredChNum >= rmInitPrms->startBlkCopyHcCh) &&
 445            (preferredChNum < (rmInitPrms->startBlkCopyHcCh + rmInitPrms->numBlkCopyHcCh)))
 446         {
 447             i = preferredChNum - rmInitPrms->startBlkCopyHcCh;
 448             offset = i >> 5U;
 449             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE);
 450             bitPos = i - (offset << 5U);
 451             bitMask = (uint32_t) 1U << bitPos;
 452             if((drvHandle->blkCopyHcChFlag[offset] & bitMask) == bitMask)
 453             {
 454                 drvHandle->blkCopyHcChFlag[offset] &= ~bitMask;
 455                 chNum = preferredChNum;
 456             }
 457         }
 458     }
 459
 460     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 461     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 462
 463     return (chNum);
 464 }
 465
 466 void Udma_rmFreeBlkCopyHcCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 467 {
 468     uint32_t            i, offset, bitPos, bitMask;
 469     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 470
 471     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 472     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 473
 474     Udma_assert(drvHandle, chNum >= (rmInitPrms->startBlkCopyHcCh));
 475     Udma_assert(drvHandle,
 476         chNum < (rmInitPrms->startBlkCopyHcCh + rmInitPrms->numBlkCopyHcCh));
 477     i = chNum - rmInitPrms->startBlkCopyHcCh;
 478     offset = i >> 5U;
 479     Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE);
 480     bitPos = i - (offset << 5U);
 481     bitMask = (uint32_t) 1U << bitPos;
 482     Udma_assert(drvHandle,
 483         (drvHandle->blkCopyHcChFlag[offset] & bitMask) == 0U);
 484     drvHandle->blkCopyHcChFlag[offset] |= bitMask;
 485
 486     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 487     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 488
 489     return;
 490 }
 491
 492 uint32_t Udma_rmAllocBlkCopyUhcCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 493 {
 494     uint32_t            i, offset, bitPos, bitMask;
 495     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 496     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 497
 498     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 499     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 500
 501     if(UDMA_DMA_CH_ANY == preferredChNum)
 502     {
 503         /* Search and allocate from Blk Copy ultra high capacity channel pool */
 504         for(i = 0U; i < rmInitPrms->numBlkCopyUhcCh; i++)
 505         {
 506             offset = i >> 5U;
 507             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE);
 508             bitPos = i - (offset << 5U);
 509             bitMask = (uint32_t) 1U << bitPos;
 510             if((drvHandle->blkCopyUhcChFlag[offset] & bitMask) == bitMask)
 511             {
 512                 drvHandle->blkCopyUhcChFlag[offset] &= ~bitMask;
 513                 chNum = i + rmInitPrms->startBlkCopyUhcCh;  /* Add start offset */
 514                 break;
 515             }
 516         }
 517     }
 518     else
 519     {
 520         /* Allocate specific Block Copy channel if free */
 521         /* Array bound check */
 522         if((preferredChNum >= rmInitPrms->startBlkCopyUhcCh) &&
 523            (preferredChNum < (rmInitPrms->startBlkCopyUhcCh + rmInitPrms->numBlkCopyUhcCh)))
 524         {
 525             i = preferredChNum - rmInitPrms->startBlkCopyUhcCh;
 526             offset = i >> 5U;
 527             Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE);
 528             bitPos = i - (offset << 5U);
 529             bitMask = (uint32_t) 1U << bitPos;
 530             if((drvHandle->blkCopyUhcChFlag[offset] & bitMask) == bitMask)
 531             {
 532                 drvHandle->blkCopyUhcChFlag[offset] &= ~bitMask;
 533                 chNum = preferredChNum;
 534             }
 535         }
 536     }
 537
 538     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 539     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 540
 541     return (chNum);
 542 }
 543
 544 void Udma_rmFreeBlkCopyUhcCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 545 {
 546     uint32_t            i, offset, bitPos, bitMask;
 547     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 548
 549     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 550     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 551
 552     Udma_assert(drvHandle, chNum >= (rmInitPrms->startBlkCopyUhcCh));
 553     Udma_assert(drvHandle,
 554         chNum < (rmInitPrms->startBlkCopyUhcCh + rmInitPrms->numBlkCopyUhcCh));
 555     i = chNum - rmInitPrms->startBlkCopyUhcCh;
 556     offset = i >> 5U;
 557     Udma_assert(drvHandle, offset < UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE);
 558     bitPos = i - (offset << 5U);
 559     bitMask = (uint32_t) 1U << bitPos;
 560     Udma_assert(drvHandle,
 561         (drvHandle->blkCopyUhcChFlag[offset] & bitMask) == 0U);
 562     drvHandle->blkCopyUhcChFlag[offset] |= bitMask;
 563
 564     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 565     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 566
 567     return;
 568 }
 569
 570 uint32_t Udma_rmAllocTxCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 571 {
 572     uint32_t            i, offset, bitPos, bitMask;
 573     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 574     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 575
 576     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 577     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 578
 579     if(UDMA_DMA_CH_ANY == preferredChNum)
 580     {
 581         /* Search and allocate from TX channel pool */
 582         for(i = 0U; i < rmInitPrms->numTxCh; i++)
 583         {
 584             offset = i >> 5U;
 585             Udma_assert(drvHandle, offset < UDMA_RM_TX_CH_ARR_SIZE);
 586             bitPos = i - (offset << 5U);
 587             bitMask = (uint32_t) 1U << bitPos;
 588             if((drvHandle->txChFlag[offset] & bitMask) == bitMask)
 589             {
 590                 drvHandle->txChFlag[offset] &= ~bitMask;
 591                 chNum = i + rmInitPrms->startTxCh;  /* Add start offset */
 592                 break;
 593             }
 594         }
 595     }
 596     else
 597     {
 598         /* Allocate specific TX channel if free */
 599         /* Array bound check */
 600         if((preferredChNum >= rmInitPrms->startTxCh) &&
 601            (preferredChNum < (rmInitPrms->startTxCh + rmInitPrms->numTxCh)))
 602         {
 603             i = preferredChNum - rmInitPrms->startTxCh;
 604             offset = i >> 5U;
 605             Udma_assert(drvHandle, offset < UDMA_RM_TX_CH_ARR_SIZE);
 606             bitPos = i - (offset << 5U);
 607             bitMask = (uint32_t) 1U << bitPos;
 608             if((drvHandle->txChFlag[offset] & bitMask) == bitMask)
 609             {
 610                 drvHandle->txChFlag[offset] &= ~bitMask;
 611                 chNum = preferredChNum;
 612             }
 613         }
 614     }
 615
 616     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 617     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 618
 619     return (chNum);
 620 }
 621
 622 void Udma_rmFreeTxCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 623 {
 624     uint32_t            i, offset, bitPos, bitMask;
 625     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 626
 627     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 628     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 629
 630     Udma_assert(drvHandle, chNum >= (rmInitPrms->startTxCh));
 631     Udma_assert(drvHandle,
 632         chNum < (rmInitPrms->startTxCh + rmInitPrms->numTxCh));
 633     i = chNum - rmInitPrms->startTxCh;
 634     offset = i >> 5U;
 635     Udma_assert(drvHandle, offset < UDMA_RM_TX_CH_ARR_SIZE);
 636     bitPos = i - (offset << 5U);
 637     bitMask = (uint32_t) 1U << bitPos;
 638     Udma_assert(drvHandle,
 639         (drvHandle->txChFlag[offset] & bitMask) == 0U);
 640     drvHandle->txChFlag[offset] |= bitMask;
 641
 642     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 643     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 644
 645     return;
 646 }
 647
 648 uint32_t Udma_rmAllocRxCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 649 {
 650     uint32_t            i, offset, bitPos, bitMask;
 651     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 652     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 653
 654     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 655     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 656
 657     if(UDMA_DMA_CH_ANY == preferredChNum)
 658     {
 659         /* Search and allocate from RX channel pool */
 660         for(i = 0U; i < rmInitPrms->numRxCh; i++)
 661         {
 662             offset = i >> 5U;
 663             Udma_assert(drvHandle, offset < UDMA_RM_RX_CH_ARR_SIZE);
 664             bitPos = i - (offset << 5U);
 665             bitMask = (uint32_t) 1U << bitPos;
 666             if((drvHandle->rxChFlag[offset] & bitMask) == bitMask)
 667             {
 668                 drvHandle->rxChFlag[offset] &= ~bitMask;
 669                 chNum = i + rmInitPrms->startRxCh;  /* Add start offset */
 670                 break;
 671             }
 672         }
 673     }
 674     else
 675     {
 676         /* Allocate specific RX channel if free */
 677         /* Array bound check */
 678         if((preferredChNum >= rmInitPrms->startRxCh) &&
 679            (preferredChNum < (rmInitPrms->startRxCh + rmInitPrms->numRxCh)))
 680         {
 681             i = preferredChNum - rmInitPrms->startRxCh;
 682             offset = i >> 5U;
 683             Udma_assert(drvHandle, offset < UDMA_RM_RX_CH_ARR_SIZE);
 684             bitPos = i - (offset << 5U);
 685             bitMask = (uint32_t) 1U << bitPos;
 686             if((drvHandle->rxChFlag[offset] & bitMask) == bitMask)
 687             {
 688                 drvHandle->rxChFlag[offset] &= ~bitMask;
 689                 chNum = preferredChNum;
 690             }
 691         }
 692     }
 693
 694     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 695     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 696
 697     return (chNum);
 698 }
 699
 700 void Udma_rmFreeRxCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 701 {
 702     uint32_t            i, offset, bitPos, bitMask;
 703     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 704
 705     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 706     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 707
 708     Udma_assert(drvHandle, chNum >= rmInitPrms->startRxCh);
 709     Udma_assert(drvHandle,
 710         chNum < (rmInitPrms->startRxCh + rmInitPrms->numRxCh));
 711     i = chNum - rmInitPrms->startRxCh;
 712     offset = i >> 5U;
 713     Udma_assert(drvHandle, offset < UDMA_RM_RX_CH_ARR_SIZE);
 714     bitPos = i - (offset << 5U);
 715     bitMask = (uint32_t) 1U << bitPos;
 716     Udma_assert(drvHandle,
 717         (drvHandle->rxChFlag[offset] & bitMask) == 0U);
 718     drvHandle->rxChFlag[offset] |= bitMask;
 719
 720     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 721     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 722
 723     return;
 724 }
 725
 726 uint32_t Udma_rmAllocTxHcCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 727 {
 728     uint32_t            i, offset, bitPos, bitMask;
 729     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 730     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 731
 732     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 733     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 734
 735     if(UDMA_DMA_CH_ANY == preferredChNum)
 736     {
 737         /* Search and allocate from TX HC channel pool */
 738         for(i = 0U; i < rmInitPrms->numTxHcCh; i++)
 739         {
 740             offset = i >> 5U;
 741             Udma_assert(drvHandle, offset < UDMA_RM_TX_HC_CH_ARR_SIZE);
 742             bitPos = i - (offset << 5U);
 743             bitMask = (uint32_t) 1U << bitPos;
 744             if((drvHandle->txHcChFlag[offset] & bitMask) == bitMask)
 745             {
 746                 drvHandle->txHcChFlag[offset] &= ~bitMask;
 747                 chNum = i + rmInitPrms->startTxHcCh;  /* Add start offset */
 748                 break;
 749             }
 750         }
 751     }
 752     else
 753     {
 754         /* Allocate specific TX HC channel if free */
 755         /* Array bound check */
 756         if((preferredChNum >= rmInitPrms->startTxHcCh) &&
 757            (preferredChNum < (rmInitPrms->startTxHcCh + rmInitPrms->numTxHcCh)))
 758         {
 759             i = preferredChNum - rmInitPrms->startTxHcCh;
 760             offset = i >> 5U;
 761             Udma_assert(drvHandle, offset < UDMA_RM_TX_HC_CH_ARR_SIZE);
 762             bitPos = i - (offset << 5U);
 763             bitMask = (uint32_t) 1U << bitPos;
 764             if((drvHandle->txHcChFlag[offset] & bitMask) == bitMask)
 765             {
 766                 drvHandle->txHcChFlag[offset] &= ~bitMask;
 767                 chNum = preferredChNum;
 768             }
 769         }
 770     }
 771
 772     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 773     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 774
 775     return (chNum);
 776 }
 777
 778 void Udma_rmFreeTxHcCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 779 {
 780     uint32_t            i, offset, bitPos, bitMask;
 781     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 782
 783     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 784     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 785
 786     Udma_assert(drvHandle, chNum >= (rmInitPrms->startTxHcCh));
 787     Udma_assert(drvHandle,
 788         chNum < (rmInitPrms->startTxHcCh + rmInitPrms->numTxHcCh));
 789     i = chNum - rmInitPrms->startTxHcCh;
 790     offset = i >> 5U;
 791     Udma_assert(drvHandle, offset < UDMA_RM_TX_HC_CH_ARR_SIZE);
 792     bitPos = i - (offset << 5U);
 793     bitMask = (uint32_t) 1U << bitPos;
 794     Udma_assert(drvHandle,
 795         (drvHandle->txHcChFlag[offset] & bitMask) == 0U);
 796     drvHandle->txHcChFlag[offset] |= bitMask;
 797
 798     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 799     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 800
 801     return;
 802 }
 803
 804 uint32_t Udma_rmAllocRxHcCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 805 {
 806     uint32_t            i, offset, bitPos, bitMask;
 807     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 808     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 809
 810     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 811     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 812
 813     if(UDMA_DMA_CH_ANY == preferredChNum)
 814     {
 815         /* Search and allocate from RX HC channel pool */
 816         for(i = 0U; i < rmInitPrms->numRxHcCh; i++)
 817         {
 818             offset = i >> 5U;
 819             Udma_assert(drvHandle, offset < UDMA_RM_RX_HC_CH_ARR_SIZE);
 820             bitPos = i - (offset << 5U);
 821             bitMask = (uint32_t) 1U << bitPos;
 822             if((drvHandle->rxHcChFlag[offset] & bitMask) == bitMask)
 823             {
 824                 drvHandle->rxHcChFlag[offset] &= ~bitMask;
 825                 chNum = i + rmInitPrms->startRxHcCh;  /* Add start offset */
 826                 break;
 827             }
 828         }
 829     }
 830     else
 831     {
 832         /* Allocate specific RX HC channel if free */
 833         /* Array bound check */
 834         if((preferredChNum >= rmInitPrms->startRxHcCh) &&
 835            (preferredChNum < (rmInitPrms->startRxHcCh + rmInitPrms->numRxHcCh)))
 836         {
 837             i = preferredChNum - rmInitPrms->startRxHcCh;
 838             offset = i >> 5U;
 839             Udma_assert(drvHandle, offset < UDMA_RM_RX_HC_CH_ARR_SIZE);
 840             bitPos = i - (offset << 5U);
 841             bitMask = (uint32_t) 1U << bitPos;
 842             if((drvHandle->rxHcChFlag[offset] & bitMask) == bitMask)
 843             {
 844                 drvHandle->rxHcChFlag[offset] &= ~bitMask;
 845                 chNum = preferredChNum;
 846             }
 847         }
 848     }
 849
 850     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 851     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 852
 853     return (chNum);
 854 }
 855
 856 void Udma_rmFreeRxHcCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 857 {
 858     uint32_t            i, offset, bitPos, bitMask;
 859     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 860
 861     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 862     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 863
 864     Udma_assert(drvHandle, chNum >= rmInitPrms->startRxHcCh);
 865     Udma_assert(drvHandle,
 866         chNum < (rmInitPrms->startRxHcCh + rmInitPrms->numRxHcCh));
 867     i = chNum - rmInitPrms->startRxHcCh;
 868     offset = i >> 5U;
 869     Udma_assert(drvHandle, offset < UDMA_RM_RX_HC_CH_ARR_SIZE);
 870     bitPos = i - (offset << 5U);
 871     bitMask = (uint32_t) 1U << bitPos;
 872     Udma_assert(drvHandle,
 873         (drvHandle->rxHcChFlag[offset] & bitMask) == 0U);
 874     drvHandle->rxHcChFlag[offset] |= bitMask;
 875
 876     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 877     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 878
 879     return;
 880 }
 881
 882 uint32_t Udma_rmAllocTxUhcCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 883 {
 884     uint32_t            i, offset, bitPos, bitMask;
 885     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 886     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 887
 888     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 889     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 890
 891     if(UDMA_DMA_CH_ANY == preferredChNum)
 892     {
 893         /* Search and allocate from TX UHC channel pool */
 894         for(i = 0U; i < rmInitPrms->numTxUhcCh; i++)
 895         {
 896             offset = i >> 5U;
 897             Udma_assert(drvHandle, offset < UDMA_RM_TX_UHC_CH_ARR_SIZE);
 898             bitPos = i - (offset << 5U);
 899             bitMask = (uint32_t) 1U << bitPos;
 900             if((drvHandle->txUhcChFlag[offset] & bitMask) == bitMask)
 901             {
 902                 drvHandle->txUhcChFlag[offset] &= ~bitMask;
 903                 chNum = i + rmInitPrms->startTxUhcCh;  /* Add start offset */
 904                 break;
 905             }
 906         }
 907     }
 908     else
 909     {
 910         /* Allocate specific TX UHC channel if free */
 911         /* Array bound check */
 912         if((preferredChNum >= rmInitPrms->startTxUhcCh) &&
 913            (preferredChNum < (rmInitPrms->startTxUhcCh + rmInitPrms->numTxUhcCh)))
 914         {
 915             i = preferredChNum - rmInitPrms->startTxUhcCh;
 916             offset = i >> 5U;
 917             Udma_assert(drvHandle, offset < UDMA_RM_TX_UHC_CH_ARR_SIZE);
 918             bitPos = i - (offset << 5U);
 919             bitMask = (uint32_t) 1U << bitPos;
 920             if((drvHandle->txUhcChFlag[offset] & bitMask) == bitMask)
 921             {
 922                 drvHandle->txUhcChFlag[offset] &= ~bitMask;
 923                 chNum = preferredChNum;
 924             }
 925         }
 926     }
 927
 928     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 929     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 930
 931     return (chNum);
 932 }
 933
 934 void Udma_rmFreeTxUhcCh(uint32_t chNum, Udma_DrvHandle drvHandle)
 935 {
 936     uint32_t            i, offset, bitPos, bitMask;
 937     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 938
 939     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 940     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 941
 942     Udma_assert(drvHandle, chNum >= (rmInitPrms->startTxUhcCh));
 943     Udma_assert(drvHandle,
 944         chNum < (rmInitPrms->startTxUhcCh + rmInitPrms->numTxUhcCh));
 945     i = chNum - rmInitPrms->startTxUhcCh;
 946     offset = i >> 5U;
 947     Udma_assert(drvHandle, offset < UDMA_RM_TX_UHC_CH_ARR_SIZE);
 948     bitPos = i - (offset << 5U);
 949     bitMask = (uint32_t) 1U << bitPos;
 950     Udma_assert(drvHandle,
 951         (drvHandle->txUhcChFlag[offset] & bitMask) == 0U);
 952     drvHandle->txUhcChFlag[offset] |= bitMask;
 953
 954     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
 955     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
 956
 957     return;
 958 }
 959
 960 uint32_t Udma_rmAllocRxUhcCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle)
 961 {
 962     uint32_t            i, offset, bitPos, bitMask;
 963     uint32_t            chNum = UDMA_DMA_CH_INVALID;
 964     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
 965
 966     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
 967     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
 968
 969     if(UDMA_DMA_CH_ANY == preferredChNum)
 970     {
 971         /* Search and allocate from RX UHC channel pool */
 972         for(i = 0U; i < rmInitPrms->numRxUhcCh; i++)
 973         {
 974             offset = i >> 5U;
 975             Udma_assert(drvHandle, offset < UDMA_RM_RX_UHC_CH_ARR_SIZE);
 976             bitPos = i - (offset << 5U);
 977             bitMask = (uint32_t) 1U << bitPos;
 978             if((drvHandle->rxUhcChFlag[offset] & bitMask) == bitMask)
 979             {
 980                 drvHandle->rxUhcChFlag[offset] &= ~bitMask;
 981                 chNum = i + rmInitPrms->startRxUhcCh;  /* Add start offset */
 982                 break;
 983             }
 984         }
 985     }
 986     else
 987     {
 988         /* Allocate specific RX UHC channel if free */
 989         /* Array bound check */
 990         if((preferredChNum >= rmInitPrms->startRxUhcCh) &&
 991            (preferredChNum < (rmInitPrms->startRxUhcCh + rmInitPrms->numRxUhcCh)))
 992         {
 993             i = preferredChNum - rmInitPrms->startRxUhcCh;
 994             offset = i >> 5U;
 995             Udma_assert(drvHandle, offset < UDMA_RM_RX_UHC_CH_ARR_SIZE);
 996             bitPos = i - (offset << 5U);
 997             bitMask = (uint32_t) 1U << bitPos;
 998             if((drvHandle->rxUhcChFlag[offset] & bitMask) == bitMask)
 999             {
1000                 drvHandle->rxUhcChFlag[offset] &= ~bitMask;
1001                 chNum = preferredChNum;
1002             }
1003         }
1004     }
1005
1006     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1007     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1008
1009     return (chNum);
1010 }
1011
1012 void Udma_rmFreeRxUhcCh(uint32_t chNum, Udma_DrvHandle drvHandle)
1013 {
1014     uint32_t            i, offset, bitPos, bitMask;
1015     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1016
1017     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1018     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1019
1020     Udma_assert(drvHandle, chNum >= rmInitPrms->startRxUhcCh);
1021     Udma_assert(drvHandle,
1022         chNum < (rmInitPrms->startRxUhcCh + rmInitPrms->numRxUhcCh));
1023     i = chNum - rmInitPrms->startRxUhcCh;
1024     offset = i >> 5U;
1025     Udma_assert(drvHandle, offset < UDMA_RM_RX_UHC_CH_ARR_SIZE);
1026     bitPos = i - (offset << 5U);
1027     bitMask = (uint32_t) 1U << bitPos;
1028     Udma_assert(drvHandle,
1029         (drvHandle->rxUhcChFlag[offset] & bitMask) == 0U);
1030     drvHandle->rxUhcChFlag[offset] |= bitMask;
1031
1032     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1033     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1034
1035     return;
1036 }
1037
1038 uint32_t Udma_rmAllocExtCh(uint32_t preferredChNum,
1039                            Udma_DrvHandle drvHandle,
1040                            const Udma_UtcInstInfo *utcInfo)
1041 {
1042     uint32_t            chNum = UDMA_DMA_CH_INVALID;
1043     uint32_t            i, offset, bitPos, bitMask;
1044     uint32_t            utcId;
1045     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1046
1047     Udma_assert(drvHandle, utcInfo != NULL_PTR);
1048     utcId = utcInfo->utcId;
1049     Udma_assert(drvHandle, utcId <= UDMA_NUM_UTC_INSTANCE);
1050     Udma_assert(drvHandle,
1051         rmInitPrms->startUtcCh[utcId] >= utcInfo->startCh);
1052     Udma_assert(drvHandle,
1053         rmInitPrms->startUtcCh[utcId] < (utcInfo->startCh + utcInfo->numCh));
1054     Udma_assert(drvHandle,
1055         (rmInitPrms->startUtcCh[utcId] + rmInitPrms->numUtcCh[utcId]) <=
1056             (utcInfo->startCh + utcInfo->numCh));
1057
1058     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1059     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1060
1061     if(UDMA_DMA_CH_ANY == preferredChNum)
1062     {
1063         /* Search and allocate from specific external channel pool */
1064         for(i = 0U; i < rmInitPrms->numUtcCh[utcId]; i++)
1065         {
1066             offset = i >> 5U;
1067             Udma_assert(drvHandle, offset < UDMA_RM_UTC_CH_ARR_SIZE);
1068             bitPos = i - (offset << 5U);
1069             bitMask = (uint32_t) 1U << bitPos;
1070             if((drvHandle->utcChFlag[utcId][offset] & bitMask) == bitMask)
1071             {
1072                 drvHandle->utcChFlag[utcId][offset] &= ~bitMask;
1073                 chNum = i + rmInitPrms->startUtcCh[utcId];  /* Add start offset */
1074                 break;
1075             }
1076         }
1077     }
1078     else
1079     {
1080         if(preferredChNum < rmInitPrms->numUtcCh[utcId])
1081         {
1082             i = preferredChNum;
1083             offset = i >> 5U;
1084             Udma_assert(drvHandle, offset < UDMA_RM_UTC_CH_ARR_SIZE);
1085             bitPos = i - (offset << 5U);
1086             bitMask = (uint32_t) 1U << bitPos;
1087             if((drvHandle->utcChFlag[utcId][offset] & bitMask) == bitMask)
1088             {
1089                 drvHandle->utcChFlag[utcId][offset] &= ~bitMask;
1090                 chNum = preferredChNum + rmInitPrms->startUtcCh[utcId];
1091             }
1092         }
1093     }
1094
1095     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1096     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1097
1098     return (chNum);
1099 }
1100
1101 void Udma_rmFreeExtCh(uint32_t chNum,
1102                       Udma_DrvHandle drvHandle,
1103                       const Udma_UtcInstInfo *utcInfo)
1104 {
1105     uint32_t            i, offset, bitPos, bitMask;
1106     uint32_t            utcId;
1107     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1108
1109     Udma_assert(drvHandle, utcInfo != NULL_PTR);
1110     utcId = utcInfo->utcId;
1111
1112     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1113     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1114     Udma_assert(drvHandle, chNum >= rmInitPrms->startUtcCh[utcId]);
1115     Udma_assert(drvHandle,
1116         chNum < (rmInitPrms->startUtcCh[utcId] + rmInitPrms->numUtcCh[utcId]));
1117     i = chNum - rmInitPrms->startUtcCh[utcId];
1118     offset = i >> 5U;
1119     Udma_assert(drvHandle, offset < UDMA_RM_UTC_CH_ARR_SIZE);
1120     bitPos = i - (offset << 5U);
1121     bitMask = (uint32_t) 1U << bitPos;
1122     Udma_assert(drvHandle,
1123         (drvHandle->utcChFlag[utcId][offset] & bitMask) == 0U);
1124     drvHandle->utcChFlag[utcId][offset] |= bitMask;
1125
1126     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1127     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1128
1129     return;
1130 }
1131
1132 uint16_t Udma_rmAllocFreeRing(Udma_DrvHandle drvHandle)
1133 {
1134     uint16_t            i, offset, ringNum = UDMA_RING_INVALID, temp;
1135     uint32_t            bitPos, bitMask;
1136     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1137
1138     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1139     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1140
1141     for(i = 0U; i < rmInitPrms->numFreeRing; i++)
1142     {
1143         offset = i >> 5U;
1144         Udma_assert(drvHandle, offset < UDMA_RM_FREE_RING_ARR_SIZE);
1145         temp = i - (offset << 5U);
1146         bitPos = (uint32_t) temp;
1147         bitMask = (uint32_t) 1U << bitPos;
1148         if((drvHandle->freeRingFlag[offset] & bitMask) == bitMask)
1149         {
1150             drvHandle->freeRingFlag[offset] &= ~bitMask;
1151             ringNum = (uint16_t)rmInitPrms->startFreeRing;  /* Add start offset */
1152             ringNum += i;
1153             ringNum += (uint16_t)(drvHandle->udmapRegs.txChanCnt +
1154                                   drvHandle->udmapRegs.txExtUtcChanCnt +
1155                                   drvHandle->udmapRegs.rxChanCnt);
1156             break;
1157         }
1158     }
1159
1160     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1161     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1162
1163     return (ringNum);
1164 }
1165
1166 void Udma_rmFreeFreeRing(uint16_t ringNum, Udma_DrvHandle drvHandle)
1167 {
1168     uint32_t            i, offset, bitPos, bitMask;
1169     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1170     uint32_t            freeRingOffset = rmInitPrms->startFreeRing +
1171                                  drvHandle->udmapRegs.txChanCnt +
1172                                  drvHandle->udmapRegs.txExtUtcChanCnt +
1173                                  drvHandle->udmapRegs.rxChanCnt;
1174
1175     /* Free up only the free ring - ignore FQ rings */
1176     if(ringNum >= freeRingOffset)
1177     {
1178         Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1179         drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1180
1181         i = ringNum - freeRingOffset;
1182         offset = i >> 5U;
1183         Udma_assert(drvHandle, offset < UDMA_RM_FREE_RING_ARR_SIZE);
1184         bitPos = i - (offset << 5U);
1185         bitMask = (uint32_t) 1U << bitPos;
1186         Udma_assert(drvHandle, (drvHandle->freeRingFlag[offset] & bitMask) == 0U);
1187         drvHandle->freeRingFlag[offset] |= bitMask;
1188
1189         Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1190         drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1191     }
1192
1193     return;
1194 }
1195
1196 uint16_t Udma_rmAllocProxy(Udma_DrvHandle drvHandle)
1197 {
1198     uint16_t            i, offset, proxyNum = UDMA_PROXY_INVALID, temp;
1199     uint32_t            bitPos, bitMask;
1200     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1201
1202     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1203     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1204
1205     for(i = 0U; i < rmInitPrms->numProxy; i++)
1206     {
1207         offset = i >> 5U;
1208         Udma_assert(drvHandle, offset < UDMA_RM_PROXY_ARR_SIZE);
1209         temp = i - (offset << 5U);
1210         bitPos = (uint32_t) temp;
1211         bitMask = (uint32_t) 1U << bitPos;
1212         if((drvHandle->proxyFlag[offset] & bitMask) == bitMask)
1213         {
1214             drvHandle->proxyFlag[offset] &= ~bitMask;
1215             proxyNum = (uint16_t)rmInitPrms->startProxy;  /* Add start offset */
1216             proxyNum += i;
1217             break;
1218         }
1219     }
1220
1221     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1222     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1223
1224     return (proxyNum);
1225 }
1226
1227 void Udma_rmFreeProxy(uint16_t proxyNum, Udma_DrvHandle drvHandle)
1228 {
1229     uint32_t            i, offset, bitPos, bitMask;
1230     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1231
1232     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1233     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1234
1235     i = proxyNum - rmInitPrms->startProxy;
1236     offset = i >> 5U;
1237     Udma_assert(drvHandle, offset < UDMA_RM_PROXY_ARR_SIZE);
1238     bitPos = i - (offset << 5U);
1239     bitMask = (uint32_t) 1U << bitPos;
1240     Udma_assert(drvHandle, (drvHandle->proxyFlag[offset] & bitMask) == 0U);
1241     drvHandle->proxyFlag[offset] |= bitMask;
1242
1243     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1244     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1245
1246     return;
1247 }
1248
1249 uint32_t Udma_rmAllocEvent(Udma_DrvHandle drvHandle)
1250 {
1251     uint32_t            globalEvent = UDMA_EVENT_INVALID;
1252     uint32_t            i, offset, bitPos, bitMask;
1253     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1254
1255     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1256     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1257
1258     for(i = 0U; i < rmInitPrms->numGlobalEvent; i++)
1259     {
1260         offset = i >> 5U;
1261         Udma_assert(drvHandle, offset < UDMA_RM_GLOBAL_EVENT_ARR_SIZE);
1262         bitPos = i - (offset << 5U);
1263         bitMask = (uint32_t) 1U << bitPos;
1264         if((drvHandle->globalEventFlag[offset] & bitMask) == bitMask)
1265         {
1266             drvHandle->globalEventFlag[offset] &= ~bitMask;
1267             globalEvent = i + rmInitPrms->startGlobalEvent;  /* Add start offset */
1268             break;
1269         }
1270     }
1271
1272     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1273     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1274
1275     return (globalEvent);
1276 }
1277
1278 void Udma_rmFreeEvent(uint32_t globalEvent, Udma_DrvHandle drvHandle)
1279 {
1280     uint32_t            i, offset, bitPos, bitMask;
1281     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1282
1283     Udma_assert(drvHandle,
1284         globalEvent < (rmInitPrms->startGlobalEvent + rmInitPrms->numGlobalEvent));
1285     Udma_assert(drvHandle, globalEvent >= rmInitPrms->startGlobalEvent);
1286
1287     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1288     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1289
1290     i = globalEvent - rmInitPrms->startGlobalEvent;
1291     offset = i >> 5U;
1292     Udma_assert(drvHandle, offset < UDMA_RM_GLOBAL_EVENT_ARR_SIZE);
1293     bitPos = i - (offset << 5U);
1294     bitMask = (uint32_t) 1U << bitPos;
1295     Udma_assert(drvHandle, (drvHandle->globalEventFlag[offset] & bitMask) == 0U);
1296     drvHandle->globalEventFlag[offset] |= bitMask;
1297
1298     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1299     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1300
1301     return;
1302 }
1303
1304 uint32_t Udma_rmAllocVintr(Udma_DrvHandle drvHandle)
1305 {
1306     uint32_t            i, offset, bitPos, bitMask;
1307     uint32_t            vintrNum = UDMA_EVENT_INVALID;
1308     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1309
1310     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1311     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1312
1313     for(i = 0U; i < rmInitPrms->numVintr; i++)
1314     {
1315         offset = i >> 5U;
1316         Udma_assert(drvHandle, offset < UDMA_RM_VINTR_ARR_SIZE);
1317         bitPos = i - (offset << 5U);
1318         bitMask = (uint32_t) 1U << bitPos;
1319         if((drvHandle->vintrFlag[offset] & bitMask) == bitMask)
1320         {
1321             drvHandle->vintrFlag[offset] &= ~bitMask;
1322             vintrNum = i + rmInitPrms->startVintr;  /* Add start offset */
1323             break;
1324         }
1325     }
1326
1327     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1328     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1329
1330     return (vintrNum);
1331 }
1332
1333 void Udma_rmFreeVintr(uint32_t vintrNum, Udma_DrvHandle drvHandle)
1334 {
1335     uint32_t            i, offset, bitPos, bitMask;
1336     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1337
1338     Udma_assert(drvHandle,
1339         vintrNum < (rmInitPrms->startVintr + rmInitPrms->numVintr));
1340     Udma_assert(drvHandle, vintrNum >= rmInitPrms->startVintr);
1341
1342     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1343     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1344
1345     i = vintrNum - rmInitPrms->startVintr;
1346     offset = i >> 5U;
1347     Udma_assert(drvHandle, offset < UDMA_RM_VINTR_ARR_SIZE);
1348     bitPos = i - (offset << 5U);
1349     bitMask = (uint32_t) 1U << bitPos;
1350     Udma_assert(drvHandle, (drvHandle->vintrFlag[offset] & bitMask) == 0U);
1351     drvHandle->vintrFlag[offset] |= bitMask;
1352
1353     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1354     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1355
1356     return;
1357 }
1358
1359 uint32_t Udma_rmAllocVintrBit(Udma_EventHandle eventHandle)
1360 {
1361     uint32_t                i;
1362     uint32_t                vintrBitNum = UDMA_EVENT_INVALID;
1363     uint64_t                bitMask;
1364     Udma_EventHandle        masterEventHandle;
1365     const Udma_EventPrms   *eventPrms;
1366     Udma_DrvHandle          drvHandle = eventHandle->drvHandle;
1367
1368     masterEventHandle = eventHandle;
1369     eventPrms = &eventHandle->eventPrms;
1370     if(NULL_PTR != eventPrms->masterEventHandle)
1371     {
1372         /* Shared event. Get the master handle */
1373         masterEventHandle = eventPrms->masterEventHandle;
1374     }
1375
1376     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1377     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1378
1379     for(i = 0U; i < UDMA_MAX_EVENTS_PER_VINTR; i++)
1380     {
1381         bitMask = ((uint64_t) 1U << i);
1382         if((masterEventHandle->vintrBitAllocFlag & bitMask) == 0U)
1383         {
1384             masterEventHandle->vintrBitAllocFlag |= bitMask;
1385             vintrBitNum = i;
1386             break;
1387         }
1388     }
1389
1390     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1391     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1392
1393     return (vintrBitNum);
1394 }
1395
1396 void Udma_rmFreeVintrBit(uint32_t vintrBitNum,
1397                          Udma_DrvHandle drvHandle,
1398                          Udma_EventHandle eventHandle)
1399 {
1400     uint64_t                bitMask;
1401     Udma_EventHandle        masterEventHandle;
1402     const Udma_EventPrms   *eventPrms;
1403
1404     masterEventHandle = eventHandle;
1405     eventPrms = &eventHandle->eventPrms;
1406     if(NULL_PTR != eventPrms->masterEventHandle)
1407     {
1408         /* Shared event. Get the master handle */
1409         masterEventHandle = eventPrms->masterEventHandle;
1410     }
1411
1412     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1413     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1414
1415     Udma_assert(drvHandle, vintrBitNum < UDMA_MAX_EVENTS_PER_VINTR);
1416     bitMask = ((uint64_t) 1U << vintrBitNum);
1417     Udma_assert(drvHandle,
1418         (masterEventHandle->vintrBitAllocFlag & bitMask) == bitMask);
1419     masterEventHandle->vintrBitAllocFlag &= ~bitMask;
1420
1421     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1422     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1423
1424     return;
1425 }
1426
1427 uint32_t Udma_rmAllocCoreIntr(uint32_t preferredCoreIntrNum,
1428                               Udma_DrvHandle drvHandle)
1429 {
1430     uint32_t            i, offset, bitPos, bitMask;
1431     uint32_t            coreIntrNum = UDMA_INTR_INVALID;
1432     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1433
1434     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1435     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1436
1437     if(UDMA_CORE_INTR_ANY == preferredCoreIntrNum)
1438     {
1439         /* Search and allocate from pool */
1440         for(i = 0U; i < rmInitPrms->numIrIntr; i++)
1441         {
1442             offset = i >> 5U;
1443             Udma_assert(drvHandle, offset < UDMA_RM_CORE_INTR_ARR_SIZE);
1444             bitPos = i - (offset << 5U);
1445             bitMask = (uint32_t) 1U << bitPos;
1446             if((drvHandle->coreIntrFlag[offset] & bitMask) == bitMask)
1447             {
1448                 drvHandle->coreIntrFlag[offset] &= ~bitMask;
1449                 coreIntrNum = i + rmInitPrms->startIrIntr;    /* Add start offset */
1450                 break;
1451             }
1452         }
1453     }
1454     else
1455     {
1456         /* Allocate specific core interrupt number if free */
1457         /* Array bound check */
1458         if((preferredCoreIntrNum >= rmInitPrms->startIrIntr) &&
1459            (preferredCoreIntrNum < (rmInitPrms->startIrIntr + rmInitPrms->numIrIntr)))
1460         {
1461             i = preferredCoreIntrNum - rmInitPrms->startIrIntr;
1462             offset = i >> 5U;
1463             Udma_assert(drvHandle, offset < UDMA_RM_CORE_INTR_ARR_SIZE);
1464             bitPos = i - (offset << 5U);
1465             bitMask = (uint32_t) 1U << bitPos;
1466             if((drvHandle->coreIntrFlag[offset] & bitMask) == bitMask)
1467             {
1468                 drvHandle->coreIntrFlag[offset] &= ~bitMask;
1469                 coreIntrNum = preferredCoreIntrNum;
1470             }
1471         }
1472     }
1473
1474     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1475     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1476
1477     return (coreIntrNum);
1478 }
1479
1480 void Udma_rmFreeCoreIntr(uint32_t coreIntrNum, Udma_DrvHandle drvHandle)
1481 {
1482     uint32_t            i, offset, bitPos, bitMask;
1483     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1484
1485     Udma_assert(drvHandle,
1486         coreIntrNum < (rmInitPrms->startIrIntr + rmInitPrms->numIrIntr));
1487     Udma_assert(drvHandle, coreIntrNum >= rmInitPrms->startIrIntr);
1488
1489     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1490     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1491
1492     i = coreIntrNum - rmInitPrms->startIrIntr;
1493     offset = i >> 5U;
1494     Udma_assert(drvHandle, offset < UDMA_RM_CORE_INTR_ARR_SIZE);
1495     bitPos = i - (offset << 5U);
1496     bitMask = (uint32_t) 1U << bitPos;
1497     Udma_assert(drvHandle, (drvHandle->coreIntrFlag[offset] & bitMask) == 0U);
1498     drvHandle->coreIntrFlag[offset] |= bitMask;
1499
1500     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1501     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1502
1503     return;
1504 }
1505
1506 uint16_t Udma_rmAllocRingMon(Udma_DrvHandle drvHandle)
1507 {
1508     uint16_t            i, offset, ringMonNum = UDMA_RING_MON_INVALID, temp;
1509     uint32_t            bitPos, bitMask;
1510     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1511
1512     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1513     drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1514
1515     for(i = 0U; i < rmInitPrms->numRingMon; i++)
1516     {
1517         offset = i >> 5U;
1518         Udma_assert(drvHandle, offset < UDMA_RM_RING_MON_ARR_SIZE);
1519         temp = i - (offset << 5U);
1520         bitPos = (uint32_t) temp;
1521         bitMask = (uint32_t) 1U << bitPos;
1522         if((drvHandle->ringMonFlag[offset] & bitMask) == bitMask)
1523         {
1524             drvHandle->ringMonFlag[offset] &= ~bitMask;
1525             ringMonNum = (uint16_t)rmInitPrms->startRingMon;  /* Add start offset */
1526             ringMonNum += i;
1527             break;
1528         }
1529     }
1530
1531     Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1532     drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1533
1534     return (ringMonNum);
1535 }
1536
1537 void Udma_rmFreeRingMon(uint16_t ringMonNum, Udma_DrvHandle drvHandle)
1538 {
1539     uint32_t            i, offset, bitPos, bitMask;
1540     Udma_RmInitPrms    *rmInitPrms = &drvHandle->initPrms.rmInitPrms;
1541     uint32_t            ringMonOffset = rmInitPrms->startRingMon;
1542
1543     if(ringMonNum >= ringMonOffset)
1544     {
1545         Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.lockMutex != (Udma_OsalMutexLockFxn) NULL_PTR);
1546         drvHandle->initPrms.osalPrms.lockMutex(drvHandle->rmLock);
1547
1548         i = ringMonNum - ringMonOffset;
1549         offset = i >> 5U;
1550         Udma_assert(drvHandle, offset < UDMA_RM_RING_MON_ARR_SIZE);
1551         bitPos = i - (offset << 5U);
1552         bitMask = (uint32_t) 1U << bitPos;
1553         Udma_assert(drvHandle, (drvHandle->ringMonFlag[offset] & bitMask) == 0U);
1554         drvHandle->ringMonFlag[offset] |= bitMask;
1555
1556         Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.unlockMutex != (Udma_OsalMutexUnlockFxn) NULL_PTR);
1557         drvHandle->initPrms.osalPrms.unlockMutex(drvHandle->rmLock);
1558     }
1559
1560     return;
1561 }
1562
1563 static int32_t Udma_rmCheckResLeak(Udma_DrvHandle drvHandle,
1564                                    const uint32_t *allocFlag,
1565                                    uint32_t numRes,
1566                                    uint32_t arrSize)
1567 {
1568     int32_t     retVal = UDMA_SOK;
1569     uint32_t    i, offset, bitMask;
1570
1571     offset = 0;
1572     i = numRes;
1573     while(i > 0U)
1574     {
1575         if(i >= (uint32_t)32U)          /* 32 resource per array element */
1576         {
1577             bitMask = (uint32_t) 0xFFFFFFFFU;
1578             i -= 32U;
1579         }
1580         else
1581         {
1582             bitMask = ((uint32_t)1U << i) - ((uint32_t)1U);
1583             i = 0U;
1584         }
1585
1586         Udma_assert(drvHandle, offset < arrSize);
1587         if((allocFlag[offset] & bitMask) != bitMask)
1588         {
1589             retVal = UDMA_EFAIL;        /* Some resources not freed */
1590             break;
1591         }
1592         offset++;
1593     }
1594
1595     return (retVal);
1596 }