new_cmsis/core_cm3.c

   1 /******************************************************************************\r
   2  * @file:    core_cm3.c\r
   3  * @purpose: CMSIS Cortex-M3 Core Peripheral Access Layer Source File\r
   4  * @version: V1.20\r
   5  * @date:    22. May 2009\r
   6  *----------------------------------------------------------------------------\r
   7  *\r
   8  * Copyright (C) 2009 ARM Limited. All rights reserved.\r
   9  *\r
  10  * ARM Limited (ARM) is supplying this software for use with Cortex-Mx \r
  11  * processor based microcontrollers.  This file can be freely distributed \r
  12  * within development tools that are supporting such ARM based processors. \r
  13  *\r
  14  * THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED\r
  15  * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF\r
  16  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.\r
  17  * ARM SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR\r
  18  * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.\r
  19  *\r
  20  ******************************************************************************/\r
  21 \r
  22 \r
  23 \r
  24 #include <stdint.h>\r
  25 \r
  26 \r
  27 /* define compiler specific symbols */\r
  28 #if defined   ( __CC_ARM   )\r
  29   #define __ASM            __asm           /*!< asm keyword for armcc           */\r
  30   #define __INLINE         __inline        /*!< inline keyword for armcc        */\r
  31 \r
  32 #elif defined ( __ICCARM__ )\r
  33   #define __ASM           __asm            /*!< asm keyword for iarcc           */\r
  34   #define __INLINE        inline           /*!< inline keyword for iarcc. Only avaiable in High optimization mode! */\r
  35 \r
  36 #elif defined (  __GNUC__  )\r
  37   #define __ASM             __asm          /*!< asm keyword for gcc            */\r
  38   #define __INLINE          inline         /*!< inline keyword for gcc         */\r
  39 \r
  40 #elif defined   (  __TASKING__  )\r
  41   #define __ASM            __asm           /*!< asm keyword for TASKING Compiler          */\r
  42   #define __INLINE         inline          /*!< inline keyword for TASKING Compiler       */\r
  43 \r
  44 #endif\r
  45 \r
  46 \r
  47 \r
  48 #if defined ( __CC_ARM   ) /*------------------RealView Compiler -----------------*/\r
  49 \r
  50 /**\r
  51  * @brief  Return the Process Stack Pointer\r
  52  *\r
  53  * @param  none\r
  54  * @return uint32_t 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  uint32_t Process Stack Pointer\r
  68  * @return none\r
  69  *\r
  70  * Assign the value ProcessStackPointer to the MSP \r
  71  * (process stack pointer) Cortex processor register\r
  72  */\r
  73 __ASM void __set_PSP(uint32_t topOfProcStack)\r
  74 {\r
  75   msr psp, r0\r
  76   bx lr\r
  77 }\r
  78 \r
  79 /**\r
  80  * @brief  Return the Main Stack Pointer\r
  81  *\r
  82  * @param  none\r
  83  * @return uint32_t Main Stack Pointer\r
  84  *\r
  85  * Return the current value of the MSP (main stack pointer)\r
  86  * Cortex processor register\r
  87  */\r
  88 __ASM uint32_t __get_MSP(void)\r
  89 {\r
  90   mrs r0, msp\r
  91   bx lr\r
  92 }\r
  93 \r
  94 /**\r
  95  * @brief  Set the Main Stack Pointer\r
  96  *\r
  97  * @param  uint32_t Main Stack Pointer\r
  98  * @return none\r
  99  *\r
 100  * Assign the value mainStackPointer to the MSP \r
 101  * (main stack pointer) Cortex processor register\r
 102  */\r
 103 __ASM void __set_MSP(uint32_t mainStackPointer)\r
 104 {\r
 105   msr msp, r0\r
 106   bx lr\r
 107 }\r
 108 \r
 109 /**\r
 110  * @brief  Reverse byte order in unsigned short value\r
 111  *\r
 112  * @param  uint16_t value to reverse\r
 113  * @return uint32_t reversed value\r
 114  *\r
 115  * Reverse byte order in unsigned short value\r
 116  */\r
 117 __ASM uint32_t __REV16(uint16_t value)\r
 118 {\r
 119   rev16 r0, r0\r
 120   bx lr\r
 121 }\r
 122 \r
 123 /**\r
 124  * @brief  Reverse byte order in signed short value with sign extension to integer\r
 125  *\r
 126  * @param  int16_t value to reverse\r
 127  * @return int32_t reversed value\r
 128  *\r
 129  * Reverse byte order in signed short value with sign extension to integer\r
 130  */\r
 131 __ASM int32_t __REVSH(int16_t value)\r
 132 {\r
 133   revsh r0, r0\r
 134   bx lr\r
 135 }\r
 136 \r
 137 \r
 138 #if (__ARMCC_VERSION < 400000)\r
 139 \r
 140 /**\r
 141  * @brief  Remove the exclusive lock created by ldrex\r
 142  *\r
 143  * @param  none\r
 144  * @return none\r
 145  *\r
 146  * Removes the exclusive lock which is created by ldrex.\r
 147  */\r
 148 __ASM void __CLREX(void)\r
 149 {\r
 150   clrex\r
 151 }\r
 152 \r
 153 /**\r
 154  * @brief  Return the Base Priority value\r
 155  *\r
 156  * @param  none\r
 157  * @return uint32_t BasePriority\r
 158  *\r
 159  * Return the content of the base priority register\r
 160  */\r
 161 __ASM uint32_t  __get_BASEPRI(void)\r
 162 {\r
 163   mrs r0, basepri\r
 164   bx lr\r
 165 }\r
 166 \r
 167 /**\r
 168  * @brief  Set the Base Priority value\r
 169  *\r
 170  * @param  uint32_t BasePriority\r
 171  * @return none\r
 172  *\r
 173  * Set the base priority register\r
 174  */\r
 175 __ASM void __set_BASEPRI(uint32_t basePri)\r
 176 {\r
 177   msr basepri, r0\r
 178   bx lr\r
 179 }\r
 180 \r
 181 /**\r
 182  * @brief  Return the Priority Mask value\r
 183  *\r
 184  * @param  none\r
 185  * @return uint32_t PriMask\r
 186  *\r
 187  * Return the state of the priority mask bit from the priority mask\r
 188  * register\r
 189  */\r
 190 __ASM uint32_t __get_PRIMASK(void)\r
 191 {\r
 192   mrs r0, primask\r
 193   bx lr\r
 194 }\r
 195 \r
 196 /**\r
 197  * @brief  Set the Priority Mask value\r
 198  *\r
 199  * @param  uint32_t PriMask\r
 200  * @return none\r
 201  *\r
 202  * Set the priority mask bit in the priority mask register\r
 203  */\r
 204 __ASM void __set_PRIMASK(uint32_t priMask)\r
 205 {\r
 206   msr primask, r0\r
 207   bx lr\r
 208 }\r
 209 \r
 210 /**\r
 211  * @brief  Return the Fault Mask value\r
 212  *\r
 213  * @param  none\r
 214  * @return uint32_t FaultMask\r
 215  *\r
 216  * Return the content of the fault mask register\r
 217  */\r
 218 __ASM uint32_t  __get_FAULTMASK(void)\r
 219 {\r
 220   mrs r0, faultmask\r
 221   bx lr\r
 222 }\r
 223 \r
 224 /**\r
 225  * @brief  Set the Fault Mask value\r
 226  *\r
 227  * @param  uint32_t faultMask value\r
 228  * @return none\r
 229  *\r
 230  * Set the fault mask register\r
 231  */\r
 232 __ASM void __set_FAULTMASK(uint32_t faultMask)\r
 233 {\r
 234   msr faultmask, r0\r
 235   bx lr\r
 236 }\r
 237 \r
 238 /**\r
 239  * @brief  Return the Control Register value\r
 240  * \r
 241  * @param  none\r
 242  * @return uint32_t Control value\r
 243  *\r
 244  * Return the content of the control register\r
 245  */\r
 246 __ASM uint32_t  __get_CONTROL(void)\r
 247 {\r
 248   mrs r0, control\r
 249   bx lr\r
 250 }\r
 251 \r
 252 /**\r
 253  * @brief  Set the Control Register value\r
 254  *\r
 255  * @param  uint32_t Control value\r
 256  * @return none\r
 257  *\r
 258  * Set the control register\r
 259  */\r
 260 __ASM void __set_CONTROL(uint32_t control)\r
 261 {\r
 262   msr control, r0\r
 263   bx lr\r
 264 }\r
 265 \r
 266 #endif /* __ARMCC_VERSION  */ \r
 267 \r
 268 \r
 269 #elif (defined (__ICCARM__)) /*------------------ ICC Compiler -------------------*/\r
 270 #pragma diag_suppress=Pe940\r
 271 \r
 272 /**\r
 273  * @brief  Return the Process Stack Pointer\r
 274  *\r
 275  * @param  none\r
 276  * @return uint32_t ProcessStackPointer\r
 277  *\r
 278  * Return the actual process stack pointer\r
 279  */\r
 280 uint32_t __get_PSP(void)\r
 281 {\r
 282   __ASM("mrs r0, psp");\r
 283   __ASM("bx lr");\r
 284 }\r
 285 \r
 286 /**\r
 287  * @brief  Set the Process Stack Pointer\r
 288  *\r
 289  * @param  uint32_t Process Stack Pointer\r
 290  * @return none\r
 291  *\r
 292  * Assign the value ProcessStackPointer to the MSP \r
 293  * (process stack pointer) Cortex processor register\r
 294  */\r
 295 void __set_PSP(uint32_t topOfProcStack)\r
 296 {\r
 297   __ASM("msr psp, r0");\r
 298   __ASM("bx lr");\r
 299 }\r
 300 \r
 301 /**\r
 302  * @brief  Return the Main Stack Pointer\r
 303  *\r
 304  * @param  none\r
 305  * @return uint32_t Main Stack Pointer\r
 306  *\r
 307  * Return the current value of the MSP (main stack pointer)\r
 308  * Cortex processor register\r
 309  */\r
 310 uint32_t __get_MSP(void)\r
 311 {\r
 312   __ASM("mrs r0, msp");\r
 313   __ASM("bx lr");\r
 314 }\r
 315 \r
 316 /**\r
 317  * @brief  Set the Main Stack Pointer\r
 318  *\r
 319  * @param  uint32_t Main Stack Pointer\r
 320  * @return none\r
 321  *\r
 322  * Assign the value mainStackPointer to the MSP \r
 323  * (main stack pointer) Cortex processor register\r
 324  */\r
 325 void __set_MSP(uint32_t topOfMainStack)\r
 326 {\r
 327   __ASM("msr msp, r0");\r
 328   __ASM("bx lr");\r
 329 }\r
 330 \r
 331 /**\r
 332  * @brief  Reverse byte order in unsigned short value\r
 333  *\r
 334  * @param  uint16_t value to reverse\r
 335  * @return uint32_t reversed value\r
 336  *\r
 337  * Reverse byte order in unsigned short value\r
 338  */\r
 339 uint32_t __REV16(uint16_t value)\r
 340 {\r
 341   __ASM("rev16 r0, r0");\r
 342   __ASM("bx lr");\r
 343 }\r
 344 \r
 345 /**\r
 346  * @brief  Reverse bit order of value\r
 347  *\r
 348  * @param  uint32_t value to reverse\r
 349  * @return uint32_t reversed value\r
 350  *\r
 351  * Reverse bit order of value\r
 352  */\r
 353 uint32_t __RBIT(uint32_t value)\r
 354 {\r
 355   __ASM("rbit r0, r0");\r
 356   __ASM("bx lr");\r
 357 }\r
 358 \r
 359 /**\r
 360  * @brief  LDR Exclusive\r
 361  *\r
 362  * @param  uint8_t* address\r
 363  * @return uint8_t value of (*address)\r
 364  *\r
 365  * Exclusive LDR command\r
 366  */\r
 367 uint8_t __LDREXB(uint8_t *addr)\r
 368 {\r
 369   __ASM("ldrexb r0, [r0]");\r
 370   __ASM("bx lr"); \r
 371 }\r
 372 \r
 373 /**\r
 374  * @brief  LDR Exclusive\r
 375  *\r
 376  * @param  uint16_t* address\r
 377  * @return uint16_t value of (*address)\r
 378  *\r
 379  * Exclusive LDR command\r
 380  */\r
 381 uint16_t __LDREXH(uint16_t *addr)\r
 382 {\r
 383   __ASM("ldrexh r0, [r0]");\r
 384   __ASM("bx lr");\r
 385 }\r
 386 \r
 387 /**\r
 388  * @brief  LDR Exclusive\r
 389  *\r
 390  * @param  uint32_t* address\r
 391  * @return uint32_t value of (*address)\r
 392  *\r
 393  * Exclusive LDR command\r
 394  */\r
 395 uint32_t __LDREXW(uint32_t *addr)\r
 396 {\r
 397   __ASM("ldrex r0, [r0]");\r
 398   __ASM("bx lr");\r
 399 }\r
 400 \r
 401 /**\r
 402  * @brief  STR Exclusive\r
 403  *\r
 404  * @param  uint8_t *address\r
 405  * @param  uint8_t value to store\r
 406  * @return uint32_t successful / failed\r
 407  *\r
 408  * Exclusive STR command\r
 409  */\r
 410 uint32_t __STREXB(uint8_t value, uint8_t *addr)\r
 411 {\r
 412   __ASM("strexb r0, r0, [r1]");\r
 413   __ASM("bx lr");\r
 414 }\r
 415 \r
 416 /**\r
 417  * @brief  STR Exclusive\r
 418  *\r
 419  * @param  uint16_t *address\r
 420  * @param  uint16_t value to store\r
 421  * @return uint32_t successful / failed\r
 422  *\r
 423  * Exclusive STR command\r
 424  */\r
 425 uint32_t __STREXH(uint16_t value, uint16_t *addr)\r
 426 {\r
 427   __ASM("strexh r0, r0, [r1]");\r
 428   __ASM("bx lr");\r
 429 }\r
 430 \r
 431 /**\r
 432  * @brief  STR Exclusive\r
 433  *\r
 434  * @param  uint32_t *address\r
 435  * @param  uint32_t value to store\r
 436  * @return uint32_t successful / failed\r
 437  *\r
 438  * Exclusive STR command\r
 439  */\r
 440 uint32_t __STREXW(uint32_t value, uint32_t *addr)\r
 441 {\r
 442   __ASM("strex r0, r0, [r1]");\r
 443   __ASM("bx lr");\r
 444 }\r
 445 \r
 446 #pragma diag_default=Pe940\r
 447 \r
 448 \r
 449 #elif (defined (__GNUC__)) /*------------------ GNU Compiler ---------------------*/\r
 450 \r
 451 /**\r
 452  * @brief  Return the Process Stack Pointer\r
 453  *\r
 454  * @param  none\r
 455  * @return uint32_t ProcessStackPointer\r
 456  *\r
 457  * Return the actual process stack pointer\r
 458  */\r
 459 uint32_t __get_PSP(void) __attribute__( ( naked ) );\r
 460 uint32_t __get_PSP(void)\r
 461 {\r
 462   uint32_t result=0;\r
 463 \r
 464   __ASM volatile ("MRS %0, psp\n\t" \r
 465                   "MOV r0, %0 \n\t"\r
 466                   "BX  lr     \n\t"  : "=r" (result) );\r
 467   return(result);\r
 468 }\r
 469 \r
 470 \r
 471 /**\r
 472  * @brief  Set the Process Stack Pointer\r
 473  *\r
 474  * @param  uint32_t Process Stack Pointer\r
 475  * @return none\r
 476  *\r
 477  * Assign the value ProcessStackPointer to the MSP \r
 478  * (process stack pointer) Cortex processor register\r
 479  */\r
 480 void __set_PSP(uint32_t topOfProcStack) __attribute__( ( naked ) );\r
 481 void __set_PSP(uint32_t topOfProcStack)\r
 482 {\r
 483   __ASM volatile ("MSR psp, %0\n\t"\r
 484                   "BX  lr     \n\t" : : "r" (topOfProcStack) );\r
 485 }\r
 486 \r
 487 /**\r
 488  * @brief  Return the Main Stack Pointer\r
 489  *\r
 490  * @param  none\r
 491  * @return uint32_t Main Stack Pointer\r
 492  *\r
 493  * Return the current value of the MSP (main stack pointer)\r
 494  * Cortex processor register\r
 495  */\r
 496 uint32_t __get_MSP(void) __attribute__( ( naked ) );\r
 497 uint32_t __get_MSP(void)\r
 498 {\r
 499   uint32_t result=0;\r
 500 \r
 501   __ASM volatile ("MRS %0, msp\n\t" \r
 502                   "MOV r0, %0 \n\t"\r
 503                   "BX  lr     \n\t"  : "=r" (result) );\r
 504   return(result);\r
 505 }\r
 506 \r
 507 /**\r
 508  * @brief  Set the Main Stack Pointer\r
 509  *\r
 510  * @param  uint32_t Main Stack Pointer\r
 511  * @return none\r
 512  *\r
 513  * Assign the value mainStackPointer to the MSP \r
 514  * (main stack pointer) Cortex processor register\r
 515  */\r
 516 void __set_MSP(uint32_t topOfMainStack) __attribute__( ( naked ) );\r
 517 void __set_MSP(uint32_t topOfMainStack)\r
 518 {\r
 519   __ASM volatile ("MSR msp, %0\n\t"\r
 520                   "BX  lr     \n\t" : : "r" (topOfMainStack) );\r
 521 }\r
 522 \r
 523 /**\r
 524  * @brief  Return the Base Priority value\r
 525  *\r
 526  * @param  none\r
 527  * @return uint32_t BasePriority\r
 528  *\r
 529  * Return the content of the base priority register\r
 530  */\r
 531 uint32_t __get_BASEPRI(void)\r
 532 {\r
 533   uint32_t result=0;\r
 534   \r
 535   __ASM volatile ("MRS %0, basepri_max" : "=r" (result) );\r
 536   return(result);\r
 537 }\r
 538 \r
 539 /**\r
 540  * @brief  Set the Base Priority value\r
 541  *\r
 542  * @param  uint32_t BasePriority\r
 543  * @return none\r
 544  *\r
 545  * Set the base priority register\r
 546  */\r
 547 void __set_BASEPRI(uint32_t value)\r
 548 {\r
 549   __ASM volatile ("MSR basepri, %0" : : "r" (value) );\r
 550 }\r
 551 \r
 552 /**\r
 553  * @brief  Return the Priority Mask value\r
 554  *\r
 555  * @param  none\r
 556  * @return uint32_t PriMask\r
 557  *\r
 558  * Return the state of the priority mask bit from the priority mask\r
 559  * register\r
 560  */\r
 561 uint32_t __get_PRIMASK(void)\r
 562 {\r
 563   uint32_t result=0;\r
 564 \r
 565   __ASM volatile ("MRS %0, primask" : "=r" (result) );\r
 566   return(result);\r
 567 }\r
 568 \r
 569 /**\r
 570  * @brief  Set the Priority Mask value\r
 571  *\r
 572  * @param  uint32_t PriMask\r
 573  * @return none\r
 574  *\r
 575  * Set the priority mask bit in the priority mask register\r
 576  */\r
 577 void __set_PRIMASK(uint32_t priMask)\r
 578 {\r
 579   __ASM volatile ("MSR primask, %0" : : "r" (priMask) );\r
 580 }\r
 581 \r
 582 /**\r
 583  * @brief  Return the Fault Mask value\r
 584  *\r
 585  * @param  none\r
 586  * @return uint32_t FaultMask\r
 587  *\r
 588  * Return the content of the fault mask register\r
 589  */\r
 590 uint32_t __get_FAULTMASK(void)\r
 591 {\r
 592   uint32_t result=0;\r
 593   \r
 594   __ASM volatile ("MRS %0, faultmask" : "=r" (result) );\r
 595   return(result);\r
 596 }\r
 597 \r
 598 /**\r
 599  * @brief  Set the Fault Mask value\r
 600  *\r
 601  * @param  uint32_t faultMask value\r
 602  * @return none\r
 603  *\r
 604  * Set the fault mask register\r
 605  */\r
 606 void __set_FAULTMASK(uint32_t faultMask)\r
 607 {\r
 608   __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) );\r
 609 }\r
 610 \r
 611 /**\r
 612  * @brief  Reverse byte order in integer value\r
 613  *\r
 614  * @param  uint32_t value to reverse\r
 615  * @return uint32_t 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  uint16_t value to reverse\r
 631  * @return uint32_t 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  int32_t value to reverse\r
 647  * @return int32_t 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  uint32_t value to reverse\r
 663  * @return uint32_t 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\r
 677  *\r
 678  * @param  uint8_t* address\r
 679  * @return uint8_t value of (*address)\r
 680  *\r
 681  * Exclusive LDR command\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\r
 693  *\r
 694  * @param  uint16_t* address\r
 695  * @return uint16_t value of (*address)\r
 696  *\r
 697  * Exclusive LDR command\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\r
 709  *\r
 710  * @param  uint32_t* address\r
 711  * @return uint32_t value of (*address)\r
 712  *\r
 713  * Exclusive LDR command\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\r
 725  *\r
 726  * @param  uint8_t *address\r
 727  * @param  uint8_t value to store\r
 728  * @return uint32_t successful / failed\r
 729  *\r
 730  * Exclusive STR command\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\r
 742  *\r
 743  * @param  uint16_t *address\r
 744  * @param  uint16_t value to store\r
 745  * @return uint32_t successful / failed\r
 746  *\r
 747  * Exclusive STR command\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\r
 759  *\r
 760  * @param  uint32_t *address\r
 761  * @param  uint32_t value to store\r
 762  * @return uint32_t successful / failed\r
 763  *\r
 764  * Exclusive STR command\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  * @brief  Return the Control Register value\r
 776  * \r
 777  * @param  none\r
 778  * @return uint32_t Control value\r
 779  *\r
 780  * Return the content of the control register\r
 781  */\r
 782 uint32_t __get_CONTROL(void)\r
 783 {\r
 784   uint32_t result=0;\r
 785 \r
 786   __ASM volatile ("MRS %0, control" : "=r" (result) );\r
 787   return(result);\r
 788 }\r
 789 \r
 790 /**\r
 791  * @brief  Set the Control Register value\r
 792  *\r
 793  * @param  uint32_t Control value\r
 794  * @return none\r
 795  *\r
 796  * Set the control register\r
 797  */\r
 798 void __set_CONTROL(uint32_t control)\r
 799 {\r
 800   __ASM volatile ("MSR control, %0" : : "r" (control) );\r
 801 }\r
 802 \r
 803 #elif (defined (__TASKING__)) /*------------------ TASKING Compiler ---------------------*/\r
 804 /* TASKING carm specific functions */\r
 805 \r
 806 /*\r
 807  * The CMSIS functions have been implemented as intrinsics in the compiler.\r
 808  * Please use "carm -?i" to get an up to date list of all instrinsics,\r
 809  * Including the CMSIS ones.\r
 810  */\r
 811 \r
 812 #endif\r
 813 \r
 814 \r
 815 \r
 816 \r
 817 \r
 818 \r
 819 \r
 820 \r
 821 \r
 822 \r
 823 \r
 824 \r
 825 \r
 826 \r
 827 \r
 828 \r
 829 \r