git.sur5r.net Git - freertos/blob - Demo/CORTEX_STM32F103_IAR/STM32F10xFWLib/src/stm32f10x_nvic.c

   1 /******************** (C) COPYRIGHT 2007 STMicroelectronics ********************\r
   2 * File Name          : stm32f10x_nvic.c\r
   3 * Author             : MCD Application Team\r
   4 * Date First Issued  : 09/29/2006\r
   5 * Description        : This file provides all the NVIC firmware functions.\r
   6 ********************************************************************************\r
   7 * History:\r
   8 * 04/02/2007: V0.2\r
   9 * 02/05/2007: V0.1\r
  10 * 09/29/2006: V0.01\r
  11 ********************************************************************************\r
  12 * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS\r
  13 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.\r
  14 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,\r
  15 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE\r
  16 * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING\r
  17 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.\r
  18 *******************************************************************************/\r
  19 \r
  20 /* Includes ------------------------------------------------------------------*/\r
  21 #include "stm32f10x_nvic.h"\r
  22 \r
  23 /* Private typedef -----------------------------------------------------------*/\r
  24 /* Private define ------------------------------------------------------------*/\r
  25 #define AIRC_VECTKEY_MASK    ((u32)0x05FA0000)\r
  26 \r
  27 /* Private macro -------------------------------------------------------------*/\r
  28 /* Private variables ---------------------------------------------------------*/\r
  29 /* Private function prototypes -----------------------------------------------*/\r
  30 /* Private functions ---------------------------------------------------------*/\r
  31 \r
  32 /*******************************************************************************\r
  33 * Function Name  : NVIC_DeInit\r
  34 * Description    : Deinitializes the NVIC peripheral registers to their default\r
  35 *                  reset values.\r
  36 * Input          : None\r
  37 * Output         : None\r
  38 * Return         : None\r
  39 *******************************************************************************/\r
  40 void NVIC_DeInit(void)\r
  41 {\r
  42   u32 index = 0;\r
  43   \r
  44   NVIC->Disable[0] = 0xFFFFFFFF;\r
  45   NVIC->Disable[1] = 0x000007FF;\r
  46   NVIC->Clear[0] = 0xFFFFFFFF;\r
  47   NVIC->Clear[1] = 0x000007FF;\r
  48   \r
  49   for(index = 0; index < 0x0B; index++)\r
  50   {\r
  51      NVIC->Priority[index] = 0x00000000;\r
  52   } \r
  53 }\r
  54 \r
  55 /*******************************************************************************\r
  56 * Function Name  : NVIC_SCBDeInit\r
  57 * Description    : Deinitializes the SCB peripheral registers to their default \r
  58 *                  reset values.\r
  59 * Input          : None\r
  60 * Output         : None\r
  61 * Return         : None\r
  62 *******************************************************************************/\r
  63 void NVIC_SCBDeInit(void)\r
  64 {\r
  65   u32 index = 0x00;\r
  66   \r
  67   SCB->IRQControlState = 0x0A000000;\r
  68   SCB->ExceptionTableOffset = 0x00000000;\r
  69   SCB->AIRC = AIRC_VECTKEY_MASK;\r
  70   SCB->SysCtrl = 0x00000000;\r
  71   SCB->ConfigCtrl = 0x00000000;\r
  72   for(index = 0; index < 0x03; index++)\r
  73   {\r
  74      SCB->SystemPriority[index] = 0;\r
  75   }\r
  76   SCB->SysHandlerCtrl = 0x00000000;\r
  77   SCB->ConfigFaultStatus = 0xFFFFFFFF;\r
  78   SCB->HardFaultStatus = 0xFFFFFFFF;\r
  79   SCB->DebugFaultStatus = 0xFFFFFFFF;\r
  80 }\r
  81 \r
  82 /*******************************************************************************\r
  83 * Function Name  : NVIC_PriorityGroupConfig\r
  84 * Description    : Configures the priority grouping: pre-emption priority\r
  85 *                  and subpriority.\r
  86 * Input          : - NVIC_PriorityGroup: specifies the priority grouping bits\r
  87 *                    length. This parameter can be one of the following values:\r
  88 *                       - NVIC_PriorityGroup_0: 0 bits for pre-emption priority\r
  89 *                         4 bits for subpriority\r
  90 *                       - NVIC_PriorityGroup_1: 1 bits for pre-emption priority\r
  91 *                         3 bits for subpriority\r
  92 *                       - NVIC_PriorityGroup_2: 2 bits for pre-emption priority\r
  93 *                         2 bits for subpriority\r
  94 *                       - NVIC_PriorityGroup_3: 3 bits for pre-emption priority\r
  95 *                         1 bits for subpriority\r
  96 *                       - NVIC_PriorityGroup_4: 4 bits for pre-emption priority\r
  97 *                         0 bits for subpriority\r
  98 * Output         : None\r
  99 * Return         : None\r
 100 *******************************************************************************/\r
 101 void NVIC_PriorityGroupConfig(u32 NVIC_PriorityGroup)\r
 102 {\r
 103   /* Check the parameters */\r
 104   assert(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));\r
 105   \r
 106   /* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */\r
 107   SCB->AIRC = AIRC_VECTKEY_MASK | NVIC_PriorityGroup;\r
 108 }\r
 109 \r
 110 /*******************************************************************************\r
 111 * Function Name  : NVIC_Init\r
 112 * Description    : Initializes the NVIC peripheral according to the specified\r
 113 *                  parameters in the NVIC_InitStruct.\r
 114 * Input          : - NVIC_InitStruct: pointer to a NVIC_InitTypeDef structure\r
 115 *                    that contains the configuration information for the\r
 116 *                    specified NVIC peripheral.\r
 117 * Output         : None\r
 118 * Return         : None\r
 119 *******************************************************************************/\r
 120 void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct)\r
 121 {\r
 122   u32 tmppriority = 0x00, tmpreg = 0x00, tmpmask = 0x00;\r
 123   u32 tmppre = 0, tmpsub = 0x0F;\r
 124 \r
 125   /* Check the parameters */\r
 126   assert(IS_FUNCTIONAL_STATE(NVIC_InitStruct->NVIC_IRQChannelCmd));\r
 127   assert(IS_NVIC_IRQ_CHANNEL(NVIC_InitStruct->NVIC_IRQChannel));\r
 128   assert(IS_NVIC_PREEMPTION_PRIORITY(NVIC_InitStruct->NVIC_IRQChannelPreemptionPriority));  \r
 129   assert(IS_NVIC_SUB_PRIORITY(NVIC_InitStruct->NVIC_IRQChannelSubPriority));\r
 130     \r
 131   if (NVIC_InitStruct->NVIC_IRQChannelCmd != DISABLE)\r
 132   {\r
 133     /* Compute the Corresponding IRQ Priority --------------------------------*/    \r
 134     tmppriority = (0x700 - (SCB->AIRC & (u32)0x700))>> 0x08;\r
 135     tmppre = (0x4 - tmppriority);\r
 136     tmpsub = tmpsub >> tmppriority;\r
 137     \r
 138     tmppriority = (u32)NVIC_InitStruct->NVIC_IRQChannelPreemptionPriority << tmppre;\r
 139     tmppriority |=  NVIC_InitStruct->NVIC_IRQChannelSubPriority & tmpsub;\r
 140 \r
 141     tmppriority = tmppriority << 0x04;\r
 142     tmppriority = ((u32)tmppriority) << ((NVIC_InitStruct->NVIC_IRQChannel & (u8)0x03) * 0x08);\r
 143     \r
 144     tmpreg = NVIC->Priority[(NVIC_InitStruct->NVIC_IRQChannel >> 0x02)];\r
 145     tmpmask = (u32)0xFF << ((NVIC_InitStruct->NVIC_IRQChannel & (u8)0x03) * 0x08);\r
 146     tmpreg &= ~tmpmask;\r
 147     tmppriority &= tmpmask;  \r
 148     tmpreg |= tmppriority;\r
 149 \r
 150     NVIC->Priority[(NVIC_InitStruct->NVIC_IRQChannel >> 0x02)] = tmpreg;\r
 151     \r
 152     /* Enable the Selected IRQ Channels --------------------------------------*/\r
 153     NVIC->Enable[(NVIC_InitStruct->NVIC_IRQChannel >> 0x05)] =\r
 154       (u32)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (u8)0x1F);\r
 155   }\r
 156   else\r
 157   {\r
 158     /* Disable the Selected IRQ Channels -------------------------------------*/\r
 159     NVIC->Disable[(NVIC_InitStruct->NVIC_IRQChannel >> 0x05)] =\r
 160       (u32)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (u8)0x1F);\r
 161   }\r
 162 }\r
 163 \r
 164 /*******************************************************************************\r
 165 * Function Name  : NVIC_StructInit\r
 166 * Description    : Fills each NVIC_InitStruct member with its default value.\r
 167 * Input          : - NVIC_InitStruct: pointer to a NVIC_InitTypeDef structure which\r
 168 *                    will be initialized.\r
 169 * Output         : None\r
 170 * Return         : None\r
 171 *******************************************************************************/\r
 172 void NVIC_StructInit(NVIC_InitTypeDef* NVIC_InitStruct)\r
 173 {\r
 174   /* NVIC_InitStruct members default value */\r
 175   NVIC_InitStruct->NVIC_IRQChannel = 0x00;\r
 176   NVIC_InitStruct->NVIC_IRQChannelPreemptionPriority = 0x00;\r
 177   NVIC_InitStruct->NVIC_IRQChannelSubPriority = 0x00;\r
 178   NVIC_InitStruct->NVIC_IRQChannelCmd = DISABLE;\r
 179 }\r
 180 \r
 181 /*******************************************************************************\r
 182 * Function Name  : NVIC_SETPRIMASK\r
 183 * Description    : Enables the PRIMASK priority: Raises the execution priority to 0.\r
 184 * Input          : None\r
 185 * Output         : None\r
 186 * Return         : None\r
 187 *******************************************************************************/\r
 188 void NVIC_SETPRIMASK(void)\r
 189 {\r
 190   __SETPRIMASK();\r
 191 }\r
 192 \r
 193 /*******************************************************************************\r
 194 * Function Name  : NVIC_RESETPRIMASK\r
 195 * Description    : Disables the PRIMASK priority.\r
 196 * Input          : None\r
 197 * Output         : None\r
 198 * Return         : None\r
 199 *******************************************************************************/\r
 200 void NVIC_RESETPRIMASK(void)\r
 201 {\r
 202   __RESETPRIMASK();\r
 203 }\r
 204 \r
 205 /*******************************************************************************\r
 206 * Function Name  : NVIC_SETFAULTMASK\r
 207 * Description    : Enables the FAULTMASK priority: Raises the execution priority to -1.\r
 208 * Input          : None\r
 209 * Output         : None\r
 210 * Return         : None\r
 211 *******************************************************************************/\r
 212 void NVIC_SETFAULTMASK(void)\r
 213 {\r
 214   __SETFAULTMASK();\r
 215 }\r
 216 \r
 217 /*******************************************************************************\r
 218 * Function Name  : NVIC_RESETFAULTMASK\r
 219 * Description    : Disables the FAULTMASK priority.\r
 220 * Input          : None\r
 221 * Output         : None\r
 222 * Return         : None\r
 223 *******************************************************************************/\r
 224 void NVIC_RESETFAULTMASK(void)\r
 225 {\r
 226   __RESETFAULTMASK();\r
 227 }\r
 228 \r
 229 /*******************************************************************************\r
 230 * Function Name  : NVIC_BASEPRICONFIG\r
 231 * Description    : The execution priority can be changed from 15 (lowest \r
 232                    configurable priority) to 1.\r
 233 * Input          : None\r
 234 * Output         : None\r
 235 * Return         : None\r
 236 *******************************************************************************/\r
 237 void NVIC_BASEPRICONFIG(u32 NewPriority)\r
 238 {\r
 239   /* Check the parameters */\r
 240   assert(IS_NVIC_BASE_PRI(NewPriority));\r
 241   \r
 242   __BASEPRICONFIG(NewPriority << 0x04);\r
 243 }\r
 244 \r
 245 /*******************************************************************************\r
 246 * Function Name  : NVIC_GetBASEPRI\r
 247 * Description    : Returns the BASEPRI mask value.\r
 248 * Input          : None\r
 249 * Output         : None\r
 250 * Return         : BASEPRI register value\r
 251 *******************************************************************************/\r
 252 u32 NVIC_GetBASEPRI(void)\r
 253 {\r
 254   return (__GetBASEPRI());\r
 255 }\r
 256 \r
 257 /*******************************************************************************\r
 258 * Function Name  : NVIC_GetCurrentPendingIRQChannel\r
 259 * Description    : Returns the current pending IRQ channel identifier.\r
 260 * Input          : None\r
 261 * Output         : None\r
 262 * Return         : Pending IRQ Channel Identifier.\r
 263 *******************************************************************************/\r
 264 u16 NVIC_GetCurrentPendingIRQChannel(void)\r
 265 {\r
 266   return ((u16)((SCB->IRQControlState & (u32)0x003FF000) >> 0x0C));\r
 267 }\r
 268 \r
 269 /*******************************************************************************\r
 270 * Function Name  : NVIC_GetIRQChannelPendingBitStatus\r
 271 * Description    : Checks whether the specified IRQ Channel pending bit is set\r
 272 *                  or not.\r
 273 * Input          : - NVIC_IRQChannel: specifies the interrupt pending bit to check.\r
 274 * Output         : None\r
 275 * Return         : The new state of IRQ Channel pending bit(SET or RESET).\r
 276 *******************************************************************************/\r
 277 ITStatus NVIC_GetIRQChannelPendingBitStatus(u8 NVIC_IRQChannel)\r
 278 {\r
 279   ITStatus pendingirqstatus = RESET;\r
 280   u32 tmp = 0x00;\r
 281   \r
 282   /* Check the parameters */\r
 283   assert(IS_NVIC_IRQ_CHANNEL(NVIC_IRQChannel));\r
 284   \r
 285   tmp = ((u32)0x01 << (NVIC_IRQChannel & (u32)0x1F));\r
 286 \r
 287   if (((NVIC->Set[(NVIC_IRQChannel >> 0x05)]) & tmp) == tmp)\r
 288   {\r
 289     pendingirqstatus = SET;\r
 290   }\r
 291   else\r
 292   {\r
 293     pendingirqstatus = RESET;\r
 294   }\r
 295   return pendingirqstatus;\r
 296 }\r
 297 \r
 298 /*******************************************************************************\r
 299 * Function Name  : NVIC_SetIRQChannelPendingBit\r
 300 * Description    : Sets the NVIC\92s interrupt pending bit.\r
 301 * Input          : - NVIC_IRQChannel: specifies the interrupt pending bit to Set.\r
 302 * Output         : None\r
 303 * Return         : None\r
 304 *******************************************************************************/\r
 305 void NVIC_SetIRQChannelPendingBit(u8 NVIC_IRQChannel)\r
 306 {\r
 307   /* Check the parameters */\r
 308   assert(IS_NVIC_IRQ_CHANNEL(NVIC_IRQChannel));\r
 309   \r
 310   *(u32*)0xE000EF00 = (u32)NVIC_IRQChannel;\r
 311 }\r
 312 \r
 313 /*******************************************************************************\r
 314 * Function Name  : NVIC_ClearIRQChannelPendingBit\r
 315 * Description    : Clears the NVIC\92s interrupt pending bit.\r
 316 * Input          : - NVIC_IRQChannel: specifies the interrupt pending bit to clear.\r
 317 * Output         : None\r
 318 * Return         : None\r
 319 *******************************************************************************/\r
 320 void NVIC_ClearIRQChannelPendingBit(u8 NVIC_IRQChannel)\r
 321 {\r
 322   /* Check the parameters */\r
 323   assert(IS_NVIC_IRQ_CHANNEL(NVIC_IRQChannel));\r
 324   \r
 325   NVIC->Clear[(NVIC_IRQChannel >> 0x05)] = (u32)0x01 << (NVIC_IRQChannel & (u32)0x1F);\r
 326 }\r
 327 \r
 328 /*******************************************************************************\r
 329 * Function Name  : NVIC_GetCurrentActiveHandler\r
 330 * Description    : Returns the current active Handler (IRQ Channel and\r
 331 *                  SystemHandler) identifier.\r
 332 * Input          : None\r
 333 * Output         : None\r
 334 * Return         : Active Handler Identifier.\r
 335 *******************************************************************************/\r
 336 u16 NVIC_GetCurrentActiveHandler(void)\r
 337 {\r
 338   return ((u16)(SCB->IRQControlState & (u32)0x3FF));\r
 339 }\r
 340 \r
 341 /*******************************************************************************\r
 342 * Function Name  : NVIC_GetIRQChannelActiveBitStatus\r
 343 * Description    : Checks whether the specified IRQ Channel active bit is set\r
 344 *                  or not.\r
 345 * Input          : - NVIC_IRQChannel: specifies the interrupt active bit to check.\r
 346 * Output         : None\r
 347 * Return         : The new state of IRQ Channel active bit(SET or RESET).\r
 348 *******************************************************************************/\r
 349 ITStatus NVIC_GetIRQChannelActiveBitStatus(u8 NVIC_IRQChannel)\r
 350 {\r
 351   ITStatus activeirqstatus = RESET;\r
 352   u32 tmp = 0x00;\r
 353 \r
 354   /* Check the parameters */\r
 355   assert(IS_NVIC_IRQ_CHANNEL(NVIC_IRQChannel));\r
 356   \r
 357   tmp = ((u32)0x01 << (NVIC_IRQChannel & (u32)0x1F));\r
 358 \r
 359   if (((NVIC->Active[(NVIC_IRQChannel >> 0x05)]) & tmp) == tmp )\r
 360   {\r
 361     activeirqstatus = SET;\r
 362   }\r
 363   else\r
 364   {\r
 365     activeirqstatus = RESET;\r
 366   }\r
 367   return activeirqstatus;\r
 368 }\r
 369 \r
 370 /*******************************************************************************\r
 371 * Function Name  : NVIC_GetCPUID\r
 372 * Description    : Returns the ID number, the version number and the implementation\r
 373 *                  details of the Cortex-M3 core.\r
 374 * Input          : None\r
 375 * Output         : None\r
 376 * Return         : CPU ID.\r
 377 *******************************************************************************/\r
 378 u32 NVIC_GetCPUID(void)\r
 379 {\r
 380   return (SCB->CPUID);\r
 381 }\r
 382 \r
 383 /*******************************************************************************\r
 384 * Function Name  : NVIC_SetVectorTable\r
 385 * Description    : Sets the vector table location and Offset.\r
 386 * Input          : - NVIC_VectTab: specifies if the vector table is in RAM or\r
 387 *                    code memory.\r
 388 *                    This parameter can be one of the following values:\r
 389 *                       - NVIC_VectTab_RAM\r
 390 *                       - NVIC_VectTab_FLASH\r
 391 *                  - Offset: Vector Table base offset field.\r
 392 * Output         : None\r
 393 * Return         : None\r
 394 *******************************************************************************/\r
 395 void NVIC_SetVectorTable(u32 NVIC_VectTab, u32 Offset)\r
 396 { \r
 397   /* Check the parameters */\r
 398   assert(IS_NVIC_VECTTAB(NVIC_VectTab));\r
 399   assert(IS_NVIC_OFFSET(Offset));  \r
 400    \r
 401   SCB->ExceptionTableOffset = (((u32)Offset << 0x07) & (u32)0x1FFFFF80);\r
 402 \r
 403   SCB->ExceptionTableOffset |= NVIC_VectTab;\r
 404 }\r
 405 \r
 406 /*******************************************************************************\r
 407 * Function Name  : NVIC_GenerateSystemReset\r
 408 * Description    : Generates a system reset.\r
 409 * Input          : None\r
 410 * Output         : None\r
 411 * Return         : None\r
 412 *******************************************************************************/\r
 413 void NVIC_GenerateSystemReset(void)\r
 414 {\r
 415   SCB->AIRC = AIRC_VECTKEY_MASK | (u32)0x04;\r
 416 }\r
 417 \r
 418 /*******************************************************************************\r
 419 * Function Name  : NVIC_GenerateCoreReset\r
 420 * Description    : Generates a Core (Core + NVIC) reset.\r
 421 * Input          : None\r
 422 * Output         : None\r
 423 * Return         : None\r
 424 *******************************************************************************/\r
 425 void NVIC_GenerateCoreReset(void)\r
 426 {\r
 427   SCB->AIRC = AIRC_VECTKEY_MASK | (u32)0x01;\r
 428 }\r
 429 \r
 430 /*******************************************************************************\r
 431 * Function Name  : NVIC_SystemLPConfig\r
 432 * Description    : Selects the condition for the system to enter low power mode.\r
 433 * Input          : - LowPowerMode: Specifies the new mode for the system to enter\r
 434 *                    low power mode.\r
 435 *                    This parameter can be one of the following values:\r
 436 *                       - NVIC_LP_SEVONPEND\r
 437 *                       - NVIC_LP_SLEEPDEEP\r
 438 *                       - NVIC_LP_SLEEPONEXIT\r
 439 *                  - NewState: new state of LP condition.\r
 440 *                    This parameter can be: ENABLE or DISABLE.\r
 441 * Output         : None\r
 442 * Return         : None\r
 443 *******************************************************************************/\r
 444 void NVIC_SystemLPConfig(u8 LowPowerMode, FunctionalState NewState)\r
 445 {\r
 446   /* Check the parameters */\r
 447   assert(IS_NVIC_LP(LowPowerMode));\r
 448   assert(IS_FUNCTIONAL_STATE(NewState));  \r
 449   \r
 450   if (NewState != DISABLE)\r
 451   {\r
 452     SCB->SysCtrl |= LowPowerMode;\r
 453   }\r
 454   else\r
 455   {\r
 456     SCB->SysCtrl &= (u32)(~(u32)LowPowerMode);\r
 457   }\r
 458 }\r
 459 \r
 460 /*******************************************************************************\r
 461 * Function Name  : NVIC_SystemHandlerConfig\r
 462 * Description    : Enables or disables the specified System Handlers.\r
 463 * Input          : - SystemHandler: specifies the system handler to be enabled\r
 464 *                    or disabled.\r
 465 *                    This parameter can be one of the following values:\r
 466 *                       - SystemHandler_MemoryManage\r
 467 *                       - SystemHandler_BusFault\r
 468 *                       - SystemHandler_UsageFault\r
 469 *                  - NewState: new state of  specified System Handlers.\r
 470 *                    This parameter can be: ENABLE or DISABLE.\r
 471 * Output         : None\r
 472 * Return         : None\r
 473 *******************************************************************************/\r
 474 void NVIC_SystemHandlerConfig(u32 SystemHandler, FunctionalState NewState)\r
 475 {\r
 476   u32 tmpreg = 0x00;\r
 477 \r
 478   /* Check the parameters */\r
 479   assert(IS_CONFIG_SYSTEM_HANDLER(SystemHandler));\r
 480   assert(IS_FUNCTIONAL_STATE(NewState)); \r
 481   \r
 482   tmpreg =  (u32)0x01 << (SystemHandler & (u32)0x1F);\r
 483 \r
 484   if (NewState != DISABLE)\r
 485   {\r
 486     SCB->SysHandlerCtrl |= tmpreg;\r
 487   }\r
 488   else\r
 489   {\r
 490     SCB->SysHandlerCtrl &= ~tmpreg;\r
 491   }\r
 492 }\r
 493 \r
 494 /*******************************************************************************\r
 495 * Function Name  : NVIC_SystemHandlerPriorityConfig\r
 496 * Description    : Configures the specified System Handlers priority.\r
 497 * Input          : - SystemHandler: specifies the system handler to be\r
 498 *                    enabled or disabled.\r
 499 *                    This parameter can be one of the following values:\r
 500 *                       - SystemHandler_MemoryManage\r
 501 *                       - SystemHandler_BusFault\r
 502 *                       - SystemHandler_UsageFault\r
 503 *                       - SystemHandler_SVCall\r
 504 *                       - SystemHandler_DebugMonitor\r
 505 *                       - SystemHandler_PSV\r
 506 *                       - SystemHandler_SysTick\r
 507 *                  - SystemHandlerPreemptionPriority: new priority group of the\r
 508 *                    specified system handlers.\r
 509 *                  - SystemHandlerSubPriority: new sub priority of the specified\r
 510 *                    system handlers.\r
 511 * Output         : None\r
 512 * Return         : None\r
 513 *******************************************************************************/\r
 514 void NVIC_SystemHandlerPriorityConfig(u32 SystemHandler, u8 SystemHandlerPreemptionPriority,\r
 515                                       u8 SystemHandlerSubPriority)\r
 516 {\r
 517   u32 tmp1 = 0x00, tmp2 = 0xFF, handlermask = 0x00;\r
 518   u32 tmppriority = 0x00;\r
 519 \r
 520   /* Check the parameters */\r
 521   assert(IS_PRIORITY_SYSTEM_HANDLER(SystemHandler));\r
 522   assert(IS_NVIC_PREEMPTION_PRIORITY(SystemHandlerPreemptionPriority));  \r
 523   assert(IS_NVIC_SUB_PRIORITY(SystemHandlerSubPriority));\r
 524     \r
 525   tmppriority = (0x700 - (SCB->AIRC & (u32)0x700))>> 0x08;\r
 526   tmp1 = (0x4 - tmppriority);\r
 527   tmp2 = tmp2 >> tmppriority;\r
 528     \r
 529   tmppriority = (u32)SystemHandlerPreemptionPriority << tmp1;\r
 530   tmppriority |=  SystemHandlerSubPriority & tmp2;\r
 531 \r
 532   tmppriority = tmppriority << 0x04;\r
 533   tmp1 = SystemHandler & (u32)0xC0;\r
 534   tmp1 = tmp1 >> 0x06; \r
 535   tmp2 = (SystemHandler >> 0x08) & (u32)0x03;\r
 536   tmppriority = tmppriority << (tmp2 * 0x08);\r
 537   handlermask = (u32)0xFF << (tmp2 * 0x08);\r
 538   \r
 539   SCB->SystemPriority[tmp1] &= ~handlermask;\r
 540   SCB->SystemPriority[tmp1] |= tmppriority;\r
 541 }\r
 542 \r
 543 /*******************************************************************************\r
 544 * Function Name  : NVIC_GetSystemHandlerPendingBitStatus\r
 545 * Description    : Checks whether the specified System handlers pending bit is\r
 546 *                  set or not.\r
 547 * Input          : - SystemHandler: specifies the system handler pending bit to\r
 548 *                    check.\r
 549 *                    This parameter can be one of the following values:\r
 550 *                       - SystemHandler_MemoryManage\r
 551 *                       - SystemHandler_BusFault\r
 552 *                       - SystemHandler_SVCall\r
 553 * Output         : None\r
 554 * Return         : The new state of System Handler pending bit(SET or RESET).\r
 555 *******************************************************************************/\r
 556 ITStatus NVIC_GetSystemHandlerPendingBitStatus(u32 SystemHandler)\r
 557 {\r
 558   ITStatus bitstatus  = RESET;\r
 559   u32 tmp = 0x00, tmppos = 0x00;\r
 560 \r
 561   /* Check the parameters */\r
 562   assert(IS_GET_PENDING_SYSTEM_HANDLER(SystemHandler));\r
 563   \r
 564   tmppos = (SystemHandler >> 0x0A);\r
 565   tmppos &= (u32)0x0F;\r
 566 \r
 567   tmppos = (u32)0x01 << tmppos;\r
 568 \r
 569   tmp = SCB->SysHandlerCtrl & tmppos;\r
 570 \r
 571   if (tmp == tmppos)\r
 572   {\r
 573     bitstatus = SET;\r
 574   }\r
 575   else\r
 576   {\r
 577     bitstatus = RESET;\r
 578   }\r
 579   return bitstatus;\r
 580 }\r
 581 \r
 582 /*******************************************************************************\r
 583 * Function Name  : NVIC_SetSystemHandlerPendingBit\r
 584 * Description    : Sets System Handler pending bit.\r
 585 * Input          : - SystemHandler: specifies the system handler pending bit\r
 586 *                    to be set.\r
 587 *                    This parameter can be one of the following values:\r
 588 *                       - SystemHandler_NMI\r
 589 *                       - SystemHandler_PSV\r
 590 *                       - SystemHandler_SysTick\r
 591 * Output         : None\r
 592 * Return         : None\r
 593 *******************************************************************************/\r
 594 void NVIC_SetSystemHandlerPendingBit(u32 SystemHandler)\r
 595 {\r
 596   u32 tmp = 0x00;\r
 597 \r
 598   /* Check the parameters */\r
 599   assert(IS_SET_PENDING_SYSTEM_HANDLER(SystemHandler));\r
 600   \r
 601   /* Get the System Handler pending bit position */\r
 602   tmp = SystemHandler & (u32)0x1F;\r
 603   /* Set the corresponding System Handler pending bit */\r
 604   SCB->IRQControlState |= ((u32)0x01 << tmp);\r
 605 }\r
 606 \r
 607 /*******************************************************************************\r
 608 * Function Name  : NVIC_ClearSystemHandlerPendingBit\r
 609 * Description    : Clears System Handler pending bit.\r
 610 * Input          : - SystemHandler: specifies the system handler pending bit to\r
 611 *                    be clear.\r
 612 *                    This parameter can be one of the following values:\r
 613 *                       - SystemHandler_PSV\r
 614 *                       - SystemHandler_SysTick\r
 615 * Output         : None\r
 616 * Return         : None\r
 617 *******************************************************************************/\r
 618 void NVIC_ClearSystemHandlerPendingBit(u32 SystemHandler)\r
 619 {\r
 620   u32 tmp = 0x00;\r
 621 \r
 622   /* Check the parameters */\r
 623   assert(IS_CLEAR_SYSTEM_HANDLER(SystemHandler));\r
 624   \r
 625   /* Get the System Handler pending bit position */\r
 626   tmp = SystemHandler & (u32)0x1F;\r
 627   /* Clear the corresponding System Handler pending bit */\r
 628   SCB->IRQControlState |= ((u32)0x01 << (tmp - 0x01));\r
 629 }\r
 630 \r
 631 /*******************************************************************************\r
 632 * Function Name  : NVIC_GetSystemHandlerActiveBitStatus\r
 633 * Description    : Checks whether the specified System handlers active bit is\r
 634 *                  set or not.\r
 635 * Input          : - SystemHandler: specifies the system handler active bit to\r
 636 *                    check.\r
 637 *                    This parameter can be one of the following values:\r
 638 *                       - SystemHandler_MemoryManage\r
 639 *                       - SystemHandler_BusFault\r
 640 *                       - SystemHandler_UsageFault\r
 641 *                       - SystemHandler_SVCall\r
 642 *                       - SystemHandler_DebugMonitor\r
 643 *                       - SystemHandler_PSV\r
 644 *                       - SystemHandler_SysTick\r
 645 * Output         : None\r
 646 * Return         : The new state of System Handler active bit(SET or RESET).\r
 647 *******************************************************************************/\r
 648 ITStatus NVIC_GetSystemHandlerActiveBitStatus(u32 SystemHandler)\r
 649 {\r
 650   ITStatus bitstatus  = RESET;\r
 651 \r
 652   u32 tmp = 0x00, tmppos = 0x00;\r
 653 \r
 654   /* Check the parameters */\r
 655   assert(IS_GET_ACTIVE_SYSTEM_HANDLER(SystemHandler));\r
 656   \r
 657   tmppos = (SystemHandler >> 0x0E) & (u32)0x0F;\r
 658 \r
 659   tmppos = (u32)0x01 << tmppos;\r
 660 \r
 661   tmp = SCB->SysHandlerCtrl & tmppos;\r
 662 \r
 663   if (tmp == tmppos)\r
 664   {\r
 665     bitstatus = SET;\r
 666   }\r
 667   else\r
 668   {\r
 669     bitstatus = RESET;\r
 670   }\r
 671   return bitstatus;\r
 672 }\r
 673 \r
 674 /*******************************************************************************\r
 675 * Function Name  : NVIC_GetFaultHandlerSources\r
 676 * Description    : Returns the system fault handlers sources.\r
 677 * Input          : - SystemHandler: specifies the system handler to get its fault\r
 678 *                    sources.\r
 679 *                    This parameter can be one of the following values:\r
 680 *                       - SystemHandler_HardFault\r
 681 *                       - SystemHandler_MemoryManage\r
 682 *                       - SystemHandler_BusFault\r
 683 *                       - SystemHandler_UsageFault\r
 684 *                       - SystemHandler_DebugMonitor\r
 685 * Output         : None\r
 686 * Return         : Source of the fault handler.\r
 687 *******************************************************************************/\r
 688 u32 NVIC_GetFaultHandlerSources(u32 SystemHandler)\r
 689 {\r
 690   u32 faultsources = 0x00;\r
 691   u32 tmpreg = 0x00, tmppos = 0x00;\r
 692 \r
 693   /* Check the parameters */\r
 694   assert(IS_FAULT_SOURCE_SYSTEM_HANDLER(SystemHandler));\r
 695   \r
 696   tmpreg = (SystemHandler >> 0x12) & (u32)0x03;\r
 697   tmppos = (SystemHandler >> 0x14) & (u32)0x03;\r
 698 \r
 699   if (tmpreg == 0x00)\r
 700   {\r
 701     faultsources = SCB->HardFaultStatus;\r
 702   }\r
 703   else if (tmpreg == 0x01)\r
 704   {\r
 705     faultsources = SCB->ConfigFaultStatus >> (tmppos * 0x08);\r
 706     if (tmppos != 0x02)\r
 707     {\r
 708       faultsources &= (u32)0x0F;\r
 709     }\r
 710     else\r
 711     {\r
 712       faultsources &= (u32)0xFF;\r
 713     }\r
 714   }\r
 715   else\r
 716   {\r
 717     faultsources = SCB->DebugFaultStatus;\r
 718   }\r
 719   return faultsources;\r
 720 }\r
 721 \r
 722 /*******************************************************************************\r
 723 * Function Name  : NVIC_GetFaultAddress\r
 724 * Description    : Returns the address of the location that generated a fault\r
 725 *                  handler.\r
 726 * Input          : - SystemHandler: specifies the system handler to get its\r
 727 *                    fault address.\r
 728 *                    This parameter can be one of the following values:\r
 729 *                       - SystemHandler_MemoryManage\r
 730 *                       - SystemHandler_BusFault\r
 731 * Output         : None\r
 732 * Return         : Fault address.\r
 733 *******************************************************************************/\r
 734 u32 NVIC_GetFaultAddress(u32 SystemHandler)\r
 735 {\r
 736   u32 faultaddress = 0x00;\r
 737   u32 tmp = 0x00;\r
 738 \r
 739   /* Check the parameters */\r
 740   assert(IS_FAULT_ADDRESS_SYSTEM_HANDLER(SystemHandler));\r
 741   \r
 742   tmp = (SystemHandler >> 0x16) & (u32)0x01;\r
 743 \r
 744   if (tmp == 0x00)\r
 745   {\r
 746     faultaddress = SCB->MemoryManageFaultAddr;\r
 747   }\r
 748   else\r
 749   {\r
 750     faultaddress = SCB->BusFaultAddr;\r
 751   }\r
 752   return faultaddress;\r
 753 }\r
 754 \r
 755 /******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/\r