{ Ввод/вывод в порты для  DOS и Windows 9x }
// !!! DOS варианты программ не отлажены!!!!

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

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

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

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

{ эквиваленты инструкций IN AL,DX и OUT DX,AL и более сложных процедур для доступа к портам
в Windows 95/98 (прямо в порты)}

unit DirectPortsIO;

interface
  USES MI1201ioctl;


function LastError:longint; register;
function AbortOperation(State:boolean):boolean;
function GetAbortState:boolean;

{ ---- прямой доступ к портам для Windows 95/98 ----}

{ Многофункциональный ввод/вывод. Принимает буфер команд 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; register; overload;

{ Ввод/вывод байта 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;

{ ЛЕНИВО ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>. С интервалом TimeStep.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function LazyWait(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;
{$IfDef Seg16 --- DOS & Protected mode ---}
function CalibrateWait(Port:word):boolean;
{$Endif}

{ ввод массива из порта в Windows 95/98}
function InBytes(Port:word; var Data; Size:word):boolean; register;
{ вывод в порт массива Windows 95/98}
function OutBytes(Port:word; const Data; Size:word):boolean; register;
{ прямой вывод в порт для Windows 95/98}
procedure OutByte(b:Byte; Port:word); register;
{ прямой ввод из порта для Windows 95/98}
function  InByte(Port:word):byte; register;

implementation
  USES {$IfNDef Seg16}Windows, {$EndIf} MiscFunc, PortsIO;

type
  NTSTATUS=ulong;

const
   STATUS_SUCCESS = 0;
   STATUS_INVALID_PARAMETER=$C000000D;

const
  globalLastError:longint=0;

function LastError:longint;
begin
  Result:=globalLastError;
end;

var
  globalAbort:boolean;

function GetPortSize(PortType:ULONG):UCHAR;
begin
  case (PortType) of
    Ord(PORT_UCHAR):  Result:=sizeof(UCHAR);
    Ord(PORT_USHORT): Result:=sizeof(USHORT);
    Ord(PORT_ULONG):  Result:=sizeof(ULONG);
    else           Result:=0;
  end;
end;

{ Многофункциональный ввод/вывод. Принимает буфер команд CommandData, выполняет команды и возвращает
  TRUE - успешное выполнение и ResultData заполняется результатами выполнения
  FALSE - неверный формат или размер буфера команд CommandData и ResultData не изменяется.
Проверить буфер команд можно вызовом CheckMultifunctionIO.}
function MultifunctionIO(const CommandData; CommandDataSize:word;
                                        var ResultData;  ResultDataSize:word):boolean; register;
  var
    CheckResultData:tGENPORT_MULTIFUNCTION_IO_OPERATION_CHECK_OUTPUT_BUFFER;
    RecordCount:ULONG;
    OutRecordCount:ULONG;
    RecordNumber:ULONG; // номер текущей записи в буфере
    pCurRecord:ptGENPORT_MULTIFUNCTION_IO_INPUT_HEADER;
    pCurOutRecord:PULONG;
    Cnt, Size:ULONG;
    WaitTime:longint;
begin
  result:=CheckMultifunctionIO(CommandData, CommandDataSize, CheckResultData);
  if result then begin
    // число записей в буфере
    RecordCount := ptGENPORT_MULTIFUNCTION_IO_INPUT_BUFFER(@CommandData)^.Count;
    // указатель на текущую запись в буфере
    pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_INPUT_BUFFER(@CommandData)^.Data;
    // указатель на текущую запись в ВЫХОДНОМ буфере
    pCurOutRecord := @ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Data;
    // счетчик записей в ВЫХОДНОМ буфере
    ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Header.OpCount:=RecordCount;
    ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Header.RecordCount:=0;
    OutRecordCount := 0;

    for RecordNumber:=1 to RecordCount do begin
      // проверяем нет ли ошибки
      if (PortsIO.IsError) then begin
	// есть запрос на прерывание - завершаем, возвратив обработанное число записей
	ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Header.OpCount:=RecordNumber-1;
	ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Header.RecordCount := OutRecordCount;
        globalLastError:=PortsIO.LastErrorCode;
        Result:=FALSE;
        Exit;
      end;
      // проверяем нет ли запроса на прерывание
      if (PortsIO.AbortState) then begin
	// есть запрос на прерывание - завершаем, возвратив обработанное число записей
	ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Header.OpCount:=RecordNumber-1;
	ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Header.RecordCount := OutRecordCount;
        Exit;
      end;

     // разбираем код операции
     case pCurRecord^.OpCode.Code of
       mfocRead: begin  // чтение одного значения
  	 // читаем
	 ptGENPORT_MULTIFUNCTION_IO_READ_OUTPUT(pCurOutRecord)^.Data.ULong := PortsIO.InByte(ptGENPORT_MULTIFUNCTION_IO_READ_INPUT(pCurRecord)^.Port.Number);
	 // все хорошо, переходим к следующей записи
	 pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_READ_INPUT_NEXT(pCurRecord)^.NextBuffer;
	 pCurOutRecord := @ptGENPORT_MULTIFUNCTION_IO_READ_OUTPUT_NEXT(pCurOutRecord)^.NextBuffer;
	 OutRecordCount := OutRecordCount+1;
       end;

       mfocWrite: begin		  // запись одного значения
         // пишем
	 PortsIO.OutByte(
                ptGENPORT_MULTIFUNCTION_IO_WRITE_INPUT(pCurRecord)^.Data.UCHAR,
                ptGENPORT_MULTIFUNCTION_IO_WRITE_INPUT(pCurRecord)^.Port.Number
	 );
         // все хорошо, переходим к следующей записи
	 pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_WRITE_INPUT_NEXT(pCurRecord)^.NextBuffer;
       end;

       mfocReadBuffer: begin	  // чтение нескольких значений
 	 // читаем
	 InBytes(ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT(pCurRecord)^.Port.Number,
		  ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT(pCurOutRecord)^.Data.ULong[0],
		  ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT(pCurRecord)^.Count
 	 );
       	 // размер выходного буфера
	 Cnt := ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT(pCurRecord)^.Count;
	 Size := GetPortSize(ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT(pCurRecord)^.Port.PortType);
	 // округление до целого числа ULONG
	 pCurOutRecord := @ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_OUTPUT(pCurOutRecord)^.Data.ULong[(Cnt*Size +3) div 4];
	 OutRecordCount := OutRecordCount+1;
	 // все хорошо, переходим к следующей записи
	 pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT_NEXT(pCurRecord)^.NextBuffer;
       end;

       mfocWriteBuffer: begin  // запись нескольких значений
	 // пишем
	 Cnt := ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Count;
         OutBytes(ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Port.Number,
		  ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Data.ULong[0],
		  Cnt
	 );
	 // вычисление полного размера записи вместе с массивом данных буфера
	 Size := GetPortSize(ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Port.PortType);
	 // все хорошо, переходим к следующей записи
	 pCurRecord := ptGENPORT_MULTIFUNCTION_IO_INPUT_HEADER(
	                @ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Data.ULong[((Cnt*Size +3) div 4)]
                     );
       end;

       mfocWait: begin // ожидание
         ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.Event:=
	           LazyWait(ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT(pCurRecord)^.WaitData.Port.Number,
                            ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT(pCurRecord)^.WaitData.Mask,
                            ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT(pCurRecord)^.WaitData.Patt,
                            ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT(pCurRecord)^.WaitData.TimeOut,
                            ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT(pCurRecord)^.WaitData.TimeResolution,
                            WaitTime
                   );
         ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.Data.ULong:=PortsIO.InByte(ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT(pCurRecord)^.WaitData.Port.Number);
         ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.TimeOut:=WaitTime;
         if LastErrorCode<>0 then begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrError);
           Result:=FALSE;
           Exit;
         end else if PortsIO.AbortState then begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrABANDONED);
         end else if ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.Event then begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrSUCCESS);
         end else begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrTimeOut);
         end;
         // переходим к следующей записи
         pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT_NEXT(pCurRecord)^.NextBuffer;
         pCurOutRecord := @ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT_NEXT(pCurOutRecord)^.NextBuffer;
         OutRecordCount := OutRecordCount+1;
       end;

       mfocWriteAndWait: begin // запись одного значения+ожидание
         ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT(pCurOutRecord)^.Event:=
           OutByteAndWait(  ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WriteData.Port.Number,
                            ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WriteData.Data.UCHAR,
                            ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WaitData.Port.Number,
                            ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WaitData.Mask,
                            ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WaitData.Patt,
                            ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WaitData.TimeOut,
                            ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WaitData.TimeResolution,
                            WaitTime
                   );
         ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.Data.ULong:=PortsIO.InByte(ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WaitData.Port.Number);
         ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.TimeOut:=WaitTime;
         if LastErrorCode<>0 then begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrError);
           Result:=FALSE;
           Exit;
         end else if PortsIO.AbortState then begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrABANDONED);
         end else if ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.Event then begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrSUCCESS);
         end else begin
           ptGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT(pCurOutRecord)^.WaitResult:=Ord(pwrTimeOut);
         end;
	 // переходим к следующей записи
	 pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT_NEXT(pCurRecord)^.NextBuffer;
	 pCurOutRecord := @ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT_NEXT(pCurOutRecord)^.NextBuffer;
  	 OutRecordCount := OutRecordCount+1;
       end;

       mfocInvalidOperation: begin 	// неверная операция - резервировано
         Result:=FALSE;
         Exit;
       end;
       else begin
         Result:=FALSE;
         Exit;
       end;
     end;
     ptGENPORT_MULTIFUNCTION_IO_OUTPUT_BUFFER(@ResultData)^.Header.RecordCount := OutRecordCount;
    end;
  end;
  globalLastError:=0;
end;

//----------------------------------------------------------
function CheckMultifunctionIrpBuffer(
    pBuffer:ptGENPORT_MULTIFUNCTION_IO_INPUT_BUFFER;
    uBufferSize:ULONG;
    var ErrorDesc:tGENPORT_MULTIFUNCTION_IO_ERROR_DESCRIPTION;
    var pOutputBufferSize:ULONG
):NTSTATUS; overload;

{
Описание процедуры:
    Эта процедура проверяет и обрабатывает буфер многофункционального IOCTL:
	1) Проверяет размеры и данные.

Аргументы:
	pBuffer		      	- Входной буфер, который надо обработать.
	pErrorDesc	      	- Описание ошибки, если возвращен не STATUS_SUCCESS.
	pOutputBufferSize	- Необходимый размер выходного буфера.

Return Value:
    STATUS_SUCCESS           -- OK

    STATUS_INVALID_PARAMETER --  буфер слишком мал (велик) или содержит недопустимые данные.
}
  var
    RecordCount:ULONG;
    RecordNumber:ULONG; // номер текущей записи в буфере
    pCurRecord:ptGENPORT_MULTIFUNCTION_IO_INPUT_HEADER;
    BufferSize:int64;
    OutputBufferSize:int64;
    Cnt, Size, ULongCnt:ULONG;
    RecordSize:LONG;

begin

   if ( uBufferSize < sizeof(tGENPORT_MULTIFUNCTION_IO_INPUT_BUFFER) ) then begin
     ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall);
     ErrorDesc.RecordNumber := 0;
     Result:=STATUS_INVALID_PARAMETER;
     Exit;
   end;

   // ожидаемое число записей в буфере
    RecordCount := pBuffer^.Count;
   // проверяем число записей в буфере
   if( 0 = RecordCount ) then begin
     ErrorDesc.ErrorCode.ULong := Ord(mferrRecordsCountEqZero);
     ErrorDesc.RecordNumber := 0;
     Result:=STATUS_INVALID_PARAMETER;
     Exit;
   end;

   // размер буфера
   BufferSize := uBufferSize;
   // указатель на текущую запись в буфере
   pCurRecord := @pBuffer^.Data;
   // размер остатка буфера
   BufferSize := BufferSize - sizeof(pBuffer^.Count);
   // размер выходного буфера
   OutputBufferSize := sizeof(tGENPORT_MULTIFUNCTION_IO_OUTPUT_HEADER);

   for RecordNumber:=1 to RecordCount do begin
    // проверяем минимально необходимый размер буфера
    if BufferSize < sizeof(pCurRecord^)  then begin
      ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_2);
      ErrorDesc.RecordNumber := RecordNumber;
      Result:=STATUS_INVALID_PARAMETER;
      Exit;
    end;

    // разбираем код операции
    case pCurRecord^.OpCode.Code of
      mfocRead: begin		  // чтение одного значения
        // проверяем  необходимый размер буфера
	if( BufferSize < sizeof(tGENPORT_MULTIFUNCTION_IO_READ_INPUT) ) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_3);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        if (Byte(Ord(PORT_UCHAR))<>ptGENPORT_MULTIFUNCTION_IO_READ_INPUT(pCurRecord)^.Port.PortType) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferraddInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        // все хорошо, переходим к следующей записи
	BufferSize := BufferSize - sizeof(tGENPORT_MULTIFUNCTION_IO_READ_INPUT);
	pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_READ_INPUT_NEXT(pCurRecord)^.NextBuffer;
	// размер выходного буфера
	OutputBufferSize := OutputBufferSize + sizeof(tGENPORT_MULTIFUNCTION_IO_READ_OUTPUT);
      end;

      mfocWrite: begin  // запись одного значения
	// проверяем  необходимый размер буфера
	if( BufferSize < sizeof(tGENPORT_MULTIFUNCTION_IO_WRITE_INPUT) ) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_3);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        if (Byte(Ord(PORT_UCHAR))<>ptGENPORT_MULTIFUNCTION_IO_WRITE_INPUT(pCurRecord)^.Port.PortType) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferraddInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        // все хорошо, переходим к следующей записи
	BufferSize := BufferSize - sizeof(tGENPORT_MULTIFUNCTION_IO_WRITE_INPUT);
	pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_WRITE_INPUT_NEXT(pCurRecord)^.NextBuffer;
	// размер выходного буфера = 0
      end;

      mfocReadBuffer: begin	  // чтение нескольких значений
	// проверяем  необходимый размер буфера
	if( BufferSize < sizeof(tGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT) ) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_3);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        if (Byte(Ord(PORT_UCHAR))<>ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT(pCurRecord)^.Port.PortType) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferraddInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
	BufferSize := BufferSize - sizeof(tGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT);
	// размер выходного буфера
	Cnt := ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT(pCurRecord)^.Count;
	if( 0 = Cnt ) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrReadBuffer_CountZero);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
	Size := GetPortSize(ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT(pCurRecord).Port.PortType);
	OutputBufferSize := OutputBufferSize
			  +((Cnt*Size +3) div 4)*4; // округление до целого числа ULONG
	// все хорошо, переходим к следующей записи
	pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_READ_BUFFER_INPUT_NEXT(pCurRecord)^.NextBuffer;
        end;

      mfocWriteBuffer: begin  // запись нескольких значений
	// проверяем  необходимый размер буфера
	if( BufferSize < sizeof(tGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT) )then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_3);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        if (Byte(Ord(PORT_UCHAR))<>ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Port.PortType) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferraddInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
	// вычисление полного размера записи вместе с массивом данных буфера
	Cnt := ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Count;
	if( 0 = Cnt ) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrReadBuffer_CountZero);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
	Size := GetPortSize(ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Port.PortType);
	if( 0 = Size ) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
	ULongCnt := ((Cnt*Size +3) div 4); // округление размера массива данных до целого числа ULONG
	RecordSize := ULongCnt*4
		     - 4  // один ULONG уже есть в GENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT
		     + sizeof(tGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT);
	if( BufferSize < RecordSize )then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_4);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
	BufferSize := BufferSize - RecordSize;
	// размер выходного буфера = 0
	// все хорошо, переходим к следующей записи
	pCurRecord := ptGENPORT_MULTIFUNCTION_IO_INPUT_HEADER(
                       @ptGENPORT_MULTIFUNCTION_IO_WRITE_BUFFER_INPUT(pCurRecord)^.Data.ULong[ULongCnt]
                     );
      end;

      mfocWait: begin  // ожидание
	// проверяем  необходимый размер буфера
        if( BufferSize < sizeof(tGENPORT_MULTIFUNCTION_IO_WAIT_INPUT) )then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_3);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        if (Byte(Ord(PORT_UCHAR))<>ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT(pCurRecord)^.WaitData.Port.PortType) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferraddInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        // все хорошо, переходим к следующей записи
	BufferSize := BufferSize - sizeof(tGENPORT_MULTIFUNCTION_IO_WAIT_INPUT);
	pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_WAIT_INPUT_NEXT(pCurRecord)^.NextBuffer;
	// размер выходного буфера
	OutputBufferSize := OutputBufferSize + sizeof(tGENPORT_MULTIFUNCTION_IO_WAIT_OUTPUT);
      end;

      mfocWriteAndWait: begin// запись одного значения+ожидание
	// проверяем  необходимый размер буфера
	if( BufferSize < sizeof(tGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT) ) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrBufferTooSmall_3);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        if (Byte(Ord(PORT_UCHAR))<>ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WriteData.Port.PortType) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferraddInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
        if (Byte(Ord(PORT_UCHAR))<>ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT(pCurRecord)^.Data.WaitData.Port.PortType) then begin
          ErrorDesc.ErrorCode.ULong := Ord(mferraddInvalidPortType);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
        end;
	// все хорошо, переходим к следующей записи
	BufferSize := BufferSize - sizeof(tGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT);
	pCurRecord := @ptGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_INPUT_NEXT(pCurRecord)^.NextBuffer;
	// размер выходного буфера
	OutputBufferSize := OutputBufferSize + sizeof(tGENPORT_MULTIFUNCTION_IO_WRITE_AND_WAIT_OUTPUT);
      end;

      mfocInvalidOperation: begin	// неверная операция - резервировано
          ErrorDesc.ErrorCode.ULong := Ord(mferrInvalidOpCode);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
      end;
      else begin
          ErrorDesc.ErrorCode.ULong := Ord(mferrInvalidOpCode);
          ErrorDesc.RecordNumber := RecordNumber;
          Result:=STATUS_INVALID_PARAMETER;
          Exit;
      end;
    end;
  end;
  if( OutputBufferSize > $FFFFFF00 ) then begin
     ErrorDesc.ErrorCode.ULong := Ord(mferrOutputBufferTooLarge);
     ErrorDesc.RecordNumber := RecordCount;
     Result:=STATUS_INVALID_PARAMETER;
     Exit;
  end;
  pOutputBufferSize := OutputBufferSize;
  result:=STATUS_SUCCESS;
end;

{ Проверка буфера команд 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;
   var OutputBufferSize:ULONG;
begin
  case CheckMultifunctionIrpBuffer(
                    ptGENPORT_MULTIFUNCTION_IO_INPUT_BUFFER(@CommandData), CommandDataSize,
                    ResultData, OutputBufferSize) of
    STATUS_SUCCESS: begin
      ResultData.ErrorCode.ULong := Ord(mferrOK); // код ошибки заносится OK
      ResultData.OutputDataSize := OutputBufferSize; // размер необходимого выходного буфера
      result:=TRUE;
    end;
    else begin
      result:=FALSE;
    end;
  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;
{$IfDef Seg16 --- DOS & Protected mode ---}
  var DelayCoef:longint; ec:word;
begin
  ec:=ErrorCode;
  If ec=0 then begin { отмена исполнения при наличии ошибки }
    DelayCoef:=prData.DelayCoefficient;
    asm
      les bx,Self
{      call CheckStatus; jc @End1}

      { Установка в CX порта для ввода}
      mov cx,WaitPort

      { Установка в ES:[DI] безопасного адреса для цикла ожидания }
      mov es,Seg0040; xor di,di
      mov ah,es:[di]

      { Подготовка маски и образца для цикла }
      mov bh,Mask; mov bl,Patt

{ Вывод байта }
    mov dx,Port
    mov al,ByteOut
    out dx,al

      { Установка в DX порта для ввода}
      mov DX,CX
      { Цикл ожидания }
      @WaitLoop:
	mov cx,word(DelayCoef); mov si,word(DelayCoef[2])
	call Wait1msec; jz @End
	sub word(Time),1; sbb word(Time[2]),0; jc @ErrorExit
      jmp @WaitLoop
      @ErrorExit: or bh,bh; jz @End
	mov ax,ecTimeOut;
      jmp @End1
      @End: xor ax,ax
      @End1:
      mov ec,ax
    end;
    if ec<>0 then
      SetErrorCode(tErrorCode(ec));
  end;
  exOutByteAndWaitX:=ec;
end;
{$Else --- Delphi ---- }
begin
  Result:=FALSE;
  if not PortsIO.AbortState then begin
    PortsIO.OutByte(aByte, Port);
    if not PortsIO.IsError then begin
      if TimeStep=0 then
        Result:=Wait(WaitPort, Mask, Patt, Time, WaitTime)
      else
        Result:=LazyWait(WaitPort, Mask, Patt, Time, TimeStep, WaitTime);
    end;
  end;
end;
{$Endif}

function AbortOperation(State:boolean):boolean;
begin
  Result:=globalAbort;
  globalAbort:=State;
end;

function GetAbortState:boolean;
  const Lock:boolean=FALSE;
begin
  if Lock then
    Result:=globalAbort
  else begin
    Lock:=TRUE;
    Result:=globalAbort or PortsIO.AbortState;
    Lock:=FALSE;
  end;
end;

type
  TByteArray=array[word] of Byte;

{ ЛЕНИВО ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>. С интервалом TimeStep.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function LazyWait(Port:word; Mask,Patt:Byte;
                  Time_ms:longint; TimeStep_ms:word; var WaitTime:longint):boolean;
  var ti:tTimeInterval;
begin
  Result:=FALSE;
  if not PortsIO.AbortState then begin
    ti.Start(Time_ms);
    Result:=((PortsIO.InByte(Port) and Mask)=Patt);
    if (not Result) then begin
      if TimeStep_ms>Time_ms then
        TimeStep_ms:=(Time_ms shr 2);
      repeat
        Result:=((PortsIO.InByte(Port) and Mask)=Patt);
        if not Result then begin
          Sleep(TimeStep_ms);
          Result:=((PortsIO.InByte(Port) and Mask)=Patt);
        end;
      until Result or ti.IntervalEnd or PortsIO.AbortState;
      if (not Result) then begin
        Result:=((PortsIO.InByte(Port) and Mask)=Patt);
      end;
    end;
    WaitTime:=ti.TimeSpend;
    globalLastError:=0;
    globalLastError:=PortsIO.LastErrorCode;
  end;
end;

{$IfDef Seg16 --- DOS & Protected mode ---}
const DelayCoefficient:longint=0;
var MinDelayInterval:longint;
var MinDelayCoefficient:longint;

{ Ожидает 1 миллисекунду событие в порте DX: (Port[DX] and BH)=BL,
заданное как BH:=маска; BL:=образец;
   Возвращает: ZF=1 - если дождалась, ZF=0 - иначе
   Использует SI:CX как счетчик }
procedure Wait1msec;
assembler;
asm
  mov cx,word(DelayCoefficient); mov si,word(DelayCoefficient[2])
  @Delay:

     in al,dx; and al,bh; xor al,bl { проверка события }
     je @EventOccured { выход если событие произошло }

     sub cx,1; sbb si,0; jc @ExitWait { проверка счетчика }

     cmp es:[di],ah { выход для калибровки по системному таймеру или требованию завершения}
  je @Delay
  @ExitWait:
  @EventOccured:
end;

{ Ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function Wait(Port:word; Mask,Patt:Byte; Time:longint; var WaitTime:longint):boolean;
assembler;
    asm
      les bx,Self
      { Установка в DX порта для ввода}
      mov dx,Port

      { Установка в ES:[DI] адреса Abort, если Abort=TRUE процедура немедленно прерывается }
      les di,Abort
      xor ah,ah

      { Подготовка маски и образца для цикла }
      mov bh,Mask; mov bl,Patt

      { Цикл ожидания }
      @WaitLoop:
	call Wait1msec; jz @End
	sub word(Time),1; sbb word(Time[2]),0; jc @End
      jmp @WaitLoop
      @End:
        cmp es:[di],0; je @OK
          xor ax,ax; xor dx,dx { остановка по требованию }
        jmp @Exit
        @OK:
          mov ax,word(Time); mov dx,word(Time[2])
      @Exit:
    end;
  end;

function CalibrateWait(Port:word):boolean;
{ Калибровка процедуры Wait1msec на 1 миллисекунду }
const
  mSecondsPerTik=55; { около 55 (точно 54.945) миллисекунд в 1-м интервале
	    системного таймера(18.2 Гц)}
  var Counter:longint;
begin
  asm
    { Установка в DX безопасного порта ввода для цикла ожидания }
    MOV dx,Port

    { Подготовка счетчика SI:CX циклов }
    xor cx,cx; not cx; mov si,cx; { CX:=$FFFF; SI:=$FFFF }
    { Подготовка маски и образца для бесконечного цикла }
    mov bx,$00FF
    { Установка в ES:[DI] адреса счетчика системного таймера для цикла ожидания }
    mov es,Seg0040; mov di,6Ch

    { Ожидание изменения счетчика системного таймера }
    mov ah,es:[di]
    @WhileEqual:
      cmp ah,es:[di]
    je @WhileEqual

    { Вызов цикла ожидания с выходом по изменению счетчика системного таймера
    для подсчета числа циклов за 1/55 секунды }
    mov ah,es:[di]
    call Wait1msec

    { Вычисление числа циклов }
    not cx; not si
    { Копирование счетчика в локальную переменную }
    mov word(counter),cx; mov word(counter+2),si;
  end;
  counter:=(counter+(mSecondsPerTik shr 1)) div mSecondsPerTik;
  DelayCoefficient:=counter;

  { Вычисление минимального времени ожидания (мкс) }
  if DelayCoefficient>0 then begin
    MinDelayInterval:=(1000 + DelayCoefficient) div DelayCoefficient;
    if MinDelayInterval<=0 then begin
      MinDelayCoefficient:=(DelayCoefficient+500) div 1000;
      MinDelayInterval:=1;
    end else begin
      MinDelayCoefficient:=1;
    end;
  end else begin
    MinDelayInterval:=1000;
    MinDelayCoefficient:=1;
  end;

  CalibrateWait:=(Counter>=3);{ проверка ограничения по быстродействию машины }
end;

{$Else --- Delphi ---- }
{ Ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
function Wait(Port:word; Mask,Patt:Byte; Time:longint; var WaitTime:longint):boolean;
  var ti:tTimeInterval;
begin
  Result:=FALSE;
  If not PortsIO.AbortState then begin { отмена исполнения по требованию }
    ti.Start(Time);
    repeat
       Result:=(PortsIO.InByte(Port) and Mask)=Patt;
    until Result or ti.IntervalEnd or PortsIO.AbortState;
    WaitTime:=ti.TimeSpend;
    globalLastError:=0;
    globalLastError:=PortsIO.LastErrorCode;
  end;
end;
{$Endif}

{ ввод массива из порта в Windows 95/98}
function InBytes(Port:word; var Data; Size:word):boolean;
{$IfDef Seg16 --- DOS & Protected mode ---}
assembler;
asm
  les bx,Self
{  call CheckStatus; jc @End}
    mov dx,Port
    mov cx,Size; les di,Data
    cld
    @loop:
      insb
(*      { Цикл задержки }
      mov ax,es:tCtrl([bx]).prData.InDelay; or ax,ax; jz @SkipDelay
	@DelayLoop: dec ax; jnz @DelayLoop
      @SkipDelay:*)
    loop @loop
  @End:
  mov ax,TRUE
end;
{$Else --- Delphi ---- }
 var i:word;
begin
  for i:=0 to Pred(Size) do begin
    TByteArray(Data)[i]:=PortsIO.InByte(Port);
  end;
  globalLastError:=0;
  globalLastError:=PortsIO.LastErrorCode;
  Result:=not PortsIO.IsError;
end;
{$EndIF}

{ вывод в порт массива Windows 95/98}
function OutBytes(Port:word; const Data; Size:word):boolean;
{$IfDef Seg16 --- DOS & Protected mode ---}
assembler;
asm
  les bx,Self
{  call CheckStatus; jc @End}
    mov dx,Port
    mov cx,Size
    push ds
      lds si,Data
      cld
      @loop:
	outsb
(*	{ Цикл задержки }
	mov ax,es:tCtrl([bx]).prData.OutDelay; or ax,ax; jz @SkipDelay
	  @DelayLoop: dec ax; jnz @DelayLoop
	@SkipDelay:*)
      loop @loop
    pop ds
  @End:
  mov ax,TRUE;
end;
{$Else --- Delphi ---- }
  var i:word;
begin
  for i:=0 to Pred(Size) do begin
    PortsIO.OutByte(TByteArray(Data)[i], Port);
  end;
  globalLastError:=0;
  globalLastError:=PortsIO.LastErrorCode;
  Result:=not PortsIO.IsError;
end;
{$EndIF}

{ прямой вывод в порт для Windows 95/98}
procedure OutByte(b:Byte; Port:word);
{Вход: AL=b; DX=Port}
asm
  out Port,b
end;

{ прямой ввод из порта для Windows 95/98}
function  InByte(Port:word):byte;
asm
  mov DX,Port
  in al,DX
end;

END.