[deliverable/binutils-gdb.git] / gdb / nlm / aio.h

#ifndef _AIO_H_
#define _AIO_H_

/*----------------------------------------------------------------------------*
 *									      *
 *	NetWare 386 Developer's Asynchronous I/O (AIO) Runtime library        *
 *									      *
 *	This include file defines the constants and prototypes required	      *
 *	to use the AIO application interface.				      *
 *									      *
 *	(c) Copyright.	1991 Novell, Inc.   All rights reserved.	      *
 *									      *
 *----------------------------------------------------------------------------*/

typedef unsigned long DWORD;


/*----------------------------------------------------------------------------*
 *									      *
 *    Predefined hardware types for use with the AIOAcquirePort function.     *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_COMX_TYPE		  (1)
#define AIO_ARTIC_TYPE		  (2)
#define AIO_WNIM_TYPE		  (3)


/*----------------------------------------------------------------------------*
 *									      *
 *    Function completion code status values.				      *
 *									      *
 *    Note that all error statuses are negative values.			      *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_SUCCESS		  (0)
#define AIO_BAD_HANDLE		  (-1)
#define AIO_FAILURE		  (-2)
#define AIO_FUNC_NOT_SUPPORTED	  (-3)
#define AIO_INVALID_PARAMETER	  (-5)
#define AIO_PORT_NOT_AVAILABLE	  (-6)
#define AIO_QUALIFIED_SUCCESS	  (-7)
#define AIO_NO_MORE_PORTS	  (-8)
#define AIO_TYPE_NUMBER_INVALID	  (-10)
#define AIO_BOARD_NUMBER_INVALID  (-11)
#define AIO_PORT_NUMBER_INVALID	  (-12)
#define AIO_RESOURCE_TAG_INVALID  (-13)
#define AIO_DATA_PRESENT	  (-14)
#define AIO_BAD_REQUEST_TYPE	  (-15)
#define AIO_PORT_GONE		  (-20)
#define AIO_RTAG_INVALID	  (-21)


/* This is only for non-CLIB application */

#define ASYNCIOSignature  0x4E595341   /* 'NYSA' */

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOSetExternalControl function.	      *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_EXTERNAL_CONTROL	  (1)  
#define AIO_EXTCTRL_DTR		    (1)
#define AIO_EXTCTRL_RTS		    (2)


#define AIO_BREAK_CONTROL	  (2)
#define AIO_SET_BREAK_OFF	    (0)
#define AIO_SET_BREAK_ON	    (1)


#define AIO_FLOW_CONTROL	  (3)
#define AIO_SOFTWARE_FLOW_CONTROL_OFF  (0)
#define AIO_SOFTWARE_FLOW_CONTROL_ON   (1)
#define AIO_HARDWARE_FLOW_CONTROL_OFF  (0)
#define AIO_HARDWARE_FLOW_CONTROL_ON   (2)


#define AIO_FLOW_CONTROL_CHARACTERS (4)	 

#define AIO_SET_DEADMAN_TIMER	  (5)  

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOGetExternalStatus function.	      *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_EXTSTA_RI	      (0x00000001)
#define AIO_EXTSTA_DCD	      (0x00000008)
#define AIO_EXTSTA_DSR	      (0x00000010)
#define AIO_EXTSTA_CTS	      (0x00000020)
#define AIO_EXTSTA_BREAK      (0x00000080)


/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOFlushBuffers function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_FLUSH_WRITE_BUFFER	  (0x0001)
#define AIO_FLUSH_READ_BUFFER	  (0x0002)


/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOReadStatus function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_RECEIVE_ACTIVE   (0)
#define AIO_RECEIVE_FULL     (1)

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOWriteStatus function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_TRANSMIT_IDLE     (0)
#define AIO_TRANSMIT_ACTIVE   (1)
#define AIO_TRANSMIT_XOFFED   (2)

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOAcquirePort function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

#define AIO_HARDWARE_TYPE_WILDCARD  (-1)
#define AIO_BOARD_NUMBER_WILDCARD   (-1)
#define AIO_PORT_NUMBER_WILDCARD    (-1)

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOConfigurePort function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

/* BitRate */
			  
#define AIO_BAUD_50	  (0)
#define AIO_BAUD_75	  (1)
#define AIO_BAUD_110	  (2)
#define AIO_BAUD_134p5	  (3)
#define AIO_BAUD_150	  (4)
#define AIO_BAUD_300	  (5)
#define AIO_BAUD_600	  (6)
#define AIO_BAUD_1200	  (7)
#define AIO_BAUD_1800	  (8)
#define AIO_BAUD_2000	  (9)
#define AIO_BAUD_2400	  (10)
#define AIO_BAUD_3600	  (11)
#define AIO_BAUD_4800	  (12)
#define AIO_BAUD_7200	  (13)
#define AIO_BAUD_9600	  (14)
#define AIO_BAUD_19200	  (15)
#define AIO_BAUD_38400	  (16)
#define AIO_BAUD_57600	  (17)
#define AIO_BAUD_115200	  (18)
			  
/* DataBits */

#define AIO_DATA_BITS_5	  (0)
#define AIO_DATA_BITS_6	  (1)
#define AIO_DATA_BITS_7	  (2)
#define AIO_DATA_BITS_8	  (3)

/* StopBits */
			     
#define AIO_STOP_BITS_1	  (0)
#define AIO_STOP_BITS_1p5 (1)
#define AIO_STOP_BITS_2	  (2)
			    
/* Parity */

#define AIO_PARITY_NONE	  (0)
#define AIO_PARITY_ODD	  (1)
#define AIO_PARITY_EVEN	  (2)
#define AIO_PARITY_MARK	  (3)
#define AIO_PARITY_SPACE  (4)

/* FlowControl */
				      
#define AIO_SOFTWARE_FLOWCONTROL_OFF  (0)
#define AIO_SOFTWARE_FLOWCONTROL_ON   (1)
#define AIO_HARDWARE_FLOWCONTROL_OFF  (0)
#define AIO_HARDWARE_FLOWCONTROL_ON   (2)

#define AIO_DROPOUT_VALUE   (0xFF)

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with AIOPORTCAPABILITIES structure.		      *
 *									      *
 *----------------------------------------------------------------------------*/
			      
typedef struct
  {			      
  WORD	  returnLength;	      /*  byte length of capabilities data */
  BYTE	  majorVersion;
  BYTE	  minorVersion;
  LONG	  notSupportedMask;
  BYTE	  minBitRate;	      /*  minimum bit rate index supported */
  BYTE	  maxBitRate;	      /*  maximum bit rate index supported */
  BYTE	  minDataBits;	      /*  minimum data bits per char index supported */
  BYTE	  maxDataBits;	      /*  maximum data bits per char index supported */
  BYTE	  minStopBits;	      /*  minimum stop bits per char index supported */
  BYTE	  maxStopBits;	      /*  maximum stop bits per char index supported */
  BYTE	  minParityMode;      /*  minimum parity mode index supported */
  BYTE	  maxParityMode;      /*  maximum parity mode index supported */
  BYTE	  minFlowCtrlMode;    /*  minimum flow control mode index supported */
  BYTE	  maxFlowCtrlMode;    /*  maximum flow control mode index supported */
  LONG	  miscCapabilities;   /*  miscellaneous capability flags */
  LONG	  minReadBufferSize;  /*  minimum length of receive buffer */
  LONG	  maxReadBufferSize;  /*  maximum length of receive buffer */
  LONG	  minWriteBufferSize; /*  minimum length of transmit buffer */
  LONG	  maxWriteBufferSize; /*  maximum length of transmit buffer */
  WORD	  minDeadmanTime;     /*  minimum deadman time (seconds) */
  WORD	  maxDeadmanTime;     /*  maximum deadman time (seconds) */
  } AIOPORTCAPABILITIES;

#define AIO_PORT_NS_MINBITRATE		 (0x80000000)
#define AIO_PORT_NS_MAXBITRATE		 (0x40000000)
#define AIO_PORT_NS_MINDATABITS		 (0x20000000)
#define AIO_PORT_NS_MAXDATABITS		 (0x10000000)
#define AIO_PORT_NS_MINSTOPBITS		 (0x08000000)
#define AIO_PORT_NS_MAXSTOPBITS		 (0x04000000)
#define AIO_PORT_NS_MINPARITYMODE	 (0x02000000)
#define AIO_PORT_NS_MAXPARITYMODE	 (0x01000000)
#define AIO_PORT_NS_MINFLOWCTRLMODE	 (0x00800000)
#define AIO_PORT_NS_MAXFLOWCTRLMODE	 (0x00400000)
#define AIO_PORT_NS_MISCCAPABILITIES	 (0x00200000)
#define AIO_PORT_NS_MINREADBUFFERSIZE	 (0x00100000)
#define AIO_PORT_NS_MAXREADBUFFERSIZE	 (0x00080000)
#define AIO_PORT_NS_MINWRITEBUFFERSIZE	 (0x00040000)
#define AIO_PORT_NS_MAXWRITEBUFFERSIZE	 (0x00020000)
#define AIO_PORT_NS_MINDEADMANTIME	 (0x00010000)
#define AIO_PORT_NS_MAXDEADMANTIME	 (0x00008000) 

#define AIO_PORT_CAPS_NOT_SUPPORTED (0x00007FFF)
#define AIO_PORT_CAPS_MAJOR_VERSION  (1)
#define AIO_PORT_CAPS_MINOR_VERSION  (0)

#define AIO_CAP_OUTPUT_BREAK	(0x00000002)
#define AIO_CAP_FLOWCTRLCHARS	(0x00000004)
#define AIO_CAP_PROGRAMMABLE	(0x00000008)
#define AIO_CAP_INPUT		(0x00000010)
#define AIO_CAP_OUTPUT		(0x00000020)


typedef struct 
  {
  WORD	  returnLength;	      /*  byte length of driver capabilities structure */
  BYTE	  byteData[2];
  } AIODVRCAPABILITIES;

#define AIO_NO_STRUCT_DATA_RETURNED   (2)

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOGetPortsRollCall function.	      *
 *									      *
 *----------------------------------------------------------------------------*/

typedef struct
  {
  WORD	  returnLength;	      /*  byte length of port info data */
  BYTE	  majorVersion;
  BYTE	  minorVersion;
  LONG	  notSupportedMask;
  int	  hardwareType;	      /*  value used with AIOAcquirePort   */  
  int	  boardNumber;	      /*    " 				   */
  int	  portNumber;	      /*    "				   */
  WORD	  availability;	      /*  availability of port for acquire */
  LONG	  externalStatus;     /*  current external status value for port */
  LONG	  chgdExternalStatus; /*  changed external status value for port  */
  } AIOPORTINFO;

#define AIO_INFO_NS_HARDWARETYPE	 (0x80000000)
#define AIO_INFO_NS_BOARDNUMBER		 (0x40000000)
#define AIO_INFO_NS_PORTNUMBER		 (0x20000000)
#define AIO_INFO_NS_AVAILABILITY	 (0x10000000)
#define AIO_INFO_NS_EXTERNALSTATUS	 (0x08000000)
#define AIO_INFO_NS_CHGDEXTERNALSTATUS	 (0x04000000)

#define AIO_PORT_INFO_NOT_SUPPORTED (0x03FFFFFF)
#define AIO_PORT_INFO_MAJOR_VERSION   (1)
#define AIO_PORT_INFO_MINOR_VERSION   (0)

#define AIO_AVAILABLE_FOR_ACQUIRE   (0)
#define AIO_ALREADY_ACQUIRED	    (1)
#define AIO_UNAVAILABLE		    (0xFF)

#define AIO_INITIAL	  (0)
#define AIO_SUCCESSOR	  (1)	 


/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOGetPortConfiguration function.	      *
 *									      *
 *----------------------------------------------------------------------------*/

typedef struct
  {
  WORD	  returnLength;	      /*  byte length of port configuration data */
  BYTE	  majorVersion;
  BYTE	  minorVersion;
  LONG	  notSupportedMask;
  int	  hardwareType;	      /*  value used with AIOAcquirePort     */
  int	  boardNumber;	      /*    "  */
  int	  portNumber;	      /*    " */
  BYTE	  bitRate;	      /*  Bits per second index */
  BYTE	  dataBits;	      /*  Bits per character index */
  BYTE	  stopBits;	      /*  Stop bits per char index */
  BYTE	  parityMode;	      /*  Generated parity index */
  BYTE	  flowCtrlMode;	      /*  Flow control mode */
  BYTE	  breakMode;	      /*  Break control mode */
  LONG	  readSize;	      /*  Receive buffer size */
  LONG	  writeSize;	      /*  Transmit buffer size */
  BYTE	  transmitXon;	 
  BYTE	  transmitXoff;	 
  BYTE	  receiveXon;	 
  BYTE	  receiveXoff;
  WORD	  externalControl;    /*  set with AIO_EXTERNAL_CONTROL */

  } AIOPORTCONFIG;

#define AIO_CONFIG_NS_HARDWARETYPE	   (0x80000000)
#define AIO_CONFIG_NS_BOARDNUMBER	   (0x40000000)
#define AIO_CONFIG_NS_PORTNUMBER	   (0x20000000)
#define AIO_CONFIG_NS_BITRATE		   (0x10000000)
#define AIO_CONFIG_NS_DATABITS		   (0x08000000)
#define AIO_CONFIG_NS_STOPBITS		   (0x04000000)
#define AIO_CONFIG_NS_PARITYMODE	   (0x02000000)
#define AIO_CONFIG_NS_FLOWCTRLMODE	   (0x01000000)
#define AIO_CONFIG_NS_BREAKMODE		   (0x00800000)
#define AIO_CONFIG_NS_READSIZE		   (0x00400000)
#define AIO_CONFIG_NS_WRITESIZE		   (0x00200000)
#define AIO_CONFIG_NS_TRANSMITXON	   (0x00100000)
#define AIO_CONFIG_NS_TRANSMITXOFF	   (0x00080000)
#define AIO_CONFIG_NS_RECEIVEXON	   (0x00040000)
#define AIO_CONFIG_NS_RECEIVEXOFF	   (0x00020000)
#define AIO_CONFIG_NS_EXTERNALCONTROL	   (0x00010000)

#define AIO_PORT_CONFIG_NOT_SUPPORTED (0x0007FFFF)
#define AIO_PORT_CONFIG_MAJOR_VERSION	(1)
#define AIO_PORT_CONFIG_MINOR_VERSION	(0)

#define AIO_EXTCTRL_DTR_ENABLE		(1)
#define AIO_EXTCTRL_DTR_DISABLE		(0)
#define AIO_EXTCTRL_RTS_ENABLE		(2)
#define AIO_EXTCTRL_RTS_DISABLE		(0)

#define AIO_BREAK_MODE_OFF	     (0)
#define AIO_BREAK_MODE_ON	     (1)

typedef struct 
  {
  WORD	  returnLength;	      /*  byte length of driver config structure */
  BYTE	  byteData[2];
  } AIODVRCONFIG;

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with the AIOGetStatistics function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

typedef struct 
  {
  WORD	  returnLength;	      /*  byte length of port statistics structure */
  BYTE	  majorVersion;
  BYTE	  minorVersion;
  LONG	  notSupportedMask;
  LONG	  receiveBytes;	      /*  total number of bytes received on port */
  LONG	  transmitBytes;      /*  total number of bytes transmitted from port */
  LONG	  parityErrors;	      /*  number of receive parity errors  */
  LONG	  framingErrors;      /*  number of receive framing errors */
  LONG	  overrunSoftware;    /*  number of software overruns (occurrences) */
  LONG	  overrunHardware;    /*  number of hardware overruns (occurrences) */
  } AIOPORTSTATISTICS;

#define AIO_STATS_NS_RECEIVEBYTES	  (0x80000000)
#define AIO_STATS_NS_TRANSMITBYTES	  (0x40000000)
#define AIO_STATS_NS_PARITYERRORS	  (0x20000000)
#define AIO_STATS_NS_FRAMINGERRORS	  (0x10000000)
#define AIO_STATS_NS_OVERRUNSOFTWARE	  (0x08000000)
#define AIO_STATS_NS_OVERRUNHARDWARE	  (0x04000000)

#define AIO_PORT_STATS_NOT_SUPPORTED  (0x03FFFFFF)
#define AIO_PORT_STATS_MAJOR_VERSION  (1)
#define AIO_PORT_STATS_MINOR_VERSION  (0)

typedef struct 
  {
  WORD	  returnLength;	      /*  byte length of driver statistics structure */
  BYTE	  byteData[2];
  } AIODVRSTATISTICS;

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with AIOGetDriverList function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

typedef struct
  {
  int	  hardwareType;
  int	  ports;
  char	  name[128];
  } AIODRIVERLISTENTRY;

typedef struct
  {
  WORD		      returnLength;
  AIODRIVERLISTENTRY  driver[1];
  } AIODRIVERLIST;

#define AIO_DRIVER_LIST_GET_FIRST   (-1)


/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with AIOGetBoardList function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

typedef struct
  {
  int	  boardNumber;
  int	  ports;
  char	  name[128];
  } AIOBOARDLISTENTRY;

typedef struct
  {
  WORD		     returnLength;
  AIOBOARDLISTENTRY  board[1];
  } AIOBOARDLIST;

#define AIO_BOARD_LIST_GET_FIRST    (-1)

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with AIOSetControlData function.		      *
 *									      *
 *----------------------------------------------------------------------------*/

typedef struct 
  {
  WORD	  returnLength;	      /*  byte length of control data structure */
  BYTE	  byteData[2];
  } AIOCONTROLDATA;

/*----------------------------------------------------------------------------*
 *									      *
 *    Definitions for use with AIOGetFirstPortInfo and AIOGetNextPortInfo     *
 *									      *
 *----------------------------------------------------------------------------*/

typedef struct
  {
  int	  typeMask;
  int	  boardMask;
  int	  portMask;
  int	  reserved[6];
  } AIOPORTSEARCH;

	/* reserved index values */

#define SEARCH_TYPE_INDEX     0
#define SEARCH_BOARD_INDEX    1
#define SEARCH_PORT_INDEX     2


/*----------------------------------------------------------------------------*
 *									      *
 *    Definition of AIO functions.					      *
 *									      *
 *----------------------------------------------------------------------------*/

extern	int  AIOAcquirePort	      ( int   *hardwareType,
					int   *boardNumber,
					int   *portNumber,
					int   *portHandle
				      );

extern	int  AIOAcquirePortWithRTag   ( int   *hardwareType,
					int   *boardNumber,	  
					int   *portNumber,	  
					int   *portHandle,	  
					LONG   RTag
				      );

extern	int  AIOConfigurePort	      ( int   portHandle,
					BYTE  bitRate,
					BYTE  dataBits,
					BYTE  stopBits,
					BYTE  parityMode,
					BYTE  flowCtrlMode
				      );
	
extern	int  AIOFlushBuffers	      ( int   portHandle,
					WORD  flushFlag
				      );
	
extern int AIOGetBoardList( int		    hardwareType,
			    int		    boardIndex,
			    AIOBOARDLIST   *pBoardList );

extern	int  AIOGetDriverList	      ( int   lastHardwareType,
					AIODRIVERLIST *pDriverList
				      );
       
extern	int  AIOGetExternalStatus     ( int   portHandle,
					LONG  *extStatus,
					LONG  *chgdExtStatus
				      );

extern int   AIOGetFirstPortInfo      ( int		    hardwareType,
					int		    boardNumber,    
					int		    portNumber,	   
					AIOPORTSEARCH	    *portSearchP,    
					AIOPORTINFO	    *portInfoP,	   
					AIOPORTCAPABILITIES *capabilitiesP,   
					AIODVRCAPABILITIES  *dvrCapabilitiesP,
					char		    *NLMModuleNameP );

extern int   AIOGetNextPortInfo	      ( AIOPORTSEARCH	    *portSearchP,	
					AIOPORTINFO	    *portInfoP,	      
					AIOPORTCAPABILITIES *capabilitiesP,   
					AIODVRCAPABILITIES  *dvrCapabilitiesP,
					char		    *NLMModuleNameP );
       
extern	int  AIOGetPortCapability     ( int		    portHandle,
					AIOPORTCAPABILITIES *pCapabilities,
					AIODVRCAPABILITIES  *pDvrCapabilities
				      );

extern	int  AIOGetPortConfiguration  ( int		    portHandle,
					AIOPORTCONFIG	    *pPortConfig,
					AIODVRCONFIG	    *pDvrConfig
				      );

extern	int  AIOGetPortStatus	      ( int   portHandle,
					LONG  *writeCount,
					WORD  *writeState,
					LONG  *readCount,
					WORD  *readState,
					LONG  *extStatus,
					LONG  *chgdExtStatus
				      );
	
extern	int  AIOGetReadBufferSize     ( int   portHandle,
					LONG  *readSize
				      );
	
extern	int  AIOGetPortStatistics     ( int   portHandle,
					AIOPORTSTATISTICS   *pPortStatistics,
					AIODVRSTATISTICS    *pDvrStatistics
				      );

extern int   AIOGetFirstPortStatistics( int		    hardwareType,
					int		    boardNumber,    
					int		    portNumber,	   
					AIOPORTSEARCH	    *portSearchP,    
					AIOPORTSTATISTICS   *pPortStatistics,
					AIODVRSTATISTICS    *pDvrStatistics
				      );

extern int   AIOGetNextPortStatistics ( AIOPORTSEARCH	    *portSearchP,	
					AIOPORTSTATISTICS   *pPortStatistics,
					AIODVRSTATISTICS    *pDvrStatistics
				      );

extern	int  AIOGetWriteBufferSize    ( int   portHandle,
					LONG  *writeSize
				      );
	
extern	int  AIOReadData	      ( int   portHandle,
					char  *buffer,
					LONG  length,
					LONG  *numberBytesRead
				      );
	
extern	int  AIOReadStatus	      ( int   portHandle, 
					LONG  *count,
					WORD  *state
				      );
	
extern	int  AIOReleasePort	      ( int   portHandle );
	
extern	int  AIOSetControlData	      ( int   portHandle,
					int   requestType,
					AIOCONTROLDATA *requestStructValue
				      );

extern	int  AIOSetExternalControl    ( int   portHandle,
					int   requestType,
					int   requestValue
				      );
	
extern	int  AIOSetFlowControl	      ( int   portHandle,
					int   flowCtrlMode
				      );
	
extern	int  AIOSetFlowControlCharacters( int	portHandle,
					BYTE  transmitXon,
					BYTE  transmitXoff,
					BYTE  receiveXon,
					BYTE  receiveXoff
				      );
	
extern	int  AIOSetReadBufferSize     ( int    portHandle,
					LONG   bufferSize
				      );
      
extern	int  AIOSetWriteBufferSize    ( int    portHandle,
					LONG   bufferSize
				      );

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