/*
 浜様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様融
 �                                                                          �
 �                      V 2 4   -   D R I V E R                             �
 �                                                                          �
 麺様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様郵
 �     Copyright (C) 1993 by Vision Systems GmbH, Norderstedt, Germany      �
 �                          All rights reserved                             �
 麺様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様郵
 � Treiber-Routinen zur Ansteuerung von COM-Schnittstellen. Es werden max.  �
 � 8 Com-Ports bedient, wobei Interrupt-Sharing und FIFOs unterst�tzt       �
 � werden. Die Routinen arbeiten - mit einigen Einschr�nkungen - auch im    �
 � Polling-Mode. Als Handshake-M�glichkeiten (nur im Interrupt-Modus)       �
 � stehen zur Verf�gung:                                                    �
 �   Output: CTS und/oder XOn/XOff                                          �
 �   Input : RTS und/oder XOn/XOff                                          �
 麺様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様郵
 � 19.Oct.93 WW: 1st release. Author: Winfried Wolf                         �
 � 19.Nov.93 WW: Interrupt Sharing                                          �
 � 24.Mar.94 WK: Auslagerung der DIRECT-Routinen nach V24DRV.SRC            �
 � 25.May.94 WK: Erzeugung C-Interface zum V24DRV-TSR                       �
 藩様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様様夕
*/

#include    <Dos.h>

#include    "tpascal.h"
#include    "v24dll.h"
#ifdef _MSC_VER
//#define segread    _segread
#define MK_FP      _MK_FP
#endif


typedef struct
{   Word    PortAddr ;
    Word    Int ;
    Integer IBSize ;
    Integer OBSize ;
} InitParam ;

enum { _Init_V24=1,     _Exit_V24,      _IntLog,        _Set_Baudrate,
       _Set_BaudDivisor,_SendBuffer,    _RecvBuffer,    _Set_LineParam,
       _ClearInpBuffer, _ClearOutBuffer,_Get_InpUsed,   _Get_OutFree,
       _Get_MSR,        _Get_LSR,       _Get_MCR,       _Set_Handshake,
       _Set_MCR,        _Uart_Class,    _All_Sent } ;


/*敖陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳朕
  � Interrupt Einsprungspunkt-Markierung                                 �
  青陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳潰*/
const struct { Byte jmp; Byte Ofs; char Mark[6]; Word FIN;} IntEntry
      =      { 0x0EB, 0x08, 'V','2','4','D','R','V', 0 } ;

static Byte far *IntPnt  = (Byte *)&IntEntry;
static int       IntNum  = 0 ;

/*敖陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳朕
  � Interrupt Call                                                       �
  青陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳潰*/
Word CallDrv (Word rAX, LongInt rCXDX, Pointer rESDI)
{
    REGS    regs ;
    SREGS   segs ;
    LongInt ESDI ;

    ESDI = (LongInt)rESDI ;
    regs.x.ax = rAX ;
    regs.x.dx = rCXDX & 0xFFFF ;
    regs.x.cx = rCXDX >> 16 ;
    regs.x.di =  ESDI & 0xFFFF ;
    /*segread (&segs);*/
    segs.es   =  ESDI >> 16 ;

    #ifdef _MSC_VER
    __asm { __mov  [segs.ds], DS;  }
    #else
    segs.ds   = _DS ;
    #endif

    return int86x(IntNum, &regs, &regs, &segs) ;
}

/*敖陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳朕
  � Check Interrupt Vector;                                              �
  � 00: unused;  01: used by other software;  02: used by V24TSR         �
  青陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳陳潰*/
Byte CheckVect (Byte far *Vect)
{
    int     i ;

    if ((Vect != Nil) && (FP_SEG(Vect) != 0xF000))
    {
        if ((FP_SEG(Vect) > 0xF000) || (FP_OFF(Vect) > 0xFF00))
            return  1 ;
        for (i=0; i<=7; i++)
            if (Vect[i] != IntPnt[i])
                return  1 ;
        return  2 ;
    }
    else
        return  0 ;
}

Boolean TPASCAL Set_IntVect (Byte Int)
{
    Byte far *Vect ;
    REGS    regs ;
    SREGS   segs ;

    if (Int < 0x60)
        return  False ;
    regs.h.ah = 0x35 ;
    regs.h.al = Int ;
    intdosx (&regs, &regs, &segs) ;
    Vect = (Byte far*)MK_FP(segs.es, regs.x.bx) ;
    if (CheckVect(Vect) != 2)
        return  False ;
    IntPnt = Vect ;
    IntNum = Int  ;

    return  True ;
}

Boolean TPASCAL Init_V24(Byte ComNum,Word aPortAddr,Byte anInt,Integer IBSiz,Integer OBSiz)
{
    InitParam   par ;

    par.PortAddr = aPortAddr ;
    par.Int      = anInt ;
    par.IBSize   = IBSiz ;
    par.OBSize   = OBSiz ;

    return (CallDrv((_Init_V24<<8)+ComNum,0,&par) == 1) ;
}

Procedure TPASCAL Exit_V24(Byte ComNum)
{
    CallDrv((_Exit_V24<<8)+ComNum,0,Nil) ;
}

Byte TPASCAL IntLog(Byte ComNum)
{
    return  CallDrv((_IntLog<<8)+ComNum,0,Nil);
}

Procedure TPASCAL Set_BaudRate(Byte ComNum, LongInt BR)
{
    CallDrv((_Set_Baudrate<<8)+ComNum,BR,Nil);
}

Procedure TPASCAL Set_BaudDivisor(Byte ComNum, Word BD)
{
    CallDrv((_Set_BaudDivisor<<8)+ComNum,BD,Nil);
}


Integer TPASCAL SendBuffer (Byte ComNum, Pointer Buf, Integer Cnt)
{
    return CallDrv((_SendBuffer<<8)+ComNum,Cnt,Buf);
}

Integer TPASCAL RecvBuffer (Byte ComNum, Pointer Buf, Integer Cnt)
{
    return CallDrv((_RecvBuffer<<8)+ComNum,Cnt,Buf);
}

Procedure TPASCAL Set_LineParam (Byte ComNum, Byte LP)
{
    CallDrv((_Set_LineParam<<8)+ComNum,LP,Nil);
}

Procedure TPASCAL ClearInpBuffer (Byte ComNum)
{
    CallDrv((_ClearInpBuffer<<8)+ComNum,0,Nil);
}

Procedure TPASCAL ClearOutBuffer  (Byte ComNum)
{
    CallDrv((_ClearOutBuffer<<8)+ComNum,0,Nil);
}

Integer   TPASCAL Get_InpUsed (Byte ComNum)
{
    return CallDrv((_Get_InpUsed<<8)+ComNum,0,Nil);
}

Integer   TPASCAL Get_OutFree (Byte ComNum)
{
    return CallDrv((_Get_OutFree<<8)+ComNum,0,Nil);
}

Byte TPASCAL Get_MSR (Byte ComNum)
{
    return CallDrv((_Get_MSR<<8)+ComNum,0,Nil);
}

Byte TPASCAL Get_LSR (Byte ComNum)
{
    return CallDrv((_Get_LSR<<8)+ComNum,0,Nil);
}

Byte TPASCAL Get_MCR (Byte ComNum)
{
    return CallDrv((_Get_MCR<<8)+ComNum,0,Nil);
}

Procedure TPASCAL Set_Handshake (Byte ComNum,Byte HS)
{
    CallDrv((_Set_Handshake<<8)+ComNum,HS,Nil);
}

Procedure TPASCAL Set_MCR (Byte ComNum,Byte Lines)
{
    CallDrv((_Set_MCR<<8)+ComNum,Lines,Nil);
}

Byte TPASCAL Uart_Class (Byte ComNum)
{
    return CallDrv((_Uart_Class<<8)+ComNum,0,Nil);
}

Boolean TPASCAL All_Sent (Byte ComNum)
{
    return  (CallDrv((_All_Sent<<8)+ComNum,0,Nil) == 1);
}