/*
 * rs.c -- rs232.c serial communicate routine
 *
 *	Copyright (C) 1997 by Sony Computer Entertainment
 *			All rights Reserved
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dos.h>
#include <time.h>
#include <conio.h>
#include <windows.h>
#include "rs.h"

extern void check_exit();

typedef enum {
	OFF,
	ON
} onoff_t;
// ---------------------------------------------------------------------
//	data defines
// ---------------------------------------------------------------------
#define BUF_MAX		0x2000u		// Receive buffer/size
#define FLOW_ON		0x1800u		// Flow control on
#define FLOW_OFF	0x0800u		// Flow control off

#define	N81MODE		0x03		// N81, 1/16 mode data
#define ERRS_ON		0x0B		// ER, RTS ON data
#define ERRS_OFF	0x08		// ER, RTS OFF data

#define MHI		0x0021		// 8259 master hardware interrupt control
#define RDB		(RSport+0)	// Read resister
#define TDB		(RSport+0)	// Write resister
#define IER		(RSport+1)	// Interrupt permitted resister
#define LCR		(RSport+3)	// Line control resister
#define MCR		(RSport+4)	// Modem control resister
#define LSR		(RSport+5)	// Line status resister
#define MSR		(RSport+6)	// Modem status resister
#define DLL		(RSport+0)	// divider factor latch (lower rank)
#define DLM		(RSport+1)	// divider factor latch (upper rank)

static	char buf[BUF_MAX + 1];	//  Receive buffer
static	int  buf_h;		//  Buffer head
static	int  buf_t;		//  Buffer tail
static	int RSvec;		/* rs vector */
static	int RSport;		/* rs port */
static	int msd_save;		/*  8259 mask save */
static	onoff_t rts_flg;	/*  RTS state */


// ---------------------------------------------------------------------
//	operations
// ---------------------------------------------------------------------
static void rs_seter(onoff_t onoff)
{
/*	outp(MCR, (onoff ? ERRS_ON : ERRS_OFF));	//  ER, RTS control
	rts_flg = onoff;*/
}

void rs_intr(void)		//  Receive interrput handler
{
/*	static int size;

	outp(MCR, 0x09);			//  Hardware flow
	disable();				//  Interrupt prohibited
	buf[buf_t++] = inp(RDB);		//  Sets characters to buffer
	if (BUF_MAX <= buf_t) buf_t = 0;	//  End of ring buffer?
	size = buf_t - buf_h;			//  Buffer check
	if (size < 0) size += BUF_MAX;
	if (FLOW_ON <= size && rts_flg) {	//  Flow control check
		outp(MCR, 0x09);		//  Hardware flow
		rts_flg = OFF;			//  RTS OFF
	}
	if( rts_flg == ON)
		outp(MCR, 0x0B);		//  Hardware flow
	enable();				//  Interrupt permitted
	outp(0x20, 0x20);			//  Interrupt end notification
*/
}


void rs_flush(void)
{
/*	disable();				//  Interrupt prohibited
	buf_h = 0;				//  Buffer pointer clear
	buf_t = 0;
	enable();				//  Interrupt permitted
	*/
}


int rs_putstat()
{
/*	if((inp(LSR) & 0x20) != 0x20) return -1;
	if((inp(MSR) & 0x10) != 0x10) return -1;*/
	return 0;
}


int rs_putch(int c)
{
/*	while ( (inp(LSR) & 0x20) != 0x20) {
		check_exit(1) ;
	}
	while ( (inp(MSR) & 0x10) != 0x10) {
		check_exit(1) ;
	}
	outp(TDB, c);*/				//	Character output
	DWORD byteswritten;
	unsigned char towrite=(unsigned char)c;
	WriteFile(hFile, (LPCVOID)&towrite, 1, &byteswritten, NULL);

	return 0 ;
}

void rs_puts( char *str)
{
/*
	for( i = 0; (i < 1024) && (str[i] != 0); i++) {
		rs_putch( str[i]) ;
	}*/
	DWORD byteswritten;
	WriteFile(hFile, (LPCVOID)str, strlen(str), &byteswritten, NULL);
}


int rs_getch(void)
{
/*	int c;
	c = 0;					//  Character clear
	if (buf_h != buf_t) {			//  Any character in buffer?
		disable();			//  Interrupt prohibited
		c = buf[buf_h];			//  Gets characters from buffer
		buf_h = (buf_h + 1) % BUF_MAX;
		if (! rts_flg && (rs_size() < FLOW_OFF)) {
			outp(MCR, 0x0B);	//  Hardware flow
			rts_flg = ON;		//  RTS ON
		}
		enable();			//  Interrupt permitted
	}*/
	if (buf_h==buf_t)
	{
		return 0;
	}
	else
	{	
		return (int)buf[buf_h++];
	}
}

void rs_open(long *bps, int port, int vec, int irqmask)
{
/*	int r;

	irqmask = ~irqmask;
	RSport = port;
	RSvec = vec;
						//  RS232C baud rate setting
	r = (int)(384/(*bps/300));		//  divider factor culculation
*/
	char* portname;
	COMMTIMEOUTS cto;
	DCB dcb;
	portname="Com2";
	if (port==0x03f8)
	{	
		portname="Com1";
	}
	if (port==0x02f8)
	{
		portname="Com2";
	}
	hFile=CreateFile(portname, 
		GENERIC_READ | GENERIC_WRITE,
		0,
		(LPSECURITY_ATTRIBUTES)NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL);
	if (hFile==INVALID_HANDLE_VALUE)
	{
		printf("cannot open coM2");
	}
	GetCommState(hFile, &dcb);
	dcb.BaudRate=*bps;
	dcb.ByteSize=8;
	dcb.Parity=0;
	dcb.StopBits=1;
	SetCommState(hFile, &dcb);

	cto.ReadIntervalTimeout = MAXDWORD;
	cto.ReadTotalTimeoutMultiplier = 0;
	cto.ReadTotalTimeoutConstant =0;
	cto.WriteTotalTimeoutMultiplier = 0;
	cto.WriteTotalTimeoutConstant = 0;
	SetCommTimeouts(hFile, &cto);

}

void rs_close(void)
{
/*	outp(IER, 0x00);			//  8251 mask
	outp(MHI, msd_save);			//  8259 mask
//	setvect(RSvec, RS_Intr_Save);		//  Returns vector
	rs_seter(OFF);				//  ER signal off
	*/
	CloseHandle(hFile);
}

int rs_size(void)
{
	int bytesRead;

	ReadFile(hFile, (LPVOID)buf, BUF_MAX, &bytesRead, NULL);
	buf_t=bytesRead;
	buf_h=0;
	return bytesRead;
}