git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_STM32F407ZG-SK/RegTest.s

   1 /*\r
   2     FreeRTOS V7.5.3 - Copyright (C) 2013 Real Time Engineers Ltd. \r
   3     All rights reserved\r
   4 \r
   5     VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
   6 \r
   7     ***************************************************************************\r
   8      *                                                                       *\r
   9      *    FreeRTOS provides completely free yet professionally developed,    *\r
  10      *    robust, strictly quality controlled, supported, and cross          *\r
  11      *    platform software that has become a de facto standard.             *\r
  12      *                                                                       *\r
  13      *    Help yourself get started quickly and support the FreeRTOS         *\r
  14      *    project by purchasing a FreeRTOS tutorial book, reference          *\r
  15      *    manual, or both from: http://www.FreeRTOS.org/Documentation        *\r
  16      *                                                                       *\r
  17      *    Thank you!                                                         *\r
  18      *                                                                       *\r
  19     ***************************************************************************\r
  20 \r
  21     This file is part of the FreeRTOS distribution.\r
  22 \r
  23     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  24     the terms of the GNU General Public License (version 2) as published by the\r
  25     Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
  26 \r
  27     >>! NOTE: The modification to the GPL is included to allow you to distribute\r
  28     >>! a combined work that includes FreeRTOS without being obliged to provide\r
  29     >>! the source code for proprietary components outside of the FreeRTOS\r
  30     >>! kernel.\r
  31 \r
  32     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  33     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  34     FOR A PARTICULAR PURPOSE.  Full license text is available from the following\r
  35     link: http://www.freertos.org/a00114.html\r
  36 \r
  37     1 tab == 4 spaces!\r
  38 \r
  39     ***************************************************************************\r
  40      *                                                                       *\r
  41      *    Having a problem?  Start by reading the FAQ "My application does   *\r
  42      *    not run, what could be wrong?"                                     *\r
  43      *                                                                       *\r
  44      *    http://www.FreeRTOS.org/FAQHelp.html                               *\r
  45      *                                                                       *\r
  46     ***************************************************************************\r
  47 \r
  48     http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
  49     license and Real Time Engineers Ltd. contact details.\r
  50 \r
  51     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  52     including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
  53     compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
  54 \r
  55     http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
  56     Integrity Systems to sell under the OpenRTOS brand.  Low cost OpenRTOS\r
  57     licenses offer ticketed support, indemnification and middleware.\r
  58 \r
  59     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  60     engineered and independently SIL3 certified version for use in safety and\r
  61     mission critical applications that require provable dependability.\r
  62 \r
  63     1 tab == 4 spaces!\r
  64 */\r
  65 \r
  66 #include <FreeRTOSConfig.h>\r
  67 \r
  68 \r
  69         RSEG    CODE:CODE(2)\r
  70         thumb\r
  71 \r
  72         EXTERN ulRegTest1LoopCounter\r
  73         EXTERN ulRegTest2LoopCounter\r
  74 \r
  75         PUBLIC vRegTest1Task\r
  76         PUBLIC vRegTest2Task\r
  77         PUBLIC vRegTestClearFlopRegistersToParameterValue\r
  78         PUBLIC ulRegTestCheckFlopRegistersContainParameterValue\r
  79         \r
  80 /*-----------------------------------------------------------*/\r
  81 \r
  82 vRegTest1Task\r
  83 \r
  84         /* Fill the core registers with known values. */\r
  85         mov r0, #100\r
  86         mov r1, #101\r
  87         mov r2, #102\r
  88         mov r3, #103\r
  89         mov     r4, #104\r
  90         mov     r5, #105\r
  91         mov     r6, #106\r
  92         mov r7, #107\r
  93         mov     r8, #108\r
  94         mov     r9, #109\r
  95         mov     r10, #110\r
  96         mov     r11, #111\r
  97         mov r12, #112\r
  98 \r
  99         /* Fill the VFP registers with known values. */\r
 100         vmov d0, r0, r1\r
 101         vmov d1, r2, r3\r
 102         vmov d2, r4, r5\r
 103         vmov d3, r6, r7\r
 104         vmov d4, r8, r9\r
 105         vmov d5, r10, r11\r
 106         vmov d6, r0, r1\r
 107         vmov d7, r2, r3\r
 108         vmov d8, r4, r5\r
 109         vmov d9, r6, r7\r
 110         vmov d10, r8, r9\r
 111         vmov d11, r10, r11\r
 112         vmov d12, r0, r1\r
 113         vmov d13, r2, r3\r
 114         vmov d14, r4, r5\r
 115         vmov d15, r6, r7\r
 116 \r
 117 reg1_loop:\r
 118         /* Check all the VFP registers still contain the values set above.\r
 119         First save registers that are clobbered by the test. */\r
 120         push { r0-r1 }\r
 121         \r
 122         vmov r0, r1, d0\r
 123         cmp r0, #100\r
 124         bne reg1_error_loopf\r
 125         cmp r1, #101\r
 126         bne reg1_error_loopf\r
 127         vmov r0, r1, d1\r
 128         cmp r0, #102\r
 129         bne reg1_error_loopf\r
 130         cmp r1, #103\r
 131         bne reg1_error_loopf\r
 132         vmov r0, r1, d2\r
 133         cmp r0, #104\r
 134         bne reg1_error_loopf\r
 135         cmp r1, #105\r
 136         bne reg1_error_loopf\r
 137         vmov r0, r1, d3\r
 138         cmp r0, #106\r
 139         bne reg1_error_loopf\r
 140         cmp r1, #107\r
 141         bne reg1_error_loopf\r
 142         vmov r0, r1, d4\r
 143         cmp r0, #108\r
 144         bne reg1_error_loopf\r
 145         cmp r1, #109\r
 146         bne reg1_error_loopf\r
 147         vmov r0, r1, d5\r
 148         cmp r0, #110\r
 149         bne reg1_error_loopf\r
 150         cmp r1, #111\r
 151         bne reg1_error_loopf\r
 152         vmov r0, r1, d6\r
 153         cmp r0, #100\r
 154         bne reg1_error_loopf\r
 155         cmp r1, #101\r
 156         bne reg1_error_loopf\r
 157         vmov r0, r1, d7\r
 158         cmp r0, #102\r
 159         bne reg1_error_loopf\r
 160         cmp r1, #103\r
 161         bne reg1_error_loopf\r
 162         vmov r0, r1, d8\r
 163         cmp r0, #104\r
 164         bne reg1_error_loopf\r
 165         cmp r1, #105\r
 166         bne reg1_error_loopf\r
 167         vmov r0, r1, d9\r
 168         cmp r0, #106\r
 169         bne reg1_error_loopf\r
 170         cmp r1, #107\r
 171         bne reg1_error_loopf\r
 172         vmov r0, r1, d10\r
 173         cmp r0, #108\r
 174         bne reg1_error_loopf\r
 175         cmp r1, #109\r
 176         bne reg1_error_loopf\r
 177         vmov r0, r1, d11\r
 178         cmp r0, #110\r
 179         bne reg1_error_loopf\r
 180         cmp r1, #111\r
 181         bne reg1_error_loopf\r
 182         vmov r0, r1, d12\r
 183         cmp r0, #100\r
 184         bne reg1_error_loopf\r
 185         cmp r1, #101\r
 186         bne reg1_error_loopf\r
 187         vmov r0, r1, d13\r
 188         cmp r0, #102\r
 189         bne reg1_error_loopf\r
 190         cmp r1, #103\r
 191         bne reg1_error_loopf\r
 192         vmov r0, r1, d14\r
 193         cmp r0, #104\r
 194         bne reg1_error_loopf\r
 195         cmp r1, #105\r
 196         bne reg1_error_loopf\r
 197         vmov r0, r1, d15\r
 198         cmp r0, #106\r
 199         bne reg1_error_loopf\r
 200         cmp r1, #107\r
 201         bne reg1_error_loopf\r
 202         \r
 203         /* Restore the registers that were clobbered by the test. */\r
 204         pop {r0-r1}\r
 205         \r
 206         /* VFP register test passed.  Jump to the core register test. */\r
 207         b reg1_loopf_pass\r
 208 \r
 209 reg1_error_loopf\r
 210         /* If this line is hit then a VFP register value was found to be\r
 211         incorrect. */\r
 212         b reg1_error_loopf\r
 213 \r
 214 reg1_loopf_pass\r
 215 \r
 216         cmp     r0, #100\r
 217         bne     reg1_error_loop\r
 218         cmp     r1, #101\r
 219         bne     reg1_error_loop\r
 220         cmp     r2, #102\r
 221         bne     reg1_error_loop\r
 222         cmp r3, #103\r
 223         bne     reg1_error_loop\r
 224         cmp     r4, #104\r
 225         bne     reg1_error_loop\r
 226         cmp     r5, #105\r
 227         bne     reg1_error_loop\r
 228         cmp     r6, #106\r
 229         bne     reg1_error_loop\r
 230         cmp     r7, #107\r
 231         bne     reg1_error_loop\r
 232         cmp     r8, #108\r
 233         bne     reg1_error_loop\r
 234         cmp     r9, #109\r
 235         bne     reg1_error_loop\r
 236         cmp     r10, #110\r
 237         bne     reg1_error_loop\r
 238         cmp     r11, #111\r
 239         bne     reg1_error_loop\r
 240         cmp     r12, #112\r
 241         bne     reg1_error_loop\r
 242         \r
 243         /* Everything passed, increment the loop counter. */\r
 244         push { r0-r1 }\r
 245         ldr     r0, =ulRegTest1LoopCounter\r
 246         ldr r1, [r0]\r
 247         adds r1, r1, #1\r
 248         str r1, [r0]\r
 249         pop { r0-r1 }\r
 250         \r
 251         /* Start again. */\r
 252         b reg1_loop\r
 253 \r
 254 reg1_error_loop:\r
 255         /* If this line is hit then there was an error in a core register value.\r
 256         The loop ensures the loop counter stops incrementing. */\r
 257         b reg1_error_loop\r
 258 \r
 259 /*-----------------------------------------------------------*/\r
 260 \r
 261 \r
 262 vRegTest2Task\r
 263 \r
 264         /* Set all the core registers to known values. */\r
 265         mov r0, #-1\r
 266         mov r1, #1\r
 267         mov r2, #2\r
 268         mov r3, #3\r
 269         mov     r4, #4\r
 270         mov     r5, #5\r
 271         mov     r6, #6\r
 272         mov r7, #7\r
 273         mov     r8, #8\r
 274         mov     r9, #9\r
 275         mov     r10, #10\r
 276         mov     r11, #11\r
 277         mov r12, #12\r
 278 \r
 279         /* Set all the VFP to known values. */\r
 280         vmov d0, r0, r1\r
 281         vmov d1, r2, r3\r
 282         vmov d2, r4, r5\r
 283         vmov d3, r6, r7\r
 284         vmov d4, r8, r9\r
 285         vmov d5, r10, r11\r
 286         vmov d6, r0, r1\r
 287         vmov d7, r2, r3\r
 288         vmov d8, r4, r5\r
 289         vmov d9, r6, r7\r
 290         vmov d10, r8, r9\r
 291         vmov d11, r10, r11\r
 292         vmov d12, r0, r1\r
 293         vmov d13, r2, r3\r
 294         vmov d14, r4, r5\r
 295         vmov d15, r6, r7\r
 296 \r
 297 reg2_loop:\r
 298         \r
 299         /* Check all the VFP registers still contain the values set above.\r
 300         First save registers that are clobbered by the test. */\r
 301         push { r0-r1 }\r
 302         \r
 303         vmov r0, r1, d0\r
 304         cmp r0, #-1\r
 305         bne reg2_error_loopf\r
 306         cmp r1, #1\r
 307         bne reg2_error_loopf\r
 308         vmov r0, r1, d1\r
 309         cmp r0, #2\r
 310         bne reg2_error_loopf\r
 311         cmp r1, #3\r
 312         bne reg2_error_loopf\r
 313         vmov r0, r1, d2\r
 314         cmp r0, #4\r
 315         bne reg2_error_loopf\r
 316         cmp r1, #5\r
 317         bne reg2_error_loopf\r
 318         vmov r0, r1, d3\r
 319         cmp r0, #6\r
 320         bne reg2_error_loopf\r
 321         cmp r1, #7\r
 322         bne reg2_error_loopf\r
 323         vmov r0, r1, d4\r
 324         cmp r0, #8\r
 325         bne reg2_error_loopf\r
 326         cmp r1, #9\r
 327         bne reg2_error_loopf\r
 328         vmov r0, r1, d5\r
 329         cmp r0, #10\r
 330         bne reg2_error_loopf\r
 331         cmp r1, #11\r
 332         bne reg2_error_loopf\r
 333         vmov r0, r1, d6\r
 334         cmp r0, #-1\r
 335         bne reg2_error_loopf\r
 336         cmp r1, #1\r
 337         bne reg2_error_loopf\r
 338         vmov r0, r1, d7\r
 339         cmp r0, #2\r
 340         bne reg2_error_loopf\r
 341         cmp r1, #3\r
 342         bne reg2_error_loopf\r
 343         vmov r0, r1, d8\r
 344         cmp r0, #4\r
 345         bne reg2_error_loopf\r
 346         cmp r1, #5\r
 347         bne reg2_error_loopf\r
 348         vmov r0, r1, d9\r
 349         cmp r0, #6\r
 350         bne reg2_error_loopf\r
 351         cmp r1, #7\r
 352         bne reg2_error_loopf\r
 353         vmov r0, r1, d10\r
 354         cmp r0, #8\r
 355         bne reg2_error_loopf\r
 356         cmp r1, #9\r
 357         bne reg2_error_loopf\r
 358         vmov r0, r1, d11\r
 359         cmp r0, #10\r
 360         bne reg2_error_loopf\r
 361         cmp r1, #11\r
 362         bne reg2_error_loopf\r
 363         vmov r0, r1, d12\r
 364         cmp r0, #-1\r
 365         bne reg2_error_loopf\r
 366         cmp r1, #1\r
 367         bne reg2_error_loopf\r
 368         vmov r0, r1, d13\r
 369         cmp r0, #2\r
 370         bne reg2_error_loopf\r
 371         cmp r1, #3\r
 372         bne reg2_error_loopf\r
 373         vmov r0, r1, d14\r
 374         cmp r0, #4\r
 375         bne reg2_error_loopf\r
 376         cmp r1, #5\r
 377         bne reg2_error_loopf\r
 378         vmov r0, r1, d15\r
 379         cmp r0, #6\r
 380         bne reg2_error_loopf\r
 381         cmp r1, #7\r
 382         bne reg2_error_loopf\r
 383         \r
 384         /* Restore the registers that were clobbered by the test. */\r
 385         pop {r0-r1}\r
 386         \r
 387         /* VFP register test passed.  Jump to the core register test. */\r
 388         b reg2_loopf_pass\r
 389 \r
 390 reg2_error_loopf\r
 391         /* If this line is hit then a VFP register value was found to be\r
 392         incorrect. */\r
 393         b reg2_error_loopf\r
 394 \r
 395 reg2_loopf_pass\r
 396 \r
 397         cmp     r0, #-1\r
 398         bne     reg2_error_loop\r
 399         cmp     r1, #1\r
 400         bne     reg2_error_loop\r
 401         cmp     r2, #2\r
 402         bne     reg2_error_loop\r
 403         cmp r3, #3\r
 404         bne     reg2_error_loop\r
 405         cmp     r4, #4\r
 406         bne     reg2_error_loop\r
 407         cmp     r5, #5\r
 408         bne     reg2_error_loop\r
 409         cmp     r6, #6\r
 410         bne     reg2_error_loop\r
 411         cmp     r7, #7\r
 412         bne     reg2_error_loop\r
 413         cmp     r8, #8\r
 414         bne     reg2_error_loop\r
 415         cmp     r9, #9\r
 416         bne     reg2_error_loop\r
 417         cmp     r10, #10\r
 418         bne     reg2_error_loop\r
 419         cmp     r11, #11\r
 420         bne     reg2_error_loop\r
 421         cmp     r12, #12\r
 422         bne     reg2_error_loop\r
 423         \r
 424         /* Increment the loop counter to indicate this test is still functioning\r
 425         correctly. */\r
 426         push { r0-r1 }\r
 427         ldr     r0, =ulRegTest2LoopCounter\r
 428         ldr r1, [r0]\r
 429         adds r1, r1, #1\r
 430         str r1, [r0]\r
 431         pop { r0-r1 }\r
 432         \r
 433         /* Start again. */\r
 434         b reg2_loop\r
 435 \r
 436 reg2_error_loop:\r
 437         /* If this line is hit then there was an error in a core register value.\r
 438         This loop ensures the loop counter variable stops incrementing. */\r
 439         b reg2_error_loop\r
 440 \r
 441 /*-----------------------------------------------------------*/\r
 442 \r
 443 vRegTestClearFlopRegistersToParameterValue\r
 444 \r
 445         /* Clobber the auto saved registers. */\r
 446         vmov d0, r0, r0\r
 447         vmov d1, r0, r0\r
 448         vmov d2, r0, r0\r
 449         vmov d3, r0, r0\r
 450         vmov d4, r0, r0\r
 451         vmov d5, r0, r0\r
 452         vmov d6, r0, r0\r
 453         vmov d7, r0, r0\r
 454         bx lr\r
 455 \r
 456 /*-----------------------------------------------------------*/\r
 457 \r
 458 ulRegTestCheckFlopRegistersContainParameterValue\r
 459 \r
 460         vmov r1, s0\r
 461         cmp r0, r1\r
 462         bne return_error\r
 463         vmov r1, s1\r
 464         cmp r0, r1\r
 465         bne return_error\r
 466         vmov r1, s2\r
 467         cmp r0, r1\r
 468         bne return_error\r
 469         vmov r1, s3\r
 470         cmp r0, r1\r
 471         bne return_error\r
 472         vmov r1, s4\r
 473         cmp r0, r1\r
 474         bne return_error\r
 475         vmov r1, s5\r
 476         cmp r0, r1\r
 477         bne return_error\r
 478         vmov r1, s6\r
 479         cmp r0, r1\r
 480         bne return_error\r
 481         vmov r1, s7\r
 482         cmp r0, r1\r
 483         bne return_error\r
 484         vmov r1, s8\r
 485         cmp r0, r1\r
 486         bne return_error\r
 487         vmov r1, s9\r
 488         cmp r0, r1\r
 489         bne return_error\r
 490         vmov r1, s10\r
 491         cmp r0, r1\r
 492         bne return_error\r
 493         vmov r1, s11\r
 494         cmp r0, r1\r
 495         bne return_error\r
 496         vmov r1, s12\r
 497         cmp r0, r1\r
 498         bne return_error\r
 499         vmov r1, s13\r
 500         cmp r0, r1\r
 501         bne return_error\r
 502         vmov r1, s14\r
 503         cmp r0, r1\r
 504         bne return_error\r
 505         vmov r1, s15\r
 506         cmp r0, r1\r
 507         bne return_error\r
 508         \r
 509 return_pass\r
 510         mov r0, #1\r
 511         bx lr\r
 512 \r
 513 return_error\r
 514         mov r0, #0\r
 515         bx lr\r
 516 \r
 517         END\r
 518         \r