|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- I N T E R F A C E S . V X W O R K S --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
131
|
9 -- Copyright (C) 1999-2018, AdaCore --
|
|
111
|
10 -- --
|
|
|
11 -- GNAT is free software; you can redistribute it and/or modify it under --
|
|
|
12 -- terms of the GNU General Public License as published by the Free Soft- --
|
|
|
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
|
|
|
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
|
|
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
|
|
16 -- or FITNESS FOR A PARTICULAR PURPOSE. --
|
|
|
17 -- --
|
|
|
18 -- As a special exception under Section 7 of GPL version 3, you are granted --
|
|
|
19 -- additional permissions described in the GCC Runtime Library Exception, --
|
|
|
20 -- version 3.1, as published by the Free Software Foundation. --
|
|
|
21 -- --
|
|
|
22 -- You should have received a copy of the GNU General Public License and --
|
|
|
23 -- a copy of the GCC Runtime Library Exception along with this program; --
|
|
|
24 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
|
|
|
25 -- <http://www.gnu.org/licenses/>. --
|
|
|
26 -- --
|
|
|
27 -- GNARL was developed by the GNARL team at Florida State University. --
|
|
|
28 -- Extensive contributions were provided by Ada Core Technologies, Inc. --
|
|
|
29 -- --
|
|
|
30 ------------------------------------------------------------------------------
|
|
|
31
|
|
|
32 -- This is the x86 VxWorks version of this package
|
|
|
33
|
|
|
34 -- This package provides a limited binding to the VxWorks API
|
|
|
35 -- In particular, it interfaces with the VxWorks hardware interrupt
|
|
|
36 -- facilities, allowing the use of low-latency direct-vectored
|
|
|
37 -- interrupt handlers. Note that such handlers have a variety of
|
|
|
38 -- restrictions regarding system calls and language constructs. In particular,
|
|
|
39 -- the use of exception handlers and functions returning variable-length
|
|
|
40 -- objects cannot be used. Less restrictive, but higher-latency handlers can
|
|
|
41 -- be written using Ada protected procedures, Ada 83 style interrupt entries,
|
|
|
42 -- or by signalling an Ada task from within an interrupt handler using a
|
|
|
43 -- binary semaphore as described in the VxWorks Programmer's Manual.
|
|
|
44 --
|
|
|
45 -- For complete documentation of the operations in this package, please
|
|
|
46 -- consult the VxWorks Programmer's Manual and VxWorks Reference Manual.
|
|
|
47
|
|
|
48 pragma Warnings (Off, "*foreign convention*");
|
|
|
49 pragma Warnings (Off, "*add Convention pragma*");
|
|
|
50
|
|
|
51 with System.VxWorks;
|
|
|
52
|
|
|
53 package Interfaces.VxWorks is
|
|
|
54 pragma Preelaborate;
|
|
|
55
|
|
|
56 ------------------------------------------------------------------------
|
|
|
57 -- Here is a complete example that shows how to handle the Interrupt 0x33
|
|
|
58 -- with a direct-vectored interrupt handler in Ada using this package:
|
|
|
59
|
|
|
60 -- with Interfaces.VxWorks; use Interfaces.VxWorks;
|
|
|
61 -- with System;
|
|
|
62 --
|
|
|
63 -- package P is
|
|
|
64 --
|
|
|
65 -- Count : Integer;
|
|
|
66 -- pragma Atomic (Count);
|
|
|
67 --
|
|
|
68 -- procedure Handler (Parameter : System.Address);
|
|
|
69 --
|
|
|
70 -- end P;
|
|
|
71 --
|
|
|
72 -- package body P is
|
|
|
73 --
|
|
|
74 -- procedure Handler (Parameter : System.Address) is
|
|
|
75 -- begin
|
|
|
76 -- Count := Count + 1;
|
|
|
77 -- logMsg ("received an interrupt" & ASCII.LF & ASCII.NUL);
|
|
|
78 -- end Handler;
|
|
|
79 -- end P;
|
|
|
80 --
|
|
|
81 -- with Interfaces.VxWorks; use Interfaces.VxWorks;
|
|
|
82 -- with Ada.Text_IO; use Ada.Text_IO;
|
|
|
83 -- with Ada.Interrupts;
|
|
|
84 -- with Machine_Code; use Machine_Code;
|
|
|
85 --
|
|
|
86 -- with P; use P;
|
|
|
87 -- procedure Useint is
|
|
|
88 --
|
|
|
89 -- -- Be sure to use a reasonable interrupt number for target board.
|
|
|
90 -- -- This one is an unreserved interrupt for the Pentium 3 BSP
|
|
|
91 --
|
|
|
92 -- Interrupt : constant := 16#33#;
|
|
|
93 --
|
|
|
94 -- task T;
|
|
|
95 --
|
|
|
96 -- S : STATUS;
|
|
|
97 --
|
|
|
98 -- task body T is
|
|
|
99 -- begin
|
|
|
100 -- loop
|
|
|
101 -- Put_Line ("Generating an interrupt...");
|
|
|
102 -- delay 1.0;
|
|
|
103 --
|
|
|
104 -- -- Generate interrupt, using interrupt number
|
|
|
105 --
|
|
|
106 -- Asm ("int %0",
|
|
|
107 -- Inputs =>
|
|
|
108 -- Ada.Interrupts.Interrupt_ID'Asm_Input
|
|
|
109 -- ("i", Interrupt));
|
|
|
110 -- end loop;
|
|
|
111 -- end T;
|
|
|
112 --
|
|
|
113 -- begin
|
|
|
114 -- S := intConnect (INUM_TO_IVEC (Interrupt), Handler'Access);
|
|
|
115 --
|
|
|
116 -- loop
|
|
|
117 -- delay 2.0;
|
|
|
118 -- Put_Line ("value of count:" & P.Count'Img);
|
|
|
119 -- end loop;
|
|
|
120 -- end Useint;
|
|
|
121 -------------------------------------
|
|
|
122
|
|
|
123 subtype int is Integer;
|
|
|
124
|
|
|
125 type STATUS is new int;
|
|
|
126 -- Equivalent of the C type STATUS
|
|
|
127
|
|
|
128 OK : constant STATUS := 0;
|
|
|
129 ERROR : constant STATUS := -1;
|
|
|
130
|
|
|
131 type VOIDFUNCPTR is access procedure (parameter : System.Address);
|
|
|
132 type Interrupt_Vector is new System.Address;
|
|
|
133 type Exception_Vector is new System.Address;
|
|
|
134
|
|
|
135 function intConnect
|
|
|
136 (vector : Interrupt_Vector;
|
|
|
137 handler : VOIDFUNCPTR;
|
|
|
138 parameter : System.Address := System.Null_Address) return STATUS;
|
|
|
139 -- Binding to the C routine intConnect. Use this to set up an user handler.
|
|
|
140 -- The routine generates a wrapper around the user handler to save and
|
|
|
141 -- restore context
|
|
|
142
|
|
|
143 function intContext return int;
|
|
|
144 -- Binding to the C routine intContext. This function returns 1 only if the
|
|
|
145 -- current execution state is in interrupt context.
|
|
|
146
|
|
|
147 function intVecGet
|
|
|
148 (Vector : Interrupt_Vector) return VOIDFUNCPTR;
|
|
|
149 -- Binding to the C routine intVecGet. Use this to get the existing handler
|
|
|
150 -- for later restoral
|
|
|
151
|
|
|
152 procedure intVecSet
|
|
|
153 (Vector : Interrupt_Vector;
|
|
|
154 Handler : VOIDFUNCPTR);
|
|
|
155 -- Binding to the C routine intVecSet. Use this to restore a handler
|
|
|
156 -- obtained using intVecGet
|
|
|
157
|
|
|
158 procedure intVecGet2
|
|
|
159 (vector : Interrupt_Vector;
|
|
|
160 pFunction : out VOIDFUNCPTR;
|
|
|
161 pIdtGate : not null access int;
|
|
|
162 pIdtSelector : not null access int);
|
|
|
163 -- Binding to the C routine intVecGet2. Use this to get the existing
|
|
|
164 -- handler for later restoral
|
|
|
165
|
|
|
166 procedure intVecSet2
|
|
|
167 (vector : Interrupt_Vector;
|
|
|
168 pFunction : VOIDFUNCPTR;
|
|
|
169 pIdtGate : not null access int;
|
|
|
170 pIdtSelector : not null access int);
|
|
|
171 -- Binding to the C routine intVecSet2. Use this to restore a
|
|
|
172 -- handler obtained using intVecGet2
|
|
|
173
|
|
|
174 function INUM_TO_IVEC (intNum : int) return Interrupt_Vector;
|
|
|
175 -- Equivalent to the C macro INUM_TO_IVEC used to convert an interrupt
|
|
|
176 -- number to an interrupt vector
|
|
|
177
|
|
|
178 procedure logMsg
|
|
|
179 (fmt : String; arg1, arg2, arg3, arg4, arg5, arg6 : int := 0);
|
|
|
180 -- Binding to the C routine logMsg. Note that it is the caller's
|
|
|
181 -- responsibility to ensure that fmt is a null-terminated string
|
|
|
182 -- (e.g logMsg ("Interrupt" & ASCII.NUL))
|
|
|
183
|
|
|
184 type FP_CONTEXT is private;
|
|
|
185 -- Floating point context save and restore. Handlers using floating point
|
|
|
186 -- must be bracketed with these calls. The pFpContext parameter should be
|
|
|
187 -- an object of type FP_CONTEXT that is declared local to the handler.
|
|
|
188 --
|
|
|
189 -- See the VxWorks Intel Architecture Supplement regarding these routines
|
|
|
190
|
|
|
191 procedure fppRestore (pFpContext : in out FP_CONTEXT);
|
|
|
192 -- Restore floating point context - old style
|
|
|
193
|
|
|
194 procedure fppSave (pFpContext : in out FP_CONTEXT);
|
|
|
195 -- Save floating point context - old style
|
|
|
196
|
|
|
197 procedure fppXrestore (pFpContext : in out FP_CONTEXT);
|
|
|
198 -- Restore floating point context - new style
|
|
|
199
|
|
|
200 procedure fppXsave (pFpContext : in out FP_CONTEXT);
|
|
|
201 -- Save floating point context - new style
|
|
|
202
|
|
|
203 private
|
|
|
204
|
|
|
205 type FP_CONTEXT is new System.VxWorks.FP_CONTEXT;
|
|
|
206 -- Target-dependent floating point context type
|
|
|
207
|
|
|
208 pragma Import (C, intConnect, "intConnect");
|
|
|
209 pragma Import (C, intContext, "intContext");
|
|
|
210 pragma Import (C, intVecGet, "intVecGet");
|
|
|
211 pragma Import (C, intVecSet, "intVecSet");
|
|
|
212 pragma Import (C, intVecGet2, "intVecGet2");
|
|
|
213 pragma Import (C, intVecSet2, "intVecSet2");
|
|
|
214 pragma Import (C, INUM_TO_IVEC, "__gnat_inum_to_ivec");
|
|
|
215 pragma Import (C, logMsg, "logMsg");
|
|
|
216 pragma Import (C, fppRestore, "fppRestore");
|
|
|
217 pragma Import (C, fppSave, "fppSave");
|
|
|
218 pragma Import (C, fppXrestore, "fppXrestore");
|
|
|
219 pragma Import (C, fppXsave, "fppXsave");
|
|
|
220 end Interfaces.VxWorks;
|
