addr.cpp

// This file is included from the loader module and the processor module

#include "super-famicom.hpp"

static SuperFamicomCartridge g_cartridge;

//----------------------------------------------------------------------------
static ea_t xlat_system(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // WRAM
  if ( bank >= 0x7e && bank <= 0x7f )
    return address;

  if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
  {
    if ( addr <= 0x1fff ) // Low RAM
      return 0x7e0000 + addr;
    else if ( addr >= 0x2100 && addr <= 0x213f ) // PPU registers
      return addr;
    else if ( addr >= 0x2140 && addr <= 0x2183 ) // CPU registers
      return addr;
    else if ( addr >= 0x4016 && addr <= 0x4017 ) // CPU registers
      return addr;
    else if ( addr >= 0x4200 && addr <= 0x421f ) // CPU registers
      return addr;
    else if ( addr >= 0x4300 && addr <= 0x437f ) // CPU registers
      return addr;
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// hitachidsp model=HG51B169 frequency=20000000
//   rom id=program name=program.rom size=hex(rom_size)
//   rom id=data name=cx4.data.rom size=0xc00
//   ram id=data size=0xc00
//   map id=io address=00-3f,80-bf:6000-7fff
//   map id=rom address=00-7f,80-ff:8000-ffff mask=0x8000
//   map id=ram address=70-77:0000-7fff
static ea_t xlat_cx4(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SRAM
  if ( g_cartridge.ram_size != 0
    && bank >= 0x70
    && bank <= 0x77
    && addr <= 0x7fff )
  {
    return address;
  }

  // mirror 00-7d => 80-fd (excluding SRAM)
  if ( bank <= 0x7d )
  {
    address += 0x800000;
    bank += 0x80;
  }

  if ( bank <= 0xbf )
  {
    if ( addr >= 0x8000 )
    {
      // ROM
      return address;
    }
    else if ( addr >= 0x6000 && addr <= 0x7fff )
    {
      // CX4 registers
      return addr;
    }
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// spc7110
//   rom id=program name=program.rom size=0x100000
//   rom id=data name=data.rom size=hex(rom_size - 0x100000)
//   ram name=save.ram size=0x", hex(ram_size)
//   map id=io address=00-3f,80-bf:4800-483f
//   map id=io address=50:0000-ffff
//   map id=rom address=00-3f,80-bf:8000-ffff
//   map id=rom address=c0-ff:0000-ffff
//   map id=ram address=00-3f,80-bf:6000-7fff mask=0xe000
static ea_t xlat_spc7110(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SRAM
  if ( g_cartridge.ram_size != 0 )
  {
    if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
    {
      if ( addr >= 0x6000 && addr <= 0x7fff )
      {
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0x1f) << 13) + (addr - 0x6000)) & ram_mask;
        uint32 res = ((ram_offset >> 13) << 16) + (0x6000 + (ram_offset & 0x1fff));
        return res;
      }
    }
  }

  // Decompressed ROM
  if ( bank >= 0x50 && bank <= 0x5f )
    return address;

  // mirror 00-7d => 80-fd (excluding SRAM, Decompressed ROM)
  if ( bank <= 0x7d )
  {
    address += 0x800000;
    bank += 0x80;
  }

  if ( bank >= 0xc0 )
  {
    // ROM (HiROM layout)
    return address;
  }
  else
  {
    if ( addr >= 0x8000 )
    {
      // ROM (LoROM-like layout)
      return ((0xc0 + (bank & 0x3f)) << 16) + addr;
    }
    else if ( addr >= 0x4800 && addr <= 0x483f )
    {
      // SPC7110 registers
      return addr;
    }
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// sdd1
//   rom name=program.rom size=hex(rom_size)
//   ram name=save.ram size=hex(ram_size)
//   map id=io address=00-3f,80-bf:4800-4807
//   map id=rom address=00-3f,80-bf:8000-ffff mask=0x8000
//   map id=rom address=c0-ff:0000-ffff
//   map id=ram address=20-3f,a0-bf:6000-7fff mask=0xe000
//   map id=ram address=70-7f:0000-7fff
static ea_t xlat_sdd1(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SRAM
  if ( g_cartridge.ram_size != 0 )
  {
    if ( bank >= 0x70 && bank <= 0x7d )
    {
      if ( addr <= 0x7fff )
      {
        // LoROM SRAM style
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0xf) << 15) + (addr & 0x7fff)) & ram_mask;
        uint32 res = ((0x70 + (ram_offset >> 15)) << 16) + (ram_offset & 0x7fff);
        return res;
      }
    }
    else if ( ( bank >= 0x20 && bank <= 0x3f ) || ( bank >= 0xa0 && bank <= 0xbf ) )
    {
      if ( addr >= 0x6000 && addr <= 0x7fff )
      {
        // HiROM SRAM style (not usually used?)
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0x1f) << 13) + (addr - 0x6000)) & ram_mask;
        uint32 res = ((0x20 + (ram_offset >> 13)) << 16) + (0x6000 + (ram_offset & 0x1fff));
        return res;
      }
    }
  }

  if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
  {
    if ( addr >= 0x8000 )
    {
      // ROM (LoROM style)
      return ((bank | 0x80) << 16) + addr;
    }
    else if ( addr >= 0x4800 && addr <= 0x4807 )
    {
      // S-DD1 registers
      return addr;
    }
  }
  else if ( bank >= 0xc0 )
  {
    // ROM (HiROM style)
    return address;
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// rom name=program.rom size=hex(rom_size)
// ram name=save.ram size=hex(ram_size)
// map id=rom address=00-7f,80-ff:8000-ffff mask=0x8000
// map id=ram address=70-7f,f0-ff:[0000-7fff|0000-ffff]
static ea_t xlat_lorom(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SRAM
  if ( g_cartridge.ram_size != 0 )
  {
    bool preserve_rom_mirror = (g_cartridge.rom_size > 0x200000) || (g_cartridge.ram_size > 32 * 1024);

    if ( ( bank >= 0x70 && bank <= 0x7d ) || bank >= 0xf0 )
    {
      if ( addr <= 0x7fff || !preserve_rom_mirror )
      {
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0xf) << 15) + (addr & 0x7fff)) & ram_mask;
        uint32 ea = ((0x70 + (ram_offset >> 15)) << 16) + (ram_offset & 0x7fff);
        if ( bank >= 0xfe )
          ea += 0x800000;
        return ea;
      }
    }
  }

  // mirror 00-7d => 80-fd (excluding SRAM)
  if ( bank <= 0x7d )
  {
    address += 0x800000;
    bank += 0x80;
  }

  // ROM
  if ( bank <= 0xbf )
  {
    if ( addr >= 0x8000 )
    {
      return address;
    }
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// rom name=program.rom size=hex(rom_size)
// ram name=save.ram size=hex(ram_size)
// map id=rom address=00-3f,80-bf:8000-ffff
// map id=rom address=40-7f,c0-ff:0000-ffff
// map id=ram address=10-3f,90-bf:6000-7fff mask=0xe000
static ea_t xlat_hirom(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SRAM
  if ( g_cartridge.ram_size != 0 )
  {
    if ( ( bank >= 0x10 && bank <= 0x3f ) || ( bank >= 0x90 && bank <= 0xbf ) )
    {
      if ( addr >= 0x6000 && addr <= 0x7fff )
      {
        // Typically, HiROM SRAM starts from $20:0000, but there are exceptions.
        // Example: Donkey Kong Country 2 (reads $B0:6000 for 2 kilobytes SRAM)
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0x1f) << 13) + (addr - 0x6000)) & ram_mask;
        uint32 res = ((0x20 + (ram_offset >> 13)) << 16) + (0x6000 + (ram_offset & 0x1fff));
        return res;
      }
    }
  }

  // mirror 00-7d => 80-fd (excluding SRAM)
  if ( bank <= 0x7d )
  {
    address += 0x800000;
    bank += 0x80;
  }

  if ( bank >= 0xc0 )
  {
    // ROM (HiROM layout)
    return address;
  }
  else
  {
    if ( addr >= 0x8000 )
    {
      // ROM (LoROM-like layout)
      return ((0xc0 + (bank & 0x3f)) << 16) + addr;
    }
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// rom name=program.rom size=hex(rom_size)
// ram name=save.ram size=hex(ram_size)
// map id=rom address=00-3f,80-bf:8000-ffff mask=0x8000
// map id=rom address=40-7f:0000-ffff
// map id=ram address=20-3f,a0-bf:6000-7fff
// map id=ram address=70-7f:0000-7fff
static ea_t xlat_exlorom(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SRAM
  if ( g_cartridge.ram_size != 0 )
  {
    if ( bank >= 0x70 && bank <= 0x7d )
    {
      if ( addr <= 0x7fff )
      {
        // LoROM SRAM style
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0xf) << 15) + (addr & 0x7fff)) & ram_mask;
        uint32 res = ((0x70 + (ram_offset >> 15)) << 16) + (ram_offset & 0x7fff);
        return res;
      }
    }
    else if ( ( bank >= 0x20 && bank <= 0x3f ) || ( bank >= 0xa0 && bank <= 0xbf ) )
    {
      if ( addr >= 0x6000 && addr <= 0x7fff )
      {
        // HiROM SRAM style (not usually used?)
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0x1f) << 13) + (addr - 0x6000)) & ram_mask;
        uint32 res = ((0x20 + (ram_offset >> 13)) << 16) + (0x6000 + (ram_offset & 0x1fff));
        return res;
      }
    }
  }

  if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
  {
    if ( addr >= 0x8000 )
    {
      // ROM (LoROM style)
      return ((bank | 0x80) << 16) + addr;
    }
  }
  else if ( bank >= 0x40 && bank <= 0x7f )
  {
    // ROM (HiROM style)
    return address;
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// rom name=program.rom size=hex(rom_size)
// ram name=save.ram size=hex(ram_size)
// map id=rom address=00-3f:8000-ffff base=0x400000
// map id=rom address=40-7f:0000-ffff base=0x400000
// map id=rom address=80-bf:8000-ffff mask=0xc00000
// map id=rom address=c0-ff:0000-ffff mask=0xc00000
// map id=ram address=20-3f,a0-bf:6000-7fff mask=0xe000
// map id=ram address=70-7f:[0000-7fff|0000-ffff]
static ea_t xlat_exhirom(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SRAM
  if ( g_cartridge.ram_size != 0 )
  {
    if ( ( bank >= 0x20 && bank <= 0x3f ) || ( bank >= 0xa0 && bank <= 0xbf ) )
    {
      if ( addr >= 0x6000 && addr <= 0x7fff )
      {
        // HiROM SRAM style
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0x1f) << 13) + (addr - 0x6000)) & ram_mask;
        uint32 res = ((0x20 + (ram_offset >> 13)) << 16) + (0x6000 + (ram_offset & 0x1fff));
        return res;
      }
    }
    else if ( bank >= 0x70 && bank <= 0x7d )
    {
      bool preserve_rom_mirror = (g_cartridge.rom_size > 0x200000) || (g_cartridge.ram_size > 32 * 1024);

      if ( addr <= 0x7fff || !preserve_rom_mirror )
      {
        // LoROM SRAM style (not usually used?)
        uint32 ram_mask = g_cartridge.ram_size - 1;
        uint32 ram_offset = (((bank & 0xf) << 15) + (addr & 0x7fff)) & ram_mask;
        uint32 res = ((0x70 + (ram_offset >> 15)) << 16) + (ram_offset & 0x7fff);
        return res;
      }
    }
  }

  if ( bank >= 0xc0 )
  {
    // ROM
    return address;
  }
  else if ( bank >= 0x80 && bank <= 0xbf )
  {
    if ( addr >= 0x8000 )
    {
      // ROM (mirror to c0-ff)
      return ((bank + 0x40) << 16) + addr;
    }
  }
  else if ( bank >= 0x40 )
  {
    // Extended ROM
    return address;
  }
  else
  {
    if ( addr >= 0x8000 )
    {
      // Extended ROM (mirror to 40-7f)
      return ((bank + 0x40) << 16) + addr;
    }
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// superfx revision=4
//   rom name=program.rom size=hex(rom_size)
//   ram name=save.ram size=hex(ram_size)
//   map id=io address=00-3f,80-bf:3000-34ff
//   map id=rom address=00-3f,80-bf:8000-ffff mask=0x8000
//   map id=rom address=40-5f,c0-df:0000-ffff
//   map id=ram address=00-3f,80-bf:6000-7fff size=0x2000
//   map id=ram address=70-71,f0-f1:0000-ffff
static ea_t xlat_superfxrom(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // SuperFX RAM
  if ( g_cartridge.ram_size != 0 )
  {
    if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
    {
      if ( addr >= 0x6000 && addr <= 0x7fff )
      {
        // 2kB Game Work RAM
        return (0x00 << 16) + addr;
      }
    }
    else if ( ( bank >= 0x70 && bank <= 0x7f ) || ( bank >= 0xf0 && bank <= 0xf1 ) )
    {
      // 128kB SRAM address space
      return ( ( bank & ~0x80 ) << 16 ) + addr;
    }
  }

  if ( ( bank >= 0x40 && bank <= 0x5f ) || ( bank >= 0xc0 && bank <= 0xdf ) )
  {
    // ROM (HiROM layout)
    return address;
  }
  else if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
  {
    if ( addr >= 0x8000 )
    {
      // ROM (LoROM layout)
      return address;
    }
  }

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// sa1
//   rom name=program.rom size=hex(rom_size)
//   ram id=bitmap name=save.ram size=hex(ram_size)
//   ram id=internal size=0x800
//   map id=io address=00-3f,80-bf:2200-23ff
//   map id=rom address=00-3f,80-bf:8000-ffff
//   map id=rom address=c0-ff:0000-ffff
//   map id=bwram address=00-3f,80-bf:6000-7fff
//   map id=bwram address=40-4f:0000-ffff
//   map id=iram address=00-3f,80-bf:3000-37ff
static ea_t xlat_sa1rom(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  // mirror 80-bf => 00-3f
  if ( bank >= 0x80 && bank <= 0xbf )
  {
    address -= 0x800000;
    bank -= 0x80;
  }

  // SA1 BWRAM (SRAM)
  if ( g_cartridge.ram_size != 0 )
  {
    if ( bank <= 0x3f )
    {
      if ( addr >= 0x6000 && addr <= 0x7fff )
      {
        // 8 kilobytes RAM (shared with 40:0000-1fff)
        uint32 ram_offset = (addr & 0x7fff) - 0x6000;
        return (0x40 << 16) + ram_offset;
      }
    }
    else if ( bank >= 0x40 && bank <= 0x4f )
    {
      // 128 kB address space, redirects to banks 40-41
      return ((bank & ~0xe) << 16) + addr;
    }
  }

  if ( bank >= 0xc0 )
  {
    // ROM (HiROM layout)
    return address;
  }
  else if ( bank <= 0x3f )
  {
    if ( addr >= 0x8000 )
    {
      // ROM (LoROM layout)
      return address;
    }
  }

  // TODO: SA1 Missing Memory Map
  // 00-3f|80-bf:0000-07ff IWRAM (SA1 side)
  // 60-6f:0000-ffff       BWRAM Bitmap (SA1 side)

  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// sharprtc
//   ram name=rtc.ram size=0x10
//   map id=io address=00-3f,80-bf:2800-2801
static ea_t xlat_sharprtc(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
  {
    if ( addr >= 0x2800 && addr <= 0x2801 )
    {
      return addr;
    }
  }

  dispatched = false;
  return false;
}

//----------------------------------------------------------------------------
// epsonrtc
//   ram name=rtc.ram size=0x10
//   map id=io address=00-3f,80-bf:4840-4842
static ea_t xlat_epsonrtc(ea_t address, bool & dispatched)
{
  uint16 addr = address & 0xffff;
  uint8 bank = (address >> 16) & 0xff;

  dispatched = true;

  if ( bank <= 0x3f || ( bank >= 0x80 && bank <= 0xbf ) )
  {
    if ( addr >= 0x4840 && addr <= 0x4842 )
    {
      return addr;
    }
  }

  dispatched = false;
  return false;
}

//----------------------------------------------------------------------------
// obc1
//   ram name=save.ram size=0x2000
//   map id=io address=00-3f,80-bf:6000-7fff
static ea_t xlat_obc1(ea_t address, bool & dispatched)
{
  // TODO: Add OBC-1 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// necdsp model=uPD7725 frequency=8000000
//   rom id=program name=dsp1b.program.rom size=0x1800
//   rom id=data name=dsp1b.data.rom size=0x800
//   ram id=data size=0x200
//
// when DSP1LoROM1MB:
//   map id=io address=20-3f,a0-bf:8000-ffff select=0x4000
//
// when DSP1LoROM2MB:
//   map id=io address=60-6f,e0-ef:0000-7fff select=0x4000
//
// when DSP1HiROM:
//   map id=io address=00-1f,80-9f:6000-7fff select=0x1000
static ea_t xlat_dsp1(ea_t address, SuperFamicomCartridge::DSP1MemoryMapper /*dsp1_mapper*/, bool & dispatched)
{
  // TODO: Add DSP-1 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// necdsp model=uPD7725 frequency=8000000
//   rom id=program name=dsp2.program.rom size=0x1800
//   rom id=data name=dsp2.data.rom size=0x800
//   ram id=data size=0x200
//   map id=io address=20-3f,a0-bf:8000-ffff select=0x4000
static ea_t xlat_dsp2(ea_t address, bool & dispatched)
{
  // TODO: Add DSP-2 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// necdsp model=uPD7725 frequency=8000000
//   rom id=program name=dsp3.program.rom size=0x1800
//   rom id=data name=dsp3.data.rom size=0x800
//   ram id=data size=0x200
//   map id=io address=20-3f,a0-bf:8000-ffff select=0x4000
static ea_t xlat_dsp3(ea_t address, bool & dispatched)
{
  // TODO: Add DSP-3 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// necdsp model=uPD7725 frequency=8000000
//   rom id=program name=dsp4.program.rom size=0x1800
//   rom id=data name=dsp4.data.rom size=0x800
//   ram id=data size=0x200
//   map id=io address=30-3f,b0-bf:8000-ffff select=0x4000
static ea_t xlat_dsp4(ea_t address, bool & dispatched)
{
  // TODO: Add DSP-4 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// necdsp model=uPD96050 frequency=11000000
//   rom id=program name=st010.program.rom size=0xc000
//   rom id=data name=st010.data.rom size=0x1000
//   ram id=data name=save.ram size=0x1000
//   map id=io address=60-67,e0-e7:0000-3fff select=0x0001
//   map id=ram address=68-6f,e8-ef:0000-7fff
static ea_t xlat_st010(ea_t address, bool & dispatched)
{
  // TODO: Add ST-010 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// necdsp model=uPD96050 frequency=15000000
//   rom id=program name=st011.program.rom size=0xc000
//   rom id=data name=st011.data.rom size=0x1000
//   ram id=data name=save.ram size=0x1000
//   map id=io address=60-67,e0-e7:0000-3fff select=0x0001
//   map id=ram address=68-6f,e8-ef:0000-7fff
static ea_t xlat_st011(ea_t address, bool & dispatched)
{
  // TODO: Add ST-011 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
// armdsp frequency=21477272
//   rom id=program name=st018.program.rom size=0x20000
//   rom id=data name=st018.data.rom size=0x8000
//   ram name=save.ram size=0x4000
//   map id=io address=00-3f,80-bf:3800-38ff
static ea_t xlat_st018(ea_t address, bool & dispatched)
{
  // TODO: Add ST-018 address mapping
  dispatched = false;
  return address;
}

//----------------------------------------------------------------------------
static bool addr_init(const SuperFamicomCartridge & cartridge)
{
  g_cartridge = cartridge;

  switch ( g_cartridge.mapper )
  {
    case SuperFamicomCartridge::LoROM:
    case SuperFamicomCartridge::HiROM:
    case SuperFamicomCartridge::ExLoROM:
    case SuperFamicomCartridge::ExHiROM:
    case SuperFamicomCartridge::SuperFXROM:
    case SuperFamicomCartridge::SA1ROM:
    case SuperFamicomCartridge::SPC7110ROM:
      return true;
    default:
      return false;
  }
}

//----------------------------------------------------------------------------
ea_t xlat(ea_t address)
{
  bool dispatched;
  ea_t remapped_address;

  remapped_address = xlat_system(address, dispatched);
  if ( dispatched )
    return remapped_address;

  if ( g_cartridge.has_cx4 )
  {
    remapped_address = xlat_cx4(address, dispatched);
  }
  else if ( g_cartridge.has_sdd1 )
  {
    remapped_address = xlat_sdd1(address, dispatched);
  }
  else
  {
    switch ( g_cartridge.mapper )
    {
      case SuperFamicomCartridge::LoROM:
        remapped_address = xlat_lorom(address, dispatched);
        break;
      case SuperFamicomCartridge::HiROM:
        remapped_address = xlat_hirom(address, dispatched);
        break;
      case SuperFamicomCartridge::ExLoROM:
        remapped_address = xlat_exlorom(address, dispatched);
        break;
      case SuperFamicomCartridge::ExHiROM:
        remapped_address = xlat_exhirom(address, dispatched);
        break;
      case SuperFamicomCartridge::SuperFXROM:
        remapped_address = xlat_superfxrom(address, dispatched);
        break;
      case SuperFamicomCartridge::SA1ROM:
        remapped_address = xlat_sa1rom(address, dispatched);
        break;
      case SuperFamicomCartridge::SPC7110ROM:
        remapped_address = xlat_spc7110(address, dispatched);
        break;
      default:
        break;
    }
  }
  if ( dispatched )
    return remapped_address;

  if ( g_cartridge.has_sharprtc )
  {
    remapped_address = xlat_sharprtc(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_epsonrtc )
  {
    remapped_address = xlat_epsonrtc(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_obc1 )
  {
    remapped_address = xlat_obc1(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_dsp1 )
  {
    remapped_address = xlat_dsp1(address, g_cartridge.dsp1_mapper, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_dsp2 )
  {
    remapped_address = xlat_dsp2(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_dsp3 )
  {
    remapped_address = xlat_dsp3(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_dsp4 )
  {
    remapped_address = xlat_dsp4(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_st010 )
  {
    remapped_address = xlat_st010(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_st011 )
  {
    remapped_address = xlat_st011(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  if ( g_cartridge.has_st018 )
  {
    remapped_address = xlat_st018(address, dispatched);
    if ( dispatched )
      return remapped_address;
  }

  return address;
}