cartreader/Cart_Reader/MD.ino

//******************************************
// SEGA MEGA DRIVE MODULE
//******************************************
// Writes to Sega CD Backup RAM Cart require an extra wire from MRES (B02) to VRES (B27)
#ifdef enable_MD

/******************************************
   Variables
 *****************************************/
unsigned long sramEnd;
word eepSize;
word addrhi;
word addrlo;
word chksum;
boolean is32x = 0;

//***********************************************
// EEPROM SAVE TYPES
// 1 = Acclaim Type 1    [24C02]
// 2 = Acclaim Type 2    [24C02/24C16/24C65]
// 3 = Capcom/SEGA       [24C01]
// 4 = EA                [24C01]
// 5 = Codemasters       [24C08/24C16/24C65]
//***********************************************
byte eepType;

//*********************************************************
// SERIAL EEPROM LOOKUP TABLE
// Format = {chksum, eepType | eepSize}
// chksum is located in ROM at 0x18E (0xC7)
// eepType and eepSize are combined to conserve memory
//*********************************************************
static const word PROGMEM eepid[] = {
  // ACCLAIM TYPE 1
  0x5B9F, 0x101,  // NBA Jam (J)
  0x694F, 0x101,  // NBA Jam (UE) (Rev 0)
  0xBFA9, 0x101,  // NBA Jam (UE) (Rev 1)
  // ACCLAIM TYPE 2
  0x16B2, 0x102,   // Blockbuster World Videogame Championship II (U)   [NO HEADER SAVE DATA]
  0xCC3F, 0x102,   // NBA Jam Tournament Edition (W) (Rev 0)            [NO HEADER SAVE DATA]
  0x8AE1, 0x102,   // NBA Jam Tournament Edition (W) (Rev 1)            [NO HEADER SAVE DATA]
  0xDB97, 0x102,   // NBA Jam Tournament Edition 32X (W)
  0x7651, 0x102,   // NFL Quarterback Club (W)
  0xDFE4, 0x102,   // NFL Quarterback Club 32X (W)
  0x3DE6, 0x802,   // NFL Quarterback Club '96 (UE)
  0xCB78, 0x2002,  // Frank Thomas Big Hurt Baseball (UE)
  0x6DD9, 0x2002,  // College Slam (U)
  // CAPCOM
  0xAD23, 0x83,  // Mega Man:  The Wily Wars (E)
  0xEA80, 0x83,  // Rockman Megaworld (J)
  // SEGA
  0x760F, 0x83,  // Evander "Real Deal" Holyfield Boxing (JU)
  0x95E7, 0x83,  // Greatest Heavyweights of the Ring (E)
  0x0000, 0x83,  // Greatest Heavyweights of the Ring (J)             [BLANK CHECKSUM 0000]
  0x7270, 0x83,  // Greatest Heavyweights of the Ring (U)
  0xBACC, 0x83,  // Honoo no Toukyuuji Dodge Danpei (J)
  0xB939, 0x83,  // MLBPA Sports Talk Baseball (U)                    [BAD HEADER SAVE DATA]
  0x487C, 0x83,  // Ninja Burai Densetsu (J)
  0x740D, 0x83,  // Wonder Boy in Monster World (B)
  0x0278, 0x83,  // Wonder Boy in Monster World (J)
  0x9D79, 0x83,  // Wonder Boy in Monster World (UE)
  // EA
  0x8512, 0x84,  // Bill Walsh College Football (UE)                  [BAD HEADER SAVE DATA]
  0xA107, 0x84,  // John Madden Football '93 (UE)                     [NO HEADER SAVE DATA]
  0x5807, 0x84,  // John Madden Football '93 Championship Edition (U) [NO HEADER SAVE DATA]
  0x2799, 0x84,  // NHLPA Hockey '93 (UE) (Rev 0)                     [NO HEADER SAVE DATA]
  0xFA57, 0x84,  // NHLPA Hockey '93 (UE) (Rev 1)                     [NO HEADER SAVE DATA]
  0x8B9F, 0x84,  // Rings of Power (UE)                               [NO HEADER SAVE DATA]
  // CODEMASTERS
  0x7E65, 0x405,   // Brian Lara Cricket (E)                            [NO HEADER SAVE DATA]
  0x9A5C, 0x2005,  // Brian Lara Cricket 96 (E) (Rev 1.0)               [NO HEADER SAVE DATA]
  0xC4EE, 0x2005,  // Brian Lara Cricket 96 (E) (Rev 1.1)               [NO HEADER SAVE DATA]
  0x7E50, 0x805,   // Micro Machines 2 (E) (J-Cart)                     [NO HEADER SAVE DATA]
  0x165E, 0x805,   // Micro Machines '96 (E) (J-Cart) (Rev 1.0/1.1)     [NO HEADER SAVE DATA]
  0x168B, 0x405,   // Micro Machines Military (E) (J-Cart)              [NO HEADER SAVE DATA]
  0x12C1, 0x2005,  // Shane Warne Cricket (E)                           [NO HEADER SAVE DATA]
};

byte eepcount = (sizeof(eepid) / sizeof(eepid[0])) / 2;
word eepdata;

// CD BACKUP RAM
unsigned long bramSize = 0;

// REALTEC MAPPER
boolean realtec = 0;

#define DEFAULT_VALUE_segaSram16bit 0
int segaSram16bit = DEFAULT_VALUE_segaSram16bit;

//*****************************************
// SONIC & KNUCKLES LOCK-ON MODE VARIABLES
// SnKmode :
// 0 = Not Sonic & Knuckles
// 1 = Only Sonic & Knucles
// 2 = Sonic & Knucles + Sonic1
// 3 = Sonic & Knucles + Sonic2
// 4 = Sonic & Knucles + Sonic3
// 5 = Sonic & Knucles + Other game
//*****************************************
static byte SnKmode = 0;
static unsigned long cartSizeLockon;
static unsigned long cartSizeSonic2 = 262144;
static word chksumLockon;
static word chksumSonic2 = 0x0635;

/******************************************
   Configuration
 *****************************************/
#ifdef use_md_conf
void mdLoadConf() {
  if (myFile.open("mdconf.txt", O_READ)) {
    char line[64];
    int n;
    int i;
    while ((n = myFile.fgets(line, sizeof(line) - 1)) > 0) {
      // preprocess
      for (i = 0; i < n; i++) {
        if (line[i] == ';') {
          // comments
          line[i] = '\0';
          n = i;
          break;
        } else if (line[i] == '\n' || line[i] == '\r') {
          // EOL
          line[n] = '\0';
          n = i;
          break;
        }
      }
      //print_Msg(F("read line: "));
      //println_Msg(line);
      if (line[0] == '[') {
        char* name;
        char* value;
        i = 1;
        name = line + i;
        for (; i < sizeof(line); i++) {
          if (line[i] == ']') {
            line[i] = '\0';
            i++;
            break;
          }
        }
        if (line[i] != '\0') {
          for (; i < sizeof(line); i++) {
            if (line[i] != ' ') {
              value = line + i;
              i++;
              break;
            }
          }
          for (; i < sizeof(line) && line[i] != '\0'; i++) {
            if (line[i] == ' ') {
              line[i] = '\0';
              break;
            }
          }
        }
        //print_Msg(F("read name: "));
        //println_Msg(name);
        //print_Msg(F("value: "));
        //println_Msg(value);
        if (!strcmp("segaSram16bit", name)) {
          // Retrode compatible setting
          // [segaSram16bit] 1   ; 0=no, 1=yes, 2=y+large
          // 0: Output each byte once. Not supported by most emulators.
          // 1: Duplicate each byte. Usable by Kega Fusion.
          // 2: Duplicate each byte. Pad with 0xFF so that the file size is 64KB.
          segaSram16bit = atoi(value);
          if (segaSram16bit != 0 && segaSram16bit != 1 && segaSram16bit != 2) {
            segaSram16bit = DEFAULT_VALUE_segaSram16bit;
          }
          print_Msg(F("segaSram16bit: "));
          println_Msg(segaSram16bit);
        }
      }
    }
    myFile.close();
  }
}
#endif

/******************************************
   Menu
 *****************************************/
// MD menu items
static const char MDMenuItem1[] PROGMEM = "Game Cartridge";
static const char MDMenuItem2[] PROGMEM = "SegaCD RamCart";
static const char MDMenuItem3[] PROGMEM = "Flash Repro";
//static const char MDMenuItem4[] PROGMEM = "Reset"; (stored in common strings array)
static const char* const menuOptionsMD[] PROGMEM = { MDMenuItem1, MDMenuItem2, MDMenuItem3, string_reset2 };

// Cart menu items
static const char MDCartMenuItem1[] PROGMEM = "Read Rom";
static const char MDCartMenuItem2[] PROGMEM = "Read Sram";
static const char MDCartMenuItem3[] PROGMEM = "Write Sram";
static const char MDCartMenuItem4[] PROGMEM = "Read EEPROM";
static const char MDCartMenuItem5[] PROGMEM = "Write EEPROM";
static const char MDCartMenuItem6[] PROGMEM = "Cycle cart";
//static const char MDCartMenuItem7[] PROGMEM = "Reset"; (stored in common strings array)
static const char* const menuOptionsMDCart[] PROGMEM = { MDCartMenuItem1, MDCartMenuItem2, MDCartMenuItem3, MDCartMenuItem4, MDCartMenuItem5, MDCartMenuItem6, string_reset2 };

// Sega CD Ram Backup Cartridge menu items
static const char SCDMenuItem1[] PROGMEM = "Read Backup RAM";
static const char SCDMenuItem2[] PROGMEM = "Write Backup RAM";
//static const char SCDMenuItem3[] PROGMEM = "Reset"; (stored in common strings array)
static const char* const menuOptionsSCD[] PROGMEM = { SCDMenuItem1, SCDMenuItem2, string_reset2 };

// Sega start menu
void mdMenu() {
  // create menu with title and 4 options to choose from
  unsigned char mdDev;
  // Copy menuOptions out of progmem
  convertPgm(menuOptionsMD, 4);
  mdDev = question_box(F("Select MD device"), menuOptions, 4, 0);

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

    case 1:
      display_Clear();
      display_Update();
      setup_MD();
      mode = mode_SEGA_CD;
      break;

#ifdef enable_FLASH
    case 2:
      display_Clear();
      display_Update();
      setup_MD();
      mode = mode_MD_Cart;
      // Change working dir to root
      filePath[0] = '\0';
      sd.chdir("/");
      fileBrowser(F("Select file"));
      display_Clear();
      // Setting CS(PH3) LOW
      PORTH &= ~(1 << 3);

      // ID flash
      resetFlash_MD();
      idFlash_MD();
      resetFlash_MD();
      print_Msg(F("Flash ID: "));
      println_Msg(flashid_str);
      if (flashid == 0xC2F1) {
        println_Msg(F("MX29F1610 detected"));
        flashSize = 2097152;
      } else {
        print_FatalError(F("Error: Unknown flashrom"));
      }
      display_Update();

      eraseFlash_MD();
      resetFlash_MD();
      blankcheck_MD();
      write29F1610_MD();
      resetFlash_MD();
      delay(1000);
      resetFlash_MD();
      delay(1000);
      verifyFlash_MD();
      // Set CS(PH3) HIGH
      PORTH |= (1 << 3);
      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();
      break;
#endif

    case 3:
      resetArduino();
      break;
  }
}

void mdCartMenu() {
  // create menu with title and 6 options to choose from
  unsigned char mainMenu;
  // Copy menuOptions out of progmem
  convertPgm(menuOptionsMDCart, 7);
  mainMenu = question_box(F("MEGA DRIVE Reader"), menuOptions, 7, 0);

  // wait for user choice to come back from the question box menu
  switch (mainMenu) {
    case 0:
      display_Clear();

      // common ROM read fail state: no cart inserted - tends to report impossibly large cartSize
      // largest known game so far is supposedly "Paprium" at 10MB, so cap sanity check at 16MB
      if (cartSize != 0 && cartSize <= 16777216) {
        // Change working dir to root
        sd.chdir("/");
        if (realtec) {
          readRealtec_MD();
        } else {
          readROM_MD();
        }
      } else {
        print_Error(F("Cart has no ROM"));
      }
#ifdef global_log
      save_log();
#endif
      break;

    case 1:
      display_Clear();
      // Does cartridge have SRAM
      if ((saveType == 1) || (saveType == 2) || (saveType == 3)) {
        // Change working dir to root
        sd.chdir("/");
        println_Msg(F("Reading Sram..."));
        display_Update();
        enableSram_MD(1);
        readSram_MD();
        enableSram_MD(0);
      } else {
        print_Error(F("Cart has no Sram"));
      }
      break;

    case 2:
      display_Clear();
      // Does cartridge have SRAM
      if ((saveType == 1) || (saveType == 2) || (saveType == 3)) {
        // Change working dir to root
        sd.chdir("/");
        // Launch file browser
        fileBrowser(F("Select srm file"));
        display_Clear();
        enableSram_MD(1);
        writeSram_MD();
        writeErrors = verifySram_MD();
        enableSram_MD(0);
        if (writeErrors == 0) {
          println_Msg(F("Sram verified 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_Error(F("Cart has no Sram"));
      }
      break;

    case 3:
      display_Clear();
      if (saveType == 4)
        readEEP_MD();
      else {
        print_Error(F("Cart has no EEPROM"));
      }
      break;

    case 4:
      display_Clear();
      if (saveType == 4) {
        // Launch file browser
        fileBrowser(F("Select eep file"));
        display_Clear();
        writeEEP_MD();
      } else {
        print_Error(F("Cart has no EEPROM"));
      }
      break;

    case 5:
      // For multi-game carts
      // Set reset pin to output (PH0)
      DDRH |= (1 << 0);
      // Switch RST(PH0) to LOW
      PORTH &= ~(1 << 0);

      display_Clear();
      print_Msg(F("Resetting..."));
      display_Update();
      delay(3000);  // wait 3 secs to switch to next game
      resetArduino();
      break;

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

void segaCDMenu() {
  // create menu with title and 3 options to choose from
  unsigned char scdMenu;
  // Copy menuOptions out of progmem
  convertPgm(menuOptionsSCD, 3);
  scdMenu = question_box(F("SEGA CD RAM"), menuOptions, 3, 0);

  // wait for user choice to come back from the question box menu
  switch (scdMenu) {
    case 0:
      display_Clear();
      if (bramSize > 0)
        readBram_MD();
      else {
        print_Error(F("Not CD Backup RAM Cart"));
      }
      break;

    case 1:
      display_Clear();
      if (bramSize > 0) {
        // Launch file browser
        fileBrowser(F("Select brm file"));
        display_Clear();
        writeBram_MD();
      } else {
        print_Error(F("Not CD Backup RAM Cart"));
      }
      break;

    case 2:
      // Reset
      asm volatile("  jmp 0");
      break;
  }
  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();
}

/******************************************
   Setup
 *****************************************/
void setup_MD() {
#ifdef use_md_conf
  mdLoadConf();
#endif

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

  // Set Control Pins to Output RST(PH0) CLK(PH1) CS(PH3) WRH(PH4) WRL(PH5) OE(PH6)
  DDRH |= (1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);

  // Set TIME(PJ0) to Output
  DDRJ |= (1 << 0);

  // Set Data Pins (D0-D15) to Input
  DDRC = 0x00;
  DDRA = 0x00;

  // Setting RST(PH0) CLK(PH1) CS(PH3) WRH(PH4) WRL(PH5) OE(PH6) HIGH
  PORTH |= (1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);

  // Setting TIME(PJ0) HIGH
  PORTJ |= (1 << 0);

  delay(200);

  // Print all the info
  getCartInfo_MD();
}

/******************************************
   I/O Functions
 *****************************************/

/******************************************
  Low level functions
*****************************************/
void writeWord_MD(unsigned long myAddress, word myData) {
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTL = (myAddress >> 16) & 0xFF;
  PORTC = myData;
  PORTA = (myData >> 8) & 0xFF;

  // Arduino running at 16Mhz -> one nop = 62.5ns
  // Wait till output is stable
  __asm__("nop\n\t"
          "nop\n\t");

  // Switch WR(PH5) to LOW
  PORTH &= ~(1 << 5);
  // Setting CS(PH3) LOW
  PORTH &= ~(1 << 3);

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

  // Setting CS(PH3) HIGH
  PORTH |= (1 << 3);
  // Switch WR(PH5) to HIGH
  PORTH |= (1 << 5);

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

word readWord_MD(unsigned long myAddress) {
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTL = (myAddress >> 16) & 0xFF;

  // Arduino running at 16Mhz -> one nop = 62.5ns
  NOP;

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

  // most MD ROMs are 200ns, comparable to SNES > use similar access delay of 6 x 62.5 = 375ns
  NOP;
  NOP;
  NOP;
  NOP;
  NOP;
  NOP;

  // Read
  word tempWord = ((PINA & 0xFF) << 8) | (PINC & 0xFF);

  // Setting CS(PH3) HIGH
  PORTH |= (1 << 3);
  // Setting OE(PH6) HIGH
  PORTH |= (1 << 6);

  // these 6x nop delays have been here before, unknown what they mean
  NOP;
  NOP;
  NOP;
  NOP;
  NOP;
  NOP;

  return tempWord;
}

void writeFlash_MD(unsigned long myAddress, word myData) {
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTL = (myAddress >> 16) & 0xFF;
  PORTC = myData;
  PORTA = (myData >> 8) & 0xFF;

  // Arduino running at 16Mhz -> one nop = 62.5ns
  // Wait till output is stable
  __asm__("nop\n\t");

  // Switch WE(PH5) to LOW
  PORTH &= ~(1 << 5);

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

  // Switch WE(PH5)to HIGH
  PORTH |= (1 << 5);

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

word readFlash_MD(unsigned long myAddress) {
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTL = (myAddress >> 16) & 0xFF;

  // Arduino running at 16Mhz -> one nop = 62.5ns
  __asm__("nop\n\t");

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

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

  // Read
  word tempWord = ((PINA & 0xFF) << 8) | (PINC & 0xFF);

  __asm__("nop\n\t");

  // Setting OE(PH6) HIGH
  PORTH |= (1 << 6);
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  return tempWord;
}

// Switch data pins to write
void dataOut_MD() {
  DDRC = 0xFF;
  DDRA = 0xFF;
}

// Switch data pins to read
void dataIn_MD() {
  DDRC = 0x00;
  DDRA = 0x00;
}

/******************************************
  MEGA DRIVE functions
*****************************************/
byte copyToRomName_MD(char* output, const byte* input, byte length) {
  byte myLength = 0;

  for (byte i = 0; i < 48; i++) {
    if (
      (
        (input[i] >= '0' && input[i] <= '9') || (input[i] >= 'A' && input[i] <= 'z'))
      && myLength < length) {
      output[myLength++] = input[i];
    }
  }

  return myLength;
}

void getCartInfo_MD() {
  // Set control
  dataIn_MD();

  cartSize = ((long(readWord_MD(0xD2)) << 16) | readWord_MD(0xD3)) + 1;

  if ((readWord_MD(0x104 / 2) == 0x2033) && (readWord_MD(0x106 / 2) == 0x3258))
    is32x = 1;
  else
    is32x = 0;

  // Cart Checksum
  chksum = readWord_MD(0xC7);

  // Zero Wing Check
  if (cartSize == 0x80000) {
    switch (chksum) {
      case 0xD07D:            //Zero Wing (J) 8Mbit
        cartSize = 0x100000;  //1MB instead of 512KB
        chksum = 0xF204;
        break;
    }
  }

  // Super Street Fighter 2 Check
  if (cartSize == 0x400000) {
    switch (chksum) {
      case 0xCE25:  // Super Street Fighter 2 (J) 40Mbit
      case 0xE41D:  // Super Street Fighter 2 (E) 40Mbit
      case 0xE017:  // Super Street Fighter 2 (U) 40Mbit
        cartSize = 0x500000;
        break;
    }
  }

  // Sonic & Knuckles Check
  SnKmode = 0;
  if (chksum == 0xDFB3) {
    char id[15];
    memset(id, 0, 15);

    // Get ID
    for (byte c = 0; c < 14; c += 2) {
      // split word
      word myWord = readWord_MD((0x180 + c) / 2);
      byte loByte = myWord & 0xFF;
      byte hiByte = myWord >> 8;

      // write to buffer
      id[c] = hiByte;
      id[c + 1] = loByte;
    }

    //Sonic & Knuckles ID:GM MK-1563 -00
    if (!strcmp("GM MK-1563 -00", id)) {
      char labelLockon[17];
      memset(labelLockon, 0, 17);

      // Get labelLockon
      for (byte c = 0; c < 16; c += 2) {
        // split word
        word myWord = readWord_MD((0x200100 + c) / 2);
        byte loByte = myWord & 0xFF;
        byte hiByte = myWord >> 8;

        // write to buffer
        labelLockon[c] = hiByte;
        labelLockon[c + 1] = loByte;
      }

      // check Lock-on game presence
      if (!(strcmp("SEGA MEGA DRIVE ", labelLockon) & strcmp("SEGA GENESIS    ", labelLockon))) {
        char idLockon[15];
        memset(idLockon, 0, 15);

        // Lock-on cart checksum
        chksumLockon = readWord_MD(0x1000C7);
        // Lock-on cart size
        cartSizeLockon = ((long(readWord_MD(0x1000D2)) << 16) | readWord_MD(0x1000D3)) + 1;

        // Get IdLockon
        for (byte c = 0; c < 14; c += 2) {
          // split word
          word myWord = readWord_MD((0x200180 + c) / 2);
          byte loByte = myWord & 0xFF;
          byte hiByte = myWord >> 8;

          // write to buffer
          idLockon[c] = hiByte;
          idLockon[c + 1] = loByte;
        }

        if (!strncmp("GM 00001009-0", idLockon, 13) || !strncmp("GM 00004049-0", idLockon, 13)) {
          //Sonic1 ID:GM 00001009-0? or GM 00004049-0?
          SnKmode = 2;
        } else if (!strcmp("GM 00001051-00", idLockon) || !strcmp("GM 00001051-01", idLockon) || !strcmp("GM 00001051-02", idLockon)) {
          //Sonic2 ID:GM 00001051-00 or GM 00001051-01 or GM 00001051-02
          SnKmode = 3;

          // Prepare Sonic2 Banks
          writeSSF2Map(0x509878, 1);  // 0xA130F1

        } else if (!strcmp("GM MK-1079 -00", idLockon)) {
          //Sonic3 ID:GM MK-1079 -00
          SnKmode = 4;
        } else {
          //Other game
          SnKmode = 5;
        }

      } else {
        SnKmode = 1;
      }
    }
  }

  // Serial EEPROM Check
  for (int i = 0; i < eepcount; i++) {
    int index = i * 2;
    word eepcheck = pgm_read_word(eepid + index);
    if (eepcheck == chksum) {
      eepdata = pgm_read_word(eepid + index + 1);
      eepType = eepdata & 0x7;
      eepSize = eepdata & 0xFFF8;
      saveType = 4;  // SERIAL EEPROM
      break;
    }
  }

  // Greatest Heavyweights of the Ring (J) has blank chksum 0x0000
  // Other non-save carts might have the same blank chksum
  // Check header for Serial EEPROM Data
  if (chksum == 0x0000) {
    if (readWord_MD(0xD9) != 0xE840) {  // NOT SERIAL EEPROM
      eepType = 0;
      eepSize = 0;
      saveType = 0;
    }
  }

  // Codemasters EEPROM Check
  // Codemasters used the same incorrect header across multiple carts
  // Carts with checksum 0x165E or 0x168B could be EEPROM or non-EEPROM
  // Check the first DWORD in ROM (0x444E4C44) to identify the EEPROM carts
  if ((chksum == 0x165E) || (chksum == 0x168B)) {
    if (readWord_MD(0x00) != 0x444E) {  // NOT SERIAL EEPROM
      eepType = 0;
      eepSize = 0;
      saveType = 0;
    }
  }

  // CD Backup RAM Cart Check
  // 4 = 128KB (2045 Blocks) Sega CD Backup RAM Cart
  // 6 = 512KB (8189 Blocks) Ultra CD Backup RAM Cart (Aftermarket)
  word bramCheck = readWord_MD(0x00);
  if ((((bramCheck & 0xFF) == 0x04) && ((chksum & 0xFF) == 0x04))
      || (((bramCheck & 0xFF) == 0x06) && ((chksum & 0xFF) == 0x06))) {
    unsigned long p = 1 << (bramCheck & 0xFF);
    bramSize = p * 0x2000L;
  }
  if (saveType != 4) {  // NOT SERIAL EEPROM
    // Check if cart has sram
    saveType = 0;
    sramSize = 0;

    // FIXED CODE FOR SRAM/FRAM/PARALLEL EEPROM
    // 0x5241F820 SRAM (ODD BYTES/EVEN BYTES)
    // 0x5241F840 PARALLEL EEPROM - READ AS SRAM
    // 0x5241E020 SRAM (BOTH BYTES)
    if (readWord_MD(0xD8) == 0x5241) {
      word sramType = readWord_MD(0xD9);
      if ((sramType == 0xF820) || (sramType == 0xF840)) {  // SRAM/FRAM ODD/EVEN BYTES
        // Get sram start and end
        sramBase = ((long(readWord_MD(0xDA)) << 16) | readWord_MD(0xDB));
        sramEnd = ((long(readWord_MD(0xDC)) << 16) | readWord_MD(0xDD));
        if (sramBase == 0x20000020 && sramEnd == 0x00010020) {  // Fix for Psy-o-blade
          sramBase = 0x200001;
          sramEnd = 0x203fff;
        }
        // Check alignment of sram
        if ((sramBase == 0x200001) || (sramBase == 0x300001)) {  // ADDED 0x300001 FOR HARDBALL '95 (U)
          // low byte
          saveType = 1;  // ODD
          sramSize = (sramEnd - sramBase + 2) / 2;
          // Right shift sram base address so [A21] is set to high 0x200000 = 0b001[0]00000000000000000000
          sramBase = sramBase >> 1;
        } else if (sramBase == 0x200000) {
          // high byte
          saveType = 2;  // EVEN
          sramSize = (sramEnd - sramBase + 1) / 2;
          // Right shift sram base address so [A21] is set to high 0x200000 = 0b001[0]00000000000000000000
          sramBase = sramBase / 2;
        } else {
          print_Msg(("sramType: "));
          print_Msg_PaddedHex16(sramType);
          println_Msg(F(""));
          print_Msg(("sramBase: "));
          print_Msg_PaddedHex32(sramBase);
          println_Msg(F(""));
          print_Msg(("sramEnd: "));
          print_Msg_PaddedHex32(sramEnd);
          println_Msg(F(""));
          print_FatalError(F("Unknown Sram Base"));
        }
      } else if (sramType == 0xE020) {  // SRAM BOTH BYTES
        // Get sram start and end
        sramBase = ((long(readWord_MD(0xDA)) << 16) | readWord_MD(0xDB));
        sramEnd = ((long(readWord_MD(0xDC)) << 16) | readWord_MD(0xDD));

        if (sramBase == 0x200001) {
          saveType = 3;  // BOTH
          sramSize = sramEnd - sramBase + 2;
          sramBase = sramBase >> 1;
        } else if (sramBase == 0x200000) {
          saveType = 3;  // BOTH
          sramSize = sramEnd - sramBase + 1;
          sramBase = sramBase >> 1;
        } else {
          print_Msg(("sramType: "));
          print_Msg_PaddedHex16(sramType);
          println_Msg(F(""));
          print_Msg(("sramBase: "));
          print_Msg_PaddedHex32(sramBase);
          println_Msg(F(""));
          print_Msg(("sramEnd: "));
          print_Msg_PaddedHex32(sramEnd);
          println_Msg(F(""));
          print_FatalError(F("Unknown Sram Base"));
        }
      }
    } else {
      // SRAM CARTS WITH BAD/MISSING HEADER SAVE DATA
      switch (chksum) {
        case 0xC2DB:     // Winter Challenge (UE)
          saveType = 1;  // ODD
          sramBase = 0x200001;
          sramEnd = 0x200FFF;
          break;

        case 0xD7B6:     // Buck Rogers: Countdown to Doomsday (UE)
        case 0xFE3E:     // NBA Live '98 (U)
        case 0xFDAD:     // NFL '94 starring Joe Montana (U)
        case 0x632E:     // PGA Tour Golf (UE) (Rev 1)
        case 0xD2BA:     // PGA Tour Golf (UE) (Rev 2)
        case 0x44FE:     // Super Hydlide (J)
          saveType = 1;  // ODD
          sramBase = 0x200001;
          sramEnd = 0x203FFF;
          break;

        case 0xDB5E:     // Might & Magic: Gates to Another World (UE) (Rev 1)
        case 0x3428:     // Starflight (UE) (Rev 0)
        case 0x43EE:     // Starflight (UE) (Rev 1)
          saveType = 3;  // BOTH
          sramBase = 0x200001;
          sramEnd = 0x207FFF;
          break;

        case 0xBF72:     // College Football USA '96 (U)
        case 0x72EF:     // FIFA Soccer '97 (UE)
        case 0xD723:     // Hardball III (U)
        case 0x06C1:     // Madden NFL '98 (U)
        case 0xDB17:     // NHL '96 (UE)
        case 0x5B3A:     // NHL '98 (U)
        case 0x2CF2:     // NFL Sports Talk Football '93 starring Joe Montana (UE)
        case 0xE9B1:     // Summer Challenge (U)
        case 0xEEE8:     // Test Drive II: The Duel (U)
          saveType = 1;  // ODD
          sramBase = 0x200001;
          sramEnd = 0x20FFFF;
          break;
      }
      if (saveType == 1) {
        sramSize = (sramEnd - sramBase + 2) / 2;
        sramBase = sramBase >> 1;
      } else if (saveType == 3) {
        sramSize = sramEnd - sramBase + 2;
        sramBase = sramBase >> 1;
      }
    }
  }

  // Get name
  for (byte c = 0; c < 48; c += 2) {
    // split word
    word myWord = readWord_MD((0x150 + c) / 2);
    byte loByte = myWord & 0xFF;
    byte hiByte = myWord >> 8;

    // write to buffer
    sdBuffer[c] = hiByte;
    sdBuffer[c + 1] = loByte;
  }
  romName[copyToRomName_MD(romName, sdBuffer, sizeof(romName) - 1)] = 0;

  //Get Lock-on cart name
  if (SnKmode >= 2) {
    char romNameLockon[12];

    //Change romName
    strcpy(romName, "SnK_");

    for (byte c = 0; c < 48; c += 2) {
      // split word
      word myWord = readWord_MD((0x200150 + c) / 2);
      byte loByte = myWord & 0xFF;
      byte hiByte = myWord >> 8;

      // write to buffer
      sdBuffer[c] = hiByte;
      sdBuffer[c + 1] = loByte;
    }
    romNameLockon[copyToRomName_MD(romNameLockon, sdBuffer, sizeof(romNameLockon) - 1)] = 0;

    switch (SnKmode) {
      case 2: strcat(romName, "SONIC1"); break;
      case 3: strcat(romName, "SONIC2"); break;
      case 4: strcat(romName, "SONIC3"); break;
      case 5: strcat(romName, romNameLockon); break;
    }
  }

  // Realtec Mapper Check
  word realtecCheck1 = readWord_MD(0x3F080);  // 0x7E100 "SEGA" (BootROM starts at 0x7E000)
  word realtecCheck2 = readWord_MD(0x3F081);
  if ((realtecCheck1 == 0x5345) && (realtecCheck2 == 0x4741)) {
    realtec = 1;
    strcpy(romName, "Realtec");
    cartSize = 0x80000;
  }

  display_Clear();
  println_Msg(F("Cart Info"));
  println_Msg(F(" "));
  print_Msg(F("Name: "));
  println_Msg(romName);
  if (bramCheck != 0x00FF) {
    print_Msg(F("bramCheck: "));
    print_Msg_PaddedHex16(bramCheck);
    println_Msg(F(""));
  }
  if (bramSize > 0) {
    print_Msg(F("bramSize(KB): "));
    println_Msg(bramSize >> 10);
  }
  print_Msg(F("Size: "));
  print_Msg(cartSize * 8 / 1024 / 1024);
  switch (SnKmode) {
    case 2:
    case 4:
    case 5:
      print_Msg(F("+"));
      print_Msg(cartSizeLockon * 8 / 1024 / 1024);
      break;
    case 3:
      print_Msg(F("+"));
      print_Msg(cartSizeLockon * 8 / 1024 / 1024);
      print_Msg(F("+"));
      print_Msg(cartSizeSonic2 * 8 / 1024 / 1024);
      break;
  }
  println_Msg(F(" MBit"));
  print_Msg(F("ChkS: "));
  print_Msg_PaddedHexByte((chksum >> 8));
  print_Msg_PaddedHexByte((chksum & 0x00ff));
  switch (SnKmode) {
    case 2:
    case 4:
    case 5:
      print_Msg(F("+"));
      print_Msg_PaddedHexByte((chksumLockon >> 8));
      print_Msg_PaddedHexByte((chksumLockon & 0x00ff));
      break;
    case 3:
      print_Msg(F("+"));
      print_Msg_PaddedHexByte((chksumLockon >> 8));
      print_Msg_PaddedHexByte((chksumLockon & 0x00ff));
      print_Msg(F("+"));
      print_Msg_PaddedHexByte((chksumSonic2 >> 8));
      print_Msg_PaddedHexByte((chksumSonic2 & 0x00ff));
      break;
  }
  println_Msg(F(""));
  if (saveType == 4) {
    print_Msg(F("Serial EEPROM: "));
    print_Msg(eepSize * 8 / 1024);
    println_Msg(F(" KBit"));
  } else {
    print_Msg(F("Sram: "));
    if (sramSize > 0) {
      print_Msg(sramSize * 8 / 1024);
      println_Msg(F(" KBit"));
    } else
      println_Msg(F("None"));
  }
  println_Msg(F(" "));

  // Wait for user input
#if (defined(enable_LCD) || defined(enable_OLED))
  // Prints string out of the common strings array either with or without newline
  print_STR(press_button_STR, 1);
  display_Update();
  wait();
#endif
}

void writeSSF2Map(unsigned long myAddress, word myData) {
  dataOut_MD();

  // Set TIME(PJ0) HIGH
  PORTJ |= (1 << 0);

  // 0x50987E * 2 = 0xA130FD  Bank 6 (0x300000-0x37FFFF)
  // 0x50987F * 2 = 0xA130FF  Bank 7 (0x380000-0x3FFFFF)
  PORTL = (myAddress >> 16) & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTF = myAddress & 0xFF;
  PORTC = myData;
  PORTA = (myData >> 8) & 0xFF;

  // Arduino running at 16Mhz -> one nop = 62.5ns
  // Wait till output is stable
  __asm__("nop\n\t"
          "nop\n\t");

  // Strobe TIME(PJ0) LOW to latch the data
  PORTJ &= ~(1 << 0);
  // Switch WR(PH5) to LOW
  PORTH &= ~(1 << 5);

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

  // Switch WR(PH5) to HIGH
  PORTH |= (1 << 5);
  // Set TIME(PJ0) HIGH
  PORTJ |= (1 << 0);

  dataIn_MD();
}

// Read rom and save to the SD card
void readROM_MD() {
  // Checksum
  uint16_t calcCKS = 0;
  uint16_t calcCKSLockon = 0;
  uint16_t calcCKSSonic2 = 0;

  // Set control
  dataIn_MD();

  // Get name, add extension and convert to char array for sd lib
  strcpy(fileName, romName);
  strcat(fileName, ".BIN");

  // create a new folder
  EEPROM_readAnything(0, foldern);
  sprintf(folder, "MD/ROM/%s/%d", romName, foldern);
  sd.mkdir(folder, true);
  sd.chdir(folder);

  display_Clear();
  print_STR(saving_to_STR, 0);
  print_Msg(folder);
  println_Msg(F("/..."));
  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(sd_error_STR);
  }

  byte buffer[1024] = { 0 };

  // get current time
  // unsigned long startTime = millis();

  // Phantasy Star/Beyond Oasis with 74HC74 and 74HC139 switch ROM/SRAM at address 0x200000
  if (0x200000 < cartSize && cartSize < 0x400000) {
    enableSram_MD(0);
  }

  // Prepare SSF2 Banks
  if (cartSize > 0x400000) {
    writeSSF2Map(0x50987E, 6);  // 0xA130FD
    writeSSF2Map(0x50987F, 7);  // 0xA130FF
  }
  byte offsetSSF2Bank = 0;
  word d = 0;

  //Initialize progress bar
  uint32_t processedProgressBar = 0;
  uint32_t totalProgressBar = (uint32_t)(cartSize);
  if (SnKmode >= 2) totalProgressBar += (uint32_t)cartSizeLockon;
  if (SnKmode == 3) totalProgressBar += (uint32_t)cartSizeSonic2;
  draw_progressbar(0, totalProgressBar);

  for (unsigned long currBuffer = 0; currBuffer < cartSize / 2; currBuffer += 512) {
    // Blink led
    if (currBuffer % 16384 == 0)
      blinkLED();

    if ((currBuffer == 0x200000) && (cartSize > 0x400000)) {
      writeSSF2Map(0x50987E, 8);  // 0xA130FD
      offsetSSF2Bank = 1;
    } else if ((currBuffer == 0x240000) && (cartSize > 0x400000)) {
      writeSSF2Map(0x50987F, 9);  // 0xA130FF
      offsetSSF2Bank = 1;
    }

    d = 0;

    for (int currWord = 0; currWord < 512; currWord++) {
      unsigned long myAddress = currBuffer + currWord - (offsetSSF2Bank * 0x80000);
      PORTF = myAddress & 0xFF;
      PORTK = (myAddress >> 8) & 0xFF;
      PORTL = (myAddress >> 16) & 0xFF;

      // Arduino running at 16Mhz -> one nop = 62.5ns
      NOP;
      // Setting CS(PH3) LOW
      PORTH &= ~(1 << 3);
      // Setting OE(PH6) LOW
      PORTH &= ~(1 << 6);
      // most MD ROMs are 200ns, comparable to SNES > use similar access delay of 6 x 62.5 = 375ns
      NOP;
      NOP;
      NOP;
      NOP;
      NOP;
      NOP;

      // Read
      buffer[d] = PINA;
      buffer[d + 1] = PINC;

      // Setting CS(PH3) HIGH
      PORTH |= (1 << 3);
      // Setting OE(PH6) HIGH
      PORTH |= (1 << 6);

      // Skip first 256 words
      if (((currBuffer == 0) && (currWord >= 256)) || (currBuffer > 0)) {
        calcCKS += ((buffer[d] << 8) | buffer[d + 1]);
      }
      d += 2;
    }
    myFile.write(buffer, 1024);

    // update progress bar
    processedProgressBar += 1024;
    draw_progressbar(processedProgressBar, totalProgressBar);
  }
  if (SnKmode >= 2) {
    for (unsigned long currBuffer = 0; currBuffer < cartSizeLockon / 2; currBuffer += 512) {
      // Blink led
      if (currBuffer % 16384 == 0)
        blinkLED();

      d = 0;

      for (int currWord = 0; currWord < 512; currWord++) {
        unsigned long myAddress = currBuffer + currWord + cartSize / 2;
        PORTF = myAddress & 0xFF;
        PORTK = (myAddress >> 8) & 0xFF;
        PORTL = (myAddress >> 16) & 0xFF;

        // Arduino running at 16Mhz -> one nop = 62.5ns
        NOP;
        // Setting CS(PH3) LOW
        PORTH &= ~(1 << 3);
        // Setting OE(PH6) LOW
        PORTH &= ~(1 << 6);
        // most MD ROMs are 200ns, comparable to SNES > use similar access delay of 6 x 62.5 = 375ns
        NOP;
        NOP;
        NOP;
        NOP;
        NOP;
        NOP;

        // Read
        buffer[d] = PINA;
        buffer[d + 1] = PINC;

        // Setting CS(PH3) HIGH
        PORTH |= (1 << 3);
        // Setting OE(PH6) HIGH
        PORTH |= (1 << 6);

        // Skip first 256 words
        if (((currBuffer == 0) && (currWord >= 256)) || (currBuffer > 0)) {
          calcCKSLockon += ((buffer[d] << 8) | buffer[d + 1]);
        }
        d += 2;
      }
      myFile.write(buffer, 1024);

      // update progress bar
      processedProgressBar += 1024;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }
  if (SnKmode == 3) {
    for (unsigned long currBuffer = 0; currBuffer < cartSizeSonic2 / 2; currBuffer += 512) {
      // Blink led
      if (currBuffer % 16384 == 0)
        blinkLED();

      d = 0;

      for (int currWord = 0; currWord < 512; currWord++) {
        unsigned long myAddress = currBuffer + currWord + (cartSize + cartSizeLockon) / 2;
        PORTF = myAddress & 0xFF;
        PORTK = (myAddress >> 8) & 0xFF;
        PORTL = (myAddress >> 16) & 0xFF;

        // Arduino running at 16Mhz -> one nop = 62.5ns
        NOP;
        // Setting CS(PH3) LOW
        PORTH &= ~(1 << 3);
        // Setting OE(PH6) LOW
        PORTH &= ~(1 << 6);
        // most MD ROMs are 200ns, comparable to SNES > use similar access delay of 6 x 62.5 = 375ns
        NOP;
        NOP;
        NOP;
        NOP;
        NOP;
        NOP;

        // Read
        buffer[d] = PINA;
        buffer[d + 1] = PINC;

        // Setting CS(PH3) HIGH
        PORTH |= (1 << 3);
        // Setting OE(PH6) HIGH
        PORTH |= (1 << 6);

        calcCKSSonic2 += ((buffer[d] << 8) | buffer[d + 1]);
        d += 2;
      }
      myFile.write(buffer, 1024);

      // update progress bar
      processedProgressBar += 1024;
      draw_progressbar(processedProgressBar, totalProgressBar);
    }
  }
  // Close the file:
  myFile.close();

  // Reset SSF2 Banks
  if (cartSize > 0x400000) {
    writeSSF2Map(0x50987E, 6);  // 0xA130FD
    writeSSF2Map(0x50987F, 7);  // 0xA130FF
  }

  // print elapsed time
  //print_Msg(F("Time elapsed: "));
  //print_Msg((millis() - startTime) / 1000);
  //println_Msg(F("s"));
  //display_Update();

  // Calculate internal checksum
  print_Msg(F("Internal checksum..."));
  display_Update();
  if (chksum == calcCKS) {
    println_Msg(F("OK"));
    display_Update();
  } else {
    println_Msg(F("Error"));
    char calcsumStr[5];
    sprintf(calcsumStr, "%04X", calcCKS);
    println_Msg(calcsumStr);
    print_Error(F(""));
    display_Update();
  }

  // More checksums
  if (SnKmode >= 2) {
    print_Msg(F("Lock-on checksum..."));
    if (chksumLockon == calcCKSLockon) {
      println_Msg(F("OK"));
      display_Update();
    } else {
      print_Msg(F("Error"));
      char calcsumStr[5];
      sprintf(calcsumStr, "%04X", calcCKSLockon);
      println_Msg(calcsumStr);
      print_Error(F(""));
      display_Update();
    }
  }
  if (SnKmode == 3) {
    print_Msg(F("Adittional checksum..."));
    if (chksumSonic2 == calcCKSSonic2) {
      println_Msg(F("OK"));
      display_Update();
    } else {
      print_Msg(F("Error"));
      char calcsumStr[5];
      sprintf(calcsumStr, "%04X", calcCKSSonic2);
      println_Msg(calcsumStr);
      print_Error(F(""));
      display_Update();
    }
  }

  // Calculate and compare CRC32 with nointro
  if (is32x)
    //database, crcString, renamerom, offset
    compareCRC("32x.txt", 0, 1, 0);
  else
    compareCRC("md.txt", 0, 1, 0);

}

/******************************************
  SRAM functions
*****************************************/
// Sonic 3 sram enable
void enableSram_MD(boolean enableSram) {
  dataOut_MD();

  // Set D0 to either 1(enable SRAM) or 0(enable ROM)
  PORTC = enableSram;

  // Strobe TIME(PJ0) LOW to latch the data
  PORTJ &= ~(1 << 0);
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");
  // Set TIME(PJ0) HIGH
  PORTJ |= (1 << 0);
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");

  dataIn_MD();
}

// Write sram to cartridge
void writeSram_MD() {
  dataOut_MD();

  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);
  println_Msg(F("Writing..."));
  println_Msg(filePath);
  display_Update();

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {
    // Write to the lower byte
    if (saveType == 1) {
      for (unsigned long currByte = sramBase; currByte < sramBase + sramSize; currByte++) {
        if (segaSram16bit > 0) {
          // skip high byte
          myFile.read();
        }
        word data = myFile.read() & 0xFF;
        writeWord_MD(currByte, data);
      }
    }
    // Write to the upper byte
    else if (saveType == 2) {
      for (unsigned long currByte = sramBase; currByte < sramBase + sramSize; currByte++) {
        word data = (myFile.read() << 8) & 0xFF00;
        writeWord_MD(currByte, data);
        if (segaSram16bit > 0) {
          // skip low byte
          myFile.read();
        }
      }
    }
    // Write to both bytes
    else if (saveType == 3) {
      for (unsigned long currByte = sramBase; currByte < sramBase + sramSize; currByte++) {
        word data = (myFile.read() << 8) & 0xFF00;
        data |= (myFile.read() & 0xFF);
        writeWord_MD(currByte, data);
      }
    } else
      print_Error(F("Unknown save type"));

    // Close the file:
    myFile.close();
    print_STR(done_STR, 1);
    display_Update();
  } else {
    print_FatalError(sd_error_STR);
  }
  dataIn_MD();
}

// Read sram and save to the SD card
void readSram_MD() {
  dataIn_MD();

  // Get name, add extension and convert to char array for sd lib
  strcpy(fileName, romName);
  strcat(fileName, ".srm");

  // create a new folder for the save file
  EEPROM_readAnything(0, foldern);
  sprintf(folder, "MD/SAVE/%s/%d", romName, foldern);
  sd.mkdir(folder, true);
  sd.chdir(folder);

  // 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);
  }

  for (unsigned long currBuffer = sramBase; currBuffer < sramBase + sramSize; currBuffer += 256) {
    for (int currWord = 0; currWord < 256; currWord++) {
      word myWord = readWord_MD(currBuffer + currWord);

      if (saveType == 2) {
        // Only use the upper byte
        if (segaSram16bit > 0) {
          sdBuffer[(currWord * 2) + 0] = ((myWord >> 8) & 0xFF);
          sdBuffer[(currWord * 2) + 1] = ((myWord >> 8) & 0xFF);
        } else {
          sdBuffer[currWord] = ((myWord >> 8) & 0xFF);
        }
      } else if (saveType == 1) {
        // Only use the lower byte
        if (segaSram16bit > 0) {
          sdBuffer[(currWord * 2) + 0] = (myWord & 0xFF);
          sdBuffer[(currWord * 2) + 1] = (myWord & 0xFF);
        } else {
          sdBuffer[currWord] = (myWord & 0xFF);
        }
      } else if (saveType == 3) {  // BOTH
        sdBuffer[currWord * 2] = ((myWord >> 8) & 0xFF);
        sdBuffer[(currWord * 2) + 1] = (myWord & 0xFF);
      }
    }
    if (saveType == 3 || segaSram16bit > 0)
      myFile.write(sdBuffer, 512);
    else
      myFile.write(sdBuffer, 256);
  }
  if (segaSram16bit == 2) {
    // pad to 64KB
    for (int i = 0; i < 512; i++) {
      sdBuffer[i] = 0xFF;
    }
    unsigned long padsize = (1UL << 16) - (sramSize << 1);
    unsigned long padblockcount = padsize >> 9;  // number of 512 byte blocks
    for (unsigned long i = 0; i < padblockcount; i++) {
      myFile.write(sdBuffer, 512);
    }
  }
  // Close the file:
  myFile.close();
  print_Msg(F("Saved to "));
  print_Msg(folder);
  println_Msg(F("/"));
  display_Update();
}

unsigned long verifySram_MD() {
  dataIn_MD();
  writeErrors = 0;

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {
    for (unsigned long currBuffer = sramBase; currBuffer < sramBase + sramSize; currBuffer += 256) {
      for (int currWord = 0; currWord < 256; currWord++) {
        word myWord = readWord_MD(currBuffer + currWord);

        if (saveType == 2) {
          // Only use the upper byte
          sdBuffer[currWord * 2] = ((myWord >> 8) & 0xFF);
        } else if (saveType == 1) {
          // Only use the lower byte
          sdBuffer[currWord * 2] = (myWord & 0xFF);
        } else if (saveType == 3) {  // BOTH
          sdBuffer[(currWord * 2) + 0] = ((myWord >> 8) & 0xFF);
          sdBuffer[(currWord * 2) + 1] = (myWord & 0xFF);
        }
      }
      int step = saveType == 3 ? 1 : 2;
      // Check sdBuffer content against file on sd card
      for (int i = 0; i < 512; i += step) {
        if (saveType == 1 && segaSram16bit > 0) {
          // skip high byte
          myFile.read();
        }
        byte b = myFile.read();
        if (saveType == 2 && segaSram16bit > 0) {
          // skip low byte
          myFile.read();
        }
        if (b != sdBuffer[i]) {
          writeErrors++;
        }
      }
    }

    // Close the file:
    myFile.close();
  } else {
    print_FatalError(sd_error_STR);
  }
  // Return 0 if verified ok, or number of errors
  return writeErrors;
}

#ifdef enable_FLASH
//******************************************
// Flashrom Functions
//******************************************
void resetFlash_MD() {
  // Set data pins to output
  dataOut_MD();

  // Reset command sequence
  writeFlash_MD(0x5555, 0xaa);
  writeFlash_MD(0x2aaa, 0x55);
  writeFlash_MD(0x5555, 0xf0);

  // Set data pins to input again
  dataIn_MD();
}

void write29F1610_MD() {
  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);
  print_STR(flashing_file_STR, 0);
  print_Msg(filePath);
  println_Msg(F("..."));
  display_Update();

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {
    // Get rom size from file
    fileSize = myFile.fileSize();
    if (fileSize > flashSize) {
      print_FatalError(file_too_big_STR);
    }
    // Set data pins to output
    dataOut_MD();

    // Fill sdBuffer with 1 page at a time then write it repeat until all bytes are written
    int d = 0;
    for (unsigned long currByte = 0; currByte < fileSize / 2; currByte += 64) {
      myFile.read(sdBuffer, 128);

      // Blink led
      if (currByte % 4096 == 0) {
        blinkLED();
      }

      // Write command sequence
      writeFlash_MD(0x5555, 0xaa);
      writeFlash_MD(0x2aaa, 0x55);
      writeFlash_MD(0x5555, 0xa0);

      // Write one full page at a time
      for (byte c = 0; c < 64; c++) {
        word currWord = ((sdBuffer[d] & 0xFF) << 8) | (sdBuffer[d + 1] & 0xFF);
        writeFlash_MD(currByte + c, currWord);
        d += 2;
      }
      d = 0;

      // Check if write is complete
      delayMicroseconds(100);
      busyCheck_MD();
    }

    // Set data pins to input again
    dataIn_MD();

    // Close the file:
    myFile.close();
  } else {
    print_STR(open_file_STR, 1);
    display_Update();
  }
}

void idFlash_MD() {
  // Set data pins to output
  dataOut_MD();

  // ID command sequence
  writeFlash_MD(0x5555, 0xaa);
  writeFlash_MD(0x2aaa, 0x55);
  writeFlash_MD(0x5555, 0x90);

  // Set data pins to input again
  dataIn_MD();

  // Read the two id bytes into a string
  flashid = (readFlash_MD(0) & 0xFF) << 8;
  flashid |= readFlash_MD(1) & 0xFF;
  sprintf(flashid_str, "%04X", flashid);
}

byte readStatusReg_MD() {
  // Set data pins to output
  dataOut_MD();

  // Status reg command sequence
  writeFlash_MD(0x5555, 0xaa);
  writeFlash_MD(0x2aaa, 0x55);
  writeFlash_MD(0x5555, 0x70);

  // Set data pins to input again
  dataIn_MD();

  // Read the status register
  byte statusReg = readFlash_MD(0);
  return statusReg;
}

void eraseFlash_MD() {
  // Set data pins to output
  dataOut_MD();

  // Erase command sequence
  writeFlash_MD(0x5555, 0xaa);
  writeFlash_MD(0x2aaa, 0x55);
  writeFlash_MD(0x5555, 0x80);
  writeFlash_MD(0x5555, 0xaa);
  writeFlash_MD(0x2aaa, 0x55);
  writeFlash_MD(0x5555, 0x10);

  // Set data pins to input again
  dataIn_MD();

  busyCheck_MD();
}

void blankcheck_MD() {
  blank = 1;
  for (unsigned long currByte = 0; currByte < flashSize / 2; currByte++) {
    if (readFlash_MD(currByte) != 0xFFFF) {
      currByte = flashSize / 2;
      blank = 0;
    }
    if (currByte % 4096 == 0) {
      blinkLED();
    }
  }
  if (!blank) {
    print_Error(F("Error: Not blank"));
  }
}

void verifyFlash_MD() {
  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {
    // Get rom size from file
    fileSize = myFile.fileSize();
    if (fileSize > flashSize) {
      print_FatalError(file_too_big_STR);
    }

    blank = 0;
    word d = 0;
    for (unsigned long currByte = 0; currByte < fileSize / 2; currByte += 256) {
      if (currByte % 4096 == 0) {
        blinkLED();
      }
      //fill sdBuffer
      myFile.read(sdBuffer, 512);
      for (int c = 0; c < 256; c++) {
        word currWord = ((sdBuffer[d] << 8) | sdBuffer[d + 1]);

        if (readFlash_MD(currByte + c) != currWord) {
          blank++;
        }
        d += 2;
      }
      d = 0;
    }
    if (blank == 0) {
      println_Msg(F("Flashrom verified OK"));
      display_Update();
    } else {
      print_STR(error_STR, 0);
      print_Msg(blank);
      print_STR(_bytes_STR, 1);
      print_Error(did_not_verify_STR);
    }
    // Close the file:
    myFile.close();
  } else {
    print_STR(open_file_STR, 1);
    display_Update();
  }
}
#endif

// Delay between write operations based on status register
void busyCheck_MD() {
  // Set data pins to input
  dataIn_MD();

  // Read the status register
  word statusReg = readFlash_MD(0);

  while ((statusReg | 0xFF7F) != 0xFFFF) {
    statusReg = readFlash_MD(0);
  }

  // Set data pins to output
  dataOut_MD();
}

//******************************************
// EEPROM Functions
//******************************************
void EepromInit(byte eepmode) {  // Acclaim Type 2
  PORTF = 0x00;                  // ADDR A0-A7
  PORTK = 0x00;                  // ADDR A8-A15
  PORTL = 0x10;                  // ADDR A16-A23
  PORTA = 0x00;                  // DATA D8-D15
  PORTH |= (1 << 0);             // /RES HIGH

  PORTC = eepmode;                 // EEPROM Switch:  0 = Enable (Read EEPROM), 1 = Disable (Read ROM)
  PORTH &= ~(1 << 3);              // CE LOW
  PORTH &= ~(1 << 4) & ~(1 << 5);  // /UDSW + /LDSW LOW
  PORTH |= (1 << 6);               // OE HIGH
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");
  PORTH |= (1 << 4) | (1 << 5);  // /UDSW + /LDSW HIGH
  __asm__("nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t"
          "nop\n\t");
}

void writeWord_SDA(unsigned long myAddress, word myData) { /* D0 goes to /SDA when only /LWR is asserted */
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTL = (myAddress >> 16) & 0xFF;
  PORTC = myData;
  PORTH &= ~(1 << 3);  // CE LOW
  PORTH &= ~(1 << 5);  // /LDSW LOW
  PORTH |= (1 << 4);   // /UDSW HIGH
  PORTH |= (1 << 6);   // OE HIGH
  if (eepSize > 0x100)
    __asm__("nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t");
  else
    delayMicroseconds(100);
  PORTH |= (1 << 5);  // /LDSW HIGH
  if (eepSize > 0x100)
    __asm__("nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t");
  else
    delayMicroseconds(100);
}

void writeWord_SCL(unsigned long myAddress, word myData) { /* D0 goes to /SCL when only /UWR is asserted */
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTL = (myAddress >> 16) & 0xFF;
  PORTC = myData;
  PORTH &= ~(1 << 3);  // CE LOW
  PORTH &= ~(1 << 4);  // /UDSW LOW
  PORTH |= (1 << 5);   // /LDSW HIGH
  PORTH |= (1 << 6);   // OE HIGH
  if (eepSize > 0x100)
    __asm__("nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t");
  else
    delayMicroseconds(100);
  PORTH |= (1 << 4);  // /UDSW HIGH
  if (eepSize > 0x100)
    __asm__("nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t"
            "nop\n\t");
  else
    delayMicroseconds(100);
}

void writeWord_CM(unsigned long myAddress, word myData) {  // Codemasters
  PORTF = myAddress & 0xFF;
  PORTK = (myAddress >> 8) & 0xFF;
  PORTL = (myAddress >> 16) & 0xFF;
  PORTC = myData;
  PORTA = (myData >> 8) & 0xFF;

  // Arduino running at 16Mhz -> one nop = 62.5ns
  // Wait till output is stable
  __asm__("nop\n\t"
          "nop\n\t");

  // Switch WR(PH4) to LOW
  PORTH &= ~(1 << 4);
  // Setting CS(PH3) LOW
  PORTH &= ~(1 << 3);
  // Pulse CLK(PH1)
  PORTH ^= (1 << 1);

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

  // Pulse CLK(PH1)
  PORTH ^= (1 << 1);
  // Setting CS(PH3) HIGH
  PORTH |= (1 << 3);
  // Switch WR(PH4) to HIGH
  PORTH |= (1 << 4);

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

// EEPROM COMMANDS
void EepromStart() {
  if (eepType == 2) {               // Acclaim Type 2
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x00);  // scl low
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x01);  // scl high
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x00);  // scl low
  } else if (eepType == 4) {        // EA
    writeWord_MD(0x100000, 0x00);   // sda low, scl low
    writeWord_MD(0x100000, 0xC0);   // sda, scl high
    writeWord_MD(0x100000, 0x40);   // sda low, scl high
    writeWord_MD(0x100000, 0x00);   // START
  } else if (eepType == 5) {        // Codemasters
    writeWord_CM(0x180000, 0x00);   // sda low, scl low
    writeWord_CM(0x180000, 0x02);   // sda low, scl high
    writeWord_CM(0x180000, 0x03);   // sda, scl high
    writeWord_CM(0x180000, 0x02);   // sda low, scl high
    writeWord_CM(0x180000, 0x00);   // START
  } else {
    writeWord_MD(0x100000, 0x00);  // sda low, scl low
    writeWord_MD(0x100000, 0x03);  // sda, scl high
    writeWord_MD(0x100000, 0x02);  // sda low, scl high
    writeWord_MD(0x100000, 0x00);  // START
  }
}

void EepromSet0() {
  if (eepType == 2) {               // Acclaim Type 2
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x01);  // scl high
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x00);  // scl low
  } else if (eepType == 4) {        // EA
    writeWord_MD(0x100000, 0x00);   // sda low, scl low
    writeWord_MD(0x100000, 0x40);   // sda low, scl high // 0
    writeWord_MD(0x100000, 0x00);   // sda low, scl low
  } else if (eepType == 5) {        // Codemasters
    writeWord_CM(0x180000, 0x00);   // sda low, scl low
    writeWord_CM(0x180000, 0x02);   // sda low, scl high // 0
    writeWord_CM(0x180000, 0x00);   // sda low, scl low
  } else {
    writeWord_MD(0x100000, 0x00);  // sda low, scl low
    writeWord_MD(0x100000, 0x02);  // sda low, scl high // 0
    writeWord_MD(0x100000, 0x00);  // sda low, scl low
  }
}

void EepromSet1() {
  if (eepType == 2) {               // Acclaim Type 2
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x01);  // scl high
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x00);  // scl low
  } else if (eepType == 4) {        // EA
    writeWord_MD(0x100000, 0x80);   // sda high, scl low
    writeWord_MD(0x100000, 0xC0);   // sda high, scl high // 1
    writeWord_MD(0x100000, 0x80);   // sda high, scl low
    writeWord_MD(0x100000, 0x00);   // sda low, scl low
  } else if (eepType == 5) {        // Codemasters
    writeWord_CM(0x180000, 0x01);   // sda high, scl low
    writeWord_CM(0x180000, 0x03);   // sda high, scl high // 1
    writeWord_CM(0x180000, 0x01);   // sda high, scl low
    writeWord_CM(0x180000, 0x00);   // sda low, scl low
  } else {
    writeWord_MD(0x100000, 0x01);  // sda high, scl low
    writeWord_MD(0x100000, 0x03);  // sda high, scl high // 1
    writeWord_MD(0x100000, 0x01);  // sda high, scl low
    writeWord_MD(0x100000, 0x00);  // sda low, scl low
  }
}


void EepromDevice() {  // 24C02+
  EepromSet1();
  EepromSet0();
  EepromSet1();
  EepromSet0();
}

void EepromSetDeviceAddress(word addrhi) {  // 24C02+
  for (int i = 0; i < 3; i++) {
    if ((addrhi >> 2) & 0x1)  // Bit is HIGH
      EepromSet1();
    else  // Bit is LOW
      EepromSet0();
    addrhi <<= 1;  // rotate to the next bit
  }
}

void EepromStatus() {  // ACK
  byte eepStatus = 1;
  if (eepType == 1) {              // Acclaim Type 1
    writeWord_MD(0x100000, 0x01);  // sda high, scl low
    writeWord_MD(0x100000, 0x03);  // sda high, scl high
    do {
      dataIn_MD();
      eepStatus = ((readWord_MD(0x100000) >> 1) & 0x1);
      dataOut_MD();
      delayMicroseconds(4);
    } while (eepStatus == 1);
    writeWord_MD(0x100000, 0x01);   // sda high, scl low
  } else if (eepType == 2) {        // Acclaim Type 2
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x01);  // scl high
    do {
      dataIn_MD();
      eepStatus = (readWord_MD(0x100000) & 0x1);
      dataOut_MD();
      delayMicroseconds(4);
    } while (eepStatus == 1);
    writeWord_SCL(0x100000, 0x00);  // scl low
  } else if (eepType == 3) {        // Capcom/Sega
    writeWord_MD(0x100000, 0x01);   // sda high, scl low
    writeWord_MD(0x100000, 0x03);   // sda high, scl high
    do {
      dataIn_MD();
      eepStatus = (readWord_MD(0x100000) & 0x1);
      dataOut_MD();
      delayMicroseconds(4);
    } while (eepStatus == 1);
    writeWord_MD(0x100000, 0x01);  // sda high, scl low
  } else if (eepType == 4) {       // EA
    writeWord_MD(0x100000, 0x80);  // sda high, scl low
    writeWord_MD(0x100000, 0xC0);  // sda high, scl high
    do {
      dataIn_MD();
      eepStatus = ((readWord_MD(0x100000) >> 7) & 0x1);
      dataOut_MD();
      delayMicroseconds(4);
    } while (eepStatus == 1);
    writeWord_MD(0x100000, 0x80);  // sda high, scl low
  } else if (eepType == 5) {       // Codemasters
    writeWord_CM(0x180000, 0x01);  // sda high, scl low
    writeWord_CM(0x180000, 0x03);  // sda high, scl high
    do {
      dataIn_MD();
      eepStatus = ((readWord_MD(0x1C0000) >> 7) & 0x1);
      dataOut_MD();
      delayMicroseconds(4);
    } while (eepStatus == 1);
    writeWord_CM(0x180000, 0x01);  // sda high, scl low
  }
}

void EepromReadMode() {
  EepromSet1();    // READ
  EepromStatus();  // ACK
}

void EepromWriteMode() {
  EepromSet0();    // WRITE
  EepromStatus();  // ACK
}

void EepromReadData() {
  if (eepType == 1) {  // Acclaim Type 1
    for (int i = 0; i < 8; i++) {
      writeWord_MD(0x100000, 0x03);  // sda high, scl high
      dataIn_MD();
      eepbit[i] = ((readWord_MD(0x100000) >> 1) & 0x1);  // Read 0x100000 with Mask 0x1 (bit 1)
      dataOut_MD();
      writeWord_MD(0x100000, 0x01);  // sda high, scl low
    }
  } else if (eepType == 2) {  // Acclaim Type 2
    for (int i = 0; i < 8; i++) {
      writeWord_SDA(0x100000, 0x01);  // sda high
      writeWord_SCL(0x100000, 0x01);  // scl high
      dataIn_MD();
      eepbit[i] = (readWord_MD(0x100000) & 0x1);  // Read 0x100000 with Mask 0x1 (bit 0)
      dataOut_MD();
      writeWord_SDA(0x100000, 0x01);  // sda high
      writeWord_SCL(0x100000, 0x00);  // scl low
    }
  } else if (eepType == 3) {  // Capcom/Sega
    for (int i = 0; i < 8; i++) {
      writeWord_MD(0x100000, 0x03);  // sda high, scl high
      dataIn_MD();
      eepbit[i] = (readWord_MD(0x100000) & 0x1);  // Read 0x100000 with Mask 0x1 (bit 0)
      dataOut_MD();
      writeWord_MD(0x100000, 0x01);  // sda high, scl low
    }
  } else if (eepType == 4) {  // EA
    for (int i = 0; i < 8; i++) {
      writeWord_MD(0x100000, 0xC0);  // sda high, scl high
      dataIn_MD();
      eepbit[i] = ((readWord_MD(0x100000) >> 7) & 0x1);  // Read 0x100000 with Mask (bit 7)
      dataOut_MD();
      writeWord_MD(0x100000, 0x80);  // sda high, scl low
    }
  } else if (eepType == 5) {  // Codemasters
    for (int i = 0; i < 8; i++) {
      writeWord_CM(0x180000, 0x03);  // sda high, scl high
      dataIn_MD();
      eepbit[i] = ((readWord_MD(0x1C0000) >> 7) & 0x1);  // Read 0x1C0000 with Mask 0x1 (bit 7)
      dataOut_MD();
      writeWord_CM(0x180000, 0x01);  // sda high, scl low
    }
  }
}

void EepromWriteData(byte data) {
  for (int i = 0; i < 8; i++) {
    if ((data >> 7) & 0x1)  // Bit is HIGH
      EepromSet1();
    else  // Bit is LOW
      EepromSet0();
    data <<= 1;  // rotate to the next bit
  }
  EepromStatus();  // ACK
}

void EepromFinish() {
  if (eepType == 2) {               // Acclaim Type 2
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x00);  // scl low
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x00);  // scl low
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x01);  // scl high
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x00);  // scl low
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x00);  // scl low
  } else if (eepType == 4) {        // EA
    writeWord_MD(0x100000, 0x00);   // sda low, scl low
    writeWord_MD(0x100000, 0x80);   // sda high, scl low
    writeWord_MD(0x100000, 0xC0);   // sda high, scl high
    writeWord_MD(0x100000, 0x80);   // sda high, scl low
    writeWord_MD(0x100000, 0x00);   // sda low, scl low
  } else if (eepType == 5) {        // Codemasters
    writeWord_CM(0x180000, 0x00);   // sda low, scl low
    writeWord_CM(0x180000, 0x01);   // sda high, scl low
    writeWord_CM(0x180000, 0x03);   // sda high, scl high
    writeWord_CM(0x180000, 0x01);   // sda high, scl low
    writeWord_CM(0x180000, 0x00);   // sda low, scl low
  } else {
    writeWord_MD(0x100000, 0x00);  // sda low, scl low
    writeWord_MD(0x100000, 0x01);  // sda high, scl low
    writeWord_MD(0x100000, 0x03);  // sda high, scl high
    writeWord_MD(0x100000, 0x01);  // sda high, scl low
    writeWord_MD(0x100000, 0x00);  // sda low, scl low
  }
}

void EepromStop() {
  if (eepType == 2) {               // Acclaim Type 2
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x01);  // scl high
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x01);  // scl high
    writeWord_SDA(0x100000, 0x01);  // sda high
    writeWord_SCL(0x100000, 0x00);  // scl low
    writeWord_SDA(0x100000, 0x00);  // sda low
    writeWord_SCL(0x100000, 0x00);  // scl low // STOP
  } else if (eepType == 4) {        // EA
    writeWord_MD(0x100000, 0x00);   // sda, scl low
    writeWord_MD(0x100000, 0x40);   // sda low, scl high
    writeWord_MD(0x100000, 0xC0);   // sda, scl high
    writeWord_MD(0x100000, 0x80);   // sda high, scl low
    writeWord_MD(0x100000, 0x00);   // STOP
  } else if (eepType == 5) {        // Codemasters
    writeWord_CM(0x180000, 0x00);   // sda low, scl low
    writeWord_CM(0x180000, 0x02);   // sda low, scl high
    writeWord_CM(0x180000, 0x03);   // sda, scl high
    writeWord_CM(0x180000, 0x01);   // sda high, scl low
    writeWord_CM(0x180000, 0x00);   // STOP
  } else {
    writeWord_MD(0x100000, 0x00);  // sda, scl low
    writeWord_MD(0x100000, 0x02);  // sda low, scl high
    writeWord_MD(0x100000, 0x03);  // sda, scl high
    writeWord_MD(0x100000, 0x01);  // sda high, scl low
    writeWord_MD(0x100000, 0x00);  // STOP
  }
}

void EepromSetAddress(word address) {
  if (eepSize > 0x80) {  // 24C02+
    for (int i = 0; i < 8; i++) {
      if ((address >> 7) & 0x1)  // Bit is HIGH
        EepromSet1();
      else  // Bit is LOW
        EepromSet0();
      address <<= 1;  // rotate to the next bit
    }
    EepromStatus();  // ACK
  } else {           // 24C01
    for (int i = 0; i < 7; i++) {
      if ((address >> 6) & 0x1)  // Bit is HIGH
        EepromSet1();
      else  // Bit is LOW
        EepromSet0();
      address <<= 1;  // rotate to the next bit
    }
  }
}

void readEepromByte(word address) {
  addrhi = address >> 8;
  addrlo = address & 0xFF;
  dataOut_MD();
  if (eepType == 2)
    EepromInit(0);  // Enable EEPROM
  EepromStart();    // START
  if (eepSize > 0x80) {
    EepromDevice();         // DEVICE [1010]
    if (eepSize > 0x800) {  // MODE 3 [24C65]
      EepromSetDeviceAddress(0);
      EepromWriteMode();
      EepromSetAddress(addrhi);        // ADDR [A15..A8]
    } else {                           // MODE 2 [24C02/24C08/24C16]
      EepromSetDeviceAddress(addrhi);  // ADDR [A10..A8]
      EepromWriteMode();
    }
  }
  EepromSetAddress(addrlo);
  if (eepSize > 0x80) {
    EepromStart();        // START
    EepromDevice();       // DEVICE [1010]
    if (eepSize > 0x800)  // MODE 3 [24C65]
      EepromSetDeviceAddress(0);
    else                               // MODE 2 [24C02/24C08/24C16]
      EepromSetDeviceAddress(addrhi);  // ADDR [A10..A8]
  }
  EepromReadMode();
  EepromReadData();
  EepromFinish();
  EepromStop();  // STOP
  if (eepType == 2)
    EepromInit(1);  // Disable EEPROM
  // OR 8 bits into byte
  eeptemp = eepbit[0] << 7 | eepbit[1] << 6 | eepbit[2] << 5 | eepbit[3] << 4 | eepbit[4] << 3 | eepbit[5] << 2 | eepbit[6] << 1 | eepbit[7];
  sdBuffer[addrlo] = eeptemp;
}

void writeEepromByte(word address) {
  addrhi = address >> 8;
  addrlo = address & 0xFF;
  eeptemp = sdBuffer[addrlo];
  dataOut_MD();
  if (eepType == 2)
    EepromInit(0);  // Enable EEPROM
  EepromStart();    // START
  if (eepSize > 0x80) {
    EepromDevice();                    // DEVICE [1010]
    if (eepSize > 0x800) {             // MODE 3 [24C65]
      EepromSetDeviceAddress(0);       // [A2-A0] = 000
      EepromWriteMode();               // WRITE
      EepromSetAddress(addrhi);        // ADDR [A15-A8]
    } else {                           // MODE 2 [24C02/24C08/24C16]
      EepromSetDeviceAddress(addrhi);  // ADDR [A10-A8]
      EepromWriteMode();               // WRITE
    }
    EepromSetAddress(addrlo);
  } else {  // 24C01
    EepromSetAddress(addrlo);
    EepromWriteMode();  // WRITE
  }
  EepromWriteData(eeptemp);
  EepromStop();  // STOP
  if (eepType == 2)
    EepromInit(1);  // Disable EEPROM
}

// Read EEPROM and save to the SD card
void readEEP_MD() {
  dataIn_MD();

  // Get name, add extension and convert to char array for sd lib
  strcpy(fileName, romName);
  strcat(fileName, ".eep");

  // create a new folder for the save file
  EEPROM_readAnything(0, foldern);
  sd.chdir();
  sprintf(folder, "MD/SAVE/%s/%d", romName, foldern);
  sd.mkdir(folder, true);
  sd.chdir(folder);

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

  println_Msg(F("Reading..."));
  display_Update();

  // Open file on sd card
  if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
    print_FatalError(sd_error_STR);
  }
  if (eepSize > 0x100) {  // 24C04+
    for (word currByte = 0; currByte < eepSize; currByte += 256) {
      print_Msg(F("*"));
      display_Update();
      for (int i = 0; i < 256; i++) {
        readEepromByte(currByte + i);
      }
      myFile.write(sdBuffer, 256);
    }
  } else {  // 24C01/24C02
    for (word currByte = 0; currByte < eepSize; currByte++) {
      if ((currByte != 0) && ((currByte + 1) % 16 == 0)) {
        print_Msg(F("*"));
        display_Update();
      }
      readEepromByte(currByte);
    }
    myFile.write(sdBuffer, eepSize);
  }
  // Close the file:
  myFile.close();
  println_Msg(F(""));
  display_Clear();
  print_Msg(F("Saved to "));
  print_Msg(folder);

  display_Update();
}

void writeEEP_MD() {
  dataOut_MD();

  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);
  println_Msg(F("Writing..."));
  println_Msg(filePath);
  display_Update();

  // Open file on sd card
  if (myFile.open(filePath, O_READ)) {
    if (eepSize > 0x100) {  // 24C04+
      for (word currByte = 0; currByte < eepSize; currByte += 256) {
        myFile.read(sdBuffer, 256);
        for (int i = 0; i < 256; i++) {
          writeEepromByte(currByte + i);
          delay(50);  // DELAY NEEDED
        }
        print_Msg(F("."));
        display_Update();
      }
    } else {  // 24C01/24C02
      myFile.read(sdBuffer, eepSize);
      for (word currByte = 0; currByte < eepSize; currByte++) {
        writeEepromByte(currByte);
        print_Msg(F("."));
        if ((currByte != 0) && ((currByte + 1) % 64 == 0))
          println_Msg(F(""));
        display_Update();  // ON SERIAL = delay(100)
      }
    }
    // Close the file:
    myFile.close();
    println_Msg(F(""));
    display_Clear();
    print_STR(done_STR, 1);
    display_Update();
  } else {
    print_FatalError(sd_error_STR);
  }
  dataIn_MD();
}

//******************************************
// CD Backup RAM Functions
//******************************************
void readBram_MD() {
  dataIn_MD();

  // Get name, add extension and convert to char array for sd lib
  strcpy(fileName, "Cart.brm");

  // create a new folder for the save file
  EEPROM_readAnything(0, foldern);
  sd.chdir();
  sprintf(folder, "MD/RAM/%d", foldern);
  sd.mkdir(folder, true);
  sd.chdir(folder);

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

  println_Msg(F("Reading..."));
  display_Update();

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

  for (unsigned long currByte = 0; currByte < bramSize; currByte += 512) {
    for (int i = 0; i < 512; i++) {
      sdBuffer[i] = readWord_MD(0x300000 + currByte + i);
    }
    myFile.write(sdBuffer, 512);
  }

  // Close the file:
  myFile.close();
  println_Msg(F(""));
  display_Clear();
  print_Msg(F("Saved to "));
  print_Msg(folder);

  display_Update();
}

void writeBram_MD() {
  dataOut_MD();

  // Create filepath
  sprintf(filePath, "%s/%s", filePath, fileName);
  println_Msg(F("Writing..."));
  println_Msg(filePath);
  display_Update();

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

    // 0x700000-0x7FFFFF: Writes by /LWR latch D0; 1=RAM write enabled, 0=disabled
    writeWord_MD(0x380000, 1);  // Enable BRAM Writes

    for (unsigned long currByte = 0; currByte < bramSize; currByte += 512) {
      myFile.read(sdBuffer, 512);
      for (int i = 0; i < 512; i++) {
        writeWord_MD(0x300000 + currByte + i, sdBuffer[i]);
      }
    }
    writeWord_MD(0x380000, 0);  // Disable BRAM Writes
    // Close the file:
    myFile.close();
    println_Msg(F(""));
    display_Clear();
    print_STR(done_STR, 1);
    display_Update();
  } else {
    print_FatalError(sd_error_STR);
  }
  dataIn_MD();
}

//******************************************
// Realtec Mapper Functions
//******************************************
void writeRealtec(unsigned long address, byte value) {  // Realtec 0x404000 (UPPER)/0x400000 (LOWER)
  dataOut_MD();
  PORTF = address & 0xFF;          // 0x00 ADDR A0-A7
  PORTK = (address >> 8) & 0xFF;   // ADDR A8-A15
  PORTL = (address >> 16) & 0xFF;  //0x20 ADDR A16-A23
  PORTA = 0x00;                    // DATA D8-D15
  PORTH |= (1 << 0);               // /RES HIGH

  PORTH |= (1 << 3);  // CE HIGH
  PORTC = value;
  PORTH &= ~(1 << 4) & ~(1 << 5);  // /UDSW + /LDSW LOW
  PORTH |= (1 << 4) | (1 << 5);    // /UDSW + /LDSW HIGH
  dataIn_MD();
}

void readRealtec_MD() {
  // Set control
  dataIn_MD();

  // Get name, add extension and convert to char array for sd lib
  strcpy(fileName, romName);
  strcat(fileName, ".MD");

  // create a new folder
  EEPROM_readAnything(0, foldern);
  sprintf(folder, "MD/ROM/%s/%d", romName, foldern);
  sd.mkdir(folder, true);
  sd.chdir(folder);

  display_Clear();
  print_STR(saving_to_STR, 0);
  print_Msg(folder);
  println_Msg(F("/..."));
  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(sd_error_STR);
  }

  // Realtec Registers
  writeWord_MD(0x201000, 4);  // Number of 128K Blocks 0x402000 (0x201000)
  writeRealtec(0x200000, 1);  // ROM Lower Address 0x400000 (0x200000)
  writeRealtec(0x202000, 0);  // ROM Upper Address 0x404000 (0x202000)

  word d = 0;
  for (unsigned long currBuffer = 0; currBuffer < cartSize / 2; currBuffer += 256) {
    // Blink led
    if (currBuffer % 16384 == 0)
      blinkLED();

    for (int currWord = 0; currWord < 256; currWord++) {
      word myWord = readWord_MD(currBuffer + currWord);
      // Split word into two bytes
      // Left
      sdBuffer[d] = ((myWord >> 8) & 0xFF);
      // Right
      sdBuffer[d + 1] = (myWord & 0xFF);
      d += 2;
    }
    myFile.write(sdBuffer, 512);
    d = 0;
  }
  // Close the file:
  myFile.close();
}

#endif

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