{ Универсальный ввод/вывод в порты  }
//--------------------- 2003 г ------------------------------
// Дополнительные функции драйвера
//--------------------------------

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

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

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

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

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

unit PortsIO;

interface
  USES Windows, DirectPortsIO, DriverPortsIO;

type
  tIOType=(ioDirect, ioViaFileSystem, ioError, ioEmulator, ioUnknown);

type
{ Вход: AL=b; DX=Port. Выход: ничего. Изменения: по соглашению о вызовах Delphi;}
  TOutB_Proc=procedure(b:Byte; Port:word); register;

{ Вход: AX=Port. Выход: AL=значение в порту. Изменения: по соглашению о вызовах Delphi;}
  TInB_Func =function(Port:word):byte; register;

{ ВВОД массива Bytes из порта Port. Возвращает: TRUE, если все хорошо }
  TInByteBuffer_Func =function(Port:word; var Bytes; Size:word):boolean; register;
{ ВЫВОД массива Bytes в порт Port. Возвращает: TRUE, если все хорошо }
  TOutByteBuffer_Func =function(Port:word; const Bytes; Size:word):boolean; register;
{ Ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
  TWait_Func = function(Port:word; Mask,Patt:Byte; Time:longint; var WaitTime:longint):boolean; register;
{ ЛЕНИВО ожидает <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>. С интервалом TimeStep.
  Возвращает: TRUE - дождались или FALSE - не дождались.  WaitTime = время ожидания [мс]. }
  TLazyWait_Func =function(Port:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
{ Ввод/вывод байта aByte в порт Port и ожидание <Time> миллисекунд события
  (Порт[Port] and <MASK>) = <PATT>.
  Возвращает: TRUE - дождались или FALSE - не дождались.
    WaitTime = время ожидания [мс]. }
  TOutByteAndWait_Func =function(Port:word; aByte:byte;
                          WaitPort:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
{ Многофункциональный ввод/вывод. Принимает буфер команд CommandData, выполняет команды и возвращает
  TRUE - успешное выполнение и ResultData заполняется результатами выполнения
  FALSE - неверный формат или размер буфера команд CommandData и ResultData не изменяется.
Проверить буфер команд можно вызовом CheckMultifunctionIO (см. модуль DriverPortsIO).}
  TMultifunctionIO_Func =function(const CommandData; CommandDataSize:word;
                                    var ResultData;  ResultDataSize:word):boolean; register;

  TLastError_Func =function:longint; register;
  TAbortState_Func =function:boolean; register;
  TAbortOperation_Func=function(State:boolean):boolean;

procedure OutByte(b:Byte; Port:word); register;
function InByte(Port:word):byte; register;
function OutByteBuffer(Port:word; var Bytes; Size:word):boolean; register;
function InByteBuffer(Port:word; var Bytes; Size:word):boolean; register;
function Wait(Port:word; Mask,Patt:Byte; Time:longint; var WaitTime:longint):boolean; register;
function LazyWait(Port:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
function OutByteAndWait(Port:word; aByte:byte;
                        WaitPort:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
function MultifunctionIO(const CommandData; CommandDataSize:word;
                           var ResultData;  ResultDataSize:word):boolean; register;

function IsError:boolean;
function LastErrorCode:longint;
function LastIOPort:Dword;
procedure LastIOPortSet(aPort:Dword);
function AbortState:boolean; register;
function AbortOperation(State:boolean):boolean; register;

function IOType:tIOType;
procedure SetIOType(aIOType:tIOType);
procedure SetDefaultIOType;

procedure SetExternalInOutByte(
              aInB:TInB_Func;
              aOutB:TOutB_Proc;
              aLastError:TLastError_Func); register;

procedure SetExternalProcedures(
              aInB:TInB_Func;
              aOutB:TOutB_Proc;
              aOutBBuf:TOutByteBuffer_Func;
              aInBBuf:TInByteBuffer_Func;
              aWait:TWait_Func;
              aLazyWait:TLazyWait_Func;
              aOutByteAndWait:TOutByteAndWait_Func;
              aMultifunctionIO:TMultifunctionIO_Func;
              aAbortState:TAbortState_Func;
              aAbortSet:TAbortOperation_Func;
              aLastError:TLastError_Func);
              register;


implementation
  USES MI1201ioctl;

type
  tFlag=(fIO_via_FileSystem, fIO_via_ExternalProcs, fIO_Error);
  tFlags=set of tFlag;

const
  cFlagsIO=[fIO_via_FileSystem, fIO_via_ExternalProcs, fIO_Error];

var
  OutB:TOutB_Proc; // вывод в порт
  InB:TInB_Func;   // ввод из порта
  InBBuf:TInByteBuffer_Func;
  OutBBuf:TOutByteBuffer_Func;
  FuncWait:TWait_Func;
  FuncLazyWait:TLazyWait_Func;
  FuncOutByteAndWait:TOutByteAndWait_Func;
  FuncMultifunctionIO:TMultifunctionIO_Func;
  AbortStateF:TAbortState_Func;
  AbortSet:TAbortOperation_Func;
  LastErr:TLastError_Func;


  prFlags:tFlags;
  prLastPortIO:dword;


procedure SetExternalProcedures(
              aInB:TInB_Func;
              aOutB:TOutB_Proc;
              aOutBBuf:TOutByteBuffer_Func;
              aInBBuf:TInByteBuffer_Func;
              aWait:TWait_Func;
              aLazyWait:TLazyWait_Func;
              aOutByteAndWait:TOutByteAndWait_Func;
              aMultifunctionIO:TMultifunctionIO_Func;
              aAbortState:TAbortState_Func;
              aAbortSet:TAbortOperation_Func;
              aLastError:TLastError_Func);
begin
  OutB:=aOutB; // вывод в порт
  InB:=aInB;   // ввод из порта
  InBBuf:=aInBBuf;
  OutBBuf:=aOutBBuf;
  FuncWait:=aWait;
  FuncLazyWait:=aLazyWait;
  FuncOutByteAndWait:=aOutByteAndWait;
  FuncMultifunctionIO:=aMultifunctionIO;
  AbortStateF:=aAbortState;
  AbortSet:=aAbortSet;
  LastErr:=aLastError;
  Exclude(prFlags,fIO_via_FileSystem);
  Include(prFlags, fIO_via_ExternalProcs);
end;

procedure SetDirectProcedures();
begin
  OutB:=DirectPortsIO.OutByte;
  InB:=DirectPortsIO.InByte;
  InBBuf:=DirectPortsIO.InBytes;
  OutBBuf:=DirectPortsIO.OutBytes;
  FuncWait:=DirectPortsIO.Wait;
  FuncLazyWait:=DirectPortsIO.LazyWait;
  FuncOutByteAndWait:=DirectPortsIO.OutByteAndWait;
  FuncMultifunctionIO:=DirectPortsIO.MultifunctionIO;
  AbortStateF:=DirectPortsIO.GetAbortState;
  AbortSet:=DirectPortsIO.AbortOperation;
  LastErr:=DirectPortsIO.LastError;
  Exclude(prFlags, fIO_via_ExternalProcs);
end;

procedure SetFileSystemProcedures();
  var DriverCapabilities:cardinal;
begin
  SetDirectProcedures();
  { Процедуры вывода в порты заменяем всегда -  в NT иного не дано }
  OutB:=DriverPortsIO.OutByte; // вывод в порт
  InB:=DriverPortsIO.InByte;   // ввод из порта
  { Запрашиваем возможности драйвера по расширенным функциям }
  DriverCapabilities:=GetDriverCapabilities;
  {$IfDef OldDriver} // возможность отключить MultiFunctionIO
  DriverCapabilities:=0;
  {$EndIf Def OldDriver}
  { Если драйвер может вводить/выводить массивы в/из порт(а)}
  if (DriverCapabilities and MI1201_CAP_FLAG_ARRAY_IO_SINGLE_PORT)<>0 then begin
    InBBuf:=DriverPortsIO.InByteShortBuffer;
    OutBBuf:=DriverPortsIO.OutByteShortBuffer;
  end;
  { Если драйвер может ожидать на порту }
  if (DriverCapabilities and MI1201_CAP_FLAG_WAIT_ON_SINGLE_PORT)<>0 then begin
    FuncWait:=DriverPortsIO.Wait;
    FuncLazyWait:=DriverPortsIO.Lazy_Wait;
  end;
  if (DriverCapabilities and MI1201_CAP_FLAG_WRITE_AND_WAIT_ON_SINGLE_PORT)<>0 then begin
    FuncOutByteAndWait:=DriverPortsIO.OutByteAndWait;
  end;
  if (DriverCapabilities and MI1201_CAP_FLAG_ARRAY_IO_RAW_PORTS_AND_WAIT)<>0 then begin
    FuncMultifunctionIO:=DriverPortsIO.MultifunctionIO;
  end;
  LastErr:=DriverPortsIO.LastError;
  AbortStateF:=DriverPortsIO.GetAbortDriverState;
  AbortSet:=DriverPortsIO.AbortDriverOperation;
  Exclude(prFlags, fIO_via_ExternalProcs);
  Include(prFlags,fIO_via_FileSystem);
end;

procedure SetExternalInOutByte(
              aInB:TInB_Func;
              aOutB:TOutB_Proc;
              aLastError:TLastError_Func); register;
begin
  SetDirectProcedures();
  OutB:=aOutB; // вывод в порт
  InB:=aInB;   // ввод из порта
  LastErr:=aLastError;
  Include(prFlags, fIO_via_ExternalProcs);
end;

procedure SetIOType(aIOType:tIOType);
begin
  case aIOType of
    ioDirect:
      SetDirectProcedures();
    ioViaFileSystem:
      SetFileSystemProcedures();
    else
      RunError(201);
  end;
end;

function Flags:tFlags;
begin
  Flags:=prFlags;
end;

procedure ClearIOFlags;
begin
  prFlags:=prFlags-cFlagsIO;
end;

procedure SetIOFlag(f:tFlag);
begin
  if f in cFlagsIO then begin
    ClearIOFlags;
    Include(prFlags,f);
  end;
end;

procedure OutByte(b:Byte; Port:word); register;
asm
  jmp OutB
end;

function  InByte(Port:word):byte; register;
asm
  jmp InB
end;

function OutByteBuffer(Port:word; var Bytes; Size:word):boolean; register;
begin
  Result:=OutBBuf(Port, Bytes, Size);
end;

function  InByteBuffer(Port:word; var Bytes; Size:word):boolean; register;
begin
  Result:=InBBuf(Port, Bytes, Size);
end;

function OutByteAndWait(Port:word; aByte:byte;
                        WaitPort:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
begin
  Result:=FuncOutByteAndWait(Port, aByte, WaitPort,Mask,Patt, Time,TimeStep, WaitTime);
end;

function Wait(Port:word; Mask,Patt:Byte; Time:longint; var WaitTime:longint):boolean; register;
begin
  Result:=FuncWait(Port, Mask,Patt, Time, WaitTime);
end;

function LazyWait(Port:word; Mask,Patt:Byte; Time:longint; TimeStep:word; var WaitTime:longint):boolean; register;
begin
  Result:=FuncLazyWait(Port, Mask,Patt, Time,TimeStep,  WaitTime);
end;

function MultifunctionIO(const CommandData; CommandDataSize:word;
                           var ResultData;  ResultDataSize:word):boolean; register;
begin
  Result:=FuncMultifunctionIO(CommandData, CommandDataSize, ResultData,  ResultDataSize);
end;


function LastErrorCode;
asm
  jmp LastErr
end;

function AbortOperation(State:boolean):boolean;
asm
  jmp AbortSet
end;

function AbortState:boolean;
asm
  jmp AbortStateF
end;

function LastIOPort;
begin
  Result:=prLastPortIO;
end;

procedure LastIOPortSet;
begin
  prLastPortIO:=aPort;
end;

function IsError;
begin
  Result:=LastErrorCode<>0;
end;

function IOType:tIOType;
begin
  if fIO_via_filesystem in Flags then begin
    IOType:=ioViaFileSystem;
  end else if (fIO_via_ExternalProcs in Flags) then begin
    IOType:=ioEmulator;
  end else begin
    IOType:=ioDirect;
  end;
end;

procedure SetDefaultIOType;
begin
  prFlags:=[];
  if IsWindowsNT then begin
    SetFileSystemProcedures();
  end else begin
    SetDirectProcedures();
  end;
end;

INITIALIZATION
  SetDefaultIOType;

FINALIZATION
END.