git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_M0_LPC43xx_Keil/M4/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 vRegTest1Task( 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 vRegTest2Task( 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         pop { r0-r1 }\r
 385         \r
 386         /* Start again. */\r
 387         b reg2_loop\r
 388 \r
 389 reg2_error_loop\r
 390         /* If this line is hit then there was an error in a core register value.\r
 391         This loop ensures the loop counter variable stops incrementing. */\r
 392         b reg2_error_loop\r
 393         nop\r
 394 }\r
 395 /*-----------------------------------------------------------*/\r
 396 \r
 397 __asm vRegTestClearFlopRegistersToParameterValue( unsigned long ulValue )\r
 398 {\r
 399         PRESERVE8\r
 400 \r
 401         /* Clobber the auto saved registers. */\r
 402         vmov d0, r0, r0\r
 403         vmov d1, r0, r0\r
 404         vmov d2, r0, r0\r
 405         vmov d3, r0, r0\r
 406         vmov d4, r0, r0\r
 407         vmov d5, r0, r0\r
 408         vmov d6, r0, r0\r
 409         vmov d7, r0, r0\r
 410         bx lr\r
 411 }\r
 412 /*-----------------------------------------------------------*/\r
 413 \r
 414 __asm ulRegTestCheckFlopRegistersContainParameterValue( unsigned long ulValue )\r
 415 {\r
 416         PRESERVE8\r
 417 \r
 418         vmov r1, s0\r
 419         cmp r0, r1\r
 420         bne return_error\r
 421         vmov r1, s1\r
 422         cmp r0, r1\r
 423         bne return_error\r
 424         vmov r1, s2\r
 425         cmp r0, r1\r
 426         bne return_error\r
 427         vmov r1, s3\r
 428         cmp r0, r1\r
 429         bne return_error\r
 430         vmov r1, s4\r
 431         cmp r0, r1\r
 432         bne return_error\r
 433         vmov r1, s5\r
 434         cmp r0, r1\r
 435         bne return_error\r
 436         vmov r1, s6\r
 437         cmp r0, r1\r
 438         bne return_error\r
 439         vmov r1, s7\r
 440         cmp r0, r1\r
 441         bne return_error\r
 442         vmov r1, s8\r
 443         cmp r0, r1\r
 444         bne return_error\r
 445         vmov r1, s9\r
 446         cmp r0, r1\r
 447         bne return_error\r
 448         vmov r1, s10\r
 449         cmp r0, r1\r
 450         bne return_error\r
 451         vmov r1, s11\r
 452         cmp r0, r1\r
 453         bne return_error\r
 454         vmov r1, s12\r
 455         cmp r0, r1\r
 456         bne return_error\r
 457         vmov r1, s13\r
 458         cmp r0, r1\r
 459         bne return_error\r
 460         vmov r1, s14\r
 461         cmp r0, r1\r
 462         bne return_error\r
 463         vmov r1, s15\r
 464         cmp r0, r1\r
 465         bne return_error\r
 466         \r
 467 return_pass\r
 468         mov r0, #1\r
 469         bx lr\r
 470 \r
 471 return_error\r
 472         mov r0, #0\r
 473         bx lr\r
 474 }\r
 475 \r
 476         \r