struct cmd_struct
{
 char               name[30];
 unsigned int       code;
 unsigned long      init;
 char               length;
 char               active;
 unsigned long      wtest;
 unsigned long      wresult;
}
cmd61[0xFF];

void load_def(void)
{
 unsigned int ld_cnt;

 ld_cnt=0;

 do
  {
   cmd61[ld_cnt].active=0;
   ld_cnt++;
  }
 while(ld_cnt<0xFF);

 strcpy(cmd61[0x00].name,"HcRevision         ");
 cmd61[0x00].code        =0x00;
 cmd61[0x00].init        =0x00000011;
 cmd61[0x00].length      =32;
 cmd61[0x00].active      =1;
 cmd61[0x00].wtest       =0xFFFFFFFF;
 cmd61[0x00].wresult     =0x00000011;

 strcpy(cmd61[0x01].name,"HcControl          ");
 cmd61[0x01].code        =0x01;
 cmd61[0x01].init        =0x00000000;
 cmd61[0x01].length      =32;
 cmd61[0x01].active      =1;
 cmd61[0x01].wtest       =0xFFFFFFFF;
 cmd61[0x01].wresult     =0x00000600;

 strcpy(cmd61[0x02].name,"HcCommandStatus    ");
 cmd61[0x02].code        =0x02;
 cmd61[0x02].init        =0x00000000;
 cmd61[0x02].length      =32;
 cmd61[0x02].active      =1;
 cmd61[0x02].wtest       =0xFFFFFFFF;
 cmd61[0x02].wresult     =0x00000000;

 strcpy(cmd61[0x03].name,"HcInterruptStatus  ");
 cmd61[0x03].code        =0x03;
 cmd61[0x03].init        =0x00000000;
 cmd61[0x03].length      =32;
 cmd61[0x03].active      =1;
 cmd61[0x03].wtest       =0xFFFFFFFF;
 cmd61[0x03].wresult     =0x00000000;

 strcpy(cmd61[0x04].name,"HcInterruptEnable  ");
 cmd61[0x04].code        =0x04;
 cmd61[0x04].init        =0x00000000;
 cmd61[0x04].length      =32;
 cmd61[0x04].active      =1;
 cmd61[0x04].wtest       =0xFFFFFFFF;
 cmd61[0x04].wresult     =0x800000FD;

 strcpy(cmd61[0x05].name,"HcInterruptDisable ");
 cmd61[0x05].code        =0x05;
 cmd61[0x05].init        =0x00000000;
 cmd61[0x05].length      =32;
 cmd61[0x05].active      =1;
 cmd61[0x05].wtest       =0xFFFFFFFF;
 cmd61[0x05].wresult     =0x00000000;

 strcpy(cmd61[0x0D].name,"HcFmInterval       ");
 cmd61[0x0D].code        =0x0D;
 cmd61[0x0D].init        =0x00002EDF;
 cmd61[0x0D].length      =32;
 cmd61[0x0D].active      =1;
 cmd61[0x0D].wtest       =0xFFFFFFFF;
 cmd61[0x0D].wresult     =0xFFFF3FFF;

 strcpy(cmd61[0x0E].name,"HcFmRemaining      ");
 cmd61[0x0E].code        =0x0E;
 cmd61[0x0E].init        =0x00000000;
 cmd61[0x0E].length      =32;
 cmd61[0x0E].active      =1;
 cmd61[0x0E].wtest       =0xFFFFFFFF;
 cmd61[0x0E].wresult     =0x00000000;

 strcpy(cmd61[0x0F].name,"HcFmNumber         ");
 cmd61[0x0F].code        =0x0F;
 cmd61[0x0F].init        =0x00000000;
 cmd61[0x0F].length      =32;
 cmd61[0x0F].active      =1;
 cmd61[0x0F].wtest       =0xFFFFFFFF;
 cmd61[0x0F].wresult     =0x00000000;

 strcpy(cmd61[0x11].name,"HcLSThreshold      ");
 cmd61[0x11].code        =0x11;
 cmd61[0x11].init        =0x00000628;
 cmd61[0x11].length      =32;
 cmd61[0x11].active      =1;
 cmd61[0x11].wtest       =0xFFFFFFFF;
 cmd61[0x11].wresult     =0x000007FF;

 strcpy(cmd61[0x12].name,"HcRhDescriptorA    ");
 cmd61[0x12].code        =0x12;
 cmd61[0x12].init        =0xFF000902;
 cmd61[0x12].length      =32;
 cmd61[0x12].active      =1;
 cmd61[0x12].wtest       =0xFFFFFFFF;
 cmd61[0x12].wresult     =0xFF001B02;

 strcpy(cmd61[0x13].name,"HcRhDescriptorB    ");
 cmd61[0x13].code        =0x13;
 cmd61[0x13].init        =0x00000000;
 cmd61[0x13].length      =32;
 cmd61[0x13].active      =1;
 cmd61[0x13].wtest       =0xFFFFFFFF;
 cmd61[0x13].wresult     =0x00060006;

 strcpy(cmd61[0x14].name,"HcRhStatus         ");
 cmd61[0x14].code        =0x14;
 cmd61[0x14].init        =0x00000000;
 cmd61[0x14].length      =32;
 cmd61[0x14].active      =1;
 cmd61[0x14].wtest       =0xFFFFFFFF;
 cmd61[0x14].wresult     =0x00000000;

 strcpy(cmd61[0x15].name,"HcRhPortStatus[1]  ");
 cmd61[0x15].code        =0x15;
 cmd61[0x15].init        =0x00000000;
 cmd61[0x15].length      =32;
 cmd61[0x15].active      =0;
 cmd61[0x15].wtest       =0xFFFFFFFF;
 cmd61[0x15].wresult     =0x00010000;

 strcpy(cmd61[0x16].name,"HcRhPortStatus[2]  ");
 cmd61[0x16].code        =0x16;
 cmd61[0x16].init        =0x00000000;
 cmd61[0x16].length      =32;
 cmd61[0x16].active      =0;
 cmd61[0x16].wtest       =0xFFFFFFFF;
 cmd61[0x16].wresult     =0x00010000;

 strcpy(cmd61[0x17].name,"HcINTLPTDDoneMap   ");
 cmd61[0x17].code        =0x17;
 cmd61[0x17].init        =0x0000;
 cmd61[0x17].length      =32;
 cmd61[0x17].active      =1;
 cmd61[0x17].wtest       =0;
 cmd61[0x17].wresult     =0;

 strcpy(cmd61[0x18].name,"HcINTLPTDSkipMap   ");
 cmd61[0x18].code        =0x18;
 cmd61[0x18].init        =0x0000;
 cmd61[0x18].length      =32;
 cmd61[0x18].active      =1;
 cmd61[0x18].wtest       =0;
 cmd61[0x18].wresult     =0;

 strcpy(cmd61[0x19].name,"HcINTLPTDLast      ");
 cmd61[0x19].code        =0x19;
 cmd61[0x19].init        =0;
 cmd61[0x19].length      =32;
 cmd61[0x19].active      =1;
 cmd61[0x19].wtest       =0;
 cmd61[0x19].wresult     =0;

 strcpy(cmd61[0x1A].name,"HcINTLCurrentActive");
 cmd61[0x1A].code        =0x1A;
 cmd61[0x1A].init        =0;
 cmd61[0x1A].length      =16;
 cmd61[0x1A].active      =1;
 cmd61[0x1A].wtest       =0;
 cmd61[0x1A].wresult     =0;

 strcpy(cmd61[0x1B].name,"HcATLPTDDoneMap    ");
 cmd61[0x1B].code        =0x1B;
 cmd61[0x1B].init        =0;
 cmd61[0x1B].length      =32;
 cmd61[0x1B].active      =1;
 cmd61[0x1B].wtest       =0;
 cmd61[0x1B].wresult     =0;

 strcpy(cmd61[0x1C].name,"HcATLPTDSkipMap    ");
 cmd61[0x1C].code        =0x1C;
 cmd61[0x1C].init        =0;
 cmd61[0x1C].length      =32;
 cmd61[0x1C].active      =1;
 cmd61[0x1C].wtest       =0;
 cmd61[0x1C].wresult     =0;

 strcpy(cmd61[0x1D].name,"HcATLLastPTD       ");
 cmd61[0x1D].code        =0x1D;
 cmd61[0x1D].init        =0;
 cmd61[0x1D].length      =32;
 cmd61[0x1D].active      =0;
 cmd61[0x1D].wtest       =0;
 cmd61[0x1D].wresult     =0;

 strcpy(cmd61[0x1E].name,"HcATLCurrentActive ");
 cmd61[0x1E].code        =0x1E;
 cmd61[0x1E].init        =0;
 cmd61[0x1E].length      =16;
 cmd61[0x1E].active      =1;
 cmd61[0x1E].wtest       =0;
 cmd61[0x1E].wresult     =0;

 strcpy(cmd61[0x20].name,"HcHardwareConfig   ");
 cmd61[0x20].code        =0x20;
 cmd61[0x20].init        =0x0028;
 cmd61[0x20].length      =16;
 cmd61[0x20].active      =1;
 cmd61[0x20].wtest       =0xFFFF;
 cmd61[0x20].wresult     =0xFFFF;

 strcpy(cmd61[0x21].name,"HcDMAConfiguration ");
 cmd61[0x21].code        =0x21;
 cmd61[0x21].init        =0x0000;
 cmd61[0x21].length      =16;
 cmd61[0x21].active      =1;
 cmd61[0x21].wtest       =0xFFFF;
 cmd61[0x21].wresult     =0xFFFF;

 strcpy(cmd61[0x22].name,"HcTransferCounter  ");
 cmd61[0x22].code        =0x22;
 cmd61[0x22].init        =0x0001;
 cmd61[0x22].length      =16;
 cmd61[0x22].active      =1;
 cmd61[0x22].wtest       =0xFFFF;
 cmd61[0x22].wresult     =0xFFFF;

 strcpy(cmd61[0x24].name,"HcUPInterrupt      ");
 cmd61[0x24].code        =0x24;
 cmd61[0x24].init        =0x0040;
 cmd61[0x24].length      =16;
 cmd61[0x24].active      =1;
 cmd61[0x24].wtest       =0xFFFF;
 cmd61[0x24].wresult     =0xFFFF;

 strcpy(cmd61[0x25].name,"HcUPInterruptEnable");
 cmd61[0x25].code        =0x25;
 cmd61[0x25].init        =0x0000;
 cmd61[0x25].length      =16;
 cmd61[0x25].active      =1;
 cmd61[0x25].wtest       =0xFFFF;
 cmd61[0x25].wresult     =0xFFFF;

 strcpy(cmd61[0x27].name,"HcChipID           ");
 cmd61[0x27].code        =0x27;
 cmd61[0x27].init        =0x3623;
 cmd61[0x27].length      =16;
 cmd61[0x27].active      =1;
 cmd61[0x27].wtest       =0xFFFF;
 cmd61[0x27].wresult     =0x3FFF;

 strcpy(cmd61[0x28].name,"HcScratch          ");
 cmd61[0x28].code        =0x28;
 cmd61[0x28].init        =0x0000;
 cmd61[0x28].length      =16;
 cmd61[0x28].active      =1;

 strcpy(cmd61[0x29].name,"HcSoftwareReset    ");
 cmd61[0x29].code        =0x29;
 cmd61[0x29].init        =0x0000;
 cmd61[0x29].length      =16;
 cmd61[0x29].active      =0;

 strcpy(cmd61[0x2C].name,"HcBufferStatus     ");
 cmd61[0x2C].code        =0x2C;
 cmd61[0x2C].init        =0x0000;
 cmd61[0x2C].length      =16;
 cmd61[0x2C].active      =1;

 strcpy(cmd61[0x30].name,"HcISTLBufferSize   ");
 cmd61[0x30].code        =0x30;
 cmd61[0x30].init        =0x0000;
 cmd61[0x30].length      =16;
 cmd61[0x30].active      =1;

 strcpy(cmd61[0x32].name,"HcDirectAddrLen    ");
 cmd61[0x32].code        =0x32;
 cmd61[0x32].init        =0x0000;
 cmd61[0x32].length      =32;
 cmd61[0x32].active      =1;

 strcpy(cmd61[0x33].name,"HcINTLBufferSize   ");
 cmd61[0x33].code        =0x33;
 cmd61[0x33].init        =0x0000;
 cmd61[0x33].length      =16;
 cmd61[0x33].active      =1;

 strcpy(cmd61[0x34].name,"HcATLBufferSize    ");
 cmd61[0x34].code        =0x34;
 cmd61[0x34].init        =0x0000;
 cmd61[0x34].length      =16;
 cmd61[0x34].active      =1;

 strcpy(cmd61[0x40].name,"HcISTL0BufferPort  ");
 cmd61[0x40].code        =0x40;
 cmd61[0x40].init        =0x0000;
 cmd61[0x40].length      =16;
 cmd61[0x40].active      =1;

 strcpy(cmd61[0x42].name,"HcISTL1BufferPort  ");
 cmd61[0x42].code        =0x42;
 cmd61[0x42].init        =0x0000;
 cmd61[0x42].length      =16;
 cmd61[0x42].active      =1;

 strcpy(cmd61[0x43].name,"HcINTLBufferPort   ");
 cmd61[0x43].code        =0x43;
 cmd61[0x43].init        =0x0000;
 cmd61[0x43].length      =16;
 cmd61[0x43].active      =0;

 strcpy(cmd61[0x45].name,"HcDirectAddress    ");
 cmd61[0x45].code        =0x45;
 cmd61[0x45].init        =0x0000;
 cmd61[0x45].length      =16;
 cmd61[0x45].active      =1;

 strcpy(cmd61[0x47].name,"HcPTLToggleRate    ");
 cmd61[0x47].code        =0x47;
 cmd61[0x47].init        =0x0000;
 cmd61[0x47].length      =16;
 cmd61[0x47].active      =1;

 strcpy(cmd61[0x51].name,"HcATLPTDDoneThrsCnt");
 cmd61[0x51].code        =0x51;
 cmd61[0x51].init        =0x0000;
 cmd61[0x51].length      =16;
 cmd61[0x51].active      =1;

 strcpy(cmd61[0x52].name,"HcATLPTDDoneThrsTO ");
 cmd61[0x52].code        =0x52;
 cmd61[0x52].init        =0x0000;
 cmd61[0x52].length      =16;
 cmd61[0x52].active      =1;

 strcpy(cmd61[0x53].name,"HcINTLBlkSize      ");
 cmd61[0x53].code        =0x53;
 cmd61[0x53].init        =0x0000;
 cmd61[0x53].length      =16;
 cmd61[0x53].active      =1;

 strcpy(cmd61[0x62].name,"OTGControl         ");
 cmd61[0x62].code        =0x62;
 cmd61[0x62].init        =0x01C0;
 cmd61[0x62].length      =16;
 cmd61[0x62].active      =1;

 strcpy(cmd61[0x67].name,"OTGStatus          ");
 cmd61[0x67].code        =0x67;
 cmd61[0x67].init        =0x0001;
 cmd61[0x67].length      =16;
 cmd61[0x67].active      =1;

 strcpy(cmd61[0x68].name,"OTGInterrupt       ");
 cmd61[0x68].code        =0x68;
 cmd61[0x68].init        =0x0000;
 cmd61[0x68].length      =16;
 cmd61[0x68].active      =1;

 strcpy(cmd61[0x69].name,"OTGInterruptEnable ");
 cmd61[0x69].code        =0x69;
 cmd61[0x69].init        =0x0000;
 cmd61[0x69].length      =16;
 cmd61[0x69].active      =1;

 strcpy(cmd61[0x6A].name,"OTGTimerControl    ");
 cmd61[0x6A].code        =0x6A;
 cmd61[0x6A].init        =0x0000;
 cmd61[0x6A].length      =32;
 cmd61[0x6A].active      =1;
}

void read_registers(void)
{
 unsigned int test_cnt;
 unsigned int no_of_test;
 long reg_data;
 long *r_ptr;
 char status_buffer[60];
 unsigned int l_space=8;

 //cleardevice();

 sprintf(status_buffer,"ISP1362 HC Register Test");
 //outtextxy(10,10,status_buffer);
 sprintf(status_buffer,"========================");
 //outtextxy(10,20,status_buffer);

 test_cnt=0;
 no_of_test=0;
 do
  {

   if(cmd61[test_cnt].active==1)
   {
	no_of_test++;
	if(cmd61[test_cnt].length==16)
	{
	 reg_data=r16(test_cnt);
	 reg_data&=0x0000FFFF;
	}

	if(cmd61[test_cnt].length==32)
	{
	 reg_data=r32(test_cnt);
	}

//	if(reg_data!=cmd61[test_cnt].init) {setcolor(RED);}

	sprintf(status_buffer,"0x%02X %s [%2d]=>%8lX, default=>%8lX",test_cnt,cmd61[test_cnt].name,cmd61[test_cnt].length,reg_data,cmd61[test_cnt].init);
//	outtextxy(10,20+no_of_test*l_space,status_buffer);

//	setcolor(YELLOW);
   }

   test_cnt++;
  }
 while(test_cnt<0xFF);

 fflush(stdin);
 sprintf(status_buffer,"Press any key to go back to main menu");
// outtextxy(10,420,status_buffer);
 sprintf(status_buffer,"=====================================");
// outtextxy(10,430,status_buffer);
// getch();
}

void wr_reg(void)
{
 unsigned int test_cnt;
 unsigned int no_of_test;
 unsigned long *r_ptr;
 unsigned long rs;
 long reg_data;
 char sb[60];
 int last_row;
 int user_in;
 long error,p_error;
 long ref;
 int reg_port;
 unsigned char key_in;
 int l_space=8;

// cleardevice();

 r_ptr=&rs;

 sprintf(sb,"ISP1362 HC Register Test");
// outtextxy(10,10,sb);
 sprintf(sb,"========================");
 //outtextxy(10,20,sb);

 test_cnt=0;
 no_of_test=0;
 do
  {
   if(cmd61[test_cnt].active==1)
   {
	no_of_test++;
	sprintf(sb,"0x%02X %s, default=>%8lX",test_cnt,cmd61[test_cnt].name,cmd61[test_cnt].init);
	//outtextxy(10,20+l_space*no_of_test,sb);
   }
   test_cnt++;
  }
 while(test_cnt<0xFF);

 //gotoxy(50,4);
 printf("Register to test? (Hex)");
 //gotoxy(50,5);
 scanf("%2x",&reg_port);

 error=0;
 p_error=0;
 test_cnt=0;

// fubar(1,0,10);

 do
  {
   p_error=error;

  // gotoxy(50,5);

	if(cmd61[reg_port].length==16)
	{
	 printf("Writing 16bit %8lX to 0x%2X",(long)test_cnt,reg_port);
	 w16(reg_port,test_cnt);
	 reg_data=r16(reg_port);
	 reg_data&=0x0000FFFF;
	// fubar(0,test_cnt,0xFFFF);
	 if(reg_data!=test_cnt)
	 {

//	  gotoxy(50,6);
	  printf("Reading       %8lX",reg_data);
//	  gotoxy(50,7);
	  printf("Error =       %8X",error);
	  error++;
	 }
	}

	if(cmd61[reg_port].length==32)
	{
	 ref=test_cnt+0x5A5A0000+(((long)test_cnt)<<16);
	 printf("Writing 32bit %8lX to 0x%2X",ref,reg_port);
//	 fubar(0,test_cnt,0xFFFF);
	 w32(reg_port, ref);
	 reg_data=r32(reg_port);

	 if(reg_data!=ref) {error++; }
	}

//   gotoxy(50,6);
   printf("Reading       %8lX",reg_data);
//   gotoxy(50,7);
   printf("Error =       %8X",error);
//   gotoxy(50,9);
   printf("Press '1' to stop",error);

   key_in=read_key(0);

 //  if(p_error!=error) {key_in=getch();}
   test_cnt++;
  }
 while((test_cnt!=0)&(key_in!='1'));

 //gotoxy(50,6);
 printf("Reading       %8lX",reg_data);
 //gotoxy(50,7);
 printf("Error =       %8X",error);

 fflush(stdin);
// getch();
}

void wr_auto(char *logfile)
{
 unsigned int cnt;
 unsigned int no_of_test;
 unsigned long rs;
 long reg_data;
 int user_in;
 long error,p_error;
 long ref;
 int reg_port;
 unsigned char key_in;
 unsigned char buf[200];

 sprintf(buf,"\nISP1362 HC Register Test");
 strcpy(logfile,buf);
 sprintf(buf,"\n========================");
 strcat(logfile,buf);

 //Test HcScratch
 printf("\nTesting HcScratch Register...");
 sprintf(buf,"\nTesting HcScratch Register...");
 strcat(logfile,buf);

 cnt=0;
 error=0;
 do
  {
   w16(HcScratch,cnt);
   if((r16(HcScratch))!=cnt)
   {
	error++;
   }
   cnt++;
  }
 while(cnt<0xFFFF);

 sprintf(buf,", Total error = %8lX",error);
 strcat(logfile,buf);

 //Test HcDirectAddrLen
 printf("\nTesting HcDirectAddrLen Register...");
 sprintf(buf,"\nTesting HcDirectAddrLen Register...");
 strcat(logfile,buf);

 reg_data=0;
 error=0;
 do
  {
   w32(HcDirAddrLen,reg_data);
   if((r16(HcDirAddrLen))!=reg_data)
   {
	error++;
   }
   reg_data++;
  }
 while(reg_data<0xFFFF);

 sprintf(buf,", Total error = %8lX",error);
 strcat(logfile,buf);
}