bung.cpp

bung.cpp bung.dfm bung.h DbgWarn.cpp DbgWarn.dfm DbgWarn.h Debug.cpp Debug.dfm Debug.h Emu.cpp Emu

   }
   num_page=(filesize/0x8000)*2;	// how many 16k banks
//   printf("num_page=%d\n",num_page);
   if((fptr=fopen(file_name,"rb"))==NULL){/* open error */
//      printf("open error !!!\07\n");
      return(-1);
   }

   if (eeprom_type==16){	// erase 16M flash
      if (erase()){		// erase error
	 fclose(fptr);		// close file handle
	 return(-1);
      }
   }
    BungSendWnd->ProgressBar1->Max=num_page;

   for (page=0;page<num_page;page++){
      if (read_16k_file()!=0){
//	 printf("load file error\n");
	 fclose(fptr);
	 return(-1);
      }
      if (page==0)
	 chk_dsp_name(0);	// display game name only
      if (write_eeprom_16k(page)){
//	 printf("write cart error at bank=%x\n",page);
	 fclose(fptr);
	 return(-1);
      }
      BungSendWnd->ProgressBar1->StepBy(1);
      BungSendWnd->ProgressBar1->Update();
      char str[64];
      sprintf(str,"Sending to Bung XChanger (%dk/%dk)...",page*16,num_page*16);
      BungSendWnd->Label1->Caption=str;
      BungSendWnd->Label1->Update();
   }
//   printf("write cart ok\n");
   fclose(fptr);
   if((fptr=fopen(file_name,"rb"))==NULL){/* open error */
//      printf("open error !!!\07\n");
      return(-1);
   }

   for (page=0;page<num_page;page++){
      if (read_16k_file()!=0){
//	 printf("load file error\n");
	 fclose(fptr);
	 return(-1);
      }
      if (verify_eeprom_16k(page)){
//	 printf("verify cart error at bank=%x\n",page);
	 fclose(fptr);
	 return(-1);
      }
   }
//   printf("verify cart ok\n");
   fclose(fptr);
   return(0);
}

char backup_rom(void)	//no_page=how many 32K
// 0	"256kBit = 32kB = 2 banks",
// 1	"512kBit = 64kB = 4 banks",
// 2	"1MBit = 128kB = 8 banks",
// 3	"2MBit = 256kB = 16 banks",
// 4	"4MBit = 512kB = 32 banks"};
// 5	"8MBit = 1MB = 64 banks",
// 6    "16MBit = 2MB = 128 banks",
{
   unsigned char max_bank_define[]={2,4,8,16,32,64,128};
   unsigned char max_bank,rom_bank;
   max_bank=max_bank_define[rom_size];
   if (cmd=='B'){
      if (eeprom_type==4)
	 max_bank=32;	// backup 4M
      if (eeprom_type==16)
	 max_bank=128;	// backup 16M
   }
//   printf("max_bank=%d\n",max_bank);
   for (rom_bank=0;rom_bank<max_bank;rom_bank++){
      read_eeprom_16k(rom_bank);
      verify_eeprom_16k(rom_bank);

      if (write_file_xxk(0x4000)!=0){
	 fclose(fptr);
	 return(-1);
      }
   }
   fclose(fptr);
   return(0);
}

char check_card(void)
{
   unsigned int sum=0xd3;	// magic code = 0xd3
   unsigned char cts[64];	// cart type string
   unsigned char check_header[48]={
      0xce,0xed,0x66,0x66,0xcc,0x0d,0x00,0x0b,
      0x03,0x73,0x00,0x83,0x00,0x0c,0x00,0x0d,
      0x00,0x08,0x11,0x1f,0x88,0x89,0x00,0x0e,
      0xdc,0xcc,0x6e,0xe6,0xdd,0xdd,0xd9,0x99,
      0xbb,0xbb,0x67,0x63,0x6e,0x0e,0xec,0xcc,
      0xdd,0xdc,0x99,0x9f,0xbb,0xb9,0x33,0x3e};
   char *cart_type_define[]={
	"ROM ONLY",		//0
	"ROM+MBC1",		//1
	"ROM+MBC1+RAM",		//2
	"ROM+MBC1+RAM+BATTERY",	//3
	"",			//4
	"ROM+MBC2",		//5
	"ROM+MBC2+BATTERY"};	//6
   char *rom_size_define[]={
	"256kBit = 32kB = 2 banks",
	"512kBit = 64kB = 4 banks",
	"1MBit = 128kB = 8 banks",
	"2MBit = 256kB = 16 banks",
	"4MBit = 512kB = 32 banks",
	"8MBit = 1MB = 64 banks",
	"16MBit = 2MB = 128 banks"};
   char *ram_size_define[]={
	"None",
	"16kBit = 2kB = 1 bank",
	"64kBit = 8kB = 1 bank",
	"256kBit = 32kB = 4 banks"};
   char game_name[17];

//   printf("checking rom information...\n");
   header_ok=1;
   for (i=0;i<48;i++){
      if (mix.buffer[i+4]!=check_header[i]){
	 header_ok=0;
	 break;
      }
   }
   if (!header_ok){
//      printf("no GB data present!\07\n");
      disp_buffer(0x50);
      return(-1);
   }
   for (i=0;i<16;i++)
      game_name[i]=mix.buffer[i+0x34];
   game_name[i]=0;
//   printf("Game Name = %s\n",game_name);

   cart_type=mix.buffer[0x47];

   switch (cart_type){
      case 0x00:strcpy(cts,"ROM only");break;	// cart type string
      case 0x01:strcpy(cts,"ROM+MBC1");break;
      case 0x02:strcpy(cts,"ROM+MBC1+RAM");break;
      case 0x03:strcpy(cts,"ROM+MBC1+RAM+BATTERY");break;
      case 0x05:strcpy(cts,"ROM+MBC");break;
      case 0x06:strcpy(cts,"ROM+MBC2+BATTERY");break;
      case 0x08:strcpy(cts,"ROM+RAM");break;
      case 0x09:strcpy(cts,"ROM+RAM+BATTERY");break;
      case 0x0B:strcpy(cts,"ROM+MMM01");break;
      case 0x0C:strcpy(cts,"ROM+MMM01+SRAM");break;
      case 0x0D:strcpy(cts,"ROM+MMM01+SRAM+BATTERY");break;
      case 0x0F:strcpy(cts,"ROM+MBC3+TIMER+BATTERY");break;
      case 0x10:strcpy(cts,"ROM+MBC3+TIMER+RAM+BATTERY");break;
      case 0x11:strcpy(cts,"ROM+MBC3");break;
      case 0x12:strcpy(cts,"ROM+MBC3+RAM");break;
      case 0x13:strcpy(cts,"ROM+MBC3+RAM+BATTERY");break;
      case 0x19:strcpy(cts,"ROM+MBC5");break;
      case 0x1A:strcpy(cts,"ROM+MBC5+RAM");break;
      case 0x1B:strcpy(cts,"ROM+MBC5+RAM+BATTERY");break;
      case 0x1C:strcpy(cts,"ROM+MBC5+RUMBLE");break;
      case 0x1D:strcpy(cts,"ROM+MBC5+RUMBLE+SRAM");break;
      case 0x1E:strcpy(cts,"ROM+MBC5+RUMBLE+SRAM+BATTERY");break;
      case 0x1F:strcpy(cts,"Pocker Camera");break;
      case 0xfd:strcpy(cts,"Bandai TAMA5");break;
      case 0xfe:strcpy(cts,"Hudson HuC-3");break;
      case 0xff:strcpy(cts,"Hudson HuC-1");break;

      default : strcpy(cts,"Not define");break;
   }
//   printf("Cartridge type(%d) = %s\n",cart_type,cts);
   rom_size=mix.buffer[0x48];
   if (rom_size>6){
//      printf("Rom size error!!! (%d)\n",rom_size);
      return(-1);
   }
//   else
//      printf("Rom size(%d) = %s\n",rom_size,rom_size_define[rom_size]);
   ram_size=mix.buffer[0x49];
   if (ram_size>4){
//      printf("Ram size error!!! (%d)\n",ram_size);
      return(-1);
   }
//   else
//      printf("Ram size(%d) = %s\n",ram_size,ram_size_define[ram_size]);

   if(cart_type>0 && cart_type<4 && rom_size>4){	// mbc1 8M/16M
      mbc1_exp=1;
//      printf("mbc1_exp=1\n");
   }

//******************* check sum **********************
   gcrc=(mix.buffer[0x4e]<<8)|mix.buffer[0x4f];
   for (i=0x4;i<0x4d;i++)
      sum+=mix.buffer[i];
   if ((sum+mix.buffer[0x4d])&0xff){
//      printf("Error Complement($%x), Correct Complement($%x)\07\n",mix.buffer[0x4d],(0x100-(sum&0xff)));

   }
   return(0);
}



char open_read()
{
struct ffblk ffblk;
int done;
   done = findfirst(file_name,&ffblk,0);
   if (done){
//      printf("file not found!\07\n");
      return(-1);
   }
   filesize=ffblk.ff_fsize;
//   printf("file length= %ld\n", filesize);

   if ((filesize<0x8000) || (filesize & 0x7fff) || (filesize>maxfilesize)){
//      printf("filesize error!\07\n");
      return(-1);
   }
//   num_page=(filesize/0x8000)*2;	// how many 16k banks
//   printf("num_page=%d\n",num_page);
   if((fptr=fopen(file_name,"rb"))==NULL){/* open error */
//      printf("open error !!!\07\n");
      return(-1);
   }

   if (read_16k_file()!=0){
//      printf("load file error\n");
      fclose(fptr);
      return(-1);
   }
   fclose(fptr);
   return(0);
}


char check_header(char mode)

{
   if (mode){          		// check game cart
      for (i=0x100;i<0x150;i++){	// read 0x100~0x150 to buffer
	 set_adr(i);
	 mix.buffer[i-0x100]=read_data();
//	 mix.buffer[i-0x100]=inportb(data);
      }
   }
   else{

      if (open_read())
	 return(-1);
      fclose(fptr);			// close file
      for (i=0;i<0x50;i++){
	 mix.buffer[i]=mix.buffer[i+0x100];
      }

   }
   return(check_card());
}

char chk_gcrc(void)
{
struct ffblk ffblk;
int done;
unsigned int sum_gcrc;
   unsigned char page,num_page;
   done = findfirst(file_name,&ffblk,0);
   if (done){
//      printf("file not found!\07\n");
      return(-1);
   }
   filesize=ffblk.ff_fsize;
//   printf("file length= %ld\n", filesize);

   if ((filesize<0x8000) || (filesize & 0x7fff) || (filesize>maxfilesize)){
//      printf("filesize error!\07\n");
      return(-1);
   }
   num_page=(filesize/0x8000)*2;	// how many 16k banks
//   printf("num_page=%d\n",num_page);
   if((fptr=fopen(file_name,"rb"))==NULL){/* open error */
//      printf("open error !!!\07\n");
      return(-1);
   }

   sum_gcrc=0;
   for (page=0;page<num_page;page++){
      if (read_16k_file()!=0){
//	 printf("load file error\n");
	 fclose(fptr);
	 return(-1);
      }
      if (page==0){
	 for(i=0;i<0x4000;i++)
	    if (i<0x14e || i>0x14f)	// skip gcrc
	       sum_gcrc+=mix.buffer[i];
      }
      else{
	 for(i=0;i<0x4000;i++)
	    sum_gcrc+=mix.buffer[i];
      }
   }
   fclose(fptr);
//   if (gcrc!=sum_gcrc)
//      printf("Error Checksum($%x), Correct Checksum($%x)\07\n",gcrc,sum_gcrc);
   return(0);
}

void backup(void)
{
   unsigned char ch;		// single key function
   if (check_header(1)){		// something error
      disp_buffer(0x50);
      return;
   }
   if((fptr=fopen(file_name,"w+b"))==NULL)
      {/* open error */
//      printf("open error !!!\07\n");
      return;
      }
   backup_rom();
//      printf("Backup Error!!!\07\n");
//   else
//      printf("Backup Rom success\n");
   return;
}

void SetSramBank(void)
{
   if (pocket_camera){
      bank_size=16;
      return;
   }
   bank_size=0;
   if (eeprom_type==4)
      bank_size=4;		// 4 x 8K =32K
   if (eeprom_type==16)
      bank_size=16;		// 16 x 8K =128K
}

void enable_sram_bank(void)
{
   init_port();
   set_adr(0x0);		// write 0000:0x0a default read mode
   out_byte(0x0a);		// enable sram
   out_byte(0xc0);		// disable sram
   set_adr(0xa000);
   out_byte(0xa0);		// ctr index
   set_adr(0xa100);
//   out_byte(0x00);		// ram_off,ram_bank_disable,MBC1
   out_byte(0xc0);		// ram_on,ram_bank_enable,MBC1

   set_adr(0x0);		// write 0000:0x0a
   out_byte(0x0a);		// enable sram
}

void gen_pat(unsigned int offset)
{
   for (i=0; i<0x2000; i++){	// 8k word = 16k bytes
      mix.bufferx[i]=i+offset;
   }
}


char test_sram_v(void)
{
   enable_sram_bank();

   for (bank=0;bank<bank_size;bank++){
      idx=0;
      set_sram_bank(bank);
      gen_pat(bank);
      for (j=0;j<0x20;j++){	// 32 x 256 = 8192(8kbytes)
	 set_ai_data(1,(0xa0+j));	// sram at 0xa000~bfff
	 set_ai_data(0,0);      // a[7..0]=0
	 set_ai_data(2,0x81);	// enable inc
	 set_ai(3);		// point to data r/w port
	 set_data_read
	 for (i=0;i<256;i++){
	    temp=read_data();
//	    temp=inportb(data);
	    if (mix.buffer[i+idx]!=temp){
//	       printf("sram verify error!\07\n");
//	       printf("sram verify error! bank=%x j=%x i=%x temp=%x pat=%x\n",bank,j,i,temp,mix.buffer[idx+i]);
	       return(-1);
	    }
	 }
	 set_ai_data(2,0x80);	// disable inc
	 idx=idx+256;
      }
   }
//   if (bank_size==4)
//      printf("256k sram verify ok\n");
//   if (bank_size==16)
//      printf("1M sram verify ok\n");
   return(0);
}



char test_sram_wv(void)
{
   enable_sram_bank();
   for (bank=0;bank<bank_size;bank++){
      idx=0;
//      printf("w");
      set_sram_bank(bank);
      gen_pat(bank);
//      disp_buffer(0x10);
      for (j=0;j<0x20;j++){	// 32 x 256 = 8192(8kbytes)
	 set_ai_data(1,(0xa0+j));	// sram at 0xa000~bfff
	 set_ai_data(0,0);      // a[7..0]=0
	 set_ai_data(2,0x81);	// enable inc
	 set_ai(3);		// point to data r/w port
	 set_data_write
	 for (i=0;i<256;i++){
	    write_data(mix.buffer[i+idx]);
//	    outportb(data,mix.buffer[i+idx]);
	 }
	 set_ai_data(2,0x80);	// disable inc
	 idx=idx+256;
      }
   }
//   if (bank_size==4)
//      printf("256k sram pattern written\n");
//   if (bank_size==16)
//      printf("1M sram pattern written\n");
   return(test_sram_v());
}

char test_all(void)
{
   if (write_cart_from_file())
      return(-1);
   return (test_sram_wv());
}

void usage(char *progname)
{
//   fprintf(stderr, "Usage: %s [-option] <Filename>\n", progname);
//   fprintf(stderr, "Usage: gbt14 [-option] <Filename>\n");
//   fprintf(stderr, "-l   : load ROM file to GB Card.\n");
//   fprintf(stderr, "-lsa : load 256k/1Mbits sram from PC to GB Card.\n");
//   fprintf(stderr, "-lsn : load 64kbits sram file from PC to specific sram bank(-n) in GB card.\n");
//   fprintf(stderr, "-lsc : load 1Mbits sram file from PC to Pocket Camera.\n");
//   fprintf(stderr, "-b   : auto-detect size and backup entire GB Card to PC.\n");
//   fprintf(stderr, "-ba  : backup full 4Mbits/16Mbits GB Card to PC.\n");
//   fprintf(stderr, "-bsa : retrieve all sram data (256k/1Mbits) from GB Card to PC.\n");
//   fprintf(stderr, "-bsn : retrieve specific bank(-n) sram data(64kbits) from GB Card to PC .\n");
//   fprintf(stderr, "-bsc : retrieve 1Mbits sram from Pocket Camera to PC.\n");
//   fprintf(stderr, "-v   : verify file in PC with GB Card.\n");
//   fprintf(stderr, "-e   : erase Flash rom.\n");
//   fprintf(stderr, "-c   : check ROM file header.\n");
   end_port();
//   exit(2);
}

char check_port_xpp(void)
{
   init_port();
   set_ai_data(1,0x12);
   set_ai_data(0,0x34);
   set_ai(1);
   set_data_read		// ninit=0, nwrite=1
   if (read_data()!=0x12) return(1);
   set_ai(0);
   set_data_read		// ninit=0, nwrite=1
   if (read_data()!=0x34) return(1);
   end_port();
   return(0);
}

char check_port(void)
{
   port_type=1;		// 0=epp, 1=spp
   if (check_port_xpp()==0){
      epp_spp=1;		// epp port present
   }
   if (port_8==0x3bc){		// if port=0x3bc skip epp test
      return(!epp_spp);
   }
   port_type=0;
   if (check_port_xpp()){
      if (epp_spp){
	 port_type=1;
	 end_port();
	 return(0);
      }
      else
	 return(1);		// no port found
   }
   return(0);
}

char open_read_sram()
{
struct ffblk ffblk;
int done;
   done = findfirst(file_name,&ffblk,0);
   if (done){
//      printf("file not found!\07\n");
      return(-1);
   }
   filesize=ffblk.ff_fsize;
//   printf("file length= %ld\n", filesize);
//   printf("bank_size=%d\n",bank_size);


   if (cmd=='L'){	// check file size 256k/1Mbits
      if ((filesize/0x2000)>bank_size){
//	    printf("filesize error!\07\n");
	    return(-1);
	 }


   }
   else{
      if (filesize!=0x2000){	// check file size 8kBytes
//	 printf("filesize error!\07\n");
	 return(-1);
      }
   }

   if((fptr=fopen(file_name,"rb"))==NULL){/* open error */
//      printf("open error !!!\07\n");
      return(-1);
   }

   bank_size=filesize/0x2000;		//********* over write bank of size
   if (cmd=='L'){
      return(0);
   }
   else{
      if (read_8k_file()!=0){
//	 printf("load file error\n");
	 fclose(fptr);
	 return(-1);
      }
   }
   fclose(fptr);
   return(0);
}

char write_sram_xxk(unsigned int length)
{
   if((fptr=fopen(file_name,"w+b"))==NULL)
      {/* open error */