arch/arm/arm_cm3/kernel/core_cm3.c

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