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

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