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.