summaryrefslogtreecommitdiffstats
path: root/drivers/char/ip2/i2lib.h
blob: 952e113ccd8a48b84c15f6af1b6b535e79f7ab28 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
/*******************************************************************************
*
*   (c) 1998 by Computone Corporation
*
********************************************************************************
*
*
*   PACKAGE:     Linux tty Device Driver for IntelliPort II family of multiport
*                serial I/O controllers.
*
*   DESCRIPTION: Header file for high level library functions
*
*******************************************************************************/
#ifndef I2LIB_H
#define I2LIB_H   1
//------------------------------------------------------------------------------
// I2LIB.H
//
// IntelliPort-II and IntelliPort-IIEX
//
// Defines, structure definitions, and external declarations for i2lib.c
//------------------------------------------------------------------------------
//--------------------------------------
// Mandatory Includes:
//--------------------------------------
#include "ip2types.h"
#include "i2ellis.h"
#include "i2pack.h"
#include "i2cmd.h"
#include <linux/workqueue.h>

//------------------------------------------------------------------------------
// i2ChanStr -- Channel Structure:
// Used to track per-channel information for the library routines using standard
// loadware. Note also, a pointer to an array of these structures is patched
// into the i2eBordStr (see i2ellis.h)
//------------------------------------------------------------------------------
//
// If we make some limits on the maximum block sizes, we can avoid dealing with
// buffer wrap. The wrapping of the buffer is based on where the start of the
// packet is. Then there is always room for the packet contiguously.
//
// Maximum total length of an outgoing data or in-line command block. The limit
// of 36 on data is quite arbitrary and based more on DOS memory limitations
// than the board interface. However, for commands, the maximum packet length is
// MAX_CMD_PACK_SIZE, because the field size for the count is only a few bits
// (see I2PACK.H) in such packets. For data packets, the count field size is not
// the limiting factor. As of this writing, MAX_OBUF_BLOCK < MAX_CMD_PACK_SIZE,
// but be careful if wanting to modify either.
//
#define MAX_OBUF_BLOCK  36

// Another note on maximum block sizes: we are buffering packets here. Data is
// put into the buffer (if there is room) regardless of the credits from the
// board. The board sends new credits whenever it has removed from his buffers a
// number of characters equal to 80% of total buffer size. (Of course, the total
// buffer size is what is reported when the very first set of flow control
// status packets are received from the board. Therefore, to be robust, you must
// always fill the board to at least 80% of the current credit limit, else you
// might not give it enough to trigger a new report. These conditions are
// obtained here so long as the maximum output block size is less than 20% the
// size of the board's output buffers. This is true at present by "coincidence"
// or "infernal knowledge": the board's output buffers are at least 700 bytes
// long (20% = 140 bytes, at least). The 80% figure is "official", so the safest
// strategy might be to trap the first flow control report and guarantee that
// the effective maxObufBlock is the minimum of MAX_OBUF_BLOCK and 20% of first
// reported buffer credit.
//
#define MAX_CBUF_BLOCK  6	// Maximum total length of a bypass command block

#define IBUF_SIZE       512	// character capacity of input buffer per channel
#define OBUF_SIZE       1024// character capacity of output buffer per channel
#define CBUF_SIZE       10	// character capacity of output bypass buffer

typedef struct _i2ChanStr
{
	// First, back-pointers so that given a pointer to this structure, you can
	// determine the correct board and channel number to reference, (say, when
	// issuing commands, etc. (Note, channel number is in infl.hd.i2sChannel.)

	int      port_index;    // Index of port in channel structure array attached
							// to board structure.
	PTTY     pTTY;          // Pointer to tty structure for port (OS specific)
	USHORT   validity;      // Indicates whether the given channel has been
							// initialized, really exists (or is a missing
							// channel, e.g. channel 9 on an 8-port box.)

	i2eBordStrPtr  pMyBord; // Back-pointer to this channel's board structure 

	int      wopen;			// waiting fer carrier

	int      throttled;		// Set if upper layer can take no data

	int      flags;         // Defined in tty.h

	PWAITQ   open_wait;     // Pointer for OS sleep function.
	PWAITQ   close_wait;    // Pointer for OS sleep function.
	PWAITQ   delta_msr_wait;// Pointer for OS sleep function.
	PWAITQ   dss_now_wait;	// Pointer for OS sleep function.

	struct timer_list  BookmarkTimer;   // Used by i2DrainOutput
	wait_queue_head_t pBookmarkWait;   // Used by i2DrainOutput

	int      BaudBase;
	int      BaudDivisor;

	USHORT   ClosingDelay;
	USHORT   ClosingWaitTime;

	volatile
	flowIn   infl;	// This structure is initialized as a completely
					// formed flow-control command packet, and as such
					// has the channel number, also the capacity and
					// "as-of" data needed continuously.

	USHORT   sinceLastFlow; // Counts the number of characters read from input
							// buffers, since the last time flow control info
							// was sent.

	USHORT   whenSendFlow;  // Determines when new flow control is to be sent to
							// the board. Note unlike earlier manifestations of
							// the driver, these packets can be sent from
							// in-place.

	USHORT   channelNeeds;  // Bit map of important things which must be done
							// for this channel. (See bits below )

	volatile
	flowStat outfl;         // Same type of structure is used to hold current
							// flow control information used to control our
							// output. "asof" is kept updated as data is sent,
							// and "room" never goes to zero.

	// The incoming ring buffer
	// Unlike the outgoing buffers, this holds raw data, not packets. The two
	// extra bytes are used to hold the byte-padding when there is room for an
	// odd number of bytes before we must wrap.
	//
	UCHAR    Ibuf[IBUF_SIZE + 2];
	volatile
	USHORT   Ibuf_stuff;     // Stuffing index
	volatile
	USHORT   Ibuf_strip;     // Stripping index

	// The outgoing ring-buffer: Holds Data and command packets. N.B., even
	// though these are in the channel structure, the channel is also written
	// here, the easier to send it to the fifo when ready. HOWEVER, individual
	// packets here are NOT padded to even length: the routines for writing
	// blocks to the fifo will pad to even byte counts.
	//
	UCHAR	Obuf[OBUF_SIZE+MAX_OBUF_BLOCK+4];
	volatile
	USHORT	Obuf_stuff;     // Stuffing index
	volatile
	USHORT	Obuf_strip;     // Stripping index
	int	Obuf_char_count;

	// The outgoing bypass-command buffer. Unlike earlier manifestations, the
	// flow control packets are sent directly from the structures. As above, the
	// channel number is included in the packet, but they are NOT padded to even
	// size.
	//
	UCHAR    Cbuf[CBUF_SIZE+MAX_CBUF_BLOCK+2];
	volatile
	USHORT   Cbuf_stuff;     // Stuffing index
	volatile
	USHORT   Cbuf_strip;     // Stripping index

	// The temporary buffer for the Linux tty driver PutChar entry.
	//
	UCHAR    Pbuf[MAX_OBUF_BLOCK - sizeof (i2DataHeader)];
	volatile
	USHORT   Pbuf_stuff;     // Stuffing index

	// The state of incoming data-set signals
	//
	USHORT   dataSetIn;     // Bit-mapped according to below. Also indicates
							// whether a break has been detected since last
							// inquiry.

	// The state of outcoming data-set signals (as far as we can tell!)
	//
	USHORT   dataSetOut;     // Bit-mapped according to below. 

	// Most recent hot-key identifier detected
	//
	USHORT   hotKeyIn;      // Hot key as sent by the board, HOT_CLEAR indicates
				// no hot key detected since last examined.

	// Counter of outstanding requests for bookmarks
	//
	short   bookMarks;	// Number of outstanding bookmark requests, (+ive
						// whenever a bookmark request if queued up, -ive
						// whenever a bookmark is received).

	// Misc options
	//
	USHORT   channelOptions;   // See below

	// To store various incoming special packets
	//
	debugStat   channelStatus;
	cntStat     channelRcount;
	cntStat     channelTcount;
	failStat    channelFail;

	// To store the last values for line characteristics we sent to the board.
	//
	int	speed;

	int flush_flags;

	void (*trace)(unsigned short,unsigned char,unsigned char,unsigned long,...);

	/*
	 * Kernel counters for the 4 input interrupts 
	 */
	struct async_icount icount;

	/*
	 *	Task queues for processing input packets from the board.
	 */
	struct work_struct	tqueue_input;
	struct work_struct	tqueue_status;
	struct work_struct	tqueue_hangup;

	rwlock_t Ibuf_spinlock;
	rwlock_t Obuf_spinlock;
	rwlock_t Cbuf_spinlock;
	rwlock_t Pbuf_spinlock;

} i2ChanStr, *i2ChanStrPtr;

//---------------------------------------------------
// Manifests and bit-maps for elements in i2ChanStr
//---------------------------------------------------
//
// flush flags
//
#define STARTFL_FLAG 1
#define STOPFL_FLAG  2

// validity
//
#define CHANNEL_MAGIC_BITS 0xff00
#define CHANNEL_MAGIC      0x5300   // (validity & CHANNEL_MAGIC_BITS) ==
									// CHANNEL_MAGIC --> structure good

#define CHANNEL_SUPPORT    0x0001   // Indicates channel is supported, exists,
									// and passed P.O.S.T.

// channelNeeds
//
#define NEED_FLOW    1  // Indicates flow control has been queued
#define NEED_INLINE  2  // Indicates inline commands or data queued
#define NEED_BYPASS  4  // Indicates bypass commands queued
#define NEED_CREDIT  8  // Indicates would be sending except has not sufficient
						// credit. The data is still in the channel structure,
						// but the channel is not enqueued in the board
						// structure again until there is a credit received from
						// the board.

// dataSetIn (Also the bits for i2GetStatus return value)
//
#define I2_DCD 1
#define I2_CTS 2
#define I2_DSR 4
#define I2_RI  8

// dataSetOut (Also the bits for i2GetStatus return value)
//
#define I2_DTR 1
#define I2_RTS 2

// i2GetStatus() can optionally clear these bits
//
#define I2_BRK    0x10  // A break was detected
#define I2_PAR    0x20  // A parity error was received 
#define I2_FRA    0x40  // A framing error was received
#define I2_OVR    0x80  // An overrun error was received 

// i2GetStatus() automatically clears these bits */
//
#define I2_DDCD   0x100 // DCD changed from its  former value
#define I2_DCTS   0x200 // CTS changed from its former value 
#define I2_DDSR   0x400 // DSR changed from its former value 
#define I2_DRI    0x800 // RI changed from its former value 

// hotKeyIn
//
#define HOT_CLEAR 0x1322   // Indicates that no hot-key has been detected

// channelOptions
//
#define CO_NBLOCK_WRITE 1  	// Writes don't block waiting for buffer. (Default
							// is, they do wait.)

// fcmodes
//
#define I2_OUTFLOW_CTS  0x0001
#define I2_INFLOW_RTS   0x0002
#define I2_INFLOW_DSR   0x0004
#define I2_INFLOW_DTR   0x0008
#define I2_OUTFLOW_DSR  0x0010
#define I2_OUTFLOW_DTR  0x0020
#define I2_OUTFLOW_XON  0x0040
#define I2_OUTFLOW_XANY 0x0080
#define I2_INFLOW_XON   0x0100

#define I2_CRTSCTS      (I2_OUTFLOW_CTS|I2_INFLOW_RTS)
#define I2_IXANY_MODE   (I2_OUTFLOW_XON|I2_OUTFLOW_XANY)

//-------------------------------------------
// Macros used from user level like functions
//-------------------------------------------

// Macros to set and clear channel options
//
#define i2SetOption(pCh, option) pCh->channelOptions |= option
#define i2ClrOption(pCh, option) pCh->channelOptions &= ~option

// Macro to set fatal-error trap
//
#define i2SetFatalTrap(pB, routine) pB->i2eFatalTrap = routine

//--------------------------------------------
// Declarations and prototypes for i2lib.c
//--------------------------------------------
//
static int  i2InitChannels(i2eBordStrPtr, int, i2ChanStrPtr);
static int  i2QueueCommands(int, i2ChanStrPtr, int, int, cmdSyntaxPtr,...);
static int  i2GetStatus(i2ChanStrPtr, int);
static int  i2Input(i2ChanStrPtr);
static int  i2InputFlush(i2ChanStrPtr);
static int  i2Output(i2ChanStrPtr, const char *, int, int);
static int  i2OutputFree(i2ChanStrPtr);
static int  i2ServiceBoard(i2eBordStrPtr);
static void i2DrainOutput(i2ChanStrPtr, int);

#ifdef IP2DEBUG_TRACE
void ip2trace(unsigned short,unsigned char,unsigned char,unsigned long,...);
#else
#define ip2trace(a,b,c,d...) do {} while (0)
#endif

// Argument to i2QueueCommands
//
#define C_IN_LINE 1
#define C_BYPASS  0

#endif   // I2LIB_H
OpenPOWER on IntegriCloud