Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-25 01:40:16 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

bus/msx/cart: Moved most msx_cart_interface implementations to anonymous namespaces. (#11464)

Browse Source
This commit is contained in:
wilbertpol 2023-08-04 16:07:26 +01:00 committed by GitHub
parent 17002db038
commit 12b0fdbc2c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
57 changed files with 1192 additions and 1323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/devices/bus/msx/cart/arc.cpp
View File

@ -3,16 +3,30 @@
#include "emu.h"
#include "arc.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_ARC, msx_cart_arc_device, "msx_cart_arc", "MSX Cartridge - Arc")
msx_cart_arc_device::msx_cart_arc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_ARC, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_7f(0)
class msx_cart_arc_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_arc_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ARC, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_7f(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
private:
void io_7f_w(u8 data);
u8 io_7f_r();
u8 m_7f;
};
void msx_cart_arc_device::device_start()
{
@ -58,3 +72,7 @@ u8 msx_cart_arc_device::io_7f_r()
{
return ((m_7f & 0x03) == 0x03) ? 0xda : 0xff;
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_ARC, msx_cart_interface, msx_cart_arc_device, "msx_cart_arc", "MSX Cartridge - Arc")

22
src/devices/bus/msx/cart/arc.h
View File

@ -8,26 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_ARC, msx_cart_arc_device)
class msx_cart_arc_device : public device_t, public msx_cart_interface
{
public:
msx_cart_arc_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
private:
void io_7f_w(u8 data);
u8 io_7f_r();
u8 m_7f;
};
DECLARE_DEVICE_TYPE(MSX_CART_ARC, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_ARC_H

152
src/devices/bus/msx/cart/ascii.cpp
View File

@ -3,20 +3,33 @@
#include "emu.h"
#include "ascii.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_ASCII8, msx_cart_ascii8_device, "msx_cart_ascii8", "MSX Cartridge - ASCII8")
DEFINE_DEVICE_TYPE(MSX_CART_ASCII16, msx_cart_ascii16_device, "msx_cart_ascii16", "MSX Cartridge - ASCII16")
DEFINE_DEVICE_TYPE(MSX_CART_ASCII8_SRAM, msx_cart_ascii8_sram_device, "msx_cart_ascii8_sram", "MSX Cartridge - ASCII8 w/SRAM")
DEFINE_DEVICE_TYPE(MSX_CART_ASCII16_SRAM, msx_cart_ascii16_sram_device, "msx_cart_ascii16_sram", "MSX Cartridge - ASCII16 w/SRAM")
msx_cart_ascii8_device::msx_cart_ascii8_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ASCII8, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
class msx_cart_ascii8_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_ascii8_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ASCII8, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x2000;
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
void msx_cart_ascii8_device::device_reset()
{
@ -66,13 +79,31 @@ void msx_cart_ascii8_device::bank_w(u8 data)
msx_cart_ascii16_device::msx_cart_ascii16_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ASCII16, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
class msx_cart_ascii16_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_ascii16_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ASCII16, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x4000;
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<2> m_rombank;
u8 m_bank_mask;
};
void msx_cart_ascii16_device::device_reset()
{
@ -120,16 +151,37 @@ void msx_cart_ascii16_device::bank_w(u8 data)
msx_cart_ascii8_sram_device::msx_cart_ascii8_sram_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ASCII8_SRAM, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view2(*this, "view2")
, m_view3(*this, "view3")
, m_bank_mask(0)
, m_sram_select_mask(0)
class msx_cart_ascii8_sram_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_ascii8_sram_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ASCII8_SRAM, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view2(*this, "view2")
, m_view3(*this, "view3")
, m_bank_mask(0)
, m_sram_select_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x2000;
void mapper_write(offs_t offset, u8 data);
memory_bank_array_creator<4> m_rombank;
memory_view m_view2;
memory_view m_view3;
u8 m_bank_mask;
u8 m_sram_select_mask;
};
void msx_cart_ascii8_sram_device::device_reset()
{
@ -211,19 +263,36 @@ void msx_cart_ascii8_sram_device::mapper_write(offs_t offset, u8 data)
msx_cart_ascii16_sram_device::msx_cart_ascii16_sram_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_ASCII16_SRAM, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view(*this, "view")
, m_bank_mask(0)
, m_sram_select_mask(0)
class msx_cart_ascii16_sram_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_ascii16_sram_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_ASCII16_SRAM, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view(*this, "view")
, m_bank_mask(0)
, m_sram_select_mask(0)
{ }
void msx_cart_ascii16_sram_device::device_start()
{
}
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x4000;
void mapper_write_6000(u8 data);
void mapper_write_7000(u8 data);
memory_bank_array_creator<2> m_rombank;
memory_view m_view;
u8 m_bank_mask;
u8 m_sram_select_mask;
};
void msx_cart_ascii16_sram_device::device_reset()
{
@ -294,3 +363,10 @@ void msx_cart_ascii16_sram_device::mapper_write_7000(u8 data)
m_rombank[1]->set_entry(data & m_bank_mask);
}
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_ASCII8, msx_cart_interface, msx_cart_ascii8_device, "msx_cart_ascii8", "MSX Cartridge - ASCII8")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_ASCII16, msx_cart_interface, msx_cart_ascii16_device, "msx_cart_ascii16", "MSX Cartridge - ASCII16")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_ASCII8_SRAM, msx_cart_interface, msx_cart_ascii8_sram_device, "msx_cart_ascii8_sram", "MSX Cartridge - ASCII8 w/SRAM")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_ASCII16_SRAM, msx_cart_interface, msx_cart_ascii16_sram_device, "msx_cart_ascii16_sram", "MSX Cartridge - ASCII16 w/SRAM")

103
src/devices/bus/msx/cart/ascii.h
View File

@ -8,104 +8,9 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_ASCII8, msx_cart_ascii8_device)
DECLARE_DEVICE_TYPE(MSX_CART_ASCII16, msx_cart_ascii16_device)
DECLARE_DEVICE_TYPE(MSX_CART_ASCII8_SRAM, msx_cart_ascii8_sram_device)
DECLARE_DEVICE_TYPE(MSX_CART_ASCII16_SRAM, msx_cart_ascii16_sram_device)
class msx_cart_ascii8_device : public device_t, public msx_cart_interface
{
public:
msx_cart_ascii8_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x2000;
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
class msx_cart_ascii16_device : public device_t, public msx_cart_interface
{
public:
msx_cart_ascii16_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x4000;
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<2> m_rombank;
u8 m_bank_mask;
};
class msx_cart_ascii8_sram_device : public device_t, public msx_cart_interface
{
public:
msx_cart_ascii8_sram_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x2000;
void mapper_write(offs_t offset, u8 data);
memory_bank_array_creator<4> m_rombank;
memory_view m_view2;
memory_view m_view3;
u8 m_bank_mask;
u8 m_sram_select_mask;
};
class msx_cart_ascii16_sram_device : public device_t, public msx_cart_interface
{
public:
msx_cart_ascii16_sram_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x4000;
void mapper_write_6000(u8 data);
void mapper_write_7000(u8 data);
memory_bank_array_creator<2> m_rombank;
memory_view m_view;
u8 m_bank_mask;
u8 m_sram_select_mask;
};
DECLARE_DEVICE_TYPE(MSX_CART_ASCII8, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_ASCII16, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_ASCII8_SRAM, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_ASCII16_SRAM, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_ASCII_H

42
src/devices/bus/msx/cart/bm_012.cpp
View File

@ -16,20 +16,38 @@ TODO:
#include "emu.h"
#include "bm_012.h"
#include "bus/midi/midi.h"
#include "cpu/z80/tmpz84c015.h"
#include "cpu/z80/z80.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_BM_012, msx_cart_bm_012_device, "msx_cart_bm_012", "MSX Cartridge - BM-012")
msx_cart_bm_012_device::msx_cart_bm_012_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_BM_012, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_tmpz84c015af(*this, "tmpz84c015af")
, m_bm012_pio(*this, "bm012_pio")
, m_mdthru(*this, "mdthru")
class msx_cart_bm_012_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_bm_012_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_BM_012, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_tmpz84c015af(*this, "tmpz84c015af")
, m_bm012_pio(*this, "bm012_pio")
, m_mdthru(*this, "mdthru")
{ }
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void midi_in(int state);
void bm_012_memory_map(address_map &map);
required_device<tmpz84c015_device> m_tmpz84c015af;
required_device<z80pio_device> m_bm012_pio;
required_device<midi_port_device> m_mdthru;
};
void msx_cart_bm_012_device::bm_012_memory_map(address_map &map)
@ -104,3 +122,7 @@ void msx_cart_bm_012_device::midi_in(int state)
m_mdthru->write_txd(state);
m_tmpz84c015af->rxb_w(state);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_BM_012, msx_cart_interface, msx_cart_bm_012_device, "msx_cart_bm_012", "MSX Cartridge - BM-012")

28
src/devices/bus/msx/cart/bm_012.h
View File

@ -5,35 +5,9 @@
#pragma once
#include "bus/midi/midi.h"
#include "bus/msx/slot/cartridge.h"
#include "cpu/z80/tmpz84c015.h"
DECLARE_DEVICE_TYPE(MSX_CART_BM_012, msx_cart_bm_012_device)
class msx_cart_bm_012_device : public device_t, public msx_cart_interface
{
public:
msx_cart_bm_012_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
protected:
virtual void device_start() override;
// device-level overrides
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void midi_in(int state);
void bm_012_memory_map(address_map &map);
required_device<tmpz84c015_device> m_tmpz84c015af;
required_device<z80pio_device> m_bm012_pio;
required_device<midi_port_device> m_mdthru;
};
DECLARE_DEVICE_TYPE(MSX_CART_BM_012, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_BM_012_H

31
src/devices/bus/msx/cart/crossblaim.cpp
View File

@ -3,15 +3,28 @@
#include "emu.h"
#include "crossblaim.h"
DEFINE_DEVICE_TYPE(MSX_CART_CROSSBLAIM, msx_cart_crossblaim_device, "msx_cart_crossblaim", "MSX Cartridge Cross Blaim")
namespace {
msx_cart_crossblaim_device::msx_cart_crossblaim_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_CROSSBLAIM, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
class msx_cart_crossblaim_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_crossblaim_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_CROSSBLAIM, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
private:
void mapper_write(u8 data);
memory_bank_creator m_rombank;
};
std::error_condition msx_cart_crossblaim_device::initialize_cartridge(std::string &message)
{
@ -44,3 +57,7 @@ void msx_cart_crossblaim_device::mapper_write(u8 data)
m_rombank->set_entry(data);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_CROSSBLAIM, msx_cart_interface, msx_cart_crossblaim_device, "msx_cart_crossblaim", "MSX Cartridge Cross Blaim")

21
src/devices/bus/msx/cart/crossblaim.h
View File

@ -8,25 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_CROSSBLAIM, msx_cart_crossblaim_device)
class msx_cart_crossblaim_device : public device_t, public msx_cart_interface
{
public:
msx_cart_crossblaim_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
private:
void mapper_write(u8 data);
memory_bank_creator m_rombank;
};
DECLARE_DEVICE_TYPE(MSX_CART_CROSSBLAIM, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_CROSSBLAIM_H

16
src/devices/bus/msx/cart/disk.cpp
View File

@ -320,7 +320,7 @@ protected:
, m_control(0)
{ }
// device-level overrides
// device_t implementation
virtual void device_start() override;
virtual void device_post_load() override;
@ -597,7 +597,7 @@ protected:
, m_control(0)
{ }
// device-level overrides
// device_t implementation
virtual void device_start() override;
virtual void device_post_load() override;
@ -731,7 +731,7 @@ protected:
, m_control(0)
{ }
// device-level overrides
// device_t implementation
virtual void device_start() override;
virtual void device_post_load() override;
@ -849,7 +849,7 @@ public:
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
// device_t implementation
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override
{
@ -892,7 +892,7 @@ public:
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
// device_t implementation
virtual void device_add_mconfig(machine_config &config) override;
virtual void device_start() override;
virtual void device_post_load() override;
@ -1043,7 +1043,7 @@ public:
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
// device_t implementation
virtual void device_add_mconfig(machine_config &config) override;
virtual void device_start() override;
virtual void device_post_load() override;
@ -1196,7 +1196,7 @@ public:
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
// device_t implementation
virtual void device_add_mconfig(machine_config &config) override;
virtual void device_start() override;
virtual void device_post_load() override;
@ -1299,7 +1299,7 @@ public:
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
// device_t implementation
virtual void device_add_mconfig(machine_config &config) override;
virtual void device_start() override;
virtual void device_post_load() override;

38
src/devices/bus/msx/cart/dooly.cpp
View File

@ -3,17 +3,33 @@
#include "emu.h"
#include "dooly.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_DOOLY, msx_cart_dooly_device, "msx_cart_dooly", "MSX Cartridge - Dooly")
msx_cart_dooly_device::msx_cart_dooly_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_DOOLY, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_view1(*this, "view1")
, m_view2(*this, "view2")
class msx_cart_dooly_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_dooly_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_DOOLY, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_view1(*this, "view1")
, m_view2(*this, "view2")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
void prot_w(u8 data);
u8 mode4_page1_r(offs_t offset);
u8 mode4_page2_r(offs_t offset);
memory_view m_view1;
memory_view m_view2;
};
void msx_cart_dooly_device::device_reset()
{
@ -68,3 +84,7 @@ void msx_cart_dooly_device::prot_w(u8 data)
logerror("msx_cart_dooly_device: unhandled protection mode %02x\n", data);
}
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_DOOLY, msx_cart_interface, msx_cart_dooly_device, "msx_cart_dooly", "MSX Cartridge - Dooly")

25
src/devices/bus/msx/cart/dooly.h
View File

@ -8,29 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_DOOLY, msx_cart_dooly_device)
class msx_cart_dooly_device : public device_t, public msx_cart_interface
{
public:
msx_cart_dooly_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
void prot_w(u8 data);
u8 mode4_page1_r(offs_t offset);
u8 mode4_page2_r(offs_t offset);
memory_view m_view1;
memory_view m_view2;
};
DECLARE_DEVICE_TYPE(MSX_CART_DOOLY, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_DOOLY_H

36
src/devices/bus/msx/cart/easi_speech.cpp
View File

@ -17,17 +17,33 @@ or a$=usr9("string")
#include "emu.h"
#include "easi_speech.h"
#include "sound/sp0256.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_EASISPEECH, msx_cart_easispeech_device, "msx_cart_easispeech", "MSX Cartridge - Easi-Speech")
msx_cart_easispeech_device::msx_cart_easispeech_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_EASISPEECH, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_speech(*this, "speech")
class msx_cart_easispeech_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_easispeech_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_EASISPEECH, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_speech(*this, "speech")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
u8 speech_r();
void speech_w(u8 data);
required_device<sp0256_device> m_speech;
};
ROM_START(msx_cart_easispeech)
ROM_REGION(0x10000, "speech", 0)
@ -76,3 +92,7 @@ void msx_cart_easispeech_device::speech_w(u8 data)
{
m_speech->ald_w(bitswap<6>(data,3,5,7,6,4,2));
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_EASISPEECH, msx_cart_interface, msx_cart_easispeech_device, "msx_cart_easispeech", "MSX Cartridge - Easi-Speech")

24
src/devices/bus/msx/cart/easi_speech.h
View File

@ -6,30 +6,8 @@
#pragma once
#include "bus/msx/slot/cartridge.h"
#include "sound/sp0256.h"
DECLARE_DEVICE_TYPE(MSX_CART_EASISPEECH, msx_cart_easispeech_device)
class msx_cart_easispeech_device : public device_t, public msx_cart_interface
{
public:
msx_cart_easispeech_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
u8 speech_r();
void speech_w(u8 data);
required_device<sp0256_device> m_speech;
};
DECLARE_DEVICE_TYPE(MSX_CART_EASISPEECH, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_EASISPEECH_H

60
src/devices/bus/msx/cart/fmpac.cpp
View File

@ -9,24 +9,55 @@ with: PAC2 BACKUP DATA. We only store the raw sram contents.
#include "emu.h"
#include "fmpac.h"
#include "sound/ymopl.h"
#include "speaker.h"
DEFINE_DEVICE_TYPE(MSX_CART_FMPAC, msx_cart_fmpac_device, "msx_cart_fmpac", "MSX Cartridge - FM-PAC")
namespace {
msx_cart_fmpac_device::msx_cart_fmpac_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_FMPAC, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_ym2413(*this, "ym2413")
, m_rombank(*this, "rombank")
, m_view(*this, "view")
, m_sram_active(false)
, m_opll_active(false)
, m_sram_unlock{0, 0}
, m_control(0)
class msx_cart_fmpac_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_fmpac_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_FMPAC, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_ym2413(*this, "ym2413")
, m_rombank(*this, "rombank")
, m_view(*this, "view")
, m_sram_active(false)
, m_opll_active(false)
, m_sram_unlock{0, 0}
, m_control(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
virtual void device_start() override;
virtual void device_reset() override;
// device_t implementation
virtual void device_add_mconfig(machine_config &config) override;
private:
void write_ym2413(offs_t offset, u8 data);
void sram_unlock(offs_t offset, u8 data);
u8 control_r();
void control_w(u8 data);
u8 bank_r();
void bank_w(u8 data);
required_device<ym2413_device> m_ym2413;
memory_bank_creator m_rombank;
memory_view m_view;
bool m_sram_active;
bool m_opll_active;
u8 m_sram_unlock[2];
u8 m_control;
};
void msx_cart_fmpac_device::device_add_mconfig(machine_config &config)
{
@ -35,7 +66,6 @@ void msx_cart_fmpac_device::device_add_mconfig(machine_config &config)
m_ym2413->add_route(ALL_OUTPUTS, soundin(), 0.8);
}
void msx_cart_fmpac_device::device_start()
{
save_item(NAME(m_sram_active));
@ -142,3 +172,7 @@ void msx_cart_fmpac_device::write_ym2413(offs_t offset, u8 data)
m_ym2413->write(offset & 1, data);
}
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_FMPAC, msx_cart_interface, msx_cart_fmpac_device, "msx_cart_fmpac", "MSX Cartridge - FM-PAC")

37
src/devices/bus/msx/cart/fmpac.h
View File

@ -6,43 +6,8 @@
#pragma once
#include "bus/msx/slot/cartridge.h"
#include "sound/ymopl.h"
DECLARE_DEVICE_TYPE(MSX_CART_FMPAC, msx_cart_fmpac_device)
class msx_cart_fmpac_device : public device_t, public msx_cart_interface
{
public:
msx_cart_fmpac_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
virtual void device_start() override;
virtual void device_reset() override;
// device-level overrides
virtual void device_add_mconfig(machine_config &config) override;
private:
void write_ym2413(offs_t offset, u8 data);
void sram_unlock(offs_t offset, u8 data);
u8 control_r();
void control_w(u8 data);
u8 bank_r();
void bank_w(u8 data);
required_device<ym2413_device> m_ym2413;
memory_bank_creator m_rombank;
memory_view m_view;
bool m_sram_active;
bool m_opll_active;
u8 m_sram_unlock[2];
u8 m_control;
};
DECLARE_DEVICE_TYPE(MSX_CART_FMPAC, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_FMPAC_H

37
src/devices/bus/msx/cart/fs_sr022.cpp
View File

@ -3,17 +3,32 @@
#include "emu.h"
#include "fs_sr022.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_FS_SR022, msx_cart_fs_sr022_device, "msx_cart_fs_sr022", "MSX Cartridge - FS-SR022")
msx_cart_fs_sr022_device::msx_cart_fs_sr022_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_FS_SR022, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_bunsetsu_rom(nullptr)
, m_bunsetsu_address(0)
class msx_cart_fs_sr022_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_fs_sr022_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_FS_SR022, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_bunsetsu_rom(nullptr)
, m_bunsetsu_address(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
private:
u8 buns_r();
void buns_w(offs_t offset, u8 data);
u8 *m_bunsetsu_rom;
u32 m_bunsetsu_address;
};
void msx_cart_fs_sr022_device::device_start()
{
@ -74,3 +89,7 @@ void msx_cart_fs_sr022_device::buns_w(offs_t offset, uint8_t data)
break;
}
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_FS_SR022, msx_cart_interface, msx_cart_fs_sr022_device, "msx_cart_fs_sr022", "MSX Cartridge - FS-SR022")

24
src/devices/bus/msx/cart/fs_sr022.h
View File

@ -8,28 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_FS_SR022, msx_cart_fs_sr022_device)
class msx_cart_fs_sr022_device : public device_t, public msx_cart_interface
{
public:
msx_cart_fs_sr022_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
private:
u8 buns_r();
void buns_w(offs_t offset, u8 data);
u8 *m_bunsetsu_rom;
u32 m_bunsetsu_address;
};
DECLARE_DEVICE_TYPE(MSX_CART_FS_SR022, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_FS_SR022_H

46
src/devices/bus/msx/cart/halnote.cpp
View File

@ -3,18 +3,40 @@
#include "emu.h"
#include "halnote.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_HALNOTE, msx_cart_halnote_device, "msx_cart_halnote", "MSX Cartridge - Halnote")
msx_cart_halnote_device::msx_cart_halnote_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_HALNOTE, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
class msx_cart_halnote_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_halnote_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_HALNOTE, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr u8 BANK_MASK = (0x100000 / 0x2000) - 1;
void bank0_w(u8 data);
void bank1_w(u8 data);
void bank2_w(u8 data);
void bank3_w(u8 data);
void bank4_w(u8 data);
void bank5_w(u8 data);
memory_bank_array_creator<6> m_rombank;
memory_view m_view0;
memory_view m_view1;
};
void msx_cart_halnote_device::device_reset()
{
@ -113,3 +135,7 @@ void msx_cart_halnote_device::bank5_w(u8 data)
{
m_rombank[5]->set_entry(data);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_HALNOTE, msx_cart_interface, msx_cart_halnote_device, "msx_cart_halnote", "MSX Cartridge - Halnote")

31
src/devices/bus/msx/cart/halnote.h
View File

@ -8,35 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_HALNOTE, msx_cart_halnote_device)
class msx_cart_halnote_device : public device_t, public msx_cart_interface
{
public:
msx_cart_halnote_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr u8 BANK_MASK = (0x100000 / 0x2000) - 1;
void bank0_w(u8 data);
void bank1_w(u8 data);
void bank2_w(u8 data);
void bank3_w(u8 data);
void bank4_w(u8 data);
void bank5_w(u8 data);
memory_bank_array_creator<6> m_rombank;
memory_view m_view0;
memory_view m_view1;
};
DECLARE_DEVICE_TYPE(MSX_CART_HALNOTE, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_HALNOTE_H

2
src/devices/bus/msx/cart/hbi55.h
View File

@ -7,7 +7,7 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_HBI55, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_HBI55_H

35
src/devices/bus/msx/cart/hfox.cpp
View File

@ -3,16 +3,31 @@
#include "emu.h"
#include "hfox.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_HFOX, msx_cart_hfox_device, "msx_cart_hfox", "MSX Cartridge - Hurry Fox")
msx_cart_hfox_device::msx_cart_hfox_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_HFOX, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
class msx_cart_hfox_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_hfox_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_HFOX, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<2> m_rombank;
u8 m_bank_mask;
};
void msx_cart_hfox_device::device_reset()
{
@ -55,3 +70,7 @@ void msx_cart_hfox_device::bank_w(u8 data)
{
m_rombank[Bank]->set_entry(data & m_bank_mask);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_HFOX, msx_cart_interface, msx_cart_hfox_device, "msx_cart_hfox", "MSX Cartridge - Hurry Fox")

24
src/devices/bus/msx/cart/hfox.h
View File

@ -8,28 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_HFOX, msx_cart_hfox_device)
class msx_cart_hfox_device : public device_t, public msx_cart_interface
{
public:
msx_cart_hfox_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<2> m_rombank;
u8 m_bank_mask;
};
DECLARE_DEVICE_TYPE(MSX_CART_HFOX, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_HFOX_H

46
src/devices/bus/msx/cart/holy_quran.cpp
View File

@ -12,18 +12,40 @@ GCMK-16X PCB, 2 ROM chips, Yamaha XE297A0 mapper chip.
#include "emu.h"
#include "holy_quran.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_HOLY_QURAN, msx_cart_holy_quran_device, "msx_cart_holy_quran", "MSX Cartridge - Holy Quran")
msx_cart_holy_quran_device::msx_cart_holy_quran_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_HOLY_QURAN, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view1(*this, "view1")
, m_view2(*this, "view2")
class msx_cart_holy_quran_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_holy_quran_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_HOLY_QURAN, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view1(*this, "view1")
, m_view2(*this, "view2")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x2000;
u8 read(offs_t offset);
u8 read2(offs_t offset);
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
memory_view m_view1;
memory_view m_view2;
std::vector<u8> m_decrypted;
u8 m_bank_mask;
};
std::error_condition msx_cart_holy_quran_device::initialize_cartridge(std::string &message)
{
@ -114,3 +136,7 @@ void msx_cart_holy_quran_device::bank_w(u8 data)
{
m_rombank[Bank]->set_entry(data & m_bank_mask);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_HOLY_QURAN, msx_cart_interface, msx_cart_holy_quran_device, "msx_cart_holy_quran", "MSX Cartridge - Holy Quran")

31
src/devices/bus/msx/cart/holy_quran.h
View File

@ -8,35 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_HOLY_QURAN, msx_cart_holy_quran_device)
class msx_cart_holy_quran_device : public device_t, public msx_cart_interface
{
public:
msx_cart_holy_quran_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
static constexpr size_t BANK_SIZE = 0x2000;
u8 read(offs_t offset);
u8 read2(offs_t offset);
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
memory_view m_view1;
memory_view m_view2;
std::vector<u8> m_decrypted;
u8 m_bank_mask;
};
DECLARE_DEVICE_TYPE(MSX_CART_HOLY_QURAN, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_HOLY_QURAN_H

34
src/devices/bus/msx/cart/ink.cpp
View File

@ -11,16 +11,32 @@ for protection.
#include "emu.h"
#include "ink.h"
#include "machine/intelfsh.h"
DEFINE_DEVICE_TYPE(MSX_CART_INK, msx_cart_ink_device, "msx_cart_ink", "MSX Cartridge - Ink")
namespace {
msx_cart_ink_device::msx_cart_ink_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_INK, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_flash(*this, "flash")
class msx_cart_ink_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_ink_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_INK, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_flash(*this, "flash")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
required_device<amd_29f040_device> m_flash;
template <int Page> void write_page(offs_t offset, u8 data);
};
ROM_START(msx_cart_ink)
ROM_REGION(0x80000, "flash", ROMREGION_ERASEFF)
@ -67,3 +83,7 @@ void msx_cart_ink_device::write_page(offs_t offset, u8 data)
// /RD connects to flashrom A16-A18
m_flash->write(offset | 0x70000 | (Page * 0x4000), data);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_INK, msx_cart_interface, msx_cart_ink_device, "msx_cart_ink", "MSX Cartridge - Ink")

24
src/devices/bus/msx/cart/ink.h
View File

@ -6,30 +6,8 @@
#pragma once
#include "bus/msx/slot/cartridge.h"
#include "machine/intelfsh.h"
DECLARE_DEVICE_TYPE(MSX_CART_INK, msx_cart_ink_device)
class msx_cart_ink_device : public device_t, public msx_cart_interface
{
public:
msx_cart_ink_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
required_device<amd_29f040_device> m_flash;
template <int Page> void write_page(offs_t offset, u8 data);
};
DECLARE_DEVICE_TYPE(MSX_CART_INK, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_INK_H

74
src/devices/bus/msx/cart/kanji.cpp
View File

@ -14,19 +14,36 @@ TODO:
#include "speaker.h"
#define VERBOSE 0
#include "logmacro.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_KANJI, msx_cart_kanji_device, "msx_cart_kanji", "MSX Cartridge - Kanji")
DEFINE_DEVICE_TYPE(MSX_CART_MSXWRITE, msx_cart_msxwrite_device, "msx_cart_msxwrite", "MSX Cartridge - MSXWRITE")
msx_cart_kanji_device::msx_cart_kanji_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_kanji_device(mconfig, MSX_CART_KANJI, tag, owner, clock)
class msx_cart_kanji_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_kanji_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_kanji_device(mconfig, MSX_CART_KANJI, tag, owner, clock)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
msx_cart_kanji_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock);
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
std::error_condition validate_kanji_regions(std::string &message);
void install_kanji_handlers();
u8 kanji_r(offs_t offset);
void kanji_w(offs_t offset, u8 data);
u32 m_kanji_mask;
u32 m_kanji_address;
};
msx_cart_kanji_device::msx_cart_kanji_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, type, tag, owner, clock)
@ -106,6 +123,33 @@ void msx_cart_kanji_device::kanji_w(offs_t offset, u8 data)
class msx_cart_msxwrite_device : public msx_cart_kanji_device
{
public:
msx_cart_msxwrite_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_kanji_device(mconfig, MSX_CART_MSXWRITE, tag, owner, clock)
, m_rombank(*this, "rombank%u", 0U)
, m_kanji_switch(*this, "KANJI")
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_reset() override;
virtual ioport_constructor device_input_ports() const override;
private:
static constexpr size_t BANK_SIZE = 0x4000;
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<2> m_rombank;
required_ioport m_kanji_switch;
u8 m_bank_mask;
};
static INPUT_PORTS_START(msxwrite_kanji_enable_switch)
PORT_START("KANJI")
PORT_CONFNAME(0x01, 0x01, "Kanji is")
@ -113,15 +157,6 @@ static INPUT_PORTS_START(msxwrite_kanji_enable_switch)
PORT_CONFSETTING(0x01, "enabled")
INPUT_PORTS_END
msx_cart_msxwrite_device::msx_cart_msxwrite_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_kanji_device(mconfig, MSX_CART_MSXWRITE, tag, owner, clock)
, m_rombank(*this, "rombank%u", 0U)
, m_kanji_switch(*this, "KANJI")
, m_bank_mask(0)
{
}
ioport_constructor msx_cart_msxwrite_device::device_input_ports() const
{
return INPUT_PORTS_NAME(msxwrite_kanji_enable_switch);
@ -179,3 +214,8 @@ void msx_cart_msxwrite_device::bank_w(u8 data)
{
m_rombank[Bank]->set_entry(data & m_bank_mask);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KANJI, msx_cart_interface, msx_cart_kanji_device, "msx_cart_kanji", "MSX Cartridge - Kanji")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MSXWRITE, msx_cart_interface, msx_cart_msxwrite_device, "msx_cart_msxwrite", "MSX Cartridge - MSXWRITE")

52
src/devices/bus/msx/cart/kanji.h
View File

@ -8,55 +8,7 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_KANJI, msx_cart_kanji_device)
DECLARE_DEVICE_TYPE(MSX_CART_MSXWRITE, msx_cart_msxwrite_device)
class msx_cart_kanji_device : public device_t, public msx_cart_interface
{
public:
msx_cart_kanji_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
msx_cart_kanji_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock);
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
std::error_condition validate_kanji_regions(std::string &message);
void install_kanji_handlers();
u8 kanji_r(offs_t offset);
void kanji_w(offs_t offset, u8 data);
u32 m_kanji_mask;
u32 m_kanji_address;
};
class msx_cart_msxwrite_device : public msx_cart_kanji_device
{
public:
msx_cart_msxwrite_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_reset() override;
virtual ioport_constructor device_input_ports() const override;
private:
static constexpr size_t BANK_SIZE = 0x4000;
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<2> m_rombank;
required_ioport m_kanji_switch;
u8 m_bank_mask;
};
DECLARE_DEVICE_TYPE(MSX_CART_KANJI, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_MSXWRITE, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_KANJI_H

298
src/devices/bus/msx/cart/konami.cpp
View File

@ -3,26 +3,38 @@
#include "emu.h"
#include "konami.h"
#include "sound/k051649.h"
#include "sound/vlm5030.h"
#include "sound/dac.h"
#include "speaker.h"
DEFINE_DEVICE_TYPE(MSX_CART_KONAMI, msx_cart_konami_device, "msx_cart_konami", "MSX Cartridge - KONAMI")
DEFINE_DEVICE_TYPE(MSX_CART_KONAMI_SCC, msx_cart_konami_scc_device, "msx_cart_konami_scc", "MSX Cartridge - KONAMI+SCC")
DEFINE_DEVICE_TYPE(MSX_CART_GAMEMASTER2, msx_cart_gamemaster2_device, "msx_cart_gamemaster2", "MSX Cartridge - GAMEMASTER2")
DEFINE_DEVICE_TYPE(MSX_CART_SYNTHESIZER, msx_cart_synthesizer_device, "msx_cart_synthesizer", "MSX Cartridge - Synthesizer")
DEFINE_DEVICE_TYPE(MSX_CART_SOUND_SNATCHER, msx_cart_konami_sound_snatcher_device, "msx_cart_sound_snatcher", "MSX Cartridge - Sound Snatcher")
DEFINE_DEVICE_TYPE(MSX_CART_SOUND_SDSNATCHER, msx_cart_konami_sound_sdsnatcher_device, "msx_cart_sound_sdsnatcher", "MSX Cartridge - Sound SD Snatcher")
DEFINE_DEVICE_TYPE(MSX_CART_KEYBOARD_MASTER, msx_cart_keyboard_master_device, "msx_cart_keyboard_master", "MSX Cartridge - Keyboard Master")
DEFINE_DEVICE_TYPE(MSX_CART_EC701, msx_cart_ec701_device, "msx_cart_ec701", "MSX Cartridge - Konami EC-701")
namespace {
msx_cart_konami_device::msx_cart_konami_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KONAMI, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
class msx_cart_konami_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_konami_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KONAMI, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
void msx_cart_konami_device::device_reset()
{
@ -77,15 +89,36 @@ void msx_cart_konami_device::bank_w(u8 data)
msx_cart_konami_scc_device::msx_cart_konami_scc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_KONAMI_SCC, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_k051649(*this, "k051649")
, m_rombank(*this, "rombank%u", 0U)
, m_scc_view(*this, "scc_view")
, m_bank_mask(0)
class msx_cart_konami_scc_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_konami_scc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_KONAMI_SCC, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_k051649(*this, "k051649")
, m_rombank(*this, "rombank%u", 0U)
, m_scc_view(*this, "scc_view")
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
virtual void device_add_mconfig(machine_config &config) override;
private:
template <int Bank> void bank_w(u8 data);
required_device<k051649_device> m_k051649;
memory_bank_array_creator<4> m_rombank;
memory_view m_scc_view;
u8 m_bank_mask;
};
void msx_cart_konami_scc_device::device_add_mconfig(machine_config &config)
{
@ -166,16 +199,35 @@ void msx_cart_konami_scc_device::bank_w(u8 data)
msx_cart_gamemaster2_device::msx_cart_gamemaster2_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_GAMEMASTER2, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_rambank(*this, "rambank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
, m_view2(*this, "view2")
class msx_cart_gamemaster2_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_gamemaster2_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_GAMEMASTER2, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_rambank(*this, "rambank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
, m_view2(*this, "view2")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<3> m_rombank;
memory_bank_array_creator<3> m_rambank;
memory_view m_view0;
memory_view m_view1;
memory_view m_view2;
};
void msx_cart_gamemaster2_device::device_reset()
{
@ -263,12 +315,26 @@ void msx_cart_gamemaster2_device::bank_w(u8 data)
msx_cart_synthesizer_device::msx_cart_synthesizer_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_SYNTHESIZER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_dac(*this, "dac")
class msx_cart_synthesizer_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_synthesizer_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_SYNTHESIZER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_dac(*this, "dac")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
private:
required_device<dac_8bit_r2r_device> m_dac;
};
void msx_cart_synthesizer_device::device_add_mconfig(machine_config &config)
{
@ -301,21 +367,56 @@ std::error_condition msx_cart_synthesizer_device::initialize_cartridge(std::stri
msx_cart_konami_sound_device::msx_cart_konami_sound_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, u8 min_rambank, u8 max_rambank)
: device_t(mconfig, type, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_k052539(*this, "k052539")
, m_rambank(*this, "rambank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
, m_view2(*this, "view2")
, m_view3(*this, "view3")
, m_min_rambank(min_rambank)
, m_max_rambank(max_rambank)
, m_selected_bank{0, 0, 0, 0}
, m_control(0)
class msx_cart_konami_sound_device : public device_t, public msx_cart_interface
{
}
public:
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
msx_cart_konami_sound_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, u8 min_rambank, u8 max_rambank)
: device_t(mconfig, type, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_k052539(*this, "k052539")
, m_rambank(*this, "rambank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
, m_view2(*this, "view2")
, m_view3(*this, "view3")
, m_min_rambank(min_rambank)
, m_max_rambank(max_rambank)
, m_selected_bank{0, 0, 0, 0}
, m_control(0)
{ }
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_add_mconfig(machine_config &config) override;
private:
static constexpr u8 VIEW_READ = 0;
static constexpr u8 VIEW_RAM = 1;
static constexpr u8 VIEW_INVALID = 2;
static constexpr u8 VIEW_SCC = 4;
template <int Bank> void bank_w(u8 data);
template <int Bank> void switch_bank();
void control_w(u8 data);
// This is actually a K052539
required_device<k051649_device> m_k052539;
memory_bank_array_creator<4> m_rambank;
memory_view m_view0;
memory_view m_view1;
memory_view m_view2;
memory_view m_view3;
u8 m_min_rambank;
u8 m_max_rambank;
u8 m_selected_bank[4];
u8 m_control;
};
void msx_cart_konami_sound_device::device_add_mconfig(machine_config &config)
{
@ -482,11 +583,16 @@ void msx_cart_konami_sound_device::bank_w(u8 data)
// The Snatcher Sound cartridge has 64KB RAM available by selecting ram banks 0-7
msx_cart_konami_sound_snatcher_device::msx_cart_konami_sound_snatcher_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_konami_sound_device(mconfig, MSX_CART_SOUND_SNATCHER, tag, owner, clock, 0, 7)
class msx_cart_konami_sound_snatcher_device : public msx_cart_konami_sound_device
{
}
public:
// The Snatcher Sound cartridge has 64KB RAM available by selecting ram banks 0-7
msx_cart_konami_sound_snatcher_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_konami_sound_device(mconfig, MSX_CART_SOUND_SNATCHER, tag, owner, clock, 0, 7)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
};
std::error_condition msx_cart_konami_sound_snatcher_device::initialize_cartridge(std::string &message)
{
@ -506,11 +612,16 @@ std::error_condition msx_cart_konami_sound_snatcher_device::initialize_cartridge
}
// The SD Snatcher Sound cartridge has 64KB RAM available by selecting ram banks 8-15
msx_cart_konami_sound_sdsnatcher_device::msx_cart_konami_sound_sdsnatcher_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_konami_sound_device(mconfig, MSX_CART_SOUND_SDSNATCHER, tag, owner, clock, 8, 15)
class msx_cart_konami_sound_sdsnatcher_device : public msx_cart_konami_sound_device
{
}
public:
// The SD Snatcher Sound cartridge has 64KB RAM available by selecting ram banks 8-15
msx_cart_konami_sound_sdsnatcher_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: msx_cart_konami_sound_device(mconfig, MSX_CART_SOUND_SDSNATCHER, tag, owner, clock, 8, 15)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
};
std::error_condition msx_cart_konami_sound_sdsnatcher_device::initialize_cartridge(std::string &message)
{
@ -531,12 +642,32 @@ std::error_condition msx_cart_konami_sound_sdsnatcher_device::initialize_cartrid
msx_cart_keyboard_master_device::msx_cart_keyboard_master_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KEYBOARD_MASTER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_vlm5030(*this, "vlm5030")
class msx_cart_keyboard_master_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_keyboard_master_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KEYBOARD_MASTER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_vlm5030(*this, "vlm5030")
{ }
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual std::error_condition initialize_cartridge(std::string &message) override;
private:
required_device<vlm5030_device> m_vlm5030;
uint8_t read_vlm(offs_t offset);
void io_20_w(uint8_t data);
uint8_t io_00_r();
void vlm_map(address_map &map);
};
void msx_cart_keyboard_master_device::vlm_map(address_map &map)
{
@ -606,13 +737,29 @@ uint8_t msx_cart_keyboard_master_device::io_00_r()
msx_cart_ec701_device::msx_cart_ec701_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_EC701, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
, m_view(*this, "view")
class msx_cart_ec701_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_ec701_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_EC701, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
, m_view(*this, "view")
{ }
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
virtual std::error_condition initialize_cartridge(std::string &message) override;
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
memory_view m_view;
};
void msx_cart_ec701_device::device_reset()
{
@ -665,3 +812,14 @@ void msx_cart_ec701_device::bank_w(u8 data)
break;
}
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KONAMI, msx_cart_interface, msx_cart_konami_device, "msx_cart_konami", "MSX Cartridge - KONAMI")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KONAMI_SCC, msx_cart_interface, msx_cart_konami_scc_device, "msx_cart_konami_scc", "MSX Cartridge - KONAMI+SCC")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_GAMEMASTER2, msx_cart_interface, msx_cart_gamemaster2_device, "msx_cart_gamemaster2", "MSX Cartridge - GAMEMASTER2")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_SYNTHESIZER, msx_cart_interface, msx_cart_synthesizer_device, "msx_cart_synthesizer", "MSX Cartridge - Synthesizer")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_SOUND_SNATCHER, msx_cart_interface, msx_cart_konami_sound_snatcher_device, "msx_cart_sound_snatcher", "MSX Cartridge - Sound Snatcher")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_SOUND_SDSNATCHER, msx_cart_interface, msx_cart_konami_sound_sdsnatcher_device, "msx_cart_sound_sdsnatcher", "MSX Cartridge - Sound SD Snatcher")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KEYBOARD_MASTER, msx_cart_interface, msx_cart_keyboard_master_device, "msx_cart_keyboard_master", "MSX Cartridge - Keyboard Master")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_EC701, msx_cart_interface, msx_cart_ec701_device, "msx_cart_ec701", "MSX Cartridge - Konami EC-701")

210
src/devices/bus/msx/cart/konami.h
View File

@ -6,209 +6,15 @@
#pragma once
#include "bus/msx/slot/cartridge.h"
#include "sound/k051649.h"
#include "sound/vlm5030.h"
#include "sound/dac.h"
DECLARE_DEVICE_TYPE(MSX_CART_KONAMI, msx_cart_konami_device)
DECLARE_DEVICE_TYPE(MSX_CART_KONAMI_SCC, msx_cart_konami_scc_device)
DECLARE_DEVICE_TYPE(MSX_CART_GAMEMASTER2, msx_cart_gamemaster2_device)
DECLARE_DEVICE_TYPE(MSX_CART_SYNTHESIZER, msx_cart_synthesizer_device)
DECLARE_DEVICE_TYPE(MSX_CART_SOUND_SNATCHER, msx_cart_konami_sound_snatcher_device)
DECLARE_DEVICE_TYPE(MSX_CART_SOUND_SDSNATCHER, msx_cart_konami_sound_sdsnatcher_device)
DECLARE_DEVICE_TYPE(MSX_CART_KEYBOARD_MASTER, msx_cart_keyboard_master_device)
DECLARE_DEVICE_TYPE(MSX_CART_EC701, msx_cart_ec701_device)
class msx_cart_konami_device : public device_t, public msx_cart_interface
{
public:
msx_cart_konami_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
class msx_cart_konami_scc_device : public device_t, public msx_cart_interface
{
public:
msx_cart_konami_scc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
virtual void device_add_mconfig(machine_config &config) override;
private:
template <int Bank> void bank_w(u8 data);
required_device<k051649_device> m_k051649;
memory_bank_array_creator<4> m_rombank;
memory_view m_scc_view;
u8 m_bank_mask;
};
class msx_cart_gamemaster2_device : public device_t, public msx_cart_interface
{
public:
msx_cart_gamemaster2_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
template <int Bank> void bank_w(u8 data);
memory_bank_array_creator<3> m_rombank;
memory_bank_array_creator<3> m_rambank;
memory_view m_view0;
memory_view m_view1;
memory_view m_view2;
};
class msx_cart_synthesizer_device : public device_t, public msx_cart_interface
{
public:
msx_cart_synthesizer_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
private:
required_device<dac_8bit_r2r_device> m_dac;
};
class msx_cart_konami_sound_device : public device_t, public msx_cart_interface
{
public:
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
msx_cart_konami_sound_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, u8 min_rambank, u8 max_rambank);
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_add_mconfig(machine_config &config) override;
private:
static constexpr u8 VIEW_READ = 0;
static constexpr u8 VIEW_RAM = 1;
static constexpr u8 VIEW_INVALID = 2;
static constexpr u8 VIEW_SCC = 4;
template <int Bank> void bank_w(u8 data);
template <int Bank> void switch_bank();
void control_w(u8 data);
// This is actually a K052539
required_device<k051649_device> m_k052539;
memory_bank_array_creator<4> m_rambank;
memory_view m_view0;
memory_view m_view1;
memory_view m_view2;
memory_view m_view3;
u8 m_min_rambank;
u8 m_max_rambank;
u8 m_selected_bank[4];
u8 m_control;
};
class msx_cart_konami_sound_snatcher_device : public msx_cart_konami_sound_device
{
public:
msx_cart_konami_sound_snatcher_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
};
class msx_cart_konami_sound_sdsnatcher_device : public msx_cart_konami_sound_device
{
public:
msx_cart_konami_sound_sdsnatcher_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
};
class msx_cart_keyboard_master_device : public device_t, public msx_cart_interface
{
public:
msx_cart_keyboard_master_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
protected:
// device-level overrides
virtual void device_start() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual std::error_condition initialize_cartridge(std::string &message) override;
private:
required_device<vlm5030_device> m_vlm5030;
uint8_t read_vlm(offs_t offset);
void io_20_w(uint8_t data);
uint8_t io_00_r();
void vlm_map(address_map &map);
};
class msx_cart_ec701_device : public device_t, public msx_cart_interface
{
public:
msx_cart_ec701_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
virtual std::error_condition initialize_cartridge(std::string &message) override;
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
memory_view m_view;
};
DECLARE_DEVICE_TYPE(MSX_CART_KONAMI, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_KONAMI_SCC, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_GAMEMASTER2, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_SYNTHESIZER, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_SOUND_SNATCHER, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_SOUND_SDSNATCHER, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_KEYBOARD_MASTER, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_EC701, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_KONAMI_H

159
src/devices/bus/msx/cart/korean.cpp
View File

@ -3,20 +3,33 @@
#include "emu.h"
#include "korean.h"
DEFINE_DEVICE_TYPE(MSX_CART_KOREAN_25IN1, msx_cart_korean_25in1_device, "msx_cart_korean_25in1", "MSX Cartridge - Korean 25-in-1")
DEFINE_DEVICE_TYPE(MSX_CART_KOREAN_80IN1, msx_cart_korean_80in1_device, "msx_cart_korean_80in1", "MSX Cartridge - Korean 80-in-1")
DEFINE_DEVICE_TYPE(MSX_CART_KOREAN_90IN1, msx_cart_korean_90in1_device, "msx_cart_korean_90in1", "MSX Cartridge - Korean 90-in-1")
DEFINE_DEVICE_TYPE(MSX_CART_KOREAN_126IN1, msx_cart_korean_126in1_device, "msx_cart_korean_126in1", "MSX Cartridge - Korean 126-in-1")
DEFINE_DEVICE_TYPE(MSX_CART_KOREAN_HYDLIDE2, msx_cart_korean_hydlide2_device, "msx_cart_korean_hydlide2", "MSX Cartridge - Korean Hydlide 2")
namespace {
msx_cart_korean_25in1_device::msx_cart_korean_25in1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_KOREAN_25IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
class msx_cart_korean_25in1_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_korean_25in1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_KOREAN_25IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
void msx_cart_korean_25in1_device::device_reset()
{
@ -68,13 +81,30 @@ void msx_cart_korean_25in1_device::bank_w(u8 data)
msx_cart_korean_80in1_device::msx_cart_korean_80in1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_KOREAN_80IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
class msx_cart_korean_80in1_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_korean_80in1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_KOREAN_80IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(offs_t offset, u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
void msx_cart_korean_80in1_device::device_reset()
{
@ -122,14 +152,31 @@ void msx_cart_korean_80in1_device::bank_w(offs_t offset, u8 data)
msx_cart_korean_90in1_device::msx_cart_korean_90in1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KOREAN_90IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view(*this, "view")
, m_bank_mask(0)
class msx_cart_korean_90in1_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_korean_90in1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KOREAN_90IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_view(*this, "view")
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
private:
void banking(u8 data);
memory_bank_array_creator<3> m_rombank;
memory_view m_view;
u8 m_bank_mask;
};
void msx_cart_korean_90in1_device::device_start()
{
@ -195,13 +242,29 @@ void msx_cart_korean_90in1_device::banking(u8 data)
msx_cart_korean_126in1_device::msx_cart_korean_126in1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KOREAN_126IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
class msx_cart_korean_126in1_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_korean_126in1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KOREAN_126IN1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(offs_t offset, u8 data);
memory_bank_array_creator<2> m_rombank;
u8 m_bank_mask;
};
void msx_cart_korean_126in1_device::device_reset()
{
@ -247,13 +310,29 @@ void msx_cart_korean_126in1_device::bank_w(offs_t offset, uint8_t data)
msx_cart_korean_hydlide2_device::msx_cart_korean_hydlide2_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KOREAN_HYDLIDE2, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
, m_bank_mask(0)
class msx_cart_korean_hydlide2_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_korean_hydlide2_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_KOREAN_HYDLIDE2, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
, m_bank_mask(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
u8 m_bank_mask;
};
void msx_cart_korean_hydlide2_device::device_reset()
{
@ -292,3 +371,11 @@ void msx_cart_korean_hydlide2_device::bank_w(uint8_t data)
{
m_rombank->set_entry(data & m_bank_mask);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KOREAN_25IN1, msx_cart_interface, msx_cart_korean_25in1_device, "msx_cart_korean_25in1", "MSX Cartridge - Korean 25-in-1")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KOREAN_80IN1, msx_cart_interface, msx_cart_korean_80in1_device, "msx_cart_korean_80in1", "MSX Cartridge - Korean 80-in-1")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KOREAN_90IN1, msx_cart_interface, msx_cart_korean_90in1_device, "msx_cart_korean_90in1", "MSX Cartridge - Korean 90-in-1")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KOREAN_126IN1, msx_cart_interface, msx_cart_korean_126in1_device, "msx_cart_korean_126in1", "MSX Cartridge - Korean 126-in-1")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_KOREAN_HYDLIDE2, msx_cart_interface, msx_cart_korean_hydlide2_device, "msx_cart_korean_hydlide2", "MSX Cartridge - Korean Hydlide 2")

114
src/devices/bus/msx/cart/korean.h
View File

@ -8,114 +8,10 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_25IN1, msx_cart_korean_25in1_device)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_80IN1, msx_cart_korean_80in1_device)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_90IN1, msx_cart_korean_90in1_device)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_126IN1, msx_cart_korean_126in1_device)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_HYDLIDE2, msx_cart_korean_hydlide2_device)
class msx_cart_korean_25in1_device : public device_t, public msx_cart_interface
{
public:
msx_cart_korean_25in1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
class msx_cart_korean_80in1_device : public device_t, public msx_cart_interface
{
public:
msx_cart_korean_80in1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(offs_t offset, u8 data);
memory_bank_array_creator<4> m_rombank;
u8 m_bank_mask;
};
class msx_cart_korean_90in1_device : public device_t, public msx_cart_interface
{
public:
msx_cart_korean_90in1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
private:
void banking(u8 data);
memory_bank_array_creator<3> m_rombank;
memory_view m_view;
u8 m_bank_mask;
};
class msx_cart_korean_126in1_device : public device_t, public msx_cart_interface
{
public:
msx_cart_korean_126in1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(offs_t offset, u8 data);
memory_bank_array_creator<2> m_rombank;
u8 m_bank_mask;
};
class msx_cart_korean_hydlide2_device : public device_t, public msx_cart_interface
{
public:
msx_cart_korean_hydlide2_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_reset() override;
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
u8 m_bank_mask;
};
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_25IN1, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_80IN1, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_90IN1, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_126IN1, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_KOREAN_HYDLIDE2, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_KOREAN_H

15
src/devices/bus/msx/cart/loveplus.cpp
View File

@ -14,12 +14,16 @@ namespace {
class msx_cart_loveplus_device : public device_t, public msx_cart_interface
{
public:
msx_cart_loveplus_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
msx_cart_loveplus_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_LOVEPLUS, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
@ -34,13 +38,6 @@ private:
};
msx_cart_loveplus_device::msx_cart_loveplus_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_LOVEPLUS, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
{
}
void msx_cart_loveplus_device::device_start()
{
save_item(NAME(m_bank_locked));

1
src/devices/bus/msx/cart/loveplus.h
View File

@ -10,5 +10,4 @@
DECLARE_DEVICE_TYPE(MSX_CART_LOVEPLUS, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_LOVEPLUS_H

38
src/devices/bus/msx/cart/majutsushi.cpp
View File

@ -3,19 +3,37 @@
#include "emu.h"
#include "majutsushi.h"
#include "sound/dac.h"
#include "speaker.h"
DEFINE_DEVICE_TYPE(MSX_CART_MAJUTSUSHI, msx_cart_majutsushi_device, "msx_cart_majutsushi", "MSX Cartridge - Majutsushi")
namespace {
msx_cart_majutsushi_device::msx_cart_majutsushi_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MAJUTSUSHI, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_dac(*this, "dac")
, m_rombank(*this, "rombank%u", 0U)
class msx_cart_majutsushi_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_majutsushi_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MAJUTSUSHI, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_dac(*this, "dac")
, m_rombank(*this, "rombank%u", 0U)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
private:
template <int Bank> void bank_w(u8 data);
required_device<dac_8bit_r2r_device> m_dac;
memory_bank_array_creator<3> m_rombank;
};
void msx_cart_majutsushi_device::device_add_mconfig(machine_config &config)
{
@ -68,3 +86,7 @@ void msx_cart_majutsushi_device::bank_w(u8 data)
{
m_rombank[Bank]->set_entry(data & 0x0f);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MAJUTSUSHI, msx_cart_interface, msx_cart_majutsushi_device, "msx_cart_majutsushi", "MSX Cartridge - Majutsushi")

25
src/devices/bus/msx/cart/majutsushi.h
View File

@ -6,31 +6,8 @@
#pragma once
#include "bus/msx/slot/cartridge.h"
#include "sound/dac.h"
DECLARE_DEVICE_TYPE(MSX_CART_MAJUTSUSHI, msx_cart_majutsushi_device)
class msx_cart_majutsushi_device : public device_t, public msx_cart_interface
{
public:
msx_cart_majutsushi_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
virtual void device_add_mconfig(machine_config &config) override;
private:
template <int Bank> void bank_w(u8 data);
required_device<dac_8bit_r2r_device> m_dac;
memory_bank_array_creator<3> m_rombank;
};
DECLARE_DEVICE_TYPE(MSX_CART_MAJUTSUSHI, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_MAJUTSUSHI_H

22
src/devices/bus/msx/cart/matra.cpp
View File

@ -8,12 +8,18 @@ namespace {
class msx_cart_matra_comp_device : public device_t, public msx_cart_interface
{
public:
msx_cart_matra_comp_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
msx_cart_matra_comp_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_MATRA_COMP, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
, m_banking_enabled(true)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
@ -27,16 +33,6 @@ private:
bool m_banking_enabled;
};
msx_cart_matra_comp_device::msx_cart_matra_comp_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_MATRA_COMP, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank%u", 0U)
, m_bank_mask(0)
, m_banking_enabled(true)
{
}
void msx_cart_matra_comp_device::device_start()
{
save_item(NAME(m_banking_enabled));
@ -99,4 +95,4 @@ void msx_cart_matra_comp_device::disable_banking_w(u8 data)
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MATRA_COMP, msx_cart_interface, msx_cart_matra_comp_device, "msx_cart_matra_comp", "MSX Cartridge - Matra Compilation")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MATRA_COMP, msx_cart_interface, msx_cart_matra_comp_device, "msx_cart_matra_comp", "MSX Cartridge - Matra Compilation")

3
src/devices/bus/msx/cart/matra.h
View File

@ -8,7 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_MATRA_COMP, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_MATRA_COMP, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_MATRA_H

40
src/devices/bus/msx/cart/moonsound.cpp
View File

@ -11,22 +11,42 @@ TODO:
#include "emu.h"
#include "moonsound.h"
#include "sound/ymopl.h"
#include "speaker.h"
#define VERBOSE 0
#include "logmacro.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_MOONSOUND, msx_cart_moonsound_device, "msx_moonsound", "MSX Cartridge - MoonSound")
msx_cart_moonsound_device::msx_cart_moonsound_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MOONSOUND, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_ymf278b(*this, "ymf278b")
class msx_cart_moonsound_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_moonsound_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MOONSOUND, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_ymf278b(*this, "ymf278b")
{ }
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void irq_w(int state);
void write_ymf278b_pcm(offs_t offset, u8 data);
u8 read_ymf278b_pcm(offs_t offset);
u8 read_c0();
void ymf278b_map(address_map &map);
required_device<ymf278b_device> m_ymf278b;
};
void msx_cart_moonsound_device::ymf278b_map(address_map &map)
{
@ -97,3 +117,7 @@ u8 msx_cart_moonsound_device::read_c0()
LOG("moonsound: read 0xc0\n");
return 0x00;
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MOONSOUND, msx_cart_interface, msx_cart_moonsound_device, "msx_moonsound", "MSX Cartridge - MoonSound")

28
src/devices/bus/msx/cart/moonsound.h
View File

@ -6,34 +6,8 @@
#pragma once
#include "bus/msx/slot/cartridge.h"
#include "sound/ymopl.h"
DECLARE_DEVICE_TYPE(MSX_CART_MOONSOUND, msx_cart_moonsound_device)
class msx_cart_moonsound_device : public device_t, public msx_cart_interface
{
public:
msx_cart_moonsound_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
protected:
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void irq_w(int state);
void write_ymf278b_pcm(offs_t offset, u8 data);
u8 read_ymf278b_pcm(offs_t offset);
u8 read_c0();
void ymf278b_map(address_map &map);
required_device<ymf278b_device> m_ymf278b;
};
DECLARE_DEVICE_TYPE(MSX_CART_MOONSOUND, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_MOONSOUND_H

127
src/devices/bus/msx/cart/msx_audio.cpp
View File

@ -62,22 +62,38 @@ and/or http://ngs.no.coocan.jp/doc/wiki.cgi/datapack?page=4.2+MSX-AUDIO+%B3%C8%C
#include "emu.h"
#include "msx_audio.h"
#include "msx_audio_kb.h"
#include "bus/midi/midi.h"
#include "machine/6850acia.h"
#include "sound/ymopl.h"
#include "speaker.h"
DEFINE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_HXMU900, msx_cart_msx_audio_hxmu900_device, "msx_audio_hxmu900", "MSX Cartridge - MSX-AUDIO HX-MU900")
DEFINE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_NMS1205, msx_cart_msx_audio_nms1205_device, "msx_audio_nms1205", "MSX Cartridge - MSX-AUDIO NMS-1205")
DEFINE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_FSCA1, msx_cart_msx_audio_fsca1_device, "msx_audio_fsca1", "MSX Cartridge - MSX-AUDIO FS-CA1")
namespace {
msx_cart_msx_audio_hxmu900_device::msx_cart_msx_audio_hxmu900_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MSX_AUDIO_HXMU900, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_y8950(*this, "y8950")
class msx_cart_msx_audio_hxmu900_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_msx_audio_hxmu900_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MSX_AUDIO_HXMU900, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_y8950(*this, "y8950")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
required_device<y8950_device> m_y8950;
};
void msx_cart_msx_audio_hxmu900_device::device_add_mconfig(machine_config &config)
{
@ -130,15 +146,35 @@ const tiny_rom_entry *msx_cart_msx_audio_hxmu900_device::device_rom_region() con
msx_cart_msx_audio_nms1205_device::msx_cart_msx_audio_nms1205_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_MSX_AUDIO_NMS1205, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_y8950(*this, "y8950")
, m_acia6850(*this, "acia6850")
, m_mdout(*this, "mdout")
, m_mdthru(*this, "mdthru")
class msx_cart_msx_audio_nms1205_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_msx_audio_nms1205_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MSX_AUDIO_NMS1205, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_y8950(*this, "y8950")
, m_acia6850(*this, "acia6850")
, m_mdout(*this, "mdout")
, m_mdthru(*this, "mdthru")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void midi_in(int state);
void irq_write(int state);
required_device<y8950_device> m_y8950;
required_device<acia6850_device> m_acia6850;
required_device<midi_port_device> m_mdout;
required_device<midi_port_device> m_mdthru;
};
void msx_cart_msx_audio_nms1205_device::device_add_mconfig(machine_config &config)
{
@ -221,18 +257,47 @@ std::error_condition msx_cart_msx_audio_nms1205_device::initialize_cartridge(std
msx_cart_msx_audio_fsca1_device::msx_cart_msx_audio_fsca1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_MSX_AUDIO_FSCA1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_y8950(*this, "y8950")
, m_io_config(*this, "CONFIG")
, m_region_y8950(*this, "y8950")
, m_rombank(*this, "rombank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
, m_7fff(0)
class msx_cart_msx_audio_fsca1_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_msx_audio_fsca1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_MSX_AUDIO_FSCA1, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_y8950(*this, "y8950")
, m_io_config(*this, "CONFIG")
, m_region_y8950(*this, "y8950")
, m_rombank(*this, "rombank%u", 0U)
, m_view0(*this, "view0")
, m_view1(*this, "view1")
, m_7fff(0)
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual ioport_constructor device_input_ports() const override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void write_y8950(offs_t offset, u8 data);
u8 read_y8950(offs_t offset);
void y8950_io_w(u8 data);
u8 y8950_io_r();
void bank_w(u8 data);
void write_7fff(u8 data);
required_device<y8950_device> m_y8950;
required_ioport m_io_config;
required_memory_region m_region_y8950;
memory_bank_array_creator<2> m_rombank;
memory_view m_view0;
memory_view m_view1;
u8 m_7fff;
};
void msx_cart_msx_audio_fsca1_device::device_add_mconfig(machine_config &config)
{
@ -364,3 +429,9 @@ u8 msx_cart_msx_audio_fsca1_device::y8950_io_r()
{
return m_io_config->read();
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MSX_AUDIO_HXMU900, msx_cart_interface, msx_cart_msx_audio_hxmu900_device, "msx_audio_hxmu900", "MSX Cartridge - MSX-AUDIO HX-MU900")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MSX_AUDIO_NMS1205, msx_cart_interface, msx_cart_msx_audio_nms1205_device, "msx_audio_nms1205", "MSX Cartridge - MSX-AUDIO NMS-1205")
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_MSX_AUDIO_FSCA1, msx_cart_interface, msx_cart_msx_audio_fsca1_device, "msx_audio_fsca1", "MSX Cartridge - MSX-AUDIO FS-CA1")

87
src/devices/bus/msx/cart/msx_audio.h
View File

@ -6,91 +6,10 @@
#pragma once
#include "bus/msx/slot/cartridge.h"
#include "sound/ymopl.h"
#include "machine/6850acia.h"
#include "bus/midi/midi.h"
DECLARE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_HXMU900, msx_cart_msx_audio_hxmu900_device)
DECLARE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_NMS1205, msx_cart_msx_audio_nms1205_device)
DECLARE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_FSCA1, msx_cart_msx_audio_fsca1_device)
class msx_cart_msx_audio_hxmu900_device : public device_t, public msx_cart_interface
{
public:
msx_cart_msx_audio_hxmu900_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
virtual void device_start() override;
// device-level overrides
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
required_device<y8950_device> m_y8950;
};
class msx_cart_msx_audio_nms1205_device : public device_t, public msx_cart_interface
{
public:
msx_cart_msx_audio_nms1205_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
virtual void device_start() override;
// device-level overrides
virtual void device_add_mconfig(machine_config &config) override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void midi_in(int state);
void irq_write(int state);
required_device<y8950_device> m_y8950;
required_device<acia6850_device> m_acia6850;
required_device<midi_port_device> m_mdout;
required_device<midi_port_device> m_mdthru;
};
class msx_cart_msx_audio_fsca1_device : public device_t, public msx_cart_interface
{
public:
msx_cart_msx_audio_fsca1_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
virtual void device_start() override;
virtual void device_reset() override;
// device-level overrides
virtual void device_add_mconfig(machine_config &config) override;
virtual ioport_constructor device_input_ports() const override;
virtual const tiny_rom_entry *device_rom_region() const override;
private:
void write_y8950(offs_t offset, u8 data);
u8 read_y8950(offs_t offset);
void y8950_io_w(u8 data);
u8 y8950_io_r();
void bank_w(u8 data);
void write_7fff(u8 data);
required_device<y8950_device> m_y8950;
required_ioport m_io_config;
required_memory_region m_region_y8950;
memory_bank_array_creator<2> m_rombank;
memory_view m_view0;
memory_view m_view1;
u8 m_7fff;
};
DECLARE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_HXMU900, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_NMS1205, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_MSX_AUDIO_FSCA1, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_MSX_AUDIO_H

2
src/devices/bus/msx/cart/msx_audio_kb.h
View File

@ -39,7 +39,7 @@ public:
u8 read();
protected:
// device-level overrides
// device_t implementation
virtual void device_start() override;
msx_audio_kb_port_interface *m_keyboard;

1
src/devices/bus/msx/cart/msxdos2.h
View File

@ -7,6 +7,7 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_MSXDOS2J, msx_cart_interface)
DECLARE_DEVICE_TYPE(MSX_CART_MSXDOS2E, msx_cart_interface)

33
src/devices/bus/msx/cart/nomapper.cpp
View File

@ -4,16 +4,29 @@
#include "emu.h"
#include "nomapper.h"
DEFINE_DEVICE_TYPE(MSX_CART_NOMAPPER, msx_cart_nomapper_device, "msx_cart_nomapper", "MSX Cartridge - ROM")
namespace {
msx_cart_nomapper_device::msx_cart_nomapper_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_NOMAPPER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_start_address(0)
, m_end_address(0)
class msx_cart_nomapper_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_nomapper_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_NOMAPPER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_start_address(0)
, m_end_address(0)
{ }
// device_t implementation
virtual void device_start() override { }
virtual std::error_condition initialize_cartridge(std::string &message) override;
private:
uint32_t m_start_address;
uint32_t m_end_address;
void install_memory();
};
void msx_cart_nomapper_device::install_memory()
{
@ -133,3 +146,7 @@ std::error_condition msx_cart_nomapper_device::initialize_cartridge(std::string
return std::error_condition();
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_NOMAPPER, msx_cart_interface, msx_cart_nomapper_device, "msx_cart_nomapper", "MSX Cartridge - ROM")

20
src/devices/bus/msx/cart/nomapper.h
View File

@ -8,24 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_NOMAPPER, msx_cart_nomapper_device)
class msx_cart_nomapper_device : public device_t, public msx_cart_interface
{
public:
msx_cart_nomapper_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// device-level overrides
virtual void device_start() override { }
virtual std::error_condition initialize_cartridge(std::string &message) override;
private:
uint32_t m_start_address;
uint32_t m_end_address;
void install_memory();
};
DECLARE_DEVICE_TYPE(MSX_CART_NOMAPPER, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_NOMAPPER_H

1
src/devices/bus/msx/cart/quickdisk.h
View File

@ -7,6 +7,7 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_QUICKDISK, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_QUICKDISK_H

1
src/devices/bus/msx/cart/ram.h
View File

@ -5,6 +5,7 @@
#pragma once
void msx_cart_ram_register_options(device_slot_interface &device);
#endif // MAME_BUS_MSX_CART_RAM_H

31
src/devices/bus/msx/cart/rtype.cpp
View File

@ -3,15 +3,28 @@
#include "emu.h"
#include "rtype.h"
DEFINE_DEVICE_TYPE(MSX_CART_RTYPE, msx_cart_rtype_device, "msx_cart_rtype", "MSX Cartridge - R-Type")
namespace {
msx_cart_rtype_device::msx_cart_rtype_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_RTYPE, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
class msx_cart_rtype_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_rtype_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_RTYPE, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
};
std::error_condition msx_cart_rtype_device::initialize_cartridge(std::string &message)
{
@ -43,3 +56,7 @@ void msx_cart_rtype_device::bank_w(u8 data)
data &= 0x17;
m_rombank->set_entry(data);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_RTYPE, msx_cart_interface, msx_cart_rtype_device, "msx_cart_rtype", "MSX Cartridge - R-Type")

21
src/devices/bus/msx/cart/rtype.h
View File

@ -8,25 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_RTYPE, msx_cart_rtype_device)
class msx_cart_rtype_device : public device_t, public msx_cart_interface
{
public:
msx_cart_rtype_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
};
DECLARE_DEVICE_TYPE(MSX_CART_RTYPE, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_RTYPE_H

1
src/devices/bus/msx/cart/slotexpander.h
View File

@ -7,6 +7,7 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_SLOTEXPANDER, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_SLOTEXPANDER_H

2
src/devices/bus/msx/cart/slotoptions.h
View File

@ -6,6 +6,7 @@
#pragma once
namespace bus::msx::cart::slotoptions {
extern char const *const ARC;
extern char const *const ASCII8;
extern char const *const ASCII8_SRAM;
@ -83,6 +84,7 @@ extern char const *const SUPER_SWANGI;
extern char const *const SUPERLODERUNNER;
extern char const *const SYNTHESIZER;
extern char const *const UCN01;
} // namespace bus::msx::cart::slotoptions
#endif // MAME_BUS_MSX_CART_SLOTOPTIONS_H

32
src/devices/bus/msx/cart/super_swangi.cpp
View File

@ -3,16 +3,28 @@
#include "emu.h"
#include "super_swangi.h"
namespace {
DEFINE_DEVICE_TYPE(MSX_CART_SUPER_SWANGI, msx_cart_super_swangi_device, "msx_cart_super_swangi", "MSX Cartridge - Super Swangi")
msx_cart_super_swangi_device::msx_cart_super_swangi_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, MSX_CART_SUPER_SWANGI, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
class msx_cart_super_swangi_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_super_swangi_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_SUPER_SWANGI, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override { }
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
};
std::error_condition msx_cart_super_swangi_device::initialize_cartridge(std::string &message)
{
@ -41,3 +53,7 @@ void msx_cart_super_swangi_device::bank_w(u8 data)
{
m_rombank->set_entry((data >> 1) & 0x03);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_SUPER_SWANGI, msx_cart_interface, msx_cart_super_swangi_device, "msx_cart_super_swangi", "MSX Cartridge - Super Swangi")

21
src/devices/bus/msx/cart/super_swangi.h
View File

@ -8,25 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_SUPER_SWANGI, msx_cart_super_swangi_device)
class msx_cart_super_swangi_device : public device_t, public msx_cart_interface
{
public:
msx_cart_super_swangi_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override { }
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
};
DECLARE_DEVICE_TYPE(MSX_CART_SUPER_SWANGI, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_SUPER_SWANGI_H

31
src/devices/bus/msx/cart/superloderunner.cpp
View File

@ -3,15 +3,28 @@
#include "emu.h"
#include "superloderunner.h"
DEFINE_DEVICE_TYPE(MSX_CART_SUPERLODERUNNER, msx_cart_superloderunner_device, "msx_cart_superloderunner", "MSX Cartridge - Super Lode Runner")
namespace {
msx_cart_superloderunner_device::msx_cart_superloderunner_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_SUPERLODERUNNER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
class msx_cart_superloderunner_device : public device_t, public msx_cart_interface
{
}
public:
msx_cart_superloderunner_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, MSX_CART_SUPERLODERUNNER, tag, owner, clock)
, msx_cart_interface(mconfig, *this)
, m_rombank(*this, "rombank")
{ }
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device_t implementation
virtual void device_start() override;
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
};
void msx_cart_superloderunner_device::device_start()
{
@ -44,3 +57,7 @@ void msx_cart_superloderunner_device::bank_w(u8 data)
{
m_rombank->set_entry(data & 0x07);
}
} // anonymous namespace
DEFINE_DEVICE_TYPE_PRIVATE(MSX_CART_SUPERLODERUNNER, msx_cart_interface, msx_cart_superloderunner_device, "msx_cart_superloderunner", "MSX Cartridge - Super Lode Runner")

21
src/devices/bus/msx/cart/superloderunner.h
View File

@ -8,25 +8,6 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_SUPERLODERUNNER, msx_cart_superloderunner_device)
class msx_cart_superloderunner_device : public device_t, public msx_cart_interface
{
public:
msx_cart_superloderunner_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
virtual std::error_condition initialize_cartridge(std::string &message) override;
protected:
// device-level overrides
virtual void device_start() override;
private:
void bank_w(u8 data);
memory_bank_creator m_rombank;
};
DECLARE_DEVICE_TYPE(MSX_CART_SUPERLODERUNNER, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_SUPERLODERUNNER_H

1
src/devices/bus/msx/cart/yamaha_ucn01.h
View File

@ -7,6 +7,7 @@
#include "bus/msx/slot/cartridge.h"
DECLARE_DEVICE_TYPE(MSX_CART_UCN01, msx_cart_interface)
#endif // MAME_BUS_MSX_CART_YAMAHA_UCN01_H