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