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

   1 /*\r
   2     FreeRTOS V8.2.0rc1 - 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     This file is part of the FreeRTOS distribution.\r
   8 \r
   9     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  10     the terms of the GNU General Public License (version 2) as published by the\r
  11     Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
  12 \r
  13     >>!   NOTE: The modification to the GPL is included to allow you to     !<<\r
  14     >>!   distribute a combined work that includes FreeRTOS without being   !<<\r
  15     >>!   obliged to provide the source code for proprietary components     !<<\r
  16     >>!   outside of the FreeRTOS kernel.                                   !<<\r
  17 \r
  18     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
  19     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
  20     FOR A PARTICULAR PURPOSE.  Full license text is available on the following\r
  21     link: http://www.freertos.org/a00114.html\r
  22 \r
  23     1 tab == 4 spaces!\r
  24 \r
  25     ***************************************************************************\r
  26      *                                                                       *\r
  27      *    Having a problem?  Start by reading the FAQ "My application does   *\r
  28      *    not run, what could be wrong?".  Have you defined configASSERT()?  *\r
  29      *                                                                       *\r
  30      *    http://www.FreeRTOS.org/FAQHelp.html                               *\r
  31      *                                                                       *\r
  32     ***************************************************************************\r
  33 \r
  34     ***************************************************************************\r
  35      *                                                                       *\r
  36      *    FreeRTOS provides completely free yet professionally developed,    *\r
  37      *    robust, strictly quality controlled, supported, and cross          *\r
  38      *    platform software that is more than just the market leader, it     *\r
  39      *    is the industry's de facto standard.                               *\r
  40      *                                                                       *\r
  41      *    Help yourself get started quickly while simultaneously helping     *\r
  42      *    to support the FreeRTOS project by purchasing a FreeRTOS           *\r
  43      *    tutorial book, reference manual, or both:                          *\r
  44      *    http://www.FreeRTOS.org/Documentation                              *\r
  45      *                                                                       *\r
  46     ***************************************************************************\r
  47 \r
  48     ***************************************************************************\r
  49      *                                                                       *\r
  50      *   Investing in training allows your team to be as productive as       *\r
  51      *   possible as early as possible, lowering your overall development    *\r
  52      *   cost, and enabling you to bring a more robust product to market     *\r
  53      *   earlier than would otherwise be possible.  Richard Barry is both    *\r
  54      *   the architect and key author of FreeRTOS, and so also the world's   *\r
  55      *   leading authority on what is the world's most popular real time     *\r
  56      *   kernel for deeply embedded MCU designs.  Obtaining your training    *\r
  57      *   from Richard ensures your team will gain directly from his in-depth *\r
  58      *   product knowledge and years of usage experience.  Contact Real Time *\r
  59      *   Engineers Ltd to enquire about the FreeRTOS Masterclass, presented  *\r
  60      *   by Richard Barry:  http://www.FreeRTOS.org/contact\r
  61      *                                                                       *\r
  62     ***************************************************************************\r
  63 \r
  64     ***************************************************************************\r
  65      *                                                                       *\r
  66      *    You are receiving this top quality software for free.  Please play *\r
  67      *    fair and reciprocate by reporting any suspected issues and         *\r
  68      *    participating in the community forum:                              *\r
  69      *    http://www.FreeRTOS.org/support                                    *\r
  70      *                                                                       *\r
  71      *    Thank you!                                                         *\r
  72      *                                                                       *\r
  73     ***************************************************************************\r
  74 \r
  75     http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
  76     license and Real Time Engineers Ltd. contact details.\r
  77 \r
  78     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
  79     including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
  80     compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
  81 \r
  82     http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
  83     Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
  84 \r
  85     http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
  86     Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS\r
  87     licenses offer ticketed support, indemnification and commercial middleware.\r
  88 \r
  89     http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
  90     engineered and independently SIL3 certified version for use in safety and\r
  91     mission critical applications that require provable dependability.\r
  92 \r
  93     1 tab == 4 spaces!\r
  94 */\r
  95 \r
  96 \r
  97 __asm vRegTest1Task( void )\r
  98 {\r
  99         PRESERVE8\r
 100         IMPORT ulRegTest1LoopCounter\r
 101 \r
 102         /* Fill the core registers with known values. */\r
 103         mov r0, #100\r
 104         mov r1, #101\r
 105         mov r2, #102\r
 106         mov r3, #103\r
 107         mov     r4, #104\r
 108         mov     r5, #105\r
 109         mov     r6, #106\r
 110         mov r7, #107\r
 111         mov     r8, #108\r
 112         mov     r9, #109\r
 113         mov     r10, #110\r
 114         mov     r11, #111\r
 115         mov r12, #112\r
 116 \r
 117         /* Fill the VFP registers with known values. */\r
 118         vmov d0, r0, r1\r
 119         vmov d1, r2, r3\r
 120         vmov d2, r4, r5\r
 121         vmov d3, r6, r7\r
 122         vmov d4, r8, r9\r
 123         vmov d5, r10, r11\r
 124         vmov d6, r0, r1\r
 125         vmov d7, r2, r3\r
 126         vmov d8, r4, r5\r
 127         vmov d9, r6, r7\r
 128         vmov d10, r8, r9\r
 129         vmov d11, r10, r11\r
 130         vmov d12, r0, r1\r
 131         vmov d13, r2, r3\r
 132         vmov d14, r4, r5\r
 133         vmov d15, r6, r7\r
 134 \r
 135 reg1_loop\r
 136         /* Check all the VFP registers still contain the values set above.\r
 137         First save registers that are clobbered by the test. */\r
 138         push { r0-r1 }\r
 139         \r
 140         vmov r0, r1, d0\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, d1\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, d2\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, d3\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, d4\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, d5\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, d6\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, d7\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, d8\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, d9\r
 186         cmp r0, #106\r
 187         bne reg1_error_loopf\r
 188         cmp r1, #107\r
 189         bne reg1_error_loopf\r
 190         vmov r0, r1, d10\r
 191         cmp r0, #108\r
 192         bne reg1_error_loopf\r
 193         cmp r1, #109\r
 194         bne reg1_error_loopf\r
 195         vmov r0, r1, d11\r
 196         cmp r0, #110\r
 197         bne reg1_error_loopf\r
 198         cmp r1, #111\r
 199         bne reg1_error_loopf\r
 200         vmov r0, r1, d12\r
 201         cmp r0, #100\r
 202         bne reg1_error_loopf\r
 203         cmp r1, #101\r
 204         bne reg1_error_loopf\r
 205         vmov r0, r1, d13\r
 206         cmp r0, #102\r
 207         bne reg1_error_loopf\r
 208         cmp r1, #103\r
 209         bne reg1_error_loopf\r
 210         vmov r0, r1, d14\r
 211         cmp r0, #104\r
 212         bne reg1_error_loopf\r
 213         cmp r1, #105\r
 214         bne reg1_error_loopf\r
 215         vmov r0, r1, d15\r
 216         cmp r0, #106\r
 217         bne reg1_error_loopf\r
 218         cmp r1, #107\r
 219         bne reg1_error_loopf\r
 220         \r
 221         /* Restore the registers that were clobbered by the test. */\r
 222         pop {r0-r1}\r
 223         \r
 224         /* VFP register test passed.  Jump to the core register test. */\r
 225         b reg1_loopf_pass\r
 226 \r
 227 reg1_error_loopf\r
 228         /* If this line is hit then a VFP register value was found to be\r
 229         incorrect. */\r
 230         b reg1_error_loopf\r
 231 \r
 232 reg1_loopf_pass\r
 233 \r
 234         cmp     r0, #100\r
 235         bne     reg1_error_loop\r
 236         cmp     r1, #101\r
 237         bne     reg1_error_loop\r
 238         cmp     r2, #102\r
 239         bne     reg1_error_loop\r
 240         cmp r3, #103\r
 241         bne     reg1_error_loop\r
 242         cmp     r4, #104\r
 243         bne     reg1_error_loop\r
 244         cmp     r5, #105\r
 245         bne     reg1_error_loop\r
 246         cmp     r6, #106\r
 247         bne     reg1_error_loop\r
 248         cmp     r7, #107\r
 249         bne     reg1_error_loop\r
 250         cmp     r8, #108\r
 251         bne     reg1_error_loop\r
 252         cmp     r9, #109\r
 253         bne     reg1_error_loop\r
 254         cmp     r10, #110\r
 255         bne     reg1_error_loop\r
 256         cmp     r11, #111\r
 257         bne     reg1_error_loop\r
 258         cmp     r12, #112\r
 259         bne     reg1_error_loop\r
 260         \r
 261         /* Everything passed, increment the loop counter. */\r
 262         push { r0-r1 }\r
 263         ldr     r0, =ulRegTest1LoopCounter\r
 264         ldr r1, [r0]\r
 265         adds r1, r1, #1\r
 266         str r1, [r0]\r
 267         pop { r0-r1 }\r
 268         \r
 269         /* Start again. */\r
 270         b reg1_loop\r
 271 \r
 272 reg1_error_loop\r
 273         /* If this line is hit then there was an error in a core register value.\r
 274         The loop ensures the loop counter stops incrementing. */\r
 275         b reg1_error_loop\r
 276         nop\r
 277 }\r
 278 /*-----------------------------------------------------------*/\r
 279 \r
 280 __asm vRegTest2Task( void )\r
 281 {\r
 282         PRESERVE8\r
 283         IMPORT ulRegTest2LoopCounter\r
 284 \r
 285         /* Set all the core registers to known values. */\r
 286         mov r0, #-1\r
 287         mov r1, #1\r
 288         mov r2, #2\r
 289         mov r3, #3\r
 290         mov     r4, #4\r
 291         mov     r5, #5\r
 292         mov     r6, #6\r
 293         mov r7, #7\r
 294         mov     r8, #8\r
 295         mov     r9, #9\r
 296         mov     r10, #10\r
 297         mov     r11, #11\r
 298         mov r12, #12\r
 299 \r
 300         /* Set all the VFP to known values. */\r
 301         vmov d0, r0, r1\r
 302         vmov d1, r2, r3\r
 303         vmov d2, r4, r5\r
 304         vmov d3, r6, r7\r
 305         vmov d4, r8, r9\r
 306         vmov d5, r10, r11\r
 307         vmov d6, r0, r1\r
 308         vmov d7, r2, r3\r
 309         vmov d8, r4, r5\r
 310         vmov d9, r6, r7\r
 311         vmov d10, r8, r9\r
 312         vmov d11, r10, r11\r
 313         vmov d12, r0, r1\r
 314         vmov d13, r2, r3\r
 315         vmov d14, r4, r5\r
 316         vmov d15, r6, r7\r
 317 \r
 318 reg2_loop\r
 319         \r
 320         /* Check all the VFP registers still contain the values set above.\r
 321         First save registers that are clobbered by the test. */\r
 322         push { r0-r1 }\r
 323         \r
 324         vmov r0, r1, d0\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, d1\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, d2\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, d3\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, d4\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, d5\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, d6\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, d7\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, d8\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, d9\r
 370         cmp r0, #6\r
 371         bne reg2_error_loopf\r
 372         cmp r1, #7\r
 373         bne reg2_error_loopf\r
 374         vmov r0, r1, d10\r
 375         cmp r0, #8\r
 376         bne reg2_error_loopf\r
 377         cmp r1, #9\r
 378         bne reg2_error_loopf\r
 379         vmov r0, r1, d11\r
 380         cmp r0, #10\r
 381         bne reg2_error_loopf\r
 382         cmp r1, #11\r
 383         bne reg2_error_loopf\r
 384         vmov r0, r1, d12\r
 385         cmp r0, #-1\r
 386         bne reg2_error_loopf\r
 387         cmp r1, #1\r
 388         bne reg2_error_loopf\r
 389         vmov r0, r1, d13\r
 390         cmp r0, #2\r
 391         bne reg2_error_loopf\r
 392         cmp r1, #3\r
 393         bne reg2_error_loopf\r
 394         vmov r0, r1, d14\r
 395         cmp r0, #4\r
 396         bne reg2_error_loopf\r
 397         cmp r1, #5\r
 398         bne reg2_error_loopf\r
 399         vmov r0, r1, d15\r
 400         cmp r0, #6\r
 401         bne reg2_error_loopf\r
 402         cmp r1, #7\r
 403         bne reg2_error_loopf\r
 404         \r
 405         /* Restore the registers that were clobbered by the test. */\r
 406         pop {r0-r1}\r
 407         \r
 408         /* VFP register test passed.  Jump to the core register test. */\r
 409         b reg2_loopf_pass\r
 410 \r
 411 reg2_error_loopf\r
 412         /* If this line is hit then a VFP register value was found to be\r
 413         incorrect. */\r
 414         b reg2_error_loopf\r
 415 \r
 416 reg2_loopf_pass\r
 417 \r
 418         cmp     r0, #-1\r
 419         bne     reg2_error_loop\r
 420         cmp     r1, #1\r
 421         bne     reg2_error_loop\r
 422         cmp     r2, #2\r
 423         bne     reg2_error_loop\r
 424         cmp r3, #3\r
 425         bne     reg2_error_loop\r
 426         cmp     r4, #4\r
 427         bne     reg2_error_loop\r
 428         cmp     r5, #5\r
 429         bne     reg2_error_loop\r
 430         cmp     r6, #6\r
 431         bne     reg2_error_loop\r
 432         cmp     r7, #7\r
 433         bne     reg2_error_loop\r
 434         cmp     r8, #8\r
 435         bne     reg2_error_loop\r
 436         cmp     r9, #9\r
 437         bne     reg2_error_loop\r
 438         cmp     r10, #10\r
 439         bne     reg2_error_loop\r
 440         cmp     r11, #11\r
 441         bne     reg2_error_loop\r
 442         cmp     r12, #12\r
 443         bne     reg2_error_loop\r
 444         \r
 445         /* Increment the loop counter to indicate this test is still functioning\r
 446         correctly. */\r
 447         push { r0-r1 }\r
 448         ldr     r0, =ulRegTest2LoopCounter\r
 449         ldr r1, [r0]\r
 450         adds r1, r1, #1\r
 451         str r1, [r0]\r
 452         pop { r0-r1 }\r
 453         \r
 454         /* Start again. */\r
 455         b reg2_loop\r
 456 \r
 457 reg2_error_loop\r
 458         /* If this line is hit then there was an error in a core register value.\r
 459         This loop ensures the loop counter variable stops incrementing. */\r
 460         b reg2_error_loop\r
 461         nop\r
 462 }\r
 463 /*-----------------------------------------------------------*/\r
 464 \r
 465 __asm vRegTestClearFlopRegistersToParameterValue( unsigned long ulValue )\r
 466 {\r
 467         PRESERVE8\r
 468 \r
 469         /* Clobber the auto saved registers. */\r
 470         vmov d0, r0, r0\r
 471         vmov d1, r0, r0\r
 472         vmov d2, r0, r0\r
 473         vmov d3, r0, r0\r
 474         vmov d4, r0, r0\r
 475         vmov d5, r0, r0\r
 476         vmov d6, r0, r0\r
 477         vmov d7, r0, r0\r
 478         bx lr\r
 479 }\r
 480 /*-----------------------------------------------------------*/\r
 481 \r
 482 __asm ulRegTestCheckFlopRegistersContainParameterValue( unsigned long ulValue )\r
 483 {\r
 484         PRESERVE8\r
 485 \r
 486         vmov r1, s0\r
 487         cmp r0, r1\r
 488         bne return_error\r
 489         vmov r1, s1\r
 490         cmp r0, r1\r
 491         bne return_error\r
 492         vmov r1, s2\r
 493         cmp r0, r1\r
 494         bne return_error\r
 495         vmov r1, s3\r
 496         cmp r0, r1\r
 497         bne return_error\r
 498         vmov r1, s4\r
 499         cmp r0, r1\r
 500         bne return_error\r
 501         vmov r1, s5\r
 502         cmp r0, r1\r
 503         bne return_error\r
 504         vmov r1, s6\r
 505         cmp r0, r1\r
 506         bne return_error\r
 507         vmov r1, s7\r
 508         cmp r0, r1\r
 509         bne return_error\r
 510         vmov r1, s8\r
 511         cmp r0, r1\r
 512         bne return_error\r
 513         vmov r1, s9\r
 514         cmp r0, r1\r
 515         bne return_error\r
 516         vmov r1, s10\r
 517         cmp r0, r1\r
 518         bne return_error\r
 519         vmov r1, s11\r
 520         cmp r0, r1\r
 521         bne return_error\r
 522         vmov r1, s12\r
 523         cmp r0, r1\r
 524         bne return_error\r
 525         vmov r1, s13\r
 526         cmp r0, r1\r
 527         bne return_error\r
 528         vmov r1, s14\r
 529         cmp r0, r1\r
 530         bne return_error\r
 531         vmov r1, s15\r
 532         cmp r0, r1\r
 533         bne return_error\r
 534         \r
 535 return_pass\r
 536         mov r0, #1\r
 537         bx lr\r
 538 \r
 539 return_error\r
 540         mov r0, #0\r
 541         bx lr\r
 542 }\r
 543 \r
 544         \r