Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /******************************************************************************* |
2 | * | |
3 | * (c) 1998 by Computone Corporation | |
4 | * | |
5 | ******************************************************************************** | |
6 | * | |
7 | * | |
8 | * PACKAGE: Linux tty Device Driver for IntelliPort II family of multiport | |
9 | * serial I/O controllers. | |
10 | * | |
11 | * DESCRIPTION: Header file for high level library functions | |
12 | * | |
13 | *******************************************************************************/ | |
14 | #ifndef I2LIB_H | |
15 | #define I2LIB_H 1 | |
16 | //------------------------------------------------------------------------------ | |
17 | // I2LIB.H | |
18 | // | |
19 | // IntelliPort-II and IntelliPort-IIEX | |
20 | // | |
21 | // Defines, structure definitions, and external declarations for i2lib.c | |
22 | //------------------------------------------------------------------------------ | |
23 | //-------------------------------------- | |
24 | // Mandatory Includes: | |
25 | //-------------------------------------- | |
26 | #include "ip2types.h" | |
27 | #include "i2ellis.h" | |
28 | #include "i2pack.h" | |
29 | #include "i2cmd.h" | |
30 | #include <linux/workqueue.h> | |
31 | ||
32 | //------------------------------------------------------------------------------ | |
33 | // i2ChanStr -- Channel Structure: | |
34 | // Used to track per-channel information for the library routines using standard | |
35 | // loadware. Note also, a pointer to an array of these structures is patched | |
36 | // into the i2eBordStr (see i2ellis.h) | |
37 | //------------------------------------------------------------------------------ | |
38 | // | |
39 | // If we make some limits on the maximum block sizes, we can avoid dealing with | |
40 | // buffer wrap. The wrapping of the buffer is based on where the start of the | |
41 | // packet is. Then there is always room for the packet contiguously. | |
42 | // | |
43 | // Maximum total length of an outgoing data or in-line command block. The limit | |
44 | // of 36 on data is quite arbitrary and based more on DOS memory limitations | |
45 | // than the board interface. However, for commands, the maximum packet length is | |
46 | // MAX_CMD_PACK_SIZE, because the field size for the count is only a few bits | |
47 | // (see I2PACK.H) in such packets. For data packets, the count field size is not | |
48 | // the limiting factor. As of this writing, MAX_OBUF_BLOCK < MAX_CMD_PACK_SIZE, | |
49 | // but be careful if wanting to modify either. | |
50 | // | |
51 | #define MAX_OBUF_BLOCK 36 | |
52 | ||
53 | // Another note on maximum block sizes: we are buffering packets here. Data is | |
54 | // put into the buffer (if there is room) regardless of the credits from the | |
55 | // board. The board sends new credits whenever it has removed from his buffers a | |
56 | // number of characters equal to 80% of total buffer size. (Of course, the total | |
57 | // buffer size is what is reported when the very first set of flow control | |
58 | // status packets are received from the board. Therefore, to be robust, you must | |
59 | // always fill the board to at least 80% of the current credit limit, else you | |
60 | // might not give it enough to trigger a new report. These conditions are | |
61 | // obtained here so long as the maximum output block size is less than 20% the | |
62 | // size of the board's output buffers. This is true at present by "coincidence" | |
63 | // or "infernal knowledge": the board's output buffers are at least 700 bytes | |
64 | // long (20% = 140 bytes, at least). The 80% figure is "official", so the safest | |
65 | // strategy might be to trap the first flow control report and guarantee that | |
66 | // the effective maxObufBlock is the minimum of MAX_OBUF_BLOCK and 20% of first | |
67 | // reported buffer credit. | |
68 | // | |
69 | #define MAX_CBUF_BLOCK 6 // Maximum total length of a bypass command block | |
70 | ||
71 | #define IBUF_SIZE 512 // character capacity of input buffer per channel | |
72 | #define OBUF_SIZE 1024// character capacity of output buffer per channel | |
73 | #define CBUF_SIZE 10 // character capacity of output bypass buffer | |
74 | ||
75 | typedef struct _i2ChanStr | |
76 | { | |
77 | // First, back-pointers so that given a pointer to this structure, you can | |
78 | // determine the correct board and channel number to reference, (say, when | |
79 | // issuing commands, etc. (Note, channel number is in infl.hd.i2sChannel.) | |
80 | ||
81 | int port_index; // Index of port in channel structure array attached | |
82 | // to board structure. | |
83 | PTTY pTTY; // Pointer to tty structure for port (OS specific) | |
84 | USHORT validity; // Indicates whether the given channel has been | |
85 | // initialized, really exists (or is a missing | |
86 | // channel, e.g. channel 9 on an 8-port box.) | |
87 | ||
88 | i2eBordStrPtr pMyBord; // Back-pointer to this channel's board structure | |
89 | ||
90 | int wopen; // waiting fer carrier | |
91 | ||
92 | int throttled; // Set if upper layer can take no data | |
93 | ||
94 | int flags; // Defined in tty.h | |
95 | ||
96 | PWAITQ open_wait; // Pointer for OS sleep function. | |
97 | PWAITQ close_wait; // Pointer for OS sleep function. | |
98 | PWAITQ delta_msr_wait;// Pointer for OS sleep function. | |
99 | PWAITQ dss_now_wait; // Pointer for OS sleep function. | |
100 | ||
101 | struct timer_list BookmarkTimer; // Used by i2DrainOutput | |
102 | wait_queue_head_t pBookmarkWait; // Used by i2DrainOutput | |
103 | ||
104 | int BaudBase; | |
105 | int BaudDivisor; | |
106 | ||
107 | USHORT ClosingDelay; | |
108 | USHORT ClosingWaitTime; | |
109 | ||
110 | volatile | |
111 | flowIn infl; // This structure is initialized as a completely | |
112 | // formed flow-control command packet, and as such | |
113 | // has the channel number, also the capacity and | |
114 | // "as-of" data needed continuously. | |
115 | ||
116 | USHORT sinceLastFlow; // Counts the number of characters read from input | |
117 | // buffers, since the last time flow control info | |
118 | // was sent. | |
119 | ||
120 | USHORT whenSendFlow; // Determines when new flow control is to be sent to | |
121 | // the board. Note unlike earlier manifestations of | |
122 | // the driver, these packets can be sent from | |
123 | // in-place. | |
124 | ||
125 | USHORT channelNeeds; // Bit map of important things which must be done | |
126 | // for this channel. (See bits below ) | |
127 | ||
128 | volatile | |
129 | flowStat outfl; // Same type of structure is used to hold current | |
130 | // flow control information used to control our | |
131 | // output. "asof" is kept updated as data is sent, | |
132 | // and "room" never goes to zero. | |
133 | ||
134 | // The incoming ring buffer | |
135 | // Unlike the outgoing buffers, this holds raw data, not packets. The two | |
136 | // extra bytes are used to hold the byte-padding when there is room for an | |
137 | // odd number of bytes before we must wrap. | |
138 | // | |
139 | UCHAR Ibuf[IBUF_SIZE + 2]; | |
140 | volatile | |
141 | USHORT Ibuf_stuff; // Stuffing index | |
142 | volatile | |
143 | USHORT Ibuf_strip; // Stripping index | |
144 | ||
145 | // The outgoing ring-buffer: Holds Data and command packets. N.B., even | |
146 | // though these are in the channel structure, the channel is also written | |
147 | // here, the easier to send it to the fifo when ready. HOWEVER, individual | |
148 | // packets here are NOT padded to even length: the routines for writing | |
149 | // blocks to the fifo will pad to even byte counts. | |
150 | // | |
151 | UCHAR Obuf[OBUF_SIZE+MAX_OBUF_BLOCK+4]; | |
152 | volatile | |
153 | USHORT Obuf_stuff; // Stuffing index | |
154 | volatile | |
155 | USHORT Obuf_strip; // Stripping index | |
156 | int Obuf_char_count; | |
157 | ||
158 | // The outgoing bypass-command buffer. Unlike earlier manifestations, the | |
159 | // flow control packets are sent directly from the structures. As above, the | |
160 | // channel number is included in the packet, but they are NOT padded to even | |
161 | // size. | |
162 | // | |
163 | UCHAR Cbuf[CBUF_SIZE+MAX_CBUF_BLOCK+2]; | |
164 | volatile | |
165 | USHORT Cbuf_stuff; // Stuffing index | |
166 | volatile | |
167 | USHORT Cbuf_strip; // Stripping index | |
168 | ||
169 | // The temporary buffer for the Linux tty driver PutChar entry. | |
170 | // | |
171 | UCHAR Pbuf[MAX_OBUF_BLOCK - sizeof (i2DataHeader)]; | |
172 | volatile | |
173 | USHORT Pbuf_stuff; // Stuffing index | |
174 | ||
175 | // The state of incoming data-set signals | |
176 | // | |
177 | USHORT dataSetIn; // Bit-mapped according to below. Also indicates | |
178 | // whether a break has been detected since last | |
179 | // inquiry. | |
180 | ||
181 | // The state of outcoming data-set signals (as far as we can tell!) | |
182 | // | |
183 | USHORT dataSetOut; // Bit-mapped according to below. | |
184 | ||
185 | // Most recent hot-key identifier detected | |
186 | // | |
187 | USHORT hotKeyIn; // Hot key as sent by the board, HOT_CLEAR indicates | |
188 | // no hot key detected since last examined. | |
189 | ||
190 | // Counter of outstanding requests for bookmarks | |
191 | // | |
192 | short bookMarks; // Number of outstanding bookmark requests, (+ive | |
193 | // whenever a bookmark request if queued up, -ive | |
194 | // whenever a bookmark is received). | |
195 | ||
196 | // Misc options | |
197 | // | |
198 | USHORT channelOptions; // See below | |
199 | ||
200 | // To store various incoming special packets | |
201 | // | |
202 | debugStat channelStatus; | |
203 | cntStat channelRcount; | |
204 | cntStat channelTcount; | |
205 | failStat channelFail; | |
206 | ||
207 | // To store the last values for line characteristics we sent to the board. | |
208 | // | |
209 | int speed; | |
210 | ||
211 | int flush_flags; | |
212 | ||
213 | void (*trace)(unsigned short,unsigned char,unsigned char,unsigned long,...); | |
214 | ||
215 | /* | |
216 | * Kernel counters for the 4 input interrupts | |
217 | */ | |
218 | struct async_icount icount; | |
219 | ||
220 | /* | |
221 | * Task queues for processing input packets from the board. | |
222 | */ | |
223 | struct work_struct tqueue_input; | |
224 | struct work_struct tqueue_status; | |
225 | struct work_struct tqueue_hangup; | |
226 | ||
227 | rwlock_t Ibuf_spinlock; | |
228 | rwlock_t Obuf_spinlock; | |
229 | rwlock_t Cbuf_spinlock; | |
230 | rwlock_t Pbuf_spinlock; | |
231 | ||
232 | } i2ChanStr, *i2ChanStrPtr; | |
233 | ||
234 | //--------------------------------------------------- | |
235 | // Manifests and bit-maps for elements in i2ChanStr | |
236 | //--------------------------------------------------- | |
237 | // | |
238 | // flush flags | |
239 | // | |
240 | #define STARTFL_FLAG 1 | |
241 | #define STOPFL_FLAG 2 | |
242 | ||
243 | // validity | |
244 | // | |
245 | #define CHANNEL_MAGIC_BITS 0xff00 | |
246 | #define CHANNEL_MAGIC 0x5300 // (validity & CHANNEL_MAGIC_BITS) == | |
247 | // CHANNEL_MAGIC --> structure good | |
248 | ||
249 | #define CHANNEL_SUPPORT 0x0001 // Indicates channel is supported, exists, | |
250 | // and passed P.O.S.T. | |
251 | ||
252 | // channelNeeds | |
253 | // | |
254 | #define NEED_FLOW 1 // Indicates flow control has been queued | |
255 | #define NEED_INLINE 2 // Indicates inline commands or data queued | |
256 | #define NEED_BYPASS 4 // Indicates bypass commands queued | |
257 | #define NEED_CREDIT 8 // Indicates would be sending except has not sufficient | |
258 | // credit. The data is still in the channel structure, | |
259 | // but the channel is not enqueued in the board | |
260 | // structure again until there is a credit received from | |
261 | // the board. | |
262 | ||
263 | // dataSetIn (Also the bits for i2GetStatus return value) | |
264 | // | |
265 | #define I2_DCD 1 | |
266 | #define I2_CTS 2 | |
267 | #define I2_DSR 4 | |
268 | #define I2_RI 8 | |
269 | ||
270 | // dataSetOut (Also the bits for i2GetStatus return value) | |
271 | // | |
272 | #define I2_DTR 1 | |
273 | #define I2_RTS 2 | |
274 | ||
275 | // i2GetStatus() can optionally clear these bits | |
276 | // | |
277 | #define I2_BRK 0x10 // A break was detected | |
278 | #define I2_PAR 0x20 // A parity error was received | |
279 | #define I2_FRA 0x40 // A framing error was received | |
280 | #define I2_OVR 0x80 // An overrun error was received | |
281 | ||
282 | // i2GetStatus() automatically clears these bits */ | |
283 | // | |
284 | #define I2_DDCD 0x100 // DCD changed from its former value | |
285 | #define I2_DCTS 0x200 // CTS changed from its former value | |
286 | #define I2_DDSR 0x400 // DSR changed from its former value | |
287 | #define I2_DRI 0x800 // RI changed from its former value | |
288 | ||
289 | // hotKeyIn | |
290 | // | |
291 | #define HOT_CLEAR 0x1322 // Indicates that no hot-key has been detected | |
292 | ||
293 | // channelOptions | |
294 | // | |
295 | #define CO_NBLOCK_WRITE 1 // Writes don't block waiting for buffer. (Default | |
296 | // is, they do wait.) | |
297 | ||
298 | // fcmodes | |
299 | // | |
300 | #define I2_OUTFLOW_CTS 0x0001 | |
301 | #define I2_INFLOW_RTS 0x0002 | |
302 | #define I2_INFLOW_DSR 0x0004 | |
303 | #define I2_INFLOW_DTR 0x0008 | |
304 | #define I2_OUTFLOW_DSR 0x0010 | |
305 | #define I2_OUTFLOW_DTR 0x0020 | |
306 | #define I2_OUTFLOW_XON 0x0040 | |
307 | #define I2_OUTFLOW_XANY 0x0080 | |
308 | #define I2_INFLOW_XON 0x0100 | |
309 | ||
310 | #define I2_CRTSCTS (I2_OUTFLOW_CTS|I2_INFLOW_RTS) | |
311 | #define I2_IXANY_MODE (I2_OUTFLOW_XON|I2_OUTFLOW_XANY) | |
312 | ||
313 | //------------------------------------------- | |
314 | // Macros used from user level like functions | |
315 | //------------------------------------------- | |
316 | ||
317 | // Macros to set and clear channel options | |
318 | // | |
319 | #define i2SetOption(pCh, option) pCh->channelOptions |= option | |
320 | #define i2ClrOption(pCh, option) pCh->channelOptions &= ~option | |
321 | ||
322 | // Macro to set fatal-error trap | |
323 | // | |
324 | #define i2SetFatalTrap(pB, routine) pB->i2eFatalTrap = routine | |
325 | ||
326 | //-------------------------------------------- | |
327 | // Declarations and prototypes for i2lib.c | |
328 | //-------------------------------------------- | |
329 | // | |
330 | static int i2InitChannels(i2eBordStrPtr, int, i2ChanStrPtr); | |
331 | static int i2QueueCommands(int, i2ChanStrPtr, int, int, cmdSyntaxPtr,...); | |
332 | static int i2GetStatus(i2ChanStrPtr, int); | |
333 | static int i2Input(i2ChanStrPtr); | |
334 | static int i2InputFlush(i2ChanStrPtr); | |
335 | static int i2Output(i2ChanStrPtr, const char *, int, int); | |
336 | static int i2OutputFree(i2ChanStrPtr); | |
337 | static int i2ServiceBoard(i2eBordStrPtr); | |
338 | static void i2DrainOutput(i2ChanStrPtr, int); | |
339 | ||
340 | #ifdef IP2DEBUG_TRACE | |
341 | void ip2trace(unsigned short,unsigned char,unsigned char,unsigned long,...); | |
342 | #else | |
343 | #define ip2trace(a,b,c,d...) do {} while (0) | |
344 | #endif | |
345 | ||
346 | // Argument to i2QueueCommands | |
347 | // | |
348 | #define C_IN_LINE 1 | |
349 | #define C_BYPASS 0 | |
350 | ||
351 | #endif // I2LIB_H |