doc/html/ref/devapi-api.html

   1 <!-- Copyright (C) 2003 Red Hat, Inc.                                -->
   2 <!-- This material may be distributed only subject to the terms      -->
   3 <!-- and conditions set forth in the Open Publication License, v1.0  -->
   4 <!-- or later (the latest version is presently available at          -->
   5 <!-- http://www.opencontent.org/openpub/).                           -->
   6 <!-- Distribution of the work or derivative of the work in any       -->
   7 <!-- standard (paper) book form is prohibited unless prior           -->
   8 <!-- permission is obtained from the copyright holder.               -->
   9 <HTML
  10 ><HEAD
  11 ><TITLE
  12 >The API</TITLE
  13 ><meta name="MSSmartTagsPreventParsing" content="TRUE">
  14 <META
  15 NAME="GENERATOR"
  16 CONTENT="Modular DocBook HTML Stylesheet Version 1.76b+
  17 "><LINK
  18 REL="HOME"
  19 TITLE="eCos Reference Manual"
  20 HREF="ecos-ref.html"><LINK
  21 REL="UP"
  22 TITLE="Device Driver Interface to the Kernel"
  23 HREF="devapi-device-driver-interface-to-the-kernel.html"><LINK
  24 REL="PREVIOUS"
  25 TITLE="Synchronization Levels"
  26 HREF="devapi-synchronization-levels.html"><LINK
  27 REL="NEXT"
  28 TITLE="File System Support Infrastructure"
  29 HREF="fileio.html"></HEAD
  30 ><BODY
  31 CLASS="SECTION"
  32 BGCOLOR="#FFFFFF"
  33 TEXT="#000000"
  34 LINK="#0000FF"
  35 VLINK="#840084"
  36 ALINK="#0000FF"
  37 ><DIV
  38 CLASS="NAVHEADER"
  39 ><TABLE
  40 SUMMARY="Header navigation table"
  41 WIDTH="100%"
  42 BORDER="0"
  43 CELLPADDING="0"
  44 CELLSPACING="0"
  45 ><TR
  46 ><TH
  47 COLSPAN="3"
  48 ALIGN="center"
  49 >eCos Reference Manual</TH
  50 ></TR
  51 ><TR
  52 ><TD
  53 WIDTH="10%"
  54 ALIGN="left"
  55 VALIGN="bottom"
  56 ><A
  57 HREF="devapi-synchronization-levels.html"
  58 ACCESSKEY="P"
  59 >Prev</A
  60 ></TD
  61 ><TD
  62 WIDTH="80%"
  63 ALIGN="center"
  64 VALIGN="bottom"
  65 >Chapter 18. Device Driver Interface to the Kernel</TD
  66 ><TD
  67 WIDTH="10%"
  68 ALIGN="right"
  69 VALIGN="bottom"
  70 ><A
  71 HREF="fileio.html"
  72 ACCESSKEY="N"
  73 >Next</A
  74 ></TD
  75 ></TR
  76 ></TABLE
  77 ><HR
  78 ALIGN="LEFT"
  79 WIDTH="100%"></DIV
  80 ><DIV
  81 CLASS="SECTION"
  82 ><H1
  83 CLASS="SECTION"
  84 ><A
  85 NAME="DEVAPI-API">The API</H1
  86 ><P
  87 >This section details the Driver Kernel
  88 Interface. Note that most of these functions are identical to Kernel C
  89 API calls, and will in most configurations be wrappers for them. In
  90 non-kernel configurations they will be supported directly by the HAL,
  91 or by code to emulate the required behavior.</P
  92 ><P
  93 >This API is defined in the header file
  94 <TT
  95 CLASS="FILENAME"
  96 >&lt;cyg/hal/drv_api.h&gt;</TT
  97 >.</P
  98 ><DIV
  99 CLASS="SECTION"
 100 ><H2
 101 CLASS="SECTION"
 102 ><A
 103 NAME="AEN11310">cyg_drv_isr_lock</H2
 104 ><P
 105 ></P
 106 ><DIV
 107 CLASS="VARIABLELIST"
 108 ><DL
 109 ><DT
 110 >Function:</DT
 111 ><DD
 112 ><TABLE
 113 BORDER="5"
 114 BGCOLOR="#E0E0F0"
 115 WIDTH="70%"
 116 ><TR
 117 ><TD
 118 ><PRE
 119 CLASS="PROGRAMLISTING"
 120 >void cyg_drv_isr_lock()</PRE
 121 ></TD
 122 ></TR
 123 ></TABLE
 124 ></DD
 125 ><DT
 126 >Arguments:</DT
 127 ><DD
 128 ><P
 129 >None</P
 130 ></DD
 131 ><DT
 132 >Result:</DT
 133 ><DD
 134 ><P
 135 >None </P
 136 ></DD
 137 ><DT
 138 >Level:</DT
 139 ><DD
 140 ><P
 141 >ISR</P
 142 ></DD
 143 ><DT
 144 >Description:</DT
 145 ><DD
 146 ><P
 147 >      Disables delivery of interrupts, preventing all ISRs running.  This
 148       function maintains a counter of the number of times it is
 149       called.
 150       </P
 151 ></DD
 152 ></DL
 153 ></DIV
 154 ></DIV
 155 ><DIV
 156 CLASS="SECTION"
 157 ><H2
 158 CLASS="SECTION"
 159 ><A
 160 NAME="AEN11333">cyg_drv_isr_unlock</H2
 161 ><P
 162 ></P
 163 ><DIV
 164 CLASS="VARIABLELIST"
 165 ><DL
 166 ><DT
 167 >Function:</DT
 168 ><DD
 169 ><TABLE
 170 BORDER="5"
 171 BGCOLOR="#E0E0F0"
 172 WIDTH="70%"
 173 ><TR
 174 ><TD
 175 ><PRE
 176 CLASS="PROGRAMLISTING"
 177 >void cyg_drv_isr_unlock()</PRE
 178 ></TD
 179 ></TR
 180 ></TABLE
 181 ></DD
 182 ><DT
 183 >Arguments:</DT
 184 ><DD
 185 ><P
 186 >None</P
 187 ></DD
 188 ><DT
 189 >Result:</DT
 190 ><DD
 191 ><P
 192 >None </P
 193 ></DD
 194 ><DT
 195 >Level:</DT
 196 ><DD
 197 ><P
 198 >ISR</P
 199 ></DD
 200 ><DT
 201 >Description:</DT
 202 ><DD
 203 ><P
 204 >Re-enables delivery of interrupts, allowing ISRs to
 205       run. This function decrements the counter maintained by
 206       <TT
 207 CLASS="FUNCTION"
 208 >cyg_drv_isr_lock()</TT
 209 >, and only re-allows
 210       interrupts when it goes to zero. </P
 211 ></DD
 212 ></DL
 213 ></DIV
 214 ></DIV
 215 ><DIV
 216 CLASS="SECTION"
 217 ><H2
 218 CLASS="SECTION"
 219 ><A
 220 NAME="AEN11357">cyg_drv_spinlock_init</H2
 221 ><P
 222 ></P
 223 ><DIV
 224 CLASS="VARIABLELIST"
 225 ><DL
 226 ><DT
 227 >Function:</DT
 228 ><DD
 229 ><TABLE
 230 BORDER="5"
 231 BGCOLOR="#E0E0F0"
 232 WIDTH="70%"
 233 ><TR
 234 ><TD
 235 ><PRE
 236 CLASS="PROGRAMLISTING"
 237 >void cyg_drv_spinlock_init(cyg_spinlock_t *lock, cyg_bool_t locked )</PRE
 238 ></TD
 239 ></TR
 240 ></TABLE
 241 ></DD
 242 ><DT
 243 >Arguments:</DT
 244 ><DD
 245 ><P
 246 ><TT
 247 CLASS="PARAMETER"
 248 ><I
 249 >lock</I
 250 ></TT
 251 > - pointer to spinlock to initialize</P
 252 ><P
 253 ><TT
 254 CLASS="PARAMETER"
 255 ><I
 256 >locked</I
 257 ></TT
 258 > - initial state of lock</P
 259 ></DD
 260 ><DT
 261 >Result:</DT
 262 ><DD
 263 ><P
 264 >None</P
 265 ></DD
 266 ><DT
 267 >Level:</DT
 268 ><DD
 269 ><P
 270 >Thread</P
 271 ></DD
 272 ><DT
 273 >Description:</DT
 274 ><DD
 275 ><P
 276 >      Initialize a spinlock. The <TT
 277 CLASS="PARAMETER"
 278 ><I
 279 >locked</I
 280 ></TT
 281 >
 282       argument indicates how the spinlock should be initialized:
 283       <TT
 284 CLASS="LITERAL"
 285 >TRUE</TT
 286 > for locked or <TT
 287 CLASS="LITERAL"
 288 >FALSE</TT
 289 >
 290       for unlocked state.
 291       </P
 292 ></DD
 293 ></DL
 294 ></DIV
 295 ></DIV
 296 ><DIV
 297 CLASS="SECTION"
 298 ><H2
 299 CLASS="SECTION"
 300 ><A
 301 NAME="AEN11386">cyg_drv_spinlock_destroy</H2
 302 ><P
 303 ></P
 304 ><DIV
 305 CLASS="VARIABLELIST"
 306 ><DL
 307 ><DT
 308 >Function:</DT
 309 ><DD
 310 ><TABLE
 311 BORDER="5"
 312 BGCOLOR="#E0E0F0"
 313 WIDTH="70%"
 314 ><TR
 315 ><TD
 316 ><PRE
 317 CLASS="PROGRAMLISTING"
 318 >void cyg_drv_spinlock_destroy(cyg_spinlock_t *lock )</PRE
 319 ></TD
 320 ></TR
 321 ></TABLE
 322 ></DD
 323 ><DT
 324 >Arguments:</DT
 325 ><DD
 326 ><P
 327 ><TT
 328 CLASS="PARAMETER"
 329 ><I
 330 >lock</I
 331 ></TT
 332 > - pointer to spinlock destroy</P
 333 ></DD
 334 ><DT
 335 >Result:</DT
 336 ><DD
 337 ><P
 338 >None</P
 339 ></DD
 340 ><DT
 341 >Level:</DT
 342 ><DD
 343 ><P
 344 >Thread</P
 345 ></DD
 346 ><DT
 347 >Description:</DT
 348 ><DD
 349 ><P
 350 >      Destroy a spinlock that is no longer of use. There should be no
 351       CPUs attempting to claim the lock at the time this function is
 352       called, otherwise the behavior is undefined.
 353       </P
 354 ></DD
 355 ></DL
 356 ></DIV
 357 ></DIV
 358 ><DIV
 359 CLASS="SECTION"
 360 ><H2
 361 CLASS="SECTION"
 362 ><A
 363 NAME="AEN11410">cyg_drv_spinlock_spin</H2
 364 ><P
 365 ></P
 366 ><DIV
 367 CLASS="VARIABLELIST"
 368 ><DL
 369 ><DT
 370 >Function:</DT
 371 ><DD
 372 ><TABLE
 373 BORDER="5"
 374 BGCOLOR="#E0E0F0"
 375 WIDTH="70%"
 376 ><TR
 377 ><TD
 378 ><PRE
 379 CLASS="PROGRAMLISTING"
 380 >void cyg_drv_spinlock_spin(cyg_spinlock_t *lock )</PRE
 381 ></TD
 382 ></TR
 383 ></TABLE
 384 ></DD
 385 ><DT
 386 >Arguments:</DT
 387 ><DD
 388 ><P
 389 ><TT
 390 CLASS="PARAMETER"
 391 ><I
 392 >lock</I
 393 ></TT
 394 > - pointer to spinlock to claim</P
 395 ></DD
 396 ><DT
 397 >Result:</DT
 398 ><DD
 399 ><P
 400 >None</P
 401 ></DD
 402 ><DT
 403 >Level:</DT
 404 ><DD
 405 ><P
 406 >ISR</P
 407 ></DD
 408 ><DT
 409 >Description:</DT
 410 ><DD
 411 ><P
 412 >      Claim a spinlock, waiting in a busy loop until it is
 413       available. Wherever this is called from, this operation
 414       effectively pauses the CPU until it succeeds. This operations
 415       should therefore be used sparingly, and in situations where
 416       deadlocks/livelocks cannot occur. Also see
 417       <TT
 418 CLASS="FUNCTION"
 419 >cyg_drv_spinlock_spin_intsave()</TT
 420 >.
 421       </P
 422 ></DD
 423 ></DL
 424 ></DIV
 425 ></DIV
 426 ><DIV
 427 CLASS="SECTION"
 428 ><H2
 429 CLASS="SECTION"
 430 ><A
 431 NAME="AEN11435">cyg_drv_spinlock_clear</H2
 432 ><P
 433 ></P
 434 ><DIV
 435 CLASS="VARIABLELIST"
 436 ><DL
 437 ><DT
 438 >Function:</DT
 439 ><DD
 440 ><TABLE
 441 BORDER="5"
 442 BGCOLOR="#E0E0F0"
 443 WIDTH="70%"
 444 ><TR
 445 ><TD
 446 ><PRE
 447 CLASS="PROGRAMLISTING"
 448 >void cyg_drv_spinlock_clear(cyg_spinlock_t *lock )</PRE
 449 ></TD
 450 ></TR
 451 ></TABLE
 452 ></DD
 453 ><DT
 454 >Arguments:</DT
 455 ><DD
 456 ><P
 457 ><TT
 458 CLASS="PARAMETER"
 459 ><I
 460 >lock</I
 461 ></TT
 462 > - pointer to spinlock to clear </P
 463 ></DD
 464 ><DT
 465 >Result:</DT
 466 ><DD
 467 ><P
 468 >None</P
 469 ></DD
 470 ><DT
 471 >Level:</DT
 472 ><DD
 473 ><P
 474 >ISR</P
 475 ></DD
 476 ><DT
 477 >Description:</DT
 478 ><DD
 479 ><P
 480 >      Clear a spinlock. This clears the spinlock and allows another
 481       CPU to claim it. If there is more than one CPU waiting in
 482       <TT
 483 CLASS="FUNCTION"
 484 >cyg_drv_spinlock_spin()</TT
 485 > then just one of
 486       them will be allowed to proceed.
 487       </P
 488 ></DD
 489 ></DL
 490 ></DIV
 491 ></DIV
 492 ><DIV
 493 CLASS="SECTION"
 494 ><H2
 495 CLASS="SECTION"
 496 ><A
 497 NAME="AEN11460">cyg_drv_spinlock_try</H2
 498 ><P
 499 ></P
 500 ><DIV
 501 CLASS="VARIABLELIST"
 502 ><DL
 503 ><DT
 504 >Function:</DT
 505 ><DD
 506 ><TABLE
 507 BORDER="5"
 508 BGCOLOR="#E0E0F0"
 509 WIDTH="70%"
 510 ><TR
 511 ><TD
 512 ><PRE
 513 CLASS="PROGRAMLISTING"
 514 >cyg_bool_t cyg_drv_spinlock_try(cyg_spinlock_t *lock )</PRE
 515 ></TD
 516 ></TR
 517 ></TABLE
 518 ></DD
 519 ><DT
 520 >Arguments:</DT
 521 ><DD
 522 ><P
 523 ><TT
 524 CLASS="PARAMETER"
 525 ><I
 526 >lock</I
 527 ></TT
 528 > - pointer to spinlock to try</P
 529 ></DD
 530 ><DT
 531 >Result:</DT
 532 ><DD
 533 ><P
 534 ><TT
 535 CLASS="LITERAL"
 536 >TRUE</TT
 537 > if the spinlock was claimed,
 538       <TT
 539 CLASS="LITERAL"
 540 >FALSE</TT
 541 > otherwise.</P
 542 ></DD
 543 ><DT
 544 >Level:</DT
 545 ><DD
 546 ><P
 547 >ISR</P
 548 ></DD
 549 ><DT
 550 >Description:</DT
 551 ><DD
 552 ><P
 553 >      Try to claim the spinlock without waiting. If the spinlock could
 554       be claimed immediately then <TT
 555 CLASS="LITERAL"
 556 >TRUE</TT
 557 > is
 558       returned. If the spinlock is already claimed then the result is
 559       <TT
 560 CLASS="LITERAL"
 561 >FALSE</TT
 562 >.
 563       </P
 564 ></DD
 565 ></DL
 566 ></DIV
 567 ></DIV
 568 ><DIV
 569 CLASS="SECTION"
 570 ><H2
 571 CLASS="SECTION"
 572 ><A
 573 NAME="AEN11488">cyg_drv_spinlock_test</H2
 574 ><P
 575 ></P
 576 ><DIV
 577 CLASS="VARIABLELIST"
 578 ><DL
 579 ><DT
 580 >Function:</DT
 581 ><DD
 582 ><TABLE
 583 BORDER="5"
 584 BGCOLOR="#E0E0F0"
 585 WIDTH="70%"
 586 ><TR
 587 ><TD
 588 ><PRE
 589 CLASS="PROGRAMLISTING"
 590 >cyg_bool_t cyg_drv_spinlock_test(cyg_spinlock_t *lock )</PRE
 591 ></TD
 592 ></TR
 593 ></TABLE
 594 ></DD
 595 ><DT
 596 >Arguments:</DT
 597 ><DD
 598 ><P
 599 ><TT
 600 CLASS="PARAMETER"
 601 ><I
 602 >lock</I
 603 ></TT
 604 > - pointer to spinlock to test</P
 605 ></DD
 606 ><DT
 607 >Result:</DT
 608 ><DD
 609 ><P
 610 ><TT
 611 CLASS="LITERAL"
 612 >TRUE</TT
 613 > if the spinlock is available,
 614       <TT
 615 CLASS="LITERAL"
 616 >FALSE</TT
 617 > otherwise.</P
 618 ></DD
 619 ><DT
 620 >Level:</DT
 621 ><DD
 622 ><P
 623 >ISR</P
 624 ></DD
 625 ><DT
 626 >Description:</DT
 627 ><DD
 628 ><P
 629 >      Inspect the state of the spinlock. If the spinlock is not locked
 630       then the result is <TT
 631 CLASS="LITERAL"
 632 >TRUE</TT
 633 >. If it is locked then
 634       the result will be <TT
 635 CLASS="LITERAL"
 636 >FALSE</TT
 637 >.
 638       </P
 639 ></DD
 640 ></DL
 641 ></DIV
 642 ></DIV
 643 ><DIV
 644 CLASS="SECTION"
 645 ><H2
 646 CLASS="SECTION"
 647 ><A
 648 NAME="AEN11516">cyg_drv_spinlock_spin_intsave</H2
 649 ><P
 650 ></P
 651 ><DIV
 652 CLASS="VARIABLELIST"
 653 ><DL
 654 ><DT
 655 >Function:</DT
 656 ><DD
 657 ><TABLE
 658 BORDER="5"
 659 BGCOLOR="#E0E0F0"
 660 WIDTH="70%"
 661 ><TR
 662 ><TD
 663 ><PRE
 664 CLASS="PROGRAMLISTING"
 665 >void cyg_drv_spinlock_spin_intsave(cyg_spinlock_t *lock,
 666                                    cyg_addrword_t *istate )</PRE
 667 ></TD
 668 ></TR
 669 ></TABLE
 670 ></DD
 671 ><DT
 672 >Arguments:</DT
 673 ><DD
 674 ><P
 675 ><TT
 676 CLASS="PARAMETER"
 677 ><I
 678 >lock</I
 679 ></TT
 680 > - pointer to spinlock to claim</P
 681 ><P
 682 ><TT
 683 CLASS="PARAMETER"
 684 ><I
 685 >istate</I
 686 ></TT
 687 > - pointer to interrupt state save location</P
 688 ></DD
 689 ><DT
 690 >Result:</DT
 691 ><DD
 692 ><P
 693 >None</P
 694 ></DD
 695 ><DT
 696 >Level:</DT
 697 ><DD
 698 ><P
 699 >ISR</P
 700 ></DD
 701 ><DT
 702 >Description:</DT
 703 ><DD
 704 ><P
 705 >      This function behaves exactly like
 706       <TT
 707 CLASS="FUNCTION"
 708 >cyg_drv_spinlock_spin()</TT
 709 > except that it also
 710       disables interrupts before attempting to claim the lock. The
 711       current interrupt enable state is saved in
 712       <TT
 713 CLASS="PARAMETER"
 714 ><I
 715 >*istate</I
 716 ></TT
 717 >. Interrupts remain disabled once
 718       the spinlock had been claimed and must be restored by calling
 719       <TT
 720 CLASS="FUNCTION"
 721 >cyg_drv_spinlock_clear_intsave()</TT
 722 >.
 723       </P
 724 ><P
 725 >      In general, device drivers should use this function to claim and
 726       release spinlocks rather than the
 727       non-<TT
 728 CLASS="FUNCTION"
 729 >_intsave()</TT
 730 > variants, to ensure proper
 731       exclusion with code running on both other CPUs and this CPU.
 732       </P
 733 ></DD
 734 ></DL
 735 ></DIV
 736 ></DIV
 737 ><DIV
 738 CLASS="SECTION"
 739 ><H2
 740 CLASS="SECTION"
 741 ><A
 742 NAME="AEN11547">cyg_drv_spinlock_clear_intsave</H2
 743 ><P
 744 ></P
 745 ><DIV
 746 CLASS="VARIABLELIST"
 747 ><DL
 748 ><DT
 749 >Function:</DT
 750 ><DD
 751 ><TABLE
 752 BORDER="5"
 753 BGCOLOR="#E0E0F0"
 754 WIDTH="70%"
 755 ><TR
 756 ><TD
 757 ><PRE
 758 CLASS="PROGRAMLISTING"
 759 >void cyg_drv_spinlock_clear_intsave( cyg_spinlock_t *lock,
 760                                      cyg_addrword_t istate )</PRE
 761 ></TD
 762 ></TR
 763 ></TABLE
 764 ></DD
 765 ><DT
 766 >Arguments:</DT
 767 ><DD
 768 ><P
 769 ><TT
 770 CLASS="PARAMETER"
 771 ><I
 772 >lock</I
 773 ></TT
 774 > - pointer to spinlock to clear </P
 775 ><P
 776 ><TT
 777 CLASS="PARAMETER"
 778 ><I
 779 >istate</I
 780 ></TT
 781 > - interrupt state to restore </P
 782 ></DD
 783 ><DT
 784 >Result:</DT
 785 ><DD
 786 ><P
 787 >None</P
 788 ></DD
 789 ><DT
 790 >Level:</DT
 791 ><DD
 792 ><P
 793 >ISR</P
 794 ></DD
 795 ><DT
 796 >Description:</DT
 797 ><DD
 798 ><P
 799 >      This function behaves exactly like
 800       <TT
 801 CLASS="FUNCTION"
 802 >cyg_drv_spinlock_clear()</TT
 803 > except that it
 804       also restores an interrupt state saved by
 805       <TT
 806 CLASS="FUNCTION"
 807 >cyg_drv_spinlock_spin_intsave()</TT
 808 >. The
 809       <TT
 810 CLASS="PARAMETER"
 811 ><I
 812 >istate</I
 813 ></TT
 814 > argument must have been
 815       initialized by a previous call to
 816       <TT
 817 CLASS="FUNCTION"
 818 >cyg_drv_spinlock_spin_intsave()</TT
 819 >.
 820       </P
 821 ></DD
 822 ></DL
 823 ></DIV
 824 ></DIV
 825 ><DIV
 826 CLASS="SECTION"
 827 ><H2
 828 CLASS="SECTION"
 829 ><A
 830 NAME="AEN11577">cyg_drv_dsr_lock</H2
 831 ><P
 832 ></P
 833 ><DIV
 834 CLASS="VARIABLELIST"
 835 ><DL
 836 ><DT
 837 >Function:</DT
 838 ><DD
 839 ><TABLE
 840 BORDER="5"
 841 BGCOLOR="#E0E0F0"
 842 WIDTH="70%"
 843 ><TR
 844 ><TD
 845 ><PRE
 846 CLASS="PROGRAMLISTING"
 847 >void cyg_drv_dsr_lock()</PRE
 848 ></TD
 849 ></TR
 850 ></TABLE
 851 ></DD
 852 ><DT
 853 >Arguments:</DT
 854 ><DD
 855 ><P
 856 >None</P
 857 ></DD
 858 ><DT
 859 >Result:</DT
 860 ><DD
 861 ><P
 862 >None </P
 863 ></DD
 864 ><DT
 865 >Level:</DT
 866 ><DD
 867 ><P
 868 >DSR</P
 869 ></DD
 870 ><DT
 871 >Description:</DT
 872 ><DD
 873 ><P
 874 >Disables scheduling of DSRs. This function maintains a
 875       counter of the number of times it has been called. </P
 876 ></DD
 877 ></DL
 878 ></DIV
 879 ></DIV
 880 ><DIV
 881 CLASS="SECTION"
 882 ><H2
 883 CLASS="SECTION"
 884 ><A
 885 NAME="AEN11600">cyg_drv_dsr_unlock</H2
 886 ><P
 887 ></P
 888 ><DIV
 889 CLASS="VARIABLELIST"
 890 ><DL
 891 ><DT
 892 >Function:</DT
 893 ><DD
 894 ><TABLE
 895 BORDER="5"
 896 BGCOLOR="#E0E0F0"
 897 WIDTH="70%"
 898 ><TR
 899 ><TD
 900 ><PRE
 901 CLASS="PROGRAMLISTING"
 902 >void cyg_drv_dsr_unlock()</PRE
 903 ></TD
 904 ></TR
 905 ></TABLE
 906 ></DD
 907 ><DT
 908 >Arguments:</DT
 909 ><DD
 910 ><P
 911 >None</P
 912 ></DD
 913 ><DT
 914 >Result:</DT
 915 ><DD
 916 ><P
 917 >               </P
 918 ><P
 919 >None </P
 920 ></DD
 921 ><DT
 922 >Level:</DT
 923 ><DD
 924 ><P
 925 >DSR</P
 926 ></DD
 927 ><DT
 928 >Description:</DT
 929 ><DD
 930 ><P
 931 >Re-enables scheduling of DSRs. This function decrements
 932       the counter incremented by
 933       <TT
 934 CLASS="FUNCTION"
 935 >cyg_drv_dsr_lock()</TT
 936 >.  DSRs are only allowed
 937       to be delivered when the counter goes to zero. </P
 938 ></DD
 939 ></DL
 940 ></DIV
 941 ></DIV
 942 ><DIV
 943 CLASS="SECTION"
 944 ><H2
 945 CLASS="SECTION"
 946 ><A
 947 NAME="AEN11625">cyg_drv_mutex_init</H2
 948 ><P
 949 ></P
 950 ><DIV
 951 CLASS="VARIABLELIST"
 952 ><DL
 953 ><DT
 954 >Function:</DT
 955 ><DD
 956 ><TABLE
 957 BORDER="5"
 958 BGCOLOR="#E0E0F0"
 959 WIDTH="70%"
 960 ><TR
 961 ><TD
 962 ><PRE
 963 CLASS="PROGRAMLISTING"
 964 >void cyg_drv_mutex_init(cyg_drv_mutex *mutex)</PRE
 965 ></TD
 966 ></TR
 967 ></TABLE
 968 ></DD
 969 ><DT
 970 >Arguments:</DT
 971 ><DD
 972 ><P
 973 ><TT
 974 CLASS="PARAMETER"
 975 ><I
 976 >mutex</I
 977 ></TT
 978 > - pointer to mutex to initialize</P
 979 ></DD
 980 ><DT
 981 >Result:</DT
 982 ><DD
 983 ><P
 984 >None </P
 985 ></DD
 986 ><DT
 987 >Level:</DT
 988 ><DD
 989 ><P
 990 >Thread</P
 991 ></DD
 992 ><DT
 993 >Description:</DT
 994 ><DD
 995 ><P
 996 >Initialize the mutex pointed to by the
 997       <TT
 998 CLASS="LITERAL"
 999 >mutex</TT
1000 > argument. </P
1001 ></DD
1002 ></DL
1003 ></DIV
1004 ></DIV
1005 ><DIV
1006 CLASS="SECTION"
1007 ><H2
1008 CLASS="SECTION"
1009 ><A
1010 NAME="AEN11650">cyg_drv_mutex_destroy</H2
1011 ><P
1012 ></P
1013 ><DIV
1014 CLASS="VARIABLELIST"
1015 ><DL
1016 ><DT
1017 >Function:</DT
1018 ><DD
1019 ><TABLE
1020 BORDER="5"
1021 BGCOLOR="#E0E0F0"
1022 WIDTH="70%"
1023 ><TR
1024 ><TD
1025 ><PRE
1026 CLASS="PROGRAMLISTING"
1027 >void cyg_drv_mutex_destroy( cyg_drv_mutex *mutex )</PRE
1028 ></TD
1029 ></TR
1030 ></TABLE
1031 ></DD
1032 ><DT
1033 >Arguments:</DT
1034 ><DD
1035 ><P
1036 ><TT
1037 CLASS="PARAMETER"
1038 ><I
1039 >mutex</I
1040 ></TT
1041 > - pointer to mutex to destroy</P
1042 ></DD
1043 ><DT
1044 >Result:</DT
1045 ><DD
1046 ><P
1047 >None </P
1048 ></DD
1049 ><DT
1050 >Level:</DT
1051 ><DD
1052 ><P
1053 >Thread</P
1054 ></DD
1055 ><DT
1056 >Description:</DT
1057 ><DD
1058 ><P
1059 >Destroy the mutex pointed to by the
1060       <TT
1061 CLASS="PARAMETER"
1062 ><I
1063 >mutex</I
1064 ></TT
1065 > argument. The mutex should be unlocked
1066       and there should be no threads waiting to lock it when this call
1067       in made.</P
1068 ></DD
1069 ></DL
1070 ></DIV
1071 ></DIV
1072 ><DIV
1073 CLASS="SECTION"
1074 ><H2
1075 CLASS="SECTION"
1076 ><A
1077 NAME="AEN11675">cyg_drv_mutex_lock</H2
1078 ><P
1079 ></P
1080 ><DIV
1081 CLASS="VARIABLELIST"
1082 ><DL
1083 ><DT
1084 >Function:</DT
1085 ><DD
1086 ><TABLE
1087 BORDER="5"
1088 BGCOLOR="#E0E0F0"
1089 WIDTH="70%"
1090 ><TR
1091 ><TD
1092 ><PRE
1093 CLASS="PROGRAMLISTING"
1094 >cyg_bool cyg_drv_mutex_lock( cyg_drv_mutex *mutex )</PRE
1095 ></TD
1096 ></TR
1097 ></TABLE
1098 ></DD
1099 ><DT
1100 >Arguments:</DT
1101 ><DD
1102 ><P
1103 ><TT
1104 CLASS="PARAMETER"
1105 ><I
1106 >mutex</I
1107 ></TT
1108 > - pointer to mutex to lock</P
1109 ></DD
1110 ><DT
1111 >Result:</DT
1112 ><DD
1113 ><P
1114 ><TT
1115 CLASS="LITERAL"
1116 >TRUE</TT
1117 > it the thread has claimed the
1118       lock, <TT
1119 CLASS="LITERAL"
1120 >FALSE</TT
1121 > otherwise.</P
1122 ></DD
1123 ><DT
1124 >Level:</DT
1125 ><DD
1126 ><P
1127 >Thread</P
1128 ></DD
1129 ><DT
1130 >Description:</DT
1131 ><DD
1132 ><P
1133 >Attempt to lock the mutex pointed to by the
1134       <TT
1135 CLASS="PARAMETER"
1136 ><I
1137 >mutex</I
1138 ></TT
1139 > argument.  If the mutex is already
1140       locked by another thread then this thread will wait until that
1141       thread is finished. If the result from this function is
1142       <TT
1143 CLASS="LITERAL"
1144 >FALSE</TT
1145 > then the thread was broken out of its
1146       wait by some other thread. In this case the mutex will not have
1147       been locked. </P
1148 ></DD
1149 ></DL
1150 ></DIV
1151 ></DIV
1152 ><DIV
1153 CLASS="SECTION"
1154 ><H2
1155 CLASS="SECTION"
1156 ><A
1157 NAME="AEN11703">cyg_drv_mutex_trylock</H2
1158 ><P
1159 ></P
1160 ><DIV
1161 CLASS="VARIABLELIST"
1162 ><DL
1163 ><DT
1164 >Function:</DT
1165 ><DD
1166 ><P
1167 ><TABLE
1168 BORDER="5"
1169 BGCOLOR="#E0E0F0"
1170 WIDTH="70%"
1171 ><TR
1172 ><TD
1173 ><PRE
1174 CLASS="PROGRAMLISTING"
1175 >cyg_bool cyg_drv_mutex_trylock( cyg_drv_mutex *mutex )</PRE
1176 ></TD
1177 ></TR
1178 ></TABLE
1179 ></P
1180 ></DD
1181 ><DT
1182 >Arguments:</DT
1183 ><DD
1184 ><P
1185 ><TT
1186 CLASS="PARAMETER"
1187 ><I
1188 >mutex</I
1189 ></TT
1190 > - pointer to mutex to lock</P
1191 ></DD
1192 ><DT
1193 >Result:</DT
1194 ><DD
1195 ><P
1196 ><TT
1197 CLASS="LITERAL"
1198 >TRUE</TT
1199 > if the mutex has been locked,
1200       <TT
1201 CLASS="LITERAL"
1202 >FALSE</TT
1203 > otherwise. </P
1204 ></DD
1205 ><DT
1206 >Level:</DT
1207 ><DD
1208 ><P
1209 >Thread</P
1210 ></DD
1211 ><DT
1212 >Description:</DT
1213 ><DD
1214 ><P
1215 >Attempt to lock the mutex pointed to by the
1216       <TT
1217 CLASS="PARAMETER"
1218 ><I
1219 >mutex</I
1220 ></TT
1221 > argument without waiting. If the
1222       mutex is already locked by some other thread then this function
1223       returns <TT
1224 CLASS="LITERAL"
1225 >FALSE</TT
1226 >. If the function can lock the
1227       mutex without waiting, then <TT
1228 CLASS="LITERAL"
1229 >TRUE</TT
1230 > is
1231       returned. </P
1232 ></DD
1233 ></DL
1234 ></DIV
1235 ></DIV
1236 ><DIV
1237 CLASS="SECTION"
1238 ><H2
1239 CLASS="SECTION"
1240 ><A
1241 NAME="AEN11733">cyg_drv_mutex_unlock</H2
1242 ><P
1243 ></P
1244 ><DIV
1245 CLASS="VARIABLELIST"
1246 ><DL
1247 ><DT
1248 >Function:</DT
1249 ><DD
1250 ><TABLE
1251 BORDER="5"
1252 BGCOLOR="#E0E0F0"
1253 WIDTH="70%"
1254 ><TR
1255 ><TD
1256 ><PRE
1257 CLASS="PROGRAMLISTING"
1258 >void cyg_drv_mutex_unlock( cyg_drv_mutex *mutex )</PRE
1259 ></TD
1260 ></TR
1261 ></TABLE
1262 ></DD
1263 ><DT
1264 >Arguments:</DT
1265 ><DD
1266 ><P
1267 ><TT
1268 CLASS="PARAMETER"
1269 ><I
1270 >mutex</I
1271 ></TT
1272 > - pointer to mutex to unlock</P
1273 ></DD
1274 ><DT
1275 >Result:</DT
1276 ><DD
1277 ><P
1278 >None </P
1279 ></DD
1280 ><DT
1281 >Level:</DT
1282 ><DD
1283 ><P
1284 >Thread</P
1285 ></DD
1286 ><DT
1287 >Description:</DT
1288 ><DD
1289 ><P
1290 >Unlock the mutex pointed to by the
1291       <TT
1292 CLASS="PARAMETER"
1293 ><I
1294 >mutex</I
1295 ></TT
1296 > argument. If there are any threads
1297       waiting to claim the lock, one of them is woken up to try and
1298       claim it. </P
1299 ></DD
1300 ></DL
1301 ></DIV
1302 ></DIV
1303 ><DIV
1304 CLASS="SECTION"
1305 ><H2
1306 CLASS="SECTION"
1307 ><A
1308 NAME="AEN11758">cyg_drv_mutex_release</H2
1309 ><P
1310 ></P
1311 ><DIV
1312 CLASS="VARIABLELIST"
1313 ><DL
1314 ><DT
1315 >Function:</DT
1316 ><DD
1317 ><TABLE
1318 BORDER="5"
1319 BGCOLOR="#E0E0F0"
1320 WIDTH="70%"
1321 ><TR
1322 ><TD
1323 ><PRE
1324 CLASS="PROGRAMLISTING"
1325 >void cyg_drv_mutex_release( cyg_drv_mutex *mutex )</PRE
1326 ></TD
1327 ></TR
1328 ></TABLE
1329 ></DD
1330 ><DT
1331 >Arguments:</DT
1332 ><DD
1333 ><P
1334 ><TT
1335 CLASS="LITERAL"
1336 >mutex</TT
1337 > - pointer to mutex to release</P
1338 ></DD
1339 ><DT
1340 >Result:</DT
1341 ><DD
1342 ><P
1343 >None </P
1344 ></DD
1345 ><DT
1346 >Level:</DT
1347 ><DD
1348 ><P
1349 >Thread</P
1350 ></DD
1351 ><DT
1352 >Description:</DT
1353 ><DD
1354 ><P
1355 >Release all threads waiting on the mutex pointed to by the
1356       <TT
1357 CLASS="PARAMETER"
1358 ><I
1359 >mutex</I
1360 ></TT
1361 > argument. These threads will return
1362       from <TT
1363 CLASS="FUNCTION"
1364 >cyg_drv_mutex_lock()</TT
1365 > with a
1366       <TT
1367 CLASS="LITERAL"
1368 >FALSE</TT
1369 > result and will not have claimed the
1370       mutex. This function has no effect on any thread that may have
1371       the mutex claimed. </P
1372 ></DD
1373 ></DL
1374 ></DIV
1375 ></DIV
1376 ><DIV
1377 CLASS="SECTION"
1378 ><H2
1379 CLASS="SECTION"
1380 ><A
1381 NAME="AEN11785">cyg_drv_cond_init</H2
1382 ><P
1383 ></P
1384 ><DIV
1385 CLASS="VARIABLELIST"
1386 ><DL
1387 ><DT
1388 >Function:</DT
1389 ><DD
1390 ><TABLE
1391 BORDER="5"
1392 BGCOLOR="#E0E0F0"
1393 WIDTH="70%"
1394 ><TR
1395 ><TD
1396 ><PRE
1397 CLASS="PROGRAMLISTING"
1398 > void cyg_drv_cond_init( cyg_drv_cond *cond, cyg_drv_mutex *mutex )
1399               </PRE
1400 ></TD
1401 ></TR
1402 ></TABLE
1403 ></DD
1404 ><DT
1405 >Arguments:</DT
1406 ><DD
1407 ><P
1408 ><TT
1409 CLASS="PARAMETER"
1410 ><I
1411 >cond</I
1412 ></TT
1413 > - condition variable to initialize</P
1414 ><P
1415 ><TT
1416 CLASS="PARAMETER"
1417 ><I
1418 >mutex</I
1419 ></TT
1420 > - mutex to associate with this condition variable</P
1421 ></DD
1422 ><DT
1423 >Result:</DT
1424 ><DD
1425 ><P
1426 >None</P
1427 ></DD
1428 ><DT
1429 >Level:</DT
1430 ><DD
1431 ><P
1432 >Thread </P
1433 ></DD
1434 ><DT
1435 >Description:</DT
1436 ><DD
1437 ><P
1438 >Initialize the condition variable pointed to by the
1439       <TT
1440 CLASS="PARAMETER"
1441 ><I
1442 >cond</I
1443 ></TT
1444 > argument.  The
1445       <TT
1446 CLASS="PARAMETER"
1447 ><I
1448 >mutex</I
1449 ></TT
1450 > argument must point to a mutex with
1451       which this condition variable is associated. A thread may only
1452       wait on this condition variable when it has already locked the
1453       associated mutex. Waiting will cause the mutex to be unlocked,
1454       and when the thread is reawakened, it will automatically claim
1455       the mutex before continuing. </P
1456 ></DD
1457 ></DL
1458 ></DIV
1459 ></DIV
1460 ><DIV
1461 CLASS="SECTION"
1462 ><H2
1463 CLASS="SECTION"
1464 ><A
1465 NAME="AEN11813">cyg_drv_cond_destroy</H2
1466 ><P
1467 ></P
1468 ><DIV
1469 CLASS="VARIABLELIST"
1470 ><DL
1471 ><DT
1472 >Function:</DT
1473 ><DD
1474 ><TABLE
1475 BORDER="5"
1476 BGCOLOR="#E0E0F0"
1477 WIDTH="70%"
1478 ><TR
1479 ><TD
1480 ><PRE
1481 CLASS="PROGRAMLISTING"
1482 > void cyg_drv_cond_destroy( cyg_drv_cond *cond )</PRE
1483 ></TD
1484 ></TR
1485 ></TABLE
1486 ></DD
1487 ><DT
1488 >Arguments:</DT
1489 ><DD
1490 ><P
1491 ><TT
1492 CLASS="PARAMETER"
1493 ><I
1494 >cond</I
1495 ></TT
1496 > - condition variable to destroy</P
1497 ></DD
1498 ><DT
1499 >Result:</DT
1500 ><DD
1501 ><P
1502 >None </P
1503 ></DD
1504 ><DT
1505 >Level:</DT
1506 ><DD
1507 ><P
1508 >Thread</P
1509 ></DD
1510 ><DT
1511 >Description:</DT
1512 ><DD
1513 ><P
1514 >Destroy the condition variable pointed to by the
1515       <TT
1516 CLASS="PARAMETER"
1517 ><I
1518 >cond</I
1519 ></TT
1520 > argument. </P
1521 ></DD
1522 ></DL
1523 ></DIV
1524 ></DIV
1525 ><DIV
1526 CLASS="SECTION"
1527 ><H2
1528 CLASS="SECTION"
1529 ><A
1530 NAME="AEN11838">cyg_drv_cond_wait</H2
1531 ><P
1532 ></P
1533 ><DIV
1534 CLASS="VARIABLELIST"
1535 ><DL
1536 ><DT
1537 >Function:</DT
1538 ><DD
1539 ><TABLE
1540 BORDER="5"
1541 BGCOLOR="#E0E0F0"
1542 WIDTH="70%"
1543 ><TR
1544 ><TD
1545 ><PRE
1546 CLASS="PROGRAMLISTING"
1547 >void cyg_drv_cond_wait( cyg_drv_cond *cond )</PRE
1548 ></TD
1549 ></TR
1550 ></TABLE
1551 ></DD
1552 ><DT
1553 >Arguments:</DT
1554 ><DD
1555 ><P
1556 ><TT
1557 CLASS="PARAMETER"
1558 ><I
1559 >cond</I
1560 ></TT
1561 > - condition variable to wait on</P
1562 ></DD
1563 ><DT
1564 >Result:</DT
1565 ><DD
1566 ><P
1567 >None </P
1568 ></DD
1569 ><DT
1570 >Level:</DT
1571 ><DD
1572 ><P
1573 >Thread</P
1574 ></DD
1575 ><DT
1576 >Description:</DT
1577 ><DD
1578 ><P
1579 >Wait for a signal on the condition variable pointed to by
1580       the <TT
1581 CLASS="PARAMETER"
1582 ><I
1583 >cond</I
1584 ></TT
1585 > argument. The thread must have
1586       locked the associated mutex, supplied in
1587       <TT
1588 CLASS="FUNCTION"
1589 >cyg_drv_cond_init()</TT
1590 >, before waiting on this
1591       condition variable. While the thread waits, the mutex will be
1592       unlocked, and will be re-locked before this function returns. It
1593       is possible for threads waiting on a condition variable to
1594       occasionally wake up spuriously. For this reason it is necessary
1595       to use this function in a loop that re-tests the condition each
1596       time it returns. Note that this function performs an implicit
1597       scheduler unlock/relock sequence, so that it may be used within
1598       an explicit
1599       <TT
1600 CLASS="LITERAL"
1601 >cyg_drv_dsr_lock()...cyg_drv_dsr_unlock()</TT
1602 >
1603       structure.</P
1604 ></DD
1605 ></DL
1606 ></DIV
1607 ></DIV
1608 ><DIV
1609 CLASS="SECTION"
1610 ><H2
1611 CLASS="SECTION"
1612 ><A
1613 NAME="AEN11865">cyg_drv_cond_signal</H2
1614 ><P
1615 ></P
1616 ><DIV
1617 CLASS="VARIABLELIST"
1618 ><DL
1619 ><DT
1620 >Function:</DT
1621 ><DD
1622 ><TABLE
1623 BORDER="5"
1624 BGCOLOR="#E0E0F0"
1625 WIDTH="70%"
1626 ><TR
1627 ><TD
1628 ><PRE
1629 CLASS="PROGRAMLISTING"
1630 >void cyg_drv_cond_signal( cyg_drv_cond *cond )</PRE
1631 ></TD
1632 ></TR
1633 ></TABLE
1634 ></DD
1635 ><DT
1636 >Arguments:</DT
1637 ><DD
1638 ><P
1639 ><TT
1640 CLASS="PARAMETER"
1641 ><I
1642 >cond</I
1643 ></TT
1644 > - condition variable to signal</P
1645 ></DD
1646 ><DT
1647 >Result:</DT
1648 ><DD
1649 ><P
1650 >None </P
1651 ></DD
1652 ><DT
1653 >Level:</DT
1654 ><DD
1655 ><P
1656 >DSR</P
1657 ></DD
1658 ><DT
1659 >Description:</DT
1660 ><DD
1661 ><P
1662 >Signal the condition variable pointed to by the <TT
1663 CLASS="PARAMETER"
1664 ><I
1665 >cond</I
1666 ></TT
1667 >
1668       argument.  If there are any threads waiting on this variable at
1669       least one of them will be awakened. Note that in some
1670       configurations there may not be any difference between this
1671       function and <TT
1672 CLASS="FUNCTION"
1673 >cyg_drv_cond_broadcast()</TT
1674 >.
1675       </P
1676 ></DD
1677 ></DL
1678 ></DIV
1679 ></DIV
1680 ><DIV
1681 CLASS="SECTION"
1682 ><H2
1683 CLASS="SECTION"
1684 ><A
1685 NAME="AEN11891">cyg_drv_cond_broadcast</H2
1686 ><P
1687 ></P
1688 ><DIV
1689 CLASS="VARIABLELIST"
1690 ><DL
1691 ><DT
1692 >Function:</DT
1693 ><DD
1694 ><TABLE
1695 BORDER="5"
1696 BGCOLOR="#E0E0F0"
1697 WIDTH="70%"
1698 ><TR
1699 ><TD
1700 ><PRE
1701 CLASS="PROGRAMLISTING"
1702 >void cyg_drv_cond_broadcast( cyg_drv_cond *cond )</PRE
1703 ></TD
1704 ></TR
1705 ></TABLE
1706 ></DD
1707 ><DT
1708 >Arguments:</DT
1709 ><DD
1710 ><P
1711 ><TT
1712 CLASS="PARAMETER"
1713 ><I
1714 >cond</I
1715 ></TT
1716 > - condition variable to broadcast to</P
1717 ></DD
1718 ><DT
1719 >Result:</DT
1720 ><DD
1721 ><P
1722 >None </P
1723 ></DD
1724 ><DT
1725 >Level:</DT
1726 ><DD
1727 ><P
1728 >DSR</P
1729 ></DD
1730 ><DT
1731 >Description:</DT
1732 ><DD
1733 ><P
1734 >Signal the condition variable pointed to by the
1735       <TT
1736 CLASS="PARAMETER"
1737 ><I
1738 >cond</I
1739 ></TT
1740 > argument.  If there are any threads
1741       waiting on this variable they will all be awakened. </P
1742 ></DD
1743 ></DL
1744 ></DIV
1745 ></DIV
1746 ><DIV
1747 CLASS="SECTION"
1748 ><H2
1749 CLASS="SECTION"
1750 ><A
1751 NAME="AEN11916">cyg_drv_interrupt_create</H2
1752 ><P
1753 ></P
1754 ><DIV
1755 CLASS="VARIABLELIST"
1756 ><DL
1757 ><DT
1758 >Function:</DT
1759 ><DD
1760 ><TABLE
1761 BORDER="5"
1762 BGCOLOR="#E0E0F0"
1763 WIDTH="70%"
1764 ><TR
1765 ><TD
1766 ><PRE
1767 CLASS="PROGRAMLISTING"
1768 >void cyg_drv_interrupt_create( cyg_vector_t vector,
1769                                cyg_priority_t priority,
1770                                cyg_addrword_t data,
1771                                cyg_ISR_t *isr,
1772                                cyg_DSR_t *dsr,
1773                                cyg_handle_t *handle,
1774                                cyg_interrupt *intr
1775                              )</PRE
1776 ></TD
1777 ></TR
1778 ></TABLE
1779 ></DD
1780 ><DT
1781 >Arguments:</DT
1782 ><DD
1783 ><P
1784 ><TT
1785 CLASS="PARAMETER"
1786 ><I
1787 >vector</I
1788 ></TT
1789 > - vector to attach to</P
1790 ><P
1791 ><TT
1792 CLASS="PARAMETER"
1793 ><I
1794 >priority</I
1795 ></TT
1796 > - queuing priority</P
1797 ><P
1798 ><TT
1799 CLASS="PARAMETER"
1800 ><I
1801 >data</I
1802 ></TT
1803 > - data pointer</P
1804 ><P
1805 ><TT
1806 CLASS="PARAMETER"
1807 ><I
1808 >isr</I
1809 ></TT
1810 > - interrupt service routine</P
1811 ><P
1812 ><TT
1813 CLASS="PARAMETER"
1814 ><I
1815 >dsr</I
1816 ></TT
1817 > - deferred service routine</P
1818 ><P
1819 ><TT
1820 CLASS="PARAMETER"
1821 ><I
1822 >handle</I
1823 ></TT
1824 > - returned handle</P
1825 ><P
1826 ><TT
1827 CLASS="PARAMETER"
1828 ><I
1829 >intr</I
1830 ></TT
1831 > - put interrupt object here</P
1832 ></DD
1833 ><DT
1834 >Result:</DT
1835 ><DD
1836 ><P
1837 >None</P
1838 ></DD
1839 ><DT
1840 >Level:</DT
1841 ><DD
1842 ><P
1843 >Thread</P
1844 ></DD
1845 ><DT
1846 >Description:</DT
1847 ><DD
1848 ><P
1849 >Create an interrupt object and returns a handle to it. The
1850       object contains information about which interrupt vector to use
1851       and the ISR and DSR that will be called after the interrupt
1852       object is attached to the vector. The interrupt object will be
1853       allocated in the memory passed in the
1854       <TT
1855 CLASS="PARAMETER"
1856 ><I
1857 >intr</I
1858 ></TT
1859 > parameter. The interrupt object is
1860       not immediately attached; it must be attached with the
1861       <TT
1862 CLASS="FUNCTION"
1863 >cyg_interrupt_attach()</TT
1864 > call. </P
1865 ></DD
1866 ></DL
1867 ></DIV
1868 ></DIV
1869 ><DIV
1870 CLASS="SECTION"
1871 ><H2
1872 CLASS="SECTION"
1873 ><A
1874 NAME="AEN11954">cyg_drv_interrupt_delete</H2
1875 ><P
1876 ></P
1877 ><DIV
1878 CLASS="VARIABLELIST"
1879 ><DL
1880 ><DT
1881 >Function:</DT
1882 ><DD
1883 ><TABLE
1884 BORDER="5"
1885 BGCOLOR="#E0E0F0"
1886 WIDTH="70%"
1887 ><TR
1888 ><TD
1889 ><PRE
1890 CLASS="PROGRAMLISTING"
1891 > void cyg_drv_interrupt_delete( cyg_handle_t interrupt )</PRE
1892 ></TD
1893 ></TR
1894 ></TABLE
1895 ></DD
1896 ><DT
1897 >Arguments:</DT
1898 ><DD
1899 ><P
1900 ><TT
1901 CLASS="PARAMETER"
1902 ><I
1903 >interrupt</I
1904 ></TT
1905 > - interrupt to delete</P
1906 ></DD
1907 ><DT
1908 >Result:</DT
1909 ><DD
1910 ><P
1911 >None </P
1912 ></DD
1913 ><DT
1914 >Level:</DT
1915 ><DD
1916 ><P
1917 >Thread</P
1918 ></DD
1919 ><DT
1920 >Description:</DT
1921 ><DD
1922 ><P
1923 >Detach the interrupt from the vector and free the memory
1924       passed in the <TT
1925 CLASS="PARAMETER"
1926 ><I
1927 >intr</I
1928 ></TT
1929 > argument to
1930       <TT
1931 CLASS="FUNCTION"
1932 >cyg_drv_interrupt_create()</TT
1933 > for
1934       reuse. </P
1935 ></DD
1936 ></DL
1937 ></DIV
1938 ></DIV
1939 ><DIV
1940 CLASS="SECTION"
1941 ><H2
1942 CLASS="SECTION"
1943 ><A
1944 NAME="AEN11980">cyg_drv_interrupt_attach</H2
1945 ><P
1946 ></P
1947 ><DIV
1948 CLASS="VARIABLELIST"
1949 ><DL
1950 ><DT
1951 >Function:</DT
1952 ><DD
1953 ><TABLE
1954 BORDER="5"
1955 BGCOLOR="#E0E0F0"
1956 WIDTH="70%"
1957 ><TR
1958 ><TD
1959 ><PRE
1960 CLASS="PROGRAMLISTING"
1961 >void cyg_drv_interrupt_attach( cyg_handle_t interrupt )</PRE
1962 ></TD
1963 ></TR
1964 ></TABLE
1965 ></DD
1966 ><DT
1967 >Arguments:</DT
1968 ><DD
1969 ><P
1970 ><TT
1971 CLASS="PARAMETER"
1972 ><I
1973 >interrupt</I
1974 ></TT
1975 > - interrupt to attach</P
1976 ></DD
1977 ><DT
1978 >Result:</DT
1979 ><DD
1980 ><P
1981 >None </P
1982 ></DD
1983 ><DT
1984 >Level:</DT
1985 ><DD
1986 ><P
1987 >ISR</P
1988 ></DD
1989 ><DT
1990 >Description:</DT
1991 ><DD
1992 ><P
1993 >Attach the interrupt to the vector so that interrupts will
1994       be delivered to the ISR when the interrupt occurs. </P
1995 ></DD
1996 ></DL
1997 ></DIV
1998 ></DIV
1999 ><DIV
2000 CLASS="SECTION"
2001 ><H2
2002 CLASS="SECTION"
2003 ><A
2004 NAME="AEN12004">cyg_drv_interrupt_detach</H2
2005 ><P
2006 ></P
2007 ><DIV
2008 CLASS="VARIABLELIST"
2009 ><DL
2010 ><DT
2011 >Function:</DT
2012 ><DD
2013 ><TABLE
2014 BORDER="5"
2015 BGCOLOR="#E0E0F0"
2016 WIDTH="70%"
2017 ><TR
2018 ><TD
2019 ><PRE
2020 CLASS="PROGRAMLISTING"
2021 >void cyg_drv_interrupt_detach( cyg_handle_t interrupt )</PRE
2022 ></TD
2023 ></TR
2024 ></TABLE
2025 ></DD
2026 ><DT
2027 >Arguments:</DT
2028 ><DD
2029 ><P
2030 ><TT
2031 CLASS="PARAMETER"
2032 ><I
2033 >interrupt</I
2034 ></TT
2035 > - interrupt to detach</P
2036 ></DD
2037 ><DT
2038 >Result:</DT
2039 ><DD
2040 ><P
2041 >None </P
2042 ></DD
2043 ><DT
2044 >Level:</DT
2045 ><DD
2046 ><P
2047 >ISR</P
2048 ></DD
2049 ><DT
2050 >Description:</DT
2051 ><DD
2052 ><P
2053 >Detach the interrupt from the vector so that interrupts
2054       will no longer be delivered to the ISR. </P
2055 ></DD
2056 ></DL
2057 ></DIV
2058 ></DIV
2059 ><DIV
2060 CLASS="SECTION"
2061 ><H2
2062 CLASS="SECTION"
2063 ><A
2064 NAME="AEN12028">cyg_drv_interrupt_mask</H2
2065 ><P
2066 ></P
2067 ><DIV
2068 CLASS="VARIABLELIST"
2069 ><DL
2070 ><DT
2071 >Function:</DT
2072 ><DD
2073 ><TABLE
2074 BORDER="5"
2075 BGCOLOR="#E0E0F0"
2076 WIDTH="70%"
2077 ><TR
2078 ><TD
2079 ><PRE
2080 CLASS="PROGRAMLISTING"
2081 >void cyg_drv_interrupt_mask(cyg_vector_t vector )</PRE
2082 ></TD
2083 ></TR
2084 ></TABLE
2085 ></DD
2086 ><DT
2087 >Arguments:</DT
2088 ><DD
2089 ><P
2090 ><TT
2091 CLASS="PARAMETER"
2092 ><I
2093 >vector</I
2094 ></TT
2095 > - vector to mask</P
2096 ></DD
2097 ><DT
2098 >Result:</DT
2099 ><DD
2100 ><P
2101 >None </P
2102 ></DD
2103 ><DT
2104 >Level:</DT
2105 ><DD
2106 ><P
2107 >ISR</P
2108 ></DD
2109 ><DT
2110 >Description:</DT
2111 ><DD
2112 ><P
2113 >Program the interrupt controller to stop delivery of
2114       interrupts on the given vector. On architectures which implement
2115       interrupt priority levels this may also disable all lower
2116       priority interrupts. </P
2117 ></DD
2118 ></DL
2119 ></DIV
2120 ></DIV
2121 ><DIV
2122 CLASS="SECTION"
2123 ><H2
2124 CLASS="SECTION"
2125 ><A
2126 NAME="AEN12052">cyg_drv_interrupt_mask_intunsafe</H2
2127 ><P
2128 ></P
2129 ><DIV
2130 CLASS="VARIABLELIST"
2131 ><DL
2132 ><DT
2133 >Function:</DT
2134 ><DD
2135 ><TABLE
2136 BORDER="5"
2137 BGCOLOR="#E0E0F0"
2138 WIDTH="70%"
2139 ><TR
2140 ><TD
2141 ><PRE
2142 CLASS="PROGRAMLISTING"
2143 >void cyg_drv_interrupt_mask_intunsafe(cyg_vector_t vector )</PRE
2144 ></TD
2145 ></TR
2146 ></TABLE
2147 ></DD
2148 ><DT
2149 >Arguments:</DT
2150 ><DD
2151 ><P
2152 ><TT
2153 CLASS="PARAMETER"
2154 ><I
2155 >vector</I
2156 ></TT
2157 > - vector to mask</P
2158 ></DD
2159 ><DT
2160 >Result:</DT
2161 ><DD
2162 ><P
2163 >None </P
2164 ></DD
2165 ><DT
2166 >Level:</DT
2167 ><DD
2168 ><P
2169 >ISR</P
2170 ></DD
2171 ><DT
2172 >Description:</DT
2173 ><DD
2174 ><P
2175 >Program the interrupt controller to stop delivery of
2176       interrupts on the given vector. On architectures which implement
2177       interrupt priority levels this may also disable all lower
2178       priority interrupts. This version differs from
2179       <TT
2180 CLASS="FUNCTION"
2181 >cyg_drv_interrupt_mask()</TT
2182 > in not being
2183       interrupt safe. So in situations where, for example, interrupts
2184       are already known to be disabled, this may be called to avoid
2185       the extra overhead.</P
2186 ></DD
2187 ></DL
2188 ></DIV
2189 ></DIV
2190 ><DIV
2191 CLASS="SECTION"
2192 ><H2
2193 CLASS="SECTION"
2194 ><A
2195 NAME="AEN12077">cyg_drv_interrupt_unmask</H2
2196 ><P
2197 ></P
2198 ><DIV
2199 CLASS="VARIABLELIST"
2200 ><DL
2201 ><DT
2202 >Function:</DT
2203 ><DD
2204 ><TABLE
2205 BORDER="5"
2206 BGCOLOR="#E0E0F0"
2207 WIDTH="70%"
2208 ><TR
2209 ><TD
2210 ><PRE
2211 CLASS="PROGRAMLISTING"
2212 >void cyg_drv_interrupt_unmask(cyg_vector_t vector )</PRE
2213 ></TD
2214 ></TR
2215 ></TABLE
2216 ></DD
2217 ><DT
2218 >Arguments:</DT
2219 ><DD
2220 ><P
2221 ><TT
2222 CLASS="PARAMETER"
2223 ><I
2224 >vector</I
2225 ></TT
2226 > - vector to unmask</P
2227 ></DD
2228 ><DT
2229 >Result:</DT
2230 ><DD
2231 ><P
2232 >None </P
2233 ></DD
2234 ><DT
2235 >Level:</DT
2236 ><DD
2237 ><P
2238 >ISR</P
2239 ></DD
2240 ><DT
2241 >Description:</DT
2242 ><DD
2243 ><P
2244 >Program the interrupt controller to re-allow delivery of
2245       interrupts on the given <TT
2246 CLASS="PARAMETER"
2247 ><I
2248 >vector</I
2249 ></TT
2250 >. </P
2251 ></DD
2252 ></DL
2253 ></DIV
2254 ></DIV
2255 ><DIV
2256 CLASS="SECTION"
2257 ><H2
2258 CLASS="SECTION"
2259 ><A
2260 NAME="AEN12102">cyg_drv_interrupt_unmask_intunsafe</H2
2261 ><P
2262 ></P
2263 ><DIV
2264 CLASS="VARIABLELIST"
2265 ><DL
2266 ><DT
2267 >Function:</DT
2268 ><DD
2269 ><TABLE
2270 BORDER="5"
2271 BGCOLOR="#E0E0F0"
2272 WIDTH="70%"
2273 ><TR
2274 ><TD
2275 ><PRE
2276 CLASS="PROGRAMLISTING"
2277 >void cyg_drv_interrupt_unmask_intunsafe(cyg_vector_t vector )</PRE
2278 ></TD
2279 ></TR
2280 ></TABLE
2281 ></DD
2282 ><DT
2283 >Arguments:</DT
2284 ><DD
2285 ><P
2286 ><TT
2287 CLASS="PARAMETER"
2288 ><I
2289 >vector</I
2290 ></TT
2291 > - vector to unmask</P
2292 ></DD
2293 ><DT
2294 >Result:</DT
2295 ><DD
2296 ><P
2297 >None </P
2298 ></DD
2299 ><DT
2300 >Level:</DT
2301 ><DD
2302 ><P
2303 >ISR</P
2304 ></DD
2305 ><DT
2306 >Description:</DT
2307 ><DD
2308 ><P
2309 >Program the interrupt controller to re-allow delivery of
2310       interrupts on the given <TT
2311 CLASS="PARAMETER"
2312 ><I
2313 >vector</I
2314 ></TT
2315 >. This
2316       version differs from
2317       <TT
2318 CLASS="FUNCTION"
2319 >cyg_drv_interrupt_unmask()</TT
2320 > in not being
2321       interrupt safe.</P
2322 ></DD
2323 ></DL
2324 ></DIV
2325 ></DIV
2326 ><DIV
2327 CLASS="SECTION"
2328 ><H2
2329 CLASS="SECTION"
2330 ><A
2331 NAME="AEN12128">cyg_drv_interrupt_acknowledge</H2
2332 ><P
2333 ></P
2334 ><DIV
2335 CLASS="VARIABLELIST"
2336 ><DL
2337 ><DT
2338 >Function:</DT
2339 ><DD
2340 ><TABLE
2341 BORDER="5"
2342 BGCOLOR="#E0E0F0"
2343 WIDTH="70%"
2344 ><TR
2345 ><TD
2346 ><PRE
2347 CLASS="PROGRAMLISTING"
2348 >void cyg_drv_interrupt_acknowledge( cyg_vector_t vector )</PRE
2349 ></TD
2350 ></TR
2351 ></TABLE
2352 ></DD
2353 ><DT
2354 >Arguments:</DT
2355 ><DD
2356 ><P
2357 ><TT
2358 CLASS="PARAMETER"
2359 ><I
2360 >vector</I
2361 ></TT
2362 > - vector to acknowledge</P
2363 ></DD
2364 ><DT
2365 >Result:</DT
2366 ><DD
2367 ><P
2368 >None </P
2369 ></DD
2370 ><DT
2371 >Level:</DT
2372 ><DD
2373 ><P
2374 >ISR</P
2375 ></DD
2376 ><DT
2377 >Description:</DT
2378 ><DD
2379 ><P
2380 >Perform any processing required at the interrupt
2381       controller and in the CPU to cancel the current interrupt
2382       request on the <TT
2383 CLASS="PARAMETER"
2384 ><I
2385 >vector</I
2386 ></TT
2387 >. An ISR may also
2388       need to program the hardware of the device to prevent an
2389       immediate re-triggering of the interrupt. </P
2390 ></DD
2391 ></DL
2392 ></DIV
2393 ></DIV
2394 ><DIV
2395 CLASS="SECTION"
2396 ><H2
2397 CLASS="SECTION"
2398 ><A
2399 NAME="AEN12153">cyg_drv_interrupt_configure</H2
2400 ><P
2401 ></P
2402 ><DIV
2403 CLASS="VARIABLELIST"
2404 ><DL
2405 ><DT
2406 >Function:</DT
2407 ><DD
2408 ><TABLE
2409 BORDER="5"
2410 BGCOLOR="#E0E0F0"
2411 WIDTH="70%"
2412 ><TR
2413 ><TD
2414 ><PRE
2415 CLASS="PROGRAMLISTING"
2416 >void cyg_drv_interrupt_configure( cyg_vector_t vector,
2417                                   cyg_bool_t level,
2418                                   cyg_bool_t up
2419                                 )</PRE
2420 ></TD
2421 ></TR
2422 ></TABLE
2423 ></DD
2424 ><DT
2425 >Arguments:</DT
2426 ><DD
2427 ><P
2428 ><TT
2429 CLASS="PARAMETER"
2430 ><I
2431 >vector</I
2432 ></TT
2433 > - vector to configure</P
2434 ><P
2435 ><TT
2436 CLASS="PARAMETER"
2437 ><I
2438 >level</I
2439 ></TT
2440 > - level or edge triggered</P
2441 ><P
2442 ><TT
2443 CLASS="PARAMETER"
2444 ><I
2445 >up</I
2446 ></TT
2447 > - rising/falling edge, high/low level</P
2448 ></DD
2449 ><DT
2450 >Result:</DT
2451 ><DD
2452 ><P
2453 >None</P
2454 ></DD
2455 ><DT
2456 >Level:</DT
2457 ><DD
2458 ><P
2459 >ISR</P
2460 ></DD
2461 ><DT
2462 >Description:</DT
2463 ><DD
2464 ><P
2465 >Program the interrupt controller with the characteristics
2466       of the interrupt source. The <TT
2467 CLASS="PARAMETER"
2468 ><I
2469 >level</I
2470 ></TT
2471 >
2472       argument chooses between level- or edge-triggered
2473       interrupts. The <TT
2474 CLASS="PARAMETER"
2475 ><I
2476 >up</I
2477 ></TT
2478 > argument chooses
2479       between high and low level for level triggered interrupts or
2480       rising and falling edges for edge triggered interrupts. This
2481       function only works with interrupt controllers that can control
2482       these parameters. </P
2483 ></DD
2484 ></DL
2485 ></DIV
2486 ></DIV
2487 ><DIV
2488 CLASS="SECTION"
2489 ><H2
2490 CLASS="SECTION"
2491 ><A
2492 NAME="AEN12183">cyg_drv_interrupt_level</H2
2493 ><P
2494 ></P
2495 ><DIV
2496 CLASS="VARIABLELIST"
2497 ><DL
2498 ><DT
2499 >Function:</DT
2500 ><DD
2501 ><TABLE
2502 BORDER="5"
2503 BGCOLOR="#E0E0F0"
2504 WIDTH="70%"
2505 ><TR
2506 ><TD
2507 ><PRE
2508 CLASS="PROGRAMLISTING"
2509 >void cyg_drv_interrupt_level( cyg_vector_t vector,
2510                               cyg_priority_t level
2511                             )</PRE
2512 ></TD
2513 ></TR
2514 ></TABLE
2515 ></DD
2516 ><DT
2517 >Arguments:</DT
2518 ><DD
2519 ><P
2520 ><TT
2521 CLASS="PARAMETER"
2522 ><I
2523 >vector</I
2524 ></TT
2525 > - vector to configure</P
2526 ><P
2527 ><TT
2528 CLASS="PARAMETER"
2529 ><I
2530 >level</I
2531 ></TT
2532 > - level to set</P
2533 ></DD
2534 ><DT
2535 >Result:</DT
2536 ><DD
2537 ><P
2538 >None </P
2539 ></DD
2540 ><DT
2541 >Level:</DT
2542 ><DD
2543 ><P
2544 >ISR</P
2545 ></DD
2546 ><DT
2547 >Description:</DT
2548 ><DD
2549 ><P
2550 >Program the interrupt controller to deliver the given
2551        interrupt at the supplied priority level. This function only
2552        works with interrupt controllers that can control this
2553        parameter.</P
2554 ></DD
2555 ></DL
2556 ></DIV
2557 ></DIV
2558 ><DIV
2559 CLASS="SECTION"
2560 ><H2
2561 CLASS="SECTION"
2562 ><A
2563 NAME="AEN12209">cyg_drv_interrupt_set_cpu</H2
2564 ><P
2565 ></P
2566 ><DIV
2567 CLASS="VARIABLELIST"
2568 ><DL
2569 ><DT
2570 >Function:</DT
2571 ><DD
2572 ><TABLE
2573 BORDER="5"
2574 BGCOLOR="#E0E0F0"
2575 WIDTH="70%"
2576 ><TR
2577 ><TD
2578 ><PRE
2579 CLASS="PROGRAMLISTING"
2580 >void cyg_drv_interrupt_set_cpu( cyg_vector_t vector,
2581                                 cyg_cpu_t cpu
2582                               )</PRE
2583 ></TD
2584 ></TR
2585 ></TABLE
2586 ></DD
2587 ><DT
2588 >Arguments:</DT
2589 ><DD
2590 ><P
2591 ><TT
2592 CLASS="PARAMETER"
2593 ><I
2594 >vector</I
2595 ></TT
2596 > - interrupt vector to route</P
2597 ><P
2598 ><TT
2599 CLASS="PARAMETER"
2600 ><I
2601 >cpu</I
2602 ></TT
2603 > - destination CPU</P
2604 ></DD
2605 ><DT
2606 >Result:</DT
2607 ><DD
2608 ><P
2609 >None</P
2610 ></DD
2611 ><DT
2612 >Level:</DT
2613 ><DD
2614 ><P
2615 >ISR</P
2616 ></DD
2617 ><DT
2618 >Description:</DT
2619 ><DD
2620 ><P
2621 >      This function causes all interrupts on the given vector to be
2622       routed to the specified CPU. Subsequently, all such interrupts
2623       will be handled by that CPU. This only works if the underlying
2624       hardware is capable of performing this kind of routing. This
2625       function does nothing on a single CPU system.
2626       </P
2627 ></DD
2628 ></DL
2629 ></DIV
2630 ></DIV
2631 ><DIV
2632 CLASS="SECTION"
2633 ><H2
2634 CLASS="SECTION"
2635 ><A
2636 NAME="AEN12235">cyg_drv_interrupt_get_cpu</H2
2637 ><P
2638 ></P
2639 ><DIV
2640 CLASS="VARIABLELIST"
2641 ><DL
2642 ><DT
2643 >Function:</DT
2644 ><DD
2645 ><TABLE
2646 BORDER="5"
2647 BGCOLOR="#E0E0F0"
2648 WIDTH="70%"
2649 ><TR
2650 ><TD
2651 ><PRE
2652 CLASS="PROGRAMLISTING"
2653 >cyg_cpu_t cyg_drv_interrupt_set_cpu( cyg_vector_t vector )</PRE
2654 ></TD
2655 ></TR
2656 ></TABLE
2657 ></DD
2658 ><DT
2659 >Arguments:</DT
2660 ><DD
2661 ><P
2662 ><TT
2663 CLASS="PARAMETER"
2664 ><I
2665 >vector</I
2666 ></TT
2667 > - interrupt vector to query</P
2668 ></DD
2669 ><DT
2670 >Result:</DT
2671 ><DD
2672 ><P
2673 >The CPU to which this vector is routed</P
2674 ></DD
2675 ><DT
2676 >Level:</DT
2677 ><DD
2678 ><P
2679 >ISR</P
2680 ></DD
2681 ><DT
2682 >Description:</DT
2683 ><DD
2684 ><P
2685 >      In multi-processor systems this function returns the id of the
2686       CPU to which interrupts on the given vector are current being
2687       delivered. In single CPU systems this function returns zero.
2688       </P
2689 ></DD
2690 ></DL
2691 ></DIV
2692 ></DIV
2693 ><DIV
2694 CLASS="SECTION"
2695 ><H2
2696 CLASS="SECTION"
2697 ><A
2698 NAME="AEN12259">cyg_ISR_t</H2
2699 ><P
2700 ></P
2701 ><DIV
2702 CLASS="VARIABLELIST"
2703 ><DL
2704 ><DT
2705 >Type:</DT
2706 ><DD
2707 ><TABLE
2708 BORDER="5"
2709 BGCOLOR="#E0E0F0"
2710 WIDTH="70%"
2711 ><TR
2712 ><TD
2713 ><PRE
2714 CLASS="PROGRAMLISTING"
2715 >typedef cyg_uint32 cyg_ISR_t( cyg_vector_t vector,
2716                               cyg_addrword_t data
2717                             )</PRE
2718 ></TD
2719 ></TR
2720 ></TABLE
2721 ></DD
2722 ><DT
2723 >Fields:</DT
2724 ><DD
2725 ><P
2726 ><TT
2727 CLASS="PARAMETER"
2728 ><I
2729 >vector</I
2730 ></TT
2731 > - vector being delivered</P
2732 ><P
2733 ><TT
2734 CLASS="PARAMETER"
2735 ><I
2736 >data</I
2737 ></TT
2738 > - data value supplied by client</P
2739 ></DD
2740 ><DT
2741 >Result:</DT
2742 ><DD
2743 ><P
2744 >Bit mask indicating whether interrupt was handled and
2745       whether the DSR should be called. </P
2746 ></DD
2747 ><DT
2748 >Description:</DT
2749 ><DD
2750 ><P
2751 >Interrupt Service Routine definition. A pointer to a
2752       function with this prototype is passed to
2753       <TT
2754 CLASS="FUNCTION"
2755 >cyg_interrupt_create()</TT
2756 > when an interrupt
2757       object is created. When an interrupt is delivered the function
2758       will be called with the vector number and the data value that
2759       was passed to <TT
2760 CLASS="FUNCTION"
2761 >cyg_interrupt_create()</TT
2762 >.
2763       </P
2764 ><P
2765 >The return value is a bit mask containing one or both of the
2766       following bits: </P
2767 ><P
2768 ></P
2769 ><DIV
2770 CLASS="VARIABLELIST"
2771 ><DL
2772 ><DT
2773 >CYG_ISR_HANDLED</DT
2774 ><DD
2775 ><P
2776 >indicates that the interrupt was handled by this
2777             ISR. It is a configuration option whether this will
2778             prevent further ISR being run. </P
2779 ></DD
2780 ><DT
2781 >CYG_ISR_CALL_DSR</DT
2782 ><DD
2783 ><P
2784 >causes the DSR that was passed to
2785             <TT
2786 CLASS="FUNCTION"
2787 >cyg_interrupt_create()</TT
2788 > to be
2789             scheduled to be called.</P
2790 ></DD
2791 ></DL
2792 ></DIV
2793 ></DD
2794 ></DL
2795 ></DIV
2796 ></DIV
2797 ><DIV
2798 CLASS="SECTION"
2799 ><H2
2800 CLASS="SECTION"
2801 ><A
2802 NAME="AEN12294">cyg_DSR_t</H2
2803 ><P
2804 ></P
2805 ><DIV
2806 CLASS="VARIABLELIST"
2807 ><DL
2808 ><DT
2809 >Type:</DT
2810 ><DD
2811 ><TABLE
2812 BORDER="5"
2813 BGCOLOR="#E0E0F0"
2814 WIDTH="70%"
2815 ><TR
2816 ><TD
2817 ><PRE
2818 CLASS="PROGRAMLISTING"
2819 >typedef void cyg_DSR_t( cyg_vector_t vector,
2820                         cyg_ucount32 count,
2821                         cyg_addrword_t data
2822                       )</PRE
2823 ></TD
2824 ></TR
2825 ></TABLE
2826 ></DD
2827 ><DT
2828 >Fields:</DT
2829 ><DD
2830 ><P
2831 ><TT
2832 CLASS="PARAMETER"
2833 ><I
2834 >vector</I
2835 ></TT
2836 > - vector being delivered</P
2837 ><P
2838 ><TT
2839 CLASS="PARAMETER"
2840 ><I
2841 >count</I
2842 ></TT
2843 > - number of times DSR has been scheduled</P
2844 ><P
2845 ><TT
2846 CLASS="PARAMETER"
2847 ><I
2848 >data</I
2849 ></TT
2850 > - data value supplied by client</P
2851 ></DD
2852 ><DT
2853 >Result:</DT
2854 ><DD
2855 ><P
2856 >None</P
2857 ></DD
2858 ><DT
2859 >Description:</DT
2860 ><DD
2861 ><P
2862 >Deferred Service Routine prototype. A pointer to a
2863       function with this prototype is passed to
2864       <TT
2865 CLASS="FUNCTION"
2866 >cyg_interrupt_create()</TT
2867 > when an interrupt
2868       object is created. When the ISR requests the scheduling of its
2869       DSR, this function will be called at some later point. In
2870       addition to the <TT
2871 CLASS="PARAMETER"
2872 ><I
2873 >vector</I
2874 ></TT
2875 > and
2876       <TT
2877 CLASS="PARAMETER"
2878 ><I
2879 >data</I
2880 ></TT
2881 > arguments, which will be the same as
2882       those passed to the ISR, this routine is also passed a
2883       <TT
2884 CLASS="PARAMETER"
2885 ><I
2886 >count</I
2887 ></TT
2888 > of the number of times the ISR has
2889       requested that this DSR be scheduled.  This counter is zeroed
2890       each time the DSR actually runs, so it indicates how many
2891       interrupts have occurred since it last ran.</P
2892 ></DD
2893 ></DL
2894 ></DIV
2895 ></DIV
2896 ></DIV
2897 ><DIV
2898 CLASS="NAVFOOTER"
2899 ><HR
2900 ALIGN="LEFT"
2901 WIDTH="100%"><TABLE
2902 SUMMARY="Footer navigation table"
2903 WIDTH="100%"
2904 BORDER="0"
2905 CELLPADDING="0"
2906 CELLSPACING="0"
2907 ><TR
2908 ><TD
2909 WIDTH="33%"
2910 ALIGN="left"
2911 VALIGN="top"
2912 ><A
2913 HREF="devapi-synchronization-levels.html"
2914 ACCESSKEY="P"
2915 >Prev</A
2916 ></TD
2917 ><TD
2918 WIDTH="34%"
2919 ALIGN="center"
2920 VALIGN="top"
2921 ><A
2922 HREF="ecos-ref.html"
2923 ACCESSKEY="H"
2924 >Home</A
2925 ></TD
2926 ><TD
2927 WIDTH="33%"
2928 ALIGN="right"
2929 VALIGN="top"
2930 ><A
2931 HREF="fileio.html"
2932 ACCESSKEY="N"
2933 >Next</A
2934 ></TD
2935 ></TR
2936 ><TR
2937 ><TD
2938 WIDTH="33%"
2939 ALIGN="left"
2940 VALIGN="top"
2941 >Synchronization Levels</TD
2942 ><TD
2943 WIDTH="34%"
2944 ALIGN="center"
2945 VALIGN="top"
2946 ><A
2947 HREF="devapi-device-driver-interface-to-the-kernel.html"
2948 ACCESSKEY="U"
2949 >Up</A
2950 ></TD
2951 ><TD
2952 WIDTH="33%"
2953 ALIGN="right"
2954 VALIGN="top"
2955 >File System Support Infrastructure</TD
2956 ></TR
2957 ></TABLE
2958 ></DIV
2959 ></BODY
2960 ></HTML
2961 >