i386/linux-2.3.21/drivers/char/ip2/i2cmd.c

   1 /*******************************************************************************
   2 *
   3 *   (c) 1998 by Computone Corporation
   4 *
   5 ********************************************************************************
   6 *
   7 *
   8 *   PACKAGE:     Linux tty Device Driver for IntelliPort family of multiport
   9 *                serial I/O controllers.
  10 *
  11 *   DESCRIPTION: Definition table for In-line and Bypass commands. Applicable
  12 *                only when the standard loadware is active. (This is included
  13 *                source code, not a separate compilation module.)
  14 *
  15 *******************************************************************************/
  16
  17 //------------------------------------------------------------------------------
  18 //
  19 // Revision History:
  20 //
  21 // 10 October 1991   MAG First Draft
  22 //  7 November 1991  MAG Reflects additional commands.
  23 // 24 February 1992  MAG Additional commands for 1.4.x loadware
  24 // 11 March 1992     MAG Additional commands
  25 // 30 March 1992     MAG Additional command: CMD_DSS_NOW
  26 // 18 May 1992       MAG Discovered commands 39 & 40 must be at the end of a
  27 //                       packet: affects implementation.
  28 //------------------------------------------------------------------------------
  29
  30 //************
  31 //* Includes *
  32 //************
  33
  34 #include "i2cmd.h"   /* To get some bit-defines */
  35
  36 //------------------------------------------------------------------------------
  37 // Here is the table of global arrays which represent each type of command
  38 // supported in the IntelliPort standard loadware. See also i2cmd.h
  39 // for a more complete explanation of what is going on.
  40 //------------------------------------------------------------------------------
  41
  42 // Here are the various globals: note that the names are not used except through
  43 // the macros defined in i2cmd.h. Also note that although they are character
  44 // arrays here (for extendability) they are cast to structure pointers in the
  45 // i2cmd.h macros. See i2cmd.h for flags definitions.
  46
  47 //                     Length Flags Command
  48 static UCHAR ct02[] = { 1, BTH,     0x02                     }; // DTR UP
  49 static UCHAR ct03[] = { 1, BTH,     0x03                     }; // DTR DN
  50 static UCHAR ct04[] = { 1, BTH,     0x04                     }; // RTS UP
  51 static UCHAR ct05[] = { 1, BTH,     0x05                     }; // RTS DN
  52 static UCHAR ct06[] = { 1, BYP,     0x06                     }; // START FL
  53 static UCHAR ct07[] = { 2, BTH,     0x07,0                   }; // BAUD
  54 static UCHAR ct08[] = { 2, BTH,     0x08,0                   }; // BITS
  55 static UCHAR ct09[] = { 2, BTH,     0x09,0                   }; // STOP
  56 static UCHAR ct10[] = { 2, BTH,     0x0A,0                   }; // PARITY
  57 static UCHAR ct11[] = { 2, BTH,     0x0B,0                   }; // XON
  58 static UCHAR ct12[] = { 2, BTH,     0x0C,0                   }; // XOFF
  59 static UCHAR ct13[] = { 1, BTH,     0x0D                     }; // STOP FL
  60 static UCHAR ct14[] = { 1, BYP|VIP, 0x0E                     }; // ACK HOTK
  61 //static UCHAR ct15[]={ 2, BTH|VIP, 0x0F,0                   }; // IRQ SET
  62 static UCHAR ct16[] = { 2, INL,     0x10,0                   }; // IXONOPTS
  63 static UCHAR ct17[] = { 2, INL,     0x11,0                   }; // OXONOPTS
  64 static UCHAR ct18[] = { 1, INL,     0x12                     }; // CTSENAB
  65 static UCHAR ct19[] = { 1, BTH,     0x13                     }; // CTSDSAB
  66 static UCHAR ct20[] = { 1, INL,     0x14                     }; // DCDENAB
  67 static UCHAR ct21[] = { 1, BTH,     0x15                     }; // DCDDSAB
  68 static UCHAR ct22[] = { 1, BTH,     0x16                     }; // DSRENAB
  69 static UCHAR ct23[] = { 1, BTH,     0x17                     }; // DSRDSAB
  70 static UCHAR ct24[] = { 1, BTH,     0x18                     }; // RIENAB
  71 static UCHAR ct25[] = { 1, BTH,     0x19                     }; // RIDSAB
  72 static UCHAR ct26[] = { 2, BTH,     0x1A,0                   }; // BRKENAB
  73 static UCHAR ct27[] = { 1, BTH,     0x1B                     }; // BRKDSAB
  74 //static UCHAR ct28[]={ 2, BTH,     0x1C,0                   }; // MAXBLOKSIZE
  75 //static UCHAR ct29[]={ 2, 0,       0x1D,0                   }; // reserved
  76 static UCHAR ct30[] = { 1, INL,     0x1E                     }; // CTSFLOWENAB
  77 static UCHAR ct31[] = { 1, INL,     0x1F                     }; // CTSFLOWDSAB
  78 static UCHAR ct32[] = { 1, INL,     0x20                     }; // RTSFLOWENAB
  79 static UCHAR ct33[] = { 1, INL,     0x21                     }; // RTSFLOWDSAB
  80 static UCHAR ct34[] = { 2, BTH,     0x22,0                   }; // ISTRIPMODE
  81 static UCHAR ct35[] = { 2, BTH|END, 0x23,0                   }; // SENDBREAK
  82 static UCHAR ct36[] = { 2, BTH,     0x24,0                   }; // SETERRMODE
  83 //static UCHAR ct36a[]={ 3, INL,    0x24,0,0                 }; // SET_REPLACE
  84
  85 // The following is listed for completeness, but should never be sent directly
  86 // by user-level code. It is sent only by library routines in response to data
  87 // movement.
  88 //static UCHAR ct37[]={ 5, BYP|VIP, 0x25,0,0,0,0             }; // FLOW PACKET
  89
  90 // Back to normal
  91 static UCHAR ct38[] = {11, BTH|VAR, 0x26,0,0,0,0,0,0,0,0,0,0 }; // DEF KEY SEQ
  92 //static UCHAR ct39[]={ 3, BTH|END, 0x27,0,0                 }; // OPOSTON
  93 //static UCHAR ct40[]={ 1, BTH|END, 0x28                     }; // OPOSTOFF
  94 static UCHAR ct41[] = { 1, BYP,     0x29                     }; // RESUME
  95 //static UCHAR ct42[]={ 2, BTH,     0x2A,0                   }; // TXBAUD
  96 //static UCHAR ct43[]={ 2, BTH,     0x2B,0                   }; // RXBAUD
  97 //static UCHAR ct44[]={ 2, BTH,     0x2C,0                   }; // MS PING
  98 //static UCHAR ct45[]={ 1, BTH,     0x2D                     }; // HOTENAB
  99 //static UCHAR ct46[]={ 1, BTH,     0x2E                     }; // HOTDSAB
 100 static UCHAR ct47[] = { 7, BTH,     0x2F,0,0,0,0,0,0         }; // UNIX FLAGS
 101 //static UCHAR ct48[]={ 1, BTH,     0x30                     }; // DSRFLOWENAB
 102 //static UCHAR ct49[]={ 1, BTH,     0x31                     }; // DSRFLOWDSAB
 103 //static UCHAR ct50[]={ 1, BTH,     0x32                     }; // DTRFLOWENAB
 104 //static UCHAR ct51[]={ 1, BTH,     0x33                     }; // DTRFLOWDSAB
 105 //static UCHAR ct52[]={ 1, BTH,     0x34                     }; // BAUDTABRESET
 106 static UCHAR ct53[] = { 3, BTH,     0x35,0,0                 }; // BAUDREMAP
 107 static UCHAR ct54[] = { 3, BTH,     0x36,0,0                 }; // CUSTOMBAUD1
 108 static UCHAR ct55[] = { 3, BTH,     0x37,0,0                 }; // CUSTOMBAUD2
 109 static UCHAR ct56[] = { 2, BTH|END, 0x38,0                   }; // PAUSE
 110 static UCHAR ct57[] = { 1, BYP,     0x39                     }; // SUSPEND
 111 static UCHAR ct58[] = { 1, BYP,     0x3A                     }; // UNSUSPEND
 112 static UCHAR ct59[] = { 2, BTH,     0x3B,0                   }; // PARITYCHK
 113 static UCHAR ct60[] = { 1, INL|VIP, 0x3C                     }; // BOOKMARKREQ
 114 //static UCHAR ct61[]={ 2, BTH,     0x3D,0                   }; // INTERNALLOOP
 115 //static UCHAR ct62[]={ 2, BTH,     0x3E,0                   }; // HOTKTIMEOUT
 116 static UCHAR ct63[] = { 2, INL,     0x3F,0                   }; // SETTXON
 117 static UCHAR ct64[] = { 2, INL,     0x40,0                   }; // SETTXOFF
 118 //static UCHAR ct65[]={ 2, BTH,     0x41,0                   }; // SETAUTORTS
 119 //static UCHAR ct66[]={ 2, BTH,     0x42,0                   }; // SETHIGHWAT
 120 //static UCHAR ct67[]={ 2, BYP,     0x43,0                   }; // STARTSELFL
 121 //static UCHAR ct68[]={ 2, INL,     0x44,0                   }; // ENDSELFL
 122 //static UCHAR ct69[]={ 1, BYP,     0x45                     }; // HWFLOW_OFF
 123 //static UCHAR ct70[]={ 1, BTH,     0x46                     }; // ODSRFL_ENAB
 124 //static UCHAR ct71[]={ 1, BTH,     0x47                     }; // ODSRFL_DSAB
 125 //static UCHAR ct72[]={ 1, BTH,     0x48                     }; // ODCDFL_ENAB
 126 //static UCHAR ct73[]={ 1, BTH,     0x49                     }; // ODCDFL_DSAB
 127 //static UCHAR ct74[]={ 2, BTH,     0x4A,0                   }; // LOADLEVEL
 128 //static UCHAR ct75[]={ 2, BTH,     0x4B,0                   }; // STATDATA
 129 //static UCHAR ct76[]={ 1, BYP,     0x4C                     }; // BREAK_ON
 130 //static UCHAR ct77[]={ 1, BYP,     0x4D                     }; // BREAK_OFF
 131 //static UCHAR ct78[]={ 1, BYP,     0x4E                     }; // GETFC
 132 static UCHAR ct79[] = { 2, BYP,     0x4F,0                   }; // XMIT_NOW
 133 //static UCHAR ct80[]={ 4, BTH,     0x50,0,0,0               }; // DIVISOR_LATCH
 134 //static UCHAR ct81[]={ 1, BYP,     0x51                     }; // GET_STATUS
 135 //static UCHAR ct82[]={ 1, BYP,     0x52                     }; // GET_TXCNT
 136 //static UCHAR ct83[]={ 1, BYP,     0x53                     }; // GET_RXCNT
 137 //static UCHAR ct84[]={ 1, BYP,     0x54                     }; // GET_BOXIDS
 138 //static UCHAR ct85[]={10, BYP,     0x55,0,0,0,0,0,0,0,0,0   }; // ENAB_MULT
 139 //static UCHAR ct86[]={ 2, BTH,     0x56,0                   }; // RCV_ENABLE
 140 static UCHAR ct87[] = { 1, BYP,     0x57                     }; // HW_TEST
 141 //static UCHAR ct88[]={ 3, BTH,     0x58,0,0                 }; // RCV_THRESHOLD
 142 //static UCHAR ct89[]={ 1, BYP,     0x59                     }; // DSS_NOW
 143 //static UCHAR ct90[]={ 3, BYP,     0x5A,0,0                 }; // Set SILO
 144 //static UCHAR ct91[]={ 2, BYP,     0x5B,0                   }; // timed break
 145
 146 // Some composite commands as well
 147 //static UCHAR cc01[]={ 2, BTH,     0x02,0x04                }; // DTR & RTS UP
 148 //static UCHAR cc02[]={ 2, BTH,     0x03,0x05                }; // DTR & RTS DN
 149
 150 //********
 151 //* Code *
 152 //********
 153
 154 //******************************************************************************
 155 // Function:   i2cmdSetSeq(type, size, string)
 156 // Parameters: type   - sequence number
 157 //             size   - length of sequence
 158 //             string - substitution string
 159 //
 160 // Returns:    Pointer to command structure
 161 //
 162 // Description:
 163 //
 164 // This routine sets the parameters of command 38 Define Hot Key sequence (alias
 165 // "special receive sequence"). Returns a pointer to the structure. Endeavours
 166 // to be bullet-proof in that the sequence number is forced in range, and any
 167 // out-of-range sizes are forced to zero.
 168 //******************************************************************************
 169 cmdSyntaxPtr
 170 i2cmdSetSeq(unsigned char type, unsigned char size, unsigned char *string)
 171 {
 172         cmdSyntaxPtr pCM = (cmdSyntaxPtr) ct38;
 173         unsigned char *pc;
 174
 175         pCM->cmd[1] = ((type > 0xf) ? 0xf : type);   // Sequence number
 176         size = ((size > 0x8) ? 0 : size);            // size
 177         pCM->cmd[2] = size;
 178         pCM->length = 3 + size;                      // UPDATES THE LENGTH!
 179
 180         pc = &(pCM->cmd[3]);
 181
 182         while(size--) {
 183                 *pc++ = *string++;
 184         }
 185         return pCM;
 186 }
 187
 188 //******************************************************************************
 189 // Function:   i2cmdUnixFlags(iflag, cflag, lflag)
 190 // Parameters: Unix tty flags
 191 //
 192 // Returns:    Pointer to command structure
 193 //
 194 // Description:
 195 //
 196 // This routine sets the parameters of command 47 and returns a pointer to the
 197 // appropriate structure.
 198 //******************************************************************************
 199 cmdSyntaxPtr
 200 i2cmdUnixFlags(unsigned short iflag,unsigned short cflag,unsigned short lflag)
 201 {
 202         cmdSyntaxPtr pCM = (cmdSyntaxPtr) ct47;
 203
 204         pCM->cmd[1] = (unsigned char)  iflag;
 205         pCM->cmd[2] = (unsigned char) (iflag >> 8);
 206         pCM->cmd[3] = (unsigned char)  cflag;
 207         pCM->cmd[4] = (unsigned char) (cflag >> 8);
 208         pCM->cmd[5] = (unsigned char)  lflag;
 209         pCM->cmd[6] = (unsigned char) (lflag >> 8);
 210         return pCM;
 211 }
 212
 213 //******************************************************************************
 214 // Function:   i2cmdBaudRemap(dest,src)
 215 // Parameters: ?
 216 //
 217 // Returns:    Pointer to command structure
 218 //
 219 // Description:
 220 //
 221 // This routine sets the parameters of command 53 and returns a pointer to the
 222 // appropriate structure.
 223 //******************************************************************************
 224 cmdSyntaxPtr
 225 i2cmdBaudRemap(unsigned char dest, unsigned char src)
 226 {
 227         cmdSyntaxPtr pCM = (cmdSyntaxPtr) ct53;
 228
 229         pCM->cmd[1] = dest;
 230         pCM->cmd[2] = src;
 231         return pCM;
 232 }
 233
 234 //******************************************************************************
 235 // Function:   i2cmdBaudDef(which, rate)
 236 // Parameters: ?
 237 //
 238 // Returns:    Pointer to command structure
 239 //
 240 // Description:
 241 //
 242 // This routine sets the parameters of commands 54 or 55 (according to the
 243 // argument which), and returns a pointer to the appropriate structure.
 244 //******************************************************************************
 245 cmdSyntaxPtr
 246 i2cmdBaudDef(int which, unsigned short rate)
 247 {
 248         cmdSyntaxPtr pCM;
 249
 250         switch(which)
 251         {
 252         case 1:
 253                 pCM = (cmdSyntaxPtr) ct54;
 254                 break;
 255         default:
 256         case 2:
 257                 pCM = (cmdSyntaxPtr) ct55;
 258                 break;
 259         }
 260         pCM->cmd[1] = (unsigned char) rate;
 261         pCM->cmd[2] = (unsigned char) (rate >> 8);
 262         return pCM;
 263 }
 264