//******************************************
// GAME BOY MODULE
//******************************************
#ifdef ENABLE_GBX

/******************************************
   Variables
 *****************************************/
// Game Boy
word sramBanks;
word romBanks;
word lastByte = 0;
boolean audioWE = 0;

/******************************************
   Menu
 *****************************************/
// GBx start menu
static const char gbxMenuItem1[] PROGMEM = "Game Boy (Color)";
static const char gbxMenuItem2[] PROGMEM = "GB Advance (3V)";
static const char gbxMenuItem3[] PROGMEM = "Flash GBC Cart";
static const char gbxMenuItem4[] PROGMEM = "NPower GB Memory";
static const char gbxMenuItem5[] PROGMEM = "Flash Codebreaker";
static const char gbxMenuItem6[] PROGMEM = "Flash Datel Device";
static const char* const menuOptionsGBx[] PROGMEM = { gbxMenuItem1, gbxMenuItem2, gbxMenuItem3, gbxMenuItem4, gbxMenuItem5, gbxMenuItem6, FSTRING_RESET };

// GB menu items
static const char* const menuOptionsGB[] PROGMEM = { FSTRING_READ_ROM, FSTRING_READ_SAVE, FSTRING_WRITE_SAVE, FSTRING_RESET };

// GB Flash items
static const char GBFlashItem1[] PROGMEM = "29F016/32/33 Cart";
static const char GBFlashItem2[] PROGMEM = "CFI Cart";
static const char GBFlashItem3[] PROGMEM = "CFI Cart and Save";
static const char GBFlashItem4[] PROGMEM = "GB Smart";
static const char* const menuOptionsGBFlash[] PROGMEM = { GBFlashItem1, GBFlashItem2, GBFlashItem3, GBFlashItem4, FSTRING_RESET };

// 29F Flash items
static const char GBFlash29Item1[] PROGMEM = "DIY MBC3 (WR)";
static const char GBFlash29Item2[] PROGMEM = "DIY MBC5 (WR)";
static const char GBFlash29Item3[] PROGMEM = "HDR MBC30 (Audio)";
static const char GBFlash29Item4[] PROGMEM = "HDR GameBoy Cam";
static const char* const menuOptionsGBFlash29[] PROGMEM = { GBFlash29Item1, GBFlash29Item2, GBFlash29Item3, GBFlash29Item4, FSTRING_RESET };

// Pelican Codebreaker, Brainboy, and Monster Brain Operation Menu
static const char PelicanRead[] PROGMEM = "Read Device";
static const char PelicanWrite[] PROGMEM = "Write Device";
static const char* const menuOptionsGBPelican[] PROGMEM = { PelicanRead, PelicanWrite };

// Datel Device Operation Menu
static const char MegaMemRead[] PROGMEM = "Read Mega Memory";
static const char MegaMemWrite[] PROGMEM = "Write Mega Memory";
static const char GameSharkRead[] PROGMEM = "Read GBC GameShark";
static const char GameSharkWrite[] PROGMEM = "Write GBC GameShark";
static const char* const menuOptionsGBDatel[] PROGMEM = { MegaMemRead, MegaMemWrite, GameSharkRead, GameSharkWrite };

bool gbxFlashCFI() {
  // Flash CFI
  display_Clear();
  display_Update();
  setup_GB();
  mode = CORE_GB;

  // Change working dir to root
  sd.chdir("/");
  // Launch filebrowser
  filePath[0] = '\0';
  sd.chdir("/");
  fileBrowser(F("Select file"));
  display_Clear();
  identifyCFI_GB();
  if (!writeCFI_GB()) {
    display_Clear();
    println_Msg(F("Flashing failed, time out!"));
    // Prints string out of the common strings array either with or without newline
    print_STR(press_button_STR, 1);
    display_Update();
    return false;
  }
  return true;
}

// Start menu for both GB and GBA
void gbxMenu() {
  // create menu with title and 5 options to choose from
  unsigned char gbType;
  // Copy menuOptions out of progmem
  convertPgm(menuOptionsGBx, 7);
  gbType = question_box(F("Select Game Boy"), menuOptions, 7, 0);

  // wait for user choice to come back from the question box menu
  switch (gbType) {
    case 0:
      display_Clear();
      display_Update();
      setup_GB();
      mode = CORE_GB;
      break;

    case 1:
      display_Clear();
      display_Update();
      setup_GBA();
      mode = CORE_GBA;
      break;

    case 2:
      // create submenu with title and 5 options to choose from
      unsigned char gbFlash;
      // Copy menuOptions out of progmem
      convertPgm(menuOptionsGBFlash, 5);
      gbFlash = question_box(F("Select type"), menuOptions, 5, 0);

      // wait for user choice to come back from the question box menu
      switch (gbFlash) {
        case 0:
          //29F Menu
          // create submenu with title and 5 options to choose from
          unsigned char gbFlash29;
          // Copy menuOptions out of progmem
          convertPgm(menuOptionsGBFlash29, 5);
          gbFlash29 = question_box(F("Select MBC"), menuOptions, 5, 0);

          // wait for user choice to come back from the question box menu
          switch (gbFlash29) {
            case 0:
              //Flash MBC3
              display_Clear();
              display_Update();
              setup_GB();
              mode = CORE_GB;

              // Change working dir to root
              sd.chdir("/");
              //MBC3
              writeFlash29F_GB(3, 1);
              // Reset
              // Prints string out of the common strings array either with or without newline
              print_STR(press_button_STR, 1);
              display_Update();
              wait();
              resetArduino();
              break;

            case 1:
              //Flash MBC5
              display_Clear();
              display_Update();
              setup_GB();
              mode = CORE_GB;

              // Change working dir to root
              sd.chdir("/");
              //MBC5
              writeFlash29F_GB(5, 1);
              // Reset
              // Prints string out of the common strings array either with or without newline
              print_STR(press_button_STR, 1);
              display_Update();
              wait();
              resetArduino();
              break;

            case 2:
              //Also pulse Audio-In during writes
              display_Clear();
              display_Update();
              setup_GB();
              mode = CORE_GB;

              //Setup Audio-In(PH4) as Output
              DDRH |= (1 << 4);
              // Output a high signal on Audio-In(PH4)
              PORTH |= (1 << 4);
              //Tell writeByte_GB function to pulse Audio-In too
              audioWE = 1;

              // Change working dir to root
              sd.chdir("/");
              //MBC5
              writeFlash29F_GB(3, 1);
              // Reset
              // Prints string out of the common strings array either with or without newline
              print_STR(press_button_STR, 1);
              display_Update();
              wait();
              resetArduino();
              break;

            case 3:
              //Flash GB Camera
              display_Clear();
              display_Update();
              setup_GB();
              mode = CORE_GB;

              //Flash first bank with erase
              // Change working dir to root
              sd.chdir("/");
              //MBC3
              writeFlash29F_GB(3, 1);
              // Prints string out of the common strings array either with or without newline
              print_STR(press_button_STR, 1);
              display_Update();
              wait();

              display_Clear();
              println_Msg(F("Please change the"));
              println_Msg(F("switch on the cart"));
              println_Msg(F("to B2 (Bank 2)"));
              println_Msg(F("if you want to flash"));
              println_Msg(F("a second game"));
              println_Msg(FS(FSTRING_EMPTY));
              // Prints string out of the common strings array either with or without newline
              print_STR(press_button_STR, 1);
              display_Update();
              wait();

              // Flash second bank without erase
              // Change working dir to root
              sd.chdir("/");
              //MBC3
              writeFlash29F_GB(3, 0);

              // Reset
              println_Msg(FS(FSTRING_EMPTY));
              // Prints string out of the common strings array either with or without newline
              print_STR(press_button_STR, 1);
              display_Update();
              wait();
              resetArduino();
              break;

            case 4:
              resetArduino();
              break;
          }
          break;

        case 1:
          // Flash CFI
          gbxFlashCFI();
          wait();
          resetArduino();
          break;

        case 2:
          // Flash CFI and save
          if (!gbxFlashCFI()) {
            wait();
            resetArduino();
          }
          getCartInfo_GB();
          // Does cartridge have SRAM
          if (lastByte > 0) {
            // Remove file name ending
            int pos = -1;
            while (fileName[++pos] != '\0') {
              if (fileName[pos] == '.') {
                fileName[pos] = '\0';
                break;
              }
            }
            sprintf(filePath, "/GB/SAVE/%s/", fileName);
            bool saveFound = false;
            if (sd.exists(filePath)) {
              EEPROM_readAnything(0, foldern);
              for (int i = foldern; i >= 0; i--) {
                sprintf(filePath, "/GB/SAVE/%s/%d/%s.SAV", fileName, i, fileName);
                if (sd.exists(filePath)) {
                  print_Msg(F("Save number "));
                  print_Msg(i);
                  println_Msg(F(" found."));
                  saveFound = true;
                  sprintf(filePath, "/GB/SAVE/%s/%d", fileName, i);
                  sprintf(fileName, "%s.SAV", fileName);
                  writeSRAM_GB();
                  unsigned long wrErrors;
                  wrErrors = verifySRAM_GB();
                  if (wrErrors == 0) {
                    println_Msg(F("Verified OK"));
                    display_Update();
                  } else {
                    print_STR(error_STR, 0);
                    print_Msg(wrErrors);
                    print_STR(_bytes_STR, 1);
                    print_Error(did_not_verify_STR);
                  }
                  break;
                }
              }
            }
            if (!saveFound) {
              println_Msg(F("Error: No save found."));
            }
          } else {
            print_Error(F("Cart has no Sram"));
          }
          // Reset
          wait();
          resetArduino();
          break;

        case 3:
          // Flash GB Smart
          display_Clear();
          display_Update();
          setup_GBSmart();
          mode = CORE_GB_GBSMART;
          break;

        case 4:
          resetArduino();
          break;
      }
      break;

    case 3:
      // Flash GB Memory
      display_Clear();
      display_Update();
      setup_GBM();
      mode = CORE_GBM;
      break;

    case 4:
      // Read or Write a Pelican Codebreaker or MonsterBrain
      // Set Address Pins to Output
      //A0-A7
      DDRF = 0xFF;
      //A8-A15
      DDRK = 0xFF;

      // Set Control Pins to Output RST(PH0) CLK(PH1) CS(PH3) WR(PH5) RD(PH6)
      DDRH |= (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 6);
      // Output a high signal on all pins, pins are active low therefore everything is disabled now
      PORTH |= (1 << 3) | (1 << 5) | (1 << 6);
      // Output a low signal on CLK(PH1) to disable writing GB Camera RAM
      // Output a low signal on RST(PH0) to initialize MMC correctly
      PORTH &= ~((1 << 0) | (1 << 1));

      // Set Data Pins (D0-D7) to Input
      DDRC = 0x00;
      // Enable Internal Pullups
      PORTC = 0xFF;

      delay(400);

      // RST(PH0) to H
      PORTH |= (1 << 0);
      mode = CORE_GB;
      display_Clear();
      display_Update();
      unsigned char gbPelican;
      // Copy menuOptions out of progmem
      convertPgm(menuOptionsGBPelican, 2);
      gbPelican = question_box(F("Select operation:"), menuOptions, 2, 0);

      // wait for user choice to come back from the question box menu
      switch (gbPelican) {
        case 0:
          readPelican_GB();
          // Reset
          // Prints string out of the common strings array either with or without newline
          print_STR(press_button_STR, 1);
          display_Update();
          wait();
          resetArduino();
          break;

        case 1:
          writePelican_GB();
          // Reset
          // Prints string out of the common strings array either with or without newline
          print_STR(press_button_STR, 1);
          display_Update();
          wait();
          resetArduino();
          break;
      }
      break;

    case 5:
      // Read or Write a Datel Device (Mega Memory Card and Gameshark)
      // Set Address Pins to Output
      //A0-A7
      DDRF = 0xFF;
      //A8-A15
      DDRK = 0xFF;

      // Set Control Pins to Output RST(PH0) CLK(PH1) CS(PH3) WR(PH5) RD(PH6)
      DDRH |= (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 6);
      // Output a high signal on all pins, pins are active low therefore everything is disabled now
      PORTH |= (1 << 3) | (1 << 5) | (1 << 6);
      // Output a low signal on CLK(PH1) to disable writing GB Camera RAM
      // Output a low signal on RST(PH0) to initialize MMC correctly
      PORTH &= ~((1 << 0) | (1 << 1));

      // Set Data Pins (D0-D7) to Input
      DDRC = 0x00;
      // Enable Internal Pullups
      PORTC = 0xFF;

      delay(400);

      // RST(PH0) to H
      PORTH |= (1 << 0);
      mode = CORE_GB;
      display_Clear();
      display_Update();
      unsigned char gbDatel;
      // Copy menuOptions out of progmem
      convertPgm(menuOptionsGBDatel, 4);
      gbDatel = question_box(F("Select operation:"), menuOptions, 4, 0);

      // wait for user choice to come back from the question box menu
      switch (gbDatel) {
        case 0:
          readMegaMem_GB();
          // Reset
          // Prints string out of the common strings array either with or without newline
          print_STR(press_button_STR, 1);
          display_Update();
          wait();
          resetArduino();
          break;

        case 1:
          writeMegaMem_GB();
          // Reset
          // Prints string out of the common strings array either with or without newline
          print_STR(press_button_STR, 1);
          display_Update();
          wait();
          resetArduino();
          break;

        case 2:
          readGameshark_GB();
          // Reset
          // Prints string out of the common strings array either with or without newline
          print_STR(press_button_STR, 1);
          display_Update();
          wait();
          resetArduino();
          break;

        case 3:
          writeGameshark_GB();
          // Reset
          // Prints string out of the common strings array either with or without newline
          print_STR(press_button_STR, 1);
          display_Update();
          wait();
          resetArduino();
          break;
      }
      break;

    case 6:
      resetArduino();
      break;
  }
}

void gbMenu() {
  // create menu with title and 4 options to choose from
  unsigned char mainMenu;
  // Copy menuOptions out of progmem
  convertPgm(menuOptionsGB, 4);
  mainMenu = question_box(F("GB Cart Reader"), menuOptions, 4, 0);

  // wait for user choice to come back from the question box menu
  switch (mainMenu) {
    case 0:
      display_Clear();
      // Change working dir to root
      sd.chdir("/");
      readROM_GB();
      compare_checksums_GB();
#ifdef ENABLE_GLOBAL_LOG
      save_log();
#endif
      break;

    case 1:
      display_Clear();
      // Does cartridge have SRAM
      if (lastByte > 0) {
        // Change working dir to root
        sd.chdir("/");
        if (romType == 32)
          readSRAMFLASH_MBC6_GB();
        else if (romType == 34)
          readEEPROM_MBC7_GB();
        else
          readSRAM_GB();
      } else {
        print_Error(F("No save or unsupported type"));
      }
      println_Msg(FS(FSTRING_EMPTY));
      break;

    case 2:
      display_Clear();
      // Does cartridge have SRAM
      if (lastByte > 0) {
        // Change working dir to root
        sd.chdir("/");
        filePath[0] = '\0';
        fileBrowser(F("Select sav file"));

        if (romType == 32)
          writeSRAMFLASH_MBC6_GB();
        else if (romType == 34)
          writeEEPROM_MBC7_GB();
        else {
          writeSRAM_GB();
          unsigned long wrErrors;
          wrErrors = verifySRAM_GB();
          if (wrErrors == 0) {
            println_Msg(F("Verified OK"));
            display_Update();
          } else {
            print_STR(error_STR, 0);
            print_Msg(wrErrors);
            print_STR(_bytes_STR, 1);
            print_Error(did_not_verify_STR);
          }
        }
      } else {
        print_Error(F("No save or unsupported type"));
      }
      println_Msg(FS(FSTRING_EMPTY));
      break;

    case 3:
      resetArduino();
      break;
  }
  // Prints string out of the common strings array either with or without newline
  print_STR(press_button_STR, 1);
  display_Update();
  wait();
}

/******************************************
   Setup
 *****************************************/
void setup_GB() {
  // Request 5V
  setVoltage(VOLTS_SET_5V);

  // Set Address Pins to Output
  //A0-A7
  DDRF = 0xFF;
  //A8-A15
  DDRK = 0xFF;

  // Set Control Pins to Output RST(PH0) CLK(PH1) CS(PH3) WR(PH5) RD(PH6)
  DDRH |= (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 6);
  // Output a high signal on all pins, pins are active low therefore everything is disabled now
  PORTH |= (1 << 3) | (1 << 5) | (1 << 6);
  // Output a low signal on CLK(PH1) to disable writing GB Camera RAM
  // Output a low signal on RST(PH0) to initialize MMC correctly
  PORTH &= ~((1 << 0) | (1 << 1));

  // Set Audio-In(PH4) to Input
  DDRH &= ~(1 << 4);
  // Enable Internal Pullup
  PORTH |= (1 << 4);

  // Set Data Pins (D0-D7) to Input
  DDRC = 0x00;
  // Enable Internal Pullups
  PORTC = 0xFF;

  delay(400);

  // RST(PH0) to HIGH
  PORTH |= (1 << 0);

  // Print start page
  getCartInfo_GB();
  showCartInfo_GB();

  // MMM01 initialize
  if (romType >= 11 && romType <= 13) {
    writeByte_GB(0x3fff, 0x00);
    writeByte_GB(0x5fff, 0x40);
    writeByte_GB(0x7fff, 0x01);
    writeByte_GB(0x1fff, 0x3a);
    writeByte_GB(0x1fff, 0x7a);
  }
}

void showCartInfo_GB() {
  display_Clear();
  if (strcmp(checksumStr, "00") != 0) {
    print_Msg(F("Title: "));
    println_Msg(romName);
    if (cartID[0] != 0) {
      print_Msg(F("Serial: "));
      println_Msg(cartID);
    }
    print_Msg(F("Revision: "));
    println_Msg(romVersion);

    print_Msg(F("Mapper: "));
    if ((romType == 0) || (romType == 8) || (romType == 9))
      print_Msg(F("none"));
    else if ((romType == 1) || (romType == 2) || (romType == 3))
      print_Msg(F("MBC1"));
    else if ((romType == 5) || (romType == 6))
      print_Msg(F("MBC2"));
    else if ((romType == 11) || (romType == 12) || (romType == 13))
      print_Msg(F("MMM01"));
    else if ((romType == 15) || (romType == 16) || (romType == 17) || (romType == 18) || (romType == 19))
      print_Msg(F("MBC3"));
    else if ((romType == 21) || (romType == 22) || (romType == 23))
      print_Msg(F("MBC4"));
    else if ((romType == 25) || (romType == 26) || (romType == 27) || (romType == 28) || (romType == 29) || (romType == 309))
      print_Msg(F("MBC5"));
    else if (romType == 32)
      print_Msg(F("MBC6"));
    else if (romType == 34)
      print_Msg(F("MBC7"));
    else if (romType == 252)
      print_Msg(F("Camera"));
    else if (romType == 253)
      print_Msg(F("TAMA5"));
    else if (romType == 254)
      print_Msg(F("HuC-3"));
    else if (romType == 255)
      print_Msg(F("HuC-1"));
    else if ((romType == 0x101) || (romType == 0x103))
      print_Msg(F("MBC1M"));
    else if (romType == 0x104)
      print_Msg(F("M161"));

    println_Msg(FS(FSTRING_EMPTY));
    print_Msg(F("ROM Size: "));
    switch (romSize) {
      case 0:
        print_Msg(F("32 KB"));
        break;

      case 1:
        print_Msg(F("64 KB"));
        break;

      case 2:
        print_Msg(F("128 KB"));
        break;

      case 3:
        print_Msg(F("256 KB"));
        break;

      case 4:
        print_Msg(F("512 KB"));
        break;

      case 5:
        print_Msg(F("1 MB"));
        break;

      case 6:
        print_Msg(F("2 MB"));
        break;

      case 7:
        print_Msg(F("4 MB"));
        break;

      case 8:
        print_Msg(F("8 MB"));
        break;
    }

    println_Msg(FS(FSTRING_EMPTY));
    //print_Msg(F("Banks: "));
    //println_Msg(romBanks);

    print_Msg(F("Save Size: "));
    switch (sramSize) {
      case 0:
        if (romType == 6) {
          print_Msg(F("512 Byte"));
        } else if (romType == 0x22) {
          print_Msg(lastByte);
          print_Msg(F(" Byte"));
        } else if (romType == 0xFD) {
          print_Msg(F("32 Byte"));
        } else {
          print_Msg(F("None"));
        }
        break;
      case 1:
        print_Msg(F("2 KB"));
        break;

      case 2:
        print_Msg(F("8 KB"));
        break;

      case 3:
        if (romType == 0x20) {
          print_Msg(F("1.03 MB"));
        } else {
          print_Msg(F("32 KB"));
        }
        break;

      case 4:
        print_Msg(F("128 KB"));
        break;

      case 5:
        print_Msg(F("64 KB"));
        break;

      default: print_Msg(F("None"));
    }
    println_Msg(FS(FSTRING_EMPTY));
    //print_Msg(F("Checksum: "));
    //println_Msg(checksumStr);
    //display_Update();

    // Wait for user input
    println_Msg(FS(FSTRING_EMPTY));
    // Prints string out of the common strings array either with or without newline
    print_STR(press_button_STR, 1);
    display_Update();
    wait();
  } else {
    print_FatalError(F("GAMEPAK ERROR"));
  }
}

/******************************************
  Low level functions
*****************************************/
byte readByte_GB(word myAddress) {
  // Set address
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  // Switch data pins to input
  DDRC = 0x00;
  // Enable pullups
  PORTC = 0xFF;

  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  // Switch RD(PH6) to LOW
  PORTH &= ~(1 << 6);

  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  // Read
  byte tempByte = PINC;

  // Switch and RD(PH6) to HIGH
  PORTH |= (1 << 6);

  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  return tempByte;
}

void writeByte_GB(int myAddress, byte myData) {
  // Set address
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  // Set data
  PORTC = myData;
  // Switch data pins to output
  DDRC = 0xFF;

  // Wait till output is stable
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  if (audioWE)
    // Pull Audio-In(PH4) low
    PORTH &= ~(1 << 4);
  // Pull WR(PH5) low
  PORTH &= ~(1 << 5);

  // Leave WR low for at least 60ns
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  if (audioWE)
    // Pull Audio-In(PH4) HIGH
    PORTH |= (1 << 4);
  // Pull WR(PH5) HIGH
  PORTH |= (1 << 5);

  // Leave WR high for at least 50ns
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  // Switch data pins to input
  DDRC = 0x00;
  // Enable pullups
  PORTC = 0xFF;
}

// Triggers CS and CLK pin
byte readByteSRAM_GB(word myAddress) {
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  // Switch data pins to input
  DDRC = 0x00;
  // Enable pullups
  PORTC = 0xFF;

  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  // Pull CS(PH3) CLK(PH1)(for FRAM MOD) LOW
  PORTH &= ~((1 << 3) | (1 << 1));
  // Pull RD(PH6) LOW
  PORTH &= ~(1 << 6);

  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  // Read
  byte tempByte = PINC;

  // Pull RD(PH6) HIGH
  PORTH |= (1 << 6);
  if (romType == 252) {
    // Pull CS(PH3) HIGH
    PORTH |= (1 << 3);
  } else {
    // Pull CS(PH3) CLK(PH1)(for FRAM MOD) HIGH
    PORTH |= (1 << 3) | (1 << 1);
  }
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  return tempByte;
}

// Triggers CS and CLK pin
void writeByteSRAM_GB(int myAddress, byte myData) {
  // Set address
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  // Set data
  PORTC = myData;
  // Switch data pins to output
  DDRC = 0xFF;

  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  if (romType == 252 || romType == 253) {
    // Pull CS(PH3) LOW
    PORTH &= ~(1 << 3);
    // Pull CLK(PH1)(for GB CAM) HIGH
    PORTH |= (1 << 1);
    // Pull WR(PH5) low
    PORTH &= ~(1 << 5);
  } else {
    // Pull CS(PH3) CLK(PH1)(for FRAM MOD) LOW
    PORTH &= ~((1 << 3) | (1 << 1));
    // Pull WR(PH5) low
    PORTH &= ~(1 << 5);
  }

  // Leave WR low for at least 60ns
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  if (romType == 252 || romType == 253) {
    // Pull WR(PH5) HIGH
    PORTH |= (1 << 5);
    // Pull CS(PH3) HIGH
    PORTH |= (1 << 3);
    // Pull  CLK(PH1) LOW (for GB CAM)
    PORTH &= ~(1 << 1);
  } else {
    // Pull WR(PH5) HIGH
    PORTH |= (1 << 5);
    // Pull CS(PH3) CLK(PH1)(for FRAM MOD) HIGH
    PORTH |= (1 << 3) | (1 << 1);
  }

  // Leave WR high for at least 50ns
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  // Switch data pins to input
  DDRC = 0x00;
  // Enable pullups
  PORTC = 0xFF;
}

/******************************************
  Game Boy functions
*****************************************/
// Read Cartridge Header
void getCartInfo_GB() {
  // Read Header into array
  for (int currByte = 0x100; currByte < 0x150; currByte++) {
    sdBuffer[currByte] = readByte_GB(currByte);
  }

  /* Compare Nintendo logo against known checksum, 156 bytes starting at 0x04
    word logoChecksum = 0;
    for (int currByte = 0x104; currByte < 0x134; currByte++) {
    logoChecksum += sdBuffer[currByte];
    }

    if (logoChecksum != 0x1546) {
    print_Error(F("STARTUP LOGO ERROR"));
    println_Msg(FS(FSTRING_EMPTY));
    println_Msg(FS(FSTRING_EMPTY));
    println_Msg(FS(FSTRING_EMPTY));
    println_Msg(F("Press Button to"));
    println_Msg(F("ignore or powercycle"));
    println_Msg(F("to try again"));
    display_Update();
    wait();
    }
  */

  // Calculate header checksum
  byte headerChecksum = 0;
  for (int currByte = 0x134; currByte < 0x14D; currByte++) {
    headerChecksum = headerChecksum - sdBuffer[currByte] - 1;
  }

  if (headerChecksum != sdBuffer[0x14D]) {
    // Read Header into array a second time
    for (int currByte = 0x100; currByte < 0x150; currByte++) {
      sdBuffer[currByte] = readByte_GB(currByte);
    }
    // Calculate header checksum a second time
    headerChecksum = 0;
    for (int currByte = 0x134; currByte < 0x14D; currByte++) {
      headerChecksum = headerChecksum - sdBuffer[currByte] - 1;
    }
  }

  if (headerChecksum != sdBuffer[0x14D]) {
    print_Error(F("HEADER CHECKSUM ERROR"));
    println_Msg(FS(FSTRING_EMPTY));
    println_Msg(FS(FSTRING_EMPTY));
    println_Msg(FS(FSTRING_EMPTY));
    println_Msg(F("Press Button to"));
    println_Msg(F("ignore or clean"));
    println_Msg(F("cart and try again"));
    display_Update();
    wait();
  }

  romType = sdBuffer[0x147];
  romSize = sdBuffer[0x148];
  sramSize = sdBuffer[0x149];

  // Get Checksum as string
  eepbit[6] = sdBuffer[0x14E];
  eepbit[7] = sdBuffer[0x14F];
  sprintf(checksumStr, "%02X%02X", eepbit[6], eepbit[7]);

  // ROM banks
  romBanks = 2;
  if (romSize >= 0x01 && romSize <= 0x08) {
    romBanks = int_pow(2, romSize + 1);
  }

  // SRAM banks
  sramBanks = 0;
  if (romType == 6) {
    sramBanks = 1;
  }

  // SRAM size
  switch (sramSize) {
    case 2:
      sramBanks = 1;
      break;
    case 3:
      sramBanks = 4;
      break;
    case 4:
      sramBanks = 16;
      break;
    case 5:
      sramBanks = 8;
      break;
  }

  // Last byte of SRAM
  if (romType == 6) {
    lastByte = 0xA1FF;
  }
  if (sramSize == 1) {
    lastByte = 0xA7FF;
  } else if (sramSize > 1) {
    lastByte = 0xBFFF;
  }

  // MBC6
  if (romType == 32) {
    sramBanks = 8;
    lastByte = 0xAFFF;
  } else if (romType == 34) {                                       // MBC7
    lastByte = (*((uint16_t*)(eepbit + 6)) == 0xa5be ? 512 : 256);  // Only "Command Master" use LC66 EEPROM
  }

  // Get name
  byte myByte = 0;
  byte myLength = 0;
  byte x = 0;
  if (sdBuffer[0x143] == 0x80 || sdBuffer[0x143] == 0xC0) {
    x++;
  }
  for (int addr = 0x0134; addr <= 0x0143 - x; addr++) {
    myByte = sdBuffer[addr];
    if (isprint(myByte) && myByte != '<' && myByte != '>' && myByte != ':' && myByte != '"' && myByte != '/' && myByte != '\\' && myByte != '|' && myByte != '?' && myByte != '*') {
      romName[myLength++] = char(myByte);
    } else if (myLength == 0 || romName[myLength - 1] != '_') {
      romName[myLength++] = '_';
    }
  }

  // Find Game Serial
  cartID[0] = 0;
  if (sdBuffer[0x143] == 0x80 || sdBuffer[0x143] == 0xC0) {
    if ((romName[myLength - 4] == 'A' || romName[myLength - 4] == 'B' || romName[myLength - 4] == 'H' || romName[myLength - 4] == 'K' || romName[myLength - 4] == 'V') && (romName[myLength - 1] == 'A' || romName[myLength - 1] == 'B' || romName[myLength - 1] == 'D' || romName[myLength - 1] == 'E' || romName[myLength - 1] == 'F' || romName[myLength - 1] == 'I' || romName[myLength - 1] == 'J' || romName[myLength - 1] == 'K' || romName[myLength - 1] == 'P' || romName[myLength - 1] == 'S' || romName[myLength - 1] == 'U' || romName[myLength - 1] == 'X' || romName[myLength - 1] == 'Y')) {
      cartID[0] = romName[myLength - 4];
      cartID[1] = romName[myLength - 3];
      cartID[2] = romName[myLength - 2];
      cartID[3] = romName[myLength - 1];
      myLength -= 4;
      romName[myLength] = 0;
    }
  }

  // Strip trailing white space
  while (
    myLength && (romName[myLength - 1] == '_' || romName[myLength - 1] == ' ')) {
    myLength--;
  }
  romName[myLength] = 0;

  // M161 (Mani 4 in 1)
  if (strncmp(romName, "TETRIS SET", 10) == 0 && sdBuffer[0x14D] == 0x3F) {
    romType = 0x104;
  }

  // MMM01 (Mani 4 in 1)
  if (
    (
      strncmp(romName, "BOUKENJIMA2 SET", 15) == 0 && sdBuffer[0x14D] == 0)
    || (strncmp(romName, "BUBBLEBOBBLE SET", 16) == 0 && sdBuffer[0x14D] == 0xC6) || (strncmp(romName, "GANBARUGA SET", 13) == 0 && sdBuffer[0x14D] == 0x90) || (strncmp(romName, "RTYPE 2 SET", 11) == 0 && sdBuffer[0x14D] == 0x32)) {
    romType = 0x0B;
  }

  // MBC1M
  if (
    (
      strncmp(romName, "MOMOCOL", 7) == 0 && sdBuffer[0x14D] == 0x28)
    || (strncmp(romName, "BOMCOL", 6) == 0 && sdBuffer[0x14D] == 0x86) || (strncmp(romName, "GENCOL", 6) == 0 && sdBuffer[0x14D] == 0x8A) || (strncmp(romName, "SUPERCHINESE 123", 16) == 0 && sdBuffer[0x14D] == 0xE4) || (strncmp(romName, "MORTALKOMBATI&II", 16) == 0 && sdBuffer[0x14D] == 0xB9) || (strncmp(romName, "MORTALKOMBAT DUO", 16) == 0 && sdBuffer[0x14D] == 0xA7)) {
    romType += 0x100;
  }

  // ROM revision
  romVersion = sdBuffer[0x14C];
}

/******************************************
  ROM functions
*****************************************/
// Read ROM
void readROM_GB() {
  // Get name, add extension and convert to char array for sd lib
  createFolderAndOpenFile("GB", "ROM", romName, "gb");

  word endAddress = 0x7FFF;
  word romAddress = 0;
  word startBank = 1;

  //Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)(romBanks)*16384;
  draw_progressbar(0, totalProgressBar);

  // M161 banks are double size and start with 0
  if (romType == 0x104) {
    startBank = 0;
    romBanks >>= 1;
    endAddress = 0x7FFF;
  }
  // MBC6 banks are half size
  else if (romType == 32) {
    romBanks <<= 1;
    endAddress = 0x3FFF;
  }

  for (word currBank = startBank; currBank < romBanks; currBank++) {
    // Second bank starts at 0x4000
    if (currBank > 1) {
      romAddress = 0x4000;

      // MBC6 banks are half size
      if (romType == 32) {
        endAddress = 0x5FFF;
      }
    }

    // Set ROM bank for M161
    if (romType == 0x104) {
      romAddress = 0;
      PORTH &= ~(1 << 0);
      delay(50);
      PORTH |= (1 << 0);
      writeByte_GB(0x4000, currBank & 0x7);
    }

    // Set ROM bank for MBC1M
    else if (romType == 0x101 || romType == 0x103) {
      if (currBank < 10) {
        writeByte_GB(0x4000, currBank >> 4);
        writeByte_GB(0x2000, (currBank & 0x1f));
      } else {
        writeByte_GB(0x4000, currBank >> 4);
        writeByte_GB(0x2000, 0x10 | (currBank & 0x1f));
      }
    }

    // Set ROM bank for MBC6
    else if (romType == 32) {
      writeByte_GB(0x2800, 0);
      writeByte_GB(0x3800, 0);
      writeByte_GB(0x2000, currBank);
      writeByte_GB(0x3000, currBank);
    }

    // Set ROM bank for TAMA5
    else if (romType == 0xFD) {
      writeByteSRAM_GB(0xA001, 0);
      writeByteSRAM_GB(0xA000, currBank & 0x0f);
      writeByteSRAM_GB(0xA001, 1);
      writeByteSRAM_GB(0xA000, (currBank >> 4) & 0x0f);
    }

    // Set ROM bank for MBC2/3/4/5
    else if (romType >= 5) {
      if (romType >= 11 && romType <= 13) {
        if ((currBank & 0x1f) == 0) {
          // reset MMM01
          PORTH &= ~(1 << 0);
          PORTH |= (1 << 0);

          // remap to higher 4Mbits ROM
          writeByte_GB(0x3fff, 0x20);
          writeByte_GB(0x5fff, 0x40);
          writeByte_GB(0x7fff, 0x01);
          writeByte_GB(0x1fff, 0x3a);
          writeByte_GB(0x1fff, 0x7a);

          // for every 4Mbits ROM, restart from 0x0000
          romAddress = 0x0000;
          currBank++;
        } else {
          writeByte_GB(0x6000, 0);
          writeByte_GB(0x2000, (currBank & 0x1f));
        }
      } else {
        if ((romType >= 0x19 && romType <= 0x1E) && (currBank == 0 || currBank == 256)) {
          writeByte_GB(0x3000, (currBank >> 8) & 0xFF);
        }
        writeByte_GB(0x2100, currBank & 0xFF);
      }
    }
    // Set ROM bank for MBC1
    else {
      writeByte_GB(0x6000, 0);
      writeByte_GB(0x4000, currBank >> 5);
      writeByte_GB(0x2000, currBank & 0x1F);
    }

    // Read banks and save to SD
    while (romAddress <= endAddress) {
      for (int i = 0; i < 512; i++) {
        sdBuffer[i] = readByte_GB(romAddress + i);
      }
      myFile.write(sdBuffer, 512);
      romAddress += 512;
      processedProgressBar += 512;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }

  // Close the file:
  myFile.close();
}

// Calculate checksum
unsigned int calc_checksum_GB(char* fileName) {
  unsigned int calcChecksum = 0;
  //  int calcFilesize = 0; // unused
  unsigned long i = 0;
  int c = 0;

  // If file exists
  if (myFile.open(fileName, O_READ)) {
    //calcFilesize = myFile.fileSize() * 8 / 1024 / 1024; // unused
    for (i = 0; i < (myFile.fileSize() / 512); i++) {
      myFile.read(sdBuffer, 512);
      for (c = 0; c < 512; c++) {
        calcChecksum += sdBuffer[c];
      }
    }
    myFile.close();
    // Subtract checksum bytes
    calcChecksum -= eepbit[6];
    calcChecksum -= eepbit[7];

    // Return result
    return (calcChecksum);
  }
  // Else show error
  else {
    print_Error(F("DUMP ROM 1ST"));
    return 0;
  }
}

// Compare checksum
void compare_checksums_GB() {
  strcpy(fileName, romName);
  strcat(fileName, ".GB");

  // last used rom folder
  EEPROM_readAnything(0, foldern);
  sprintf(folder, "GB/ROM/%s/%d", romName, foldern - 1);

  if (strcmp(folder, "root") != 0)
    sd.chdir(folder);

  // Internal ROM checksum
  char calcsumStr[5];
  sprintf(calcsumStr, "%04X", calc_checksum_GB(fileName));

  print_Msg(F("Checksum: "));
  print_Msg(calcsumStr);
  if (strcmp(calcsumStr, checksumStr) == 0) {
    println_Msg(F(" -> OK"));
  } else {
    print_Msg(F(" != "));
    println_Msg(checksumStr);
    print_Error(F("Invalid Checksum"));
  }
  compareCRC("gb.txt", 0, 1, 0);
  display_Update();
  //go to root
  sd.chdir();
}

/******************************************
  SRAM functions
*****************************************/
// Read RAM
void readSRAM_GB() {
  // Does cartridge have RAM
  if (lastByte > 0) {

    // Get name, add extension and convert to char array for sd lib
    createFolder("GB", "SAVE", romName, "sav");

    // write new folder number back to eeprom
    foldern = foldern + 1;
    EEPROM_writeAnything(0, foldern);

    //open file on sd card
    if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
      print_FatalError(sd_error_STR);
    }

    // MBC2 Fix
    readByte_GB(0x0134);

    if (romType <= 4 || (romType >= 11 && romType <= 13)) {
      writeByte_GB(0x6000, 1);
    }

    // Initialise MBC
    writeByte_GB(0x0000, 0x0A);

    // Switch SRAM banks
    for (byte currBank = 0; currBank < sramBanks; currBank++) {
      writeByte_GB(0x4000, currBank);

      // Read SRAM
      for (word sramAddress = 0xA000; sramAddress <= lastByte; sramAddress += 64) {
        for (byte i = 0; i < 64; i++) {
          sdBuffer[i] = readByteSRAM_GB(sramAddress + i);
        }
        myFile.write(sdBuffer, 64);
      }
    }

    // Disable SRAM
    writeByte_GB(0x0000, 0x00);

    // Close the file:
    myFile.close();

    // Signal end of process
    print_Msg(F("Saved to "));
    print_Msg(folder);
    println_Msg(F("/"));
    display_Update();
  } else {
    print_Error(F("Cart has no SRAM"));
  }
}

// Write RAM
void writeSRAM_GB() {
  // Does cartridge have SRAM
  if (lastByte > 0) {
    // Create filepath
    sprintf(filePath, "%s/%s", filePath, fileName);

    //open file on sd card
    if (myFile.open(filePath, O_READ)) {
      // MBC2 Fix
      readByte_GB(0x0134);

      // Enable SRAM for MBC1
      if (romType <= 4 || (romType >= 11 && romType <= 13)) {
        writeByte_GB(0x6000, 1);
      }

      // Initialise MBC
      writeByte_GB(0x0000, 0x0A);

      // Switch RAM banks
      for (byte currBank = 0; currBank < sramBanks; currBank++) {
        writeByte_GB(0x4000, currBank);

        // Write RAM
        for (word sramAddress = 0xA000; sramAddress <= lastByte; sramAddress++) {
          writeByteSRAM_GB(sramAddress, myFile.read());
        }
      }
      // Disable SRAM
      writeByte_GB(0x0000, 0x00);

      // Close the file:
      myFile.close();
      display_Clear();
      println_Msg(F("SRAM writing finished"));
      display_Update();

    } else {
      print_Error(FS(FSTRING_FILE_DOESNT_EXIST));
    }
  } else {
    print_Error(F("Cart has no SRAM"));
  }
}

// Check if the SRAM was written without any error
unsigned long verifySRAM_GB() {

  //open file on sd card
  if (myFile.open(filePath, O_READ)) {

    // Variable for errors
    writeErrors = 0;

    // MBC2 Fix
    readByte_GB(0x0134);

    // Check SRAM size
    if (lastByte > 0) {
      if (romType <= 4) {         // MBC1
        writeByte_GB(0x6000, 1);  // Set RAM Mode
      }

      // Initialise MBC
      writeByte_GB(0x0000, 0x0A);

      // Switch SRAM banks
      for (byte currBank = 0; currBank < sramBanks; currBank++) {
        writeByte_GB(0x4000, currBank);

        // Read SRAM
        for (word sramAddress = 0xA000; sramAddress <= lastByte; sramAddress += 64) {
          //fill sdBuffer
          myFile.read(sdBuffer, 64);
          for (int c = 0; c < 64; c++) {
            if (readByteSRAM_GB(sramAddress + c) != sdBuffer[c]) {
              writeErrors++;
            }
          }
        }
      }
      // Disable RAM
      writeByte_GB(0x0000, 0x00);
    }
    // Close the file:
    myFile.close();
    return writeErrors;
  } else {
    print_FatalError(open_file_STR);
    return 1;
  }
}

// Read SRAM + FLASH save data of MBC6
void readSRAMFLASH_MBC6_GB() {
  // Get name, add extension and convert to char array for sd lib
  createFolderAndOpenFile("GB", "SAVE", romName, "sav");

  //Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = 0x108000;
  draw_progressbar(0, totalProgressBar);

  // Enable Mapper and SRAM
  writeByte_GB(0x0000, 0x0A);

  // Switch SRAM banks
  for (byte currBank = 0; currBank < sramBanks; currBank++) {
    writeByte_GB(0x0400, currBank);
    writeByte_GB(0x0800, currBank);

    // Read SRAM
    for (word sramAddress = 0xA000; sramAddress <= lastByte; sramAddress += 64) {
      for (byte i = 0; i < 64; i++) {
        sdBuffer[i] = readByteSRAM_GB(sramAddress + i);
      }
      myFile.write(sdBuffer, 64);
      processedProgressBar += 64;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }

  // Disable SRAM
  writeByte_GB(0x0000, 0x00);

  // Enable flash save memory (map to ROM)
  writeByte_GB(0x1000, 0x01);
  writeByte_GB(0x0C00, 0x01);
  writeByte_GB(0x1000, 0x00);
  writeByte_GB(0x2800, 0x08);
  writeByte_GB(0x3800, 0x08);

  // Switch FLASH banks
  for (byte currBank = 0; currBank < 128; currBank++) {
    word romAddress = 0x4000;

    writeByte_GB(0x2000, currBank);
    writeByte_GB(0x3000, currBank);

    // Read banks and save to SD
    while (romAddress <= 0x5FFF) {
      for (int i = 0; i < 512; i++) {
        sdBuffer[i] = readByte_GB(romAddress + i);
      }
      myFile.write(sdBuffer, 512);
      romAddress += 512;
      processedProgressBar += 512;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }

  // Disable flash save memory
  writeByte_GB(0x1000, 0x01);
  writeByte_GB(0x0C00, 0x00);
  writeByte_GB(0x1000, 0x00);
  writeByte_GB(0x2800, 0x00);
  writeByte_GB(0x3800, 0x00);

  // Close the file:
  myFile.close();

  // Signal end of process
  println_Msg(FS(FSTRING_OK));
  display_Update();
}

// Write RAM
void writeSRAMFLASH_MBC6_GB() {
  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);

  //open file on sd card
  if (myFile.open(filePath, O_READ)) {
    display_Clear();
    println_Msg(F("Writing MBC6 save..."));
    display_Update();

    //Initialize progress bar
    uint32_t processedProgressBar = 0;
    uint32_t totalProgressBar = 0x108000;
    draw_progressbar(0, totalProgressBar);

    // Enable Mapper and SRAM
    writeByte_GB(0x0000, 0x0A);

    // Switch SRAM banks
    for (byte currBank = 0; currBank < sramBanks; currBank++) {
      writeByte_GB(0x0400, currBank);
      writeByte_GB(0x0800, currBank);

      // Write SRAM
      for (word sramAddress = 0xA000; sramAddress <= lastByte; sramAddress++) {
        writeByteSRAM_GB(sramAddress, myFile.read());
      }

      processedProgressBar += (lastByte + 1) - 0xA000;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }

    // Disable SRAM
    writeByte_GB(0x0000, 0x00);

    // Enable flash save memory (map to ROM)
    writeByte_GB(0x1000, 0x01);
    writeByte_GB(0x0C00, 0x01);
    writeByte_GB(0x1000, 0x01);
    writeByte_GB(0x2800, 0x08);
    writeByte_GB(0x3800, 0x08);

    for (byte currBank = 0; currBank < 128; currBank++) {
      word romAddress = 0x4000;

      // Erase FLASH sector
      if (((processedProgressBar - 0x8000) % 0x20000) == 0) {
        writeByte_GB(0x2800, 0x08);
        writeByte_GB(0x3800, 0x08);
        writeByte_GB(0x2000, 0x01);
        writeByte_GB(0x3000, 0x02);
        writeByte_GB(0x7555, 0xAA);
        writeByte_GB(0x4AAA, 0x55);
        writeByte_GB(0x7555, 0x80);
        writeByte_GB(0x7555, 0xAA);
        writeByte_GB(0x4AAA, 0x55);
        writeByte_GB(0x2800, 0x08);
        writeByte_GB(0x3800, 0x08);
        writeByte_GB(0x2000, currBank);
        writeByte_GB(0x3000, currBank);
        writeByte_GB(0x4000, 0x30);
        byte lives = 100;
        while (1) {
          byte sr = readByte_GB(0x4000);
          if (sr == 0x80) break;
          delay(1);
          if (lives-- <= 0) {
            // Disable flash save memory
            writeByte_GB(0x1000, 0x01);
            writeByte_GB(0x0C00, 0x00);
            writeByte_GB(0x1000, 0x00);
            writeByte_GB(0x2800, 0x00);
            writeByte_GB(0x3800, 0x00);
            myFile.close();
            display_Clear();
            print_FatalError(F("Error erasing FLASH sector."));
          }
        }
      } else {
        writeByte_GB(0x2800, 0x08);
        writeByte_GB(0x3800, 0x08);
        writeByte_GB(0x2000, currBank);
        writeByte_GB(0x3000, currBank);
      }

      // Write to FLASH
      while (romAddress <= 0x5FFF) {
        writeByte_GB(0x2000, 0x01);
        writeByte_GB(0x3000, 0x02);
        writeByte_GB(0x7555, 0xAA);
        writeByte_GB(0x4AAA, 0x55);
        writeByte_GB(0x7555, 0xA0);
        writeByte_GB(0x2800, 0x08);
        writeByte_GB(0x3800, 0x08);
        writeByte_GB(0x2000, currBank);
        writeByte_GB(0x3000, currBank);
        for (int i = 0; i < 128; i++) {
          writeByte_GB(romAddress++, myFile.read());
        }
        writeByte_GB(romAddress - 1, 0x00);
        byte lives = 100;
        while (1) {
          byte sr = readByte_GB(romAddress - 1);
          if (sr == 0x80) break;
          delay(1);
          if (lives-- <= 0) {
            // Disable flash save memory
            writeByte_GB(0x1000, 0x01);
            writeByte_GB(0x0C00, 0x00);
            writeByte_GB(0x1000, 0x00);
            writeByte_GB(0x2800, 0x00);
            writeByte_GB(0x3800, 0x00);
            myFile.close();
            display_Clear();
            print_FatalError(F("Error writing to FLASH."));
          }
        }
        writeByte_GB(romAddress - 1, 0xF0);
        processedProgressBar += 128;
        draw_progressbar(processedProgressBar, totalProgressBar);
      }
    }

    // Disable flash save memory
    writeByte_GB(0x1000, 0x01);
    writeByte_GB(0x0C00, 0x00);
    writeByte_GB(0x1000, 0x00);
    writeByte_GB(0x2800, 0x00);
    writeByte_GB(0x3800, 0x00);

    // Close the file:
    myFile.close();
    println_Msg(F("Save writing finished"));
    display_Update();
  } else {
    print_Error(FS(FSTRING_FILE_DOESNT_EXIST));
  }
}

void readEEPROM_MBC7_GB() {

  // Get name, add extension and convert to char array for sd lib
  createFolder("GB", "SAVE", romName, "sav");

  // write new folder number back to eeprom
  foldern = foldern + 1;
  EEPROM_writeAnything(0, foldern);

  //open file on sd card
  if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
    print_FatalError(sd_error_STR);
  }

  display_Clear();
  print_STR(saving_to_STR, 0);
  print_Msg(folder);
  println_Msg(F("/..."));
  display_Update();

  uint16_t* data = (uint16_t*)sdBuffer;

  // enable 0xa000 - 0xbfff access
  writeByte_GB(0x0000, 0x0a);
  writeByte_GB(0x4000, 0x40);

  // set CS high
  writeByte_GB(0xa080, 0x00);
  writeByte_GB(0xa080, 0x80);

  sendMBC7EEPROM_Inst_GB(2, 0, 0);

  // read data from EEPROM
  for (uint16_t i = 0; i < lastByte; i += 2, data++) {
    *data = 0;

    for (uint8_t j = 0; j < 16; j++) {
      writeByte_GB(0xa080, 0x80);
      writeByte_GB(0xa080, 0xc0);

      *data <<= 1;
      *data |= (readByte_GB(0xa080) & 0x01);
    }
  }

  // deselect chip and ram access
  writeByte_GB(0xa080, 0x00);
  writeByte_GB(0x0000, 0x00);
  writeByte_GB(0x4000, 0x00);

  myFile.write(sdBuffer, lastByte);
  myFile.close();

  print_STR(done_STR, true);
  display_Update();
}

void writeEEPROM_MBC7_GB() {

  sprintf(filePath, "%s/%s", filePath, fileName);

  // open file on sd card
  if (!myFile.open(filePath, O_READ))
    print_Error(FS(FSTRING_FILE_DOESNT_EXIST));

  myFile.read(sdBuffer, lastByte);
  myFile.close();

  display_Clear();

  uint16_t* data = (uint16_t*)sdBuffer;

  // enable 0xa000 - 0xbfff access
  writeByte_GB(0x0000, 0x0a);
  writeByte_GB(0x4000, 0x40);

  // set CS high
  writeByte_GB(0xa080, 0x00);
  writeByte_GB(0xa080, 0x80);

  println_Msg(F("Unlocking EEPROM..."));
  display_Update();

  // unlock EEPROM by sending EWEN instruction
  sendMBC7EEPROM_Inst_GB(0, 0xc0, 0);
  // set CS low
  writeByte_GB(0xa080, 0x00);

  println_Msg(F("Erasing EEPROM..."));
  display_Update();

  // erase entire EEPROM by sending ERAL instruction
  sendMBC7EEPROM_Inst_GB(0, 0x80, 0);

  // set CS low
  writeByte_GB(0xa080, 0x00);
  // set CS high
  writeByte_GB(0xa080, 0x80);

  // wait for erase complete
  do {
    writeByte_GB(0xa080, 0x80);
    writeByte_GB(0xa080, 0xc0);
  } while ((readByte_GB(0xa080) & 0x01) == 0);

  println_Msg(F("Writing EEPROM..."));
  display_Update();

  // write data to EEPROM by sending WRITE instruction word by word
  for (uint16_t i = 0; i < lastByte; i += 2, data++) {
    sendMBC7EEPROM_Inst_GB(1, (i >> 1), *data);

    // set CS low
    writeByte_GB(0xa080, 0x00);
    // set CS high
    writeByte_GB(0xa080, 0x80);

    // wait for writing complete
    do {
      writeByte_GB(0xa080, 0x80);
      writeByte_GB(0xa080, 0xc0);
    } while ((readByte_GB(0xa080) & 0x01) == 0);
  }

  println_Msg(F("Locking EEPROM..."));
  display_Update();

  // re-lock EEPROM
  sendMBC7EEPROM_Inst_GB(0, 0, 0);
  writeByte_GB(0xa080, 0x00);

  // disable ram access
  writeByte_GB(0x0000, 0x00);
  writeByte_GB(0x4000, 0x00);

  // done
  print_STR(done_STR, true);
  display_Update();
}

void sendMBC7EEPROM_Inst_GB(uint8_t op, uint8_t addr, uint16_t data) {
  boolean send_data = false;
  uint8_t i;

  op = op & 0x03;

  if (op == 0) {
    addr &= 0xc0;
    if (addr == 0x40)
      send_data = true;
  } else if (op == 1) {
    send_data = true;
  }

  // send start bit
  writeByte_GB(0xa080, 0x82);
  writeByte_GB(0xa080, 0xc2);

  // send op
  for (i = 0; i < 2; i++, op <<= 1) {
    eepbit[1] = (op & 0x02);
    eepbit[0] = (eepbit[1] | 0x80);
    eepbit[1] |= 0xc0;

    writeByte_GB(0xa080, eepbit[0]);
    writeByte_GB(0xa080, eepbit[1]);
  }

  // send addr
  for (i = 0; i < 8; i++, addr <<= 1) {
    eepbit[1] = ((addr & 0x80) >> 6);
    eepbit[0] = (eepbit[1] | 0x80);
    eepbit[1] |= 0xc0;

    writeByte_GB(0xa080, eepbit[0]);
    writeByte_GB(0xa080, eepbit[1]);
  }

  if (send_data) {
    for (i = 0; i < 16; i++, data <<= 1) {
      eepbit[1] = ((data & 0x8000) >> 14);
      eepbit[0] = (eepbit[1] | 0x80);
      eepbit[1] |= 0xc0;

      writeByte_GB(0xa080, eepbit[0]);
      writeByte_GB(0xa080, eepbit[1]);
    }
  }
}

/******************************************
  29F016/29F032/29F033 flashrom functions
*****************************************/
// Write 29F032 flashrom
// A0-A13 directly connected to cart edge -> 16384(0x0-0x3FFF) bytes per bank -> 256(0x0-0xFF) banks
// A14-A21 connected to MBC5
void writeFlash29F_GB(byte MBC, boolean flashErase) {
  // Launch filebrowser
  filePath[0] = '\0';
  sd.chdir("/");
  fileBrowser(F("Select file"));
  display_Clear();

  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {
    // Get rom size from file
    myFile.seekCur(0x147);
    romType = myFile.read();
    romSize = myFile.read();
    // Go back to file beginning
    myFile.seekSet(0);

    // ROM banks
    romBanks = 2;
    if (romSize >= 0x01 && romSize <= 0x07) {
      romBanks = int_pow(2, romSize + 1);
    }

    // Set ROM bank hi 0
    writeByte_GB(0x3000, 0);
    // Set ROM bank low 0
    writeByte_GB(0x2000, 0);
    delay(100);

    // Reset flash
    writeByte_GB(0x555, 0xf0);
    delay(100);

    // ID command sequence
    writeByte_GB(0x555, 0xaa);
    writeByte_GB(0x2aa, 0x55);
    writeByte_GB(0x555, 0x90);

    // Read the two id bytes into a string
    flashid = readByte_GB(0) << 8;
    flashid |= readByte_GB(1);

    if (flashid == 0x04D4) {
      println_Msg(F("MBM29F033C"));
      print_Msg(F("Banks: "));
      print_Msg(romBanks);
      println_Msg(F("/256"));
      display_Update();
    } else if (flashid == 0x0141) {
      println_Msg(F("AM29F032B"));
      print_Msg(F("Banks: "));
      print_Msg(romBanks);
      println_Msg(F("/256"));
      display_Update();
    } else if (flashid == 0x01AD) {
      println_Msg(F("AM29F016B"));
      print_Msg(F("Banks: "));
      print_Msg(romBanks);
      println_Msg(F("/128"));
      display_Update();
    } else if (flashid == 0x04AD) {
      println_Msg(F("AM29F016D"));
      print_Msg(F("Banks: "));
      print_Msg(romBanks);
      println_Msg(F("/128"));
      display_Update();
    } else if (flashid == 0x01D5) {
      println_Msg(F("AM29F080B"));
      print_Msg(F("Banks: "));
      print_Msg(romBanks);
      println_Msg(F("/64"));
      display_Update();
    } else {
      print_Msg(F("Flash ID: "));
      sprintf(flashid_str, "%04X", flashid);
      println_Msg(flashid_str);
      display_Update();
      print_FatalError(F("Unknown flashrom"));
    }

    // Reset flash
    writeByte_GB(0x555, 0xf0);

    delay(100);

    if (flashErase) {
      println_Msg(F("Erasing flash"));
      display_Update();

      // Erase flash
      writeByte_GB(0x555, 0xaa);
      writeByte_GB(0x2aa, 0x55);
      writeByte_GB(0x555, 0x80);
      writeByte_GB(0x555, 0xaa);
      writeByte_GB(0x2aa, 0x55);
      writeByte_GB(0x555, 0x10);

      // Read the status register
      byte statusReg = readByte_GB(0);
      // After a completed erase D7 will output 1
      while ((statusReg & 0x80) != 0x80) {
        // Update Status
        statusReg = readByte_GB(0);
      }

      // Blankcheck
      println_Msg(F("Blankcheck"));
      display_Update();

      // Read x number of banks
      for (word currBank = 0; currBank < romBanks; currBank++) {
        // Blink led
        blinkLED();

        // Set ROM bank
        writeByte_GB(0x2000, currBank);

        for (unsigned int currAddr = 0x4000; currAddr < 0x7FFF; currAddr += 512) {
          for (int currByte = 0; currByte < 512; currByte++) {
            sdBuffer[currByte] = readByte_GB(currAddr + currByte);
          }
          for (int j = 0; j < 512; j++) {
            if (sdBuffer[j] != 0xFF) {
              println_Msg(F("Not empty"));
              print_FatalError(F("Erase failed"));
            }
          }
        }
      }
    }

    if (MBC == 3) {
      if (audioWE)
        println_Msg(F("Writing flash MBC30 (Audio)"));
      else
        println_Msg(F("Writing flash MBC3"));
      display_Update();

      // Write flash
      word currAddr = 0;
      word endAddr = 0x3FFF;

      //Initialize progress bar
      uint32_t processedProgressBar = 0;
      uint32_t totalProgressBar = (uint32_t)(romBanks)*16384;
      draw_progressbar(0, totalProgressBar);

      for (word currBank = 0; currBank < romBanks; currBank++) {
        // Blink led
        blinkLED();

        // Set ROM bank
        writeByte_GB(0x2100, currBank);
        if (romBanks > 128)
          // Map SRAM Bank to prevent getting stuck at 0x2A8000
          writeByte_GB(0x4000, 0x0);

        if (currBank > 0) {
          currAddr = 0x4000;
          endAddr = 0x7FFF;
        }

        while (currAddr <= endAddr) {
          myFile.read(sdBuffer, 512);

          for (int currByte = 0; currByte < 512; currByte++) {
            // Write command sequence
            writeByte_GB(0x555, 0xaa);
            writeByte_GB(0x2aa, 0x55);
            writeByte_GB(0x555, 0xa0);
            // Write current byte
            writeByte_GB(currAddr + currByte, sdBuffer[currByte]);

            // Set OE/RD(PH6) LOW
            PORTH &= ~(1 << 6);

            // Busy check
            //byte count = 0;
            while ((PINC & 0x80) != (sdBuffer[currByte] & 0x80)) {
              /*
              // Debug
              count++;
              __asm__("nop\n\t"
                      "nop\n\t"
                      "nop\n\t"
                      "nop\n\t");
              if (count > 250) {
                println_Msg("");
                print_Msg(F("Bank: "));
                print_Msg(currBank);
                print_Msg(F(" Addr: "));
                println_Msg(currAddr + currByte);
                display_Update();
                wait();
              }
              */
            }

            // Switch OE/RD(PH6) to HIGH
            PORTH |= (1 << 6);
          }
          currAddr += 512;
          processedProgressBar += 512;
          draw_progressbar(processedProgressBar, totalProgressBar);
        }
      }
    }

    else if (MBC == 5) {
      println_Msg(F("Writing flash MBC5"));
      display_Update();

      // Write flash
      //Initialize progress bar
      uint32_t processedProgressBar = 0;
      uint32_t totalProgressBar = (uint32_t)(romBanks)*16384;
      draw_progressbar(0, totalProgressBar);

      for (word currBank = 0; currBank < romBanks; currBank++) {
        // Blink led
        blinkLED();

        // Set ROM bank
        writeByte_GB(0x2000, currBank);
        // 0x2A8000 fix
        writeByte_GB(0x4000, 0x0);

        for (unsigned int currAddr = 0x4000; currAddr < 0x7FFF; currAddr += 512) {
          myFile.read(sdBuffer, 512);

          for (int currByte = 0; currByte < 512; currByte++) {
            // Write command sequence
            writeByte_GB(0x555, 0xaa);
            writeByte_GB(0x2aa, 0x55);
            writeByte_GB(0x555, 0xa0);
            // Write current byte
            writeByte_GB(currAddr + currByte, sdBuffer[currByte]);

            // Set OE/RD(PH6) LOW
            PORTH &= ~(1 << 6);

            // Busy check
            while ((PINC & 0x80) != (sdBuffer[currByte] & 0x80)) {
            }

            // Switch OE/RD(PH6) to HIGH
            PORTH |= (1 << 6);
          }
          processedProgressBar += 512;
          draw_progressbar(processedProgressBar, totalProgressBar);
        }
      }
    }

    print_STR(verifying_STR, 0);
    display_Update();

    // Go back to file beginning
    myFile.seekSet(0);
    //unsigned int addr = 0;  // unused
    writeErrors = 0;

    // Verify flashrom
    word romAddress = 0;

    // Read number of banks and switch banks
    for (word bank = 1; bank < romBanks; bank++) {
      if (romType >= 5) {                   // MBC2 and above
        writeByte_GB(0x2100, bank);         // Set ROM bank
      } else {                              // MBC1
        writeByte_GB(0x6000, 0);            // Set ROM Mode
        writeByte_GB(0x4000, bank >> 5);    // Set bits 5 & 6 (01100000) of ROM bank
        writeByte_GB(0x2000, bank & 0x1F);  // Set bits 0 & 4 (00011111) of ROM bank
      }

      if (bank > 1) {
        romAddress = 0x4000;
      }
      // Blink led
      blinkLED();

      // Read up to 7FFF per bank
      while (romAddress <= 0x7FFF) {
        // Fill sdBuffer
        myFile.read(sdBuffer, 512);
        // Compare
        for (int i = 0; i < 512; i++) {
          if (readByte_GB(romAddress + i) != sdBuffer[i]) {
            writeErrors++;
          }
        }
        romAddress += 512;
      }
    }
    // Close the file:
    myFile.close();

    if (writeErrors == 0) {
      println_Msg(FS(FSTRING_OK));
      display_Update();
    } else {
      println_Msg(F("Error"));
      print_Msg(writeErrors);
      print_STR(_bytes_STR, 1);
      print_FatalError(did_not_verify_STR);
    }
  } else {
    print_STR(open_file_STR, 1);
    display_Update();
  }
}

/******************************************
  CFU flashrom functions
*****************************************/

/*
   Flash chips can either be in x8 mode or x16 mode and sometimes the two
   least significant bits on flash cartridges' data lines are swapped.
   This function reads a byte and compensates for the differences.
   This is only necessary for commands to the flash, not for data read from the flash, the MBC or SRAM.

   address needs to be the x8 mode address of the flash register that should be read.
*/
byte readByteCompensated(int address) {
  byte data = readByte_GB(address >> (flashX16Mode ? 1 : 0));
  if (flashSwitchLastBits) {
    return (data & 0b11111100) | ((data << 1) & 0b10) | ((data >> 1) & 0b01);
  }
  return data;
}

/*
   Flash chips can either be in x8 mode or x16 mode and sometimes the two
   least significant bits on flash cartridges' data lines are swapped.
   This function writes a byte and compensates for the differences.
   This is only necessary for commands to the flash, not for data written to the flash, the MBC or SRAM.
   .
   address needs to be the x8 mode address of the flash register that should be read.
*/
void writeByteCompensated(int address, byte data) {
  if (flashSwitchLastBits) {
    data = (data & 0b11111100) | ((data << 1) & 0b10) | ((data >> 1) & 0b01);
  }
  writeByte_GB(address >> (flashX16Mode ? 1 : 0), data);
}

void startCFIMode(boolean x16Mode) {
  if (x16Mode) {
    writeByte_GB(0x555, 0xf0);  //x16 mode reset command
    delay(500);
    writeByte_GB(0x555, 0xf0);  //Double reset to get out of possible Autoselect + CFI mode
    delay(500);
    writeByte_GB(0x55, 0x98);  //x16 CFI Query command
  } else {
    writeByte_GB(0xAAA, 0xf0);  //x8  mode reset command
    delay(100);
    writeByte_GB(0xAAA, 0xf0);  //Double reset to get out of possible Autoselect + CFI mode
    delay(100);
    writeByte_GB(0xAA, 0x98);  //x8 CFI Query command
  }
}

/* Identify the different flash chips.
   Sets the global variables flashBanks, flashX16Mode and flashSwitchLastBits
*/
void identifyCFI_GB() {
  // Reset flash
  display_Clear();
  writeByte_GB(0x6000, 0);  // Set ROM Mode
  writeByte_GB(0x2000, 0);  // Set Bank to 0
  writeByte_GB(0x3000, 0);

  startCFIMode(false);  // Trying x8 mode first

  display_Clear();
  // Try x8 mode first
  char cfiQRYx8[7];
  char cfiQRYx16[7];
  sprintf(cfiQRYx8, "%02X%02X%02X", readByte_GB(0x20), readByte_GB(0x22), readByte_GB(0x24));
  sprintf(cfiQRYx16, "%02X%02X%02X", readByte_GB(0x10), readByte_GB(0x11), readByte_GB(0x12));  // some devices use x8-style CFI Query command even though they are in x16 command mode
  if (strcmp(cfiQRYx8, "515259") == 0) {                                                        // QRY in x8 mode
    println_Msg(F("Normal CFI x8 Mode"));
    flashX16Mode = false;
    flashSwitchLastBits = false;
  } else if (strcmp(cfiQRYx8, "52515A") == 0) {  // QRY in x8 mode with switched last bit
    println_Msg(F("Switched CFI x8 Mode"));
    flashX16Mode = false;
    flashSwitchLastBits = true;
  } else if (strcmp(cfiQRYx16, "515259") == 0) {  // QRY in x16 mode
    println_Msg(F("Normal CFI x16 Mode"));
    flashX16Mode = true;
    flashSwitchLastBits = false;
  } else if (strcmp(cfiQRYx16, "52515A") == 0) {  // QRY in x16 mode with switched last bit
    println_Msg(F("Switched CFI x16 Mode"));
    flashX16Mode = true;
    flashSwitchLastBits = true;
  } else {
    startCFIMode(true);  // Try x16 mode next
    sprintf(cfiQRYx16, "%02X%02X%02X", readByte_GB(0x10), readByte_GB(0x11), readByte_GB(0x12));
    if (strcmp(cfiQRYx16, "515259") == 0) {  // QRY in x16 mode
      println_Msg(F("Normal CFI x16 Mode"));
      flashX16Mode = true;
      flashSwitchLastBits = false;
    } else if (strcmp(cfiQRYx16, "52515A") == 0) {  // QRY in x16 mode with switched last bit
      println_Msg(F("Switched CFI x16 Mode"));
      flashX16Mode = true;
      flashSwitchLastBits = true;
    } else {
      println_Msg(F("CFI Query failed!"));
      display_Update();
      wait();
      return;
    }
  }
  flashBanks = 1 << (readByteCompensated(0x4E) - 14);  // - flashX16Mode);

  // Reset flash
  writeByteCompensated(0xAAA, 0xf0);
  delay(100);
}

// Write 29F032 flashrom
// A0-A13 directly connected to cart edge -> 16384(0x0-0x3FFF) bytes per bank -> 256(0x0-0xFF) banks
// A14-A21 connected to MBC5
// identifyFlash_GB() needs to be run before this!
bool writeCFI_GB() {
  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {
    // Get rom size from file
    myFile.seekCur(0x147);
    romType = myFile.read();
    romSize = myFile.read();
    // Go back to file beginning
    myFile.seekSet(0);

    // ROM banks
    romBanks = 2;
    if (romSize >= 0x01 && romSize <= 0x07) {
      romBanks = int_pow(2, romSize + 1);
    }

    if (romBanks <= flashBanks) {
      print_Msg(F("Using "));
      print_Msg(romBanks);
      print_Msg(F("/"));
      print_Msg(flashBanks);
      println_Msg(F(" Banks"));
      display_Update();
    } else {
      println_Msg(F("Error: Flash has too few banks!"));
      print_Msg(F("Has "));
      print_Msg(flashBanks);
      println_Msg(F(" banks,"));
      print_Msg(F("but needs "));
      print_Msg(romBanks);
      println_Msg(F("."));
      // Prints string out of the common strings array either with or without newline
      print_STR(press_button_STR, 1);
      display_Update();
      wait();
      resetArduino();
    }

    // Set ROM bank hi 0
    writeByte_GB(0x3000, 0);
    // Set ROM bank low 0
    writeByte_GB(0x2000, 0);
    delay(100);

    // Reset flash
    writeByteCompensated(0xAAA, 0xf0);
    delay(100);

    // Reset flash
    writeByte_GB(0x555, 0xf0);

    delay(100);
    println_Msg(F("Erasing flash"));
    display_Update();

    // Erase flash
    writeByteCompensated(0xAAA, 0xaa);
    writeByteCompensated(0x555, 0x55);
    writeByteCompensated(0xAAA, 0x80);
    writeByteCompensated(0xAAA, 0xaa);
    writeByteCompensated(0x555, 0x55);
    writeByteCompensated(0xAAA, 0x10);

    // Read the status register
    byte statusReg = readByte_GB(0);

    // After a completed erase D7 will output 1
    while ((statusReg & 0x80) != 0x80) {
      // Blink led
      blinkLED();
      delay(100);
      // Update Status
      statusReg = readByte_GB(0);
    }

    // Blankcheck
    println_Msg(F("Blankcheck"));
    display_Update();

    // Read x number of banks
    for (word currBank = 0; currBank < romBanks; currBank++) {
      // Blink led
      blinkLED();

      // Set ROM bank
      writeByte_GB(0x2000, currBank);

      for (unsigned int currAddr = 0x4000; currAddr < 0x7FFF; currAddr += 512) {
        for (int currByte = 0; currByte < 512; currByte++) {
          sdBuffer[currByte] = readByte_GB(currAddr + currByte);
        }
        for (int j = 0; j < 512; j++) {
          if (sdBuffer[j] != 0xFF) {
            println_Msg(F("Not empty"));
            print_FatalError(F("Erase failed"));
          }
        }
      }
    }

    println_Msg(F("Writing flash MBC3/5"));
    display_Update();

    // Write flash
    word currAddr = 0;
    word endAddr = 0x3FFF;

    for (word currBank = 0; currBank < romBanks; currBank++) {
      // Blink led
      blinkLED();

      // Set ROM bank
      writeByte_GB(0x2100, currBank);
      // 0x2A8000 fix
      writeByte_GB(0x4000, 0x0);

      if (currBank > 0) {
        currAddr = 0x4000;
        endAddr = 0x7FFF;
      }

      while (currAddr <= endAddr) {
        myFile.read(sdBuffer, 512);

        for (int currByte = 0; currByte < 512; currByte++) {
          // Write command sequence
          writeByteCompensated(0xAAA, 0xaa);
          writeByteCompensated(0x555, 0x55);
          writeByteCompensated(0xAAA, 0xa0);

          // Write current byte
          writeByte_GB(currAddr + currByte, sdBuffer[currByte]);

          // Setting CS(PH3) and OE/RD(PH6) LOW
          PORTH &= ~((1 << 3) | (1 << 6));

          // Busy check
          short i = 0;
          while ((PINC & 0x80) != (sdBuffer[currByte] & 0x80)) {
            i++;
            if (i > 500) {
              if (currAddr < 0x4000) {  // This happens when trying to flash an MBC5 as if it was an MBC3. Retry to flash as MBC5, starting from last successfull byte.
                currByte--;
                currAddr += 0x4000;
                endAddr = 0x7FFF;
                break;
              } else {  // If a timeout happens while trying to flash MBC5-style, flashing failed.
                return false;
              }
            }
          }

          // Switch CS(PH3) and OE/RD(PH6) to HIGH
          PORTH |= (1 << 3) | (1 << 6);
          __asm__("nop\n\tnop\n\tnop\n\t");  // Waste a few CPU cycles to remove write errors
        }
        currAddr += 512;
      }
    }

    display_Clear();
    println_Msg(F("Verifying"));
    display_Update();

    // Go back to file beginning
    myFile.seekSet(0);
    //unsigned int addr = 0;  // unused
    writeErrors = 0;

    // Verify flashrom
    word romAddress = 0;

    // Read number of banks and switch banks
    for (word bank = 1; bank < romBanks; bank++) {
      if (romType >= 5) {                   // MBC2 and above
        writeByte_GB(0x2100, bank);         // Set ROM bank
      } else {                              // MBC1
        writeByte_GB(0x6000, 0);            // Set ROM Mode
        writeByte_GB(0x4000, bank >> 5);    // Set bits 5 & 6 (01100000) of ROM bank
        writeByte_GB(0x2000, bank & 0x1F);  // Set bits 0 & 4 (00011111) of ROM bank
      }

      if (bank > 1) {
        romAddress = 0x4000;
      }
      // Blink led
      blinkLED();

      // Read up to 7FFF per bank
      while (romAddress <= 0x7FFF) {
        // Fill sdBuffer
        myFile.read(sdBuffer, 512);
        // Compare
        for (int i = 0; i < 512; i++) {
          if (readByte_GB(romAddress + i) != sdBuffer[i]) {
            writeErrors++;
          }
        }
        romAddress += 512;
      }
    }
    // Close the file:
    myFile.close();

    if (writeErrors == 0) {
      println_Msg(FS(FSTRING_OK));
      display_Update();
    } else {
      print_STR(error_STR, 0);
      print_Msg(writeErrors);
      print_STR(_bytes_STR, 1);
      print_Error(did_not_verify_STR);
    }
  } else {
    print_STR(open_file_STR, 1);
    display_Update();
  }
  return true;
}

/**************************************************
  Pelican Gameboy Device Read Function
**************************************************/
// Read Pelican GBC Device - All Brainboys, MonsterBrains, Codebreakers
void readPelican_GB() {
  // Get name, add extension and convert to char array for sd lib
  createFolderAndOpenFile("GB", "ROM", "Pelican", "GB");

  word finalAddress = 0x3FFF;
  word startAddress = 0x2000;
  word bankAddress = 0xA000;

  //Enable bank addressing in the CPLD
  readByte_GB(0x100);

  // W29C020 ID command sequence
  writeByteSRAM_GB(0xA000, 0x2);
  writeByte_GB(0x3555, 0xAA);
  writeByteSRAM_GB(0xA000, 0x1);
  writeByte_GB(0x2AAA, 0x55);
  writeByteSRAM_GB(0xA000, 0x2);
  writeByte_GB(0x3555, 0x80);
  writeByte_GB(0x3555, 0xAA);
  writeByteSRAM_GB(0xA000, 0x1);
  writeByte_GB(0x2AAA, 0x55);
  writeByteSRAM_GB(0xA000, 0x2);
  writeByte_GB(0x3555, 0x60);
  delay(10);

  // Read the two id bytes into a string
  writeByteSRAM_GB(0xA000, 0x0);
  flashid = readByte_GB(0) << 8;
  flashid |= readByte_GB(1);

  // W29C020 Flash ID Mode Exit
  writeByteSRAM_GB(0xA000, 0x2);
  writeByte_GB(0x3555, 0xAA);
  writeByteSRAM_GB(0xA000, 0x1);
  writeByte_GB(0x2AAA, 0x55);
  writeByteSRAM_GB(0xA000, 0x2);
  writeByte_GB(0x3555, 0xF0);
  delay(100);

  if (flashid == 0xDA45 || flashid == 0xBF10) {
    println_Msg(F("29EE020 / W29C020"));
    println_Msg(F("Banks Used: 32/64"));
    println_Msg(F("Rom Size: 256 KB"));
    romBanks = 32;
    display_Update();
  } else {
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0xFF);
    delay(100);
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0x90);
    delay(100);
    flashid = readByte_GB(0) << 8;
    flashid |= readByte_GB(1);
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0xFF);
    delay(100);
    if (flashid != 0xBF04) {
      println_Msg(F("Unknown Flash ID"));
      println_Msg(flashid);
      print_STR(press_button_STR, 1);
      display_Update();
      wait();
      mainMenu();
    }
  }

  if (flashid == 0xBF04) {
    println_Msg(F("SST 28LF040"));
    println_Msg(F("Banks Used: 64/64"));
    println_Msg(F("Rom Size: 512 KB"));
    romBanks = 64;
    display_Update();
  }

  // Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)(romBanks)*8192;
  draw_progressbar(0, totalProgressBar);

  for (size_t workBank = 0; workBank < romBanks; workBank++) {  // Loop over banks

    startAddress = 0x2000;

    writeByteSRAM_GB(bankAddress, (workBank & 0xFF));

    // Read banks and save to SD
    while (startAddress <= finalAddress) {
      for (int i = 0; i < 512; i++) {
        sdBuffer[i] = readByte_GB(startAddress + i);
      }
      myFile.write(sdBuffer, 512);
      startAddress += 512;
      processedProgressBar += 512;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }

  // Close the file:
  myFile.close();
}

/******************************************
  Pelican Gameboy Device Write Function
*****************************************/
// Write Pelican GBC Device - All Brainboys, MonsterBrains, Codebreakers
void writePelican_GB() {
  // Launch filebrowser
  filePath[0] = '\0';
  sd.chdir("/");
  fileBrowser(F("Select file"));
  display_Clear();

  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {

    // Enable Rom Banks
    readByte_GB(0x100);
    delay(100);

    // W29C020 ID command sequence
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0xAA);
    writeByteSRAM_GB(0xA000, 0x1);
    writeByte_GB(0x2AAA, 0x55);
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0x80);
    writeByte_GB(0x3555, 0xAA);
    writeByteSRAM_GB(0xA000, 0x1);
    writeByte_GB(0x2AAA, 0x55);
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0x60);
    delay(10);

    // Read the two id bytes into a string
    writeByteSRAM_GB(0xA000, 0x0);
    flashid = readByte_GB(0) << 8;
    flashid |= readByte_GB(1);

    // W29C020 Flash ID Mode Exit
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0xAA);
    writeByteSRAM_GB(0xA000, 0x1);
    writeByte_GB(0x2AAA, 0x55);
    writeByteSRAM_GB(0xA000, 0x2);
    writeByte_GB(0x3555, 0xF0);
    delay(100);

    if (flashid == 0xDA45 || flashid == 0xBF10) {
      println_Msg(F("29EE020 / W29C020"));
      println_Msg(F("Banks Used: 32/64"));
      romBanks = 32;
      display_Update();
      println_Msg(F("Erasing flash..."));
      display_Update();

      if (flashid == 0xDA45) {
        // Disable BootBlock
        writeByteSRAM_GB(0xA000, 0x2);
        writeByte_GB(0x3555, 0xAA);
        writeByteSRAM_GB(0xA000, 0x1);
        writeByte_GB(0x2AAA, 0x55);
        writeByteSRAM_GB(0xA000, 0x2);
        writeByte_GB(0x3555, 0x80);
        writeByte_GB(0x3555, 0xAA);
        writeByteSRAM_GB(0xA000, 0x1);
        writeByte_GB(0x2AAA, 0x55);
        writeByteSRAM_GB(0xA000, 0x2);
        writeByte_GB(0x3555, 0x40);
        writeByteSRAM_GB(0xA000, 0x1);
        writeByte_GB(0x2AAA, 0xAA);
        delay(100);
      }

      // Erase flash
      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0xAA);
      writeByteSRAM_GB(0xA000, 0x1);
      writeByte_GB(0x2AAA, 0x55);
      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0x80);
      writeByte_GB(0x3555, 0xAA);
      writeByteSRAM_GB(0xA000, 0x1);
      writeByte_GB(0x2AAA, 0x55);
      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0x10);
      delay(1000);
    } else {
      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0xFF);
      delay(100);
      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0x90);
      delay(100);
      flashid = readByte_GB(0) << 8;
      flashid |= readByte_GB(1);
      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0xFF);
      delay(100);
      if (flashid != 0xBF04) {
        println_Msg(F("Unknown Flash ID"));
        println_Msg(flashid);
        print_STR(press_button_STR, 1);
        display_Update();
        wait();
        mainMenu();
      }
    }

    if (flashid == 0xBF04) {
      println_Msg(F("SST 28LF040"));
      println_Msg(F("Banks Used: 64/64"));
      romBanks = 64;
      display_Update();
      println_Msg(F("Erasing flash..."));
      display_Update();

      //Unprotect flash
      writeByteSRAM_GB(0xA000, 0x0);
      readByte_GB(0x3823);
      readByte_GB(0x3820);
      readByte_GB(0x3822);
      readByte_GB(0x2418);
      readByte_GB(0x241B);
      readByte_GB(0x2419);
      readByte_GB(0x241A);
      delay(100);

      //Erase flash
      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0x30);
      writeByte_GB(0x3555, 0x30);
      delay(100);

      writeByteSRAM_GB(0xA000, 0x2);
      writeByte_GB(0x3555, 0xFF);
      delay(100);
    }

    // Blankcheck
    println_Msg(F("Blankcheck..."));
    display_Update();

    // Read x number of banks
    for (word currBank = 0; currBank < romBanks; currBank++) {
      // Blink led
      blinkLED();

      // Set ROM bank
      writeByteSRAM_GB(0xA000, currBank);

      for (word currAddr = 0x2000; currAddr < 0x4000; currAddr += 0x200) {
        for (int currByte = 0; currByte < 512; currByte++) {
          sdBuffer[currByte] = readByte_GB(currAddr + currByte);
        }
        for (int j = 0; j < 512; j++) {
          if (sdBuffer[j] != 0xFF) {
            println_Msg(F("Not empty"));
            print_FatalError(F("Erase failed"));
          }
        }
      }
    }
  }

  println_Msg(F("Writing flash..."));
  display_Update();

  // Write flash
  word currAddr = 0x2000;
  word endAddr = 0x3FFF;
  byte byte1;
  byte byte2;
  bool toggle = true;

  //Unprotect flash
  writeByteSRAM_GB(0xA000, 0x0);
  readByte_GB(0x3823);
  readByte_GB(0x3820);
  readByte_GB(0x3822);
  readByte_GB(0x2418);
  readByte_GB(0x241B);
  readByte_GB(0x2419);
  readByte_GB(0x241A);
  delay(100);

  //Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)(romBanks)*8192;
  draw_progressbar(0, totalProgressBar);

  for (word currBank = 0; currBank < romBanks; currBank++) {
    // Blink led
    blinkLED();
    currAddr = 0x2000;

    if (flashid == 0xDA45 || flashid == 0xBF10) {
      while (currAddr <= endAddr) {
        myFile.read(sdBuffer, 128);

        // Write command sequence
        writeByteSRAM_GB(0xA000, 0x2);
        writeByte_GB(0x3555, 0xAA);
        writeByteSRAM_GB(0xA000, 0x1);
        writeByte_GB(0x2AAA, 0x55);
        writeByteSRAM_GB(0xA000, 0x2);
        writeByte_GB(0x3555, 0xA0);

        // Set ROM bank
        writeByteSRAM_GB(0xA000, currBank);

        for (int currByte = 0; currByte < 128; currByte++) {

          // Write current byte
          writeByte_GB(currAddr + currByte, sdBuffer[currByte]);
        }
        currAddr += 128;
        processedProgressBar += 128;
        draw_progressbar(processedProgressBar, totalProgressBar);
        delay(10);
      }
    }

    if (flashid == 0xBF04) {
      while (currAddr <= endAddr) {
        myFile.read(sdBuffer, 512);

        for (int currByte = 0; currByte < 512; currByte++) {

          toggle = true;
          // Write current byte
          writeByteSRAM_GB(0xA000, 0x2);
          writeByte_GB(0x3555, 0x10);
          writeByteSRAM_GB(0xA000, currBank);
          writeByte_GB(currAddr + currByte, sdBuffer[currByte]);
          while (toggle) {
            byte1 = readByte_GB(currAddr + currByte);
            byte2 = readByte_GB(currAddr + currByte);
            toggle = isToggle(byte1, byte2);
          }
          byte1 = readByte_GB(currAddr + currByte);
          if (byte1 != sdBuffer[currByte]) {
            writeByteSRAM_GB(0xA000, 0x2);
            writeByte_GB(0x3555, 0x10);
            writeByteSRAM_GB(0xA000, currBank);
            writeByte_GB(currAddr + currByte, sdBuffer[currByte]);
            while (toggle) {
              byte1 = readByte_GB(currAddr + currByte);
              byte2 = readByte_GB(currAddr + currByte);
              toggle = isToggle(byte1, byte2);
            }
          }
        }
        currAddr += 512;
        processedProgressBar += 512;
        draw_progressbar(processedProgressBar, totalProgressBar);
      }
    }
  }

  if (flashid == 0xBF04) {
    //Protect flash
    writeByteSRAM_GB(0xA000, 0x0);
    readByte_GB(0x3823);
    readByte_GB(0x3820);
    readByte_GB(0x3822);
    readByte_GB(0x2418);
    readByte_GB(0x241B);
    readByte_GB(0x2419);
    readByte_GB(0x240A);
    delay(100);
  }

  display_Clear();
  print_STR(verifying_STR, 0);
  display_Update();

  // Go back to file beginning
  myFile.seekSet(0);
  //unsigned int addr = 0;  // unused
  writeErrors = 0;

  // Verify flashrom
  word romAddress = 0x2000;

  // Read number of banks and switch banks
  for (word bank = 0; bank < romBanks; bank++) {
    writeByteSRAM_GB(0xA000, bank);  // Set ROM bank
    romAddress = 0x2000;

    // Blink led
    blinkLED();

    // Read up to 3FFF per bank
    while (romAddress < 0x4000) {
      // Fill sdBuffer
      myFile.read(sdBuffer, 512);
      // Compare
      for (int i = 0; i < 512; i++) {
        if (readByte_GB(romAddress + i) != sdBuffer[i]) {
          writeErrors++;
        }
      }
      romAddress += 512;
    }
  }
  // Close the file:
  myFile.close();

  if (writeErrors == 0) {
    println_Msg(FS(FSTRING_OK));
    println_Msg(F("Please turn off the power."));
    display_Update();
  } else {
    println_Msg(F("Error"));
    print_Msg(writeErrors);
    print_STR(_bytes_STR, 1);
    print_FatalError(did_not_verify_STR);
  }
}

bool isToggle(byte byte1, byte byte2) {
  // XOR the two bytes to get the bits that are different
  byte difference = byte1 ^ byte2;
  difference = difference & 0b00100000;

  // Check if only the 6th bit is different
  return difference == 0b00100000;
}

/******************************************************
  Datel Mega Memory Card Gameboy Device Read Function
******************************************************/
// Read Mega Memory Card Rom and Save Backup Data
void readMegaMem_GB() {
  // Dump the Rom
  createFolder("GB", "ROM", "MegaMem", "GB");

  display_Clear();
  print_STR(saving_to_STR, 0);
  print_Msg(folder);
  println_Msg(F("/..."));
  println_Msg(F("Rom.GB"));
  display_Update();

  //open file on sd card
  if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
    print_FatalError(create_file_STR);
  }

  word finalAddress = 0x3FFF;
  word startAddress = 0x0;

  // Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)16384;
  draw_progressbar(0, totalProgressBar);

  // Read banks and save to SD
  while (startAddress <= finalAddress) {
    for (int i = 0; i < 512; i++) {
      sdBuffer[i] = readByte_GB(startAddress + i);
    }
    myFile.write(sdBuffer, 512);
    startAddress += 512;
    processedProgressBar += 512;
    draw_progressbar(processedProgressBar, totalProgressBar);
  }

  // Close the file:
  myFile.close();

  // Dump the Save Data SST28LF040
  strcpy(fileName, "SaveData");
  strcat(fileName, ".bin");

  display_Clear();
  print_STR(saving_to_STR, 0);
  print_Msg(folder);
  println_Msg(F("/..."));
  println_Msg(F("SaveData.bin"));
  display_Update();

  // write new folder number back to eeprom
  foldern = foldern + 1;
  EEPROM_writeAnything(0, foldern);

  //open file on sd card
  if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
    print_FatalError(create_file_STR);
  }

  finalAddress = 0x7FFF;
  startAddress = 0x4000;
  word bankAddress = 0x2000;
  romBanks = 32;

  // Initialize progress bar
  processedProgressBar = 0;
  totalProgressBar = (uint32_t)(romBanks)*8192;
  draw_progressbar(0, totalProgressBar);

  for (size_t workBank = 0; workBank < romBanks; workBank++) {  // Loop over banks

    startAddress = 0x4000;

    writeByte_GB(bankAddress, (workBank & 0xFF));

    // Read banks and save to SD
    while (startAddress <= finalAddress) {
      for (int i = 0; i < 512; i++) {
        sdBuffer[i] = readByte_GB(startAddress + i);
      }
      myFile.write(sdBuffer, 512);
      startAddress += 512;
      processedProgressBar += 512;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }

  // Close the file:
  myFile.close();
}

/*******************************************************
  Datel Mega Memory Card Gameboy Device Write Function
*******************************************************/
// Read Mega Memory Card Rom and Save Backup Data
void writeMegaMem_GB() {
  // Write Datel Mega Memory Card Save Storage Chip SST28LF040
  filePath[0] = '\0';
  sd.chdir("/");
  fileBrowser(F("Select file"));
  display_Clear();

  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {

    writeByte_GB(0x2000, 0x1);
    writeByte_GB(0x5555, 0xFF);
    delay(100);
    writeByte_GB(0x2000, 0x1);
    writeByte_GB(0x5555, 0x90);
    delay(100);
    writeByte_GB(0x2000, 0x0);
    flashid = readByte_GB(0x4000) << 8;
    flashid |= readByte_GB(0x4001);
    writeByte_GB(0x2000, 0x1);
    writeByte_GB(0x5555, 0xFF);
    delay(100);
    if (flashid != 0xBF04) {
      println_Msg(F("Unknown Flash ID"));
      println_Msg(flashid);
      print_STR(press_button_STR, 1);
      display_Update();
      wait();
      mainMenu();
    }
  }

  if (flashid == 0xBF04) {
    println_Msg(F("SST 28LF040"));
    romBanks = 32;
    display_Update();
    println_Msg(F("Erasing flash..."));
    display_Update();

    //Unprotect flash
    writeByte_GB(0x2000, 0x0);
    readByte_GB(0x5823);
    readByte_GB(0x5820);
    readByte_GB(0x5822);
    readByte_GB(0x4418);
    readByte_GB(0x441B);
    readByte_GB(0x4419);
    readByte_GB(0x441A);
    delay(100);

    //Erase flash
    writeByte_GB(0x2000, 0x1);
    writeByte_GB(0x5555, 0x30);
    writeByte_GB(0x5555, 0x30);
    delay(100);

    writeByte_GB(0x2000, 0x1);
    writeByte_GB(0x5555, 0xFF);
    delay(100);
  }

  // Blankcheck
  println_Msg(F("Blankcheck..."));
  display_Update();

  // Read x number of banks
  for (word currBank = 0; currBank < romBanks; currBank++) {
    // Blink led
    blinkLED();

    // Set ROM bank
    writeByte_GB(0x2000, currBank);

    for (word currAddr = 0x4000; currAddr < 0x8000; currAddr += 0x200) {
      for (int currByte = 0; currByte < 512; currByte++) {
        sdBuffer[currByte] = readByte_GB(currAddr + currByte);
      }
      for (int j = 0; j < 512; j++) {
        if (sdBuffer[j] != 0xFF) {
          println_Msg(F("Not empty"));
          print_FatalError(F("Erase failed"));
        }
      }
    }
  }

  println_Msg(F("Writing flash..."));
  display_Update();

  // Write flash
  word currAddr = 0x4000;
  word endAddr = 0x7FFF;
  byte byte1;
  byte byte2;
  bool toggle = true;

  //Unprotect flash
  writeByte_GB(0x2000, 0x0);
  readByte_GB(0x5823);
  readByte_GB(0x5820);
  readByte_GB(0x5822);
  readByte_GB(0x4418);
  readByte_GB(0x441B);
  readByte_GB(0x4419);
  readByte_GB(0x441A);
  delay(100);

  //Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)(romBanks)*8192;
  draw_progressbar(0, totalProgressBar);

  for (word currBank = 0; currBank < romBanks; currBank++) {
    // Blink led
    blinkLED();
    currAddr = 0x4000;

    if (flashid == 0xBF04) {
      while (currAddr <= endAddr) {
        myFile.read(sdBuffer, 512);

        for (int currByte = 0; currByte < 512; currByte++) {

          toggle = true;
          // Write current byte
          writeByte_GB(0x2000, 0x1);
          writeByte_GB(0x5555, 0x10);
          writeByte_GB(0x2000, currBank);
          writeByte_GB(currAddr + currByte, sdBuffer[currByte]);
          while (toggle) {
            byte1 = readByte_GB(currAddr + currByte);
            byte2 = readByte_GB(currAddr + currByte);
            toggle = isToggle(byte1, byte2);
          }
          byte1 = readByte_GB(currAddr + currByte);
          if (byte1 != sdBuffer[currByte]) {
            writeByte_GB(0x2000, 0x1);
            writeByte_GB(0x5555, 0x10);
            writeByte_GB(0x2000, currBank);
            writeByte_GB(currAddr + currByte, sdBuffer[currByte]);
            while (toggle) {
              byte1 = readByte_GB(currAddr + currByte);
              byte2 = readByte_GB(currAddr + currByte);
              toggle = isToggle(byte1, byte2);
            }
          }
        }
        currAddr += 512;
        processedProgressBar += 512;
        draw_progressbar(processedProgressBar, totalProgressBar);
      }
    }
  }

  if (flashid == 0xBF04) {
    //Protect flash
    writeByte_GB(0x2000, 0x0);
    readByte_GB(0x5823);
    readByte_GB(0x5820);
    readByte_GB(0x5822);
    readByte_GB(0x4418);
    readByte_GB(0x441B);
    readByte_GB(0x4419);
    readByte_GB(0x440A);
    delay(100);
  }

  display_Clear();
  print_STR(verifying_STR, 0);
  display_Update();

  // Go back to file beginning
  myFile.seekSet(0);
  //unsigned int addr = 0;  // unused
  writeErrors = 0;

  // Verify flashrom
  word romAddress = 0x4000;

  // Read number of banks and switch banks
  for (word bank = 0; bank < romBanks; bank++) {
    writeByte_GB(0x2000, bank);  // Set ROM bank
    romAddress = 0x4000;

    // Blink led
    blinkLED();

    // Read up to 3FFF per bank
    while (romAddress < 0x8000) {
      // Fill sdBuffer
      myFile.read(sdBuffer, 512);
      // Compare
      for (int i = 0; i < 512; i++) {
        if (readByte_GB(romAddress + i) != sdBuffer[i]) {
          writeErrors++;
        }
      }
      romAddress += 512;
    }
  }
  // Close the file:
  myFile.close();

  if (writeErrors == 0) {
    println_Msg(FS(FSTRING_OK));
    println_Msg(F("Please turn off the power."));
    display_Update();
  } else {
    println_Msg(F("Error"));
    print_Msg(writeErrors);
    print_STR(_bytes_STR, 1);
    print_FatalError(did_not_verify_STR);
  }
}

/***************************************************
  Datel GBC Gameshark Gameboy Device Read Function
***************************************************/
// Read Datel GBC Gameshark Device
void readGameshark_GB() {
  word finalAddress = 0x5FFF;
  word startAddress = 0x4000;
  word bankAddress = 0x7FE1;
  romBanks = 16;

  //Enable bank addressing in the CPLD
  readByte_GB(0x101);
  readByte_GB(0x108);
  readByte_GB(0x101);

  // SST 39SF010 ID command sequence
  writeByte_GB(bankAddress, 0x2);
  writeByte_GB(0x5555, 0xAA);
  writeByte_GB(bankAddress, 0x1);
  writeByte_GB(0x4AAA, 0x55);
  writeByte_GB(bankAddress, 0x2);
  writeByte_GB(0x5555, 0x90);
  delay(10);

  // Read the two id bytes into a string
  writeByte_GB(bankAddress, 0x0);
  flashid = readByte_GB(0x4000) << 8;
  flashid |= readByte_GB(0x4001);

  // SST 39SF010 Flash ID Mode Exit
  writeByte_GB(bankAddress, 0x2);
  writeByte_GB(0x5555, 0xAA);
  writeByte_GB(bankAddress, 0x1);
  writeByte_GB(0x4AAA, 0x55);
  writeByte_GB(bankAddress, 0x2);
  writeByte_GB(0x5555, 0xF0);
  delay(100);

  if (flashid == 0xBFB5) {
    display_Clear();
    println_Msg(F("SST 39SF010"));
    println_Msg(F("Rom Size: 128 KB"));
    display_Update();
  } else {
    display_Clear();
    println_Msg(F("Unknown Flash ID"));
    println_Msg(F("Check Cartridge Connection"));
    print_STR(press_button_STR, 1);
    display_Update();
    wait();
    mainMenu();
  }

  // Get name, add extension and convert to char array for sd lib
  createFolder("GB", "ROM", "Gameshark", "GB");

  printAndIncrementFolder();

  //open file on sd card
  if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
    print_FatalError(create_file_STR);
  }

  // Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)(romBanks)*8192;
  draw_progressbar(0, totalProgressBar);

  for (size_t workBank = 0; workBank < romBanks; workBank++) {  // Loop over banks

    startAddress = 0x4000;

    writeByte_GB(bankAddress, (workBank & 0xFF));

    // Read banks and save to SD
    while (startAddress <= finalAddress) {
      for (int i = 0; i < 512; i++) {
        sdBuffer[i] = readByte_GB(startAddress + i);
      }
      myFile.write(sdBuffer, 512);
      startAddress += 512;
      processedProgressBar += 512;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }

  // Close the file:
  myFile.close();
}

/****************************************************
  Datel GBC Gameshark Gameboy Device Write Function
****************************************************/
// Write Datel GBC Gameshark Device
void writeGameshark_GB() {
  // Enable Rom Banks
  readByte_GB(0x101);
  readByte_GB(0x108);
  readByte_GB(0x101);
  delay(100);

  // SST 39SF010 ID command sequence
  writeByte_GB(0x7FE1, 0x2);
  writeByte_GB(0x5555, 0xAA);
  writeByte_GB(0x7FE1, 0x1);
  writeByte_GB(0x4AAA, 0x55);
  writeByte_GB(0x7FE1, 0x2);
  writeByte_GB(0x5555, 0x90);
  delay(10);

  // Read the two id bytes into a string
  writeByte_GB(0x7FE1, 0x0);
  flashid = readByte_GB(0x4000) << 8;
  flashid |= readByte_GB(0x4001);

  // SST 39SF010 Flash ID Mode Exit
  writeByte_GB(0x7FE1, 0x2);
  writeByte_GB(0x5555, 0xAA);
  writeByte_GB(0x7FE1, 0x1);
  writeByte_GB(0x4AAA, 0x55);
  writeByte_GB(0x7FE1, 0x2);
  writeByte_GB(0x5555, 0xF0);

  if (flashid != 0xBFB5) {
    display_Clear();
    println_Msg(F("Unknown Flash ID"));
    println_Msg(F("Check Cartridge Connection"));
    print_STR(press_button_STR, 1);
    display_Update();
    wait();
    mainMenu();
  }

  // Launch filebrowser
  filePath[0] = '\0';
  sd.chdir("/");
  fileBrowser(F("Select file"));
  display_Clear();

  byte byte1;
  bool toggle = true;

  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);

  // Open file on sd card
  myFile.open(filePath, O_READ);

  if (flashid == 0xBFB5) {
    println_Msg(F("SST 39SF010"));
    romBanks = 16;
    display_Update();
    println_Msg(F("Erasing flash..."));
    display_Update();

    //Erase flash
    writeByte_GB(0x7FE1, 0x2);
    writeByte_GB(0x5555, 0xAA);
    writeByte_GB(0x7FE1, 0x1);
    writeByte_GB(0x4AAA, 0x55);
    writeByte_GB(0x7FE1, 0x2);
    writeByte_GB(0x5555, 0x80);
    writeByte_GB(0x7FE1, 0x2);
    writeByte_GB(0x5555, 0xAA);
    writeByte_GB(0x7FE1, 0x1);
    writeByte_GB(0x4AAA, 0x55);
    writeByte_GB(0x7FE1, 0x2);
    writeByte_GB(0x5555, 0x10);
    delay(100);
  }

  // Blankcheck
  println_Msg(F("Blankcheck..."));
  display_Update();

  // Read x number of banks
  for (word currBank = 0; currBank < romBanks; currBank++) {
    // Blink led
    blinkLED();

    // Set ROM bank
    writeByte_GB(0x7FE1, currBank);

    for (word currAddr = 0x4000; currAddr < 0x6000; currAddr += 0x200) {
      for (int currByte = 0; currByte < 512; currByte++) {
        sdBuffer[currByte] = readByte_GB(currAddr + currByte);
      }
      for (int j = 0; j < 512; j++) {
        if (sdBuffer[j] != 0xFF) {
          println_Msg(F("Not empty"));
          print_FatalError(F("Erase failed"));
        }
      }
    }
  }

  println_Msg(F("Writing flash..."));
  display_Update();

  // Write flash
  word currAddr = 0x4000;
  word endAddr = 0x5FFF;

  //Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)(romBanks)*8192;
  draw_progressbar(0, totalProgressBar);

  for (word currBank = 0; currBank < romBanks; currBank++) {
    // Blink led
    blinkLED();
    currAddr = 0x4000;

    while (currAddr <= endAddr) {
      myFile.read(sdBuffer, 512);

      for (int currByte = 0; currByte < 512; currByte++) {

        // Write command sequence
        writeByte_GB(0x7FE1, 0x2);
        writeByte_GB(0x5555, 0xAA);
        writeByte_GB(0x7FE1, 0x1);
        writeByte_GB(0x4AAA, 0x55);
        writeByte_GB(0x7FE1, 0x2);
        writeByte_GB(0x5555, 0xA0);

        // Set ROM bank
        writeByte_GB(0x7FE1, currBank);

        toggle = true;

        // Write current byte
        writeByte_GB(currAddr + currByte, sdBuffer[currByte]);
        while (toggle) {
          byte1 = readByte_GB(currAddr + currByte);
          if (byte1 == sdBuffer[currByte]) {
            toggle = false;
          }
        }
      }
      currAddr += 512;
      processedProgressBar += 512;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }

  display_Clear();
  print_STR(verifying_STR, 0);
  display_Update();

  // Go back to file beginning
  myFile.seekSet(0);
  //unsigned int addr = 0;  // unused
  writeErrors = 0;

  // Verify flashrom
  word romAddress = 0x4000;

  // Read number of banks and switch banks
  for (word bank = 0; bank < romBanks; bank++) {
    writeByte_GB(0x7FE1, bank);  // Set ROM bank
    romAddress = 0x4000;

    // Blink led
    blinkLED();

    // Read up to 1FFF per bank
    while (romAddress < 0x6000) {
      // Fill sdBuffer
      myFile.read(sdBuffer, 512);
      // Compare
      for (int i = 0; i < 512; i++) {
        if (readByte_GB(romAddress + i) != sdBuffer[i]) {
          writeErrors++;
        }
      }
      romAddress += 512;
    }
  }
  // Close the file:
  myFile.close();

  if (writeErrors == 0) {
    println_Msg(FS(FSTRING_OK));
    println_Msg(F("Please turn off the power."));
    display_Update();
  } else {
    println_Msg(F("Error"));
    print_Msg(writeErrors);
    print_STR(_bytes_STR, 1);
    print_FatalError(did_not_verify_STR);
  }
}

#endif

//******************************************
// End of File
//******************************************