Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 351 insertions, 0 deletions

diff --git a/drivers/char/ip2/i2lib.h b/drivers/char/ip2/i2lib.h
new file mode 100644
index 000000000000..952e113ccd8a
--- /dev/null
+++ b/drivers/char/ip2/i2lib.h
@@ -0,0 +1,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