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

   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 #include <FreeRTOSConfig.h>\r
  29 \r
  30 \r
  31         RSEG    CODE:CODE(2)\r
  32         thumb\r
  33 \r
  34         EXTERN ulRegTest1LoopCounter\r
  35         EXTERN ulRegTest2LoopCounter\r
  36 \r
  37         PUBLIC vRegTest1Implementation\r
  38         PUBLIC vRegTest2Implementation\r
  39 \r
  40 /*-----------------------------------------------------------*/\r
  41 \r
  42 vRegTest1Implementation\r
  43 \r
  44         /* Fill the core registers with known values. */\r
  45         mov r0, #100\r
  46         mov r1, #101\r
  47         mov r2, #102\r
  48         mov r3, #103\r
  49         mov     r4, #104\r
  50         mov     r5, #105\r
  51         mov     r6, #106\r
  52         mov r7, #107\r
  53         mov     r8, #108\r
  54         mov     r9, #109\r
  55         mov     r10, #110\r
  56         mov     r11, #111\r
  57         mov r12, #112\r
  58 \r
  59         /* Fill the VFP registers with known values. */\r
  60         vmov d0, r0, r1\r
  61         vmov d1, r2, r3\r
  62         vmov d2, r4, r5\r
  63         vmov d3, r6, r7\r
  64         vmov d4, r8, r9\r
  65         vmov d5, r10, r11\r
  66         vmov d6, r0, r1\r
  67         vmov d7, r2, r3\r
  68         vmov d8, r4, r5\r
  69         vmov d9, r6, r7\r
  70         vmov d10, r8, r9\r
  71         vmov d11, r10, r11\r
  72         vmov d12, r0, r1\r
  73         vmov d13, r2, r3\r
  74         vmov d14, r4, r5\r
  75         vmov d15, r6, r7\r
  76 \r
  77 reg1_loop:\r
  78         /* Check all the VFP registers still contain the values set above.\r
  79         First save registers that are clobbered by the test. */\r
  80         push { r0-r1 }\r
  81 \r
  82         vmov r0, r1, d0\r
  83         cmp r0, #100\r
  84         bne reg1_error_loopf\r
  85         cmp r1, #101\r
  86         bne reg1_error_loopf\r
  87         vmov r0, r1, d1\r
  88         cmp r0, #102\r
  89         bne reg1_error_loopf\r
  90         cmp r1, #103\r
  91         bne reg1_error_loopf\r
  92         vmov r0, r1, d2\r
  93         cmp r0, #104\r
  94         bne reg1_error_loopf\r
  95         cmp r1, #105\r
  96         bne reg1_error_loopf\r
  97         vmov r0, r1, d3\r
  98         cmp r0, #106\r
  99         bne reg1_error_loopf\r
 100         cmp r1, #107\r
 101         bne reg1_error_loopf\r
 102         vmov r0, r1, d4\r
 103         cmp r0, #108\r
 104         bne reg1_error_loopf\r
 105         cmp r1, #109\r
 106         bne reg1_error_loopf\r
 107         vmov r0, r1, d5\r
 108         cmp r0, #110\r
 109         bne reg1_error_loopf\r
 110         cmp r1, #111\r
 111         bne reg1_error_loopf\r
 112         vmov r0, r1, d6\r
 113         cmp r0, #100\r
 114         bne reg1_error_loopf\r
 115         cmp r1, #101\r
 116         bne reg1_error_loopf\r
 117         vmov r0, r1, d7\r
 118         cmp r0, #102\r
 119         bne reg1_error_loopf\r
 120         cmp r1, #103\r
 121         bne reg1_error_loopf\r
 122         vmov r0, r1, d8\r
 123         cmp r0, #104\r
 124         bne reg1_error_loopf\r
 125         cmp r1, #105\r
 126         bne reg1_error_loopf\r
 127         vmov r0, r1, d9\r
 128         cmp r0, #106\r
 129         bne reg1_error_loopf\r
 130         cmp r1, #107\r
 131         bne reg1_error_loopf\r
 132         vmov r0, r1, d10\r
 133         cmp r0, #108\r
 134         bne reg1_error_loopf\r
 135         cmp r1, #109\r
 136         bne reg1_error_loopf\r
 137         vmov r0, r1, d11\r
 138         cmp r0, #110\r
 139         bne reg1_error_loopf\r
 140         cmp r1, #111\r
 141         bne reg1_error_loopf\r
 142         vmov r0, r1, d12\r
 143         cmp r0, #100\r
 144         bne reg1_error_loopf\r
 145         cmp r1, #101\r
 146         bne reg1_error_loopf\r
 147         vmov r0, r1, d13\r
 148         cmp r0, #102\r
 149         bne reg1_error_loopf\r
 150         cmp r1, #103\r
 151         bne reg1_error_loopf\r
 152         vmov r0, r1, d14\r
 153         cmp r0, #104\r
 154         bne reg1_error_loopf\r
 155         cmp r1, #105\r
 156         bne reg1_error_loopf\r
 157         vmov r0, r1, d15\r
 158         cmp r0, #106\r
 159         bne reg1_error_loopf\r
 160         cmp r1, #107\r
 161         bne reg1_error_loopf\r
 162 \r
 163         /* Restore the registers that were clobbered by the test. */\r
 164         pop {r0-r1}\r
 165 \r
 166         /* VFP register test passed.  Jump to the core register test. */\r
 167         b reg1_loopf_pass\r
 168 \r
 169 reg1_error_loopf\r
 170         /* If this line is hit then a VFP register value was found to be\r
 171         incorrect. */\r
 172         b reg1_error_loopf\r
 173 \r
 174 reg1_loopf_pass\r
 175 \r
 176         cmp     r0, #100\r
 177         bne     reg1_error_loop\r
 178         cmp     r1, #101\r
 179         bne     reg1_error_loop\r
 180         cmp     r2, #102\r
 181         bne     reg1_error_loop\r
 182         cmp r3, #103\r
 183         bne     reg1_error_loop\r
 184         cmp     r4, #104\r
 185         bne     reg1_error_loop\r
 186         cmp     r5, #105\r
 187         bne     reg1_error_loop\r
 188         cmp     r6, #106\r
 189         bne     reg1_error_loop\r
 190         cmp     r7, #107\r
 191         bne     reg1_error_loop\r
 192         cmp     r8, #108\r
 193         bne     reg1_error_loop\r
 194         cmp     r9, #109\r
 195         bne     reg1_error_loop\r
 196         cmp     r10, #110\r
 197         bne     reg1_error_loop\r
 198         cmp     r11, #111\r
 199         bne     reg1_error_loop\r
 200         cmp     r12, #112\r
 201         bne     reg1_error_loop\r
 202 \r
 203         /* Everything passed, increment the loop counter. */\r
 204         push { r0-r1 }\r
 205         ldr     r0, =ulRegTest1LoopCounter\r
 206         ldr r1, [r0]\r
 207         adds r1, r1, #1\r
 208         str r1, [r0]\r
 209         pop { r0-r1 }\r
 210 \r
 211         /* Start again. */\r
 212         b reg1_loop\r
 213 \r
 214 reg1_error_loop:\r
 215         /* If this line is hit then there was an error in a core register value.\r
 216         The loop ensures the loop counter stops incrementing. */\r
 217         b reg1_error_loop\r
 218 \r
 219 /*-----------------------------------------------------------*/\r
 220 \r
 221 \r
 222 vRegTest2Implementation\r
 223 \r
 224         /* Set all the core registers to known values. */\r
 225         mov r0, #-1\r
 226         mov r1, #1\r
 227         mov r2, #2\r
 228         mov r3, #3\r
 229         mov     r4, #4\r
 230         mov     r5, #5\r
 231         mov     r6, #6\r
 232         mov r7, #7\r
 233         mov     r8, #8\r
 234         mov     r9, #9\r
 235         mov     r10, #10\r
 236         mov     r11, #11\r
 237         mov r12, #12\r
 238 \r
 239         /* Set all the VFP to known values. */\r
 240         vmov d0, r0, r1\r
 241         vmov d1, r2, r3\r
 242         vmov d2, r4, r5\r
 243         vmov d3, r6, r7\r
 244         vmov d4, r8, r9\r
 245         vmov d5, r10, r11\r
 246         vmov d6, r0, r1\r
 247         vmov d7, r2, r3\r
 248         vmov d8, r4, r5\r
 249         vmov d9, r6, r7\r
 250         vmov d10, r8, r9\r
 251         vmov d11, r10, r11\r
 252         vmov d12, r0, r1\r
 253         vmov d13, r2, r3\r
 254         vmov d14, r4, r5\r
 255         vmov d15, r6, r7\r
 256 \r
 257 reg2_loop:\r
 258 \r
 259         /* Check all the VFP registers still contain the values set above.\r
 260         First save registers that are clobbered by the test. */\r
 261         push { r0-r1 }\r
 262 \r
 263         vmov r0, r1, d0\r
 264         cmp r0, #-1\r
 265         bne reg2_error_loopf\r
 266         cmp r1, #1\r
 267         bne reg2_error_loopf\r
 268         vmov r0, r1, d1\r
 269         cmp r0, #2\r
 270         bne reg2_error_loopf\r
 271         cmp r1, #3\r
 272         bne reg2_error_loopf\r
 273         vmov r0, r1, d2\r
 274         cmp r0, #4\r
 275         bne reg2_error_loopf\r
 276         cmp r1, #5\r
 277         bne reg2_error_loopf\r
 278         vmov r0, r1, d3\r
 279         cmp r0, #6\r
 280         bne reg2_error_loopf\r
 281         cmp r1, #7\r
 282         bne reg2_error_loopf\r
 283         vmov r0, r1, d4\r
 284         cmp r0, #8\r
 285         bne reg2_error_loopf\r
 286         cmp r1, #9\r
 287         bne reg2_error_loopf\r
 288         vmov r0, r1, d5\r
 289         cmp r0, #10\r
 290         bne reg2_error_loopf\r
 291         cmp r1, #11\r
 292         bne reg2_error_loopf\r
 293         vmov r0, r1, d6\r
 294         cmp r0, #-1\r
 295         bne reg2_error_loopf\r
 296         cmp r1, #1\r
 297         bne reg2_error_loopf\r
 298         vmov r0, r1, d7\r
 299         cmp r0, #2\r
 300         bne reg2_error_loopf\r
 301         cmp r1, #3\r
 302         bne reg2_error_loopf\r
 303         vmov r0, r1, d8\r
 304         cmp r0, #4\r
 305         bne reg2_error_loopf\r
 306         cmp r1, #5\r
 307         bne reg2_error_loopf\r
 308         vmov r0, r1, d9\r
 309         cmp r0, #6\r
 310         bne reg2_error_loopf\r
 311         cmp r1, #7\r
 312         bne reg2_error_loopf\r
 313         vmov r0, r1, d10\r
 314         cmp r0, #8\r
 315         bne reg2_error_loopf\r
 316         cmp r1, #9\r
 317         bne reg2_error_loopf\r
 318         vmov r0, r1, d11\r
 319         cmp r0, #10\r
 320         bne reg2_error_loopf\r
 321         cmp r1, #11\r
 322         bne reg2_error_loopf\r
 323         vmov r0, r1, d12\r
 324         cmp r0, #-1\r
 325         bne reg2_error_loopf\r
 326         cmp r1, #1\r
 327         bne reg2_error_loopf\r
 328         vmov r0, r1, d13\r
 329         cmp r0, #2\r
 330         bne reg2_error_loopf\r
 331         cmp r1, #3\r
 332         bne reg2_error_loopf\r
 333         vmov r0, r1, d14\r
 334         cmp r0, #4\r
 335         bne reg2_error_loopf\r
 336         cmp r1, #5\r
 337         bne reg2_error_loopf\r
 338         vmov r0, r1, d15\r
 339         cmp r0, #6\r
 340         bne reg2_error_loopf\r
 341         cmp r1, #7\r
 342         bne reg2_error_loopf\r
 343 \r
 344         /* Restore the registers that were clobbered by the test. */\r
 345         pop {r0-r1}\r
 346 \r
 347         /* VFP register test passed.  Jump to the core register test. */\r
 348         b reg2_loopf_pass\r
 349 \r
 350 reg2_error_loopf\r
 351         /* If this line is hit then a VFP register value was found to be\r
 352         incorrect. */\r
 353         b reg2_error_loopf\r
 354 \r
 355 reg2_loopf_pass\r
 356 \r
 357         cmp     r0, #-1\r
 358         bne     reg2_error_loop\r
 359         cmp     r1, #1\r
 360         bne     reg2_error_loop\r
 361         cmp     r2, #2\r
 362         bne     reg2_error_loop\r
 363         cmp r3, #3\r
 364         bne     reg2_error_loop\r
 365         cmp     r4, #4\r
 366         bne     reg2_error_loop\r
 367         cmp     r5, #5\r
 368         bne     reg2_error_loop\r
 369         cmp     r6, #6\r
 370         bne     reg2_error_loop\r
 371         cmp     r7, #7\r
 372         bne     reg2_error_loop\r
 373         cmp     r8, #8\r
 374         bne     reg2_error_loop\r
 375         cmp     r9, #9\r
 376         bne     reg2_error_loop\r
 377         cmp     r10, #10\r
 378         bne     reg2_error_loop\r
 379         cmp     r11, #11\r
 380         bne     reg2_error_loop\r
 381         cmp     r12, #12\r
 382         bne     reg2_error_loop\r
 383 \r
 384         /* Increment the loop counter to indicate this test is still functioning\r
 385         correctly. */\r
 386         push { r0-r1 }\r
 387         ldr     r0, =ulRegTest2LoopCounter\r
 388         ldr r1, [r0]\r
 389         adds r1, r1, #1\r
 390         str r1, [r0]\r
 391 \r
 392         /* Yield to increase test coverage. */\r
 393         movs r0, #0x01\r
 394         ldr r1, =0xe000ed04 /*NVIC_INT_CTRL */\r
 395         lsl r0, r0, #28 /* Shift to PendSV bit */\r
 396         str r0, [r1]\r
 397         dsb\r
 398 \r
 399         pop { r0-r1 }\r
 400 \r
 401         /* Start again. */\r
 402         b reg2_loop\r
 403 \r
 404 reg2_error_loop:\r
 405         /* If this line is hit then there was an error in a core register value.\r
 406         This loop ensures the loop counter variable stops incrementing. */\r
 407         b reg2_error_loop\r
 408 \r
 409 /*-----------------------------------------------------------*/\r
 410 \r
 411 vRegTestClearFlopRegistersToParameterValue\r
 412 \r
 413         /* Clobber the auto saved registers. */\r
 414         vmov d0, r0, r0\r
 415         vmov d1, r0, r0\r
 416         vmov d2, r0, r0\r
 417         vmov d3, r0, r0\r
 418         vmov d4, r0, r0\r
 419         vmov d5, r0, r0\r
 420         vmov d6, r0, r0\r
 421         vmov d7, r0, r0\r
 422         bx lr\r
 423 \r
 424 /*-----------------------------------------------------------*/\r
 425 \r
 426 ulRegTestCheckFlopRegistersContainParameterValue\r
 427 \r
 428         vmov r1, s0\r
 429         cmp r0, r1\r
 430         bne return_error\r
 431         vmov r1, s1\r
 432         cmp r0, r1\r
 433         bne return_error\r
 434         vmov r1, s2\r
 435         cmp r0, r1\r
 436         bne return_error\r
 437         vmov r1, s3\r
 438         cmp r0, r1\r
 439         bne return_error\r
 440         vmov r1, s4\r
 441         cmp r0, r1\r
 442         bne return_error\r
 443         vmov r1, s5\r
 444         cmp r0, r1\r
 445         bne return_error\r
 446         vmov r1, s6\r
 447         cmp r0, r1\r
 448         bne return_error\r
 449         vmov r1, s7\r
 450         cmp r0, r1\r
 451         bne return_error\r
 452         vmov r1, s8\r
 453         cmp r0, r1\r
 454         bne return_error\r
 455         vmov r1, s9\r
 456         cmp r0, r1\r
 457         bne return_error\r
 458         vmov r1, s10\r
 459         cmp r0, r1\r
 460         bne return_error\r
 461         vmov r1, s11\r
 462         cmp r0, r1\r
 463         bne return_error\r
 464         vmov r1, s12\r
 465         cmp r0, r1\r
 466         bne return_error\r
 467         vmov r1, s13\r
 468         cmp r0, r1\r
 469         bne return_error\r
 470         vmov r1, s14\r
 471         cmp r0, r1\r
 472         bne return_error\r
 473         vmov r1, s15\r
 474         cmp r0, r1\r
 475         bne return_error\r
 476 \r
 477 return_pass\r
 478         mov r0, #1\r
 479         bx lr\r
 480 \r
 481 return_error\r
 482         mov r0, #0\r
 483         bx lr\r
 484 \r
 485         END\r
 486 \r