git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/Full_Demo/RegTest_Keil.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 __asm void vRegTest1Implementation( void )\r
  29 {\r
  30         PRESERVE8\r
  31         IMPORT ulRegTest1LoopCounter\r
  32 \r
  33         /* Fill the core registers with known values. */\r
  34         mov r0, #100\r
  35         mov r1, #101\r
  36         mov r2, #102\r
  37         mov r3, #103\r
  38         mov     r4, #104\r
  39         mov     r5, #105\r
  40         mov     r6, #106\r
  41         mov r7, #107\r
  42         mov     r8, #108\r
  43         mov     r9, #109\r
  44         mov     r10, #110\r
  45         mov     r11, #111\r
  46         mov r12, #112\r
  47 \r
  48         /* Fill the VFP registers with known values. */\r
  49         vmov d0, r0, r1\r
  50         vmov d1, r2, r3\r
  51         vmov d2, r4, r5\r
  52         vmov d3, r6, r7\r
  53         vmov d4, r8, r9\r
  54         vmov d5, r10, r11\r
  55         vmov d6, r0, r1\r
  56         vmov d7, r2, r3\r
  57         vmov d8, r4, r5\r
  58         vmov d9, r6, r7\r
  59         vmov d10, r8, r9\r
  60         vmov d11, r10, r11\r
  61         vmov d12, r0, r1\r
  62         vmov d13, r2, r3\r
  63         vmov d14, r4, r5\r
  64         vmov d15, r6, r7\r
  65 \r
  66 reg1_loop\r
  67         /* Check all the VFP registers still contain the values set above.\r
  68         First save registers that are clobbered by the test. */\r
  69         push { r0-r1 }\r
  70         \r
  71         vmov r0, r1, d0\r
  72         cmp r0, #100\r
  73         bne reg1_error_loopf\r
  74         cmp r1, #101\r
  75         bne reg1_error_loopf\r
  76         vmov r0, r1, d1\r
  77         cmp r0, #102\r
  78         bne reg1_error_loopf\r
  79         cmp r1, #103\r
  80         bne reg1_error_loopf\r
  81         vmov r0, r1, d2\r
  82         cmp r0, #104\r
  83         bne reg1_error_loopf\r
  84         cmp r1, #105\r
  85         bne reg1_error_loopf\r
  86         vmov r0, r1, d3\r
  87         cmp r0, #106\r
  88         bne reg1_error_loopf\r
  89         cmp r1, #107\r
  90         bne reg1_error_loopf\r
  91         vmov r0, r1, d4\r
  92         cmp r0, #108\r
  93         bne reg1_error_loopf\r
  94         cmp r1, #109\r
  95         bne reg1_error_loopf\r
  96         vmov r0, r1, d5\r
  97         cmp r0, #110\r
  98         bne reg1_error_loopf\r
  99         cmp r1, #111\r
 100         bne reg1_error_loopf\r
 101         vmov r0, r1, d6\r
 102         cmp r0, #100\r
 103         bne reg1_error_loopf\r
 104         cmp r1, #101\r
 105         bne reg1_error_loopf\r
 106         vmov r0, r1, d7\r
 107         cmp r0, #102\r
 108         bne reg1_error_loopf\r
 109         cmp r1, #103\r
 110         bne reg1_error_loopf\r
 111         vmov r0, r1, d8\r
 112         cmp r0, #104\r
 113         bne reg1_error_loopf\r
 114         cmp r1, #105\r
 115         bne reg1_error_loopf\r
 116         vmov r0, r1, d9\r
 117         cmp r0, #106\r
 118         bne reg1_error_loopf\r
 119         cmp r1, #107\r
 120         bne reg1_error_loopf\r
 121         vmov r0, r1, d10\r
 122         cmp r0, #108\r
 123         bne reg1_error_loopf\r
 124         cmp r1, #109\r
 125         bne reg1_error_loopf\r
 126         vmov r0, r1, d11\r
 127         cmp r0, #110\r
 128         bne reg1_error_loopf\r
 129         cmp r1, #111\r
 130         bne reg1_error_loopf\r
 131         vmov r0, r1, d12\r
 132         cmp r0, #100\r
 133         bne reg1_error_loopf\r
 134         cmp r1, #101\r
 135         bne reg1_error_loopf\r
 136         vmov r0, r1, d13\r
 137         cmp r0, #102\r
 138         bne reg1_error_loopf\r
 139         cmp r1, #103\r
 140         bne reg1_error_loopf\r
 141         vmov r0, r1, d14\r
 142         cmp r0, #104\r
 143         bne reg1_error_loopf\r
 144         cmp r1, #105\r
 145         bne reg1_error_loopf\r
 146         vmov r0, r1, d15\r
 147         cmp r0, #106\r
 148         bne reg1_error_loopf\r
 149         cmp r1, #107\r
 150         bne reg1_error_loopf\r
 151         \r
 152         /* Restore the registers that were clobbered by the test. */\r
 153         pop {r0-r1}\r
 154         \r
 155         /* VFP register test passed.  Jump to the core register test. */\r
 156         b reg1_loopf_pass\r
 157 \r
 158 reg1_error_loopf\r
 159         /* If this line is hit then a VFP register value was found to be\r
 160         incorrect. */\r
 161         b reg1_error_loopf\r
 162 \r
 163 reg1_loopf_pass\r
 164 \r
 165         cmp     r0, #100\r
 166         bne     reg1_error_loop\r
 167         cmp     r1, #101\r
 168         bne     reg1_error_loop\r
 169         cmp     r2, #102\r
 170         bne     reg1_error_loop\r
 171         cmp r3, #103\r
 172         bne     reg1_error_loop\r
 173         cmp     r4, #104\r
 174         bne     reg1_error_loop\r
 175         cmp     r5, #105\r
 176         bne     reg1_error_loop\r
 177         cmp     r6, #106\r
 178         bne     reg1_error_loop\r
 179         cmp     r7, #107\r
 180         bne     reg1_error_loop\r
 181         cmp     r8, #108\r
 182         bne     reg1_error_loop\r
 183         cmp     r9, #109\r
 184         bne     reg1_error_loop\r
 185         cmp     r10, #110\r
 186         bne     reg1_error_loop\r
 187         cmp     r11, #111\r
 188         bne     reg1_error_loop\r
 189         cmp     r12, #112\r
 190         bne     reg1_error_loop\r
 191         \r
 192         /* Everything passed, increment the loop counter. */\r
 193         push { r0-r1 }\r
 194         ldr     r0, =ulRegTest1LoopCounter\r
 195         ldr r1, [r0]\r
 196         adds r1, r1, #1\r
 197         str r1, [r0]\r
 198         pop { r0-r1 }\r
 199         \r
 200         /* Start again. */\r
 201         b reg1_loop\r
 202 \r
 203 reg1_error_loop\r
 204         /* If this line is hit then there was an error in a core register value.\r
 205         The loop ensures the loop counter stops incrementing. */\r
 206         b reg1_error_loop\r
 207         nop\r
 208 }\r
 209 /*-----------------------------------------------------------*/\r
 210 \r
 211 __asm void vRegTest2Implementation( void )\r
 212 {\r
 213         PRESERVE8\r
 214         IMPORT ulRegTest2LoopCounter\r
 215 \r
 216         /* Set all the core registers to known values. */\r
 217         mov r0, #-1\r
 218         mov r1, #1\r
 219         mov r2, #2\r
 220         mov r3, #3\r
 221         mov     r4, #4\r
 222         mov     r5, #5\r
 223         mov     r6, #6\r
 224         mov r7, #7\r
 225         mov     r8, #8\r
 226         mov     r9, #9\r
 227         mov     r10, #10\r
 228         mov     r11, #11\r
 229         mov r12, #12\r
 230 \r
 231         /* Set all the VFP to known values. */\r
 232         vmov d0, r0, r1\r
 233         vmov d1, r2, r3\r
 234         vmov d2, r4, r5\r
 235         vmov d3, r6, r7\r
 236         vmov d4, r8, r9\r
 237         vmov d5, r10, r11\r
 238         vmov d6, r0, r1\r
 239         vmov d7, r2, r3\r
 240         vmov d8, r4, r5\r
 241         vmov d9, r6, r7\r
 242         vmov d10, r8, r9\r
 243         vmov d11, r10, r11\r
 244         vmov d12, r0, r1\r
 245         vmov d13, r2, r3\r
 246         vmov d14, r4, r5\r
 247         vmov d15, r6, r7\r
 248 \r
 249 reg2_loop\r
 250         \r
 251         /* Check all the VFP registers still contain the values set above.\r
 252         First save registers that are clobbered by the test. */\r
 253         push { r0-r1 }\r
 254         \r
 255         vmov r0, r1, d0\r
 256         cmp r0, #-1\r
 257         bne reg2_error_loopf\r
 258         cmp r1, #1\r
 259         bne reg2_error_loopf\r
 260         vmov r0, r1, d1\r
 261         cmp r0, #2\r
 262         bne reg2_error_loopf\r
 263         cmp r1, #3\r
 264         bne reg2_error_loopf\r
 265         vmov r0, r1, d2\r
 266         cmp r0, #4\r
 267         bne reg2_error_loopf\r
 268         cmp r1, #5\r
 269         bne reg2_error_loopf\r
 270         vmov r0, r1, d3\r
 271         cmp r0, #6\r
 272         bne reg2_error_loopf\r
 273         cmp r1, #7\r
 274         bne reg2_error_loopf\r
 275         vmov r0, r1, d4\r
 276         cmp r0, #8\r
 277         bne reg2_error_loopf\r
 278         cmp r1, #9\r
 279         bne reg2_error_loopf\r
 280         vmov r0, r1, d5\r
 281         cmp r0, #10\r
 282         bne reg2_error_loopf\r
 283         cmp r1, #11\r
 284         bne reg2_error_loopf\r
 285         vmov r0, r1, d6\r
 286         cmp r0, #-1\r
 287         bne reg2_error_loopf\r
 288         cmp r1, #1\r
 289         bne reg2_error_loopf\r
 290         vmov r0, r1, d7\r
 291         cmp r0, #2\r
 292         bne reg2_error_loopf\r
 293         cmp r1, #3\r
 294         bne reg2_error_loopf\r
 295         vmov r0, r1, d8\r
 296         cmp r0, #4\r
 297         bne reg2_error_loopf\r
 298         cmp r1, #5\r
 299         bne reg2_error_loopf\r
 300         vmov r0, r1, d9\r
 301         cmp r0, #6\r
 302         bne reg2_error_loopf\r
 303         cmp r1, #7\r
 304         bne reg2_error_loopf\r
 305         vmov r0, r1, d10\r
 306         cmp r0, #8\r
 307         bne reg2_error_loopf\r
 308         cmp r1, #9\r
 309         bne reg2_error_loopf\r
 310         vmov r0, r1, d11\r
 311         cmp r0, #10\r
 312         bne reg2_error_loopf\r
 313         cmp r1, #11\r
 314         bne reg2_error_loopf\r
 315         vmov r0, r1, d12\r
 316         cmp r0, #-1\r
 317         bne reg2_error_loopf\r
 318         cmp r1, #1\r
 319         bne reg2_error_loopf\r
 320         vmov r0, r1, d13\r
 321         cmp r0, #2\r
 322         bne reg2_error_loopf\r
 323         cmp r1, #3\r
 324         bne reg2_error_loopf\r
 325         vmov r0, r1, d14\r
 326         cmp r0, #4\r
 327         bne reg2_error_loopf\r
 328         cmp r1, #5\r
 329         bne reg2_error_loopf\r
 330         vmov r0, r1, d15\r
 331         cmp r0, #6\r
 332         bne reg2_error_loopf\r
 333         cmp r1, #7\r
 334         bne reg2_error_loopf\r
 335         \r
 336         /* Restore the registers that were clobbered by the test. */\r
 337         pop {r0-r1}\r
 338         \r
 339         /* VFP register test passed.  Jump to the core register test. */\r
 340         b reg2_loopf_pass\r
 341 \r
 342 reg2_error_loopf\r
 343         /* If this line is hit then a VFP register value was found to be\r
 344         incorrect. */\r
 345         b reg2_error_loopf\r
 346 \r
 347 reg2_loopf_pass\r
 348 \r
 349         cmp     r0, #-1\r
 350         bne     reg2_error_loop\r
 351         cmp     r1, #1\r
 352         bne     reg2_error_loop\r
 353         cmp     r2, #2\r
 354         bne     reg2_error_loop\r
 355         cmp r3, #3\r
 356         bne     reg2_error_loop\r
 357         cmp     r4, #4\r
 358         bne     reg2_error_loop\r
 359         cmp     r5, #5\r
 360         bne     reg2_error_loop\r
 361         cmp     r6, #6\r
 362         bne     reg2_error_loop\r
 363         cmp     r7, #7\r
 364         bne     reg2_error_loop\r
 365         cmp     r8, #8\r
 366         bne     reg2_error_loop\r
 367         cmp     r9, #9\r
 368         bne     reg2_error_loop\r
 369         cmp     r10, #10\r
 370         bne     reg2_error_loop\r
 371         cmp     r11, #11\r
 372         bne     reg2_error_loop\r
 373         cmp     r12, #12\r
 374         bne     reg2_error_loop\r
 375         \r
 376         /* Increment the loop counter to indicate this test is still functioning\r
 377         correctly. */\r
 378         push { r0-r1 }\r
 379         ldr     r0, =ulRegTest2LoopCounter\r
 380         ldr r1, [r0]\r
 381         adds r1, r1, #1\r
 382         str r1, [r0]\r
 383         \r
 384         /* Yield to increase test coverage. */\r
 385         movs r0, #0x01\r
 386         ldr r1, =0xe000ed04 /*NVIC_INT_CTRL */\r
 387         lsl r0, r0, #28 /* Shift to PendSV bit */\r
 388         str r0, [r1]\r
 389         dsb\r
 390         \r
 391         pop { r0-r1 }\r
 392         \r
 393         /* Start again. */\r
 394         b reg2_loop\r
 395 \r
 396 reg2_error_loop\r
 397         /* If this line is hit then there was an error in a core register value.\r
 398         This loop ensures the loop counter variable stops incrementing. */\r
 399         b reg2_error_loop\r
 400 }\r
 401 /*-----------------------------------------------------------*/\r
 402 \r