git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_M0_LPC43xx_Keil/M4/RegTest.c

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