gdb/nlm/alpha-patch.h

   1 /* This contains defs for the stubs defined in alpha-patch.c.  Many of these
   2    defs are ripped off of other files.  */
   3
   4 #include "altdebug.h"           /* Get StackFrame structure */
   5
   6 /* -=-=-= aio.h -=-=-= */
   7
   8 /*----------------------------------------------------------------------------*
   9  *                                                                            *
  10  *      NetWare 386 Developer's Asynchronous I/O (AIO) Runtime library        *
  11  *                                                                            *
  12  *      This include file defines the constants and prototypes required       *
  13  *      to use the AIO application interface.                                 *
  14  *                                                                            *
  15  *      (c) Copyright.  1991 Novell, Inc.   All rights reserved.              *
  16  *                                                                            *
  17  *----------------------------------------------------------------------------*/
  18
  19 typedef unsigned long DWORD;
  20
  21
  22 /*----------------------------------------------------------------------------*
  23  *                                                                            *
  24  *    Predefined hardware types for use with the AIOAcquirePort function.     *
  25  *                                                                            *
  26  *----------------------------------------------------------------------------*/
  27
  28 #define AIO_COMX_TYPE             (1)
  29 #define AIO_ARTIC_TYPE            (2)
  30 #define AIO_WNIM_TYPE             (3)
  31
  32
  33 /*----------------------------------------------------------------------------*
  34  *                                                                            *
  35  *    Function completion code status values.                                 *
  36  *                                                                            *
  37  *    Note that all error statuses are negative values.                       *
  38  *                                                                            *
  39  *----------------------------------------------------------------------------*/
  40
  41 #define AIO_SUCCESS               (0)
  42 #define AIO_BAD_HANDLE            (-1)
  43 #define AIO_FAILURE               (-2)
  44 #define AIO_FUNC_NOT_SUPPORTED    (-3)
  45 #define AIO_INVALID_PARAMETER     (-5)
  46 #define AIO_PORT_NOT_AVAILABLE    (-6)
  47 #define AIO_QUALIFIED_SUCCESS     (-7)
  48 #define AIO_NO_MORE_PORTS         (-8)
  49 #define AIO_TYPE_NUMBER_INVALID   (-10)
  50 #define AIO_BOARD_NUMBER_INVALID  (-11)
  51 #define AIO_PORT_NUMBER_INVALID   (-12)
  52 #define AIO_RESOURCE_TAG_INVALID  (-13)
  53 #define AIO_DATA_PRESENT          (-14)
  54 #define AIO_BAD_REQUEST_TYPE      (-15)
  55 #define AIO_PORT_GONE             (-20)
  56 #define AIO_RTAG_INVALID          (-21)
  57
  58
  59 /* This is only for non-CLIB application */
  60
  61 #define ASYNCIOSignature  0x4E595341   /* 'NYSA' */
  62
  63 /*----------------------------------------------------------------------------*
  64  *                                                                            *
  65  *    Definitions for use with the AIOSetExternalControl function.            *
  66  *                                                                            *
  67  *----------------------------------------------------------------------------*/
  68
  69 #define AIO_EXTERNAL_CONTROL      (1)
  70 #define AIO_EXTCTRL_DTR             (1)
  71 #define AIO_EXTCTRL_RTS             (2)
  72
  73
  74 #define AIO_BREAK_CONTROL         (2)
  75 #define AIO_SET_BREAK_OFF           (0)
  76 #define AIO_SET_BREAK_ON            (1)
  77
  78
  79 #define AIO_FLOW_CONTROL          (3)
  80 #define AIO_SOFTWARE_FLOW_CONTROL_OFF  (0)
  81 #define AIO_SOFTWARE_FLOW_CONTROL_ON   (1)
  82 #define AIO_HARDWARE_FLOW_CONTROL_OFF  (0)
  83 #define AIO_HARDWARE_FLOW_CONTROL_ON   (2)
  84
  85
  86 #define AIO_FLOW_CONTROL_CHARACTERS (4)
  87
  88 #define AIO_SET_DEADMAN_TIMER     (5)
  89
  90 /*----------------------------------------------------------------------------*
  91  *                                                                            *
  92  *    Definitions for use with the AIOGetExternalStatus function.             *
  93  *                                                                            *
  94  *----------------------------------------------------------------------------*/
  95
  96 #define AIO_EXTSTA_RI         (0x00000001)
  97 #define AIO_EXTSTA_DCD        (0x00000008)
  98 #define AIO_EXTSTA_DSR        (0x00000010)
  99 #define AIO_EXTSTA_CTS        (0x00000020)
 100 #define AIO_EXTSTA_BREAK      (0x00000080)
 101
 102
 103 /*----------------------------------------------------------------------------*
 104  *                                                                            *
 105  *    Definitions for use with the AIOFlushBuffers function.                  *
 106  *                                                                            *
 107  *----------------------------------------------------------------------------*/
 108
 109 #define AIO_FLUSH_WRITE_BUFFER    (0x0001)
 110 #define AIO_FLUSH_READ_BUFFER     (0x0002)
 111
 112
 113 /*----------------------------------------------------------------------------*
 114  *                                                                            *
 115  *    Definitions for use with the AIOReadStatus function.                    *
 116  *                                                                            *
 117  *----------------------------------------------------------------------------*/
 118
 119 #define AIO_RECEIVE_ACTIVE   (0)
 120 #define AIO_RECEIVE_FULL     (1)
 121
 122 /*----------------------------------------------------------------------------*
 123  *                                                                            *
 124  *    Definitions for use with the AIOWriteStatus function.                   *
 125  *                                                                            *
 126  *----------------------------------------------------------------------------*/
 127
 128 #define AIO_TRANSMIT_IDLE     (0)
 129 #define AIO_TRANSMIT_ACTIVE   (1)
 130 #define AIO_TRANSMIT_XOFFED   (2)
 131
 132 /*----------------------------------------------------------------------------*
 133  *                                                                            *
 134  *    Definitions for use with the AIOAcquirePort function.                   *
 135  *                                                                            *
 136  *----------------------------------------------------------------------------*/
 137
 138 #define AIO_HARDWARE_TYPE_WILDCARD  (-1)
 139 #define AIO_BOARD_NUMBER_WILDCARD   (-1)
 140 #define AIO_PORT_NUMBER_WILDCARD    (-1)
 141
 142 /*----------------------------------------------------------------------------*
 143  *                                                                            *
 144  *    Definitions for use with the AIOConfigurePort function.                 *
 145  *                                                                            *
 146  *----------------------------------------------------------------------------*/
 147
 148 /* BitRate */
 149
 150 #define AIO_BAUD_50       (0)
 151 #define AIO_BAUD_75       (1)
 152 #define AIO_BAUD_110      (2)
 153 #define AIO_BAUD_134p5    (3)
 154 #define AIO_BAUD_150      (4)
 155 #define AIO_BAUD_300      (5)
 156 #define AIO_BAUD_600      (6)
 157 #define AIO_BAUD_1200     (7)
 158 #define AIO_BAUD_1800     (8)
 159 #define AIO_BAUD_2000     (9)
 160 #define AIO_BAUD_2400     (10)
 161 #define AIO_BAUD_3600     (11)
 162 #define AIO_BAUD_4800     (12)
 163 #define AIO_BAUD_7200     (13)
 164 #define AIO_BAUD_9600     (14)
 165 #define AIO_BAUD_19200    (15)
 166 #define AIO_BAUD_38400    (16)
 167 #define AIO_BAUD_57600    (17)
 168 #define AIO_BAUD_115200   (18)
 169
 170 /* DataBits */
 171
 172 #define AIO_DATA_BITS_5   (0)
 173 #define AIO_DATA_BITS_6   (1)
 174 #define AIO_DATA_BITS_7   (2)
 175 #define AIO_DATA_BITS_8   (3)
 176
 177 /* StopBits */
 178
 179 #define AIO_STOP_BITS_1   (0)
 180 #define AIO_STOP_BITS_1p5 (1)
 181 #define AIO_STOP_BITS_2   (2)
 182
 183 /* Parity */
 184
 185 #define AIO_PARITY_NONE   (0)
 186 #define AIO_PARITY_ODD    (1)
 187 #define AIO_PARITY_EVEN   (2)
 188 #define AIO_PARITY_MARK   (3)
 189 #define AIO_PARITY_SPACE  (4)
 190
 191 /* FlowControl */
 192
 193 #define AIO_SOFTWARE_FLOWCONTROL_OFF  (0)
 194 #define AIO_SOFTWARE_FLOWCONTROL_ON   (1)
 195 #define AIO_HARDWARE_FLOWCONTROL_OFF  (0)
 196 #define AIO_HARDWARE_FLOWCONTROL_ON   (2)
 197
 198 #define AIO_DROPOUT_VALUE   (0xFF)
 199
 200 /*----------------------------------------------------------------------------*
 201  *                                                                            *
 202  *    Definitions for use with AIOPORTCAPABILITIES structure.                 *
 203  *                                                                            *
 204  *----------------------------------------------------------------------------*/
 205
 206 typedef struct
 207   {
 208   WORD    returnLength;       /*  byte length of capabilities data */
 209   BYTE    majorVersion;
 210   BYTE    minorVersion;
 211   LONG    notSupportedMask;
 212   BYTE    minBitRate;         /*  minimum bit rate index supported */
 213   BYTE    maxBitRate;         /*  maximum bit rate index supported */
 214   BYTE    minDataBits;        /*  minimum data bits per char index supported */
 215   BYTE    maxDataBits;        /*  maximum data bits per char index supported */
 216   BYTE    minStopBits;        /*  minimum stop bits per char index supported */
 217   BYTE    maxStopBits;        /*  maximum stop bits per char index supported */
 218   BYTE    minParityMode;      /*  minimum parity mode index supported */
 219   BYTE    maxParityMode;      /*  maximum parity mode index supported */
 220   BYTE    minFlowCtrlMode;    /*  minimum flow control mode index supported */
 221   BYTE    maxFlowCtrlMode;    /*  maximum flow control mode index supported */
 222   LONG    miscCapabilities;   /*  miscellaneous capability flags */
 223   LONG    minReadBufferSize;  /*  minimum length of receive buffer */
 224   LONG    maxReadBufferSize;  /*  maximum length of receive buffer */
 225   LONG    minWriteBufferSize; /*  minimum length of transmit buffer */
 226   LONG    maxWriteBufferSize; /*  maximum length of transmit buffer */
 227   WORD    minDeadmanTime;     /*  minimum deadman time (seconds) */
 228   WORD    maxDeadmanTime;     /*  maximum deadman time (seconds) */
 229   } AIOPORTCAPABILITIES;
 230
 231 #define AIO_PORT_NS_MINBITRATE           (0x80000000)
 232 #define AIO_PORT_NS_MAXBITRATE           (0x40000000)
 233 #define AIO_PORT_NS_MINDATABITS          (0x20000000)
 234 #define AIO_PORT_NS_MAXDATABITS          (0x10000000)
 235 #define AIO_PORT_NS_MINSTOPBITS          (0x08000000)
 236 #define AIO_PORT_NS_MAXSTOPBITS          (0x04000000)
 237 #define AIO_PORT_NS_MINPARITYMODE        (0x02000000)
 238 #define AIO_PORT_NS_MAXPARITYMODE        (0x01000000)
 239 #define AIO_PORT_NS_MINFLOWCTRLMODE      (0x00800000)
 240 #define AIO_PORT_NS_MAXFLOWCTRLMODE      (0x00400000)
 241 #define AIO_PORT_NS_MISCCAPABILITIES     (0x00200000)
 242 #define AIO_PORT_NS_MINREADBUFFERSIZE    (0x00100000)
 243 #define AIO_PORT_NS_MAXREADBUFFERSIZE    (0x00080000)
 244 #define AIO_PORT_NS_MINWRITEBUFFERSIZE   (0x00040000)
 245 #define AIO_PORT_NS_MAXWRITEBUFFERSIZE   (0x00020000)
 246 #define AIO_PORT_NS_MINDEADMANTIME       (0x00010000)
 247 #define AIO_PORT_NS_MAXDEADMANTIME       (0x00008000)
 248
 249 #define AIO_PORT_CAPS_NOT_SUPPORTED (0x00007FFF)
 250 #define AIO_PORT_CAPS_MAJOR_VERSION  (1)
 251 #define AIO_PORT_CAPS_MINOR_VERSION  (0)
 252
 253 #define AIO_CAP_OUTPUT_BREAK    (0x00000002)
 254 #define AIO_CAP_FLOWCTRLCHARS   (0x00000004)
 255 #define AIO_CAP_PROGRAMMABLE    (0x00000008)
 256 #define AIO_CAP_INPUT           (0x00000010)
 257 #define AIO_CAP_OUTPUT          (0x00000020)
 258
 259
 260 typedef struct
 261   {
 262   WORD    returnLength;       /*  byte length of driver capabilities structure */
 263   BYTE    byteData[2];
 264   } AIODVRCAPABILITIES;
 265
 266 #define AIO_NO_STRUCT_DATA_RETURNED   (2)
 267
 268 /*----------------------------------------------------------------------------*
 269  *                                                                            *
 270  *    Definitions for use with the AIOGetPortsRollCall function.              *
 271  *                                                                            *
 272  *----------------------------------------------------------------------------*/
 273
 274 typedef struct
 275   {
 276   WORD    returnLength;       /*  byte length of port info data */
 277   BYTE    majorVersion;
 278   BYTE    minorVersion;
 279   LONG    notSupportedMask;
 280   int     hardwareType;       /*  value used with AIOAcquirePort   */
 281   int     boardNumber;        /*    "                              */
 282   int     portNumber;         /*    "                              */
 283   WORD    availability;       /*  availability of port for acquire */
 284   LONG    externalStatus;     /*  current external status value for port */
 285   LONG    chgdExternalStatus; /*  changed external status value for port  */
 286   } AIOPORTINFO;
 287
 288 #define AIO_INFO_NS_HARDWARETYPE         (0x80000000)
 289 #define AIO_INFO_NS_BOARDNUMBER          (0x40000000)
 290 #define AIO_INFO_NS_PORTNUMBER           (0x20000000)
 291 #define AIO_INFO_NS_AVAILABILITY         (0x10000000)
 292 #define AIO_INFO_NS_EXTERNALSTATUS       (0x08000000)
 293 #define AIO_INFO_NS_CHGDEXTERNALSTATUS   (0x04000000)
 294
 295 #define AIO_PORT_INFO_NOT_SUPPORTED (0x03FFFFFF)
 296 #define AIO_PORT_INFO_MAJOR_VERSION   (1)
 297 #define AIO_PORT_INFO_MINOR_VERSION   (0)
 298
 299 #define AIO_AVAILABLE_FOR_ACQUIRE   (0)
 300 #define AIO_ALREADY_ACQUIRED        (1)
 301 #define AIO_UNAVAILABLE             (0xFF)
 302
 303 #define AIO_INITIAL       (0)
 304 #define AIO_SUCCESSOR     (1)
 305
 306
 307 /*----------------------------------------------------------------------------*
 308  *                                                                            *
 309  *    Definitions for use with the AIOGetPortConfiguration function.          *
 310  *                                                                            *
 311  *----------------------------------------------------------------------------*/
 312
 313 typedef struct
 314   {
 315   WORD    returnLength;       /*  byte length of port configuration data */
 316   BYTE    majorVersion;
 317   BYTE    minorVersion;
 318   LONG    notSupportedMask;
 319   int     hardwareType;       /*  value used with AIOAcquirePort     */
 320   int     boardNumber;        /*    "  */
 321   int     portNumber;         /*    " */
 322   BYTE    bitRate;            /*  Bits per second index */
 323   BYTE    dataBits;           /*  Bits per character index */
 324   BYTE    stopBits;           /*  Stop bits per char index */
 325   BYTE    parityMode;         /*  Generated parity index */
 326   BYTE    flowCtrlMode;       /*  Flow control mode */
 327   BYTE    breakMode;          /*  Break control mode */
 328   LONG    readSize;           /*  Receive buffer size */
 329   LONG    writeSize;          /*  Transmit buffer size */
 330   BYTE    transmitXon;
 331   BYTE    transmitXoff;
 332   BYTE    receiveXon;
 333   BYTE    receiveXoff;
 334   WORD    externalControl;    /*  set with AIO_EXTERNAL_CONTROL */
 335
 336   } AIOPORTCONFIG;
 337
 338 #define AIO_CONFIG_NS_HARDWARETYPE         (0x80000000)
 339 #define AIO_CONFIG_NS_BOARDNUMBER          (0x40000000)
 340 #define AIO_CONFIG_NS_PORTNUMBER           (0x20000000)
 341 #define AIO_CONFIG_NS_BITRATE              (0x10000000)
 342 #define AIO_CONFIG_NS_DATABITS             (0x08000000)
 343 #define AIO_CONFIG_NS_STOPBITS             (0x04000000)
 344 #define AIO_CONFIG_NS_PARITYMODE           (0x02000000)
 345 #define AIO_CONFIG_NS_FLOWCTRLMODE         (0x01000000)
 346 #define AIO_CONFIG_NS_BREAKMODE            (0x00800000)
 347 #define AIO_CONFIG_NS_READSIZE             (0x00400000)
 348 #define AIO_CONFIG_NS_WRITESIZE            (0x00200000)
 349 #define AIO_CONFIG_NS_TRANSMITXON          (0x00100000)
 350 #define AIO_CONFIG_NS_TRANSMITXOFF         (0x00080000)
 351 #define AIO_CONFIG_NS_RECEIVEXON           (0x00040000)
 352 #define AIO_CONFIG_NS_RECEIVEXOFF          (0x00020000)
 353 #define AIO_CONFIG_NS_EXTERNALCONTROL      (0x00010000)
 354
 355 #define AIO_PORT_CONFIG_NOT_SUPPORTED (0x0007FFFF)
 356 #define AIO_PORT_CONFIG_MAJOR_VERSION   (1)
 357 #define AIO_PORT_CONFIG_MINOR_VERSION   (0)
 358
 359 #define AIO_EXTCTRL_DTR_ENABLE          (1)
 360 #define AIO_EXTCTRL_DTR_DISABLE         (0)
 361 #define AIO_EXTCTRL_RTS_ENABLE          (2)
 362 #define AIO_EXTCTRL_RTS_DISABLE         (0)
 363
 364 #define AIO_BREAK_MODE_OFF           (0)
 365 #define AIO_BREAK_MODE_ON            (1)
 366
 367 typedef struct
 368   {
 369   WORD    returnLength;       /*  byte length of driver config structure */
 370   BYTE    byteData[2];
 371   } AIODVRCONFIG;
 372
 373 /*----------------------------------------------------------------------------*
 374  *                                                                            *
 375  *    Definitions for use with the AIOGetStatistics function.                 *
 376  *                                                                            *
 377  *----------------------------------------------------------------------------*/
 378
 379 typedef struct
 380   {
 381   WORD    returnLength;       /*  byte length of port statistics structure */
 382   BYTE    majorVersion;
 383   BYTE    minorVersion;
 384   LONG    notSupportedMask;
 385   LONG    receiveBytes;       /*  total number of bytes received on port */
 386   LONG    transmitBytes;      /*  total number of bytes transmitted from port */
 387   LONG    parityErrors;       /*  number of receive parity errors  */
 388   LONG    framingErrors;      /*  number of receive framing errors */
 389   LONG    overrunSoftware;    /*  number of software overruns (occurrences) */
 390   LONG    overrunHardware;    /*  number of hardware overruns (occurrences) */
 391   } AIOPORTSTATISTICS;
 392
 393 #define AIO_STATS_NS_RECEIVEBYTES         (0x80000000)
 394 #define AIO_STATS_NS_TRANSMITBYTES        (0x40000000)
 395 #define AIO_STATS_NS_PARITYERRORS         (0x20000000)
 396 #define AIO_STATS_NS_FRAMINGERRORS        (0x10000000)
 397 #define AIO_STATS_NS_OVERRUNSOFTWARE      (0x08000000)
 398 #define AIO_STATS_NS_OVERRUNHARDWARE      (0x04000000)
 399
 400 #define AIO_PORT_STATS_NOT_SUPPORTED  (0x03FFFFFF)
 401 #define AIO_PORT_STATS_MAJOR_VERSION  (1)
 402 #define AIO_PORT_STATS_MINOR_VERSION  (0)
 403
 404 typedef struct
 405   {
 406   WORD    returnLength;       /*  byte length of driver statistics structure */
 407   BYTE    byteData[2];
 408   } AIODVRSTATISTICS;
 409
 410 /*----------------------------------------------------------------------------*
 411  *                                                                            *
 412  *    Definitions for use with AIOGetDriverList function.                     *
 413  *                                                                            *
 414  *----------------------------------------------------------------------------*/
 415
 416 typedef struct
 417   {
 418   int     hardwareType;
 419   int     ports;
 420   char    name[128];
 421   } AIODRIVERLISTENTRY;
 422
 423 typedef struct
 424   {
 425   WORD                returnLength;
 426   AIODRIVERLISTENTRY  driver[1];
 427   } AIODRIVERLIST;
 428
 429 #define AIO_DRIVER_LIST_GET_FIRST   (-1)
 430
 431
 432 /*----------------------------------------------------------------------------*
 433  *                                                                            *
 434  *    Definitions for use with AIOGetBoardList function.                      *
 435  *                                                                            *
 436  *----------------------------------------------------------------------------*/
 437
 438 typedef struct
 439   {
 440   int     boardNumber;
 441   int     ports;
 442   char    name[128];
 443   } AIOBOARDLISTENTRY;
 444
 445 typedef struct
 446   {
 447   WORD               returnLength;
 448   AIOBOARDLISTENTRY  board[1];
 449   } AIOBOARDLIST;
 450
 451 #define AIO_BOARD_LIST_GET_FIRST    (-1)
 452
 453 /*----------------------------------------------------------------------------*
 454  *                                                                            *
 455  *    Definitions for use with AIOSetControlData function.                    *
 456  *                                                                            *
 457  *----------------------------------------------------------------------------*/
 458
 459 typedef struct
 460   {
 461   WORD    returnLength;       /*  byte length of control data structure */
 462   BYTE    byteData[2];
 463   } AIOCONTROLDATA;
 464
 465 /*----------------------------------------------------------------------------*
 466  *                                                                            *
 467  *    Definitions for use with AIOGetFirstPortInfo and AIOGetNextPortInfo     *
 468  *                                                                            *
 469  *----------------------------------------------------------------------------*/
 470
 471 typedef struct
 472   {
 473   int     typeMask;
 474   int     boardMask;
 475   int     portMask;
 476   int     reserved[6];
 477   } AIOPORTSEARCH;
 478
 479         /* reserved index values */
 480
 481 #define SEARCH_TYPE_INDEX     0
 482 #define SEARCH_BOARD_INDEX    1
 483 #define SEARCH_PORT_INDEX     2
 484
 485
 486 /*----------------------------------------------------------------------------*
 487  *                                                                            *
 488  *    Definition of AIO functions.                                            *
 489  *                                                                            *
 490  *----------------------------------------------------------------------------*/
 491
 492 extern  int  AIOAcquirePort           ( int   *hardwareType,
 493                                         int   *boardNumber,
 494                                         int   *portNumber,
 495                                         int   *portHandle
 496                                       );
 497
 498 extern  int  AIOAcquirePortWithRTag   ( int   *hardwareType,
 499                                         int   *boardNumber,
 500                                         int   *portNumber,
 501                                         int   *portHandle,
 502                                         LONG   RTag
 503                                       );
 504
 505 extern  int  AIOConfigurePort         ( int   portHandle,
 506                                         BYTE  bitRate,
 507                                         BYTE  dataBits,
 508                                         BYTE  stopBits,
 509                                         BYTE  parityMode,
 510                                         BYTE  flowCtrlMode
 511                                       );
 512
 513 extern  int  AIOFlushBuffers          ( int   portHandle,
 514                                         WORD  flushFlag
 515                                       );
 516
 517 extern int AIOGetBoardList( int             hardwareType,
 518                             int             boardIndex,
 519                             AIOBOARDLIST   *pBoardList );
 520
 521 extern  int  AIOGetDriverList         ( int   lastHardwareType,
 522                                         AIODRIVERLIST *pDriverList
 523                                       );
 524
 525 extern  int  AIOGetExternalStatus     ( int   portHandle,
 526                                         LONG  *extStatus,
 527                                         LONG  *chgdExtStatus
 528                                       );
 529
 530 extern int   AIOGetFirstPortInfo      ( int                 hardwareType,
 531                                         int                 boardNumber,
 532                                         int                 portNumber,
 533                                         AIOPORTSEARCH       *portSearchP,
 534                                         AIOPORTINFO         *portInfoP,
 535                                         AIOPORTCAPABILITIES *capabilitiesP,
 536                                         AIODVRCAPABILITIES  *dvrCapabilitiesP,
 537                                         char                *NLMModuleNameP );
 538
 539 extern int   AIOGetNextPortInfo       ( AIOPORTSEARCH       *portSearchP,
 540                                         AIOPORTINFO         *portInfoP,
 541                                         AIOPORTCAPABILITIES *capabilitiesP,
 542                                         AIODVRCAPABILITIES  *dvrCapabilitiesP,
 543                                         char                *NLMModuleNameP );
 544
 545 extern  int  AIOGetPortCapability     ( int                 portHandle,
 546                                         AIOPORTCAPABILITIES *pCapabilities,
 547                                         AIODVRCAPABILITIES  *pDvrCapabilities
 548                                       );
 549
 550 extern  int  AIOGetPortConfiguration  ( int                 portHandle,
 551                                         AIOPORTCONFIG       *pPortConfig,
 552                                         AIODVRCONFIG        *pDvrConfig
 553                                       );
 554
 555 extern  int  AIOGetPortStatus         ( int   portHandle,
 556                                         LONG  *writeCount,
 557                                         WORD  *writeState,
 558                                         LONG  *readCount,
 559                                         WORD  *readState,
 560                                         LONG  *extStatus,
 561                                         LONG  *chgdExtStatus
 562                                       );
 563
 564 extern  int  AIOGetReadBufferSize     ( int   portHandle,
 565                                         LONG  *readSize
 566                                       );
 567
 568 extern  int  AIOGetPortStatistics     ( int   portHandle,
 569                                         AIOPORTSTATISTICS   *pPortStatistics,
 570                                         AIODVRSTATISTICS    *pDvrStatistics
 571                                       );
 572
 573 extern int   AIOGetFirstPortStatistics( int                 hardwareType,
 574                                         int                 boardNumber,
 575                                         int                 portNumber,
 576                                         AIOPORTSEARCH       *portSearchP,
 577                                         AIOPORTSTATISTICS   *pPortStatistics,
 578                                         AIODVRSTATISTICS    *pDvrStatistics
 579                                       );
 580
 581 extern int   AIOGetNextPortStatistics ( AIOPORTSEARCH       *portSearchP,
 582                                         AIOPORTSTATISTICS   *pPortStatistics,
 583                                         AIODVRSTATISTICS    *pDvrStatistics
 584                                       );
 585
 586 extern  int  AIOGetWriteBufferSize    ( int   portHandle,
 587                                         LONG  *writeSize
 588                                       );
 589
 590 extern  int  AIOReadData              ( int   portHandle,
 591                                         char  *buffer,
 592                                         LONG  length,
 593                                         LONG  *numberBytesRead
 594                                       );
 595
 596 extern  int  AIOReadStatus            ( int   portHandle,
 597                                         LONG  *count,
 598                                         WORD  *state
 599                                       );
 600
 601 extern  int  AIOReleasePort           ( int   portHandle );
 602
 603 extern  int  AIOSetControlData        ( int   portHandle,
 604                                         int   requestType,
 605                                         AIOCONTROLDATA *requestStructValue
 606                                       );
 607
 608 extern  int  AIOSetExternalControl    ( int   portHandle,
 609                                         int   requestType,
 610                                         int   requestValue
 611                                       );
 612
 613 extern  int  AIOSetFlowControl        ( int   portHandle,
 614                                         int   flowCtrlMode
 615                                       );
 616
 617 extern  int  AIOSetFlowControlCharacters( int   portHandle,
 618                                         BYTE  transmitXon,
 619                                         BYTE  transmitXoff,
 620                                         BYTE  receiveXon,
 621                                         BYTE  receiveXoff
 622                                       );
 623
 624 extern  int  AIOSetReadBufferSize     ( int    portHandle,
 625                                         LONG   bufferSize
 626                                       );
 627
 628 extern  int  AIOSetWriteBufferSize    ( int    portHandle,
 629                                         LONG   bufferSize
 630                                       );
 631
 632 extern  int  AIOWriteData             ( int   portHandle,
 633                                         char  *buffer,
 634                                         LONG  length,
 635                                         LONG  *numberBytesWritten
 636                                       );
 637
 638 extern  int  AIOWriteStatus           ( int   portHandle,
 639                                         LONG  *count,
 640                                         WORD  *state
 641                                       );
 642
 643 /* -=-=-= Random stuff -=-=-=-= */
 644
 645 #define isspace(C) (C == '\n' || C == '\r' || C == ' ' || C == '\t')
 646 int Breakpoint (int __arg);
 647
 648 #define ULONG unsigned long
 649
 650 #define COM1 0x8000
 651 #define COM2 0x9000