/*******************************************************************/
/* SEALEVEL SYSTEMS INC.                                 			*/
/*  P.O. Box 830 155 Technology Place                    			*/
/*  Liberty SC 29657   USA                               			*/
/*  (864) 843-4343  PHONE                                			*/
/*  (864) 843-3067  FAX												*/
/*******************************************************************/
/*  SSDR56.C =>=> PROGRAM FOR 5010 Z16C32 BASED CARD	 			*/
/*	History: Start 06-12-94								 			*/
/*	Build with int.asm and R56_IO.asm					 			*/
/*******************************************************************/
#include <dos.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <bios.h>
#include "sstypes.h"
#include "Z16C32.h"
#include "int.h"
#include "r56_io.h"
#include "ssdr56.h"
/*******************************************************************/
#define SELECT_V35     Port3_PinCtrl_Input | Port2_PinCtrl_Output0
#define SELECT_EIA530  Port3_PinCtrl_Input | Port2_PinCtrl_Input
#define SELECT_RS232   Port3_PinCtrl_Output0 | Port2_PinCtrl_Output0
#define RTS_ON	       Port7_PinCtrl_Output1
#define RTS_OFF        Port7_PinCtrl_Output0
#define DTR_ON	       Port6_PinCtrl_Output1
#define DTR_OFF        Port6_PinCtrl_Output0
#define CTS_OFF        CTS_PinStatus_Zero
#define CTS_ON	       CTS_PinStatus_One
#define DCD_OFF        DCD_PinStatus_Zero
#define DCD_ON	       DCD_PinStatus_One
#define RI_ON	       TxREQ_PinStatus_One
#define RI_ZERO	       TxREQ_PinStatus_Zero
#define DSR_ON	       RxREQ_PinStatus_One
#define DSR_ZERO       RxREQ_PinStatus_Zero

#define TXC_OUTPUT     Port5_PinCtrl_Output0
#define TXC_INPUT      Port5_PinCtrl_Output1
#define P0_IS_CLOCK    Port0_PinCtrl_CTR0_Clock

/*******************************************************************/
/*               MACROS                                  			*/
/*******************************************************************/
#define NUM_REG 49
char sRegList[NUM_REG][10]={
	    "CCAR\0" ,
	    "CMCR\0" ,
	    "HCR\0" ,
	    "CCSR\0" ,
	    "IOCR\0" ,
	    "SICR\0" ,
	    "MISR\0" ,
	    "PCR\0" ,
	    "PSR\0" ,
	    "CCR\0" ,	    //10
	    "CMR\0" ,
	    "DCCR\0" ,
	    "TMR\0" ,
	    "TCSR\0" ,
	    "TICR\0" ,
	    "TSR\0" ,
	    "TCLR\0" ,
	    "TCCR\0" ,
	    "RMR\0" ,
	    "RCSR\0" ,	    //20
	    "RICR\0" ,
	    "RSR\0" ,
	    "RCLR\0" ,
	    "RCCR\0" ,
	    "ICR\0" ,
	    "IVR\0" ,
	    "TC0R\0" ,
	    "TC1R\0" ,
	    "DCAR\0" ,
	    "DCR\0" ,	    //30
	    "BDCR\0" ,
	    "SDIR\0" ,
	    "DICR\0" ,
	    "DIVR\0" ,
	    "TDIAR\0" ,
	    "RDIAR\0" ,
	    "TDMR\0" ,
	    "NTARU\0" ,
	    "NTARL\0" ,
	    "TARU\0" ,	    //40
	    "TARL\0" ,
	    "TBCR\0" ,
	    "RDMR\0" ,
	    "NRARU\0" ,
	    "NRARL\0" ,
	    "RARU\0" ,
	    "RARL\0" ,
	    "RBCR\0" ,
	    "RBCR\0" };     //Intentional duplicate entry   //49
unsigned char bRegList[NUM_REG]={
	    CCAR ,
	    CMCR ,
	    HCR  ,
	    CCSR ,
	    IOCR ,
	    SICR ,
	    MISR ,
	    PCR  ,
	    PSR  ,
	    CCR  ,
	    CMR  ,
	    DCCR ,
	    TMR  ,
	    TCSR ,
	    TICR ,
	    TSR  ,
	    TCLR ,
	    TCCR ,
	    RMR  ,
	    RCSR ,
	    RICR ,
	    RSR  ,
	    RCLR ,
	    RCCR ,
	    ICR  ,
	    IVR  ,
	    TC0R ,
	    TC1R ,
	    DCAR ,
	    DCR  ,
	    BDCR ,
	    SDIR ,
	    DICR ,
	    DIVR ,
	    TDIAR ,
	    RDIAR ,
	    TDMR  ,
	    NTARU ,
	    NTARL ,
	    TARU  ,
	    TARL  ,
	    TBCR  ,
	    RDMR  ,
	    NRARU ,
	    NRARL ,
	    RARU  ,
	    RARL  ,
	    RBCR  ,
	    RBCR  };   //Duplicate entry

/*********************************************************/
#define LOOP_COUNT 45
#define TX_COUNT 450  /*loop_COUNT x 10*/
#define ESC 27
#define MIN_COMMAND 3       //Minimum Command Line Arguments
#define T_OUT 0x1000
#define TITLE_MESS cls();cursor(0x0200); \
  printf("\n\n\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n" \
	     "\tº SEALEVEL SYSTEMS DIAGNOSTICS for R56 adapter, 1995; Version 1.0     º\n" \
	     "\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n\n\n");
#define MENU printf("\t\t  1) Verify Address and examine R56 I/O registers\n"	\
		    "\t\t  2) Internal IUSC loopback test\n"		     \
		    "\t\t  3) External loopback test (connector required)\n" \
		    "\t\t  4) IRQ test\n"				    \
		    "\t\t  5) Examine modem control signals\n"		    \
		    "\t\t  6) Modify IUSC register contents\n"	\
		    "\t\t  7) Terminal mode\n"				   \
		    "\t\t  8) Memory Test\n"				   \
		    "\t\t  9) DMA Test\n"				   \
		    "\t\tEsc) Exit to DOS\n"				    \
		    "\t\t\t   Selection...>");
#define DIRECTIONS printf("\n"\
		"Usage: SSDR56 /b:base /i:irq /m:memory\n\n"\
		"  /b:[base]   Base Address in HEX (100H-FFFFH)\n"\
		"  /i:[irq]    Interrupt Request Signal (Valid IRQs are 3,4,9,10,11,12,15)\n"\
		"  /m:[memory] Starting Memory Range in HEX\n"\
		"\n\n");
#define SIGN_ON  printf("\nSealevel (R) Route 56 Multi-Protocol WAN Adapter Diagonistic Program\n" \
		 "Version 1.0  Sealevel Systems Inc. (C) 1995. Beta 1\n\n");
char *ResultONOFF[2] ={"On \0","Off\0"};
char *ResultINOUT[2] ={"Out\0","In \0"};
char *ResultYESNO[2] ={"Yes\0","No \0"};
char *ResultINTERFACE[4] ={"EIA-530\0","RS-232  \0","V.35    \0","None    \0"};
/*********************************************************/
/*********************************************************/
unsigned short AValues[]={
	BCR	|	writeW,	BRQ_Signal_TotemPole | BusWidth_16BitBus |      /* 1st write after reset*/
				IRQ_Signal_OpenDrain | ShiftedAddr_ShiftRightMode,  /* bus configuration*/
	/* for testing purposes*/
	//CCSR|	writeW|checkL,	RCC_FIFO_Clear_Reset | PORT0_1BypassCTR_Yes, /* use P0 clock not CTR0 */
	//RICR|	checkH, 	0,					/* Make sure Rx FIFO is empty */
	/* for testing purposes*/
	PCR	|	writeW|checkW,	Port7_PinCtrl_Output1 |	/* RTS off */
				Port6_PinCtrl_Output1 |				/* DTR off */
				Port5_PinCtrl_Output0 |		/* Enable TxC driver to modem */
				Port3_PinCtrl_Output1 |		/* balanced TxD,TxC drive (RS-449, V.35, X.21) */
				Port2_PinCtrl_Output1 |		/* balanced RTS,DTR drive (RS-449, X.21) */
				Port1_PinCtrl_Output0 |		/* Drive P1 low, not used	*/
				Port0_PinCtrl_CTR0_Clock,	/* P0 is on board OSC input	*/
	IOCR|	writeW|checkW,	TxC_PinControl_TxClkOutput | TxD_PinControl_TxDataOutput ,	
	CCSR|	writeW|checkL,	RCC_FIFO_Clear_Reset | PORT0_1BypassCTR_Yes, /* use P0 clock not CTR0 */
	CMCR|	writeW|checkW,	BRG0_ClkSource_CTR0_Output | TxClkSource_BRG0_Output| 
				RxClkSource_BRG0_Output,
	TC0R|	writeW|checkW,	10,				/* 16/(10|1)=1.4545... Mbps */
 	HCR	|	writeW|checkW,	BRG0_Enable_Yes,/* enable BRG0 */
	CCR	|	writeW|checkW,	0, /*TxCtrlBlockXfer_2WordCtrlBlock | RxStatBlockXfer_2WordStatBlock ,*/
	CMR	|	writeW|checkW,	TxMode_Asynchronous | TxStopBitsAsync_One |	
				TxClockRateAsync_DataRate16X | RxClockRateAsync_DataRate16X | 
				RxMode_Asynchronous,
	RICR|	checkH,		0,					/* Make sure Rx FIFO is empty */
	RCSR|	writeW,		RxCommand_SelectIntLevel | 0x1FF ,	/*unlatch all status flags*/
	RICR|	writeW|checkW,	1* 0x100,		/* DIFFERENT: 31*100h*/
	RCSR|	writeH,		RxCommand_SelectReqLevel,
	RICR|	writeH|checkH,	1* 0x100,		/* RxDMA 12 bytes in FIFO DIFFERENT:1 * 0x100*/
	RCSR|	writeH,		RxCommand_SelectFilLevel,
	RICR|	checkH,		0,					/* check fill level 0 */
	RCLR|	writeW|checkW,	-1,
	TICR|	checkH,		32 * 0x100 ,		/* check Tx FIFO empty DIFFERENT: 31 * 0x100*/
	TCSR|	writeW,		TxCommand_SelectIntLevel | 0x0FF,
	TICR|	writeW|checkW,	31* 0x100,
	TCSR|	writeH,		TxCommand_SelectReqLevel,
	TICR|	writeH|checkH,	11 * 0x100 ,	/* TxDMA 12 bytes in FIFO DIFFERENT: 31*100h*/
	TCSR|	writeH,		TxCommand_SelectFilLevel,
	TICR|	checkH,		32 * 0x100 ,		/* check TX emptiness level*/
	DCCR|	writeW,		IP_Command_ResetIP_IUS | 0x3F,	/* clear all serial IP & IUS*/
	DCR	|	writeW|checkW,	BinaryValueOrder_Z80_Intel | ChannelPriority_Rx,
//; IF LList
	RDMR | writeW|checkW,	RxChannelMode_LinkedList | RxDMAAdvStatHdl_Yes | RxTermEnable_Yes,
	TDMR | writeW|checkW,	TxChannelMode_LinkedList | TxDMAAdvStatHdl_Yes,
// ELSEIF
//RDMR|writeW|checkW,	RxChannelMode_Array | RxDMAAdvStatHdl_Yes | RxTermEnable_Yes,
//TDMR|writeW|checkW,	TxChannelMode_Array | TxDMAAdvStatHdl_Yes,
// ENDIF
	CCAR | writeW,		ChannelCommand_SelctD7_0_1st|	ModeControl_NormalOp,
	CCAR | checkH,		ModeControl_NormalOp,	/*ModeControl_IntLocalLpback	; check CCAR readback */
	TMR  | writeW|checkW,	TxEnable_Enable,
	RMR  | writeW|checkW,	RxEnable_Enable,
 -1};				    /* end of table*/
/*********************************************************/
/*********************************************************/
/*              GLOBAL VARIABLES                         */
/*********************************************************/
/*********************************************************/
unsigned int rx_ptr,tx_ptr;			 /*rx ptr*/
char rxbuff[TX_COUNT+LOOP_COUNT];	 /*RX_BUFFER*/
unsigned char loop_data[LOOP_COUNT]="THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG\n";
int x,i;
unsigned char c;
unsigned short wBASE, wMEMORY;
unsigned long dwMEMORY;
unsigned char bIRQ;
union _REGS inregs, outregs;
char TempString[80];
R56_INFO CARD1;
R56_INFO * fpCARD1;
unsigned long dwTemp;
unsigned short wTemp;
unsigned short cur_position;
unsigned short MasterPCR;
/*********************************************************/
/*           START MAIN                                  */
/*********************************************************/
int main (int argc,char *argv[])
{   fpCARD1 = &CARD1;
    SIGN_ON
    if(argc < MIN_COMMAND)
     {DIRECTIONS	  //print command line options
      return(1);   //exit with error level 1
     }  //end if
    for(i = 1; i < argc; i++)	//get command line
     { if (strncmp(argv[i],"/b:",3)==0)
	{strcpy(TempString,argv[i]);
	 sscanf(&TempString[3],"%x",&wBASE);
	}
       if (strncmp(argv[i],"/B:",3)==0)
	{strcpy(TempString,argv[i]);
	 sscanf(&TempString[3],"%x",&wBASE);
	}
       if (strncmp(argv[i],"/i:",3)==0)
       {strcpy(TempString,argv[i]);
	 sscanf(&TempString[3],"%d",&bIRQ);
       }
       if (strncmp(argv[i],"/I:",3)==0)
       {strcpy(TempString,argv[i]);
	 sscanf(&TempString[3],"%d",&bIRQ);
       }
       if (strncmp(argv[i],"/m:",3)==0)
       {strcpy(TempString,argv[i]);
	 sscanf(&TempString[3],"%x",&wMEMORY);
       }
       if (strncmp(argv[i],"/M:",3)==0)
       {strcpy(TempString,argv[i]);
	 sscanf(&TempString[3],"%x",&wMEMORY);
       }
    }   //end for
    switch(wMEMORY)
       {case 0x8000:
	case 0x8400:
	case 0x8800:
	case 0x8c00:
	case 0x9000:
	case 0x9400:
	case 0x9800:
	case 0x9c00:
	case 0xa000:
	case 0xa400:
	case 0xa800:
	case 0xac00:
	case 0xb000:
	case 0xb400:
	case 0xb800:
	case 0xbc00:
	case 0xc000:
	case 0xc400:
	case 0xc800:
	case 0xcc00:
	case 0xd000:
	case 0xd400:
	case 0xd800:
	case 0xdc00:
	case 0xe000:
	case 0xe400:
	case 0xe800:
	case 0xec00:
	case 0xf000:
	case 0xf400:
	case 0xf800:
	case 0xfc00:
	    dwMEMORY = wMEMORY;
	    dwMEMORY =dwMEMORY << 16;
	    CARD1.MemoryBase = (void __far*) dwMEMORY;
	    break;
	default:
	    DIRECTIONS
	    exit(1);
	}   /*end switch-case*/
    if( wBASE < 100)
	{DIRECTIONS
	 exit(1);
	}
	CARD1.wIOAddress = wBASE;
    switch(bIRQ)
       {case 3:
	case 4:
	case 9:
	case 10:
	case 11:
	case 12:
	case 15:
	  CARD1.IUSCIRQ = bIRQ;
	  break;
	default:
	  DIRECTIONS
	  printf("Error: Invalid IRQ selected.\n");
	  exit(1);
	  break;
	}


    if(VerifyR56(&CARD1))
	{printf("Error: Incorrect I/O address or R56 is not responding at %X HEX. \n",wBASE);
	 Continue();
	 }
    /* Reset IUSC here , Possibly Delay also*/

    dwTemp = ResetIUSC(&CARD1);
    if((0 != LOWORD(dwTemp))) /* if reset error*/
	{if((LOWORD(dwTemp)) == ER_BADRESET)
	      {printf("Error: Reset line is stuck on!\n"); Beep();
	       outp(fpCARD1->wIOAddress, 0x00);	 //Turn off memory address
	       return(1);
	       }
	if((LOWORD(dwTemp)) == ER_RESETTO)
	      {printf("Error: Time out wating for IUSC reset.\n");
	       Beep();
	       outp(fpCARD1->wIOAddress, 0x00);	 //Turn off memory address
	       return(1);
	       }
	}

  /*Init IUSC here */
    CARD1.InitArray = (unsigned short *) &AValues;
    if(0 != (wTemp =InitIUSC(&CARD1)))
      {for(i = 0; i < NUM_REG; i++)
	{if(bRegList[i]==LOBYTE(wTemp))
		printf("Failure programming the %s.\n", &sRegList[i][0]);
	}  //End for
       printf("Error: Failure initializing the IUSC.\n");
       Beep();
       Continue();
       }
    MasterPCR = IUSCin(fpCARD1, PCR);
    /*Possibly continue with warning to screen*/
    ok();  /*print menu*/

    while((c=getch())!=ESC)
     {switch(c)
	 {case '1': verify();
	     ok();
	     break;
	  case '2':
	     internal();
	     ok();
	     break;
	  case '3':
	     external();
	     ok();
	     break;
	  case '4':
	     int_test();
	     ok();
	     break;
	  case '5':
	     modem();
	     ok();
	     break;
	  case '6':display_parm();
	     ok();
	     break;
	  case '7':
	     terminal();
	     ok();
	     break;
	  case '8':
	     memory_test();
	     ok();
	     break;
	  case '9':
	     dma_test();
	     ok();
	     break;
  //	  case 'x':
  //	  case 'X':
  //	      cls();
  //	      outp(fpCARD1->wIOAddress, 0x00);	//Turn off memory address
  //	      exit(0);
  //	      break;
	 } /* end switch-case*/
     }	   /* end while*/
  cls();
  outp(fpCARD1->wIOAddress, 0x00);   //Turn off memory address
  return(0);
}
/*********************************************************/
void Continue(void)
{
    while(1)
	{printf("Continue? (y/n)\r");
	 c=getch();
	 if(c=='n' || c=='N')
	  {printf("\n\n");
	   outp(fpCARD1->wIOAddress,0x00);  //Turn off memory windows etc.
	   exit(1);
	  }
	 if(c=='y' || c=='Y')
	  {printf("\n\n");
	   break;
	  }
	 }

}
/*********************************************************/
void Beep(void)
{
    printf("\7\7\7");
}
/*********************************************************/
void ok(void)
{
     TITLE_MESS
     MENU
}
/*********************************************************/
void SaveCursor(void)
{__asm               /*yyxx cursor position passes*/
    {
	mov ah,3
	mov bh,0
	int 10h
	mov cur_position, cx
    }
}

/*********************************************************/
void HideCursor(void)
{__asm               /*yyxx cursor position passes*/
    {
	mov ah,1
	mov bh,0
	mov ch, 20h
	int 10h
    }
}
/*********************************************************/
void RestoreCursor(void)
{__asm               /*yyxx cursor position passes*/
    {
	mov ah,1
	mov bh,0
	mov cx,cur_position
	int 10h
    }
}

/*********************************************************/
void cls(void)
{ inregs.h.ah=0x06;
  inregs.h.al=0x00;
  inregs.h.bh=0x07;
  inregs.h.bl=0x00;
  inregs.h.ch=0x00;
  inregs.h.cl=0x00;
  inregs.h.dh=0x18;
  inregs.h.dl=0x4f;
  _int86(0x10,&inregs,&outregs);    /*bios cls*/
  cursor(0000);
}
/*********************************************************/
void cursor(unsigned short cur_pos)
{__asm               /*yyxx cursor position passes*/
    {
	mov ah,2
	mov bh,0
	mov dx,cur_pos
	int 10h
    }
}
/*********************************************************/
void wait_for_key(void)
{       int j;
	cursor(0x1518);
	SaveCursor();
	HideCursor();
	printf("PRESS ANY KEY TO CONTINUE");
	j=getch();
	RestoreCursor();
	cls();
}
/*********************************************************/
/*********************************************************/
/*********************************************************/

void verify(void)
{	unsigned char IOValue0,IOValue3,x;
	cls();
	TITLE_MESS
    if(0 != VerifyR56(fpCARD1))	/*return value changed*/
       {cursor(0x0900);
	printf("ERROR: I/O address is not responding at %X HEX. ", fpCARD1->wIOAddress);
	Beep();
       }
    cursor(0x0a00);
    IOValue0 = inp(fpCARD1->wIOAddress);
    IOValue3 = inp(fpCARD1->wIOAddress+3);
    printf("Value Read at %X = %X \n", fpCARD1->wIOAddress, IOValue0);
    printf("Value Read at %X = %X \n", fpCARD1->wIOAddress+3, IOValue3);
    printf("Memory Window........%s\t", ResultONOFF[OnOff((unsigned char)(IOValue0 & 0x80))]); //
    //printf("V.35 Jumper..........%s\n", ResultONOFF[OnOff((unsigned char)(IOValue3 & 0x80))]);
    printf("\n");
    printf("Memory Page..........%X   \t", IOValue0 & 0x0f);
    printf("IUSC Disable.........%s\n", ResultONOFF[OnOff((unsigned char)(IOValue0 & 0x40))]);
    printf("Interrupt Pending....%s\t", ResultYESNO[OnOff((unsigned char)(invert(IOValue3,0x20) & 0x20))]);
    printf("Reset Status.........%s\n", ResultONOFF[OnOff((unsigned char)(invert(IOValue3,0x10) & 0x10))]);
    printf("16 Bit Slot..........%s\t", ResultYESNO[OnOff((unsigned char)(IOValue3 & 0x08))]);

    // BugBug: These need to be checked with a scope
    IUSCout(fpCARD1, PSR, 0xaaaa); /*Unlatch all bits of the Port Status Register*/
    printf("RTS..................%s\n", ResultONOFF[wOnOff((IUSCin(fpCARD1,PSR)) & Port7_Pin_Low)]);
    printf("DTR..................%s\t", ResultONOFF[wOnOff((IUSCin(fpCARD1,PSR)) & Port6_Pin_Low)]);
    printf("CTS..................%s\n", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & CTS_ON)]);
    printf("DCD..................%s\t", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & DCD_ON)]);
    printf("DSR..................%s\n", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & DSR_ON)]);
    printf("RI...................%s\t", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & RI_ON)]);
    printf("TM...................%s\n", ResultONOFF[wOnOff((IUSCin(fpCARD1,PSR)) & Port4_Pin_Low)]);
    printf("TxC..................%s\t", ResultINOUT[wOnOff((IUSCin(fpCARD1,PSR)) & Port5_Pin_Low)]);
    printf("Interface selected...%s\n", ResultINTERFACE[GetInterface((IUSCin(fpCARD1,PCR)) & 0x00f0)]);
    wait_for_key();
}
/*********************************************************/
unsigned char GetInterface(unsigned short testvalue)
{
    switch(testvalue)
    {case SELECT_EIA530:
	return(0);
	break;
    case SELECT_RS232:
	return(1);
	break;
    case SELECT_V35:
	return(2);
	break;
    default:
	return(3);
	break;
    }
}
/*********************************************************/
unsigned char OnOff(unsigned char testvalue)
{
    if(testvalue)
	return(0);
    else
	return(1);
}
/*********************************************************/
unsigned char wOnOff(unsigned short testvalue)
{
    if(testvalue)
	return(0);
    else
	return(1);
}

/*********************************************************/
void term(void)
{
   /* Enable Tx and Rx*/
   while(1)
    {if(_bios_keybrd(_KEYBRD_READY))
       {c=(_bios_keybrd(_KEYBRD_READ));
	if (c==ESC)
	    break;
	IUSCoutb(fpCARD1,TDR,c);
	}   //end if Tx
    if((IUSCin(fpCARD1, RCSR) & RxCharAvailable_FIFO_NotEmpty))
	printf("%c",IUSCinb(fpCARD1, RDR));
    }	//end while
}
/*********************************************************/
void loopback(void)
{       unsigned char i,j;
	unsigned short tx_to,rx_to;
	cursor(0x0300);
	/*rts and tx enabled*/
	for(i = 0; i < 10; i++)		 /*loop 10 times*/
	 {for (j = 0; j < LOOP_COUNT; j++)	 /*loop # of char in string*/
	  {tx_to=0;
	   do{
	      if((IUSCin(fpCARD1, TCSR) & TxBuffer_Empty))
		 {IUSCoutb(fpCARD1, TDR, loop_data[j]);
		  tx_to=0;
		 }
	      else
		{tx_to++;
		    if(tx_to==0xffff)
		    {printf("\nError: Tx Time out failure.\n");
		     goto wfk;
		    }
		}
	    }while(tx_to!=0);

	   rx_to=0;
	   do{
	    if((IUSCin(fpCARD1, RCSR) & RxCharAvailable_FIFO_NotEmpty))
	    {printf("%c",IUSCinb(fpCARD1, RDR));
	     rx_to=0;
	    }
	    else
		{rx_to++;
		 if(rx_to== 0xffff)
		    {printf("\nError: Rx Time out failure.\n");
		     goto wfk;
		    }
		}
	    }while(rx_to != 0);
	  } //end for
	 }  //End for
wfk:
    wait_for_key();
    /*rts and tx dis-abled*/
    /*clean fifo*/
}
/*********************************************************/
void internal(void)
{
	cls();
	printf("INTERNAL LOOPBACK\n\n");
	/* set internal loop bit*/
	clean_fifo();
	IUSCout(fpCARD1,IOCR,	TxC_PinControl_TxClkOutput | TxD_PinControl_Output1);
	IUSCout(fpCARD1,CCAR, ModeControl_IntLocalLpback );
	loopback();
	/* reset internal loop bit*/
	IUSCout(fpCARD1,IOCR,	TxC_PinControl_TxClkOutput | TxD_PinControl_TxDataOutput);
	IUSCout(fpCARD1,CCAR, ModeControl_NormalOp  );


}
/*********************************************************/
void external(void)
{
	cls();
	printf("EXTERNAL LOOPBACK\n\n");
	clean_fifo();
	IUSCout(fpCARD1,CCAR, ModeControl_NormalOp );
	loopback();
}
/*********************************************************/
void delay(unsigned int how_long)
{
    _asm
    {push cx
     mov cx,how_long
dl1: jmp short $+2
     loop dl1
     pop cx
    }
}
/*********************************************************/
void memory_test(void)
{   unsigned short __far *fpwTestPtr;
    unsigned char __far *fpbTestPtr;
    unsigned char bPage;
    unsigned short wOffset;
    unsigned char bBase0Value;
    cls();

    bBase0Value = _inp(fpCARD1->wIOAddress); /* Save Base+0 value to restore*/

    _outp(fpCARD1->wIOAddress+2, LOADD | EN_16_BIT | NO_ZERO_WS | ISA_IRQ);
    _outp(fpCARD1->wIOAddress, IUSC_DISABLE | MEM_WIN_ON | MEM_PAGE_FIRST);
    fpwTestPtr = (LPWORD)fpCARD1->MemoryBase;
    fpbTestPtr = fpCARD1->MemoryBase;
    //Need to test all access speeds etc...
    printf("Memory Test: \n\nTesting LOW Address Mode, Word Access, Wait State Enabled....\n");

   for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("Writting pattern to page %d\r",bPage);
     for(wOffset = 0; wOffset <= 0x1fff; wOffset++)
	{*(fpwTestPtr + wOffset) = wOffset | bPage << 8;
	} /* end wOffset for loop*/
    } /* end bPage for loop*/

    printf("\n");
    for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("\rReading pattern from page %d",bPage);
     for(wOffset = 0; wOffset <= 0x1fff; wOffset++)
	{if(*(fpwTestPtr + wOffset)!= (wOffset | bPage << 8))
	  {printf("\n\nError: Memory read error at page %d offset %x\n",bPage,wOffset*2);
	   wait_for_key();
	   _outp(fpCARD1->wIOAddress, bBase0Value);
	   return;
	  }
	} /* end wOffset for loop*/
    } /* end bPage for loop*/
    printf("  PASSED\n");

    printf("\nTesting LOW Address Mode, Byte Access, Wait State Enabled....\n");
    for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("Writting pattern to page %d\r",bPage);
     for(wOffset = 0; wOffset <= 0x3fff; wOffset++)
	{*(fpbTestPtr + wOffset) = wOffset ;
	} /* end wOffset for loop*/
    } /* end bPage for loop*/

    printf("\n");
    for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("\rReading pattern from page %d",bPage);
     for(wOffset = 0; wOffset <= 0x3fff; wOffset++)
	{if(*(fpbTestPtr + wOffset) != LOBYTE(wOffset))
	  {printf("\n\nError: Memory read error at page %d offset %x\n",bPage,wOffset);
	   wait_for_key();
	   _outp(fpCARD1->wIOAddress, bBase0Value);
	   return;
	  }
	} /* end wOffset for loop*/
    } /* end bPage for loop*/
    printf("  PASSED\n");

    _outp(fpCARD1->wIOAddress+2, LOADD | EN_16_BIT | ZERO_WS | ISA_IRQ);
    printf("\nTesting LOW Address Mode, Word Access, Zero Wait State Enabled....\n");

   for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("Writting pattern to page %d\r",bPage);
     for(wOffset = 0; wOffset <= 0x1fff; wOffset++)
	{*(fpwTestPtr + wOffset) = wOffset | bPage << 8;
	} /* end wOffset for loop*/
    } /* end bPage for loop*/

    printf("\n");
    for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("\rReading pattern from page %d",bPage);
     for(wOffset = 0; wOffset <= 0x1fff; wOffset++)
	{if(*(fpwTestPtr + wOffset)!= (wOffset | bPage << 8))
	  {printf("\n\nError: Memory read error at page %d offset %x\n",bPage,wOffset*2);
	   wait_for_key();
	   _outp(fpCARD1->wIOAddress, bBase0Value);
	   return;
	  }
	} /* end wOffset for loop*/
    } /* end bPage for loop*/
    printf("  PASSED\n");

    printf("\nTesting LOW Address Mode, Byte Access, Zero Wait State Enabled....\n");
    for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("Writting pattern to page %d\r",bPage);
     for(wOffset = 0; wOffset <= 0x3fff; wOffset++)
	{*(fpbTestPtr + wOffset) = wOffset ;
	} /* end wOffset for loop*/
    } /* end bPage for loop*/

    printf("\n");
    for(bPage = MEM_PAGE_FIRST; bPage <= MEM_PAGE_LAST; bPage++)
    {
     ChangeR56Page(fpCARD1, bPage);
     printf("\rReading pattern from page %d",bPage);
     for(wOffset = 0; wOffset <= 0x3fff; wOffset++)
	{if(*(fpbTestPtr + wOffset) != LOBYTE(wOffset))
	  {printf("\n\nError: Memory read error at page %d offset %x\n",bPage,wOffset);
	   wait_for_key();
	   _outp(fpCARD1->wIOAddress, bBase0Value);
	   return;
	  }
	} /* end wOffset for loop*/
    } /* end bPage for loop*/
    printf("  PASSED\n");
    _outp(fpCARD1->wIOAddress, bBase0Value);
    wait_for_key();

}

/*******************************************************************/
/*  WriteLink	:													*/
/* This routine will put a link list array of nNumBuffers + 1 on the first */
/* (0) page. Each buffer in the link starts on a new page. The starting    */
/* buffer is specified by bPage.					   */
/*******************************************************************/
void WriteLink(unsigned short wNumBuffers, unsigned short wLinkOffset, unsigned char bPage,  unsigned short wCC)
{
    fpIUSCLINKLISTDMA lMemoryAddress;
    unsigned short i, j;
    unsigned long lTempPage;
    char __far * TempPointer;



    _outp(fpCARD1->wIOAddress+2, LOADD | EN_16_BIT | NO_ZERO_WS | ISA_IRQ);
    _outp(fpCARD1->wIOAddress, IUSC_DISABLE | MEM_WIN_ON | MEM_PAGE_FIRST);

    
	ChangeR56Page(fpCARD1, MEM_PAGE_0);	/* point to page zero*/
    // Address = (Page*4) << 0x10;              
    // first do the Tx Link List
    TempPointer = (char __far *)fpCARD1->MemoryBase + wLinkOffset;
    lMemoryAddress = (fpIUSCLINKLISTDMA)(TempPointer);
    lTempPage = bPage;
    for( i = 1; i <= wNumBuffers; i++)
	{	lMemoryAddress->lBufferAddress = ((lTempPage * 4) << 0x0c);
		lTempPage++;
		lMemoryAddress->wByteCount = wCC;     /* word Char Count*/
		lMemoryAddress->wCSB = 0;
		lMemoryAddress->wCCLength = wCC;
		lMemoryAddress->wNotUsed = 0xffff;
		lMemoryAddress->lNextAddress = wLinkOffset + (i * sizeof(IUSCLINKLISTDMA));
		(char __far *)lMemoryAddress = (char __far *)(lMemoryAddress) + sizeof(IUSCLINKLISTDMA);
	}
	// Last link is nulled
    lMemoryAddress->lBufferAddress = 0;
    lMemoryAddress->wByteCount = 0;			/* word Char Count*/
    lMemoryAddress->wCSB = 0;
    lMemoryAddress->wCCLength = 0;
    lMemoryAddress->wNotUsed = 0;
    lMemoryAddress->lNextAddress =	0;
	
    // Now do the Rx Link List
    TempPointer = (char __far *)fpCARD1->MemoryBase + wLinkOffset + wLinkOffset;
    lMemoryAddress = (fpIUSCLINKLISTDMA)(TempPointer);
    lTempPage = bPage;
    for( i = 1; i <= wNumBuffers; i++)
	{	lMemoryAddress->lBufferAddress = ((lTempPage * 4) << 0x0c) + 0x100;
		lTempPage++;
		lMemoryAddress->wByteCount = wCC;     /* word Char Count*/
		lMemoryAddress->wCSB = 0;
		lMemoryAddress->wCCLength = wCC;
		lMemoryAddress->wNotUsed = 0xffff;
		lMemoryAddress->lNextAddress = (2 * wLinkOffset) + (i * sizeof(IUSCLINKLISTDMA));
		(char __far *)lMemoryAddress = (char __far *)(lMemoryAddress) + sizeof(IUSCLINKLISTDMA);
	}                                   
	// Last link is nulled
    lMemoryAddress->lBufferAddress = 0;
    lMemoryAddress->wByteCount = 0;			/* word Char Count*/
    lMemoryAddress->wCSB = 0;
    lMemoryAddress->wCCLength = 0;
    lMemoryAddress->wNotUsed = 0;
    lMemoryAddress->lNextAddress =	0;

}
/*********************************************************/
void dma_test(void)
{   unsigned char __far *fpbTestPtr;
    unsigned char bPage;
    unsigned short wOffset;
    unsigned char bBase0Value;
    unsigned short i;
    unsigned short wTemp;
    fpIUSCLINKLISTDMA lMemoryAddress;
    char __far * TempPointer;

    cls();
    printf("DMA DRIVEN INTERNAL LOOPBACK TEST:\n\n");
    /* Set internal loop bit*/
    IUSCout(fpCARD1,IOCR,TxC_PinControl_TxClkOutput | TxD_PinControl_Output1);
    IUSCout(fpCARD1,CCAR, ModeControl_IntLocalLpback );
    IUSCout(fpCARD1,CCR, TxCtrlBlockXfer_2WordCtrlBlock | RxStatBlockXfer_2WordStatBlock);
    IUSCout(fpCARD1,DCAR, DMA_ChannelCmd_PauseBoth);

    bBase0Value = _inp(fpCARD1->wIOAddress); /* Save Base+0 value to restore*/

    _outp(fpCARD1->wIOAddress+2, LOADD | EN_16_BIT | NO_ZERO_WS | ISA_IRQ);
    _outp(fpCARD1->wIOAddress, IUSC_DISABLE | MEM_WIN_ON | MEM_PAGE_FIRST);
    fpbTestPtr = fpCARD1->MemoryBase;

   /*skip page zero, pages 1 to 10 offset 0 is Tx buffer*/
   for(bPage = MEM_PAGE_1; bPage <= MEM_PAGE_A; bPage++)
    {ChangeR56Page(fpCARD1, bPage);
     for(wOffset = 0; wOffset <= LOOP_COUNT; wOffset++)
	{*(fpbTestPtr + wOffset) = loop_data[wOffset];
	} /* end wOffset for loop*/
    } /* end bPage for loop*/

    /*skip page zero, pages 1 to 10 offset 100h is Rx buffer*/
    fpbTestPtr = fpbTestPtr + 0x100;
    for(bPage = MEM_PAGE_1; bPage <= MEM_PAGE_A; bPage++)
    {ChangeR56Page(fpCARD1, bPage);
     for(wOffset = 0; wOffset <= LOOP_COUNT; wOffset++)
	{*(fpbTestPtr + wOffset) = 0;
	} /* end wOffset for loop*/
    } /* end bPage for loop*/


    WriteLink(10, 0x200, 1, LOOP_COUNT);

    _outp(fpCARD1->wIOAddress, IUSC_ENABLE | MEM_WIN_ON | MEM_PAGE_FIRST);

    IUSCout(fpCARD1,NTARU, 0x000);   /* Next Tx Address*/
    IUSCout(fpCARD1,NTARL, 0x200);
    IUSCout(fpCARD1,NRARU, 0x000);   /* Next Rx Address*/
    IUSCout(fpCARD1,NRARL, 0x400);
    IUSCout(fpCARD1,CCAR, ChannelCommand_LoadTxCharCt | ModeControl_IntLocalLpback);
    IUSCout(fpCARD1,DCAR, DMA_ChannelCmd_StartInitBoth | MasterBusReqEn_Yes);
    /*Delay*/

   // wait_for_key();
    cursor(0x0300);
    i = 0;
    do{
	i++;
	if(i == 0xfffe)
	    printf("\nError: DMA time out failure.\n");
	wTemp = IUSCin(fpCARD1, TDMR); /* BUGBUG: for some reason RDMR Busy does not work*/
	wTemp = RxBusy_Yes & wTemp;
	if(wTemp==0)
	    break;
    }while(i <0xffff);
    //cursor(0x0300);
    /*skip page zero, Print pages 1 to 10 offset 100h is Rx buffer*/
    _outp(fpCARD1->wIOAddress, IUSC_DISABLE | MEM_WIN_ON | MEM_PAGE_FIRST);
    fpbTestPtr = fpCARD1->MemoryBase;
    fpbTestPtr = fpbTestPtr + 0x100;
    for(bPage = MEM_PAGE_1; bPage <= MEM_PAGE_A; bPage++)
    {ChangeR56Page(fpCARD1, bPage);
     for(wOffset = 0; wOffset < LOOP_COUNT; wOffset++)
	{printf("%c",*(fpbTestPtr + wOffset));
	} /* end wOffset for loop*/
    } /* end bPage for loop*/

     /* Stop both DMA channels*/
    _outp(fpCARD1->wIOAddress, IUSC_ENABLE | MEM_WIN_ON | MEM_PAGE_FIRST);
    IUSCout(fpCARD1,DCAR, DMA_ChannelCmd_PauseBoth);
    _outp(fpCARD1->wIOAddress, bBase0Value); /*restore Base+0 value*/
    /*reset internal loop bit */
    IUSCout(fpCARD1,CCR, 0);
    IUSCout(fpCARD1,IOCR,TxC_PinControl_TxClkOutput | TxD_PinControl_TxDataOutput);
    IUSCout(fpCARD1,CCAR, ModeControl_NormalOp	);
    clean_fifo();
    wait_for_key();
}
/*********************************************************/
void int_test(void)
{   unsigned int i,j;
    unsigned short tx_to;
    void __far *p;

    cls();
    printf("INTERRUPT DRIVEN INTERNAL LOOPBACK TEST:\n\n");
    rx_ptr=0;		/* set char pointer to 0*/
    tx_ptr=0;
    clean_fifo();	/*clean fifo*/
    /* Set internal loop bit*/
    IUSCout(fpCARD1,IOCR,	TxC_PinControl_TxClkOutput | TxD_PinControl_Output1);
    IUSCout(fpCARD1,CCAR, ModeControl_IntLocalLpback|ChannelCommand_RxTxFIFO_Purge );

    SaveIRQMask();
    p=isr;
    IRQSetupEx(fpCARD1->IUSCIRQ,p);	  /*   */
    /*rts & tx enabled*/
    /* Master Interrupt Enable*/
    cursor(0x0300);

    IUSCout(fpCARD1,ICR, MasterIntEnable_Yes | IE_Command_SetIE | RxDataIE_Yes );
    IUSCout(fpCARD1,CCAR, ModeControl_IntLocalLpback | ChannelCommand_RxTxFIFO_Purge );
    for(i = 0; i < 10; i++)		 /*loop 10 times*/
	 {for (j = 0; j < LOOP_COUNT; j++)	 /*loop # of char in string*/
	  {tx_to=0;
	   do{
	      if((IUSCin(fpCARD1, TCSR) & TxBuffer_Empty))
		 {IUSCoutb(fpCARD1, TDR, loop_data[j]);
		  tx_ptr++;
		  tx_to=0;
		 }
	      else
		{tx_to++;
		    if(tx_to==0xffff)
		    {printf("\nError: Tx Time out failure.\n");
		     goto wfk2;
		    }
		}
	    }while(tx_to!=0);
      } //end for
     }	//End for
	/* IUSC ints off */
    i = 0;
    do{
	i++;
	if(i == 0xffff)
	    {printf("Error: Time out waiting for transfer to complete.\n\n");
	     break;
	    }
    }while(rx_ptr < TX_COUNT);
wfk1:
    for( rx_ptr=0; rx_ptr <= TX_COUNT; rx_ptr++)	/*print buffer*/
	printf("%c",rxbuff[rx_ptr]);
wfk2:
    for( rx_ptr=0; rx_ptr <= TX_COUNT; rx_ptr++)  /* clean buffer */
	rxbuff[rx_ptr] = ' ';

    IUSCout(fpCARD1,ICR, MasterIntEnable_No | IE_Command_ResetIE | RxDataIE_Yes);
    IRQUnsetup(CARD1.IUSCIRQ);
    ReturnIRQMask();
    /*reset internal loop bit */
    IUSCout(fpCARD1,IOCR,	TxC_PinControl_TxClkOutput | TxD_PinControl_TxDataOutput);
    IUSCout(fpCARD1,CCAR, ModeControl_NormalOp	);
    clean_fifo();
    wait_for_key();
}
/*********************************************************/
#pragma check_stack(off)
void __interrupt __far isr(void)
{   _disable();

    /* This line is needed because we get one interrupt that is not a
       RxCharAvail interrupt first. At this time I do not know why*/
    if((IUSCin(fpCARD1,RCSR) & RxCharAvailable_FIFO_NotEmpty))
    do{
     rxbuff[rx_ptr] = IUSCinb(fpCARD1, RDR);
      if(rx_ptr < TX_COUNT)
	rx_ptr++;
     }while((IUSCin(fpCARD1,RCSR) & RxCharAvailable_FIFO_NotEmpty));

    IUSCout(fpCARD1,DCCR, IUS_Command_ResetIUS | RxDataIUS_Yes | IP_Command_ResetIP | RxDataIP_Yes);
    /* Non-specifice End of Interrupt to one or both PICs (EOI) */

    if( fpCARD1->IUSCIRQ > 0x07)
	outp(0xa0, 0x20);
    outp(0x20, 0x20);
    _enable();
}
#pragma check_stack()
/*********************************************************/
void clear_rx_buff(void)
{       unsigned int i;
	for(i=0;i<TX_COUNT;i++)
	   rxbuff[i]=0x00;
}
/*********************************************************/
unsigned char invert(unsigned char what,unsigned char bit)
{   unsigned char value;
    _asm
    {   push bx
	push cx
	mov al,what
	mov bl,bit
	push ax
	MOV CL,bl
	AND AL,BL               ;MASK BIT
	NOT AL                  ;INVERT
	AND AL,BL               ;MASK AGAIN
	JZ IB1
	pop bx
	OR AL,BL
	JMP IBE
IB1:    POP BX
	NOT CL
	MOV AL,CL
	AND AL,BL
IBE:    pop cx
	pop bx
	mov value,al
    }
	return value;
}
/*********************************************************/
void modem(void)
{
    unsigned short wTemp;

   cls();
   SaveCursor();
   HideCursor();
   cursor(0x0200);
   printf("\t\t\tMODEM CONTROL SIGNAL TEST\nPress <R> to toggle RTS, \
<D> to toggle DTR, and <Esc> to return to main menu.\n");
   printf("To toggle selected interface: <1> EIA-530, <2> RS-232, <3> V.35\n");
   printf("To toggle TxC as input or output, press <T>\n");
   //BugBug: possibly change the writing portion to PSR instead of PCR

 MasterPCR= IUSCin(fpCARD1,PCR);
 while(1)
 {cursor(0x0700);
  IUSCout(fpCARD1, PSR, 0xaaaa); /*Unlatch all bits of the Port Status Register*/
  if(_bios_keybrd(_KEYBRD_READY))
     {c=_bios_keybrd(_KEYBRD_READ);
      if(c==ESC)
       {break;
       }
      else
       {switch(c)
	{case 'r':
	 case 'R':
	    if((IUSCin(fpCARD1,PSR)) & Port7_Pin_Low)
		{MasterPCR = MasterPCR & 0x3fff;
		 MasterPCR = MasterPCR | RTS_ON;
		 IUSCout(fpCARD1,PCR,MasterPCR);
		}
	     else
		{MasterPCR = MasterPCR & 0x3fff;
		 MasterPCR = MasterPCR | RTS_OFF;
		 IUSCout(fpCARD1,PCR,MasterPCR);
		}
	    break;
	 case 'd':
	 case 'D':
	    if((IUSCin(fpCARD1,PSR)) & Port6_Pin_Low)
		{MasterPCR = MasterPCR & 0xcfff;
		 MasterPCR = MasterPCR | DTR_ON;
		 IUSCout(fpCARD1,PCR,MasterPCR);
		}
	    else
		{MasterPCR = MasterPCR & 0xcfff;
		 MasterPCR = MasterPCR | DTR_OFF;
		 IUSCout(fpCARD1,PCR,MasterPCR);
		}
	    break;
	 case '1':
	 case '2':
	 case '3':
	    MasterPCR= IUSCin(fpCARD1,PCR);
	    MasterPCR = MasterPCR & 0xff0f;
	    if(c=='1')
	      MasterPCR = MasterPCR | SELECT_EIA530;
	    else if(c=='2')
	      MasterPCR = MasterPCR | SELECT_RS232;
	    else if(c=='3')
	      MasterPCR = MasterPCR | SELECT_V35;
	    IUSCout(fpCARD1,PCR,MasterPCR);
	    break;
	 case 'T':
	 case 't':
	    MasterPCR= IUSCin(fpCARD1,PCR);
	     if((IUSCin(fpCARD1,PSR)) & Port5_Pin_Low)
		{MasterPCR = MasterPCR & 0xf3ff;
		 MasterPCR = MasterPCR | TXC_INPUT;
		 IUSCout(fpCARD1,PCR,MasterPCR);
		 wTemp = IUSCin(fpCARD1, IOCR);
		 wTemp = wTemp & 0xffC7;    /*TxC is input*/
		 IUSCout(fpCARD1, IOCR, wTemp);
		}
	    else
		{MasterPCR = MasterPCR & 0xf3ff;
		 MasterPCR = MasterPCR | TXC_OUTPUT;
		 IUSCout(fpCARD1,PCR,MasterPCR);
		 wTemp = IUSCin(fpCARD1, IOCR);
		 wTemp = wTemp & 0xffC7;
		 wTemp = wTemp | 0x0020;    /*TxC is output of BRG0*/
		 IUSCout(fpCARD1, IOCR, wTemp);
		}
	    break;
	 } //end switch /case
	} //end else
     }	//End if kbd check
    IUSCout(fpCARD1, PSR, 0xaaaa); /*Unlatch all bits of the Port Status Register*/
    printf("RTS..................%s\t", ResultONOFF[wOnOff((IUSCin(fpCARD1,PSR)) & Port7_Pin_Low)]);
    printf("CTS..................%s\n", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & CTS_ON)]);
    printf("DTR..................%s\t", ResultONOFF[wOnOff((IUSCin(fpCARD1,PSR)) & Port6_Pin_Low)]);
    printf("DCD..................%s\n", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & DCD_ON)]);
    printf("RI...................%s\t", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & RI_ON)]);
    printf("DSR..................%s\n", ResultONOFF[wOnOff((IUSCin(fpCARD1,MISR)) & DSR_ON)]);
    printf("TM...................%s\t", ResultONOFF[wOnOff((IUSCin(fpCARD1,PSR)) & Port4_Pin_Low)]);
    printf("TxC..................%s\n", ResultINOUT[wOnOff((IUSCin(fpCARD1,PSR)) & Port5_Pin_Low)]);
    /*BugBug: this is a latched state need to issue an UNLATCH command then read PSR*/
    printf("Interface selected...%s\t", ResultINTERFACE[GetInterface((IUSCin(fpCARD1,PCR)) & 0x00f0)]);
  }  //end while
   RestoreCursor();

}
/*********************************************************/
void display_parm(void)
{   int i;
    unsigned short DataVal;
    char RegString[80];
    do{
    cls();
    cursor(0x0200);
    printf("Press <1> to initialize with new values OR\n");
    printf("      <2> to reinitilize with default values OR\n");
    printf("      <Esc> return to the menu.\n");
    c=getch();
    switch (c)
	{case '1':
	    cursor(0x600);
	    printf("Enter IUSC register value followed by <Enter>...");
	    RegString[0]= 0;
	    scanf("%s",&RegString);
	    strupr(RegString);
	    for(i = 0; i < NUM_REG; i++)
		{if(strcmp(&sRegList[i][0],RegString)==0)
		   {printf("\nEnter the value to register in HEX followed by <Enter>...");
		    scanf("%x", &DataVal);
		    IUSCout( fpCARD1, bRegList[i], DataVal);
		    printf("\n\n%X programmed to %s.\n",DataVal,&sRegList[i][0]);
		    wait_for_key();
		    break;
		    }
		}
	    if(i==NUM_REG)
	      {printf("\nError: Invalid register specified.\n");
	       i=0;
	       wait_for_key();
	      }
	    break;
	 case '2':
	    if(0 != InitIUSC(fpCARD1))
		{printf("Error: Failure initializing the IUSC.\n");
		 Continue();
		}
	    else
		{cursor(0x1018);
		printf("Default values programmed.\n");
		wait_for_key();
		}
	    break;
	case ESC:
	    return;  //((void) 0);
	    break;
	default:
		break;
	} //end switch case

    }while(c != ESC);
	//wait_for_key();
}
/*********************************************************/
void terminal(void)
{
	cls();
	cursor(0x0100);
	printf("TERMINAL MODE: Press <1> for Data Stream <2> for Terminal <ESC> for menu.\n");
	while((c=getch())!=ESC)
	   {switch(c)
		 {case '1':printf("\tData Stream: Sending 55 HEX.\n");
		    cursor(0x1518);
			 /*rts and tx enabled*/
		    printf("Press any key to pause or <ESC> for menu.\n");
		    while(1)
		    {if(_bios_keybrd(_KEYBRD_READY))
			{c=_bios_keybrd(_KEYBRD_READ);
			 if(c!=ESC)
			  {cursor(0x1518);
			   printf("  Press any key to continue                \n");
			   c=getch();
			   cursor(0x1518);
			   printf("Press any key to pause or <ESC> for menu.\n");
			  }
			 else
			   goto terminal_out;
			}
			 if((IUSCin(fpCARD1, TCSR) & TxBuffer_Empty))
			   IUSCoutb(fpCARD1,TDR,0x55);
		     }
		    break;
		  case '2':printf("\tTerminal: Press <ESC> to exit.\n");
		    cursor(0x0400);
		    term();
		    cls();
		    goto terminal_out;
		 }
	   }
terminal_out: ;
	    /* clean fifo*/
    clean_fifo();
}
/*********************************************************/
void clean_fifo(void)
{

    IUSCout(fpCARD1, CCAR, ModeControl_NormalOp | ChannelCommand_RxTxFIFO_Purge);
    //IUSCout(fpCARD1, CCAR, ModeControl_NormalOp | ChannelCommand_RxFIFO_Purge);
    //IUSCout(fpCARD1, CCAR, ModeControl_NormalOp | ChannelCommand_TxFIFO_Purge);
    //IUSCout(fpCARD1, CCAR, ModeControl_NormalOp | ChannelCommand_RxFIFO_Purge);
    //while((IUSCin(fpCARD1, RCSR) & RxCharAvailable_FIFO_NotEmpty))
    //	IUSCinb(fpCARD1, RDR);

}
/*********************************************************/
/*********************************************************/