{ Ввод/вывод в порты через ДРАЙВЕР для  Windows NT/2000 }

{---------------------------------------------------------------------------
The control units for mass-spectrometer MI1201-AGM
(c) Copyright	 Aleksandrov O.E., 1999

   Molecular Physics department, USTU, Ekaterinsburg, K-2, 620002, RUSSIA
   phone 75-47-15
   E-mail: aleks@dpt.ustu.ru

Модуль управления масс-спектрометром МИ1201-АГМ
(c) Собственность     Александрова О.Е., 1999

   620002, Екатеринбург, К-2, УГТУ, Кафедра молекулярной физики
   тел. 75-47-15
   E-mail: aleks@dpt.ustu.ru
----------------------------------------------------------------------------}

{ эквиваленты инструкций IN AL,DX, OUT DX,AL и более сложных конструкций для использования в
операционных системах Windows NT (через драйвер устройства, см. cDeviceName) }

unit DriverPortsIO;

interface
  USES Windows, MI1201ioctl;

const
  cOldDeviceName='\\.\PortIODev';{ действующее, но неудачное имя для драйвера }
  cMi1201AGM='\\.\MI1201_Dev'; { новое имя для драйвера }
  cDeviceName=cMi1201AGM;

type
  tDynamicArrayOfULong=array of dword;
  ptDynamicArrayOfULong=^tDynamicArrayOfULong;

function LastError:longint; register;

procedure OutByte(b:Byte; Port:word); register;
function  InByte(Port:word):byte; register;

function IsWindowsNT:boolean;

//--------------------- 2003 г ------------------------------
// Дополнительные функции драйвера
//--------------------------------
function GetDriverVersion:ULONG;
function GetDriverCapabilities:ULONG;
function AbortDriverOperation(State:boolean):boolean;
function GetAbortDriverState:boolean;

{ Многофункциональный ввод/вывод. Принимает буфер команд CommandData, выполняет команды и возвращает
  TRUE - успешное выполнение и ResultData заполняется результатами выполнения
  FALSE - неверный формат или размер буфера команд CommandData и ResultData не изменяется.
Проверить буфер команд можно вызовом CheckMultifunctionIO.}
function MultifunctionIO(const CommandData; CommandDataSize:word;
                                        var ResultData;  ResultDataSize:word):boolean; register;

{ Проверка буфера команд CommandData для многофункционального ввода/вывода MultifunctionIO, проверяет команды и возвращает
  TRUE - успешное выполнение, то ResultData.ErrorCode=mferrOK,
                                 ResultData.OutputDataSize=необходимый размер буфера возврата для MultifunctionIO;
  FALSE - неверный формат или размер буфера команд CommandData, то
          ResultData.ErrorCode=код ошибки,
          ResultData.RecordNumber=номер записи в буфере команд где обнаружена ошибка}
function CheckMultifunctionIO(
  const CommandData; CommandDataSize:word;
  var   ResultData:tGENPORT_MULTIFUNCTION_IO_OPERATION_CHECK_OUTPUT_BUFFER
):boolean;

const
  cDefaultWaitControlFlags=[wcfUserRequest, wcfUserMode, wcfAllowZeroResolution];
  //Примечание: при TimeStep_ms=0 OutByteAndWait добавляет флаг wcfWaitOnDISPATCH_Level
  cDefaultWriteAndWaitControlFlags=[wcfUserRequest, wcfUserMode, wcfAllowZeroResolution];

{ ЛЕНИВО ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>. С интервалом TimeStep.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function Lazy_Wait(Port:word; Mask,Patt:Byte;
                  Time_ms:longint; TimeStep_ms:word; var WaitTime:longint):boolean; register;
{ Ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function Wait(Port:word; Mask,Patt:Byte; Time:longint; var WaitTime:longint):boolean; register;

{ Ввод/вывод байта aByte в порт Port и ожидание <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function OutByteAndWait(Port:word; aByte:byte;
                        WaitPort:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
  //Примечание: при TimeStep_ms=0 OutByteAndWait выполняется на DISPATCH_Level

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    WaitControlFlags:tWaitControlFlags;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean; register; overload;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word;
    TimeResolution:word;
    WaitControlFlags:tWaitControlFlags
):boolean; register; overload;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean; register; overload;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitTime:dword
):boolean; register; overload;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word;
    TimeResolution:word = 1
):boolean; register; overload;

function OutByteShortBuffer(Port:word; const Bytes; Size:word):boolean; register; {overload;}
function OutByteBuffer(Port:word; const Bytes; Size:word):boolean; register; {overload;}
{function OutByteShortBuffer(Port:word; const Bytes:array of byte):boolean; register; overload;
function OutByteBuffer(Port:word; const Bytes:array of byte):boolean; register; overload;
function OutByteBuffer(Port:word; const Bytes; Size:word):boolean; register; overload;}

function InByteBuffer(Port:word; var Bytes; Size:word):boolean; register; {overload;}
function InByteShortBuffer(Port:word; var Bytes; Size:word):boolean; register; {overload;
function InByteShortBuffer(Port:word; var Bytes:array of byte):boolean; register; overload;
function InByteBuffer(Port:word; var Bytes:array of byte):boolean; register; overload;}

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word
):boolean; register; overload;

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitTime:dword
):boolean; register; overload;

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean; register; overload;

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    WaitControlFlags:tWaitControlFlags;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean; register; overload;

implementation
   USES PortsIO, SysUtils, IOBuffer;

var
  HDevice:THandle;

threadvar
  LastIOErrorCode:DWord;

function LastError;
begin
  Result:=LastIOErrorCode;
end;


function  GetDriver(
      IoctlCode:ulong;
      const InputBuffer;  InputBufferSize:dword;
      var OutputBuffer; OutputBufferSize:dword
):boolean;
  var ReturnBytesCount:dword;
begin
  Result:=DeviceIOControl(HDevice,                      // handle to device of interest
                          IoctlCode,    // control code of operation to perform
			  @InputBuffer,                       // pointer to buffer to supply input data
			  InputBufferSize,// size of input buffer
			  @OutputBuffer,                      // pointer to buffer to receive output data
			  OutputBufferSize,                            // size of output buffer
			  ReturnBytesCount,                          // pointer to variable to receive output byte count
			  nil                           // pointer to overlapped structure for asynchronous
			 )
     and (ReturnBytesCount = OutputBufferSize);
  LastIOErrorCode:=GetLastError;
  if not Result then begin
    if LastIOErrorCode=0 then
      LastIOErrorCode:=High(LastIOErrorCode);
  end;
end;

function  GetDriverInOnly(
      IoctlCode:ulong;
      const InputBuffer;  InputBufferSize:dword
):boolean;
begin
  Result:=GetDriver(IoctlCode, InputBuffer,  InputBufferSize, nil^, 0);
end;

// вывод в порт для Windows NT
procedure OutByte(b:Byte; Port:word); register;
  var
    buf: tGENPORT_WRITE_INPUT_BUFFER;
begin
  buf.PortNumber:=Port;
  buf.UCharData:=b;
  LastIOPortSet(Port);
  GetDriverInOnly(IOCTL_GPD_WRITE_PORT_UCHAR,  buf, SizeOf(buf));
end;

// ввод из порта для Windows NT
function  InByte(Port:word):byte; register;
  var InputBuff:tGENPORT_READ_INPUT_BUFFER;
begin
  InputBuff.PortNumber:=Port;
  LastIOPortSet(Port);
  if not GetDriver(IOCTL_GPD_READ_PORT_UCHAR,
            InputBuff, SizeOf(InputBuff),
            Result, 1) then begin
    Result:=$FF;
  end;
end;

function QueryIsWindowsNT:boolean;
  var osvi:OSVERSIONINFO;
begin
  osvi.dwOSVersionInfoSize:=SizeOf(osvi);
  GetVersionEx(osvi);
  Result:=(osvi.dwPlatformId=VER_PLATFORM_WIN32_NT);
end;

function IsWindowsNT:boolean;
  type
    tFlag=(fOsTypeQueried, fOsTypeIsNT);
    tFlags=set of tFlag;
  const
    Flags:tFlags=[];
begin
  if (fOsTypeQueried in Flags) then begin
    Result:=(fOsTypeIsNT in Flags);
  end else begin
    Result:=QueryIsWindowsNT;
    Include(Flags,fOsTypeQueried);
    if Result then
      Include(Flags,fOsTypeIsNT);
  end;
end;

procedure ReleaseHandle;
begin
  if HDevice<>INVALID_HANDLE_VALUE then begin
    CloseHandle(HDevice);
    LastIOErrorCode:=GetLastError;
    HDevice:=INVALID_HANDLE_VALUE;
  end;
end;

function GetNtDriverHandle(DriverName:PChar):boolean;
begin
  if IsWindowsNT then begin
    ReleaseHandle;
    HDevice := CreateFile(cMi1201AGM,                   // address of name of the file
                        GENERIC_READ or GENERIC_WRITE,  // access (read-write) mode
                        FILE_SHARE_READ,                // share mode
                        nil,                            // address of security descriptor
                        OPEN_EXISTING,                  // how to create
		        0,                              // file attributes
			0                               // handle of file with attributes to copy
		       );
    LastIOErrorCode:=GetLastError;
  end else begin
    HDevice:=INVALID_HANDLE_VALUE;
  end;
  Result:=HDevice<>INVALID_HANDLE_VALUE;
end;

function  GetDriverInfo(
      const InputBuffer;  InputBufferSize:dword;
      var OutputBuffer; OutputBufferSize:dword
):boolean;
begin
  Result:=GetDriver(IOCTL_MI1201_GET_CONTROL_INFO, InputBuffer,  InputBufferSize, OutputBuffer, OutputBufferSize);
end;

function GetDriverCapabilities:ULONG;
  var
    InBuf:tMI1201_CONTROL_INFO_INPUT_BUFFER_BASE_PART;
    OutBuf:tMI1201_CONTROL_INFO_INPUT_BUFFER_GET_CAPABILITIES;
begin
  Result:=0;
  InBuf.ControlCode:=Ord(MI1201_GET_CONTROL_CODE_GET_CAPABILITIES);
  InBuf.FullSize:=SizeOf(InBuf);
  if GetDriverInfo(InBuf, SizeOf(InBuf), OutBuf, SizeOf(OutBuf)) then begin
     Result:=OutBuf.Capabilities;
  end;
end;

function AbortDriverOperation(State:boolean):boolean;
  var
    InBuf:tMI1201_ABORT_INPUT_BUFFER;
    OutBuf:tMI1201_ABORT_OUTPUT_BUFFER;
begin
  Result:=TRUE;
  InBuf.Stop:=State;
  if GetDriver(IOCTL_MI1201_ABORT, InBuf, SizeOf(InBuf), OutBuf, SizeOf(OutBuf)) then begin
    Result:=OutBuf.PreviosState;
  end;
end;

function GetAbortDriverState:boolean;
  var
    InBuf:tMI1201_CONTROL_INFO_INPUT_BUFFER_BASE_PART;
    OutBuf:tMI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_ABORT_STATE;
begin
  Result:=TRUE;
  InBuf.ControlCode:=Ord(MI1201_GET_CONTROL_CODE_GET_ABORT_STATE);
  InBuf.FullSize:=SizeOf(InBuf);
  if GetDriverInfo(InBuf, SizeOf(InBuf), OutBuf, SizeOf(OutBuf)) then begin
    Result:=OutBuf.State;
  end;
end;

function GetDriverVersion:ULONG;
  var
    InBuf:tMI1201_CONTROL_INFO_INPUT_BUFFER_BASE_PART;
    OutBuf:tMI1201_CONTROL_INFO_OUTPUT_BUFFER_GET_VERSION;
begin
  Result:=0;
  InBuf.ControlCode:=Ord(MI1201_GET_CONTROL_CODE_GET_VERSION);
  InBuf.FullSize:=SizeOf(InBuf);
  if GetDriverInfo(InBuf, SizeOf(InBuf), OutBuf, SizeOf(OutBuf)) then begin
    Result:=OutBuf.InternalVersion;
  end;
end;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitTime:dword
):boolean;
  var wr:tPortWaitResult;
begin
  Result:=LazyWait(Port, Mask,Patt, TimeOut,TimeResolution,
    cDefaultWaitControlFlags,
    wr, WaitTime
  );
end;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word
):boolean;
  var wr:tPortWaitResult; wt:dword;
begin
  Result:=LazyWait(Port, Mask,Patt, TimeOut,TimeResolution,
    cDefaultWaitControlFlags,
    wr, wt
  );
end;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean;
begin
  Result:=LazyWait(Port, Mask,Patt, TimeOut,TimeResolution,
    cDefaultWaitControlFlags,
    WaitResult,WaitTime
  );
end;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    WaitControlFlags:tWaitControlFlags
):boolean; overload;
  var wr:tPortWaitResult; wt:dword;
begin
  Result:=LazyWait(Port, Mask, Patt, TimeOut, TimeResolution, WaitControlFlags, wr, wt);
end;

function LazyWait(
    Port:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    WaitControlFlags:tWaitControlFlags;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean; overload;
var
  InOutBuf:tGENPORT_WAIT_INPUT_OUTPUT_BUFFER;
begin
  InOutBuf.Input.Port:=Port;
  InOutBuf.Input.PortType:=Ord(PORT_UCHAR);
  InOutBuf.Input.TimeOut:=TimeOut;
  InOutBuf.Input.TimeResolution:=TimeResolution;
  InOutBuf.Input.Mask:=Mask;
  InOutBuf.Input.Patt:=Patt;
  InOutBuf.Input.ControlFlags:=Byte(WaitControlFlags);
  LastIOPortSet(Port);
  Result:=GetDriver(IOCTL_GPD_WAIT_ON_PORT, InOutBuf, SizeOf(InOutBuf.Input), InOutBuf, SizeOf(InOutBuf.Output));
  if Result then begin
    WaitResult:=tPortWaitResult(InOutBuf.Output.WaitResult);
    WaitTime  :=InOutBuf.Output.TimeOut;
    Result    :=InOutBuf.Output.Event;
  end;
end;

{ ЛЕНИВО ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>. С интервалом TimeStep.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
threadvar WaitResult:tPortWaitResult;
function Lazy_Wait(Port:word; Mask,Patt:Byte;
                  Time_ms:longint; TimeStep_ms:word; var WaitTime:longint):boolean;
begin
  Result:=LazyWait(
    Port, Mask,Patt, Time_ms, TimeStep_ms,
    cDefaultWaitControlFlags, WaitResult,
    DWORD(WaitTime)
  );
end;

{ Ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function Wait(Port:word; Mask,Patt:Byte; Time:longint; var WaitTime:longint):boolean;
begin
  Result:=LazyWait(
    Port, Mask,Patt, Time, 0,
    cDefaultWaitControlFlags+[wcfAllowZeroResolution], WaitResult,
    DWORD(WaitTime)
  );
end;

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word
):boolean;
    var WaitTime:dword;
    var WaitResult:tPortWaitResult;
begin
  Result:=WriteAndLazyWait(
    WritePort, ValueToWrite,
    WaitPort, Mask,Patt,
    TimeOut, TimeResolution,
    cDefaultWriteAndWaitControlFlags,
    WaitResult, WaitTime
  );
end;

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitTime:dword
):boolean;
    var WaitResult:tPortWaitResult;
begin
  Result:=WriteAndLazyWait(
    WritePort, ValueToWrite,
    WaitPort, Mask,Patt,
    TimeOut, TimeResolution,
    cDefaultWriteAndWaitControlFlags,
    WaitResult, WaitTime
  );
end;

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean;
begin
  Result:=WriteAndLazyWait(
    WritePort, ValueToWrite,
    WaitPort, Mask,Patt,
    TimeOut, TimeResolution,
    cDefaultWriteAndWaitControlFlags,
    WaitResult, WaitTime
  );
end;

function WriteAndLazyWait(
    WritePort:word; ValueToWrite:Byte;
    WaitPort:word;
    Mask,Patt:Byte;
    TimeOut:word; TimeResolution:word;
    WaitControlFlags:tWaitControlFlags;
    var WaitResult:tPortWaitResult;
    var WaitTime:dword
):boolean;
var
  InOutBuf:tGENPORT_WRITE_AND_WAIT_INPUT_OUTPUT_BUFFER;
begin
  InOutBuf.Input.WriteData.Port.Number:=WritePort;
  InOutBuf.Input.WriteData.Port.PortType:=Ord(PORT_UCHAR);
  InOutBuf.Input.WriteData.Data.ULong:=ValueToWrite;

  InOutBuf.Input.WaitData.Port.Number:=WaitPort;
  InOutBuf.Input.WaitData.Port.PortType:=Ord(PORT_UCHAR);
  InOutBuf.Input.WaitData.TimeOut:=TimeOut;
  InOutBuf.Input.WaitData.TimeResolution:=TimeResolution;
  InOutBuf.Input.WaitData.Mask:=Mask;
  InOutBuf.Input.WaitData.Patt:=Patt;
  InOutBuf.Input.WaitData.ControlFlags:=Byte(WaitControlFlags);
  LastIOPortSet(WaitPort);

  Result:=GetDriver(IOCTL_GPD_WRITE_AND_WAIT_ON_PORT, InOutBuf, SizeOf(InOutBuf.Input), InOutBuf, SizeOf(InOutBuf.Output));
  if Result then begin
    WaitResult:=tPortWaitResult(InOutBuf.Output.WaitResult);
    WaitTime  :=InOutBuf.Output.TimeOut;
    Result    :=InOutBuf.Output.Event;
  end;
end;

{ Ввод/вывод байта aByte в порт Port и ожидание <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function OutByteAndWait(Port:word; aByte:byte;
                        WaitPort:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
   var WaitResult:tPortWaitResult;
begin
  if TimeStep<>0 then begin
    Result:=WriteAndLazyWait(
       Port, aByte,
       WaitPort, Mask,Patt, Time, TimeStep,
       cDefaultWriteAndWaitControlFlags, WaitResult,
       dword(WaitTime)
    )
  end else begin
    Result:=WriteAndLazyWait(
       Port, aByte,
       WaitPort, Mask,Patt, Time, 0,
       cDefaultWriteAndWaitControlFlags+[wcfWaitOnDISPATCH_Level], WaitResult,
       dword(WaitTime)
    )
  end;
end;

function PortSize(aPortType:byte):cardinal;
begin
  case aPortType of
    0: Result:=1;
    1: Result:=2;
    2: Result:=4;
    else begin
      Result:=0;
      {$IfOpt R+}
         raise ERangeError.Create('PortSize: Invalid aPortType value.');
      {$EndIf Opt R+}
    end;
  end;
end;

function SizeOf_tGENPORT_WRITE_MULTI_INPUT_BUFFER(const Data:tGENPORT_WRITE_MULTI_INPUT_BUFFER):cardinal;
  {$IfOpt R+}var x:dword;{$EndIf Opt R+}
begin
  Result:=SizeOf(Data.Header)+PortSize(Data.Header.PortType)*Data.Header.Count;
  {$IfOpt R+}
  case Data.Header.PortType of
    0: x:=ptArrayOfByte(@Data.Data)^[Data.Header.Count-1];
    1: x:=ptArrayOfWord(@Data.Data)^[Data.Header.Count-1];
    2: x:=ptArrayOfDWord(@Data.Data)^[Data.Header.Count-1];
  end;
  {$EndIf Opt R+}
end;

function OutBuffer(const Data:tGENPORT_WRITE_MULTI_INPUT_BUFFER):boolean;
begin
  LastIOPortSet(Data.Header.Port);
  Result:=GetDriverInOnly(IOCTL_GPD_WRITE_PORT_BUFFER, Data, SizeOf_tGENPORT_WRITE_MULTI_INPUT_BUFFER(Data));
end;

function InBuffer(
   const InData:tGENPORT_Read_MULTI_INPUT_BUFFER;
   var   OutData:tGENPORT_Read_MULTI_OUTPUT_BUFFER
):boolean;
  {$IfOpt R+}var x:dword;{$EndIf Opt R+}
begin
  {$IfOpt R+}
   case InData.PortType of
     0: x:=ptArrayOfByte(@OutData.Data)^[InData.Count-1];
     1: x:=ptArrayOfWord(@OutData.Data)^[InData.Count-1];
     2: x:=ptArrayOfDWord(@OutData.Data)^[InData.Count-1];
     else
       raise ERangeError.Create('InBuffer: Invalid PortType value.');
   end;
  {$EndIf Opt R+}
   LastIOPortSet(InData.Port);
   Result:=GetDriver(IOCTL_GPD_READ_PORT_BUFFER,
                        InData, SizeOf(InData),
                        OutData, SizeOf(OutData.Header)+PortSize(InData.PortType)*InData.Count
      );
end;

const cOutByteBuffer10Size=((cShortBuffer+3) div 4)*4;
type
  tGENPORT_WRITE_MULTI_INPUT_ShortBUFFER=packed record
    Header:tGENPORT_WRITE_MULTI_INPUT_BUFFER;
    Data:array[0..cOutByteBuffer10Size-SizeOf(ULONG)] of byte;
  end;

threadvar OutByteBuffer10:tGENPORT_WRITE_MULTI_INPUT_ShortBUFFER;

function OutByteShortBuffer(Port:word; const Bytes; Size:word):boolean;
begin
  {$IfOpt R+}
    if Size>cOutByteBuffer10Size then
    raise ERangeError.Create('OutByteShortBuffer: Too large size of Bytes.');
  {$EndIf Opt R+}
  OutByteBuffer10.Header.Header.Port:=Port;
  OutByteBuffer10.Header.Header.PortType:=Ord(PORT_UCHAR);
  OutByteBuffer10.Header.Header.Count:=Size;
  Move(Bytes,OutByteBuffer10.Header.Data, Size);
  LastIOPortSet(Port);
  Result:=GetDriverInOnly(IOCTL_GPD_WRITE_PORT_BUFFER,
                   OutByteBuffer10, SizeOf_tGENPORT_WRITE_MULTI_INPUT_BUFFER(OutByteBuffer10.Header));
end;

{function OutByteShortBuffer(Port:word; const Bytes:array of byte):boolean;
begin
  Result:=OutByteShortBuffer(Port, Bytes[0], Length(Bytes));
end;}

var OutBufferData:tOutBuffer;
function OutByteBuffer(Port:word; const Bytes; Size:word):boolean;
  var Buf:ptGENPORT_WRITE_MULTI_INPUT_BUFFER;
begin
  if not Assigned(OutBufferData) then
    OutBufferData:=tOutBuffer.Create;
  Buf:=OutBufferData.LockAndGetBufferPtr;
  Buf^.Header.Port:=Port;
  OutBufferData.AssignByteArray(Bytes, Size);
  LastIOPortSet(Port);
  Result:=GetDriverInOnly(IOCTL_GPD_WRITE_PORT_BUFFER,
                    Buf^, SizeOf_tGENPORT_WRITE_MULTI_INPUT_BUFFER(Buf^));
  OutBufferData.Unlock;
end;

{function OutByteBuffer(Port:word; const Bytes:array of byte):boolean;
  var Buf:ptGENPORT_WRITE_MULTI_INPUT_BUFFER;
begin
  if not Assigned(OutBufferData) then
    OutBufferData:=tOutBuffer.Create;
  Buf:=OutBufferData.LockAndGetBufferPtr;
  Buf^.Header.Port:=Port;
  OutBufferData.AssignByteArray(Bytes);
  Result:=GetDriverInOnly(IOCTL_GPD_WRITE_PORT_BUFFER,
                   Buf^, SizeOf_tGENPORT_WRITE_MULTI_INPUT_BUFFER(Buf^));
  OutBufferData.Unlock;
end;}

const cInByteBuffer10Size=cOutByteBuffer10Size;
type
  tGENPORT_READ_MULTI_INPUT_ShortBUFFER=packed record
    Header:tGENPORT_READ_MULTI_OUTPUT_BUFFER;
    Data:array[0..cInByteBuffer10Size-SizeOf(ULONG)] of byte;
  end;

threadvar InByteBuffer10:tGENPORT_READ_MULTI_INPUT_ShortBUFFER;

function InByteShortBuffer(Port:word; var Bytes; Size:word):boolean;
  var InBuf:tGENPORT_READ_MULTI_INPUT_BUFFER;
begin
  {$IfOpt R+}
    if Size>cOutByteBuffer10Size then
    raise ERangeError.Create('InByteBuffer10: Too large size of Bytes.');
  {$EndIf Opt R+}
  InBuf.Port:=Port;
  InBuf.PortType:=Ord(PORT_UCHAR);
  InBuf.Count:=Size;
  LastIOPortSet(Port);
  Result:=GetDriver(IOCTL_GPD_READ_PORT_BUFFER,
                    InBuf, SizeOf(InBuf),
                    InByteBuffer10,SizeOf(InByteBuffer10.Header.Header)+Size);
  if Result then
    Move(InByteBuffer10.Header.Data, Bytes, Size);
end;

{function InByteShortBuffer(Port:word; var Bytes:array of byte):boolean;
begin
  Result:=InByteShortBuffer(Port, Bytes[0], Length(Bytes));
end;}

var InBufferData:tInBuffer;
function InByteBuffer(Port:word; var Bytes; Size:word):boolean;
  var OutBuf:ptGENPORT_READ_MULTI_OUTPUT_BUFFER;
      InBuf:tGENPORT_READ_MULTI_INPUT_BUFFER;
begin
  if not Assigned(InBufferData) then
    InBufferData:=tInBuffer.Create;
  InBuf.Port:=Port;
  InBuf.PortType:=Ord(PORT_UCHAR);
  InBuf.Count:=Size;
  InBufferData.Lock;
  InBufferData.Size:=Size;
  OutBuf:=InBufferData.GetBufferPtr;
  LastIOPortSet(Port);
  Result:=GetDriver(IOCTL_GPD_READ_PORT_BUFFER,
                    InBuf, SizeOf(InBuf),
                    OutBuf^,SizeOf(OutBuf^.Header)+Size);
  if Result then
    InBufferData.CopyByteArrayTo(Bytes, Size);
  InBufferData.Unlock;
end;

{function InByteBuffer(Port:word; var Bytes:array of byte):boolean;
begin
  Result:=InByteBuffer(Port, Bytes[0], Length(Bytes));
end;}

function CheckMultifunctionIO(
  const CommandData; CommandDataSize:word;
  var   ResultData:tGENPORT_MULTIFUNCTION_IO_OPERATION_CHECK_OUTPUT_BUFFER
):boolean;
begin
  LastIOPortSet(0);
  Result:=GetDriver(IOCTL_GPD_MULTIFUNCTION_IO_OPERATION_CHECK_INPUT_BUFFER,
             CommandData, CommandDataSize,
             ResultData, SizeOf(ResultData));
end;

function XMultifunctionIO(const CommandData:array of dword; ResultData:ptDynamicArrayOfULong):boolean;
  var OutBuf:tGENPORT_MULTIFUNCTION_IO_OPERATION_CHECK_OUTPUT_BUFFER;
begin
  Result:=Length(ResultData^)>0;
  if not Result then begin
    Result:=GetDriver(IOCTL_GPD_MULTIFUNCTION_IO_OPERATION_CHECK_INPUT_BUFFER,
             CommandData[0], Length(CommandData)*SizeOf(CommandData[0]),
             OutBuf, SizeOf(OutBuf));
    if Result then begin
       SetLength(ResultData^, (OutBuf.OutputDataSize div 4));
    end;
  end;
  if Result then begin
    LastIOPortSet(0);
    Result:=GetDriver(IOCTL_GPD_MULTIFUNCTION_IO_OPERATION,
           CommandData[0], Length(CommandData)*SizeOf(CommandData[0]),
             ResultData^[0], Length(ResultData^)*SizeOf(ResultData^[0]));
  end;
end;

function MultifunctionIO(const CommandData; CommandDataSize:word;
                                        var ResultData;  ResultDataSize:word):boolean;
begin
  LastIOPortSet(0);
  Result:=GetDriver(IOCTL_GPD_MULTIFUNCTION_IO_OPERATION,
             CommandData, CommandDataSize,
             ResultData, ResultDataSize);
end;

INITIALIZATION
{ Подключиться к драйверу }
  LastIOErrorCode:=0;
  OutBufferData:=NIL;
  InBufferData:=NIL;

  if not GetNtDriverHandle(cMi1201AGM) then
    GetNtDriverHandle(cOldDeviceName);

FINALIZATION
{ Освободить HANDLE (закрыть файл) }
  ReleaseHandle;
  FreeAndNil(OutBufferData);
  FreeAndNil(InBufferData);
END.