// SIO2.CPP Copyright White Falcon Software House and Sapikli TM.

/*#################### Import�l�sok ######################################*/

#include <conio.h>
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include "sio2.h"

static char VERSION_STRING[]="SIO2 v3.2  07/1995";

/*############## Export�lt (glob�lis) v�ltoz�k ###########################*/

char inpuf[puflen]; 			//soros input puffer
char csat=1;				//COM x
char level=4;				//IRQ x
int inwrpoi=0;				//input puffer mutat�
int inrdpoi=0;				//olvas�sn�l/�r�sn�l
int count;                              //a timer IT-hez
unsigned rs_bas=0x03f8;			//COMx b�zisc�m

/*#################### Modul (lok�lis) v�ltoz�k ##########################*/

static char hiba=0;			//RS-232 hiba v�ltoz�
static char lastit;			//az el�z� IT maszk
static char savedbits=0;		//az elmentett adatbitsz�m, stopbitsz�m, parit�s
static unsigned savedrate=1200;		//az elmentett BaudRate (ld. SaveLineDatas)
static unsigned it_seg;			//a megszak�t�s c�m�nek ment�s�hez
static unsigned it_ofs;
static unsigned rs_seg;			//az RS_Intr c�me
static unsigned rs_ofs;
static unsigned test_seg;		//tesztvektor
static unsigned test_ofs;
static unsigned w;
static unsigned it_vekt=0x30;		//IT b�zisc�m a vektort�bl�ban
static char megszak=0x0c;		//megszak�t�ssz�m

/*#################### Modul (lok�lis) f�ggv�nydeklar�ci�k ###############*/

static void interrupt (*oldhandler)(...);   //a r�gi megszak�t�s megh�v�s�hoz
static void interrupt (*oldtimer)(...);     //a r�gi timer-interrupt

static char IT_Test();		//ellen�rzi, hogy a vektor RS_Intr-re mutat-e
static void interrupt RS_Intr();	//a megszak�t�srutin
static void interrupt handler(...);        //timer IT

/*########################################################################*/

static void interrupt handler(...)	//a timer IT-re hurkol�dunk a timeout vizsg�lat�hoz
{
   count++;				//a sz�ml�l� n�vel�se
   oldtimer();				//a r�gi rutin megh�v�sa
}

char RSError()				//visszaadja a port �llapot�t vagy a hibak�dot
{
  char seged;

  seged=hiba;			//lek�rdezz�k az �llapotot
  hiba=0;			//t�r�lj�k a glob�lis v�ltoz�t
  return seged;
}				// 1: tele az input puffer
				// 2: tele az output puffer
				// 3: overrun
				// 4: par_test
				// 5: chr_ok
				// 6: DSR
				// 7: CTS
				// 8: �res az input puffer
				// 9: nincs grafikus driver
				//10: hardverhiba
				//11: felhaszn�l� �ltal megszak�tva
				//13: �rv�nytelen portc�m. (Nincs COM...)
				//14: �rv�nytelen param�ter
				//15: nincs tablet

/*########################################################################*/

int GetComNum()				// megkeresi a program els� 
//param�terek�nt megadott port sz�m�t, ennek hi�ny�ban az els� fizikailag
//l�tez� portot illetve kikeresi a port c�m�t is
{
  char len=0;
  int seged;

  asm {
    push ax
    push bx
    push cx
    push ds
    mov ax,_psp
    mov ds,ax
    mov bx,0x0080
    mov cl,[bx]				// a PSP-ben megkeress�k az els� param�tert
    xor al,al
    or cl,cl
    jz GCN4
    xor ch,ch
  }
GCN1:
  asm {
    inc bx
    mov al,[bx]
    cmp al,0x30
    jnc GCN2
    loop GCN1
    xor al,al
    jmp GCN4
  }
GCN2:
  asm {
    cmp al,0x3a				// ha sz�mmal kezd�dik, akkor vizsg�lunk csak
    jc GCN3
    loop GCN2
    xor al,al
    jmp GCN4
  }
GCN3:
  asm {
    sub al,0x30;
  }
GCN4:
  asm {
    mov len,al
    pop ds
    pop cx
    pop bx
    pop ax
  }
  if (!len) {				// automatikus portc�mkeres�s (ha nem volt param�ter)
    len=1;
    while (len<5) {
      asm {
        push ax
        push bx
        push es
        xor ax,ax
        mov es,ax
        mov bx,0x03fe			// a BIOS t�bl�zat�b�l kikeress�k a port c�m�t
        mov al,len
        xor ah,ah
        shl ax,1
        add bx,ax
        mov ax,es:[bx]
        mov bl,len
        add bl,5
        mov len,bl
        or ax,ax			//ha ez �res, akkor ugyanez a k�vetkez� portra
        jnz GCN5
        sub bl,5
        mov len,bl
      }
GCN5:
      asm {
        pop es
        pop bx
        pop ax
      }
    }
    if (len!=5) len-=5;		 	//a "len"-ben folyatott manipul�ci�k a tal�lat jelz�s�re szolg�lnak
  }
  seged=len;
  if ((seged<1) || (seged>4)) hiba=invalidparam;	//�rv�nytelen param�terrel ind�tott�k a programot
  return seged;
}

/*########################################################################*/

void ChrOut(char b)
{
  long idozito;

  if (hiba) return;
//  idozito=10000;
//  while (idozito && (!hiba)) --idozito;		//egy kis v�rakoz�s a torl�d�sok megel�z�s�re
  if (hiba) return;
  asm {
    push ax
    push dx
    mov dx,rs_bas			//v�rakoz�s az ad�spuffer �r�l�s�re
    add dx,rs_lsr
  }
SendCikl:
  asm {
    in al,dx
    test al,chr_out
    jz SendCikl
    pop dx
    pop ax
  }
  outportb(rs_bas+rs_mcr,10);			//request-to-send
  outportb(rs_bas,b);				//az adat kik�ld�se
  outportb(int_bas,0x20);			//esetleges ad�s IT eset�n IT-v�g jelz�s
}

/*########################################################################*/

char ChrIn()					//karakter olvas�sa a portr�l
{
  char data;

  if (hiba) return 0;
  if (((inrdpoi+1)==inwrpoi) || ((inrdpoi-puflen+1)>=inwrpoi)) {
    hiba=1;				//tele az input puffer
    return 0;
  }
  if (inwrpoi==inrdpoi) {
    hiba=8;				//�res az input puffer
    return 0;
  }
  data=inpuf[inwrpoi];			//az adat beolvas�sa
  (++inwrpoi)%=puflen;			//mutat�-l�ptet�s
  return data;
}

/*########################################################################*/

char ReadPort()				//karakter olvas�sa a portr�l v�rakoz�ssal
{
  while ((inrdpoi==inwrpoi) && (!hiba)) {	//v�rakozunk adat �rkez�s�re
    if (kbhit()) hiba=userbrk;
  };
  return ChrIn();			//beolvassuk
}

/*########################################################################*/

static void interrupt RS_Intr()		//Ez a rutin v�gzi a portr�l j�v� adatok beolvas�s�t
{
  asm {
    mov dx,rs_bas
    add dx,rs_lsr
    in al,dx
    test al,errors			//st�tusz olvas�sa
    jz RS3
    test al,chr_ok			//s�r�lt karakter?
    jz RS1
    mov al,5
    mov hiba,al
    jmp RS_Vege
  }
RS1:
  asm {
    test al,par_test			//parit�shiba?
    jz RS2
    mov al,4
    mov hiba,al
    jmp RS_Vege
  }
RS2:
  asm {
    test al,overrun			//overrun?
    jz RS_Vege
    mov al,3
    mov hiba,al
    jmp RS_Vege
  }
RS3:
  asm {
    test al,chr_in			//�rkezett �rv�nyes karakter?
    jz RS_Vege
    mov dx,rs_bas			//adatbeolvas�s
    in al,dx
    lea bx,inpuf
    mov di,inrdpoi			//az adat elt�rol�sa
    mov [bx+di],al
    inc word ptr inrdpoi
    cmp word ptr inrdpoi,puflen
    jc RS_Vege
    xor dx,dx
    mov inrdpoi,dx
  }
RS_Vege:
  asm {
    mov dx,int_bas			//jelezz�k, hogy j�het a k�vetkez� megszak�t�s
    mov al,0x20
    out dx,al
  }
  oldhandler();				//megh�vjuk az el�z� rutint
  return;
}

/*########################################################################*/

static char IT_Test()			//Megvizsg�ljuk, hogy �t van-e �ll�tva az IT (0: nem, 1: igen)
{
  char a=0;				//seg�dv�ltoz�

  asm {					//megszak�t�s ellen�rz�se
    push ax
    push bx
    push cx
    push dx
    push es
    mov ax,cs
    lea dx,RS_Intr
    mov rs_seg,ax
    mov rs_ofs,dx			//az "RS_Intr" rutin c�m�nek lek�rdez�se �s elt�rol�sa
    xor ax,ax
    mov es,ax
    mov bx,it_vekt
    mov ax,es:[bx+2]			//a soros porthoz tartoz� megszak�t�s vektorok kiolvas�sa
    mov cx,es:[bx]
    mov test_seg,ax			//az "RS_Intr" rutin c�m�nek visszaolvas�sa
    mov test_ofs,cx
    mov bx,rs_seg
    push cx				// Ha ax:cx == bx:dx, akkor a:=1
    push dx				// (IT vektor == &RS_Intr)
    shr cx,4
    shr dx,4
    add ax,cx				//a c�mekb�l 20 bites c�met k�sz�t�nk
    add bx,dx				//(�gy oldhat� meg az ugyanahhoz a c�met k�pvisel�,
    pop dx				//de k�l�nb�z� ofszet-szegmens� c�mek detekt�l�sa)
    pop cx
    and cl,0x0f
    and dl,0x0f
    cmp cl,dl				//�gy m�r k�zvetlen�l �ssze lehet �ket hasonl�tani
    jnz Vege1
    cmp ax,bx
    jnz Vege1
    mov al,1
    mov a,al
  }
Vege1:
  asm {
    pop es
    pop dx
    pop bx
    pop cx
    pop ax
  }
  return a;
}

/*########################################################################*/

void IntrInit(char vonal, char irq, char uzem)	//IT �zemm�d be�ll�t�s
					//vonal: 1-4 [COM x]
					//irq: 0-7   [IRQ x]
					//uzem: 1 -- v�tel IT
					//      2 -- ad�s IT
					//      4 -- v�teli st�tusz IT
					//      8 -- modem IT enged�lyez�s
//*** Mivel jelen file-ban az ad�s nem IT-vel megoldott, nem c�lszer� ennek a bitnek a be�ll�t�sa
{
  char kontrolszo;

  csat=vonal;
  level=irq;
  asm {
    push ax
    push bx
    push es
    xor ax,ax
    mov es,ax
    mov bx,0x03fe			//a BIOS t�bl�zatb�l kiolvassuk a port c�m�t
    mov al,csat
    xor ah,ah
    shl ax,1
    add bx,ax
    mov ax,es:[bx]
    mov rs_bas,ax			//el is t�roljuk egy v�ltoz�ba
    pop es
    pop bx
    pop ax
  }
  if (!rs_bas) {			//ha nincs ilyen port
    hiba=invalidport;
    return;
  }
  megszak=level+8;
  it_vekt=megszak*4;
  if (IT_Test()) return;		//m�r �t van �ll�tva?
  kontrolszo=lastit=inportb((int_bas+1));     //az el�z� IT maszk elment�se
  kontrolszo&=(0xff-(1<<level));	//IRQ x enged�lyez�se
  outportb((int_bas+1),kontrolszo);
  oldhandler=getvect(megszak);
  asm {					//megszak�t�s �t�r�sa
    push ax
    push bx
    push dx
    push es
    mov dx,rs_bas			//az IT-k ideiglenes lekapcsol�sa
    push dx
    add dx,rs_ier
    xor al,al
    out dx,al
    pop dx				//a modemvez. OUT2 bitj�nek bekapcs.
    add dx,rs_mcr
    out dx,al
    mov al,8
    out dx,al
    cli					//az �t�ll�t�s idej�re lekapcsoljuk az IT-ket
    mov ax,test_seg
    mov it_seg,ax
    mov ax,test_ofs
    mov it_ofs,ax
    xor ax,ax
    mov es,ax
    mov bx,it_vekt
    mov dx,rs_ofs
    mov es:[bx],dx
    mov ax,cs
    mov es:[bx+2],ax
    sti					//IT-k �jraenged�lyez�se
    pop es
    pop dx
    pop bx
    pop ax
  }
  outportb((rs_bas+rs_lcr),(inportb(rs_bas+rs_lcr) & 0x7f));   //IER el�rhet�
  outportb((rs_bas+rs_ier),uzem);	//megszak�t�s maszkol�sa
  inportb(rs_bas);
}

/*########################################################################*/

void ClearIntr()			//IT kikapcsol�s
{
  char a;				//seg�dv�ltoz�

  if (!IT_Test()) return;	        //�t van �ll�tva egy�ltal�n?
  a=inportb(int_bas+1);
  a=lastit;				//az el�z�l IT maszk visszament�se
  outportb(int_bas+1,a);
  asm {					//megszak�t�s vissza�ll�t�sa
    push ax
    push bx
    push dx
    push es
    cli
    xor ax,ax
    mov es,ax
    mov bx,it_vekt
    mov dx,it_ofs
    mov es:[bx],dx
    mov dx,it_seg
    mov es:[bx+2],dx
    sti
    pop es
    pop dx
    pop bx
    pop ax
  }
}

/*########################################################################*/

void SaveLineDatas()		        //az aktu�lis port be�ll�t�sainak ment�se
{
  unsigned division;

  outportb((rs_bas+rs_lcr),0x80);	//a division regiszterek el�rhet�k
  division=inportw(rs_bas);         //az oszt�s (BaudRate) elment�se
  savedbits=inportb(rs_bas+rs_lcr);	//az adatbitek, a stopbitek �s a parit�s elment�se
  if (division) savedrate=115200/division;
  else savedrate=1200;
}

/*########################################################################*/

void RestoreLineDatas()		         //az aktu�lis port be�ll�t�sainak vissza�ll�t�sa
{
  unsigned division;

  division=115200/savedrate;
  outportb((rs_bas+rs_lcr),0x80);	//a division regiszterek el�rhet�k
  outportw(rs_bas,division);	      //BaudRate
  outportb((rs_bas+rs_lcr),savedbits);	//protokolm�d
  outportb((int_bas+1),lastit);		//megszak�t�s enged�lyez�se
}

/*########################################################################*/

void InitLine(unsigned baud, char bit, char stopbit, Partip paritas)
						//COMx felprogramoz�s
				//baud:	1..115200
				//bit: 5..8
				//stopbit: 1,2
				//paritas: none,odd,even,stickodd,stickeven
{
  char kontrolszo;
  unsigned division;

  if (baud) division=115200/baud;
  else division=96;			//a BaudRate-nek megfelel� oszt�sar�ny kisz�m�t�sa
  switch (paritas)
  {
    case none: kontrolszo=0; break;				//nincs
    case odd: kontrolszo=paren; break;				//p�ratlan
    case even: kontrolszo=(paren|evpar); break;			//p�ros
    case stickodd: kontrolszo=(paren|stpar); break;		//fix 0
    case stickeven: kontrolszo=(paren|stpar|evpar); break;	//fix 1
  }
  kontrolszo+=bit;			//a bitsz�m be�ll�t�sa
  kontrolszo-=5;
  if (stopbit==2) kontrolszo|=stops;	//a stopbitek sz�m�nak be�ll�t�sa
  outportb((rs_bas+rs_lcr),0x80);	//a division regiszterek el�rhet�k
  outportw(rs_bas,division);
  outportb((rs_bas+rs_lcr),kontrolszo);	//protokolm�d
  kontrolszo=inportb((int_bas+1));	//megszak�t�s enged�lyez�se
  lastit=kontrolszo;			//az el�z� IT maszk elment�se
  if (csat&1) kontrolszo&=0xef;		//IRQ 4 enged�lyez�se
  else kontrolszo&=0xf7;		//IRQ 3 enged�lyez�se
  outportb((int_bas+1),kontrolszo);
  inportb(rs_bas);
  inportb(rs_bas+rs_lsr);		//status registerek t�rl�se
  inportb(rs_bas+rs_msr);
  inportb(rs_bas+rs_iir);
  inpuf[inrdpoi]=inportb(rs_bas);
  oldtimer=getvect(0x1c);		//a timer IT �t�ll�t�sa
  setvect(0x1c,handler);
  count=0;

// while () {
//  ...  (Id�z�tett perif�ria-ellen�rz�s)
// }

  setvect(0x1c,oldtimer);		//vissza�ll�tjuk a timer IT-t
  if (count>=porttimeout) hiba=notablet;	//ha nem j�tt id�ben v�lasz
}

/*#################### Modul v�ge ########################################*/