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

   1 /*\r
   2     FreeRTOS V8.1.2 - Copyright (C) 2014 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     !<<\r
  28     >>!   distribute a combined work that includes FreeRTOS without being   !<<\r
  29     >>!   obliged to provide the source code for proprietary components     !<<\r
  30     >>!   outside of the FreeRTOS 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 \r
  67 __asm vRegTest1Task( void )\r
  68 {\r
  69         PRESERVE8\r
  70         IMPORT ulRegTest1LoopCounter\r
  71 \r
  72         /* Fill the core registers with known values. */\r
  73         mov r0, #100\r
  74         mov r1, #101\r
  75         mov r2, #102\r
  76         mov r3, #103\r
  77         mov     r4, #104\r
  78         mov     r5, #105\r
  79         mov     r6, #106\r
  80         mov r7, #107\r
  81         mov     r8, #108\r
  82         mov     r9, #109\r
  83         mov     r10, #110\r
  84         mov     r11, #111\r
  85         mov r12, #112\r
  86 \r
  87         /* Fill the VFP registers with known values. */\r
  88         vmov d0, r0, r1\r
  89         vmov d1, r2, r3\r
  90         vmov d2, r4, r5\r
  91         vmov d3, r6, r7\r
  92         vmov d4, r8, r9\r
  93         vmov d5, r10, r11\r
  94         vmov d6, r0, r1\r
  95         vmov d7, r2, r3\r
  96         vmov d8, r4, r5\r
  97         vmov d9, r6, r7\r
  98         vmov d10, r8, r9\r
  99         vmov d11, r10, r11\r
 100         vmov d12, r0, r1\r
 101         vmov d13, r2, r3\r
 102         vmov d14, r4, r5\r
 103         vmov d15, r6, r7\r
 104 \r
 105 reg1_loop\r
 106         /* Check all the VFP registers still contain the values set above.\r
 107         First save registers that are clobbered by the test. */\r
 108         push { r0-r1 }\r
 109         \r
 110         vmov r0, r1, d0\r
 111         cmp r0, #100\r
 112         bne reg1_error_loopf\r
 113         cmp r1, #101\r
 114         bne reg1_error_loopf\r
 115         vmov r0, r1, d1\r
 116         cmp r0, #102\r
 117         bne reg1_error_loopf\r
 118         cmp r1, #103\r
 119         bne reg1_error_loopf\r
 120         vmov r0, r1, d2\r
 121         cmp r0, #104\r
 122         bne reg1_error_loopf\r
 123         cmp r1, #105\r
 124         bne reg1_error_loopf\r
 125         vmov r0, r1, d3\r
 126         cmp r0, #106\r
 127         bne reg1_error_loopf\r
 128         cmp r1, #107\r
 129         bne reg1_error_loopf\r
 130         vmov r0, r1, d4\r
 131         cmp r0, #108\r
 132         bne reg1_error_loopf\r
 133         cmp r1, #109\r
 134         bne reg1_error_loopf\r
 135         vmov r0, r1, d5\r
 136         cmp r0, #110\r
 137         bne reg1_error_loopf\r
 138         cmp r1, #111\r
 139         bne reg1_error_loopf\r
 140         vmov r0, r1, d6\r
 141         cmp r0, #100\r
 142         bne reg1_error_loopf\r
 143         cmp r1, #101\r
 144         bne reg1_error_loopf\r
 145         vmov r0, r1, d7\r
 146         cmp r0, #102\r
 147         bne reg1_error_loopf\r
 148         cmp r1, #103\r
 149         bne reg1_error_loopf\r
 150         vmov r0, r1, d8\r
 151         cmp r0, #104\r
 152         bne reg1_error_loopf\r
 153         cmp r1, #105\r
 154         bne reg1_error_loopf\r
 155         vmov r0, r1, d9\r
 156         cmp r0, #106\r
 157         bne reg1_error_loopf\r
 158         cmp r1, #107\r
 159         bne reg1_error_loopf\r
 160         vmov r0, r1, d10\r
 161         cmp r0, #108\r
 162         bne reg1_error_loopf\r
 163         cmp r1, #109\r
 164         bne reg1_error_loopf\r
 165         vmov r0, r1, d11\r
 166         cmp r0, #110\r
 167         bne reg1_error_loopf\r
 168         cmp r1, #111\r
 169         bne reg1_error_loopf\r
 170         vmov r0, r1, d12\r
 171         cmp r0, #100\r
 172         bne reg1_error_loopf\r
 173         cmp r1, #101\r
 174         bne reg1_error_loopf\r
 175         vmov r0, r1, d13\r
 176         cmp r0, #102\r
 177         bne reg1_error_loopf\r
 178         cmp r1, #103\r
 179         bne reg1_error_loopf\r
 180         vmov r0, r1, d14\r
 181         cmp r0, #104\r
 182         bne reg1_error_loopf\r
 183         cmp r1, #105\r
 184         bne reg1_error_loopf\r
 185         vmov r0, r1, d15\r
 186         cmp r0, #106\r
 187         bne reg1_error_loopf\r
 188         cmp r1, #107\r
 189         bne reg1_error_loopf\r
 190         \r
 191         /* Restore the registers that were clobbered by the test. */\r
 192         pop {r0-r1}\r
 193         \r
 194         /* VFP register test passed.  Jump to the core register test. */\r
 195         b reg1_loopf_pass\r
 196 \r
 197 reg1_error_loopf\r
 198         /* If this line is hit then a VFP register value was found to be\r
 199         incorrect. */\r
 200         b reg1_error_loopf\r
 201 \r
 202 reg1_loopf_pass\r
 203 \r
 204         cmp     r0, #100\r
 205         bne     reg1_error_loop\r
 206         cmp     r1, #101\r
 207         bne     reg1_error_loop\r
 208         cmp     r2, #102\r
 209         bne     reg1_error_loop\r
 210         cmp r3, #103\r
 211         bne     reg1_error_loop\r
 212         cmp     r4, #104\r
 213         bne     reg1_error_loop\r
 214         cmp     r5, #105\r
 215         bne     reg1_error_loop\r
 216         cmp     r6, #106\r
 217         bne     reg1_error_loop\r
 218         cmp     r7, #107\r
 219         bne     reg1_error_loop\r
 220         cmp     r8, #108\r
 221         bne     reg1_error_loop\r
 222         cmp     r9, #109\r
 223         bne     reg1_error_loop\r
 224         cmp     r10, #110\r
 225         bne     reg1_error_loop\r
 226         cmp     r11, #111\r
 227         bne     reg1_error_loop\r
 228         cmp     r12, #112\r
 229         bne     reg1_error_loop\r
 230         \r
 231         /* Everything passed, increment the loop counter. */\r
 232         push { r0-r1 }\r
 233         ldr     r0, =ulRegTest1LoopCounter\r
 234         ldr r1, [r0]\r
 235         adds r1, r1, #1\r
 236         str r1, [r0]\r
 237         pop { r0-r1 }\r
 238         \r
 239         /* Start again. */\r
 240         b reg1_loop\r
 241 \r
 242 reg1_error_loop\r
 243         /* If this line is hit then there was an error in a core register value.\r
 244         The loop ensures the loop counter stops incrementing. */\r
 245         b reg1_error_loop\r
 246         nop\r
 247 }\r
 248 /*-----------------------------------------------------------*/\r
 249 \r
 250 __asm vRegTest2Task( void )\r
 251 {\r
 252         PRESERVE8\r
 253         IMPORT ulRegTest2LoopCounter\r
 254 \r
 255         /* Set all the core registers to known values. */\r
 256         mov r0, #-1\r
 257         mov r1, #1\r
 258         mov r2, #2\r
 259         mov r3, #3\r
 260         mov     r4, #4\r
 261         mov     r5, #5\r
 262         mov     r6, #6\r
 263         mov r7, #7\r
 264         mov     r8, #8\r
 265         mov     r9, #9\r
 266         mov     r10, #10\r
 267         mov     r11, #11\r
 268         mov r12, #12\r
 269 \r
 270         /* Set all the VFP to known values. */\r
 271         vmov d0, r0, r1\r
 272         vmov d1, r2, r3\r
 273         vmov d2, r4, r5\r
 274         vmov d3, r6, r7\r
 275         vmov d4, r8, r9\r
 276         vmov d5, r10, r11\r
 277         vmov d6, r0, r1\r
 278         vmov d7, r2, r3\r
 279         vmov d8, r4, r5\r
 280         vmov d9, r6, r7\r
 281         vmov d10, r8, r9\r
 282         vmov d11, r10, r11\r
 283         vmov d12, r0, r1\r
 284         vmov d13, r2, r3\r
 285         vmov d14, r4, r5\r
 286         vmov d15, r6, r7\r
 287 \r
 288 reg2_loop\r
 289         \r
 290         /* Check all the VFP registers still contain the values set above.\r
 291         First save registers that are clobbered by the test. */\r
 292         push { r0-r1 }\r
 293         \r
 294         vmov r0, r1, d0\r
 295         cmp r0, #-1\r
 296         bne reg2_error_loopf\r
 297         cmp r1, #1\r
 298         bne reg2_error_loopf\r
 299         vmov r0, r1, d1\r
 300         cmp r0, #2\r
 301         bne reg2_error_loopf\r
 302         cmp r1, #3\r
 303         bne reg2_error_loopf\r
 304         vmov r0, r1, d2\r
 305         cmp r0, #4\r
 306         bne reg2_error_loopf\r
 307         cmp r1, #5\r
 308         bne reg2_error_loopf\r
 309         vmov r0, r1, d3\r
 310         cmp r0, #6\r
 311         bne reg2_error_loopf\r
 312         cmp r1, #7\r
 313         bne reg2_error_loopf\r
 314         vmov r0, r1, d4\r
 315         cmp r0, #8\r
 316         bne reg2_error_loopf\r
 317         cmp r1, #9\r
 318         bne reg2_error_loopf\r
 319         vmov r0, r1, d5\r
 320         cmp r0, #10\r
 321         bne reg2_error_loopf\r
 322         cmp r1, #11\r
 323         bne reg2_error_loopf\r
 324         vmov r0, r1, d6\r
 325         cmp r0, #-1\r
 326         bne reg2_error_loopf\r
 327         cmp r1, #1\r
 328         bne reg2_error_loopf\r
 329         vmov r0, r1, d7\r
 330         cmp r0, #2\r
 331         bne reg2_error_loopf\r
 332         cmp r1, #3\r
 333         bne reg2_error_loopf\r
 334         vmov r0, r1, d8\r
 335         cmp r0, #4\r
 336         bne reg2_error_loopf\r
 337         cmp r1, #5\r
 338         bne reg2_error_loopf\r
 339         vmov r0, r1, d9\r
 340         cmp r0, #6\r
 341         bne reg2_error_loopf\r
 342         cmp r1, #7\r
 343         bne reg2_error_loopf\r
 344         vmov r0, r1, d10\r
 345         cmp r0, #8\r
 346         bne reg2_error_loopf\r
 347         cmp r1, #9\r
 348         bne reg2_error_loopf\r
 349         vmov r0, r1, d11\r
 350         cmp r0, #10\r
 351         bne reg2_error_loopf\r
 352         cmp r1, #11\r
 353         bne reg2_error_loopf\r
 354         vmov r0, r1, d12\r
 355         cmp r0, #-1\r
 356         bne reg2_error_loopf\r
 357         cmp r1, #1\r
 358         bne reg2_error_loopf\r
 359         vmov r0, r1, d13\r
 360         cmp r0, #2\r
 361         bne reg2_error_loopf\r
 362         cmp r1, #3\r
 363         bne reg2_error_loopf\r
 364         vmov r0, r1, d14\r
 365         cmp r0, #4\r
 366         bne reg2_error_loopf\r
 367         cmp r1, #5\r
 368         bne reg2_error_loopf\r
 369         vmov r0, r1, d15\r
 370         cmp r0, #6\r
 371         bne reg2_error_loopf\r
 372         cmp r1, #7\r
 373         bne reg2_error_loopf\r
 374         \r
 375         /* Restore the registers that were clobbered by the test. */\r
 376         pop {r0-r1}\r
 377         \r
 378         /* VFP register test passed.  Jump to the core register test. */\r
 379         b reg2_loopf_pass\r
 380 \r
 381 reg2_error_loopf\r
 382         /* If this line is hit then a VFP register value was found to be\r
 383         incorrect. */\r
 384         b reg2_error_loopf\r
 385 \r
 386 reg2_loopf_pass\r
 387 \r
 388         cmp     r0, #-1\r
 389         bne     reg2_error_loop\r
 390         cmp     r1, #1\r
 391         bne     reg2_error_loop\r
 392         cmp     r2, #2\r
 393         bne     reg2_error_loop\r
 394         cmp r3, #3\r
 395         bne     reg2_error_loop\r
 396         cmp     r4, #4\r
 397         bne     reg2_error_loop\r
 398         cmp     r5, #5\r
 399         bne     reg2_error_loop\r
 400         cmp     r6, #6\r
 401         bne     reg2_error_loop\r
 402         cmp     r7, #7\r
 403         bne     reg2_error_loop\r
 404         cmp     r8, #8\r
 405         bne     reg2_error_loop\r
 406         cmp     r9, #9\r
 407         bne     reg2_error_loop\r
 408         cmp     r10, #10\r
 409         bne     reg2_error_loop\r
 410         cmp     r11, #11\r
 411         bne     reg2_error_loop\r
 412         cmp     r12, #12\r
 413         bne     reg2_error_loop\r
 414         \r
 415         /* Increment the loop counter to indicate this test is still functioning\r
 416         correctly. */\r
 417         push { r0-r1 }\r
 418         ldr     r0, =ulRegTest2LoopCounter\r
 419         ldr r1, [r0]\r
 420         adds r1, r1, #1\r
 421         str r1, [r0]\r
 422         \r
 423         /* Yield to increase test coverage. */\r
 424         movs r0, #0x01\r
 425         ldr r1, =0xe000ed04 /*NVIC_INT_CTRL */\r
 426         lsl r0, r0, #28 /* Shift to PendSV bit */\r
 427         str r0, [r1]\r
 428         dsb\r
 429         \r
 430         pop { r0-r1 }\r
 431         \r
 432         /* Start again. */\r
 433         b reg2_loop\r
 434 \r
 435 reg2_error_loop\r
 436         /* If this line is hit then there was an error in a core register value.\r
 437         This loop ensures the loop counter variable stops incrementing. */\r
 438         b reg2_error_loop\r
 439 }\r
 440 /*-----------------------------------------------------------*/\r
 441 \r
 442 __asm vRegTestClearFlopRegistersToParameterValue( unsigned long ulValue )\r
 443 {\r
 444         PRESERVE8\r
 445 \r
 446         /* Clobber the auto saved registers. */\r
 447         vmov d0, r0, r0\r
 448         vmov d1, r0, r0\r
 449         vmov d2, r0, r0\r
 450         vmov d3, r0, r0\r
 451         vmov d4, r0, r0\r
 452         vmov d5, r0, r0\r
 453         vmov d6, r0, r0\r
 454         vmov d7, r0, r0\r
 455         bx lr\r
 456 }\r
 457 /*-----------------------------------------------------------*/\r
 458 \r
 459 __asm ulRegTestCheckFlopRegistersContainParameterValue( unsigned long ulValue )\r
 460 {\r
 461         PRESERVE8\r
 462 \r
 463         vmov r1, s0\r
 464         cmp r0, r1\r
 465         bne return_error\r
 466         vmov r1, s1\r
 467         cmp r0, r1\r
 468         bne return_error\r
 469         vmov r1, s2\r
 470         cmp r0, r1\r
 471         bne return_error\r
 472         vmov r1, s3\r
 473         cmp r0, r1\r
 474         bne return_error\r
 475         vmov r1, s4\r
 476         cmp r0, r1\r
 477         bne return_error\r
 478         vmov r1, s5\r
 479         cmp r0, r1\r
 480         bne return_error\r
 481         vmov r1, s6\r
 482         cmp r0, r1\r
 483         bne return_error\r
 484         vmov r1, s7\r
 485         cmp r0, r1\r
 486         bne return_error\r
 487         vmov r1, s8\r
 488         cmp r0, r1\r
 489         bne return_error\r
 490         vmov r1, s9\r
 491         cmp r0, r1\r
 492         bne return_error\r
 493         vmov r1, s10\r
 494         cmp r0, r1\r
 495         bne return_error\r
 496         vmov r1, s11\r
 497         cmp r0, r1\r
 498         bne return_error\r
 499         vmov r1, s12\r
 500         cmp r0, r1\r
 501         bne return_error\r
 502         vmov r1, s13\r
 503         cmp r0, r1\r
 504         bne return_error\r
 505         vmov r1, s14\r
 506         cmp r0, r1\r
 507         bne return_error\r
 508         vmov r1, s15\r
 509         cmp r0, r1\r
 510         bne return_error\r
 511         \r
 512 return_pass\r
 513         mov r0, #1\r
 514         bx lr\r
 515 \r
 516 return_error\r
 517         mov r0, #0\r
 518         bx lr\r
 519 }\r
 520 \r
 521         \r