git.sur5r.net Git - freertos/blob - Demo/CORTEX_M4F_M0_LPC43xx_Keil/system/core_cmFunc.h

   1 /**************************************************************************//**\r
   2  * @file     core_cmFunc.h\r
   3  * @brief    CMSIS Cortex-M Core Function Access Header File\r
   4  * @version  V2.01\r
   5  * @date     06. December 2010\r
   6  *\r
   7  * @note\r
   8  * Copyright (C) 2009-2010 ARM Limited. All rights reserved.\r
   9  *\r
  10  * @par\r
  11  * ARM Limited (ARM) is supplying this software for use with Cortex-M \r
  12  * processor based microcontrollers.  This file can be freely distributed \r
  13  * within development tools that are supporting such ARM based processors. \r
  14  *\r
  15  * @par\r
  16  * THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED\r
  17  * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF\r
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.\r
  19  * ARM SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR\r
  20  * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.\r
  21  *\r
  22  ******************************************************************************/\r
  23 \r
  24 #ifndef __CORE_CMFUNC_H__\r
  25 #define __CORE_CMFUNC_H__\r
  26 \r
  27 /* ###########################  Core Function Access  ########################### */\r
  28 /** \ingroup  CMSIS_Core_FunctionInterface   \r
  29     \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions\r
  30   @{\r
  31  */\r
  32 \r
  33 #if defined ( __CC_ARM   ) /*------------------ RealView Compiler ----------------*/\r
  34 /* ARM armcc specific functions */\r
  35 \r
  36 /* intrinsic void __enable_irq();     */\r
  37 /* intrinsic void __disable_irq();    */\r
  38 \r
  39 /** \brief  Get Control Register\r
  40 \r
  41     This function returns the content of the Control Register.\r
  42 \r
  43     \return               Control Register value\r
  44  */\r
  45 #if       (__ARMCC_VERSION <  400000)\r
  46 extern          uint32_t __get_CONTROL(void);\r
  47 #else  /* (__ARMCC_VERSION >= 400000) */\r
  48 static __INLINE uint32_t __get_CONTROL(void)\r
  49 {\r
  50   register uint32_t __regControl         __ASM("control");\r
  51   return(__regControl);\r
  52 }\r
  53 #endif /*  __ARMCC_VERSION  */ \r
  54 \r
  55 \r
  56 /** \brief  Set Control Register\r
  57 \r
  58     This function writes the given value to the Control Register.\r
  59 \r
  60     \param [in]    control  Control Register value to set\r
  61  */\r
  62 #if       (__ARMCC_VERSION <  400000)\r
  63 extern          void __set_CONTROL(uint32_t control);\r
  64 #else  /* (__ARMCC_VERSION >= 400000) */\r
  65 static __INLINE void __set_CONTROL(uint32_t control)\r
  66 {\r
  67   register uint32_t __regControl         __ASM("control");\r
  68   __regControl = control;\r
  69 }\r
  70 #endif /*  __ARMCC_VERSION  */ \r
  71 \r
  72 \r
  73 /** \brief  Get ISPR Register\r
  74 \r
  75     This function returns the content of the ISPR Register.\r
  76 \r
  77     \return               ISPR Register value\r
  78  */\r
  79 #if       (__ARMCC_VERSION <  400000)\r
  80 extern          uint32_t __get_IPSR(void);\r
  81 #else  /* (__ARMCC_VERSION >= 400000) */\r
  82 static __INLINE uint32_t __get_IPSR(void)\r
  83 {\r
  84   register uint32_t __regIPSR          __ASM("ipsr");\r
  85   return(__regIPSR);\r
  86 }\r
  87 #endif /*  __ARMCC_VERSION  */ \r
  88 \r
  89 \r
  90 /** \brief  Get APSR Register\r
  91 \r
  92     This function returns the content of the APSR Register.\r
  93 \r
  94     \return               APSR Register value\r
  95  */\r
  96 #if       (__ARMCC_VERSION <  400000)\r
  97 extern          uint32_t __get_APSR(void);\r
  98 #else  /* (__ARMCC_VERSION >= 400000) */\r
  99 static __INLINE uint32_t __get_APSR(void)\r
 100 {\r
 101   register uint32_t __regAPSR          __ASM("apsr");\r
 102   return(__regAPSR);\r
 103 }\r
 104 #endif /*  __ARMCC_VERSION  */ \r
 105 \r
 106 \r
 107 /** \brief  Get xPSR Register\r
 108 \r
 109     This function returns the content of the xPSR Register.\r
 110 \r
 111     \return               xPSR Register value\r
 112  */\r
 113 #if       (__ARMCC_VERSION <  400000)\r
 114 extern          uint32_t __get_xPSR(void);\r
 115 #else  /* (__ARMCC_VERSION >= 400000) */\r
 116 static __INLINE uint32_t __get_xPSR(void)\r
 117 {\r
 118   register uint32_t __regXPSR          __ASM("xpsr");\r
 119   return(__regXPSR);\r
 120 }\r
 121 #endif /*  __ARMCC_VERSION  */ \r
 122 \r
 123 \r
 124 /** \brief  Get Process Stack Pointer\r
 125 \r
 126     This function returns the current value of the Process Stack Pointer (PSP).\r
 127 \r
 128     \return               PSP Register value\r
 129  */\r
 130 #if       (__ARMCC_VERSION <  400000)\r
 131 extern          uint32_t __get_PSP(void);\r
 132 #else  /* (__ARMCC_VERSION >= 400000) */\r
 133 static __INLINE uint32_t __get_PSP(void)\r
 134 {\r
 135   register uint32_t __regProcessStackPointer  __ASM("psp");\r
 136   return(__regProcessStackPointer);\r
 137 }\r
 138 #endif /*  __ARMCC_VERSION  */ \r
 139 \r
 140 \r
 141 /** \brief  Set Process Stack Pointer\r
 142 \r
 143     This function assigns the given value to the Process Stack Pointer (PSP).\r
 144 \r
 145     \param [in]    topOfProcStack  Process Stack Pointer value to set\r
 146  */\r
 147 #if       (__ARMCC_VERSION <  400000)\r
 148 extern          void __set_PSP(uint32_t topOfProcStack);\r
 149 #else  /* (__ARMCC_VERSION >= 400000) */\r
 150 static __INLINE void __set_PSP(uint32_t topOfProcStack)\r
 151 {\r
 152   register uint32_t __regProcessStackPointer  __ASM("psp");\r
 153   __regProcessStackPointer = topOfProcStack;\r
 154 }\r
 155 #endif /*  __ARMCC_VERSION  */ \r
 156 \r
 157 \r
 158 /** \brief  Get Main Stack Pointer\r
 159 \r
 160     This function returns the current value of the Main Stack Pointer (MSP).\r
 161 \r
 162     \return               MSP Register value\r
 163  */\r
 164 #if       (__ARMCC_VERSION <  400000)\r
 165 extern          uint32_t __get_MSP(void);\r
 166 #else  /* (__ARMCC_VERSION >= 400000) */\r
 167 static __INLINE uint32_t __get_MSP(void)\r
 168 {\r
 169   register uint32_t __regMainStackPointer     __ASM("msp");\r
 170   return(__regMainStackPointer);\r
 171 }\r
 172 #endif /*  __ARMCC_VERSION  */ \r
 173 \r
 174 \r
 175 /** \brief  Set Main Stack Pointer\r
 176 \r
 177     This function assigns the given value to the Main Stack Pointer (MSP).\r
 178 \r
 179     \param [in]    topOfMainStack  Main Stack Pointer value to set\r
 180  */\r
 181 #if       (__ARMCC_VERSION <  400000)\r
 182 extern          void __set_MSP(uint32_t topOfMainStack);\r
 183 #else  /* (__ARMCC_VERSION >= 400000) */\r
 184 static __INLINE void __set_MSP(uint32_t topOfMainStack)\r
 185 {\r
 186   register uint32_t __regMainStackPointer     __ASM("msp");\r
 187   __regMainStackPointer = topOfMainStack;\r
 188 }\r
 189 #endif /*  __ARMCC_VERSION  */ \r
 190 \r
 191 \r
 192 /** \brief  Get Priority Mask\r
 193 \r
 194     This function returns the current state of the priority mask bit from the Priority Mask Register.\r
 195 \r
 196     \return               Priority Mask value\r
 197  */\r
 198 #if       (__ARMCC_VERSION <  400000)\r
 199 extern          uint32_t __get_PRIMASK(void);\r
 200 #else  /* (__ARMCC_VERSION >= 400000) */\r
 201 static __INLINE uint32_t __get_PRIMASK(void)\r
 202 {\r
 203   register uint32_t __regPriMask         __ASM("primask");\r
 204   return(__regPriMask);\r
 205 }\r
 206 #endif /*  __ARMCC_VERSION  */ \r
 207 \r
 208 \r
 209 /** \brief  Set Priority Mask\r
 210 \r
 211     This function assigns the given value to the Priority Mask Register.\r
 212 \r
 213     \param [in]    priMask  Priority Mask\r
 214  */\r
 215 #if       (__ARMCC_VERSION <  400000)\r
 216 extern          void __set_PRIMASK(uint32_t priMask);\r
 217 #else  /* (__ARMCC_VERSION >= 400000) */\r
 218 static __INLINE void __set_PRIMASK(uint32_t priMask)\r
 219 {\r
 220   register uint32_t __regPriMask         __ASM("primask");\r
 221   __regPriMask = (priMask);\r
 222 }\r
 223 #endif /*  __ARMCC_VERSION  */ \r
 224  \r
 225 \r
 226 #if       (__CORTEX_M >= 0x03)\r
 227 \r
 228 /** \brief  Enable FIQ\r
 229 \r
 230     This function enables FIQ interrupts by clearing the F-bit in the CPSR.\r
 231     Can only be executed in Privileged modes.\r
 232  */\r
 233 #define __enable_fault_irq                __enable_fiq\r
 234 \r
 235 \r
 236 /** \brief  Disable FIQ\r
 237 \r
 238     This function disables FIQ interrupts by setting the F-bit in the CPSR.\r
 239     Can only be executed in Privileged modes.\r
 240  */\r
 241 #define __disable_fault_irq               __disable_fiq\r
 242 \r
 243 \r
 244 /** \brief  Get Base Priority\r
 245 \r
 246     This function returns the current value of the Base Priority register.\r
 247 \r
 248     \return               Base Priority register value\r
 249  */\r
 250 #if       (__ARMCC_VERSION <  400000)\r
 251 extern          uint32_t __get_BASEPRI(void);\r
 252 #else  /* (__ARMCC_VERSION >= 400000) */\r
 253 static __INLINE uint32_t  __get_BASEPRI(void)\r
 254 {\r
 255   register uint32_t __regBasePri         __ASM("basepri");\r
 256   return(__regBasePri);\r
 257 }\r
 258 #endif /*  __ARMCC_VERSION  */ \r
 259 \r
 260 \r
 261 /** \brief  Set Base Priority\r
 262 \r
 263     This function assigns the given value to the Base Priority register.\r
 264 \r
 265     \param [in]    basePri  Base Priority value to set\r
 266  */\r
 267 #if       (__ARMCC_VERSION <  400000)\r
 268 extern          void __set_BASEPRI(uint32_t basePri);\r
 269 #else  /* (__ARMCC_VERSION >= 400000) */\r
 270 static __INLINE void __set_BASEPRI(uint32_t basePri)\r
 271 {\r
 272   register uint32_t __regBasePri         __ASM("basepri");\r
 273   __regBasePri = (basePri & 0xff);\r
 274 }\r
 275 #endif /*  __ARMCC_VERSION  */ \r
 276  \r
 277 \r
 278 /** \brief  Get Fault Mask\r
 279 \r
 280     This function returns the current value of the Fault Mask register.\r
 281 \r
 282     \return               Fault Mask register value\r
 283  */\r
 284 #if       (__ARMCC_VERSION <  400000)\r
 285 extern          uint32_t __get_FAULTMASK(void);\r
 286 #else  /* (__ARMCC_VERSION >= 400000) */\r
 287 static __INLINE uint32_t __get_FAULTMASK(void)\r
 288 {\r
 289   register uint32_t __regFaultMask       __ASM("faultmask");\r
 290   return(__regFaultMask);\r
 291 }\r
 292 #endif /*  __ARMCC_VERSION  */ \r
 293 \r
 294 \r
 295 /** \brief  Set Fault Mask\r
 296 \r
 297     This function assigns the given value to the Fault Mask register.\r
 298 \r
 299     \param [in]    faultMask  Fault Mask value to set\r
 300  */\r
 301 #if       (__ARMCC_VERSION <  400000)\r
 302 extern          void __set_FAULTMASK(uint32_t faultMask);\r
 303 #else  /* (__ARMCC_VERSION >= 400000) */\r
 304 static __INLINE void __set_FAULTMASK(uint32_t faultMask)\r
 305 {\r
 306   register uint32_t __regFaultMask       __ASM("faultmask");\r
 307   __regFaultMask = (faultMask & 1);\r
 308 }\r
 309 #endif /*  __ARMCC_VERSION  */ \r
 310 \r
 311 #endif /* (__CORTEX_M >= 0x03) */\r
 312 \r
 313 \r
 314 #if       (__CORTEX_M == 0x04)\r
 315 \r
 316 /** \brief  Get FPSCR\r
 317 \r
 318     This function returns the current value of the Floating Point Status/Control register.\r
 319 \r
 320     \return               Floating Point Status/Control register value\r
 321  */\r
 322 static __INLINE uint32_t __get_FPSCR(void)\r
 323 {\r
 324 #if (__FPU_PRESENT == 1)\r
 325   register uint32_t __regfpscr         __ASM("fpscr");\r
 326   return(__regfpscr);\r
 327 #else\r
 328    return(0);\r
 329 #endif\r
 330 }\r
 331 \r
 332 \r
 333 /** \brief  Set FPSCR\r
 334 \r
 335     This function assigns the given value to the Floating Point Status/Control register.\r
 336 \r
 337     \param [in]    fpscr  Floating Point Status/Control value to set\r
 338  */\r
 339 static __INLINE void __set_FPSCR(uint32_t fpscr)\r
 340 {\r
 341 #if (__FPU_PRESENT == 1)\r
 342   register uint32_t __regfpscr         __ASM("fpscr");\r
 343   __regfpscr = (fpscr);\r
 344 #endif\r
 345 }\r
 346 \r
 347 #endif /* (__CORTEX_M == 0x04) */\r
 348 \r
 349 \r
 350  #elif (defined (__ICCARM__)) /*---------------- ICC Compiler ---------------------*/\r
 351 /* IAR iccarm specific functions */\r
 352 \r
 353 #if defined (__ICCARM__)\r
 354   #include <intrinsics.h>                     /* IAR Intrinsics   */\r
 355 #endif\r
 356 \r
 357 #pragma diag_suppress=Pe940\r
 358 \r
 359 /** \brief  Enable IRQ Interrupts\r
 360 \r
 361   This function enables IRQ interrupts by clearing the I-bit in the CPSR.\r
 362   Can only be executed in Privileged modes.\r
 363  */\r
 364 #define __enable_irq                              __enable_interrupt\r
 365 \r
 366 \r
 367 /** \brief  Disable IRQ Interrupts\r
 368 \r
 369   This function disables IRQ interrupts by setting the I-bit in the CPSR.\r
 370   Can only be executed in Privileged modes.\r
 371  */\r
 372 #define __disable_irq                             __disable_interrupt\r
 373 \r
 374 \r
 375 /* intrinsic unsigned long __get_CONTROL( void ); (see intrinsic.h) */\r
 376 /* intrinsic void __set_CONTROL( unsigned long ); (see intrinsic.h) */\r
 377 \r
 378 \r
 379 /** \brief  Get ISPR Register\r
 380 \r
 381     This function returns the content of the ISPR Register.\r
 382 \r
 383     \return               ISPR Register value\r
 384  */\r
 385 static uint32_t __get_IPSR(void)\r
 386 {\r
 387   __ASM("mrs r0, ipsr");\r
 388 }\r
 389 \r
 390 \r
 391 /** \brief  Get APSR Register\r
 392 \r
 393     This function returns the content of the APSR Register.\r
 394 \r
 395     \return               APSR Register value\r
 396  */\r
 397 static uint32_t __get_APSR(void)\r
 398 {\r
 399   __ASM("mrs r0, apsr");\r
 400 }\r
 401 \r
 402 \r
 403 /** \brief  Get xPSR Register\r
 404 \r
 405     This function returns the content of the xPSR Register.\r
 406 \r
 407     \return               xPSR Register value\r
 408  */\r
 409 static uint32_t __get_xPSR(void)\r
 410 {\r
 411   __ASM("mrs r0, psr");           // assembler does not know "xpsr"\r
 412 }\r
 413 \r
 414 \r
 415 /** \brief  Get Process Stack Pointer\r
 416 \r
 417     This function returns the current value of the Process Stack Pointer (PSP).\r
 418 \r
 419     \return               PSP Register value\r
 420  */\r
 421 static uint32_t __get_PSP(void)\r
 422 {\r
 423   __ASM("mrs r0, psp");\r
 424 }\r
 425  \r
 426 \r
 427 /** \brief  Set Process Stack Pointer\r
 428 \r
 429     This function assigns the given value to the Process Stack Pointer (PSP).\r
 430 \r
 431     \param [in]    topOfProcStack  Process Stack Pointer value to set\r
 432  */\r
 433 static void __set_PSP(uint32_t topOfProcStack)\r
 434 {\r
 435   __ASM("msr psp, r0");\r
 436 }\r
 437 \r
 438 \r
 439 /** \brief  Get Main Stack Pointer\r
 440 \r
 441     This function returns the current value of the Main Stack Pointer (MSP).\r
 442 \r
 443     \return               MSP Register value\r
 444  */\r
 445 static uint32_t __get_MSP(void)\r
 446 {\r
 447   __ASM("mrs r0, msp");\r
 448 }\r
 449  \r
 450 \r
 451 /** \brief  Set Main Stack Pointer\r
 452 \r
 453     This function assigns the given value to the Main Stack Pointer (MSP).\r
 454 \r
 455     \param [in]    topOfMainStack  Main Stack Pointer value to set\r
 456  */\r
 457 static void __set_MSP(uint32_t topOfMainStack)\r
 458 {\r
 459   __ASM("msr msp, r0");\r
 460 }\r
 461  \r
 462 \r
 463 /* intrinsic unsigned long __get_PRIMASK( void ); (see intrinsic.h) */\r
 464 /* intrinsic void __set_PRIMASK( unsigned long ); (see intrinsic.h) */\r
 465  \r
 466 \r
 467 #if       (__CORTEX_M >= 0x03)\r
 468 \r
 469 /** \brief  Enable FIQ\r
 470 \r
 471     This function enables FIQ interrupts by clearing the F-bit in the CPSR.\r
 472     Can only be executed in Privileged modes.\r
 473  */\r
 474 static __INLINE void __enable_fault_irq(void)\r
 475 {\r
 476   __ASM ("cpsie f");\r
 477 }\r
 478 \r
 479 \r
 480 /** \brief  Disable FIQ\r
 481 \r
 482     This function disables FIQ interrupts by setting the F-bit in the CPSR.\r
 483     Can only be executed in Privileged modes.\r
 484  */\r
 485 static __INLINE void __disable_fault_irq(void)\r
 486 {\r
 487   __ASM ("cpsid f");\r
 488 }\r
 489 \r
 490 \r
 491 /* intrinsic unsigned long __get_BASEPRI( void );   (see intrinsic.h) */\r
 492 /* intrinsic void __set_BASEPRI( unsigned long );   (see intrinsic.h) */\r
 493 /* intrinsic unsigned long __get_FAULTMASK( void ); (see intrinsic.h) */\r
 494 /* intrinsic void __set_FAULTMASK(unsigned long);   (see intrinsic.h) */\r
 495 \r
 496 #endif /* (__CORTEX_M >= 0x03) */\r
 497 \r
 498 \r
 499 #if       (__CORTEX_M == 0x04)\r
 500 \r
 501 /** \brief  Get FPSCR\r
 502 \r
 503     This function returns the current value of the Floating Point Status/Control register.\r
 504 \r
 505     \return               Floating Point Status/Control register value\r
 506  */\r
 507 static uint32_t __get_FPSCR(void)\r
 508 {\r
 509 #if (__FPU_PRESENT == 1)\r
 510   __ASM("vmrs r0, fpscr"); \r
 511 #else\r
 512   return(0);\r
 513 #endif\r
 514 }\r
 515 \r
 516 \r
 517 /** \brief  Set FPSCR\r
 518 \r
 519     This function assigns the given value to the Floating Point Status/Control register.\r
 520 \r
 521     \param [in]    fpscr  Floating Point Status/Control value to set\r
 522  */\r
 523 static void __set_FPSCR(uint32_t fpscr)\r
 524 {\r
 525 #if (__FPU_PRESENT == 1)\r
 526   __ASM("vmsr fpscr, r0");\r
 527 #endif\r
 528 }\r
 529 \r
 530 #endif /* (__CORTEX_M == 0x04) */\r
 531 \r
 532 #pragma diag_default=Pe940\r
 533 \r
 534 \r
 535 #elif (defined (__GNUC__)) /*------------------ GNU Compiler ---------------------*/\r
 536 /* GNU gcc specific functions */\r
 537 \r
 538 /** \brief  Enable IRQ Interrupts\r
 539 \r
 540   This function enables IRQ interrupts by clearing the I-bit in the CPSR.\r
 541   Can only be executed in Privileged modes.\r
 542  */\r
 543 __attribute__( ( always_inline ) ) static __INLINE void __enable_irq(void)\r
 544 {\r
 545   __ASM volatile ("cpsie i");\r
 546 }\r
 547 \r
 548 \r
 549 /** \brief  Disable IRQ Interrupts\r
 550 \r
 551   This function disables IRQ interrupts by setting the I-bit in the CPSR.\r
 552   Can only be executed in Privileged modes.\r
 553  */\r
 554 __attribute__( ( always_inline ) ) static __INLINE void __disable_irq(void)\r
 555 {\r
 556   __ASM volatile ("cpsid i");\r
 557 }\r
 558 \r
 559 \r
 560 /** \brief  Get Control Register\r
 561 \r
 562     This function returns the content of the Control Register.\r
 563 \r
 564     \return               Control Register value\r
 565  */\r
 566 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_CONTROL(void)\r
 567 {\r
 568   uint32_t result;\r
 569 \r
 570   __ASM volatile ("MRS %0, control" : "=r" (result) );\r
 571   return(result);\r
 572 }\r
 573 \r
 574 \r
 575 /** \brief  Set Control Register\r
 576 \r
 577     This function writes the given value to the Control Register.\r
 578 \r
 579     \param [in]    control  Control Register value to set\r
 580  */\r
 581 __attribute__( ( always_inline ) ) static __INLINE void __set_CONTROL(uint32_t control)\r
 582 {\r
 583   __ASM volatile ("MSR control, %0" : : "r" (control) );\r
 584 }\r
 585 \r
 586 \r
 587 /** \brief  Get ISPR Register\r
 588 \r
 589     This function returns the content of the ISPR Register.\r
 590 \r
 591     \return               ISPR Register value\r
 592  */\r
 593 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_IPSR(void)\r
 594 {\r
 595   uint32_t result;\r
 596 \r
 597   __ASM volatile ("MRS %0, ipsr" : "=r" (result) );\r
 598   return(result);\r
 599 }\r
 600 \r
 601 \r
 602 /** \brief  Get APSR Register\r
 603 \r
 604     This function returns the content of the APSR Register.\r
 605 \r
 606     \return               APSR Register value\r
 607  */\r
 608 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_APSR(void)\r
 609 {\r
 610   uint32_t result;\r
 611 \r
 612   __ASM volatile ("MRS %0, apsr" : "=r" (result) );\r
 613   return(result);\r
 614 }\r
 615 \r
 616 \r
 617 /** \brief  Get xPSR Register\r
 618 \r
 619     This function returns the content of the xPSR Register.\r
 620 \r
 621     \return               xPSR Register value\r
 622  */\r
 623 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_xPSR(void)\r
 624 {\r
 625   uint32_t result;\r
 626 \r
 627   __ASM volatile ("MRS %0, xpsr" : "=r" (result) );\r
 628   return(result);\r
 629 }\r
 630 \r
 631 \r
 632 /** \brief  Get Process Stack Pointer\r
 633 \r
 634     This function returns the current value of the Process Stack Pointer (PSP).\r
 635 \r
 636     \return               PSP Register value\r
 637  */\r
 638 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_PSP(void)\r
 639 {\r
 640   register uint32_t result;\r
 641 \r
 642   __ASM volatile ("MRS %0, psp\n"  : "=r" (result) );\r
 643   return(result);\r
 644 }\r
 645  \r
 646 \r
 647 /** \brief  Set Process Stack Pointer\r
 648 \r
 649     This function assigns the given value to the Process Stack Pointer (PSP).\r
 650 \r
 651     \param [in]    topOfProcStack  Process Stack Pointer value to set\r
 652  */\r
 653 __attribute__( ( always_inline ) ) static __INLINE void __set_PSP(uint32_t topOfProcStack)\r
 654 {\r
 655   __ASM volatile ("MSR psp, %0\n" : : "r" (topOfProcStack) );\r
 656 }\r
 657 \r
 658 \r
 659 /** \brief  Get Main Stack Pointer\r
 660 \r
 661     This function returns the current value of the Main Stack Pointer (MSP).\r
 662 \r
 663     \return               MSP Register value\r
 664  */\r
 665 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_MSP(void)\r
 666 {\r
 667   register uint32_t result;\r
 668 \r
 669   __ASM volatile ("MRS %0, msp\n" : "=r" (result) );\r
 670   return(result);\r
 671 }\r
 672  \r
 673 \r
 674 /** \brief  Set Main Stack Pointer\r
 675 \r
 676     This function assigns the given value to the Main Stack Pointer (MSP).\r
 677 \r
 678     \param [in]    topOfMainStack  Main Stack Pointer value to set\r
 679  */\r
 680 __attribute__( ( always_inline ) ) static __INLINE void __set_MSP(uint32_t topOfMainStack)\r
 681 {\r
 682   __ASM volatile ("MSR msp, %0\n" : : "r" (topOfMainStack) );\r
 683 }\r
 684 \r
 685 \r
 686 /** \brief  Get Priority Mask\r
 687 \r
 688     This function returns the current state of the priority mask bit from the Priority Mask Register.\r
 689 \r
 690     \return               Priority Mask value\r
 691  */\r
 692 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_PRIMASK(void)\r
 693 {\r
 694   uint32_t result;\r
 695 \r
 696   __ASM volatile ("MRS %0, primask" : "=r" (result) );\r
 697   return(result);\r
 698 }\r
 699 \r
 700 \r
 701 /** \brief  Set Priority Mask\r
 702 \r
 703     This function assigns the given value to the Priority Mask Register.\r
 704 \r
 705     \param [in]    priMask  Priority Mask\r
 706  */\r
 707 __attribute__( ( always_inline ) ) static __INLINE void __set_PRIMASK(uint32_t priMask)\r
 708 {\r
 709   __ASM volatile ("MSR primask, %0" : : "r" (priMask) );\r
 710 }\r
 711  \r
 712 \r
 713 #if       (__CORTEX_M >= 0x03)\r
 714 \r
 715 /** \brief  Enable FIQ\r
 716 \r
 717     This function enables FIQ interrupts by clearing the F-bit in the CPSR.\r
 718     Can only be executed in Privileged modes.\r
 719  */\r
 720 __attribute__( ( always_inline ) ) static __INLINE void __enable_fault_irq(void)\r
 721 {\r
 722   __ASM volatile ("cpsie f");\r
 723 }\r
 724 \r
 725 \r
 726 /** \brief  Disable FIQ\r
 727 \r
 728     This function disables FIQ interrupts by setting the F-bit in the CPSR.\r
 729     Can only be executed in Privileged modes.\r
 730  */\r
 731 __attribute__( ( always_inline ) ) static __INLINE void __disable_fault_irq(void)\r
 732 {\r
 733   __ASM volatile ("cpsid f");\r
 734 }\r
 735 \r
 736 \r
 737 /** \brief  Get Base Priority\r
 738 \r
 739     This function returns the current value of the Base Priority register.\r
 740 \r
 741     \return               Base Priority register value\r
 742  */\r
 743 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_BASEPRI(void)\r
 744 {\r
 745   uint32_t result;\r
 746   \r
 747   __ASM volatile ("MRS %0, basepri_max" : "=r" (result) );\r
 748   return(result);\r
 749 }\r
 750 \r
 751 \r
 752 /** \brief  Set Base Priority\r
 753 \r
 754     This function assigns the given value to the Base Priority register.\r
 755 \r
 756     \param [in]    basePri  Base Priority value to set\r
 757  */\r
 758 __attribute__( ( always_inline ) ) static __INLINE void __set_BASEPRI(uint32_t value)\r
 759 {\r
 760   __ASM volatile ("MSR basepri, %0" : : "r" (value) );\r
 761 }\r
 762 \r
 763 \r
 764 /** \brief  Get Fault Mask\r
 765 \r
 766     This function returns the current value of the Fault Mask register.\r
 767 \r
 768     \return               Fault Mask register value\r
 769  */\r
 770 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_FAULTMASK(void)\r
 771 {\r
 772   uint32_t result;\r
 773   \r
 774   __ASM volatile ("MRS %0, faultmask" : "=r" (result) );\r
 775   return(result);\r
 776 }\r
 777 \r
 778 \r
 779 /** \brief  Set Fault Mask\r
 780 \r
 781     This function assigns the given value to the Fault Mask register.\r
 782 \r
 783     \param [in]    faultMask  Fault Mask value to set\r
 784  */\r
 785 __attribute__( ( always_inline ) ) static __INLINE void __set_FAULTMASK(uint32_t faultMask)\r
 786 {\r
 787   __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) );\r
 788 }\r
 789 \r
 790 #endif /* (__CORTEX_M >= 0x03) */\r
 791 \r
 792 \r
 793 #if       (__CORTEX_M == 0x04)\r
 794 \r
 795 /** \brief  Get FPSCR\r
 796 \r
 797     This function returns the current value of the Floating Point Status/Control register.\r
 798 \r
 799     \return               Floating Point Status/Control register value\r
 800  */\r
 801 __attribute__( ( always_inline ) ) static __INLINE uint32_t __get_FPSCR(void)\r
 802 {\r
 803 #if (__FPU_PRESENT == 1)\r
 804   uint32_t result;\r
 805 \r
 806   __ASM volatile ("MRS %0, fpscr" : "=r" (result) );\r
 807   return(result);\r
 808 #else\r
 809    return(0);\r
 810 #endif\r
 811 }\r
 812 \r
 813 \r
 814 /** \brief  Set FPSCR\r
 815 \r
 816     This function assigns the given value to the Floating Point Status/Control register.\r
 817 \r
 818     \param [in]    fpscr  Floating Point Status/Control value to set\r
 819  */\r
 820 __attribute__( ( always_inline ) ) static __INLINE void __set_FPSCR(uint32_t fpscr)\r
 821 {\r
 822 #if (__FPU_PRESENT == 1)\r
 823   __ASM volatile ("MSR fpscr, %0" : : "r" (fpscr) );\r
 824 #endif\r
 825 }\r
 826 \r
 827 #endif /* (__CORTEX_M == 0x04) */\r
 828 \r
 829 \r
 830 #elif (defined (__TASKING__)) /*--------------- TASKING Compiler -----------------*/\r
 831 /* TASKING carm specific functions */\r
 832 \r
 833 /*\r
 834  * The CMSIS functions have been implemented as intrinsics in the compiler.\r
 835  * Please use "carm -?i" to get an up to date list of all instrinsics,\r
 836  * Including the CMSIS ones.\r
 837  */\r
 838 \r
 839 #endif\r
 840 \r
 841 /*@} end of CMSIS_Core_RegAccFunctions */\r
 842 \r
 843 \r
 844 #endif /* __CORE_CMFUNC_H__ */\r