tmk_core/tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_RENESAS/TARGET_RZ_A1H/gic.h

   1 /**************************************************************************//**
   2  * @file     gic.h
   3  * @brief    Implementation of GIC functions declared in CMSIS Cortex-A9 Core Peripheral Access Layer Header File
   4  * @version
   5  * @date     29 August 2013
   6  *
   7  * @note
   8  *
   9  ******************************************************************************/
  10 /* Copyright (c) 2011 - 2013 ARM LIMITED
  11
  12    All rights reserved.
  13    Redistribution and use in source and binary forms, with or without
  14    modification, are permitted provided that the following conditions are met:
  15    - Redistributions of source code must retain the above copyright
  16      notice, this list of conditions and the following disclaimer.
  17    - Redistributions in binary form must reproduce the above copyright
  18      notice, this list of conditions and the following disclaimer in the
  19      documentation and/or other materials provided with the distribution.
  20    - Neither the name of ARM nor the names of its contributors may be used
  21      to endorse or promote products derived from this software without
  22      specific prior written permission.
  23    *
  24    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27    ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
  28    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34    POSSIBILITY OF SUCH DAMAGE.
  35    ---------------------------------------------------------------------------*/
  36
  37 #ifndef GIC_H_
  38 #define GIC_H_
  39
  40 /* IO definitions (access restrictions to peripheral registers) */
  41 /**
  42 */
  43 #ifdef __cplusplus
  44   #define   __I     volatile             /*!< Defines 'read only' permissions                 */
  45 #else
  46   #define   __I     volatile const       /*!< Defines 'read only' permissions                 */
  47 #endif
  48 #define     __O     volatile             /*!< Defines 'write only' permissions                */
  49 #define     __IO    volatile             /*!< Defines 'read / write' permissions              */
  50
  51 /** \brief  Structure type to access the Generic Interrupt Controller Distributor (GICD)
  52  */
  53 typedef struct
  54 {
  55   __IO uint32_t ICDDCR;
  56   __I  uint32_t ICDICTR;
  57   __I  uint32_t ICDIIDR;
  58        uint32_t RESERVED0[29];
  59   __IO uint32_t ICDISR[32];
  60   __IO uint32_t ICDISER[32];
  61   __IO uint32_t ICDICER[32];
  62   __IO uint32_t ICDISPR[32];
  63   __IO uint32_t ICDICPR[32];
  64   __I  uint32_t ICDABR[32];
  65        uint32_t RESERVED1[32];
  66   __IO uint32_t ICDIPR[256];
  67   __IO uint32_t ICDIPTR[256];
  68   __IO uint32_t ICDICFR[64];
  69        uint32_t RESERVED2[128];
  70   __IO uint32_t ICDSGIR;
  71 }  GICDistributor_Type;
  72
  73 /** \brief  Structure type to access the Controller Interface (GICC)
  74  */
  75 typedef struct
  76 {
  77   __IO uint32_t ICCICR;          // +0x000 - RW - CPU Interface Control Register
  78   __IO uint32_t ICCPMR;          // +0x004 - RW - Interrupt Priority Mask Register
  79   __IO uint32_t ICCBPR;          // +0x008 - RW - Binary Point Register
  80   __I  uint32_t ICCIAR;          // +0x00C - RO - Interrupt Acknowledge Register
  81   __IO uint32_t ICCEOIR;         // +0x010 - WO - End of Interrupt Register
  82   __I  uint32_t ICCRPR;          // +0x014 - RO - Running Priority Register
  83   __I  uint32_t ICCHPIR;         // +0x018 - RO - Highest Pending Interrupt Register
  84   __IO uint32_t ICCABPR;         // +0x01C - RW - Aliased Binary Point Register
  85
  86        uint32_t RESERVED[55];
  87
  88   __I  uint32_t ICCIIDR;         // +0x0FC - RO - CPU Interface Identification Register
  89 }  GICInterface_Type;
  90
  91 /*@} end of GICD */
  92
  93 /* ##########################   GIC functions  #################################### */
  94 /**  \brief      Functions that manage interrupts via the GIC.
  95   @{
  96  */
  97
  98 /** \brief  Enable DistributorGICInterface->ICCICR |= 1; //enable interface
  99
 100    Enables the forwarding of pending interrupts to the CPU interfaces.
 101
 102  */
 103 void GIC_EnableDistributor(void);
 104
 105 /** \brief  Disable Distributor
 106
 107    Disables the forwarding of pending interrupts to the CPU interfaces.
 108
 109  */
 110 void GIC_DisableDistributor(void);
 111
 112 /** \brief  Provides information about the configuration of the GIC.
 113    Provides information about the configuration of the GIC.
 114    - whether the GIC implements the Security Extensions
 115    - the maximum number of interrupt IDs that the GIC supports
 116    - the number of CPU interfaces implemented
 117    - if the GIC implements the Security Extensions, the maximum number of implemented Lockable Shared Peripheral Interrupts (LSPIs).
 118
 119    \return Distributor Information.
 120  */
 121 uint32_t GIC_DistributorInfo(void);
 122
 123 /** \brief  Distributor Implementer Identification Register.
 124
 125    Distributor Implementer Identification Register
 126
 127    \return Implementer Information.
 128  */
 129 uint32_t GIC_DistributorImplementer(void);
 130
 131 /** \brief  Set list of processors that the interrupt is sent to if it is asserted.
 132
 133     The ICDIPTRs provide an 8-bit CPU targets field for each interrupt supported by the GIC.
 134     This field stores the list of processors that the interrupt is sent to if it is asserted.
 135
 136     \param [in]      IRQn  Interrupt number.
 137     \param [in]    target  CPU target
 138  */
 139 void GIC_SetTarget(IRQn_Type IRQn, uint32_t cpu_target);
 140
 141 /** \brief  Get list of processors that the interrupt is sent to if it is asserted.
 142
 143     The ICDIPTRs provide an 8-bit CPU targets field for each interrupt supported by the GIC.
 144     This field stores the list of processors that the interrupt is sent to if it is asserted.
 145
 146     \param [in]      IRQn  Interrupt number.
 147     \param [in]    target  CPU target
 148 */
 149 uint32_t GIC_GetTarget(IRQn_Type IRQn);
 150
 151 /** \brief  Enable Interface
 152
 153    Enables the signalling of interrupts to the target processors.
 154
 155  */
 156 void GIC_EnableInterface(void);
 157
 158 /** \brief  Disable Interface
 159
 160    Disables the signalling of interrupts to the target processors.
 161
 162  */
 163 void GIC_DisableInterface(void);
 164
 165 /** \brief  Acknowledge Interrupt
 166
 167     The function acknowledges the highest priority pending interrupt and returns its IRQ number.
 168
 169     \return             Interrupt number
 170  */
 171 IRQn_Type GIC_AcknowledgePending(void);
 172
 173 /** \brief  End Interrupt
 174
 175     The function writes the end of interrupt register, indicating that handling of the interrupt is complete.
 176
 177     \param [in]   IRQn  Interrupt number.
 178  */
 179 void GIC_EndInterrupt(IRQn_Type IRQn);
 180
 181
 182 /** \brief  Enable Interrupt
 183
 184     Set-enable bit for each interrupt supported by the GIC.
 185
 186     \param [in]      IRQn  External interrupt number.
 187  */
 188 void GIC_EnableIRQ(IRQn_Type IRQn);
 189
 190 /** \brief  Disable Interrupt
 191
 192     Clear-enable bit for each interrupt supported by the GIC.
 193
 194     \param [in]      IRQn  Number of the external interrupt to disable
 195  */
 196 void GIC_DisableIRQ(IRQn_Type IRQn);
 197
 198 /** \brief  Set Pending Interrupt
 199
 200     Set-pending bit for each interrupt supported by the GIC.
 201
 202     \param [in]      IRQn  Interrupt number.
 203  */
 204 void GIC_SetPendingIRQ(IRQn_Type IRQn);
 205
 206 /** \brief  Clear Pending Interrupt
 207
 208     Clear-pending bit for each interrupt supported by the GIC
 209
 210     \param [in]      IRQn  Number of the interrupt for clear pending
 211  */
 212 void GIC_ClearPendingIRQ(IRQn_Type IRQn);
 213
 214 /** \brief  Int_config field for each interrupt supported by the GIC.
 215
 216     This field identifies whether the corresponding interrupt is:
 217     (1) edge-triggered or (0) level-sensitive
 218     (1) 1-N model or (0) N-N model
 219
 220     \param [in]      IRQn  Interrupt number.
 221     \param [in] edge_level (1) edge-triggered or (0) level-sensitive
 222     \param [in] model      (1) 1-N model or (0) N-N model
 223  */
 224 void GIC_SetLevelModel(IRQn_Type IRQn, int8_t edge_level, int8_t model);
 225
 226
 227 /** \brief  Set Interrupt Priority
 228
 229     The function sets the priority of an interrupt.
 230
 231     \param [in]      IRQn  Interrupt number.
 232     \param [in]  priority  Priority to set.
 233  */
 234 void GIC_SetPriority(IRQn_Type IRQn, uint32_t priority);
 235
 236 /** \brief  Get Interrupt Priority
 237
 238     The function reads the priority of an interrupt.
 239
 240     \param [in]   IRQn  Interrupt number.
 241     \return             Interrupt Priority.
 242  */
 243 uint32_t GIC_GetPriority(IRQn_Type IRQn);
 244
 245 /** \brief  CPU Interface Priority Mask Register
 246
 247     The priority mask level for the CPU interface. If the priority of an interrupt is higher than the
 248     value indicated by this field, the interface signals the interrupt to the processor.
 249
 250     \param [in]   Mask.
 251  */
 252 void GIC_InterfacePriorityMask(uint32_t priority);
 253
 254 /** \brief  Set the binary point.
 255
 256      Set the point at which the priority value fields split into two parts, the group priority field and the subpriority field.
 257
 258     \param [in]   Mask.
 259  */
 260 void GIC_SetBinaryPoint(uint32_t binary_point);
 261
 262 /** \brief  Get the binary point.
 263
 264      Get the point at which the priority value fields split into two parts, the group priority field and the subpriority field.
 265
 266     \return  Binary point.
 267  */
 268 uint32_t GIC_GetBinaryPoint(uint32_t binary_point);
 269
 270 /** \brief  Get Interrupt state.
 271
 272      Get the interrupt state, whether pending and/or active
 273
 274     \return  0 - inactive, 1 - pending, 2 - active, 3 - pending and active
 275  */
 276 uint32_t GIC_GetIRQStatus(IRQn_Type IRQn);
 277
 278 /** \brief  Send Software Generated interrupt
 279
 280     Provides an interrupt priority filter. Only interrupts with higher priority than the value in this register can be signalled to the processor.
 281 GIC_InterfacePriorityMask
 282     \param [in]   IRQn         The Interrupt ID of the SGI.
 283     \param [in]   target_list  CPUTargetList
 284     \param [in]   filter_list  TargetListFilter
 285  */
 286 void GIC_SendSGI(IRQn_Type IRQn, uint32_t target_list, uint32_t filter_list);
 287
 288 /** \brief  API call to initialise the interrupt distributor
 289
 290    API call to initialise the interrupt distributor
 291
 292  */
 293 void GIC_DistInit(void);
 294
 295 /** \brief  API call to initialise the CPU interface
 296
 297    API call to initialise the CPU interface
 298
 299  */
 300 void GIC_CPUInterfaceInit(void);
 301
 302 /** \brief  API call to set the Interrupt Configuration Registers
 303
 304    API call to initialise the Interrupt Configuration Registers
 305
 306  */
 307 void GIC_SetICDICFR (const uint32_t *ICDICFRn);
 308
 309 /** \brief  API call to  Enable the GIC
 310
 311    API call to  Enable the GIC
 312
 313  */
 314 void GIC_Enable(void);
 315
 316 #endif /* GIC_H_ */