1 /****************************************************************************** 2 * Filename: hw_smph_h 3 * Revised: 2018-05-14 12:24:52 +0200 (Mon, 14 May 2018) 4 * Revision: 51990 5 * 6 * Copyright (c) 2015 - 2017, Texas Instruments Incorporated 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions are met: 11 * 12 * 1) Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * 2) Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * 3) Neither the name of the ORGANIZATION nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 24 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 * 35 ******************************************************************************/ 36 37 #ifndef __HW_SMPH_H__ 38 #define __HW_SMPH_H__ 39 40 //***************************************************************************** 41 // 42 // This section defines the register offsets of 43 // SMPH component 44 // 45 //***************************************************************************** 46 // MCU SEMAPHORE 0 47 #define SMPH_O_SMPH0 0x00000000 48 49 // MCU SEMAPHORE 1 50 #define SMPH_O_SMPH1 0x00000004 51 52 // MCU SEMAPHORE 2 53 #define SMPH_O_SMPH2 0x00000008 54 55 // MCU SEMAPHORE 3 56 #define SMPH_O_SMPH3 0x0000000C 57 58 // MCU SEMAPHORE 4 59 #define SMPH_O_SMPH4 0x00000010 60 61 // MCU SEMAPHORE 5 62 #define SMPH_O_SMPH5 0x00000014 63 64 // MCU SEMAPHORE 6 65 #define SMPH_O_SMPH6 0x00000018 66 67 // MCU SEMAPHORE 7 68 #define SMPH_O_SMPH7 0x0000001C 69 70 // MCU SEMAPHORE 8 71 #define SMPH_O_SMPH8 0x00000020 72 73 // MCU SEMAPHORE 9 74 #define SMPH_O_SMPH9 0x00000024 75 76 // MCU SEMAPHORE 10 77 #define SMPH_O_SMPH10 0x00000028 78 79 // MCU SEMAPHORE 11 80 #define SMPH_O_SMPH11 0x0000002C 81 82 // MCU SEMAPHORE 12 83 #define SMPH_O_SMPH12 0x00000030 84 85 // MCU SEMAPHORE 13 86 #define SMPH_O_SMPH13 0x00000034 87 88 // MCU SEMAPHORE 14 89 #define SMPH_O_SMPH14 0x00000038 90 91 // MCU SEMAPHORE 15 92 #define SMPH_O_SMPH15 0x0000003C 93 94 // MCU SEMAPHORE 16 95 #define SMPH_O_SMPH16 0x00000040 96 97 // MCU SEMAPHORE 17 98 #define SMPH_O_SMPH17 0x00000044 99 100 // MCU SEMAPHORE 18 101 #define SMPH_O_SMPH18 0x00000048 102 103 // MCU SEMAPHORE 19 104 #define SMPH_O_SMPH19 0x0000004C 105 106 // MCU SEMAPHORE 20 107 #define SMPH_O_SMPH20 0x00000050 108 109 // MCU SEMAPHORE 21 110 #define SMPH_O_SMPH21 0x00000054 111 112 // MCU SEMAPHORE 22 113 #define SMPH_O_SMPH22 0x00000058 114 115 // MCU SEMAPHORE 23 116 #define SMPH_O_SMPH23 0x0000005C 117 118 // MCU SEMAPHORE 24 119 #define SMPH_O_SMPH24 0x00000060 120 121 // MCU SEMAPHORE 25 122 #define SMPH_O_SMPH25 0x00000064 123 124 // MCU SEMAPHORE 26 125 #define SMPH_O_SMPH26 0x00000068 126 127 // MCU SEMAPHORE 27 128 #define SMPH_O_SMPH27 0x0000006C 129 130 // MCU SEMAPHORE 28 131 #define SMPH_O_SMPH28 0x00000070 132 133 // MCU SEMAPHORE 29 134 #define SMPH_O_SMPH29 0x00000074 135 136 // MCU SEMAPHORE 30 137 #define SMPH_O_SMPH30 0x00000078 138 139 // MCU SEMAPHORE 31 140 #define SMPH_O_SMPH31 0x0000007C 141 142 // MCU SEMAPHORE 0 ALIAS 143 #define SMPH_O_PEEK0 0x00000800 144 145 // MCU SEMAPHORE 1 ALIAS 146 #define SMPH_O_PEEK1 0x00000804 147 148 // MCU SEMAPHORE 2 ALIAS 149 #define SMPH_O_PEEK2 0x00000808 150 151 // MCU SEMAPHORE 3 ALIAS 152 #define SMPH_O_PEEK3 0x0000080C 153 154 // MCU SEMAPHORE 4 ALIAS 155 #define SMPH_O_PEEK4 0x00000810 156 157 // MCU SEMAPHORE 5 ALIAS 158 #define SMPH_O_PEEK5 0x00000814 159 160 // MCU SEMAPHORE 6 ALIAS 161 #define SMPH_O_PEEK6 0x00000818 162 163 // MCU SEMAPHORE 7 ALIAS 164 #define SMPH_O_PEEK7 0x0000081C 165 166 // MCU SEMAPHORE 8 ALIAS 167 #define SMPH_O_PEEK8 0x00000820 168 169 // MCU SEMAPHORE 9 ALIAS 170 #define SMPH_O_PEEK9 0x00000824 171 172 // MCU SEMAPHORE 10 ALIAS 173 #define SMPH_O_PEEK10 0x00000828 174 175 // MCU SEMAPHORE 11 ALIAS 176 #define SMPH_O_PEEK11 0x0000082C 177 178 // MCU SEMAPHORE 12 ALIAS 179 #define SMPH_O_PEEK12 0x00000830 180 181 // MCU SEMAPHORE 13 ALIAS 182 #define SMPH_O_PEEK13 0x00000834 183 184 // MCU SEMAPHORE 14 ALIAS 185 #define SMPH_O_PEEK14 0x00000838 186 187 // MCU SEMAPHORE 15 ALIAS 188 #define SMPH_O_PEEK15 0x0000083C 189 190 // MCU SEMAPHORE 16 ALIAS 191 #define SMPH_O_PEEK16 0x00000840 192 193 // MCU SEMAPHORE 17 ALIAS 194 #define SMPH_O_PEEK17 0x00000844 195 196 // MCU SEMAPHORE 18 ALIAS 197 #define SMPH_O_PEEK18 0x00000848 198 199 // MCU SEMAPHORE 19 ALIAS 200 #define SMPH_O_PEEK19 0x0000084C 201 202 // MCU SEMAPHORE 20 ALIAS 203 #define SMPH_O_PEEK20 0x00000850 204 205 // MCU SEMAPHORE 21 ALIAS 206 #define SMPH_O_PEEK21 0x00000854 207 208 // MCU SEMAPHORE 22 ALIAS 209 #define SMPH_O_PEEK22 0x00000858 210 211 // MCU SEMAPHORE 23 ALIAS 212 #define SMPH_O_PEEK23 0x0000085C 213 214 // MCU SEMAPHORE 24 ALIAS 215 #define SMPH_O_PEEK24 0x00000860 216 217 // MCU SEMAPHORE 25 ALIAS 218 #define SMPH_O_PEEK25 0x00000864 219 220 // MCU SEMAPHORE 26 ALIAS 221 #define SMPH_O_PEEK26 0x00000868 222 223 // MCU SEMAPHORE 27 ALIAS 224 #define SMPH_O_PEEK27 0x0000086C 225 226 // MCU SEMAPHORE 28 ALIAS 227 #define SMPH_O_PEEK28 0x00000870 228 229 // MCU SEMAPHORE 29 ALIAS 230 #define SMPH_O_PEEK29 0x00000874 231 232 // MCU SEMAPHORE 30 ALIAS 233 #define SMPH_O_PEEK30 0x00000878 234 235 // MCU SEMAPHORE 31 ALIAS 236 #define SMPH_O_PEEK31 0x0000087C 237 238 //***************************************************************************** 239 // 240 // Register: SMPH_O_SMPH0 241 // 242 //***************************************************************************** 243 // Field: [0] STAT 244 // 245 // Status when reading: 246 // 247 // 0: Semaphore is taken 248 // 1: Semaphore is available 249 // 250 // Reading the register causes it to change value to 0. Releasing the semaphore 251 // is done by writing 1. 252 #define SMPH_SMPH0_STAT 0x00000001 253 #define SMPH_SMPH0_STAT_BITN 0 254 #define SMPH_SMPH0_STAT_M 0x00000001 255 #define SMPH_SMPH0_STAT_S 0 256 257 //***************************************************************************** 258 // 259 // Register: SMPH_O_SMPH1 260 // 261 //***************************************************************************** 262 // Field: [0] STAT 263 // 264 // Status when reading: 265 // 266 // 0: Semaphore is taken 267 // 1: Semaphore is available 268 // 269 // Reading the register causes it to change value to 0. Releasing the semaphore 270 // is done by writing 1. 271 #define SMPH_SMPH1_STAT 0x00000001 272 #define SMPH_SMPH1_STAT_BITN 0 273 #define SMPH_SMPH1_STAT_M 0x00000001 274 #define SMPH_SMPH1_STAT_S 0 275 276 //***************************************************************************** 277 // 278 // Register: SMPH_O_SMPH2 279 // 280 //***************************************************************************** 281 // Field: [0] STAT 282 // 283 // Status when reading: 284 // 285 // 0: Semaphore is taken 286 // 1: Semaphore is available 287 // 288 // Reading the register causes it to change value to 0. Releasing the semaphore 289 // is done by writing 1. 290 #define SMPH_SMPH2_STAT 0x00000001 291 #define SMPH_SMPH2_STAT_BITN 0 292 #define SMPH_SMPH2_STAT_M 0x00000001 293 #define SMPH_SMPH2_STAT_S 0 294 295 //***************************************************************************** 296 // 297 // Register: SMPH_O_SMPH3 298 // 299 //***************************************************************************** 300 // Field: [0] STAT 301 // 302 // Status when reading: 303 // 304 // 0: Semaphore is taken 305 // 1: Semaphore is available 306 // 307 // Reading the register causes it to change value to 0. Releasing the semaphore 308 // is done by writing 1. 309 #define SMPH_SMPH3_STAT 0x00000001 310 #define SMPH_SMPH3_STAT_BITN 0 311 #define SMPH_SMPH3_STAT_M 0x00000001 312 #define SMPH_SMPH3_STAT_S 0 313 314 //***************************************************************************** 315 // 316 // Register: SMPH_O_SMPH4 317 // 318 //***************************************************************************** 319 // Field: [0] STAT 320 // 321 // Status when reading: 322 // 323 // 0: Semaphore is taken 324 // 1: Semaphore is available 325 // 326 // Reading the register causes it to change value to 0. Releasing the semaphore 327 // is done by writing 1. 328 #define SMPH_SMPH4_STAT 0x00000001 329 #define SMPH_SMPH4_STAT_BITN 0 330 #define SMPH_SMPH4_STAT_M 0x00000001 331 #define SMPH_SMPH4_STAT_S 0 332 333 //***************************************************************************** 334 // 335 // Register: SMPH_O_SMPH5 336 // 337 //***************************************************************************** 338 // Field: [0] STAT 339 // 340 // Status when reading: 341 // 342 // 0: Semaphore is taken 343 // 1: Semaphore is available 344 // 345 // Reading the register causes it to change value to 0. Releasing the semaphore 346 // is done by writing 1. 347 #define SMPH_SMPH5_STAT 0x00000001 348 #define SMPH_SMPH5_STAT_BITN 0 349 #define SMPH_SMPH5_STAT_M 0x00000001 350 #define SMPH_SMPH5_STAT_S 0 351 352 //***************************************************************************** 353 // 354 // Register: SMPH_O_SMPH6 355 // 356 //***************************************************************************** 357 // Field: [0] STAT 358 // 359 // Status when reading: 360 // 361 // 0: Semaphore is taken 362 // 1: Semaphore is available 363 // 364 // Reading the register causes it to change value to 0. Releasing the semaphore 365 // is done by writing 1. 366 #define SMPH_SMPH6_STAT 0x00000001 367 #define SMPH_SMPH6_STAT_BITN 0 368 #define SMPH_SMPH6_STAT_M 0x00000001 369 #define SMPH_SMPH6_STAT_S 0 370 371 //***************************************************************************** 372 // 373 // Register: SMPH_O_SMPH7 374 // 375 //***************************************************************************** 376 // Field: [0] STAT 377 // 378 // Status when reading: 379 // 380 // 0: Semaphore is taken 381 // 1: Semaphore is available 382 // 383 // Reading the register causes it to change value to 0. Releasing the semaphore 384 // is done by writing 1. 385 #define SMPH_SMPH7_STAT 0x00000001 386 #define SMPH_SMPH7_STAT_BITN 0 387 #define SMPH_SMPH7_STAT_M 0x00000001 388 #define SMPH_SMPH7_STAT_S 0 389 390 //***************************************************************************** 391 // 392 // Register: SMPH_O_SMPH8 393 // 394 //***************************************************************************** 395 // Field: [0] STAT 396 // 397 // Status when reading: 398 // 399 // 0: Semaphore is taken 400 // 1: Semaphore is available 401 // 402 // Reading the register causes it to change value to 0. Releasing the semaphore 403 // is done by writing 1. 404 #define SMPH_SMPH8_STAT 0x00000001 405 #define SMPH_SMPH8_STAT_BITN 0 406 #define SMPH_SMPH8_STAT_M 0x00000001 407 #define SMPH_SMPH8_STAT_S 0 408 409 //***************************************************************************** 410 // 411 // Register: SMPH_O_SMPH9 412 // 413 //***************************************************************************** 414 // Field: [0] STAT 415 // 416 // Status when reading: 417 // 418 // 0: Semaphore is taken 419 // 1: Semaphore is available 420 // 421 // Reading the register causes it to change value to 0. Releasing the semaphore 422 // is done by writing 1. 423 #define SMPH_SMPH9_STAT 0x00000001 424 #define SMPH_SMPH9_STAT_BITN 0 425 #define SMPH_SMPH9_STAT_M 0x00000001 426 #define SMPH_SMPH9_STAT_S 0 427 428 //***************************************************************************** 429 // 430 // Register: SMPH_O_SMPH10 431 // 432 //***************************************************************************** 433 // Field: [0] STAT 434 // 435 // Status when reading: 436 // 437 // 0: Semaphore is taken 438 // 1: Semaphore is available 439 // 440 // Reading the register causes it to change value to 0. Releasing the semaphore 441 // is done by writing 1. 442 #define SMPH_SMPH10_STAT 0x00000001 443 #define SMPH_SMPH10_STAT_BITN 0 444 #define SMPH_SMPH10_STAT_M 0x00000001 445 #define SMPH_SMPH10_STAT_S 0 446 447 //***************************************************************************** 448 // 449 // Register: SMPH_O_SMPH11 450 // 451 //***************************************************************************** 452 // Field: [0] STAT 453 // 454 // Status when reading: 455 // 456 // 0: Semaphore is taken 457 // 1: Semaphore is available 458 // 459 // Reading the register causes it to change value to 0. Releasing the semaphore 460 // is done by writing 1. 461 #define SMPH_SMPH11_STAT 0x00000001 462 #define SMPH_SMPH11_STAT_BITN 0 463 #define SMPH_SMPH11_STAT_M 0x00000001 464 #define SMPH_SMPH11_STAT_S 0 465 466 //***************************************************************************** 467 // 468 // Register: SMPH_O_SMPH12 469 // 470 //***************************************************************************** 471 // Field: [0] STAT 472 // 473 // Status when reading: 474 // 475 // 0: Semaphore is taken 476 // 1: Semaphore is available 477 // 478 // Reading the register causes it to change value to 0. Releasing the semaphore 479 // is done by writing 1. 480 #define SMPH_SMPH12_STAT 0x00000001 481 #define SMPH_SMPH12_STAT_BITN 0 482 #define SMPH_SMPH12_STAT_M 0x00000001 483 #define SMPH_SMPH12_STAT_S 0 484 485 //***************************************************************************** 486 // 487 // Register: SMPH_O_SMPH13 488 // 489 //***************************************************************************** 490 // Field: [0] STAT 491 // 492 // Status when reading: 493 // 494 // 0: Semaphore is taken 495 // 1: Semaphore is available 496 // 497 // Reading the register causes it to change value to 0. Releasing the semaphore 498 // is done by writing 1. 499 #define SMPH_SMPH13_STAT 0x00000001 500 #define SMPH_SMPH13_STAT_BITN 0 501 #define SMPH_SMPH13_STAT_M 0x00000001 502 #define SMPH_SMPH13_STAT_S 0 503 504 //***************************************************************************** 505 // 506 // Register: SMPH_O_SMPH14 507 // 508 //***************************************************************************** 509 // Field: [0] STAT 510 // 511 // Status when reading: 512 // 513 // 0: Semaphore is taken 514 // 1: Semaphore is available 515 // 516 // Reading the register causes it to change value to 0. Releasing the semaphore 517 // is done by writing 1. 518 #define SMPH_SMPH14_STAT 0x00000001 519 #define SMPH_SMPH14_STAT_BITN 0 520 #define SMPH_SMPH14_STAT_M 0x00000001 521 #define SMPH_SMPH14_STAT_S 0 522 523 //***************************************************************************** 524 // 525 // Register: SMPH_O_SMPH15 526 // 527 //***************************************************************************** 528 // Field: [0] STAT 529 // 530 // Status when reading: 531 // 532 // 0: Semaphore is taken 533 // 1: Semaphore is available 534 // 535 // Reading the register causes it to change value to 0. Releasing the semaphore 536 // is done by writing 1. 537 #define SMPH_SMPH15_STAT 0x00000001 538 #define SMPH_SMPH15_STAT_BITN 0 539 #define SMPH_SMPH15_STAT_M 0x00000001 540 #define SMPH_SMPH15_STAT_S 0 541 542 //***************************************************************************** 543 // 544 // Register: SMPH_O_SMPH16 545 // 546 //***************************************************************************** 547 // Field: [0] STAT 548 // 549 // Status when reading: 550 // 551 // 0: Semaphore is taken 552 // 1: Semaphore is available 553 // 554 // Reading the register causes it to change value to 0. Releasing the semaphore 555 // is done by writing 1. 556 #define SMPH_SMPH16_STAT 0x00000001 557 #define SMPH_SMPH16_STAT_BITN 0 558 #define SMPH_SMPH16_STAT_M 0x00000001 559 #define SMPH_SMPH16_STAT_S 0 560 561 //***************************************************************************** 562 // 563 // Register: SMPH_O_SMPH17 564 // 565 //***************************************************************************** 566 // Field: [0] STAT 567 // 568 // Status when reading: 569 // 570 // 0: Semaphore is taken 571 // 1: Semaphore is available 572 // 573 // Reading the register causes it to change value to 0. Releasing the semaphore 574 // is done by writing 1. 575 #define SMPH_SMPH17_STAT 0x00000001 576 #define SMPH_SMPH17_STAT_BITN 0 577 #define SMPH_SMPH17_STAT_M 0x00000001 578 #define SMPH_SMPH17_STAT_S 0 579 580 //***************************************************************************** 581 // 582 // Register: SMPH_O_SMPH18 583 // 584 //***************************************************************************** 585 // Field: [0] STAT 586 // 587 // Status when reading: 588 // 589 // 0: Semaphore is taken 590 // 1: Semaphore is available 591 // 592 // Reading the register causes it to change value to 0. Releasing the semaphore 593 // is done by writing 1. 594 #define SMPH_SMPH18_STAT 0x00000001 595 #define SMPH_SMPH18_STAT_BITN 0 596 #define SMPH_SMPH18_STAT_M 0x00000001 597 #define SMPH_SMPH18_STAT_S 0 598 599 //***************************************************************************** 600 // 601 // Register: SMPH_O_SMPH19 602 // 603 //***************************************************************************** 604 // Field: [0] STAT 605 // 606 // Status when reading: 607 // 608 // 0: Semaphore is taken 609 // 1: Semaphore is available 610 // 611 // Reading the register causes it to change value to 0. Releasing the semaphore 612 // is done by writing 1. 613 #define SMPH_SMPH19_STAT 0x00000001 614 #define SMPH_SMPH19_STAT_BITN 0 615 #define SMPH_SMPH19_STAT_M 0x00000001 616 #define SMPH_SMPH19_STAT_S 0 617 618 //***************************************************************************** 619 // 620 // Register: SMPH_O_SMPH20 621 // 622 //***************************************************************************** 623 // Field: [0] STAT 624 // 625 // Status when reading: 626 // 627 // 0: Semaphore is taken 628 // 1: Semaphore is available 629 // 630 // Reading the register causes it to change value to 0. Releasing the semaphore 631 // is done by writing 1. 632 #define SMPH_SMPH20_STAT 0x00000001 633 #define SMPH_SMPH20_STAT_BITN 0 634 #define SMPH_SMPH20_STAT_M 0x00000001 635 #define SMPH_SMPH20_STAT_S 0 636 637 //***************************************************************************** 638 // 639 // Register: SMPH_O_SMPH21 640 // 641 //***************************************************************************** 642 // Field: [0] STAT 643 // 644 // Status when reading: 645 // 646 // 0: Semaphore is taken 647 // 1: Semaphore is available 648 // 649 // Reading the register causes it to change value to 0. Releasing the semaphore 650 // is done by writing 1. 651 #define SMPH_SMPH21_STAT 0x00000001 652 #define SMPH_SMPH21_STAT_BITN 0 653 #define SMPH_SMPH21_STAT_M 0x00000001 654 #define SMPH_SMPH21_STAT_S 0 655 656 //***************************************************************************** 657 // 658 // Register: SMPH_O_SMPH22 659 // 660 //***************************************************************************** 661 // Field: [0] STAT 662 // 663 // Status when reading: 664 // 665 // 0: Semaphore is taken 666 // 1: Semaphore is available 667 // 668 // Reading the register causes it to change value to 0. Releasing the semaphore 669 // is done by writing 1. 670 #define SMPH_SMPH22_STAT 0x00000001 671 #define SMPH_SMPH22_STAT_BITN 0 672 #define SMPH_SMPH22_STAT_M 0x00000001 673 #define SMPH_SMPH22_STAT_S 0 674 675 //***************************************************************************** 676 // 677 // Register: SMPH_O_SMPH23 678 // 679 //***************************************************************************** 680 // Field: [0] STAT 681 // 682 // Status when reading: 683 // 684 // 0: Semaphore is taken 685 // 1: Semaphore is available 686 // 687 // Reading the register causes it to change value to 0. Releasing the semaphore 688 // is done by writing 1. 689 #define SMPH_SMPH23_STAT 0x00000001 690 #define SMPH_SMPH23_STAT_BITN 0 691 #define SMPH_SMPH23_STAT_M 0x00000001 692 #define SMPH_SMPH23_STAT_S 0 693 694 //***************************************************************************** 695 // 696 // Register: SMPH_O_SMPH24 697 // 698 //***************************************************************************** 699 // Field: [0] STAT 700 // 701 // Status when reading: 702 // 703 // 0: Semaphore is taken 704 // 1: Semaphore is available 705 // 706 // Reading the register causes it to change value to 0. Releasing the semaphore 707 // is done by writing 1. 708 #define SMPH_SMPH24_STAT 0x00000001 709 #define SMPH_SMPH24_STAT_BITN 0 710 #define SMPH_SMPH24_STAT_M 0x00000001 711 #define SMPH_SMPH24_STAT_S 0 712 713 //***************************************************************************** 714 // 715 // Register: SMPH_O_SMPH25 716 // 717 //***************************************************************************** 718 // Field: [0] STAT 719 // 720 // Status when reading: 721 // 722 // 0: Semaphore is taken 723 // 1: Semaphore is available 724 // 725 // Reading the register causes it to change value to 0. Releasing the semaphore 726 // is done by writing 1. 727 #define SMPH_SMPH25_STAT 0x00000001 728 #define SMPH_SMPH25_STAT_BITN 0 729 #define SMPH_SMPH25_STAT_M 0x00000001 730 #define SMPH_SMPH25_STAT_S 0 731 732 //***************************************************************************** 733 // 734 // Register: SMPH_O_SMPH26 735 // 736 //***************************************************************************** 737 // Field: [0] STAT 738 // 739 // Status when reading: 740 // 741 // 0: Semaphore is taken 742 // 1: Semaphore is available 743 // 744 // Reading the register causes it to change value to 0. Releasing the semaphore 745 // is done by writing 1. 746 #define SMPH_SMPH26_STAT 0x00000001 747 #define SMPH_SMPH26_STAT_BITN 0 748 #define SMPH_SMPH26_STAT_M 0x00000001 749 #define SMPH_SMPH26_STAT_S 0 750 751 //***************************************************************************** 752 // 753 // Register: SMPH_O_SMPH27 754 // 755 //***************************************************************************** 756 // Field: [0] STAT 757 // 758 // Status when reading: 759 // 760 // 0: Semaphore is taken 761 // 1: Semaphore is available 762 // 763 // Reading the register causes it to change value to 0. Releasing the semaphore 764 // is done by writing 1. 765 #define SMPH_SMPH27_STAT 0x00000001 766 #define SMPH_SMPH27_STAT_BITN 0 767 #define SMPH_SMPH27_STAT_M 0x00000001 768 #define SMPH_SMPH27_STAT_S 0 769 770 //***************************************************************************** 771 // 772 // Register: SMPH_O_SMPH28 773 // 774 //***************************************************************************** 775 // Field: [0] STAT 776 // 777 // Status when reading: 778 // 779 // 0: Semaphore is taken 780 // 1: Semaphore is available 781 // 782 // Reading the register causes it to change value to 0. Releasing the semaphore 783 // is done by writing 1. 784 #define SMPH_SMPH28_STAT 0x00000001 785 #define SMPH_SMPH28_STAT_BITN 0 786 #define SMPH_SMPH28_STAT_M 0x00000001 787 #define SMPH_SMPH28_STAT_S 0 788 789 //***************************************************************************** 790 // 791 // Register: SMPH_O_SMPH29 792 // 793 //***************************************************************************** 794 // Field: [0] STAT 795 // 796 // Status when reading: 797 // 798 // 0: Semaphore is taken 799 // 1: Semaphore is available 800 // 801 // Reading the register causes it to change value to 0. Releasing the semaphore 802 // is done by writing 1. 803 #define SMPH_SMPH29_STAT 0x00000001 804 #define SMPH_SMPH29_STAT_BITN 0 805 #define SMPH_SMPH29_STAT_M 0x00000001 806 #define SMPH_SMPH29_STAT_S 0 807 808 //***************************************************************************** 809 // 810 // Register: SMPH_O_SMPH30 811 // 812 //***************************************************************************** 813 // Field: [0] STAT 814 // 815 // Status when reading: 816 // 817 // 0: Semaphore is taken 818 // 1: Semaphore is available 819 // 820 // Reading the register causes it to change value to 0. Releasing the semaphore 821 // is done by writing 1. 822 #define SMPH_SMPH30_STAT 0x00000001 823 #define SMPH_SMPH30_STAT_BITN 0 824 #define SMPH_SMPH30_STAT_M 0x00000001 825 #define SMPH_SMPH30_STAT_S 0 826 827 //***************************************************************************** 828 // 829 // Register: SMPH_O_SMPH31 830 // 831 //***************************************************************************** 832 // Field: [0] STAT 833 // 834 // Status when reading: 835 // 836 // 0: Semaphore is taken 837 // 1: Semaphore is available 838 // 839 // Reading the register causes it to change value to 0. Releasing the semaphore 840 // is done by writing 1. 841 #define SMPH_SMPH31_STAT 0x00000001 842 #define SMPH_SMPH31_STAT_BITN 0 843 #define SMPH_SMPH31_STAT_M 0x00000001 844 #define SMPH_SMPH31_STAT_S 0 845 846 //***************************************************************************** 847 // 848 // Register: SMPH_O_PEEK0 849 // 850 //***************************************************************************** 851 // Field: [0] STAT 852 // 853 // Status when reading: 854 // 855 // 0: Semaphore is taken 856 // 1: Semaphore is available 857 // 858 // Used for semaphore debugging. A read operation will not change register 859 // value. Register writing is not possible. 860 #define SMPH_PEEK0_STAT 0x00000001 861 #define SMPH_PEEK0_STAT_BITN 0 862 #define SMPH_PEEK0_STAT_M 0x00000001 863 #define SMPH_PEEK0_STAT_S 0 864 865 //***************************************************************************** 866 // 867 // Register: SMPH_O_PEEK1 868 // 869 //***************************************************************************** 870 // Field: [0] STAT 871 // 872 // Status when reading: 873 // 874 // 0: Semaphore is taken 875 // 1: Semaphore is available 876 // 877 // Used for semaphore debugging. A read operation will not change register 878 // value. Register writing is not possible. 879 #define SMPH_PEEK1_STAT 0x00000001 880 #define SMPH_PEEK1_STAT_BITN 0 881 #define SMPH_PEEK1_STAT_M 0x00000001 882 #define SMPH_PEEK1_STAT_S 0 883 884 //***************************************************************************** 885 // 886 // Register: SMPH_O_PEEK2 887 // 888 //***************************************************************************** 889 // Field: [0] STAT 890 // 891 // Status when reading: 892 // 893 // 0: Semaphore is taken 894 // 1: Semaphore is available 895 // 896 // Used for semaphore debugging. A read operation will not change register 897 // value. Register writing is not possible. 898 #define SMPH_PEEK2_STAT 0x00000001 899 #define SMPH_PEEK2_STAT_BITN 0 900 #define SMPH_PEEK2_STAT_M 0x00000001 901 #define SMPH_PEEK2_STAT_S 0 902 903 //***************************************************************************** 904 // 905 // Register: SMPH_O_PEEK3 906 // 907 //***************************************************************************** 908 // Field: [0] STAT 909 // 910 // Status when reading: 911 // 912 // 0: Semaphore is taken 913 // 1: Semaphore is available 914 // 915 // Used for semaphore debugging. A read operation will not change register 916 // value. Register writing is not possible. 917 #define SMPH_PEEK3_STAT 0x00000001 918 #define SMPH_PEEK3_STAT_BITN 0 919 #define SMPH_PEEK3_STAT_M 0x00000001 920 #define SMPH_PEEK3_STAT_S 0 921 922 //***************************************************************************** 923 // 924 // Register: SMPH_O_PEEK4 925 // 926 //***************************************************************************** 927 // Field: [0] STAT 928 // 929 // Status when reading: 930 // 931 // 0: Semaphore is taken 932 // 1: Semaphore is available 933 // 934 // Used for semaphore debugging. A read operation will not change register 935 // value. Register writing is not possible. 936 #define SMPH_PEEK4_STAT 0x00000001 937 #define SMPH_PEEK4_STAT_BITN 0 938 #define SMPH_PEEK4_STAT_M 0x00000001 939 #define SMPH_PEEK4_STAT_S 0 940 941 //***************************************************************************** 942 // 943 // Register: SMPH_O_PEEK5 944 // 945 //***************************************************************************** 946 // Field: [0] STAT 947 // 948 // Status when reading: 949 // 950 // 0: Semaphore is taken 951 // 1: Semaphore is available 952 // 953 // Used for semaphore debugging. A read operation will not change register 954 // value. Register writing is not possible. 955 #define SMPH_PEEK5_STAT 0x00000001 956 #define SMPH_PEEK5_STAT_BITN 0 957 #define SMPH_PEEK5_STAT_M 0x00000001 958 #define SMPH_PEEK5_STAT_S 0 959 960 //***************************************************************************** 961 // 962 // Register: SMPH_O_PEEK6 963 // 964 //***************************************************************************** 965 // Field: [0] STAT 966 // 967 // Status when reading: 968 // 969 // 0: Semaphore is taken 970 // 1: Semaphore is available 971 // 972 // Used for semaphore debugging. A read operation will not change register 973 // value. Register writing is not possible. 974 #define SMPH_PEEK6_STAT 0x00000001 975 #define SMPH_PEEK6_STAT_BITN 0 976 #define SMPH_PEEK6_STAT_M 0x00000001 977 #define SMPH_PEEK6_STAT_S 0 978 979 //***************************************************************************** 980 // 981 // Register: SMPH_O_PEEK7 982 // 983 //***************************************************************************** 984 // Field: [0] STAT 985 // 986 // Status when reading: 987 // 988 // 0: Semaphore is taken 989 // 1: Semaphore is available 990 // 991 // Used for semaphore debugging. A read operation will not change register 992 // value. Register writing is not possible. 993 #define SMPH_PEEK7_STAT 0x00000001 994 #define SMPH_PEEK7_STAT_BITN 0 995 #define SMPH_PEEK7_STAT_M 0x00000001 996 #define SMPH_PEEK7_STAT_S 0 997 998 //***************************************************************************** 999 // 1000 // Register: SMPH_O_PEEK8 1001 // 1002 //***************************************************************************** 1003 // Field: [0] STAT 1004 // 1005 // Status when reading: 1006 // 1007 // 0: Semaphore is taken 1008 // 1: Semaphore is available 1009 // 1010 // Used for semaphore debugging. A read operation will not change register 1011 // value. Register writing is not possible. 1012 #define SMPH_PEEK8_STAT 0x00000001 1013 #define SMPH_PEEK8_STAT_BITN 0 1014 #define SMPH_PEEK8_STAT_M 0x00000001 1015 #define SMPH_PEEK8_STAT_S 0 1016 1017 //***************************************************************************** 1018 // 1019 // Register: SMPH_O_PEEK9 1020 // 1021 //***************************************************************************** 1022 // Field: [0] STAT 1023 // 1024 // Status when reading: 1025 // 1026 // 0: Semaphore is taken 1027 // 1: Semaphore is available 1028 // 1029 // Used for semaphore debugging. A read operation will not change register 1030 // value. Register writing is not possible. 1031 #define SMPH_PEEK9_STAT 0x00000001 1032 #define SMPH_PEEK9_STAT_BITN 0 1033 #define SMPH_PEEK9_STAT_M 0x00000001 1034 #define SMPH_PEEK9_STAT_S 0 1035 1036 //***************************************************************************** 1037 // 1038 // Register: SMPH_O_PEEK10 1039 // 1040 //***************************************************************************** 1041 // Field: [0] STAT 1042 // 1043 // Status when reading: 1044 // 1045 // 0: Semaphore is taken 1046 // 1: Semaphore is available 1047 // 1048 // Used for semaphore debugging. A read operation will not change register 1049 // value. Register writing is not possible. 1050 #define SMPH_PEEK10_STAT 0x00000001 1051 #define SMPH_PEEK10_STAT_BITN 0 1052 #define SMPH_PEEK10_STAT_M 0x00000001 1053 #define SMPH_PEEK10_STAT_S 0 1054 1055 //***************************************************************************** 1056 // 1057 // Register: SMPH_O_PEEK11 1058 // 1059 //***************************************************************************** 1060 // Field: [0] STAT 1061 // 1062 // Status when reading: 1063 // 1064 // 0: Semaphore is taken 1065 // 1: Semaphore is available 1066 // 1067 // Used for semaphore debugging. A read operation will not change register 1068 // value. Register writing is not possible. 1069 #define SMPH_PEEK11_STAT 0x00000001 1070 #define SMPH_PEEK11_STAT_BITN 0 1071 #define SMPH_PEEK11_STAT_M 0x00000001 1072 #define SMPH_PEEK11_STAT_S 0 1073 1074 //***************************************************************************** 1075 // 1076 // Register: SMPH_O_PEEK12 1077 // 1078 //***************************************************************************** 1079 // Field: [0] STAT 1080 // 1081 // Status when reading: 1082 // 1083 // 0: Semaphore is taken 1084 // 1: Semaphore is available 1085 // 1086 // Used for semaphore debugging. A read operation will not change register 1087 // value. Register writing is not possible. 1088 #define SMPH_PEEK12_STAT 0x00000001 1089 #define SMPH_PEEK12_STAT_BITN 0 1090 #define SMPH_PEEK12_STAT_M 0x00000001 1091 #define SMPH_PEEK12_STAT_S 0 1092 1093 //***************************************************************************** 1094 // 1095 // Register: SMPH_O_PEEK13 1096 // 1097 //***************************************************************************** 1098 // Field: [0] STAT 1099 // 1100 // Status when reading: 1101 // 1102 // 0: Semaphore is taken 1103 // 1: Semaphore is available 1104 // 1105 // Used for semaphore debugging. A read operation will not change register 1106 // value. Register writing is not possible. 1107 #define SMPH_PEEK13_STAT 0x00000001 1108 #define SMPH_PEEK13_STAT_BITN 0 1109 #define SMPH_PEEK13_STAT_M 0x00000001 1110 #define SMPH_PEEK13_STAT_S 0 1111 1112 //***************************************************************************** 1113 // 1114 // Register: SMPH_O_PEEK14 1115 // 1116 //***************************************************************************** 1117 // Field: [0] STAT 1118 // 1119 // Status when reading: 1120 // 1121 // 0: Semaphore is taken 1122 // 1: Semaphore is available 1123 // 1124 // Used for semaphore debugging. A read operation will not change register 1125 // value. Register writing is not possible. 1126 #define SMPH_PEEK14_STAT 0x00000001 1127 #define SMPH_PEEK14_STAT_BITN 0 1128 #define SMPH_PEEK14_STAT_M 0x00000001 1129 #define SMPH_PEEK14_STAT_S 0 1130 1131 //***************************************************************************** 1132 // 1133 // Register: SMPH_O_PEEK15 1134 // 1135 //***************************************************************************** 1136 // Field: [0] STAT 1137 // 1138 // Status when reading: 1139 // 1140 // 0: Semaphore is taken 1141 // 1: Semaphore is available 1142 // 1143 // Used for semaphore debugging. A read operation will not change register 1144 // value. Register writing is not possible. 1145 #define SMPH_PEEK15_STAT 0x00000001 1146 #define SMPH_PEEK15_STAT_BITN 0 1147 #define SMPH_PEEK15_STAT_M 0x00000001 1148 #define SMPH_PEEK15_STAT_S 0 1149 1150 //***************************************************************************** 1151 // 1152 // Register: SMPH_O_PEEK16 1153 // 1154 //***************************************************************************** 1155 // Field: [0] STAT 1156 // 1157 // Status when reading: 1158 // 1159 // 0: Semaphore is taken 1160 // 1: Semaphore is available 1161 // 1162 // Used for semaphore debugging. A read operation will not change register 1163 // value. Register writing is not possible. 1164 #define SMPH_PEEK16_STAT 0x00000001 1165 #define SMPH_PEEK16_STAT_BITN 0 1166 #define SMPH_PEEK16_STAT_M 0x00000001 1167 #define SMPH_PEEK16_STAT_S 0 1168 1169 //***************************************************************************** 1170 // 1171 // Register: SMPH_O_PEEK17 1172 // 1173 //***************************************************************************** 1174 // Field: [0] STAT 1175 // 1176 // Status when reading: 1177 // 1178 // 0: Semaphore is taken 1179 // 1: Semaphore is available 1180 // 1181 // Used for semaphore debugging. A read operation will not change register 1182 // value. Register writing is not possible. 1183 #define SMPH_PEEK17_STAT 0x00000001 1184 #define SMPH_PEEK17_STAT_BITN 0 1185 #define SMPH_PEEK17_STAT_M 0x00000001 1186 #define SMPH_PEEK17_STAT_S 0 1187 1188 //***************************************************************************** 1189 // 1190 // Register: SMPH_O_PEEK18 1191 // 1192 //***************************************************************************** 1193 // Field: [0] STAT 1194 // 1195 // Status when reading: 1196 // 1197 // 0: Semaphore is taken 1198 // 1: Semaphore is available 1199 // 1200 // Used for semaphore debugging. A read operation will not change register 1201 // value. Register writing is not possible. 1202 #define SMPH_PEEK18_STAT 0x00000001 1203 #define SMPH_PEEK18_STAT_BITN 0 1204 #define SMPH_PEEK18_STAT_M 0x00000001 1205 #define SMPH_PEEK18_STAT_S 0 1206 1207 //***************************************************************************** 1208 // 1209 // Register: SMPH_O_PEEK19 1210 // 1211 //***************************************************************************** 1212 // Field: [0] STAT 1213 // 1214 // Status when reading: 1215 // 1216 // 0: Semaphore is taken 1217 // 1: Semaphore is available 1218 // 1219 // Used for semaphore debugging. A read operation will not change register 1220 // value. Register writing is not possible. 1221 #define SMPH_PEEK19_STAT 0x00000001 1222 #define SMPH_PEEK19_STAT_BITN 0 1223 #define SMPH_PEEK19_STAT_M 0x00000001 1224 #define SMPH_PEEK19_STAT_S 0 1225 1226 //***************************************************************************** 1227 // 1228 // Register: SMPH_O_PEEK20 1229 // 1230 //***************************************************************************** 1231 // Field: [0] STAT 1232 // 1233 // Status when reading: 1234 // 1235 // 0: Semaphore is taken 1236 // 1: Semaphore is available 1237 // 1238 // Used for semaphore debugging. A read operation will not change register 1239 // value. Register writing is not possible. 1240 #define SMPH_PEEK20_STAT 0x00000001 1241 #define SMPH_PEEK20_STAT_BITN 0 1242 #define SMPH_PEEK20_STAT_M 0x00000001 1243 #define SMPH_PEEK20_STAT_S 0 1244 1245 //***************************************************************************** 1246 // 1247 // Register: SMPH_O_PEEK21 1248 // 1249 //***************************************************************************** 1250 // Field: [0] STAT 1251 // 1252 // Status when reading: 1253 // 1254 // 0: Semaphore is taken 1255 // 1: Semaphore is available 1256 // 1257 // Used for semaphore debugging. A read operation will not change register 1258 // value. Register writing is not possible. 1259 #define SMPH_PEEK21_STAT 0x00000001 1260 #define SMPH_PEEK21_STAT_BITN 0 1261 #define SMPH_PEEK21_STAT_M 0x00000001 1262 #define SMPH_PEEK21_STAT_S 0 1263 1264 //***************************************************************************** 1265 // 1266 // Register: SMPH_O_PEEK22 1267 // 1268 //***************************************************************************** 1269 // Field: [0] STAT 1270 // 1271 // Status when reading: 1272 // 1273 // 0: Semaphore is taken 1274 // 1: Semaphore is available 1275 // 1276 // Used for semaphore debugging. A read operation will not change register 1277 // value. Register writing is not possible. 1278 #define SMPH_PEEK22_STAT 0x00000001 1279 #define SMPH_PEEK22_STAT_BITN 0 1280 #define SMPH_PEEK22_STAT_M 0x00000001 1281 #define SMPH_PEEK22_STAT_S 0 1282 1283 //***************************************************************************** 1284 // 1285 // Register: SMPH_O_PEEK23 1286 // 1287 //***************************************************************************** 1288 // Field: [0] STAT 1289 // 1290 // Status when reading: 1291 // 1292 // 0: Semaphore is taken 1293 // 1: Semaphore is available 1294 // 1295 // Used for semaphore debugging. A read operation will not change register 1296 // value. Register writing is not possible. 1297 #define SMPH_PEEK23_STAT 0x00000001 1298 #define SMPH_PEEK23_STAT_BITN 0 1299 #define SMPH_PEEK23_STAT_M 0x00000001 1300 #define SMPH_PEEK23_STAT_S 0 1301 1302 //***************************************************************************** 1303 // 1304 // Register: SMPH_O_PEEK24 1305 // 1306 //***************************************************************************** 1307 // Field: [0] STAT 1308 // 1309 // Status when reading: 1310 // 1311 // 0: Semaphore is taken 1312 // 1: Semaphore is available 1313 // 1314 // Used for semaphore debugging. A read operation will not change register 1315 // value. Register writing is not possible. 1316 #define SMPH_PEEK24_STAT 0x00000001 1317 #define SMPH_PEEK24_STAT_BITN 0 1318 #define SMPH_PEEK24_STAT_M 0x00000001 1319 #define SMPH_PEEK24_STAT_S 0 1320 1321 //***************************************************************************** 1322 // 1323 // Register: SMPH_O_PEEK25 1324 // 1325 //***************************************************************************** 1326 // Field: [0] STAT 1327 // 1328 // Status when reading: 1329 // 1330 // 0: Semaphore is taken 1331 // 1: Semaphore is available 1332 // 1333 // Used for semaphore debugging. A read operation will not change register 1334 // value. Register writing is not possible. 1335 #define SMPH_PEEK25_STAT 0x00000001 1336 #define SMPH_PEEK25_STAT_BITN 0 1337 #define SMPH_PEEK25_STAT_M 0x00000001 1338 #define SMPH_PEEK25_STAT_S 0 1339 1340 //***************************************************************************** 1341 // 1342 // Register: SMPH_O_PEEK26 1343 // 1344 //***************************************************************************** 1345 // Field: [0] STAT 1346 // 1347 // Status when reading: 1348 // 1349 // 0: Semaphore is taken 1350 // 1: Semaphore is available 1351 // 1352 // Used for semaphore debugging. A read operation will not change register 1353 // value. Register writing is not possible. 1354 #define SMPH_PEEK26_STAT 0x00000001 1355 #define SMPH_PEEK26_STAT_BITN 0 1356 #define SMPH_PEEK26_STAT_M 0x00000001 1357 #define SMPH_PEEK26_STAT_S 0 1358 1359 //***************************************************************************** 1360 // 1361 // Register: SMPH_O_PEEK27 1362 // 1363 //***************************************************************************** 1364 // Field: [0] STAT 1365 // 1366 // Status when reading: 1367 // 1368 // 0: Semaphore is taken 1369 // 1: Semaphore is available 1370 // 1371 // Used for semaphore debugging. A read operation will not change register 1372 // value. Register writing is not possible. 1373 #define SMPH_PEEK27_STAT 0x00000001 1374 #define SMPH_PEEK27_STAT_BITN 0 1375 #define SMPH_PEEK27_STAT_M 0x00000001 1376 #define SMPH_PEEK27_STAT_S 0 1377 1378 //***************************************************************************** 1379 // 1380 // Register: SMPH_O_PEEK28 1381 // 1382 //***************************************************************************** 1383 // Field: [0] STAT 1384 // 1385 // Status when reading: 1386 // 1387 // 0: Semaphore is taken 1388 // 1: Semaphore is available 1389 // 1390 // Used for semaphore debugging. A read operation will not change register 1391 // value. Register writing is not possible. 1392 #define SMPH_PEEK28_STAT 0x00000001 1393 #define SMPH_PEEK28_STAT_BITN 0 1394 #define SMPH_PEEK28_STAT_M 0x00000001 1395 #define SMPH_PEEK28_STAT_S 0 1396 1397 //***************************************************************************** 1398 // 1399 // Register: SMPH_O_PEEK29 1400 // 1401 //***************************************************************************** 1402 // Field: [0] STAT 1403 // 1404 // Status when reading: 1405 // 1406 // 0: Semaphore is taken 1407 // 1: Semaphore is available 1408 // 1409 // Used for semaphore debugging. A read operation will not change register 1410 // value. Register writing is not possible. 1411 #define SMPH_PEEK29_STAT 0x00000001 1412 #define SMPH_PEEK29_STAT_BITN 0 1413 #define SMPH_PEEK29_STAT_M 0x00000001 1414 #define SMPH_PEEK29_STAT_S 0 1415 1416 //***************************************************************************** 1417 // 1418 // Register: SMPH_O_PEEK30 1419 // 1420 //***************************************************************************** 1421 // Field: [0] STAT 1422 // 1423 // Status when reading: 1424 // 1425 // 0: Semaphore is taken 1426 // 1: Semaphore is available 1427 // 1428 // Used for semaphore debugging. A read operation will not change register 1429 // value. Register writing is not possible. 1430 #define SMPH_PEEK30_STAT 0x00000001 1431 #define SMPH_PEEK30_STAT_BITN 0 1432 #define SMPH_PEEK30_STAT_M 0x00000001 1433 #define SMPH_PEEK30_STAT_S 0 1434 1435 //***************************************************************************** 1436 // 1437 // Register: SMPH_O_PEEK31 1438 // 1439 //***************************************************************************** 1440 // Field: [0] STAT 1441 // 1442 // Status when reading: 1443 // 1444 // 0: Semaphore is taken 1445 // 1: Semaphore is available 1446 // 1447 // Used for semaphore debugging. A read operation will not change register 1448 // value. Register writing is not possible. 1449 #define SMPH_PEEK31_STAT 0x00000001 1450 #define SMPH_PEEK31_STAT_BITN 0 1451 #define SMPH_PEEK31_STAT_M 0x00000001 1452 #define SMPH_PEEK31_STAT_S 0 1453 1454 1455 #endif // __SMPH__ 1456
