begriffs open source - cmsis/blob - CMSIS/CoreValidation/Source/CV_CoreFunc.c

   1 /*-----------------------------------------------------------------------------
   2  *      Name:         CV_CoreFunc.c
   3  *      Purpose:      CMSIS CORE validation tests implementation
   4  *-----------------------------------------------------------------------------
   5  *      Copyright (c) 2017 ARM Limited. All rights reserved.
   6  *----------------------------------------------------------------------------*/
   7
   8 #include "CV_Framework.h"
   9 #include "cmsis_cv.h"
  10
  11 /*-----------------------------------------------------------------------------
  12  *      Test implementation
  13  *----------------------------------------------------------------------------*/
  14
  15 static volatile uint32_t irqTaken = 0U;
  16 #if defined(__CORTEX_M) && (__CORTEX_M > 0)
  17 static volatile uint32_t irqActive = 0U;
  18 #endif
  19
  20 static void TC_CoreFunc_EnDisIRQIRQHandler(void) {
  21   ++irqTaken;
  22 #if defined(__CORTEX_M) && (__CORTEX_M > 0)
  23   irqActive = NVIC_GetActive(WDT_IRQn);
  24 #endif
  25 }
  26
  27 static volatile uint32_t irqIPSR = 0U;
  28 static volatile uint32_t irqXPSR = 0U;
  29
  30 static void TC_CoreFunc_IPSR_IRQHandler(void) {
  31   irqIPSR = __get_IPSR();
  32   irqXPSR = __get_xPSR();
  33 }
  34
  35 /*-----------------------------------------------------------------------------
  36  *      Test cases
  37  *----------------------------------------------------------------------------*/
  38
  39 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
  40 /**
  41 \brief Test case: TC_CoreFunc_EnDisIRQ
  42 \details
  43 Check expected behavior of interrupt related control functions:
  44 - __disable_irq() and __enable_irq()
  45 - NVIC_EnableIRQ, NVIC_DisableIRQ,  and NVIC_GetEnableIRQ
  46 - NVIC_SetPendingIRQ, NVIC_ClearPendingIRQ, and NVIC_GetPendingIRQ
  47 - NVIC_GetActive (not on Cortex-M0/M0+)
  48 */
  49 void TC_CoreFunc_EnDisIRQ (void)
  50 {
  51   // Globally disable all interrupt servicing
  52   __disable_irq();
  53
  54   // Enable the interrupt
  55   NVIC_EnableIRQ(WDT_IRQn);
  56   ASSERT_TRUE(NVIC_GetEnableIRQ(WDT_IRQn) != 0U);
  57
  58   // Clear its pending state
  59   NVIC_ClearPendingIRQ(WDT_IRQn);
  60   ASSERT_TRUE(NVIC_GetPendingIRQ(WDT_IRQn) == 0U);
  61
  62   // Register test interrupt handler.
  63   TST_IRQHandler = TC_CoreFunc_EnDisIRQIRQHandler;
  64   irqTaken = 0U;
  65 #if defined(__CORTEX_M) && (__CORTEX_M > 0)
  66   irqActive = UINT32_MAX;
  67 #endif
  68
  69   // Set the interrupt pending state
  70   NVIC_SetPendingIRQ(WDT_IRQn);
  71   for(uint32_t i = 10U; i > 0U; --i) {}
  72
  73   // Interrupt is not taken
  74   ASSERT_TRUE(irqTaken == 0U);
  75   ASSERT_TRUE(NVIC_GetPendingIRQ(WDT_IRQn) != 0U);
  76 #if defined(__CORTEX_M) && (__CORTEX_M > 0)
  77   ASSERT_TRUE(NVIC_GetActive(WDT_IRQn) == 0U);
  78 #endif
  79
  80   // Globally enable interrupt servicing
  81   __enable_irq();
  82
  83   for(uint32_t i = 10U; i > 0U; --i) {}
  84
  85   // Interrupt was taken
  86   ASSERT_TRUE(irqTaken == 1U);
  87 #if defined(__CORTEX_M) && (__CORTEX_M > 0)
  88   ASSERT_TRUE(irqActive != 0U);
  89   ASSERT_TRUE(NVIC_GetActive(WDT_IRQn) == 0U);
  90 #endif
  91
  92   // Interrupt it not pending anymore.
  93   ASSERT_TRUE(NVIC_GetPendingIRQ(WDT_IRQn) == 0U);
  94
  95   // Disable interrupt
  96   NVIC_DisableIRQ(WDT_IRQn);
  97   ASSERT_TRUE(NVIC_GetEnableIRQ(WDT_IRQn) == 0U);
  98
  99   // Set interrupt pending
 100   NVIC_SetPendingIRQ(WDT_IRQn);
 101   for(uint32_t i = 10U; i > 0U; --i) {}
 102
 103   // Interrupt is not taken again
 104   ASSERT_TRUE(irqTaken == 1U);
 105   ASSERT_TRUE(NVIC_GetPendingIRQ(WDT_IRQn) != 0U);
 106
 107   // Clear interrupt pending
 108   NVIC_ClearPendingIRQ(WDT_IRQn);
 109   for(uint32_t i = 10U; i > 0U; --i) {}
 110
 111   // Interrupt it not pending anymore.
 112   ASSERT_TRUE(NVIC_GetPendingIRQ(WDT_IRQn) == 0U);
 113
 114   // Globally disable interrupt servicing
 115   __disable_irq();
 116 }
 117
 118 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 119 /**
 120 \brief Test case: TC_CoreFunc_IRQPrio
 121 \details
 122 Check expected behavior of interrupt priority control functions:
 123 - NVIC_SetPriority, NVIC_GetPriority
 124 */
 125 void TC_CoreFunc_IRQPrio (void)
 126 {
 127   /* Test Exception Priority */
 128   uint32_t orig = NVIC_GetPriority(SVCall_IRQn);
 129
 130   NVIC_SetPriority(SVCall_IRQn, orig+1U);
 131   uint32_t prio = NVIC_GetPriority(SVCall_IRQn);
 132
 133   ASSERT_TRUE(prio == orig+1U);
 134
 135   NVIC_SetPriority(SVCall_IRQn, orig);
 136
 137   /* Test Interrupt Priority */
 138   orig = NVIC_GetPriority(WDT_IRQn);
 139
 140   NVIC_SetPriority(WDT_IRQn, orig+1U);
 141   prio = NVIC_GetPriority(WDT_IRQn);
 142
 143   ASSERT_TRUE(prio == orig+1U);
 144
 145   NVIC_SetPriority(WDT_IRQn, orig);
 146 }
 147
 148 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 149 /** Helper function for TC_CoreFunc_EncDecIRQPrio
 150 \details
 151 The helper encodes and decodes the given priority configuration.
 152 \param[in] prigroup The PRIGROUP setting to be considered for encoding/decoding.
 153 \param[in] pre The preempt priority value.
 154 \param[in] sub The subpriority value.
 155 */
 156 static void TC_CoreFunc_EncDecIRQPrio_Step(uint32_t prigroup, uint32_t pre, uint32_t sub) {
 157   uint32_t prio = NVIC_EncodePriority(prigroup, pre, sub);
 158
 159   uint32_t ret_pre = UINT32_MAX;
 160   uint32_t ret_sub = UINT32_MAX;
 161
 162   NVIC_DecodePriority(prio, prigroup, &ret_pre, &ret_sub);
 163
 164   ASSERT_TRUE(ret_pre == pre);
 165   ASSERT_TRUE(ret_sub == sub);
 166 }
 167
 168 /**
 169 \brief Test case: TC_CoreFunc_EncDecIRQPrio
 170 \details
 171 Check expected behavior of interrupt priority encoding/decoding functions:
 172 - NVIC_EncodePriority, NVIC_DecodePriority
 173 */
 174 void TC_CoreFunc_EncDecIRQPrio (void)
 175 {
 176   /* Check only the valid range of PRIGROUP and preempt-/sub-priority values. */
 177   static const uint32_t priobits = (__NVIC_PRIO_BITS > 7U) ? 7U : __NVIC_PRIO_BITS;
 178   for(uint32_t prigroup = 7U-priobits; prigroup<7U; prigroup++) {
 179     for(uint32_t pre = 0U; pre<(128U>>prigroup); pre++) {
 180       for(uint32_t sub = 0U; sub<(256U>>(8U-__NVIC_PRIO_BITS+7U-prigroup)); sub++) {
 181         TC_CoreFunc_EncDecIRQPrio_Step(prigroup, pre, sub);
 182       }
 183     }
 184   }
 185 }
 186
 187 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 188 /**
 189 \brief Test case: TC_CoreFunc_IRQVect
 190 \details
 191 Check expected behavior of interrupt vector relocation functions:
 192 - NVIC_SetVector, NVIC_GetVector
 193 */
 194 void TC_CoreFunc_IRQVect(void) {
 195 #if defined(__VTOR_PRESENT) && __VTOR_PRESENT
 196   /* relocate vector table */
 197   extern uint32_t __Vectors[];
 198   static uint32_t vectors[32] __ALIGNED(512);
 199
 200   for(uint32_t i=0U; i<32U; i++) {
 201     vectors[i] = __Vectors[i];
 202   }
 203
 204   const uint32_t orig_vtor = SCB->VTOR;
 205   const uint32_t vtor = ((uint32_t)vectors) & SCB_VTOR_TBLOFF_Msk;
 206   SCB->VTOR = vtor;
 207
 208   ASSERT_TRUE(vtor == SCB->VTOR);
 209
 210   /* check exception vectors */
 211   extern void HardFault_Handler(void);
 212   extern void SVC_Handler(void);
 213   extern void PendSV_Handler(void);
 214   extern void SysTick_Handler(void);
 215
 216   ASSERT_TRUE(NVIC_GetVector(HardFault_IRQn) == (uint32_t)HardFault_Handler);
 217   ASSERT_TRUE(NVIC_GetVector(SVCall_IRQn) == (uint32_t)SVC_Handler);
 218   ASSERT_TRUE(NVIC_GetVector(PendSV_IRQn) == (uint32_t)PendSV_Handler);
 219   ASSERT_TRUE(NVIC_GetVector(SysTick_IRQn) == (uint32_t)SysTick_Handler);
 220
 221   /* reconfigure WDT IRQ vector */
 222   extern void WDT_IRQHandler(void);
 223
 224   const uint32_t wdtvec = NVIC_GetVector(WDT_IRQn);
 225   ASSERT_TRUE(wdtvec == (uint32_t)WDT_IRQHandler);
 226
 227   NVIC_SetVector(WDT_IRQn, wdtvec + 32U);
 228
 229   ASSERT_TRUE(NVIC_GetVector(WDT_IRQn) == (wdtvec + 32U));
 230
 231   /* restore vector table */
 232   SCB->VTOR = orig_vtor;
 233 #endif
 234 }
 235
 236 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 237 /**
 238 \brief Test case: TC_CoreFunc_GetCtrl
 239 \details
 240 - Check if __set_CONTROL and __get_CONTROL() sets/gets control register
 241 */
 242 void TC_CoreFunc_Control (void) {
 243   // don't use stack for this variables
 244   static uint32_t orig;
 245   static uint32_t ctrl;
 246   static uint32_t result;
 247
 248   orig = __get_CONTROL();
 249   ctrl = orig;
 250   result = UINT32_MAX;
 251
 252 #ifdef CONTROL_SPSEL_Msk
 253   // toggle SPSEL
 254   ctrl = (ctrl & ~CONTROL_SPSEL_Msk) | (~ctrl & CONTROL_SPSEL_Msk);
 255 #endif
 256
 257   __set_CONTROL(ctrl);
 258   __ISB();
 259
 260   result = __get_CONTROL();
 261
 262   __set_CONTROL(orig);
 263   __ISB();
 264
 265   ASSERT_TRUE(result == ctrl);
 266   ASSERT_TRUE(__get_CONTROL() == orig);
 267 }
 268
 269 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 270 /**
 271 \brief Test case: TC_CoreFunc_IPSR
 272 \details
 273 - Check if __get_IPSR intrinsic is available
 274 - Check if __get_xPSR intrinsic is available
 275 - Result differentiates between thread and exception modes
 276 */
 277 void TC_CoreFunc_IPSR (void) {
 278   uint32_t result = __get_IPSR();
 279   ASSERT_TRUE(result == 0U); // Thread Mode
 280
 281   result = __get_xPSR();
 282   ASSERT_TRUE((result & xPSR_ISR_Msk) == 0U); // Thread Mode
 283
 284   TST_IRQHandler = TC_CoreFunc_IPSR_IRQHandler;
 285   irqIPSR = 0U;
 286   irqXPSR = 0U;
 287
 288   NVIC_ClearPendingIRQ(WDT_IRQn);
 289   NVIC_EnableIRQ(WDT_IRQn);
 290   __enable_irq();
 291
 292   NVIC_SetPendingIRQ(WDT_IRQn);
 293   for(uint32_t i = 10U; i > 0U; --i) {}
 294
 295   __disable_irq();
 296   NVIC_DisableIRQ(WDT_IRQn);
 297
 298   ASSERT_TRUE(irqIPSR != 0U); // Exception Mode
 299   ASSERT_TRUE((irqXPSR & xPSR_ISR_Msk) != 0U); // Exception Mode
 300 }
 301
 302 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 303
 304 #if defined(__CC_ARM)
 305 #define SUBS(Rd, Rm, Rn) __ASM("SUBS " # Rd ", " # Rm ", " # Rn)
 306 #define ADDS(Rd, Rm, Rn) __ASM("ADDS " # Rd ", " # Rm ", " # Rn)
 307 #elif defined( __GNUC__ )  && (defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_8M_BASE__))
 308 #define SUBS(Rd, Rm, Rn) __ASM("SUB %0, %1, %2" : "=r"(Rd) : "r"(Rm), "r"(Rn) : "cc")
 309 #define ADDS(Rd, Rm, Rn) __ASM("ADD %0, %1, %2" : "=r"(Rd) : "r"(Rm), "r"(Rn) : "cc")
 310 #elif defined(_lint)
 311 //lint -save -e(9026) allow function-like macro
 312 #define SUBS(Rd, Rm, Rn) ((Rd) = (Rm) - (Rn))
 313 #define ADDS(Rd, Rm, Rn) ((Rd) = (Rm) + (Rn))
 314 //lint -restore
 315 #else
 316 #define SUBS(Rd, Rm, Rn) __ASM("SUBS %0, %1, %2" : "=r"(Rd) : "r"(Rm), "r"(Rn) : "cc")
 317 #define ADDS(Rd, Rm, Rn) __ASM("ADDS %0, %1, %2" : "=r"(Rd) : "r"(Rm), "r"(Rn) : "cc")
 318 #endif
 319
 320 /**
 321 \brief Test case: TC_CoreFunc_APSR
 322 \details
 323 - Check if __get_APSR intrinsic is available
 324 - Check if __get_xPSR intrinsic is available
 325 - Check negative, zero and overflow flags
 326 */
 327 void TC_CoreFunc_APSR (void) {
 328   uint32_t result;
 329   //lint -esym(838, Rm) unused values
 330   //lint -esym(438, Rm) unused values
 331
 332   // Check negative flag
 333   int32_t Rm = 5;
 334   int32_t Rn = 7;
 335   SUBS(Rm, Rm, Rn);
 336   result  = __get_APSR();
 337   ASSERT_TRUE((result & APSR_N_Msk) == APSR_N_Msk);
 338
 339   Rm = 5;
 340   Rn = 7;
 341   SUBS(Rm, Rm, Rn);
 342   result  = __get_xPSR();
 343   ASSERT_TRUE((result & xPSR_N_Msk) == xPSR_N_Msk);
 344
 345   // Check zero and compare flag
 346   Rm = 5;
 347   SUBS(Rm, Rm, Rm);
 348   result  = __get_APSR();
 349   ASSERT_TRUE((result & APSR_Z_Msk) == APSR_Z_Msk);
 350   ASSERT_TRUE((result & APSR_C_Msk) == APSR_C_Msk);
 351
 352   Rm = 5;
 353   SUBS(Rm, Rm, Rm);
 354   result  = __get_xPSR();
 355   ASSERT_TRUE((result & xPSR_Z_Msk) == xPSR_Z_Msk);
 356   ASSERT_TRUE((result & APSR_C_Msk) == APSR_C_Msk);
 357
 358   // Check overflow flag
 359   Rm = 5;
 360   Rn = INT32_MAX;
 361   ADDS(Rm, Rm, Rn);
 362   result  = __get_APSR();
 363   ASSERT_TRUE((result & APSR_V_Msk) == APSR_V_Msk);
 364
 365   Rm = 5;
 366   Rn = INT32_MAX;
 367   ADDS(Rm, Rm, Rn);
 368   result  = __get_xPSR();
 369   ASSERT_TRUE((result & xPSR_V_Msk) == xPSR_V_Msk);
 370 }
 371
 372 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 373 /**
 374 \brief Test case: TC_CoreFunc_PSP
 375 \details
 376 - Check if __get_PSP and __set_PSP intrinsic can be used to manipulate process stack pointer.
 377 */
 378 void TC_CoreFunc_PSP (void) {
 379   // don't use stack for this variables
 380   static uint32_t orig;
 381   static uint32_t psp;
 382   static uint32_t result;
 383
 384   orig = __get_PSP();
 385
 386   psp = orig + 0x12345678U;
 387   __set_PSP(psp);
 388
 389   result = __get_PSP();
 390
 391   __set_PSP(orig);
 392
 393   ASSERT_TRUE(result == psp);
 394 }
 395
 396 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 397 /**
 398 \brief Test case: TC_CoreFunc_MSP
 399 \details
 400 - Check if __get_MSP and __set_MSP intrinsic can be used to manipulate main stack pointer.
 401 */
 402 void TC_CoreFunc_MSP (void) {
 403   // don't use stack for this variables
 404   static uint32_t orig;
 405   static uint32_t msp;
 406   static uint32_t result;
 407   static uint32_t ctrl;
 408
 409   ctrl = __get_CONTROL();
 410   orig = __get_MSP();
 411
 412   __set_PSP(orig);
 413   __set_CONTROL(ctrl | CONTROL_SPSEL_Msk); // switch to PSP
 414
 415   msp = orig + 0x12345678U;
 416   __set_MSP(msp);
 417
 418   result = __get_MSP();
 419
 420   __set_MSP(orig);
 421
 422   __set_CONTROL(ctrl);
 423
 424   ASSERT_TRUE(result == msp);
 425 }
 426
 427 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 428 #if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
 429      (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
 430
 431 /**
 432 \brief Test case: TC_CoreFunc_PSPLIM
 433 \details
 434 - Check if __get_PSPLIM and __set_PSPLIM intrinsic can be used to manipulate process stack pointer limit.
 435 */
 436 void TC_CoreFunc_PSPLIM (void) {
 437   // don't use stack for this variables
 438   static uint32_t orig;
 439   static uint32_t psplim;
 440   static uint32_t result;
 441
 442   orig = __get_PSPLIM();
 443
 444   psplim = orig + 0x12345678U;
 445   __set_PSPLIM(psplim);
 446
 447   result = __get_PSPLIM();
 448
 449   __set_PSPLIM(orig);
 450
 451 #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
 452      (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
 453   // without main extensions, the non-secure PSPLIM is RAZ/WI
 454   ASSERT_TRUE(result == 0U);
 455 #else
 456   ASSERT_TRUE(result == psplim);
 457 #endif
 458 }
 459
 460 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 461 /**
 462 \brief Test case: TC_CoreFunc_PSPLIM_NS
 463 \details
 464 - Check if __TZ_get_PSPLIM_NS and __TZ_set_PSPLIM_NS intrinsic can be used to manipulate process stack pointer limit.
 465 */
 466 void TC_CoreFunc_PSPLIM_NS (void) {
 467 #if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3))
 468   uint32_t orig;
 469   uint32_t psplim;
 470   uint32_t result;
 471
 472   orig = __TZ_get_PSPLIM_NS();
 473
 474   psplim = orig + 0x12345678U;
 475   __TZ_set_PSPLIM_NS(psplim);
 476
 477   result = __TZ_get_PSPLIM_NS();
 478
 479   __TZ_set_PSPLIM_NS(orig);
 480
 481 #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
 482   // without main extensions, the non-secure PSPLIM is RAZ/WI
 483   ASSERT_TRUE(result == 0U);
 484 #else
 485   ASSERT_TRUE(result == psplim);
 486 #endif
 487 #endif
 488 }
 489
 490 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 491 /**
 492 \brief Test case: TC_CoreFunc_MSPLIM
 493 \details
 494 - Check if __get_MSPLIM and __set_MSPLIM intrinsic can be used to manipulate main stack pointer limit.
 495 */
 496 void TC_CoreFunc_MSPLIM (void) {
 497   // don't use stack for this variables
 498   static uint32_t orig;
 499   static uint32_t msplim;
 500   static uint32_t result;
 501   static uint32_t ctrl;
 502
 503   ctrl = __get_CONTROL();
 504   __set_CONTROL(ctrl | CONTROL_SPSEL_Msk); // switch to PSP
 505
 506   orig = __get_MSPLIM();
 507
 508   msplim = orig + 0x12345678U;
 509   __set_MSPLIM(msplim);
 510
 511   result = __get_MSPLIM();
 512
 513   __set_MSPLIM(orig);
 514
 515   __set_CONTROL(ctrl);
 516
 517 #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
 518      (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
 519   // without main extensions, the non-secure MSPLIM is RAZ/WI
 520   ASSERT_TRUE(result == 0U);
 521 #else
 522   ASSERT_TRUE(result == msplim);
 523 #endif
 524 }
 525
 526 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 527 /**
 528 \brief Test case: TC_CoreFunc_MSPLIM_NS
 529 \details
 530 - Check if __TZ_get_MSPLIM_NS and __TZ_set_MSPLIM_NS intrinsic can be used to manipulate process stack pointer limit.
 531 */
 532 void TC_CoreFunc_MSPLIM_NS (void) {
 533 #if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3))
 534   uint32_t orig;
 535   uint32_t msplim;
 536   uint32_t result;
 537
 538   orig = __TZ_get_MSPLIM_NS();
 539
 540   msplim = orig + 0x12345678U;
 541   __TZ_set_MSPLIM_NS(msplim);
 542
 543   result = __TZ_get_MSPLIM_NS();
 544
 545   __TZ_set_MSPLIM_NS(orig);
 546
 547 #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
 548   // without main extensions, the non-secure MSPLIM is RAZ/WI
 549   ASSERT_TRUE(result == 0U);
 550 #else
 551   ASSERT_TRUE(result == msplim);
 552 #endif
 553 #endif
 554 }
 555
 556 #endif
 557
 558 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 559 /**
 560 \brief Test case: TC_CoreFunc_PRIMASK
 561 \details
 562 - Check if __get_PRIMASK and __set_PRIMASK intrinsic can be used to manipulate PRIMASK.
 563 - Check if __enable_irq and __disable_irq are reflected in PRIMASK.
 564 */
 565 void TC_CoreFunc_PRIMASK (void) {
 566   uint32_t orig = __get_PRIMASK();
 567
 568   // toggle primask
 569   uint32_t primask = (orig & ~0x01U) | (~orig & 0x01U);
 570
 571   __set_PRIMASK(primask);
 572   uint32_t result = __get_PRIMASK();
 573
 574   ASSERT_TRUE(result == primask);
 575
 576   __disable_irq();
 577   result = __get_PRIMASK();
 578   ASSERT_TRUE((result & 0x01U) == 1U);
 579
 580   __enable_irq();
 581   result = __get_PRIMASK();
 582   ASSERT_TRUE((result & 0x01U) == 0U);
 583
 584   __disable_irq();
 585   result = __get_PRIMASK();
 586   ASSERT_TRUE((result & 0x01U) == 1U);
 587
 588   __set_PRIMASK(orig);
 589 }
 590
 591 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 592 #if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
 593      (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
 594      (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
 595
 596 /**
 597 \brief Test case: TC_CoreFunc_FAULTMASK
 598 \details
 599 - Check if __get_FAULTMASK and __set_FAULTMASK intrinsic can be used to manipulate FAULTMASK.
 600 - Check if __enable_fault_irq and __disable_fault_irq are reflected in FAULTMASK.
 601 */
 602 void TC_CoreFunc_FAULTMASK (void) {
 603   uint32_t orig = __get_FAULTMASK();
 604
 605   // toggle faultmask
 606   uint32_t faultmask = (orig & ~0x01U) | (~orig & 0x01U);
 607
 608   __set_FAULTMASK(faultmask);
 609   uint32_t result = __get_FAULTMASK();
 610
 611   ASSERT_TRUE(result == faultmask);
 612
 613   __disable_fault_irq();
 614   result = __get_FAULTMASK();
 615   ASSERT_TRUE((result & 0x01U) == 1U);
 616
 617   __enable_fault_irq();
 618   result = __get_FAULTMASK();
 619   ASSERT_TRUE((result & 0x01U) == 0U);
 620
 621   __disable_fault_irq();
 622   result = __get_FAULTMASK();
 623   ASSERT_TRUE((result & 0x01U) == 1U);
 624
 625   __set_FAULTMASK(orig);
 626 }
 627
 628 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 629 /**
 630 \brief Test case: TC_CoreFunc_BASEPRI
 631 \details
 632 - Check if __get_BASEPRI and __set_BASEPRI intrinsic can be used to manipulate BASEPRI.
 633 - Check if __set_BASEPRI_MAX intrinsic can be used to manipulate BASEPRI.
 634 */
 635 void TC_CoreFunc_BASEPRI(void) {
 636   uint32_t orig = __get_BASEPRI();
 637
 638   uint32_t basepri = ~orig & 0x80U;
 639   __set_BASEPRI(basepri);
 640   uint32_t result = __get_BASEPRI();
 641
 642   ASSERT_TRUE(result == basepri);
 643
 644   __set_BASEPRI(orig);
 645
 646   __set_BASEPRI_MAX(basepri);
 647   result = __get_BASEPRI();
 648
 649   ASSERT_TRUE(result == basepri);
 650 }
 651 #endif
 652
 653 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 654 /**
 655 \brief Test case: TC_CoreFunc_FPUType
 656 \details
 657 Check SCB_GetFPUType returns information.
 658 */
 659 void TC_CoreFunc_FPUType(void) {
 660   uint32_t fpuType = SCB_GetFPUType();
 661 #if defined(__FPU_PRESENT) && (__FPU_PRESENT != 0)
 662   ASSERT_TRUE(fpuType > 0U);
 663 #else
 664   ASSERT_TRUE(fpuType  == 0U);
 665 #endif
 666 }
 667
 668 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 669 /**
 670 \brief Test case: TC_CoreFunc_FPSCR
 671 \details
 672 - Check if __get_FPSCR and __set_FPSCR intrinsics can be used
 673 */
 674 void TC_CoreFunc_FPSCR(void) {
 675   uint32_t fpscr = __get_FPSCR();
 676   __ISB();
 677   __DSB();
 678
 679   __set_FPSCR(~fpscr);
 680   __ISB();
 681   __DSB();
 682
 683   uint32_t result = __get_FPSCR();
 684
 685   __set_FPSCR(fpscr);
 686
 687 #if (defined (__FPU_USED   ) && (__FPU_USED    == 1U))
 688   ASSERT_TRUE(result != fpscr);
 689 #else
 690   ASSERT_TRUE(result == 0U);
 691 #endif
 692 }