/*++

Copyright (c) 2003 Aleksandrov O.E. All rights Reserved


Module Name:

    mi1201.h  

Abstract:   Include file for MI1201-AGM Port I/O Driver
********************************************************
ORIGINATED from 

Copyright (c) 1990-2000 Microsoft Corporation, All Rights Reserved

Abstract:   Include file for Generic Port I/O Example Driver


Author:    Robert R. Howell  January 8, 1993


Revision History:

 Robert B. Nelson (Microsoft)     March 1, 1993

--*/

#if     !defined(__MI1201IOCTL_H__)
#define __MI1201IOCTL_H__


// Символическое имя драйвера в файловой системе, устанавливаемое при загрузке
#define DOS_DEVICE_NAME L"\\??\\MI1201_Dev" // ?? эквивалентно DosDevices
// Имя, использовавшееся предыдущей версией драйвера, устанавливается при загрузке для совместимости
#define OLD_DOS_DEVICE_NAME L"\\DosDevices\\PortIODev"
// !!! Вы должны использовать вызов CreateFile(\\??\\MI1201_Dev", ..., чтобы получить доступ к драйверу



// Символическое имя драйвера, устанавливаемое при загрузке
#define GPD_DEVICE_NAME L"\\Device\\MI1201_0"

//
// Define the IOCTL codes we will use.  The IOCTL code contains a command
// identifier, plus other information about the device, the type of access
// with which the file must have been opened, and the type of buffering.
//

//
// Device type           -- in the "User Defined" range."
//

#define GPD_TYPE 40000


// The IOCTL function codes from 0x800 to 0xFFF are for customer use.
#define IOCTL_GPD_READ_PORT_UCHAR \
    CTL_CODE( GPD_TYPE, 0x900, METHOD_BUFFERED, FILE_READ_ACCESS )

#define IOCTL_GPD_READ_PORT_USHORT \
    CTL_CODE( GPD_TYPE, 0x901, METHOD_BUFFERED, FILE_READ_ACCESS )

#define IOCTL_GPD_READ_PORT_ULONG \
    CTL_CODE( GPD_TYPE, 0x902, METHOD_BUFFERED, FILE_READ_ACCESS )

// Чтение нескольких значений из ПОРТА
#define IOCTL_GPD_READ_PORT_BUFFER \
    CTL_CODE( GPD_TYPE, 0x903, METHOD_BUFFERED, FILE_READ_ACCESS )

// Ожидание на ПОРТу
#define IOCTL_GPD_WAIT_ON_PORT \
    CTL_CODE( GPD_TYPE, 0x904, METHOD_BUFFERED, FILE_READ_ACCESS )

#define IOCTL_GPD_WRITE_PORT_UCHAR \
    CTL_CODE(GPD_TYPE,  0x910, METHOD_BUFFERED, FILE_WRITE_ACCESS)

#define IOCTL_GPD_WRITE_PORT_USHORT \
    CTL_CODE(GPD_TYPE,  0x911, METHOD_BUFFERED, FILE_WRITE_ACCESS)

#define IOCTL_GPD_WRITE_PORT_ULONG \
    CTL_CODE(GPD_TYPE,  0x912, METHOD_BUFFERED, FILE_WRITE_ACCESS)

// Запись нескольких значений в ПОРТ
#define IOCTL_GPD_WRITE_PORT_BUFFER \
    CTL_CODE( GPD_TYPE, 0x913, METHOD_BUFFERED, FILE_WRITE_ACCESS )

// Запись в порт1 + ожидание на ПОРТу 2
#define IOCTL_GPD_WRITE_AND_WAIT_ON_PORT \
    CTL_CODE( GPD_TYPE, 0x914, METHOD_BUFFERED, FILE_WRITE_ACCESS )

// Проверка корректности входного буфера для MULTIFUNCTION_IO_OPERATION
#define IOCTL_GPD_MULTIFUNCTION_IO_OPERATION_CHECK_INPUT_BUFFER \
    CTL_CODE( GPD_TYPE, 0x915, METHOD_BUFFERED, FILE_READ_ACCESS )

// MULTIFUNCTION_IO_OPERATION
#define IOCTL_GPD_MULTIFUNCTION_IO_OPERATION \
    CTL_CODE( GPD_TYPE, 0x916, METHOD_BUFFERED, FILE_WRITE_ACCESS )

typedef struct  _GENPORT_WRITE_INPUT {
    ULONG   PortNumber;     // Port # to write to
    union   {               // Data to be output to port
        ULONG   LongData;
        USHORT  ShortData;
        UCHAR   CharData;
    };
}   GENPORT_WRITE_INPUT, *PGENPORT_WRITE_INPUT;

// ---------- Новый вариант драйвера ----------------

typedef struct  _LSHUnion {
    union   {
		ULONG   ULong; 
		USHORT  UShort;
		UCHAR   UChar;
		LONG	Long; 
		SHORT	Short;
		CHAR	Char;
	};
}   tLSHUnion, *PLSHUnion;

typedef struct  _LSHArrayUnion {
    union   {
		ULONG   ULong[1]; 
		USHORT  UShort[1];
		UCHAR   UChar[1];
		LONG	Long[1]; 
		SHORT	Short[1];
		CHAR	Char[1];
	};
}   tLSHArrayUnion, *PLSHArrayUnion;

// Чтение -------------------------
typedef struct  _GENPORT_READ_OUTPUT_BUFFER {
	tLSHUnion Data; // Данные считанные с порта
}   GENPORT_READ_OUTPUT_BUFFER , *PGENPORT_READ_OUTPUT_BUFFER;

typedef struct  _GENPORT_READ_INTPUT_BUFFER {
	ULONG   PortNumber;     // Port # to read from
}   GENPORT_READ_INTPUT_BUFFER, *PGENPORT_READ_INTPUT_BUFFER;

typedef struct  _GENPORT_READ_INPUT_OUTPUT_BUFFER {
    union   {
		GENPORT_READ_INTPUT_BUFFER	Input;  // Данные по порту
		GENPORT_READ_OUTPUT_BUFFER	Output; // Данные считанные с порта
	};
}   GENPORT_READ_INPUT_OUTPUT_BUFFER, *PGENPORT_READ_INPUT_OUTPUT_BUFFER;

typedef struct  _GENPORT_READ_MULTI_OUTPUT_BUFFER_HEADER {
	ULONG   Count;     // Количество считанных значений
}   GENPORT_READ_MULTI_OUTPUT_BUFFER_HEADER, *PGENPORT_READ_MULTI_OUTPUT_BUFFER_HEADER;

typedef struct  _GENPORT_READ_MULTI_OUTPUT_BUFFER {
	GENPORT_READ_MULTI_OUTPUT_BUFFER_HEADER	Header;     // Заголовок
	tLSHArrayUnion							Data; // Данные считанные с порта
}   GENPORT_READ_MULTI_OUTPUT_BUFFER, *PGENPORT_READ_MULTI_OUTPUT_BUFFER;

// тип порта
#define myPORT_UCHAR	0
#define myPORT_USHORT	1
#define myPORT_ULONG	2

typedef struct  _GENPORT_READ_MULTI_INPUT_BUFFER {
	ULONG   Port;     // Port # to read from
	UCHAR   PortType;     // 0 - byte; 1 - word; 2 - dword
	ULONG   Count;     // Количество значений для считывания
}   GENPORT_READ_MULTI_INPUT_BUFFER, *PGENPORT_READ_MULTI_INPUT_BUFFER;

typedef struct  _GENPORT_READ_MULTI_INPUT_OUTPUT_BUFFER {
    union   {
		GENPORT_READ_MULTI_INPUT_BUFFER		Input;  // Данные по порту
		GENPORT_READ_MULTI_OUTPUT_BUFFER	Output; // Данные считанные с порта
	};
}   GENPORT_READ_MULTI_INPUT_OUTPUT_BUFFER, *PGENPORT_READ_MULTI_INPUT_OUTPUT_BUFFER;

// Запись -------------------------
typedef struct  _GENPORT_WRITE_INPUT_BUFFER {
    ULONG		Port;     // Port # to write to
	tLSHUnion	Data;	// Data to be output to port
}   GENPORT_WRITE_INPUT_BUFFER, *PGENPORT_WRITE_INPUT_BUFFER;

typedef struct  _GENPORT_WRITE_MULTI_INPUT_BUFFER_HEADER {
    ULONG			Port;     // Port # to write to
    UCHAR			PortType;     // 0 - byte; 1 - word; 2 - dword
	ULONG			Count;     // Количество значений для считывания
}   GENPORT_WRITE_MULTI_INPUT_BUFFER_HEADER, *PGENPORT_WRITE_MULTI_INPUT_BUFFER_HEADER;

typedef struct  _GENPORT_WRITE_MULTI_INPUT_BUFFER {
    GENPORT_WRITE_MULTI_INPUT_BUFFER_HEADER	Header;     // Port # to write to
	tLSHArrayUnion							Data; // Данные, записиваемые в порт
}   GENPORT_WRITE_MULTI_INPUT_BUFFER, *PGENPORT_WRITE_MULTI_INPUT_BUFFER;

typedef struct  _GENPORT_WRITE_MULTI_OUTPUT_BUFFER_HEADER {
    ULONG   XXX;     // ЗАГЛУШКА
}   GENPORT_WRITE_MULTI_OUTPUT_BUFFER_HEADER, *PGENPORT_WRITE_MULTI_OUTPUT_BUFFER_HEADER;

typedef struct  _GENPORT_WRITE_MULTI_OUTPUT_BUFFER {
	GENPORT_WRITE_MULTI_OUTPUT_BUFFER_HEADER   Header;     // Заголовок
}   GENPORT_WRITE_MULTI_OUTPUT_BUFFER, *PGENPORT_WRITE_MULTI_OUTPUT_BUFFER;

typedef struct  _GENPORT_WRITE_MULTI_INPUT_OUTPUT_BUFFER {
    union   {
		GENPORT_WRITE_MULTI_INPUT_BUFFER	Input;  // Данные для вывода в порт
		GENPORT_WRITE_MULTI_OUTPUT_BUFFER	Output; 
	};
}   GENPORT_WRITE_MULTI_INPUT_OUTPUT_BUFFER, *PGENPORT_WRITE_MULTI_INPUT_OUTPUT_BUFFER;

// Ожидание -------------------------

typedef enum _tPortWaitResult {
	pwrSUCCESS,		// дождались
	pwrTIMEOUT,		// таймаут 
    pwrABANDONED	// ожидание прервано  
} tPortWaitResult;

// Результат ожидания события  
// но не менее 1 раза
typedef struct  _GENPORT_WAIT_OUTPUT_BUFFER {
	BOOLEAN		Event;			// Результат ожидания: TRUE - дождались.
	ULONG		WaitResult;     // Результат ожидания, см. myPORT_WAIT_xxx
	ULONG		TimeOut;		// Реальное время, затраченное на ожидание в мс, 
								// если установлен wcfReturnWaitIntervalIn100nanosecUnit, то в единицах 100 наносекунд
	ULONG		Data; // последние данные, считанные с порта
}   GENPORT_WAIT_OUTPUT_BUFFER, *PGENPORT_WAIT_OUTPUT_BUFFER;

// Флаги управления ожиданием (номера битов)
typedef enum _tWaitControlFlag {
  wcfUserRequest, // запрос пользователя, иначе [Executive]
  wcfUserMode, // ожидать в режиме UserMode, иначе [KernelMode]
  wcfAlertable, // ожидание можно прервать, иначе [FALSE]
  wcfWaitOnAPC_Level, // ТОЛЬКО WriteAndWaitOnPort ожидание на IRQL=APC_LEVEL
  wcfWaitOnDISPATCH_Level, // ТОЛЬКО WriteAndWaitOnPort ожидание на IRQL=DISPATCH_LEVEL
  wcfAllowZeroResolution, //  разрешить ожидание с 0 разрешением 
  wcfUseQueryPerformanceCounter, // ТОЛЬКО WriteAndWaitOnPort использовать KeQueryPerformanceCounter для определения времени ожидания
  wcfReturnWaitIntervalIn100nanosecUnit // ТОЛЬКО WriteAndWaitOnPort возвратить данные ожидания в единицах 100 наносекунд
} tWaitControlFlag;

#define bit_wcfUserRequest							(1<<wcfUserRequest)
#define bit_wcfUserMode								(1<<wcfUserMode)
#define bit_wcfAlertable							(1<<wcfAlertable)
#define bit_wcfWaitOnAPC_Level						(1<<wcfWaitOnAPC_Level)
#define bit_wcfWaitOnDISPATCH_Level					(1<<wcfWaitOnDISPATCH_Level)
#define bit_wcfAllowZeroResolution					(1<<wcfAllowZeroResolution)
#define bit_wcfUseQueryPerformanceCounter			(1<<wcfUseQueryPerformanceCounter)
#define bit_wcfReturnWaitIntervalIn100nanosecUnit	(1<<wcfReturnWaitIntervalIn100nanosecUnit)

// Ожидание события (Порт(PortNumber) and Mask) == Patt в течение TimeOut мс опрашивая порт через TimeResolution, 
// но не менее 1 раза
typedef struct  _GENPORT_WAIT_INPUT_BUFFER {
	ULONG		Port;     // Порт для ожидания
	UCHAR		PortType;		// 0 - byte; 1 - word; 2 - dword
	USHORT		TimeOut;		// Время ожидания в мс
	USHORT		TimeResolution; // Интервал опроса порта в мс
	ULONG		Mask; // Маска
	ULONG		Patt; // Образец
	ULONG		ControlFlags;   // Флаги (битовые) управления ожиданием
}   GENPORT_WAIT_INPUT_BUFFER, *PGENPORT_WAIT_INPUT_BUFFER;

typedef struct  _GENPORT_WAIT_INPUT_OUTPUT_BUFFER {
    union   {
		GENPORT_WAIT_INPUT_BUFFER		Input;  // Данные по порту
		GENPORT_WAIT_OUTPUT_BUFFER	Output; // Данные считанные с порта
	};
}   GENPORT_WAIT_INPUT_OUTPUT_BUFFER, *PGENPORT_WAIT_INPUT_OUTPUT_BUFFER;


// Запись в порт 1 + ожидание события (Порт 2(PortNumber) and Mask) == Patt в течение TimeOut мс опрашивая порт через TimeResolution, 
// но не менее 1 раза
typedef struct  _PORT_DATA {
    ULONG		Number;     // Port # to write to
	ULONG		Type;		// 0 - byte; 1 - word; 2 - dword
	ULONG		MemoryType; // опционально, инициализируется и используется только самим драйвером
}   PORT_DATA, *PPORT_DATA;

typedef struct  _GENPORT_WRITE_AND_WAIT_WRITE_DATA {
    PORT_DATA	Port;     // Port # to write to
	tLSHUnion	Data;			// Data to be output to port
}   GENPORT_WRITE_AND_WAIT_WRITE_DATA, *PGENPORT_WRITE_AND_WAIT_WRITE_DATA;

typedef struct  _GENPORT_GENPORT_WRITE_AND_WAIT_WAIT_DATA {
	PORT_DATA	Port;     // Порт для ожидания
	ULONG		TimeOut;		// Время ожидания в мс
	ULONG		TimeResolution; // Интервал опроса порта в мс
	ULONG		Mask; // Маска
	ULONG		Patt; // Образец
	ULONG		ControlFlags;   // Флаги (битовые) управления ожиданием
}   GENPORT_GENPORT_WRITE_AND_WAIT_WAIT_DATA, *PGENPORT_GENPORT_WRITE_AND_WAIT_WAIT_DATA;

typedef struct  _GENPORT_WRITE_AND_WAIT_INPUT_BUFFER {
	GENPORT_WRITE_AND_WAIT_WRITE_DATA			WriteData;
	GENPORT_GENPORT_WRITE_AND_WAIT_WAIT_DATA	WaitData;
}   GENPORT_WRITE_AND_WAIT_INPUT_BUFFER, *PGENPORT_WRITE_AND_WAIT_INPUT_BUFFER;

typedef struct  _GENPORT_WRITE_AND_WAIT_INPUT_OUTPUT_BUFFER {
    union   {
		GENPORT_WRITE_AND_WAIT_INPUT_BUFFER	Input;  // Данные по порту
		GENPORT_WAIT_OUTPUT_BUFFER	Output; // Данные считанные с порта
	};
}   GENPORT_WRITE_AND_WAIT_INPUT_OUTPUT_BUFFER, *PGENPORT_WRITE_AND_WAIT_INPUT_OUTPUT_BUFFER;


// УПРАВЛЕНИЕ ДРАЙВЕРОМ -------------------------
#define cDriverInternalVersion 1


//  Запрос информации о драйвере
#define IOCTL_MI1201_GET_CONTROL_INFO \
    CTL_CODE( GPD_TYPE, 0x8FF, METHOD_BUFFERED, FILE_READ_ACCESS )

#define IOCTL_MI1201_SET_CONTROL_INFO \
    CTL_CODE( GPD_TYPE, 0x8FE, METHOD_BUFFERED, FILE_READ_ACCESS )

// Запрос на немедленное прекращение всех операций.
#define IOCTL_MI1201_ABORT \
    CTL_CODE( GPD_TYPE, 0x8FD, METHOD_BUFFERED, FILE_WRITE_ACCESS )

//  Управление драйвером
#define MI1201_GET_CONTROL_CODE_GET_VERSION			0
#define MI1201_GET_CONTROL_CODE_GET_CAPABILITIES	1
#define MI1201_GET_CONTROL_CODE_GET_ABORT_STATE		2

typedef struct  _MI1201_ABORT_INPUT_BUFFER {
    BOOLEAN   Stop;     // TRUE - останов длинных операций;  FALSE - разрешение длинных операций;
}   MI1201_ABORT_INPUT_BUFFER, *PMI1201_ABORT_INPUT_BUFFER;

typedef struct  _MI1201_ABORT_OUTPUT_BUFFER {
    BOOLEAN   PreviousState;     // предыдущее состояние;
}   MI1201_ABORT_OUTPUT_BUFFER, *PMI1201_ABORT_OUTPUT_BUFFER;

typedef struct  _MI1201_ABORT_INPUT_OUTPUT_BUFFER {
    union   {
		MI1201_ABORT_INPUT_BUFFER	Input;  // Данные по порту
		MI1201_ABORT_OUTPUT_BUFFER	Output; // Данные считанные с порта
	};
}   MI1201_ABORT_INPUT_OUTPUT_BUFFER, *PMI1201_ABORT_INPUT_OUTPUT_BUFFER;

typedef struct  _MI1201_CONTROL_INFO_INPUT_BUFFER_BASE_PART {
    ULONG   ControlCode;     // Основной код операции
    ULONG   ControlSubCode;  // Доп. код операции
    ULONG   FullSize;        // Полный размер данных
}   MI1201_CONTROL_INFO_INPUT_BUFFER_BASE_PART, *PMI1201_CONTROL_INFO_INPUT_BUFFER_BASE_PART;

typedef struct  _MI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_VERSION {
    ULONG   InternalVersion;     // внутренний номер версии
}   MI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_VERSION, *PMI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_VERSION;

typedef struct  _MI1201_CONTROL_INFO_OUTPUT_GET_ABORT_STATE {
    BOOLEAN   State;     // предыдущее состояние;
}   MI1201_CONTROL_INFO_OUTPUT_GET_ABORT_STATE, *PMI1201_CONTROL_INFO_OUTPUT_GET_ABORT_STATE;

//  Флаги возможностей драйвера
#define MI1201_CAP_FLAG_ARRAY_IO_SINGLE_PORT			1  // Возможность ввода/вывода в один порт массива (нескольких значений за один раз)
#define MI1201_CAP_FLAG_ARRAY_IO_RAW_PORTS				2  // Возможность ввода/вывода в несколько портов нескольких массивов (нескольких значений за один раз)
#define MI1201_CAP_FLAG_WAIT_ON_SINGLE_PORT				4  // Ожидания на порту события по маске и образцу указанное число миллисекунд
#define MI1201_CAP_FLAG_WRITE_AND_WAIT_ON_SINGLE_PORT	8  // Запись в порт 1 + Ожидания на порту 2 события по маске и образцу указанное число миллисекунд
#define MI1201_CAP_FLAG_ARRAY_IO_RAW_PORTS_AND_WAIT		16 // Возможность ввода/вывода/ожидания в несколько портов нескольких массивов (нескольких значений за один раз)

typedef struct  _MI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_CAPABILITIES {
    ULONG   Capabilities;     // флаги функциональных возможностей
}   MI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_CAPABILITIES, *PMI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_CAPABILITIES;

//--- Мультифункциональная операция ввода/вывода (МФОВВ)
/*++
 Входной буфер МФОВВ всегда представляет собой массив значений ULONG.
 Массив ULONG трактуется как последовательность одиночных операции (ОО).
 Каждая ОО представляет собой запись, размером в целое число значений ULONG.
 Каждая запись для ОО содержит стандартный заголовок и данные, зависящие от типа ОО. 	

 Выходной буфер МФОВВ всегда представляет собой массив значений ULONG.
 Массив ULONG трактуется как последовательность одиночных операции (ОО).
 Каждая ОО представляет собой запись, размером в целое число значений ULONG либо нулевой длины.
--*/

typedef enum _tMultifunctionOpCode {
	mfocRead,		  // чтение одного значения
	mfocWrite,		  // запись одного значения
	mfocReadBuffer,	  // чтение нескольких значений
	mfocWriteBuffer,  // запись нескольких значений
	mfocWait,		  // ожидание
	mfocWriteAndWait, // запись одного значения+ожидание 
    mfocInvalidOperation	// неверная операция - резервировано   
} tMultifunctionOpCode, *ptMultifunctionOpCode;

typedef enum _tMultifunctionError {
	mferrOK,
	mferrBufferTooSmall,
	mferrRecordsCountEqZero,
	mferrBufferTooSmall_2,
	mferrInvalidOpCode,
	mferrBufferTooSmall_3,
	mferrBufferTooSmall_4,
	mferrInvalidPort,
	mferrInvalidPort_2,
	mferrWriteBuffer_CountZero,
	mferrReadBuffer_CountZero,
	mferrInvalidPortType,
	mferrOutputBufferTooLarge
} tMultifunctionError, *ptMultifunctionError;

typedef struct  _GENPORT_MULTIFUNCTION_IO_ERROR_DESCRIPTION {
	tMultifunctionError	ErrorCode;
	union{
		ULONG	RecordNumber;   // номер записи, в которой ошибка
		ULONG	OutputDataSize; // полный размер буфера для возврата данных
	};
}   GENPORT_MULTIFUNCTION_IO_ERROR_DESCRIPTION, *PGENPORT_MULTIFUNCTION_IO_ERROR_DESCRIPTION;

typedef struct  _GENPORT_MULTIFUNCTION_IO_INPUT_HEADER {
	tMultifunctionOpCode	OpCode;
}   GENPORT_MULTIFUNCTION_IO_INPUT_HEADER, *PGENPORT_MULTIFUNCTION_IO_INPUT_HEADER;

typedef struct  _GENPORT_MULTIFUNCTION_IO_INPUT_BUFFER {
	ULONG									Count; // число операций в буфере
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER	Data;  // данные по операциям
}   GENPORT_MULTIFUNCTION_IO_INPUT_BUFFER, *PGENPORT_MULTIFUNCTION_IO_INPUT_BUFFER;

typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_INPUT {
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER	Header;
	PORT_DATA								Port;
}   GENPORT_MULTIFUNCTION_IO_READ_INPUT, *PGENPORT_MULTIFUNCTION_IO_READ_INPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_INPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_READ_INPUT		Buffer;
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER	NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_READ_INPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_READ_INPUT_NEXT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WRITE_INPUT {
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER	Header;
	PORT_DATA								Port;
	tLSHUnion								Data;
}   GENPORT_MULTIFUNCTION_IO_WRITE_INPUT, *PGENPORT_MULTIFUNCTION_IO_WRITE_INPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WRITE_INPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_WRITE_INPUT	Buffer;
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER	NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_WRITE_INPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_WRITE_INPUT_NEXT;


typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT {
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER	Header;
	PORT_DATA								Port;
	ULONG									Count;
}   GENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT, *PGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT	Buffer;
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER		NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT_NEXT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT {
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER	Header;
	PORT_DATA								Port;
	ULONG									Count;
	tLSHArrayUnion	Data;
}   GENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT, *PGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WAIT_INPUT {
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER		Header;
	GENPORT_GENPORT_WRITE_AND_WAIT_WAIT_DATA	WaitData;
}   GENPORT_MULTIFUNCTION_IO_WAIT_INPUT, *PGENPORT_MULTIFUNCTION_IO_WAIT_INPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WAIT_INPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_WAIT_INPUT			Buffer;
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER		NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_WAIT_INPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_WAIT_INPUT_NEXT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT {
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER		Header;
	GENPORT_WRITE_AND_WAIT_INPUT_BUFFER			Data;
}   GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT, *PGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT	Buffer;
	GENPORT_MULTIFUNCTION_IO_INPUT_HEADER			NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT_NEXT;

typedef GENPORT_MULTIFUNCTION_IO_ERROR_DESCRIPTION GENPORT_MULTIFUNCTION_IO_OPERATION_CHECK_OUTPUT_BUFFER;

typedef struct  _GENPORT_MULTIFUNCTION_IO_CHECK_INPUT_OUTPUT_BUFFER {
    union   {
		GENPORT_MULTIFUNCTION_IO_INPUT_BUFFER	Input;  // ВХОДНЫЕ Данные 
		GENPORT_MULTIFUNCTION_IO_OPERATION_CHECK_OUTPUT_BUFFER	Output; // ВЫХОДНЫЕ  Данные 
	};
}   GENPORT_MULTIFUNCTION_IO_CHECK_INPUT_OUTPUT_BUFFER, *PGENPORT_MULTIFUNCTION_IO_CHECK_INPUT_OUTPUT_BUFFER;


// OUTPUT
typedef struct  _GENPORT_MULTIFUNCTION_IO_OUTPUT_HEADER {
	ULONG	OpCount; // число операций в буфере (из INPUT буфера)
	ULONG	RecordCount; // число записанных операций в буфере
}   GENPORT_MULTIFUNCTION_IO_OUTPUT_HEADER, *PGENPORT_MULTIFUNCTION_IO_OUTPUT_HEADER;

typedef struct  _GENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER {
	GENPORT_MULTIFUNCTION_IO_OUTPUT_HEADER	Header;
	ULONG									Data;  // данные по операциям
}   GENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER, *PGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER;

typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_OUTPUT {
	tLSHUnion	Data;
}   GENPORT_MULTIFUNCTION_IO_READ_OUTPUT, *PGENPORT_MULTIFUNCTION_IO_READ_OUTPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_OUTPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_READ_OUTPUT	Buffer;
	ULONG									NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_READ_OUTPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_READ_OUTPUT_NEXT;

//typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT_HEADER {
//	ULONG			Count; // число элементов в массиве Data
//	ULONG			Type;  // тип элементов в массиве Data
//}   GENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT_HEADER, *PGENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT_HEADER;

typedef struct  _GENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT {
//	GENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT_HEADER Header;
	tLSHArrayUnion	Data;
}   GENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT, *PGENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT;

typedef  GENPORT_WAIT_OUTPUT_BUFFER		GENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT;
typedef  GENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT *PGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT	Buffer;
	ULONG									NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT_NEXT;

typedef GENPORT_WAIT_OUTPUT_BUFFER						GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT;
typedef GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT *PGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT;

typedef struct  _GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT_NEXT {
	GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT	Buffer;
	ULONG											NextBuffer;
}   GENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT_NEXT, *PGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT_NEXT;


#endif