git.sur5r.net Git - freertos/blob - Demo/CORTEX_STM32L152_IAR/system_and_ST_code/CMSIS/CM3/CoreSupport/core_cm3.c

   1 /**************************************************************************//**\r
   2  * @file     core_cm3.c\r
   3  * @brief    CMSIS Cortex-M3 Core Peripheral Access Layer Source File\r
   4  * @version  V1.30\r
   5  * @date     30. October 2009\r
   6  *\r
   7  * @note\r
   8  * Copyright (C) 2009 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 #include <stdint.h>\r
  25 \r
  26 /* define compiler specific symbols */\r
  27 #if defined ( __CC_ARM   )\r
  28   #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler          */\r
  29   #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler       */\r
  30 \r
  31 #elif defined ( __ICCARM__ )\r
  32   #define __ASM           __asm                                       /*!< asm keyword for IAR Compiler          */\r
  33   #define __INLINE        inline                                      /*!< inline keyword for IAR Compiler. Only avaiable in High optimization mode! */\r
  34 \r
  35 #elif defined   (  __GNUC__  )\r
  36   #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler          */\r
  37   #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler       */\r
  38 \r
  39 #elif defined   (  __TASKING__  )\r
  40   #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler      */\r
  41   #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler   */\r
  42 \r
  43 #endif\r
  44 \r
  45 \r
  46 /* ###################  Compiler specific Intrinsics  ########################### */\r
  47 \r
  48 #if defined ( __CC_ARM   ) /*------------------RealView Compiler -----------------*/\r
  49 /* ARM armcc specific functions */\r
  50 \r
  51 /**\r
  52  * @brief  Return the Process Stack Pointer\r
  53  *\r
  54  * @return ProcessStackPointer\r
  55  *\r
  56  * Return the actual process stack pointer\r
  57  */\r
  58 __ASM uint32_t __get_PSP(void)\r
  59 {\r
  60   mrs r0, psp\r
  61   bx lr\r
  62 }\r
  63 \r
  64 /**\r
  65  * @brief  Set the Process Stack Pointer\r
  66  *\r
  67  * @param  topOfProcStack  Process Stack Pointer\r
  68  *\r
  69  * Assign the value ProcessStackPointer to the MSP \r
  70  * (process stack pointer) Cortex processor register\r
  71  */\r
  72 __ASM void __set_PSP(uint32_t topOfProcStack)\r
  73 {\r
  74   msr psp, r0\r
  75   bx lr\r
  76 }\r
  77 \r
  78 /**\r
  79  * @brief  Return the Main Stack Pointer\r
  80  *\r
  81  * @return Main Stack Pointer\r
  82  *\r
  83  * Return the current value of the MSP (main stack pointer)\r
  84  * Cortex processor register\r
  85  */\r
  86 __ASM uint32_t __get_MSP(void)\r
  87 {\r
  88   mrs r0, msp\r
  89   bx lr\r
  90 }\r
  91 \r
  92 /**\r
  93  * @brief  Set the Main Stack Pointer\r
  94  *\r
  95  * @param  topOfMainStack  Main Stack Pointer\r
  96  *\r
  97  * Assign the value mainStackPointer to the MSP \r
  98  * (main stack pointer) Cortex processor register\r
  99  */\r
 100 __ASM void __set_MSP(uint32_t mainStackPointer)\r
 101 {\r
 102   msr msp, r0\r
 103   bx lr\r
 104 }\r
 105 \r
 106 /**\r
 107  * @brief  Reverse byte order in unsigned short value\r
 108  *\r
 109  * @param   value  value to reverse\r
 110  * @return         reversed value\r
 111  *\r
 112  * Reverse byte order in unsigned short value\r
 113  */\r
 114 __ASM uint32_t __REV16(uint16_t value)\r
 115 {\r
 116   rev16 r0, r0\r
 117   bx lr\r
 118 }\r
 119 \r
 120 /**\r
 121  * @brief  Reverse byte order in signed short value with sign extension to integer\r
 122  *\r
 123  * @param   value  value to reverse\r
 124  * @return         reversed value\r
 125  *\r
 126  * Reverse byte order in signed short value with sign extension to integer\r
 127  */\r
 128 __ASM int32_t __REVSH(int16_t value)\r
 129 {\r
 130   revsh r0, r0\r
 131   bx lr\r
 132 }\r
 133 \r
 134 \r
 135 #if (__ARMCC_VERSION < 400000)\r
 136 \r
 137 /**\r
 138  * @brief  Remove the exclusive lock created by ldrex\r
 139  *\r
 140  * Removes the exclusive lock which is created by ldrex.\r
 141  */\r
 142 __ASM void __CLREX(void)\r
 143 {\r
 144   clrex\r
 145 }\r
 146 \r
 147 /**\r
 148  * @brief  Return the Base Priority value\r
 149  *\r
 150  * @return BasePriority\r
 151  *\r
 152  * Return the content of the base priority register\r
 153  */\r
 154 __ASM uint32_t  __get_BASEPRI(void)\r
 155 {\r
 156   mrs r0, basepri\r
 157   bx lr\r
 158 }\r
 159 \r
 160 /**\r
 161  * @brief  Set the Base Priority value\r
 162  *\r
 163  * @param  basePri  BasePriority\r
 164  *\r
 165  * Set the base priority register\r
 166  */\r
 167 __ASM void __set_BASEPRI(uint32_t basePri)\r
 168 {\r
 169   msr basepri, r0\r
 170   bx lr\r
 171 }\r
 172 \r
 173 /**\r
 174  * @brief  Return the Priority Mask value\r
 175  *\r
 176  * @return PriMask\r
 177  *\r
 178  * Return state of the priority mask bit from the priority mask register\r
 179  */\r
 180 __ASM uint32_t __get_PRIMASK(void)\r
 181 {\r
 182   mrs r0, primask\r
 183   bx lr\r
 184 }\r
 185 \r
 186 /**\r
 187  * @brief  Set the Priority Mask value\r
 188  *\r
 189  * @param  priMask  PriMask\r
 190  *\r
 191  * Set the priority mask bit in the priority mask register\r
 192  */\r
 193 __ASM void __set_PRIMASK(uint32_t priMask)\r
 194 {\r
 195   msr primask, r0\r
 196   bx lr\r
 197 }\r
 198 \r
 199 /**\r
 200  * @brief  Return the Fault Mask value\r
 201  *\r
 202  * @return FaultMask\r
 203  *\r
 204  * Return the content of the fault mask register\r
 205  */\r
 206 __ASM uint32_t  __get_FAULTMASK(void)\r
 207 {\r
 208   mrs r0, faultmask\r
 209   bx lr\r
 210 }\r
 211 \r
 212 /**\r
 213  * @brief  Set the Fault Mask value\r
 214  *\r
 215  * @param  faultMask  faultMask value\r
 216  *\r
 217  * Set the fault mask register\r
 218  */\r
 219 __ASM void __set_FAULTMASK(uint32_t faultMask)\r
 220 {\r
 221   msr faultmask, r0\r
 222   bx lr\r
 223 }\r
 224 \r
 225 /**\r
 226  * @brief  Return the Control Register value\r
 227  * \r
 228  * @return Control value\r
 229  *\r
 230  * Return the content of the control register\r
 231  */\r
 232 __ASM uint32_t __get_CONTROL(void)\r
 233 {\r
 234   mrs r0, control\r
 235   bx lr\r
 236 }\r
 237 \r
 238 /**\r
 239  * @brief  Set the Control Register value\r
 240  *\r
 241  * @param  control  Control value\r
 242  *\r
 243  * Set the control register\r
 244  */\r
 245 __ASM void __set_CONTROL(uint32_t control)\r
 246 {\r
 247   msr control, r0\r
 248   bx lr\r
 249 }\r
 250 \r
 251 #endif /* __ARMCC_VERSION  */ \r
 252 \r
 253 \r
 254 \r
 255 #elif (defined (__ICCARM__)) /*------------------ ICC Compiler -------------------*/\r
 256 /* IAR iccarm specific functions */\r
 257 #pragma diag_suppress=Pe940\r
 258 \r
 259 /**\r
 260  * @brief  Return the Process Stack Pointer\r
 261  *\r
 262  * @return ProcessStackPointer\r
 263  *\r
 264  * Return the actual process stack pointer\r
 265  */\r
 266 uint32_t __get_PSP(void)\r
 267 {\r
 268   __ASM("mrs r0, psp");\r
 269   __ASM("bx lr");\r
 270 }\r
 271 \r
 272 /**\r
 273  * @brief  Set the Process Stack Pointer\r
 274  *\r
 275  * @param  topOfProcStack  Process Stack Pointer\r
 276  *\r
 277  * Assign the value ProcessStackPointer to the MSP \r
 278  * (process stack pointer) Cortex processor register\r
 279  */\r
 280 void __set_PSP(uint32_t topOfProcStack)\r
 281 {\r
 282   __ASM("msr psp, r0");\r
 283   __ASM("bx lr");\r
 284 }\r
 285 \r
 286 /**\r
 287  * @brief  Return the Main Stack Pointer\r
 288  *\r
 289  * @return Main Stack Pointer\r
 290  *\r
 291  * Return the current value of the MSP (main stack pointer)\r
 292  * Cortex processor register\r
 293  */\r
 294 uint32_t __get_MSP(void)\r
 295 {\r
 296   __ASM("mrs r0, msp");\r
 297   __ASM("bx lr");\r
 298 }\r
 299 \r
 300 /**\r
 301  * @brief  Set the Main Stack Pointer\r
 302  *\r
 303  * @param  topOfMainStack  Main Stack Pointer\r
 304  *\r
 305  * Assign the value mainStackPointer to the MSP \r
 306  * (main stack pointer) Cortex processor register\r
 307  */\r
 308 void __set_MSP(uint32_t topOfMainStack)\r
 309 {\r
 310   __ASM("msr msp, r0");\r
 311   __ASM("bx lr");\r
 312 }\r
 313 \r
 314 /**\r
 315  * @brief  Reverse byte order in unsigned short value\r
 316  *\r
 317  * @param  value  value to reverse\r
 318  * @return        reversed value\r
 319  *\r
 320  * Reverse byte order in unsigned short value\r
 321  */\r
 322 uint32_t __REV16(uint16_t value)\r
 323 {\r
 324   __ASM("rev16 r0, r0");\r
 325   __ASM("bx lr");\r
 326 }\r
 327 \r
 328 /**\r
 329  * @brief  Reverse bit order of value\r
 330  *\r
 331  * @param  value  value to reverse\r
 332  * @return        reversed value\r
 333  *\r
 334  * Reverse bit order of value\r
 335  */\r
 336 uint32_t __RBIT(uint32_t value)\r
 337 {\r
 338   __ASM("rbit r0, r0");\r
 339   __ASM("bx lr");\r
 340 }\r
 341 \r
 342 /**\r
 343  * @brief  LDR Exclusive (8 bit)\r
 344  *\r
 345  * @param  *addr  address pointer\r
 346  * @return        value of (*address)\r
 347  *\r
 348  * Exclusive LDR command for 8 bit values)\r
 349  */\r
 350 uint8_t __LDREXB(uint8_t *addr)\r
 351 {\r
 352   __ASM("ldrexb r0, [r0]");\r
 353   __ASM("bx lr"); \r
 354 }\r
 355 \r
 356 /**\r
 357  * @brief  LDR Exclusive (16 bit)\r
 358  *\r
 359  * @param  *addr  address pointer\r
 360  * @return        value of (*address)\r
 361  *\r
 362  * Exclusive LDR command for 16 bit values\r
 363  */\r
 364 uint16_t __LDREXH(uint16_t *addr)\r
 365 {\r
 366   __ASM("ldrexh r0, [r0]");\r
 367   __ASM("bx lr");\r
 368 }\r
 369 \r
 370 /**\r
 371  * @brief  LDR Exclusive (32 bit)\r
 372  *\r
 373  * @param  *addr  address pointer\r
 374  * @return        value of (*address)\r
 375  *\r
 376  * Exclusive LDR command for 32 bit values\r
 377  */\r
 378 uint32_t __LDREXW(uint32_t *addr)\r
 379 {\r
 380   __ASM("ldrex r0, [r0]");\r
 381   __ASM("bx lr");\r
 382 }\r
 383 \r
 384 /**\r
 385  * @brief  STR Exclusive (8 bit)\r
 386  *\r
 387  * @param  value  value to store\r
 388  * @param  *addr  address pointer\r
 389  * @return        successful / failed\r
 390  *\r
 391  * Exclusive STR command for 8 bit values\r
 392  */\r
 393 uint32_t __STREXB(uint8_t value, uint8_t *addr)\r
 394 {\r
 395   __ASM("strexb r0, r0, [r1]");\r
 396   __ASM("bx lr");\r
 397 }\r
 398 \r
 399 /**\r
 400  * @brief  STR Exclusive (16 bit)\r
 401  *\r
 402  * @param  value  value to store\r
 403  * @param  *addr  address pointer\r
 404  * @return        successful / failed\r
 405  *\r
 406  * Exclusive STR command for 16 bit values\r
 407  */\r
 408 uint32_t __STREXH(uint16_t value, uint16_t *addr)\r
 409 {\r
 410   __ASM("strexh r0, r0, [r1]");\r
 411   __ASM("bx lr");\r
 412 }\r
 413 \r
 414 /**\r
 415  * @brief  STR Exclusive (32 bit)\r
 416  *\r
 417  * @param  value  value to store\r
 418  * @param  *addr  address pointer\r
 419  * @return        successful / failed\r
 420  *\r
 421  * Exclusive STR command for 32 bit values\r
 422  */\r
 423 uint32_t __STREXW(uint32_t value, uint32_t *addr)\r
 424 {\r
 425   __ASM("strex r0, r0, [r1]");\r
 426   __ASM("bx lr");\r
 427 }\r
 428 \r
 429 #pragma diag_default=Pe940\r
 430 \r
 431 \r
 432 #elif (defined (__GNUC__)) /*------------------ GNU Compiler ---------------------*/\r
 433 /* GNU gcc specific functions */\r
 434 \r
 435 /**\r
 436  * @brief  Return the Process Stack Pointer\r
 437  *\r
 438  * @return ProcessStackPointer\r
 439  *\r
 440  * Return the actual process stack pointer\r
 441  */\r
 442 uint32_t __get_PSP(void) __attribute__( ( naked ) );\r
 443 uint32_t __get_PSP(void)\r
 444 {\r
 445   uint32_t result=0;\r
 446 \r
 447   __ASM volatile ("MRS %0, psp\n\t" \r
 448                   "MOV r0, %0 \n\t"\r
 449                   "BX  lr     \n\t"  : "=r" (result) );\r
 450   return(result);\r
 451 }\r
 452 \r
 453 /**\r
 454  * @brief  Set the Process Stack Pointer\r
 455  *\r
 456  * @param  topOfProcStack  Process Stack Pointer\r
 457  *\r
 458  * Assign the value ProcessStackPointer to the MSP \r
 459  * (process stack pointer) Cortex processor register\r
 460  */\r
 461 void __set_PSP(uint32_t topOfProcStack) __attribute__( ( naked ) );\r
 462 void __set_PSP(uint32_t topOfProcStack)\r
 463 {\r
 464   __ASM volatile ("MSR psp, %0\n\t"\r
 465                   "BX  lr     \n\t" : : "r" (topOfProcStack) );\r
 466 }\r
 467 \r
 468 /**\r
 469  * @brief  Return the Main Stack Pointer\r
 470  *\r
 471  * @return Main Stack Pointer\r
 472  *\r
 473  * Return the current value of the MSP (main stack pointer)\r
 474  * Cortex processor register\r
 475  */\r
 476 uint32_t __get_MSP(void) __attribute__( ( naked ) );\r
 477 uint32_t __get_MSP(void)\r
 478 {\r
 479   uint32_t result=0;\r
 480 \r
 481   __ASM volatile ("MRS %0, msp\n\t" \r
 482                   "MOV r0, %0 \n\t"\r
 483                   "BX  lr     \n\t"  : "=r" (result) );\r
 484   return(result);\r
 485 }\r
 486 \r
 487 /**\r
 488  * @brief  Set the Main Stack Pointer\r
 489  *\r
 490  * @param  topOfMainStack  Main Stack Pointer\r
 491  *\r
 492  * Assign the value mainStackPointer to the MSP \r
 493  * (main stack pointer) Cortex processor register\r
 494  */\r
 495 void __set_MSP(uint32_t topOfMainStack) __attribute__( ( naked ) );\r
 496 void __set_MSP(uint32_t topOfMainStack)\r
 497 {\r
 498   __ASM volatile ("MSR msp, %0\n\t"\r
 499                   "BX  lr     \n\t" : : "r" (topOfMainStack) );\r
 500 }\r
 501 \r
 502 /**\r
 503  * @brief  Return the Base Priority value\r
 504  *\r
 505  * @return BasePriority\r
 506  *\r
 507  * Return the content of the base priority register\r
 508  */\r
 509 uint32_t __get_BASEPRI(void)\r
 510 {\r
 511   uint32_t result=0;\r
 512   \r
 513   __ASM volatile ("MRS %0, basepri_max" : "=r" (result) );\r
 514   return(result);\r
 515 }\r
 516 \r
 517 /**\r
 518  * @brief  Set the Base Priority value\r
 519  *\r
 520  * @param  basePri  BasePriority\r
 521  *\r
 522  * Set the base priority register\r
 523  */\r
 524 void __set_BASEPRI(uint32_t value)\r
 525 {\r
 526   __ASM volatile ("MSR basepri, %0" : : "r" (value) );\r
 527 }\r
 528 \r
 529 /**\r
 530  * @brief  Return the Priority Mask value\r
 531  *\r
 532  * @return PriMask\r
 533  *\r
 534  * Return state of the priority mask bit from the priority mask register\r
 535  */\r
 536 uint32_t __get_PRIMASK(void)\r
 537 {\r
 538   uint32_t result=0;\r
 539 \r
 540   __ASM volatile ("MRS %0, primask" : "=r" (result) );\r
 541   return(result);\r
 542 }\r
 543 \r
 544 /**\r
 545  * @brief  Set the Priority Mask value\r
 546  *\r
 547  * @param  priMask  PriMask\r
 548  *\r
 549  * Set the priority mask bit in the priority mask register\r
 550  */\r
 551 void __set_PRIMASK(uint32_t priMask)\r
 552 {\r
 553   __ASM volatile ("MSR primask, %0" : : "r" (priMask) );\r
 554 }\r
 555 \r
 556 /**\r
 557  * @brief  Return the Fault Mask value\r
 558  *\r
 559  * @return FaultMask\r
 560  *\r
 561  * Return the content of the fault mask register\r
 562  */\r
 563 uint32_t __get_FAULTMASK(void)\r
 564 {\r
 565   uint32_t result=0;\r
 566   \r
 567   __ASM volatile ("MRS %0, faultmask" : "=r" (result) );\r
 568   return(result);\r
 569 }\r
 570 \r
 571 /**\r
 572  * @brief  Set the Fault Mask value\r
 573  *\r
 574  * @param  faultMask  faultMask value\r
 575  *\r
 576  * Set the fault mask register\r
 577  */\r
 578 void __set_FAULTMASK(uint32_t faultMask)\r
 579 {\r
 580   __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) );\r
 581 }\r
 582 \r
 583 /**\r
 584  * @brief  Return the Control Register value\r
 585 * \r
 586 *  @return Control value\r
 587  *\r
 588  * Return the content of the control register\r
 589  */\r
 590 uint32_t __get_CONTROL(void)\r
 591 {\r
 592   uint32_t result=0;\r
 593 \r
 594   __ASM volatile ("MRS %0, control" : "=r" (result) );\r
 595   return(result);\r
 596 }\r
 597 \r
 598 /**\r
 599  * @brief  Set the Control Register value\r
 600  *\r
 601  * @param  control  Control value\r
 602  *\r
 603  * Set the control register\r
 604  */\r
 605 void __set_CONTROL(uint32_t control)\r
 606 {\r
 607   __ASM volatile ("MSR control, %0" : : "r" (control) );\r
 608 }\r
 609 \r
 610 \r
 611 /**\r
 612  * @brief  Reverse byte order in integer value\r
 613  *\r
 614  * @param  value  value to reverse\r
 615  * @return        reversed value\r
 616  *\r
 617  * Reverse byte order in integer value\r
 618  */\r
 619 uint32_t __REV(uint32_t value)\r
 620 {\r
 621   uint32_t result=0;\r
 622   \r
 623   __ASM volatile ("rev %0, %1" : "=r" (result) : "r" (value) );\r
 624   return(result);\r
 625 }\r
 626 \r
 627 /**\r
 628  * @brief  Reverse byte order in unsigned short value\r
 629  *\r
 630  * @param  value  value to reverse\r
 631  * @return        reversed value\r
 632  *\r
 633  * Reverse byte order in unsigned short value\r
 634  */\r
 635 uint32_t __REV16(uint16_t value)\r
 636 {\r
 637   uint32_t result=0;\r
 638   \r
 639   __ASM volatile ("rev16 %0, %1" : "=r" (result) : "r" (value) );\r
 640   return(result);\r
 641 }\r
 642 \r
 643 /**\r
 644  * @brief  Reverse byte order in signed short value with sign extension to integer\r
 645  *\r
 646  * @param  value  value to reverse\r
 647  * @return        reversed value\r
 648  *\r
 649  * Reverse byte order in signed short value with sign extension to integer\r
 650  */\r
 651 int32_t __REVSH(int16_t value)\r
 652 {\r
 653   uint32_t result=0;\r
 654   \r
 655   __ASM volatile ("revsh %0, %1" : "=r" (result) : "r" (value) );\r
 656   return(result);\r
 657 }\r
 658 \r
 659 /**\r
 660  * @brief  Reverse bit order of value\r
 661  *\r
 662  * @param  value  value to reverse\r
 663  * @return        reversed value\r
 664  *\r
 665  * Reverse bit order of value\r
 666  */\r
 667 uint32_t __RBIT(uint32_t value)\r
 668 {\r
 669   uint32_t result=0;\r
 670   \r
 671    __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) );\r
 672    return(result);\r
 673 }\r
 674 \r
 675 /**\r
 676  * @brief  LDR Exclusive (8 bit)\r
 677  *\r
 678  * @param  *addr  address pointer\r
 679  * @return        value of (*address)\r
 680  *\r
 681  * Exclusive LDR command for 8 bit value\r
 682  */\r
 683 uint8_t __LDREXB(uint8_t *addr)\r
 684 {\r
 685     uint8_t result=0;\r
 686   \r
 687    __ASM volatile ("ldrexb %0, [%1]" : "=r" (result) : "r" (addr) );\r
 688    return(result);\r
 689 }\r
 690 \r
 691 /**\r
 692  * @brief  LDR Exclusive (16 bit)\r
 693  *\r
 694  * @param  *addr  address pointer\r
 695  * @return        value of (*address)\r
 696  *\r
 697  * Exclusive LDR command for 16 bit values\r
 698  */\r
 699 uint16_t __LDREXH(uint16_t *addr)\r
 700 {\r
 701     uint16_t result=0;\r
 702   \r
 703    __ASM volatile ("ldrexh %0, [%1]" : "=r" (result) : "r" (addr) );\r
 704    return(result);\r
 705 }\r
 706 \r
 707 /**\r
 708  * @brief  LDR Exclusive (32 bit)\r
 709  *\r
 710  * @param  *addr  address pointer\r
 711  * @return        value of (*address)\r
 712  *\r
 713  * Exclusive LDR command for 32 bit values\r
 714  */\r
 715 uint32_t __LDREXW(uint32_t *addr)\r
 716 {\r
 717     uint32_t result=0;\r
 718   \r
 719    __ASM volatile ("ldrex %0, [%1]" : "=r" (result) : "r" (addr) );\r
 720    return(result);\r
 721 }\r
 722 \r
 723 /**\r
 724  * @brief  STR Exclusive (8 bit)\r
 725  *\r
 726  * @param  value  value to store\r
 727  * @param  *addr  address pointer\r
 728  * @return        successful / failed\r
 729  *\r
 730  * Exclusive STR command for 8 bit values\r
 731  */\r
 732 uint32_t __STREXB(uint8_t value, uint8_t *addr)\r
 733 {\r
 734    uint32_t result=0;\r
 735   \r
 736    __ASM volatile ("strexb %0, %2, [%1]" : "=r" (result) : "r" (addr), "r" (value) );\r
 737    return(result);\r
 738 }\r
 739 \r
 740 /**\r
 741  * @brief  STR Exclusive (16 bit)\r
 742  *\r
 743  * @param  value  value to store\r
 744  * @param  *addr  address pointer\r
 745  * @return        successful / failed\r
 746  *\r
 747  * Exclusive STR command for 16 bit values\r
 748  */\r
 749 uint32_t __STREXH(uint16_t value, uint16_t *addr)\r
 750 {\r
 751    uint32_t result=0;\r
 752   \r
 753    __ASM volatile ("strexh %0, %2, [%1]" : "=r" (result) : "r" (addr), "r" (value) );\r
 754    return(result);\r
 755 }\r
 756 \r
 757 /**\r
 758  * @brief  STR Exclusive (32 bit)\r
 759  *\r
 760  * @param  value  value to store\r
 761  * @param  *addr  address pointer\r
 762  * @return        successful / failed\r
 763  *\r
 764  * Exclusive STR command for 32 bit values\r
 765  */\r
 766 uint32_t __STREXW(uint32_t value, uint32_t *addr)\r
 767 {\r
 768    uint32_t result=0;\r
 769   \r
 770    __ASM volatile ("strex %0, %2, [%1]" : "=r" (result) : "r" (addr), "r" (value) );\r
 771    return(result);\r
 772 }\r
 773 \r
 774 \r
 775 #elif (defined (__TASKING__)) /*------------------ TASKING Compiler ---------------------*/\r
 776 /* TASKING carm specific functions */\r
 777 \r
 778 /*\r
 779  * The CMSIS functions have been implemented as intrinsics in the compiler.\r
 780  * Please use "carm -?i" to get an up to date list of all instrinsics,\r
 781  * Including the CMSIS ones.\r
 782  */\r
 783 \r
 784 #endif\r