OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [doc/] [html/] [ref/] [devapi-api.html] - Blame information for rev 588

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 28 unneback 
<!-- 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 
>

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.