git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_MSP432_LaunchPad_IAR_CCS_Keil/Full_Demo/RegTest.c

   1 /*\r
   2  * FreeRTOS Kernel V10.2.1\r
   3  * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   6  * this software and associated documentation files (the "Software"), to deal in\r
   7  * the Software without restriction, including without limitation the rights to\r
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
   9  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  10  * subject to the following conditions:\r
  11  *\r
  12  * The above copyright notice and this permission notice shall be included in all\r
  13  * copies or substantial portions of the Software.\r
  14  *\r
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  21  *\r
  22  * http://www.FreeRTOS.org\r
  23  * http://aws.amazon.com/freertos\r
  24  *\r
  25  * 1 tab == 4 spaces!\r
  26  */\r
  27 \r
  28 \r
  29 __asm void vRegTest1Implementation( void )\r
  30 {\r
  31         PRESERVE8\r
  32         IMPORT ulRegTest1LoopCounter\r
  33 \r
  34         /* Fill the core registers with known values. */\r
  35         mov r0, #100\r
  36         mov r1, #101\r
  37         mov r2, #102\r
  38         mov r3, #103\r
  39         mov     r4, #104\r
  40         mov     r5, #105\r
  41         mov     r6, #106\r
  42         mov r7, #107\r
  43         mov     r8, #108\r
  44         mov     r9, #109\r
  45         mov     r10, #110\r
  46         mov     r11, #111\r
  47         mov r12, #112\r
  48 \r
  49         /* Fill the VFP registers with known values. */\r
  50         vmov d0, r0, r1\r
  51         vmov d1, r2, r3\r
  52         vmov d2, r4, r5\r
  53         vmov d3, r6, r7\r
  54         vmov d4, r8, r9\r
  55         vmov d5, r10, r11\r
  56         vmov d6, r0, r1\r
  57         vmov d7, r2, r3\r
  58         vmov d8, r4, r5\r
  59         vmov d9, r6, r7\r
  60         vmov d10, r8, r9\r
  61         vmov d11, r10, r11\r
  62         vmov d12, r0, r1\r
  63         vmov d13, r2, r3\r
  64         vmov d14, r4, r5\r
  65         vmov d15, r6, r7\r
  66 \r
  67 reg1_loop\r
  68         /* Check all the VFP registers still contain the values set above.\r
  69         First save registers that are clobbered by the test. */\r
  70         push { r0-r1 }\r
  71         \r
  72         vmov r0, r1, d0\r
  73         cmp r0, #100\r
  74         bne reg1_error_loopf\r
  75         cmp r1, #101\r
  76         bne reg1_error_loopf\r
  77         vmov r0, r1, d1\r
  78         cmp r0, #102\r
  79         bne reg1_error_loopf\r
  80         cmp r1, #103\r
  81         bne reg1_error_loopf\r
  82         vmov r0, r1, d2\r
  83         cmp r0, #104\r
  84         bne reg1_error_loopf\r
  85         cmp r1, #105\r
  86         bne reg1_error_loopf\r
  87         vmov r0, r1, d3\r
  88         cmp r0, #106\r
  89         bne reg1_error_loopf\r
  90         cmp r1, #107\r
  91         bne reg1_error_loopf\r
  92         vmov r0, r1, d4\r
  93         cmp r0, #108\r
  94         bne reg1_error_loopf\r
  95         cmp r1, #109\r
  96         bne reg1_error_loopf\r
  97         vmov r0, r1, d5\r
  98         cmp r0, #110\r
  99         bne reg1_error_loopf\r
 100         cmp r1, #111\r
 101         bne reg1_error_loopf\r
 102         vmov r0, r1, d6\r
 103         cmp r0, #100\r
 104         bne reg1_error_loopf\r
 105         cmp r1, #101\r
 106         bne reg1_error_loopf\r
 107         vmov r0, r1, d7\r
 108         cmp r0, #102\r
 109         bne reg1_error_loopf\r
 110         cmp r1, #103\r
 111         bne reg1_error_loopf\r
 112         vmov r0, r1, d8\r
 113         cmp r0, #104\r
 114         bne reg1_error_loopf\r
 115         cmp r1, #105\r
 116         bne reg1_error_loopf\r
 117         vmov r0, r1, d9\r
 118         cmp r0, #106\r
 119         bne reg1_error_loopf\r
 120         cmp r1, #107\r
 121         bne reg1_error_loopf\r
 122         vmov r0, r1, d10\r
 123         cmp r0, #108\r
 124         bne reg1_error_loopf\r
 125         cmp r1, #109\r
 126         bne reg1_error_loopf\r
 127         vmov r0, r1, d11\r
 128         cmp r0, #110\r
 129         bne reg1_error_loopf\r
 130         cmp r1, #111\r
 131         bne reg1_error_loopf\r
 132         vmov r0, r1, d12\r
 133         cmp r0, #100\r
 134         bne reg1_error_loopf\r
 135         cmp r1, #101\r
 136         bne reg1_error_loopf\r
 137         vmov r0, r1, d13\r
 138         cmp r0, #102\r
 139         bne reg1_error_loopf\r
 140         cmp r1, #103\r
 141         bne reg1_error_loopf\r
 142         vmov r0, r1, d14\r
 143         cmp r0, #104\r
 144         bne reg1_error_loopf\r
 145         cmp r1, #105\r
 146         bne reg1_error_loopf\r
 147         vmov r0, r1, d15\r
 148         cmp r0, #106\r
 149         bne reg1_error_loopf\r
 150         cmp r1, #107\r
 151         bne reg1_error_loopf\r
 152         \r
 153         /* Restore the registers that were clobbered by the test. */\r
 154         pop {r0-r1}\r
 155         \r
 156         /* VFP register test passed.  Jump to the core register test. */\r
 157         b reg1_loopf_pass\r
 158 \r
 159 reg1_error_loopf\r
 160         /* If this line is hit then a VFP register value was found to be\r
 161         incorrect. */\r
 162         b reg1_error_loopf\r
 163 \r
 164 reg1_loopf_pass\r
 165 \r
 166         cmp     r0, #100\r
 167         bne     reg1_error_loop\r
 168         cmp     r1, #101\r
 169         bne     reg1_error_loop\r
 170         cmp     r2, #102\r
 171         bne     reg1_error_loop\r
 172         cmp r3, #103\r
 173         bne     reg1_error_loop\r
 174         cmp     r4, #104\r
 175         bne     reg1_error_loop\r
 176         cmp     r5, #105\r
 177         bne     reg1_error_loop\r
 178         cmp     r6, #106\r
 179         bne     reg1_error_loop\r
 180         cmp     r7, #107\r
 181         bne     reg1_error_loop\r
 182         cmp     r8, #108\r
 183         bne     reg1_error_loop\r
 184         cmp     r9, #109\r
 185         bne     reg1_error_loop\r
 186         cmp     r10, #110\r
 187         bne     reg1_error_loop\r
 188         cmp     r11, #111\r
 189         bne     reg1_error_loop\r
 190         cmp     r12, #112\r
 191         bne     reg1_error_loop\r
 192         \r
 193         /* Everything passed, increment the loop counter. */\r
 194         push { r0-r1 }\r
 195         ldr     r0, =ulRegTest1LoopCounter\r
 196         ldr r1, [r0]\r
 197         adds r1, r1, #1\r
 198         str r1, [r0]\r
 199         pop { r0-r1 }\r
 200         \r
 201         /* Start again. */\r
 202         b reg1_loop\r
 203 \r
 204 reg1_error_loop\r
 205         /* If this line is hit then there was an error in a core register value.\r
 206         The loop ensures the loop counter stops incrementing. */\r
 207         b reg1_error_loop\r
 208         nop\r
 209 }\r
 210 /*-----------------------------------------------------------*/\r
 211 \r
 212 __asm void vRegTest2Implementation( void )\r
 213 {\r
 214         PRESERVE8\r
 215         IMPORT ulRegTest2LoopCounter\r
 216 \r
 217         /* Set all the core registers to known values. */\r
 218         mov r0, #-1\r
 219         mov r1, #1\r
 220         mov r2, #2\r
 221         mov r3, #3\r
 222         mov     r4, #4\r
 223         mov     r5, #5\r
 224         mov     r6, #6\r
 225         mov r7, #7\r
 226         mov     r8, #8\r
 227         mov     r9, #9\r
 228         mov     r10, #10\r
 229         mov     r11, #11\r
 230         mov r12, #12\r
 231 \r
 232         /* Set all the VFP to known values. */\r
 233         vmov d0, r0, r1\r
 234         vmov d1, r2, r3\r
 235         vmov d2, r4, r5\r
 236         vmov d3, r6, r7\r
 237         vmov d4, r8, r9\r
 238         vmov d5, r10, r11\r
 239         vmov d6, r0, r1\r
 240         vmov d7, r2, r3\r
 241         vmov d8, r4, r5\r
 242         vmov d9, r6, r7\r
 243         vmov d10, r8, r9\r
 244         vmov d11, r10, r11\r
 245         vmov d12, r0, r1\r
 246         vmov d13, r2, r3\r
 247         vmov d14, r4, r5\r
 248         vmov d15, r6, r7\r
 249 \r
 250 reg2_loop\r
 251         \r
 252         /* Check all the VFP registers still contain the values set above.\r
 253         First save registers that are clobbered by the test. */\r
 254         push { r0-r1 }\r
 255         \r
 256         vmov r0, r1, d0\r
 257         cmp r0, #-1\r
 258         bne reg2_error_loopf\r
 259         cmp r1, #1\r
 260         bne reg2_error_loopf\r
 261         vmov r0, r1, d1\r
 262         cmp r0, #2\r
 263         bne reg2_error_loopf\r
 264         cmp r1, #3\r
 265         bne reg2_error_loopf\r
 266         vmov r0, r1, d2\r
 267         cmp r0, #4\r
 268         bne reg2_error_loopf\r
 269         cmp r1, #5\r
 270         bne reg2_error_loopf\r
 271         vmov r0, r1, d3\r
 272         cmp r0, #6\r
 273         bne reg2_error_loopf\r
 274         cmp r1, #7\r
 275         bne reg2_error_loopf\r
 276         vmov r0, r1, d4\r
 277         cmp r0, #8\r
 278         bne reg2_error_loopf\r
 279         cmp r1, #9\r
 280         bne reg2_error_loopf\r
 281         vmov r0, r1, d5\r
 282         cmp r0, #10\r
 283         bne reg2_error_loopf\r
 284         cmp r1, #11\r
 285         bne reg2_error_loopf\r
 286         vmov r0, r1, d6\r
 287         cmp r0, #-1\r
 288         bne reg2_error_loopf\r
 289         cmp r1, #1\r
 290         bne reg2_error_loopf\r
 291         vmov r0, r1, d7\r
 292         cmp r0, #2\r
 293         bne reg2_error_loopf\r
 294         cmp r1, #3\r
 295         bne reg2_error_loopf\r
 296         vmov r0, r1, d8\r
 297         cmp r0, #4\r
 298         bne reg2_error_loopf\r
 299         cmp r1, #5\r
 300         bne reg2_error_loopf\r
 301         vmov r0, r1, d9\r
 302         cmp r0, #6\r
 303         bne reg2_error_loopf\r
 304         cmp r1, #7\r
 305         bne reg2_error_loopf\r
 306         vmov r0, r1, d10\r
 307         cmp r0, #8\r
 308         bne reg2_error_loopf\r
 309         cmp r1, #9\r
 310         bne reg2_error_loopf\r
 311         vmov r0, r1, d11\r
 312         cmp r0, #10\r
 313         bne reg2_error_loopf\r
 314         cmp r1, #11\r
 315         bne reg2_error_loopf\r
 316         vmov r0, r1, d12\r
 317         cmp r0, #-1\r
 318         bne reg2_error_loopf\r
 319         cmp r1, #1\r
 320         bne reg2_error_loopf\r
 321         vmov r0, r1, d13\r
 322         cmp r0, #2\r
 323         bne reg2_error_loopf\r
 324         cmp r1, #3\r
 325         bne reg2_error_loopf\r
 326         vmov r0, r1, d14\r
 327         cmp r0, #4\r
 328         bne reg2_error_loopf\r
 329         cmp r1, #5\r
 330         bne reg2_error_loopf\r
 331         vmov r0, r1, d15\r
 332         cmp r0, #6\r
 333         bne reg2_error_loopf\r
 334         cmp r1, #7\r
 335         bne reg2_error_loopf\r
 336         \r
 337         /* Restore the registers that were clobbered by the test. */\r
 338         pop {r0-r1}\r
 339         \r
 340         /* VFP register test passed.  Jump to the core register test. */\r
 341         b reg2_loopf_pass\r
 342 \r
 343 reg2_error_loopf\r
 344         /* If this line is hit then a VFP register value was found to be\r
 345         incorrect. */\r
 346         b reg2_error_loopf\r
 347 \r
 348 reg2_loopf_pass\r
 349 \r
 350         cmp     r0, #-1\r
 351         bne     reg2_error_loop\r
 352         cmp     r1, #1\r
 353         bne     reg2_error_loop\r
 354         cmp     r2, #2\r
 355         bne     reg2_error_loop\r
 356         cmp r3, #3\r
 357         bne     reg2_error_loop\r
 358         cmp     r4, #4\r
 359         bne     reg2_error_loop\r
 360         cmp     r5, #5\r
 361         bne     reg2_error_loop\r
 362         cmp     r6, #6\r
 363         bne     reg2_error_loop\r
 364         cmp     r7, #7\r
 365         bne     reg2_error_loop\r
 366         cmp     r8, #8\r
 367         bne     reg2_error_loop\r
 368         cmp     r9, #9\r
 369         bne     reg2_error_loop\r
 370         cmp     r10, #10\r
 371         bne     reg2_error_loop\r
 372         cmp     r11, #11\r
 373         bne     reg2_error_loop\r
 374         cmp     r12, #12\r
 375         bne     reg2_error_loop\r
 376         \r
 377         /* Increment the loop counter to indicate this test is still functioning\r
 378         correctly. */\r
 379         push { r0-r1 }\r
 380         ldr     r0, =ulRegTest2LoopCounter\r
 381         ldr r1, [r0]\r
 382         adds r1, r1, #1\r
 383         str r1, [r0]\r
 384         \r
 385         /* Yield to increase test coverage. */\r
 386         movs r0, #0x01\r
 387         ldr r1, =0xe000ed04 /*NVIC_INT_CTRL */\r
 388         lsl r0, r0, #28 /* Shift to PendSV bit */\r
 389         str r0, [r1]\r
 390         dsb\r
 391         \r
 392         pop { r0-r1 }\r
 393         \r
 394         /* Start again. */\r
 395         b reg2_loop\r
 396 \r
 397 reg2_error_loop\r
 398         /* If this line is hit then there was an error in a core register value.\r
 399         This loop ensures the loop counter variable stops incrementing. */\r
 400         b reg2_error_loop\r
 401 }\r
 402 /*-----------------------------------------------------------*/\r
 403 \r
 404 __asm void vRegTestClearFlopRegistersToParameterValue( unsigned long ulValue    )\r
 405 {\r
 406         PRESERVE8\r
 407 \r
 408         /* Clobber the auto saved registers. */\r
 409         vmov d0, r0, r0\r
 410         vmov d1, r0, r0\r
 411         vmov d2, r0, r0\r
 412         vmov d3, r0, r0\r
 413         vmov d4, r0, r0\r
 414         vmov d5, r0, r0\r
 415         vmov d6, r0, r0\r
 416         vmov d7, r0, r0\r
 417         bx lr\r
 418 }\r
 419 /*-----------------------------------------------------------*/\r
 420 \r
 421 __asm void ulRegTestCheckFlopRegistersContainParameterValue( unsigned long ulValue )\r
 422 {\r
 423         PRESERVE8\r
 424 \r
 425         vmov r1, s0\r
 426         cmp r0, r1\r
 427         bne return_error\r
 428         vmov r1, s1\r
 429         cmp r0, r1\r
 430         bne return_error\r
 431         vmov r1, s2\r
 432         cmp r0, r1\r
 433         bne return_error\r
 434         vmov r1, s3\r
 435         cmp r0, r1\r
 436         bne return_error\r
 437         vmov r1, s4\r
 438         cmp r0, r1\r
 439         bne return_error\r
 440         vmov r1, s5\r
 441         cmp r0, r1\r
 442         bne return_error\r
 443         vmov r1, s6\r
 444         cmp r0, r1\r
 445         bne return_error\r
 446         vmov r1, s7\r
 447         cmp r0, r1\r
 448         bne return_error\r
 449         vmov r1, s8\r
 450         cmp r0, r1\r
 451         bne return_error\r
 452         vmov r1, s9\r
 453         cmp r0, r1\r
 454         bne return_error\r
 455         vmov r1, s10\r
 456         cmp r0, r1\r
 457         bne return_error\r
 458         vmov r1, s11\r
 459         cmp r0, r1\r
 460         bne return_error\r
 461         vmov r1, s12\r
 462         cmp r0, r1\r
 463         bne return_error\r
 464         vmov r1, s13\r
 465         cmp r0, r1\r
 466         bne return_error\r
 467         vmov r1, s14\r
 468         cmp r0, r1\r
 469         bne return_error\r
 470         vmov r1, s15\r
 471         cmp r0, r1\r
 472         bne return_error\r
 473         \r
 474 return_pass\r
 475         mov r0, #1\r
 476         bx lr\r
 477 \r
 478 return_error\r
 479         mov r0, #0\r
 480         bx lr\r
 481 }\r
 482 \r
 483         \r