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

   1 /*\r
   2     FreeRTOS V8.0.0:rc1 - 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 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 \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         pop { r0-r1 }\r
 423         \r
 424         /* Start again. */\r
 425         b reg2_loop\r
 426 \r
 427 reg2_error_loop\r
 428         /* If this line is hit then there was an error in a core register value.\r
 429         This loop ensures the loop counter variable stops incrementing. */\r
 430         b reg2_error_loop\r
 431         nop\r
 432 }\r
 433 /*-----------------------------------------------------------*/\r
 434 \r
 435 __asm vRegTestClearFlopRegistersToParameterValue( unsigned long ulValue )\r
 436 {\r
 437         PRESERVE8\r
 438 \r
 439         /* Clobber the auto saved registers. */\r
 440         vmov d0, r0, r0\r
 441         vmov d1, r0, r0\r
 442         vmov d2, r0, r0\r
 443         vmov d3, r0, r0\r
 444         vmov d4, r0, r0\r
 445         vmov d5, r0, r0\r
 446         vmov d6, r0, r0\r
 447         vmov d7, r0, r0\r
 448         bx lr\r
 449 }\r
 450 /*-----------------------------------------------------------*/\r
 451 \r
 452 __asm ulRegTestCheckFlopRegistersContainParameterValue( unsigned long ulValue )\r
 453 {\r
 454         PRESERVE8\r
 455 \r
 456         vmov r1, s0\r
 457         cmp r0, r1\r
 458         bne return_error\r
 459         vmov r1, s1\r
 460         cmp r0, r1\r
 461         bne return_error\r
 462         vmov r1, s2\r
 463         cmp r0, r1\r
 464         bne return_error\r
 465         vmov r1, s3\r
 466         cmp r0, r1\r
 467         bne return_error\r
 468         vmov r1, s4\r
 469         cmp r0, r1\r
 470         bne return_error\r
 471         vmov r1, s5\r
 472         cmp r0, r1\r
 473         bne return_error\r
 474         vmov r1, s6\r
 475         cmp r0, r1\r
 476         bne return_error\r
 477         vmov r1, s7\r
 478         cmp r0, r1\r
 479         bne return_error\r
 480         vmov r1, s8\r
 481         cmp r0, r1\r
 482         bne return_error\r
 483         vmov r1, s9\r
 484         cmp r0, r1\r
 485         bne return_error\r
 486         vmov r1, s10\r
 487         cmp r0, r1\r
 488         bne return_error\r
 489         vmov r1, s11\r
 490         cmp r0, r1\r
 491         bne return_error\r
 492         vmov r1, s12\r
 493         cmp r0, r1\r
 494         bne return_error\r
 495         vmov r1, s13\r
 496         cmp r0, r1\r
 497         bne return_error\r
 498         vmov r1, s14\r
 499         cmp r0, r1\r
 500         bne return_error\r
 501         vmov r1, s15\r
 502         cmp r0, r1\r
 503         bne return_error\r
 504         \r
 505 return_pass\r
 506         mov r0, #1\r
 507         bx lr\r
 508 \r
 509 return_error\r
 510         mov r0, #0\r
 511         bx lr\r
 512 }\r
 513 \r
 514         \r