pdk_k2g_1_0_1/packages/ti/csl/arch/a15/src/interrupt.c

   1 /*
   2  *  Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
   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   interrupt.c
  36  *
  37  *  \brief  Interrupt related APIs.
  38  *
  39  *   This file contains the APIs for configuring AINTC
  40  */
  41
  42 /* ========================================================================== */
  43 /*                             Include Files                                  */
  44 /* ========================================================================== */
  45 #include <stdint.h>
  46 #include <stddef.h>
  47 #include <ti/csl/arch/csl_arch.h>
  48 #include <interrupt.h>
  49 #include <ti/csl/csl_types.h>
  50 #include <ti/csl/hw_types.h>
  51 #include <ti/csl/soc.h>
  52 #include <ti/csl/arch/csl_arch.h>
  53 #include <ti/csl/csl_a15.h>
  54 #include <ti/csl/arch/csl_arch.h>
  55
  56 /* ========================================================================== */
  57 /*                                 Macros & typedefs                          */
  58 /* ========================================================================== */
  59 #define REG_IDX_SHIFT                  (0x05U)
  60 #define REG_BIT_MASK                   (0x1FU)
  61
  62 #define NUM_GICD_ENABLE_REGS    6U
  63 #define NUM_BYTES_REG           4U
  64 #define BINARY_POINT_REG_VAL    0x03
  65 #define PRIORITY_MASK_REG_VAL   0xF0
  66
  67 /* ========================================================================== */
  68 /*                            Global Variables                                */
  69 /* ========================================================================== */
  70 IntrFuncPtr fnRAMVectors[NUM_INTERRUPTS];
  71 void       *argArray[NUM_INTERRUPTS] = {0};
  72 /* This change is done as ADDR_IAR & ADDR_EOI macro from hw_intc.h
  73    has an address appended with U(unsigned) which is not
  74    allowed in asm file. */
  75 const uint32_t addrIar = ADDR_IAR;
  76 const uint32_t addrEoi = ADDR_EOI;
  77
  78 /* ========================================================================== */
  79 /*                 Internal Function Declarations                             */
  80 /* ========================================================================== */
  81 static void IntDefaultHandler(void *dummy);
  82 extern void CopyVectorTable(void);
  83
  84 /* ========================================================================== */
  85 /*                          Function Definitions                              */
  86 /* ========================================================================== */
  87
  88 /**
  89  *
  90  * The Default Interrupt Handler.
  91  *
  92  * This is the default interrupt handler for all interrupts.  It simply loops
  93  * forever so that the system state is preserved for observation by a
  94  * debugger.  Since interrupts should be disabled before unregistering the
  95  * corresponding handler, this should never be called.
  96  *
  97  *
  98  **/
  99 static void IntDefaultHandler(void *dummy)
 100 {
 101     /* Go into an infinite loop.*/
 102     volatile uint32_t loop = 1U;
 103     while (1U == loop)
 104     {
 105         ;
 106     }
 107 }
 108
 109 void Intc_IntRegister(uint16_t intrNum, IntrFuncPtr fptr, void *fun_arg)
 110 {
 111     /* Assign ISR */
 112     fnRAMVectors[intrNum] = fptr;
 113     argArray[intrNum]     = fun_arg;
 114 }
 115
 116 void Intc_IntUnregister(uint16_t intrNum)
 117 {
 118     uint32_t IntDefaultHandler_t = (uint32_t) (&IntDefaultHandler);
 119     /* Assign default ISR */
 120     fnRAMVectors[intrNum] = (IntrFuncPtr) IntDefaultHandler_t;
 121     argArray[intrNum]     = NULL;
 122 }
 123
 124 void Intc_Init(void)
 125 {
 126     uint32_t intActiveReg = 0;
 127     uint32_t i, j;
 128
 129     /*Initialize vector table*/
 130     CopyVectorTable();
 131
 132     /*
 133      * Disable forwarding of interrupts in GIC Distributor and CPU interface
 134      * Controller.
 135      */
 136     HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE + MPU_GICD_DCR, 0);
 137     HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_ICR, 0);
 138
 139     /*
 140      * Disable all interrupts at startup
 141      */
 142     for (i = 0U; i < NUM_GICD_ENABLE_REGS; i++)
 143     {
 144         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 145                     (MPU_GICD_ICER0 + (NUM_BYTES_REG * i)), 0xFFFFFFFFU);
 146     }
 147
 148     /*
 149      * Disable all wakeup events at startup
 150      */
 151     MPU_WUGEN_Init();
 152
 153     /*
 154      * Enable forwarding of both secure and non secure interrupts in GIC
 155      * Distributor and CPU interface
 156      * Controller.
 157      */
 158 /*    HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE + MPU_GICD_DCR,
 159  *          (MPU_GICD_DCR__ENABLENS | MPU_GICD_DCR_ENABLES_MASK));
 160  *  HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_ICR,
 161  *          (MPU_GICC_ICR_ENABLES_MASK | MPU_GICC_ICR__ENABLENS |
 162  *                  MPU_GICC_ICR__ACKCTL | MPU_GICC_ICR__SBPR));
 163  */
 164     HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 165                 MPU_GICD_DCR, MPU_GICD_DCR_ENABLES_MASK);
 166     HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE +
 167                 MPU_GICC_ICR, MPU_GICC_ICR_ENABLES_MASK);
 168
 169     /* Search for any previously active interrupts and acknowledge them */
 170     for (i = 0; i < NUM_GICD_ENABLE_REGS; i++)
 171     {
 172         intActiveReg =
 173             HW_RD_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 174                         (MPU_GICD_ISACTIVER0 + (NUM_BYTES_REG * i)));
 175
 176         if (intActiveReg)
 177         {
 178             for (j = 0U; j < 32U; j++)
 179             {
 180                 if (intActiveReg & 0x1U)
 181                 {
 182                     HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE +
 183                                 MPU_GICC_EOIR, (i * 32U) + j);
 184                 }
 185                 intActiveReg = intActiveReg >> 1;
 186             }
 187         }
 188     }
 189
 190     /*
 191      * Clear any currently pending enabled interrupts
 192      *
 193      * Note: SGIs are always enabled
 194      */
 195     for (i = 0U; i < 4U; i++)
 196     {
 197         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 198                     (MPU_GICD_CPENDSGIR0 + (NUM_BYTES_REG * i)), 0x01010101);
 199     }
 200
 201     for (i = 0; i < NUM_GICD_ENABLE_REGS; i++)
 202     {
 203         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 204                     (MPU_GICD_ICPR0 + (NUM_BYTES_REG * i)), 0xFFFFFFFFU);
 205     }
 206
 207     /*
 208      * Clear all interrupt active status registers
 209      */
 210     for (i = 0; i < NUM_GICD_ENABLE_REGS; i++) {
 211         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 212                     (MPU_GICD_ICACTIVER0 + (NUM_BYTES_REG * i)), 0xFFFFFFFFU);
 213     }
 214
 215     /*
 216      * Set MPU0 as the target processor for all interrupts.
 217      *
 218      */
 219     for (i = 0U; i < 48U; i++) {
 220         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 221                     (MPU_GICD_IPTR0 + (NUM_BYTES_REG * i)), 0x01010101);
 222     }
 223
 224     /*
 225      * Initialize Binary Point Register
 226      */
 227     HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_BPR,
 228                 BINARY_POINT_REG_VAL);
 229
 230     /*
 231      * Initialize Priority mast register
 232      */
 233     HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_PMR,
 234                 PRIORITY_MASK_REG_VAL);
 235
 236     /*configure interrupts to level-sensitive interrupt type and 1-N model */
 237     for (i = 0U; i < 12U; i++)
 238     {
 239         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 240                     (MPU_GICD_ICFR0 + (NUM_BYTES_REG * i)), 0xFFFFFFFFU);
 241     }
 242 }
 243
 244 void Intc_IntPrioritySet(uint16_t intrNum, uint16_t priority,
 245                          uint8_t hostIntRoute)
 246 {
 247     uint32_t index, mask;
 248
 249     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 250     {
 251         index = ((uint32_t) intrNum >> 2) + 1U;
 252         mask  = (uint32_t) intrNum % 4U;
 253
 254         /*Sets the priority of shared peripheral interrupt*/
 255         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 256                     (MPU_GICD_IPR0 + (NUM_BYTES_REG * index)),
 257                     ((priority & (uint32_t) 0xFF) << (mask * 8U)));
 258     }
 259 }
 260
 261 void Intc_SystemEnable(uint16_t intrNum)
 262 {
 263     uint32_t index, mask, shift;
 264     uint32_t addr, target_cpus;
 265
 266     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 267     {
 268         index = ((uint32_t) intrNum >> REG_IDX_SHIFT) + 1U;
 269         mask  = ((uint32_t) 1) << ((uint32_t) intrNum & REG_BIT_MASK);
 270
 271         /* Enable the system interrupt for interrupt number passed */
 272         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 273                     (MPU_GICD_ISER0 + (NUM_BYTES_REG * index)), mask);
 274
 275         index = (uint32_t) intrNum >> 2;
 276         shift = ((uint32_t) ((uint32_t) intrNum & 3U) << 3);
 277         mask  = 0xffU << shift;
 278         addr  = SOC_INTC_MPU_DISTRIBUTOR_BASE +
 279                 (MPU_GICD_IPTR8 + (NUM_BYTES_REG * index));
 280         target_cpus = HW_RD_FIELD32_RAW(addr,
 281                                         mask,
 282                                         shift);
 283         switch (target_cpus)
 284         {
 285             case 1U:
 286                 MPU_WUGEN_0_Enable(intrNum);
 287                 break;
 288             case 2U:
 289                 MPU_WUGEN_1_Enable(intrNum);
 290                 break;
 291             case 3U:
 292                 MPU_WUGEN_0_Enable(intrNum);
 293                 MPU_WUGEN_1_Enable(intrNum);
 294                 break;
 295             default:
 296                 MPU_WUGEN_0_Enable(intrNum);
 297                 break;
 298         }
 299     }
 300 }
 301
 302 void Intc_SystemDisable(uint16_t intrNum)
 303 {
 304     uint32_t index, mask, shift;
 305     uint32_t addr, target_cpus;
 306
 307     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 308     {
 309         index = ((uint32_t) intrNum >> REG_IDX_SHIFT) + 1U;
 310         mask  = ((uint32_t) 1) << ((uint32_t) intrNum & REG_BIT_MASK);
 311
 312         /* Disable the system interrupt for interrupt number passed */
 313         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 314                     (MPU_GICD_ICER0 + (NUM_BYTES_REG * index)), mask);
 315
 316         index = (uint32_t) intrNum >> 2;
 317         shift = ((uint32_t) ((uint32_t) intrNum & 3U) << 3);
 318         mask  = 0xffU << shift;
 319         addr  = SOC_INTC_MPU_DISTRIBUTOR_BASE +
 320                 (MPU_GICD_IPTR8 + (NUM_BYTES_REG * index));
 321         target_cpus = HW_RD_FIELD32_RAW(addr,
 322                                         mask,
 323                                         shift);
 324         switch (target_cpus)
 325         {
 326             case 1U:
 327                 MPU_WUGEN_0_Disable(intrNum);
 328                 break;
 329             case 2U:
 330                 MPU_WUGEN_1_Disable(intrNum);
 331                 break;
 332             case 3U:
 333                 MPU_WUGEN_0_Disable(intrNum);
 334                 MPU_WUGEN_1_Disable(intrNum);
 335                 break;
 336             default:
 337                 MPU_WUGEN_0_Disable(intrNum);
 338                 break;
 339         }
 340     }
 341 }
 342
 343 void IntEnableSecureMode(uint32_t intrNum)
 344 {
 345     uint32_t index, mask;
 346     uint32_t tmpVar;
 347
 348     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 349     {
 350         index = (intrNum >> REG_IDX_SHIFT) + 1U;
 351
 352         mask = ~((uint32_t) 1U << (intrNum & (uint32_t) 0x1fU));
 353
 354         /* Enable secure mode for interrupt number passed */
 355         tmpVar = HW_RD_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 356                              (MPU_GICD_ISR0 + (NUM_BYTES_REG * index)));
 357         tmpVar &= mask;
 358         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 359                     (MPU_GICD_ISR0 + (NUM_BYTES_REG * index)), tmpVar);
 360     }
 361 }
 362
 363 void IntDisableSecureMode(uint32_t intrNum)
 364 {
 365     uint32_t index, mask;
 366     uint32_t tmpVar;
 367
 368     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 369     {
 370         index = (intrNum >> REG_IDX_SHIFT) + 1U;
 371
 372         mask = (uint32_t) 1 << (intrNum & (uint32_t) 0x1f);
 373
 374         /* Disable secure mode for interrupt number passed */
 375         tmpVar = HW_RD_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 376                              (MPU_GICD_ISR0 + (NUM_BYTES_REG * index)));
 377         tmpVar |= mask;
 378         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 379                     (MPU_GICD_ISR0 + (NUM_BYTES_REG * index)), tmpVar);
 380     }
 381 }
 382
 383 void IntSetPendingState(uint32_t intrNum)
 384 {
 385     uint32_t index, mask;
 386
 387     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 388     {
 389         index = (intrNum >> REG_IDX_SHIFT) + 1U;
 390         mask  = ((uint32_t) 1) << (intrNum & REG_BIT_MASK);
 391
 392         /* Set the interrupt status to pending for the interrupt number passed*/
 393         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 394                     (MPU_GICD_ISPR0 + (NUM_BYTES_REG * index)), mask);
 395     }
 396 }
 397
 398 void IntClearPendingState(uint32_t intrNum)
 399 {
 400     uint32_t index, mask;
 401
 402     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 403     {
 404         index = (intrNum >> REG_IDX_SHIFT) + 1U;
 405         mask  = ((uint32_t) 1) << (intrNum & REG_BIT_MASK);
 406
 407         /* Clear the interrupt pending status for the interrupt number passed */
 408         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 409                     (MPU_GICD_ICPR0 + (NUM_BYTES_REG * index)), mask);
 410     }
 411 }
 412
 413 uint32_t IntGetPendingState(uint32_t intrNum)
 414 {
 415     uint32_t state = 0U;
 416     uint32_t index, mask;
 417
 418     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 419     {
 420         index = (intrNum >> REG_IDX_SHIFT) + 1U;
 421         mask  = ((uint32_t) 1) << (intrNum & REG_BIT_MASK);
 422
 423         /* Clear the interrupt pending status for the interrupt number passed */
 424         state = (HW_RD_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 425                             (MPU_GICD_ISPR0 + (NUM_BYTES_REG * index))) & mask);
 426     }
 427
 428     return (state);
 429 }
 430
 431 uint32_t IntGetActiveState(uint32_t intrNum)
 432 {
 433     uint32_t state = 0U;
 434     uint32_t index, mask;
 435
 436     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 437     {
 438         index = (intrNum >> REG_IDX_SHIFT) + 1U;
 439         mask  = ((uint32_t) 1) << (intrNum & REG_BIT_MASK);
 440
 441         /* Clear the interrupt pending status for the interrupt number passed */
 442         state = (HW_RD_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 443                             (MPU_GICD_ISACTIVER0 +
 444                              (NUM_BYTES_REG * index))) & mask);
 445     }
 446
 447     return (state);
 448 }
 449
 450 void IntClearActiveState(uint32_t intrNum)
 451 {
 452     uint32_t index, mask;
 453
 454     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 455     {
 456         index = (intrNum >> REG_IDX_SHIFT) + 1U;
 457         mask  = ((uint32_t) 1) << (intrNum & REG_BIT_MASK);
 458
 459         /* Clear the interrupt pending status for the interrupt number passed */
 460         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 461                     (MPU_GICD_ICACTIVER0 + (NUM_BYTES_REG * index)), mask);
 462     }
 463 }
 464
 465 void IntSetTargetProcessor(uint32_t intrNum, uint32_t processorSelect)
 466 {
 467     uint32_t index, mask;
 468     uint32_t tmpVar;
 469
 470     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 471     {
 472         index = (intrNum >> 2) + 1U;
 473         mask  = intrNum % 4U;
 474
 475         tmpVar = HW_RD_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 476                              (MPU_GICD_IPTR0 + (NUM_BYTES_REG * index)));
 477         tmpVar |= ((processorSelect & (uint32_t) 0x03) << (mask * 8U));
 478         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 479                     (MPU_GICD_IPTR0 + (NUM_BYTES_REG * index)), tmpVar);
 480     }
 481 }
 482
 483 void IntConfigTypenModel(uint32_t intrNum, uint32_t intType,
 484                          uint32_t intHandleModel)
 485 {
 486     uint32_t index, mask;
 487     uint32_t tmpVar;
 488
 489     if (intrNum < NUM_INTERRUPTS_EXTERNAL)
 490     {
 491         index = intrNum / 16U;
 492         mask  = intrNum % 16U;
 493
 494         tmpVar = HW_RD_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 495                              (MPU_GICD_ICFR0 + (NUM_BYTES_REG * index)));
 496         tmpVar &= ~(MPU_GICD_ICFR0_INT_CONFIG_FIELD_0_MASK << (mask * 2U));
 497         tmpVar |= ((((intType & 0x01U) << 1) |
 498                     (intHandleModel & 0x01U)) << (mask * 2U));
 499         HW_WR_REG32(SOC_INTC_MPU_DISTRIBUTOR_BASE +
 500                     (MPU_GICD_ICFR0 + (NUM_BYTES_REG * index)), tmpVar);
 501     }
 502 }
 503
 504 void IntEnableSecureFIQ(uint32_t intRoute)
 505 {
 506     uint32_t tmpVar;
 507     if (AINTC_HOSTINT_ROUTE_FIQ == intRoute)
 508     {
 509         tmpVar  = HW_RD_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_ICR);
 510         tmpVar |= MPU_GICC_ICR_FIQEN_MASK;
 511         HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_ICR, tmpVar);
 512     }
 513     else
 514     {
 515         tmpVar  = HW_RD_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_ICR);
 516         tmpVar &= (~MPU_GICC_ICR_FIQEN_MASK);
 517         HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_ICR, tmpVar);
 518     }
 519 }
 520
 521 void IntSetProirityMask(uint32_t priorityMask)
 522 {
 523     HW_WR_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE +
 524                 MPU_GICC_PMR, (priorityMask & MPU_GICC_PMR_PRIORITY_MASK));
 525 }
 526
 527 uint32_t IntGetProirityMask(void)
 528 {
 529     return (HW_RD_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE +
 530                         MPU_GICC_PMR) & MPU_GICC_PMR_PRIORITY_MASK);
 531 }
 532
 533 uint32_t IntGetActivePriority(void)
 534 {
 535     return (HW_RD_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_RPR));
 536 }
 537
 538 uint32_t IntGetPendingIntNum(void)
 539 {
 540     return (HW_RD_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE +
 541                         MPU_GICC_HPIR) & MPU_GICC_HPIR_PENDINTID_MASK);
 542 }
 543
 544 uint32_t IntGetPendingCPUID(void)
 545 {
 546     uint32_t tmpVar;
 547     tmpVar = HW_RD_REG32(SOC_INTC_MPU_PHYS_CPU_IF_BASE + MPU_GICC_HPIR);
 548     tmpVar = (tmpVar & MPU_GICC_HPIR_CPUID_MASK) >> MPU_GICC_HPIR_CPUID_SHIFT;
 549     return (tmpVar);
 550 }
 551
 552 void IntMasterIRQEnable(void)
 553 {
 554     /* Enable IRQ in CPSR.*/
 555     CSL_a15EnableIrq();
 556 }
 557
 558 void IntMasterIRQDisable(void)
 559 {
 560     /* Disable IRQ in CPSR.*/
 561     CSL_a15DisableIrq();
 562 }
 563
 564 void IntMasterFIQEnable(void)
 565 {
 566     /* Enable FIQ in CPSR.*/
 567     CSL_a15EnableFiq();
 568 }
 569
 570 void IntMasterFIQDisable(void)
 571 {
 572     /* Disable FIQ in CPSR.*/
 573     CSL_a15DisableFiq();
 574 }
 575
 576 uint32_t IntMasterStatusGet(void)
 577 {
 578     return CSL_a15IntrStatus();
 579 }
 580
 581 uint8_t Intc_IntDisable(void)
 582 {
 583     uint8_t status;
 584
 585     /* Reads the current status.*/
 586     status = (uint8_t) (IntMasterStatusGet() & 0xFFU);
 587
 588     /* Disable the Interrupts.*/
 589     IntMasterIRQDisable();
 590
 591     return status;
 592 }
 593
 594 void Intc_IntEnable(uint8_t status)
 595 {
 596     if ((status & 0x80U) == 0)
 597     {
 598         IntMasterIRQEnable();
 599     }
 600 }
 601
 602 void Intc_AbortHandler(void)
 603 {
 604     if (0U != fnRAMVectors[INTERNAL_INTERRUPT_ABORT_ID])
 605     {
 606         fnRAMVectors[INTERNAL_INTERRUPT_ABORT_ID]
 607             (argArray[INTERNAL_INTERRUPT_ABORT_ID]);
 608     }
 609     else
 610     {
 611         /* Go into an infinite loop.*/
 612         volatile uint32_t loop = 1U;
 613         while (1U == loop)
 614         {
 615             ;
 616         }
 617     }
 618 }
 619 /********************************** End Of File ******************************/