/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   2000-2002 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // File Name:        HAL4ISA.c
   // Author:           ZhenYu Zhang
   // Created:			Jun. 8, 2000
   // Modified:			May 28, 2002 by wang.zhong.wei@philips.com
   // Revision:         1.0
   //
   //*************************************************************************
   //
   //*************************************************************************
*/

#include <stdio.h>
#include <dos.h>

#include "BasicTyp.h"
#include "common.h"
#include "SysCnfg.h"

#include "hal4sys.h"

#include "hal4ISA.h"
/*
//*************************************************************************
//  Public static data
//*************************************************************************
*/
extern void interrupt ISR_4Timer();
extern void interrupt ISR_4HC();
extern void interrupt ISR_4D13();

/*
//*************************************************************************
//  Private static data
//*************************************************************************
*/
void interrupt (*Hal4ISA_OldIsr4Timer)();
void interrupt (*Hal4ISA_OldIsr4HC)();
void interrupt (*Hal4ISA_OldIsr4D13)();

extern ULONG IRQ4D13_CHNNL;
extern ULONG IRQ4HC_CHNNL;
extern ULONG HC_COM;
extern ULONG HC_DATA;
extern ULONG DC_COM;
extern ULONG DC_DATA;

/*
//*************************************************************************
//  Subroutines
//*************************************************************************
*/

void Hal4ISA_CommandOutW4HC(USHORT wData)
{
	Hal4Sys_OutportW(HC_COM,wData);
}

void Hal4ISA_DataOutW4HC(USHORT wData)
{
	Hal4Sys_OutportW(HC_DATA,wData);
}

USHORT Hal4ISA_DataInW4HC(void)
{
	return Hal4Sys_InportW(HC_DATA);
}


void Hal4ISA_CommandOutB4D13(UCHAR byData)
{
	Hal4Sys_OutportW(DC_COM,(USHORT)byData);
}

void Hal4ISA_DataOutDW4D13(ULONG dwData)
{
	Hal4Sys_OutportW(DC_DATA,(USHORT)dwData);
	Hal4Sys_OutportW(DC_DATA,(USHORT)(dwData>>16));
}

ULONG Hal4ISA_DataInDW4D13(void)
{
	ULONG	dwData;
	dwData =Hal4Sys_InportW(DC_DATA);
	dwData += (Hal4Sys_InportW(DC_DATA)<<16);

	return dwData;
}

void Hal4ISA_DataOutW4D13(USHORT wData)
{
	Hal4Sys_OutportW(DC_DATA,wData);
}

USHORT Hal4ISA_DataInW4D13(void)
{
	USHORT	wData;
	wData =Hal4Sys_InportW(DC_DATA);
//	wData <<= 8;
//	wData += Hal4Sys_InportB(DC_DATA);
	return wData;
}

void Hal4ISA_AcquireIRQ4Timer(void)
{
	RaiseIRQL();
	Hal4ISA_OldIsr4Timer = getvect(0x8);	//keep the DOS default vector
	setvect(0x8, ISR_4Timer);      //reroute IRQ0(Timer) to ISR_4Timer

	//Get 1ms based Ticks
	// 1.193 MHz /1193 = 1000 Hz
	// 1193 = 0x4A9 : 1ms;  0x174D : 5ms;
	Hal4Sys_OutportB(0x43,0x34); //Choose Counter 0, mode 2
	Hal4Sys_OutportB(0x40,0xA9);
	Hal4Sys_OutportB(0x40,0x04);

	LowerIRQL();
}

void Hal4ISA_ReleaseIRQ4Timer(void)
{
	RaiseIRQL();

	Hal4Sys_OutportB(0x43,0x34);	//Choose 8253 Counter 0
	Hal4Sys_OutportB(0x40,0x00);
	Hal4Sys_OutportB(0x40,0x00);	//recover system clock

	setvect(0x8, Hal4ISA_OldIsr4Timer);	//return to DOS timer
	LowerIRQL();
}




void Hal4ISA_AcquireIRQ4HC(void)
{
	UCHAR byIMR;

	RaiseIRQL();

	if (IRQ4HC_CHNNL < 8)
	{
		Hal4ISA_OldIsr4HC = getvect(0x08+IRQ4HC_CHNNL);
		setvect(0x08+IRQ4HC_CHNNL, ISR_4HC);

		byIMR = Hal4Sys_InportB(0x21); //PIC-0 IMR
		byIMR &= !(0x01<<IRQ4HC_CHNNL);
		Hal4Sys_OutportB(0x21,byIMR);
	}
	else
	{
		Hal4ISA_OldIsr4HC = getvect(0x70+IRQ4HC_CHNNL-8);
		setvect(0x70+IRQ4HC_CHNNL-8, ISR_4HC);

		byIMR = Hal4Sys_InportB(0xA1); //PIC-1 IMR
		byIMR &= !(0x01<<(IRQ4HC_CHNNL-8));
		Hal4Sys_OutportB(0xA1,byIMR);
	}

	LowerIRQL();
}

void Hal4ISA_ReleaseIRQ4HC(void)
{
	UCHAR	byIMR;

	RaiseIRQL();

	if (IRQ4HC_CHNNL < 8)
	{
		setvect(0x08+IRQ4HC_CHNNL, Hal4ISA_OldIsr4HC);

		byIMR = Hal4Sys_InportB(0x21); //PIC-0 IMR
		byIMR |= (0x01 << IRQ4HC_CHNNL);
		Hal4Sys_OutportB(0x21,byIMR);
	}
	else
	{
		setvect(0x70+IRQ4HC_CHNNL-8, Hal4ISA_OldIsr4HC);

		byIMR = Hal4Sys_InportB(0xA1); //PIC-1 IMR
		byIMR |= (0x01 << (IRQ4HC_CHNNL-8));
		Hal4Sys_OutportB(0xA1,byIMR);
	}

	LowerIRQL();
}

void Hal4ISA_AcquireIRQ4D13(void)
{
	UCHAR byIMR;
	RaiseIRQL();

//	Hal4Sys_OutportB(0xA0,0x18);
	if (IRQ4D13_CHNNL < 8)
	{
		Hal4ISA_OldIsr4D13 = getvect(0x8+IRQ4D13_CHNNL);
		setvect(0x8+IRQ4D13_CHNNL, ISR_4D13);

		byIMR = Hal4Sys_InportB(0x21); //PIC-0 IMR
		byIMR &= !(0x01<<IRQ4D13_CHNNL);
		Hal4Sys_OutportB(0x21,byIMR);
	}
	else
	{
		Hal4ISA_OldIsr4D13 = getvect(0x70+IRQ4D13_CHNNL-8);
		setvect(0x70+IRQ4D13_CHNNL-8, ISR_4D13);

		byIMR = Hal4Sys_InportB(0xA1); //PIC-1 IMR
		byIMR &= !(0x01<<(IRQ4D13_CHNNL-8));
		Hal4Sys_OutportB(0xA1,byIMR);
	}

	LowerIRQL();
}

void Hal4ISA_ReleaseIRQ4D13(void)
{
	UCHAR	byIMR;
	RaiseIRQL();
	if (IRQ4D13_CHNNL < 8)
	{
		setvect(0x8+IRQ4D13_CHNNL, Hal4ISA_OldIsr4D13);

		byIMR = Hal4Sys_InportB(0x21); //PIC-0 IMR
		byIMR |= (0x01 << IRQ4D13_CHNNL);
		Hal4Sys_OutportB(0x21,byIMR);
	}
	else
	{
		setvect(0x70+IRQ4D13_CHNNL-8, Hal4ISA_OldIsr4D13);

		byIMR = Hal4Sys_InportB(0xA1); //PIC-0 IMR
		byIMR |= (0x01 << (IRQ4D13_CHNNL-8));
		Hal4Sys_OutportB(0xA1,byIMR);
	}

	LowerIRQL();
}

void Hal4ISA_AcquireDMA4HC(void)
{
}

void Hal4ISA_ReleaseDMA4HC(void)
{
}
void Hal4ISA_AcquireDMA4D13(void)
{
}
void Hal4ISA_ReleaseDMA4D13(void)
{
}

void Hal4ISA_AcquirePIO4HC(void)
{
}

void Hal4ISA_AcquirePIO4D13(void)
{
}

void Hal4ISA_ReleasePIO4HC(void)
{
}

void Hal4ISA_ReleasePIO4D13(void)
{
}