git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_CEC1302_MikroC/MikroC_Specific/RegTest.c

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