From 02192d18e1a47b44549bfc008a1c2bce3f39f8b1 Mon Sep 17 00:00:00 2001 From: AJR Date: Mon, 19 Jun 2023 09:32:26 -0400 Subject: New machines marked as NOT_WORKING ---------------------------------- Orla HK1000 Orla XM200 Orchestra Module --- scripts/src/cpu.lua | 9 +- src/devices/cpu/st9/st905x.cpp | 238 +++++++++++++++++++++++++++++++++++++++++ src/devices/cpu/st9/st905x.h | 95 ++++++++++++++++ src/mame/orla/hk1000.cpp | 144 +++++++++++++++++++++++++ src/mame/orla/xm200.cpp | 64 +++++++++++ 5 files changed, 549 insertions(+), 1 deletion(-) create mode 100644 src/devices/cpu/st9/st905x.cpp create mode 100644 src/devices/cpu/st9/st905x.h create mode 100644 src/mame/orla/hk1000.cpp create mode 100644 src/mame/orla/xm200.cpp diff --git a/scripts/src/cpu.lua b/scripts/src/cpu.lua index a7b9bc3745c..4b52c2415e9 100644 --- a/scripts/src/cpu.lua +++ b/scripts/src/cpu.lua @@ -3835,10 +3835,17 @@ if opt_tool(CPUS, "INTERDATA16") then end -------------------------------------------------- --- SGS-Thomson ST9, disassembler only +-- SGS-Thomson ST9 --@src/devices/cpu/st9/st9.h,CPUS["ST9"] = true -------------------------------------------------- +if CPUS["ST9"] then + files { + MAME_DIR .. "src/devices/cpu/st9/st905x.cpp", + MAME_DIR .. "src/devices/cpu/st9/st905x.h", + } +end + if opt_tool(CPUS, "ST9") then table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/st9/st9dasm.cpp") table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/st9/st9dasm.h") diff --git a/src/devices/cpu/st9/st905x.cpp b/src/devices/cpu/st9/st905x.cpp new file mode 100644 index 00000000000..590c4d142d9 --- /dev/null +++ b/src/devices/cpu/st9/st905x.cpp @@ -0,0 +1,238 @@ +// license:BSD-3-Clause +// copyright-holders:AJR +/*************************************************************************** + + SGS-Thomson ST905x series + + Currently this device is just a stub with no actual execution core. + +***************************************************************************/ + +#include "emu.h" +#include "st905x.h" +#include "st9dasm.h" + +// device type definitions +DEFINE_DEVICE_TYPE(ST90R50, st90r50_device, "st90r50", "SGS-Thomson ST90R50") + +st9_device::st9_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor regmap) + : cpu_device(mconfig, type, tag, owner, clock) + , m_program_config("program", ENDIANNESS_BIG, 8, 16, 0) + , m_data_config("data", ENDIANNESS_BIG, 8, 16, 0) + , m_register_config("register", ENDIANNESS_BIG, 8, 8, 0, regmap) + , m_pc(0) + , m_sspr(0) + , m_uspr(0) + , m_cicr(0) + , m_flagr(0) + , m_rpr{0, 0} + , m_ppr(0) + , m_moder(0) + , m_icount(0) +{ +} + +st90r50_device::st90r50_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : st9_device(mconfig, ST90R50, tag, owner, clock, address_map_constructor(FUNC(st90r50_device::register_map), this)) +{ +} + +void st90r50_device::register_map(address_map &map) +{ + map(0x00, 0xdf).ram(); + map(0xe6, 0xe6).rw(FUNC(st90r50_device::cicr_r), FUNC(st90r50_device::cicr_w)); + map(0xe7, 0xe7).rw(FUNC(st90r50_device::flagr_r), FUNC(st90r50_device::flagr_w)); + map(0xe8, 0xe9).rw(FUNC(st90r50_device::rpr_r), FUNC(st90r50_device::rpr_w)); + map(0xea, 0xea).rw(FUNC(st90r50_device::ppr_r), FUNC(st90r50_device::ppr_w)); + map(0xeb, 0xeb).rw(FUNC(st90r50_device::moder_r), FUNC(st90r50_device::moder_w)); + map(0xec, 0xef).rw(FUNC(st90r50_device::spr_r), FUNC(st90r50_device::spr_w)); +} + +std::unique_ptr st9_device::create_disassembler() +{ + return std::make_unique(); +} + +device_memory_interface::space_config_vector st9_device::memory_space_config() const +{ + if (has_configured_map(AS_DATA)) + { + return space_config_vector { + std::make_pair(AS_PROGRAM, &m_program_config), + std::make_pair(AS_DATA, &m_data_config), + std::make_pair(AS_IO, &m_register_config) + }; + } + else + { + return space_config_vector { + std::make_pair(AS_PROGRAM, &m_program_config), + std::make_pair(AS_IO, &m_register_config) + }; + } +} + +u8 st9_device::cicr_r() +{ + return m_cicr; +} + +void st9_device::cicr_w(u8 data) +{ + m_cicr = data; +} + +u8 st9_device::flagr_r() +{ + return m_flagr; +} + +void st9_device::flagr_w(u8 data) +{ + m_flagr = data; +} + +u8 st9_device::rpr_r(offs_t offset) +{ + return m_rpr[offset]; +} + +void st9_device::rpr_w(offs_t offset, u8 data) +{ + m_rpr[offset] = data & 0xfc; + if (BIT(data, 2)) + m_rpr[offset ^ 1] |= 0x04; + else + m_rpr[offset ^ 1] &= 0xf8; +} + +u8 st9_device::ppr_r() +{ + return m_ppr; +} + +void st9_device::ppr_w(u8 data) +{ + m_ppr = data & 0xfc; +} + +u8 st9_device::moder_r() +{ + return m_moder; +} + +void st9_device::moder_w(u8 data) +{ + m_moder = data; +} + +u8 st9_device::spr_r(offs_t offset) +{ + return BIT(BIT(offset, 1) ? m_sspr : m_uspr, BIT(offset, 0) ? 0 : 8, 8); +} + +void st9_device::spr_w(offs_t offset, u8 data) +{ + u16 &spr = BIT(offset, 1) ? m_sspr : m_uspr; + if (BIT(offset, 0)) + spr = (spr & 0xff00) | data; + else + spr = u16(data) << 8 | (spr & 0x00ff); +} + +u8 st9_device::debug_register_r(int r) +{ + auto dis = machine().disable_side_effects(); + return m_register.read_byte(BIT(m_rpr[0], 2) ? (m_rpr[BIT(r, 3)] & 0xf8) | (r & 7) : (m_rpr[0] & 0xf0) | r); +} + +void st9_device::debug_register_w(int r, u8 data) +{ + auto dis = machine().disable_side_effects(); + m_register.write_byte(BIT(m_rpr[0], 2) ? (m_rpr[BIT(r, 3)] & 0xf8) | (r & 7) : (m_rpr[0] & 0xf0) | r, data); +} + +u16 st9_device::debug_rpair_r(int rr) +{ + auto dis = machine().disable_side_effects(); + return m_register.read_word(BIT(m_rpr[0], 2) ? (m_rpr[BIT(rr, 3)] & 0xf8) | (rr & 6) : (m_rpr[0] & 0xf0) | rr); +} + +void st9_device::debug_rpair_w(int rr, u16 data) +{ + auto dis = machine().disable_side_effects(); + m_register.write_word(BIT(m_rpr[0], 2) ? (m_rpr[BIT(rr, 3)] & 0xf8) | (rr & 6) : (m_rpr[0] & 0xf0) | rr, data); +} + +void st9_device::device_start() +{ + space(AS_PROGRAM).cache(m_cache); + space(AS_PROGRAM).specific(m_program); + space(has_space(AS_DATA) ? AS_DATA : AS_PROGRAM).specific(m_data); + space(AS_IO).specific(m_register); + + set_icountptr(m_icount); + + using namespace std::placeholders; + state_add(STATE_GENPC, "GENPC", m_pc).noshow(); + state_add(STATE_GENPCBASE, "CURPC", m_pc).noshow(); + state_add(STATE_GENFLAGS, "CURFLAGS", m_flagr).noshow().formatstr("%10s"); + state_add(ST9_PC, "PC", m_pc); + state_add(ST9_SSPR, "SSPR", m_sspr); + state_add(ST9_USPR, "USPR", m_uspr); + state_add(ST9_CICR, "CICR", m_cicr); + state_add(ST9_FLAGR, "FLAGR", m_flagr); + state_add(ST9_RP0R, "RP0R", m_rpr[0], std::bind(&st9_device::rpr_w, this, 0, _1)).mask(0xfc); + state_add(ST9_RP1R, "RP1R", m_rpr[1], std::bind(&st9_device::rpr_w, this, 1, _1)).mask(0xfc); + state_add(ST9_PPR, "PPR", m_ppr).mask(0xfc); + state_add(ST9_MODER, "MODER", m_moder); + for (int i = 0; i < 16; i++) + state_add(ST9_R0 + i, util::string_format("r%d", i).c_str(), + std::bind(&st9_device::debug_register_r, this, i), + std::bind(&st9_device::debug_register_w, this, i, _1)); + for (int i = 0; i < 16; i += 2) + state_add(ST9_RR0 + i / 2, util::string_format("rr%d", i).c_str(), + std::bind(&st9_device::debug_rpair_r, this, i), + std::bind(&st9_device::debug_rpair_w, this, i, _1)).noshow(); + + save_item(NAME(m_pc)); + save_item(NAME(m_sspr)); + save_item(NAME(m_uspr)); + save_item(NAME(m_cicr)); + save_item(NAME(m_flagr)); + save_item(NAME(m_rpr)); + save_item(NAME(m_ppr)); + save_item(NAME(m_moder)); +} + +void st9_device::device_reset() +{ + m_cicr = 0x87; + m_moder = 0xe0; +} + +void st9_device::execute_run() +{ + m_pc = m_cache.read_word(0x0000); + debugger_instruction_hook(m_pc); + + m_icount = 0; +} + +void st9_device::state_string_export(const device_state_entry &entry, std::string &str) const +{ + switch (entry.index()) + { + case STATE_GENFLAGS: + str = util::string_format("%c%c%c%c%c%c%c %cM", + BIT(m_flagr, 7) ? 'C' : '.', + BIT(m_flagr, 6) ? 'Z' : '.', + BIT(m_flagr, 5) ? 'S' : '.', + BIT(m_flagr, 4) ? 'V' : '.', + BIT(m_flagr, 3) ? 'D' : '.', + BIT(m_flagr, 2) ? 'H' : '.', + BIT(m_flagr, 1) ? 'U' : '.', + BIT(m_flagr, 0) ? 'D' : 'P'); + break; + } +} diff --git a/src/devices/cpu/st9/st905x.h b/src/devices/cpu/st9/st905x.h new file mode 100644 index 00000000000..17605756f1b --- /dev/null +++ b/src/devices/cpu/st9/st905x.h @@ -0,0 +1,95 @@ +// license:BSD-3-Clause +// copyright-holders:AJR + +#ifndef MAME_CPU_ST9_ST905X_H +#define MAME_CPU_ST9_ST905X_H + +#pragma once + +class st9_device : public cpu_device +{ +public: + enum { + ST9_PC, ST9_SSPR, ST9_USPR, + ST9_CICR, ST9_FLAGR, ST9_RP0R, ST9_RP1R, ST9_PPR, ST9_MODER, + ST9_R0, ST9_R1, ST9_R2, ST9_R3, ST9_R4, ST9_R5, ST9_R6, ST9_R7, + ST9_R8, ST9_R9, ST9_R10, ST9_R11, ST9_R12, ST9_R13, ST9_R14, ST9_R15, + ST9_RR0, ST9_RR2, ST9_RR4, ST9_RR6, ST9_RR8, ST9_RR10, ST9_RR12, ST9_RR14 + }; + +protected: + // construction/destruction + st9_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor regmap); + + // device-level overrides + virtual void device_start() override; + virtual void device_reset() override; + + // device_execute_interface overrides + virtual void execute_run() override; + + // device_disasm_interface overrides + virtual std::unique_ptr create_disassembler() override; + + // device_memory_interface overrides + virtual space_config_vector memory_space_config() const override; + + // device_state_interface overrides + void state_string_export(const device_state_entry &entry, std::string &str) const override; + + // internal register handlers + u8 cicr_r(); + void cicr_w(u8 data); + u8 flagr_r(); + void flagr_w(u8 data); + u8 rpr_r(offs_t offset); + void rpr_w(offs_t offset, u8 data); + u8 ppr_r(); + void ppr_w(u8 data); + u8 moder_r(); + void moder_w(u8 data); + u8 spr_r(offs_t offset); + void spr_w(offs_t offset, u8 data); + +private: + // debugging helpers + u8 debug_register_r(int r); + void debug_register_w(int r, u8 data); + u16 debug_rpair_r(int rr); + void debug_rpair_w(int rr, u16 data); + + // address spaces + address_space_config m_program_config; + address_space_config m_data_config; + address_space_config m_register_config; + memory_access<16, 0, 0, ENDIANNESS_BIG>::cache m_cache; + memory_access<16, 0, 0, ENDIANNESS_BIG>::specific m_program; + memory_access<16, 0, 0, ENDIANNESS_BIG>::specific m_data; + memory_access<8, 0, 0, ENDIANNESS_BIG>::specific m_register; + + // internal state + u16 m_pc; + u16 m_sspr; + u16 m_uspr; + u8 m_cicr; + u8 m_flagr; + u8 m_rpr[2]; + u8 m_ppr; + u8 m_moder; + s32 m_icount; +}; + +class st90r50_device : public st9_device +{ +public: + // device type constructor + st90r50_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); + +private: + void register_map(address_map &map); +}; + +// device type declaration +DECLARE_DEVICE_TYPE(ST90R50, st90r50_device) + +#endif // MAME_CPU_ST9_ST905X_H diff --git a/src/mame/orla/hk1000.cpp b/src/mame/orla/hk1000.cpp new file mode 100644 index 00000000000..94b9ff8a5f8 --- /dev/null +++ b/src/mame/orla/hk1000.cpp @@ -0,0 +1,144 @@ +// license:BSD-3-Clause +// copyright-holders:AJR +/*************************************************************************** + + Skeleton driver for Orla HK1000 music keyboard. + +***************************************************************************/ + +#include "emu.h" +#include "cpu/m6502/m6502.h" +#include "cpu/tms7000/tms7000.h" +#include "cpu/upd7810/upd7810.h" +#include "machine/i8255.h" +#include "sound/ymopl.h" + + +namespace { + +class hk1000_state : public driver_device +{ +public: + hk1000_state(const machine_config &mconfig, device_type type, const char *tag) + : driver_device(mconfig, type, tag) + , m_maincpu(*this, "maincpu") + , m_soundcpu(*this, "soundcpu") + , m_slotcpu(*this, "slotcpu") + { + } + + void hk1000(machine_config &config); + +private: + void main_map(address_map &map); + void sound_map(address_map &map); + void slot_map(address_map &map); + + required_device m_maincpu; + required_device m_soundcpu; + required_device m_slotcpu; +}; + + +void hk1000_state::main_map(address_map &map) +{ + map(0x0000, 0x7fff).rom().region("mainpcb", 0); + map(0x2000, 0x2000).nopw(); // ? + map(0x8000, 0x9fff).ram(); + map(0xa000, 0xa003).rw("ppi", FUNC(i8255_device::read), FUNC(i8255_device::write)); + map(0xa300, 0xa300).nopr(); // ? + map(0xc000, 0xc000).nopr(); // ? +} + +void hk1000_state::sound_map(address_map &map) +{ + map(0xc000, 0xffff).rom().region("soundpcb", 0); +} + +void hk1000_state::slot_map(address_map &map) +{ + map(0x0000, 0x0fff).ram(); + map(0x2000, 0x2001).rw("ymsnd", FUNC(ym3812_device::read), FUNC(ym3812_device::write)); + map(0x8000, 0xffff).rom().region("slotpcb", 0); +} + + +static INPUT_PORTS_START(hk1000) +INPUT_PORTS_END + +void hk1000_state::hk1000(machine_config &config) +{ + UPD7810(config, m_maincpu, 12'000'000); + m_maincpu->set_addrmap(AS_PROGRAM, &hk1000_state::main_map); + + I8255(config, "ppi"); + + TMS7002(config, m_soundcpu, 4'000'000); + m_soundcpu->set_addrmap(AS_PROGRAM, &hk1000_state::sound_map); + + M6502(config, m_slotcpu, 2'000'000); + m_slotcpu->set_addrmap(AS_PROGRAM, &hk1000_state::slot_map); + + YM3812(config, "ymsnd", 4'000'000); +} + + +/* +Dumper's notes: + +This EPROM set stems from a working specimen of the Orla HK1000 music keyboard. + +layout +------ +The Orla HK1000 contains many small PCBs. Except PCB3 (analog) they all contain each one eprom. From left to right I number these PCB1 to PCB5. The slot PCB is in the case top to the right. + + +PCB1 (FM main voice) +-------------------- +Suono +HK + +PCB2 (main CPU) +--------------- +HK 1000 +V2 + +PCB4 (reverb) +------------- +STD.OEM 4/2/87 +ALESIS 4D49 A + +PCB5 (pcm percussion) +--------------------- +TIMBRI +PCM + +slot PCB (accompaniment) +------------------------ +AKK +HK +V2 +*/ + +ROM_START(hk1000) + ROM_REGION(0x8000, "mainpcb", 0) + ROM_LOAD("hk1000 v2_s 27c256-20.bin", 0x0000, 0x8000, CRC(b5d005e9) SHA1(5b1b6e45e84494254c5937ba726ea0f15162bdc9)) + + ROM_REGION(0x4000, "soundpcb", 0) + ROM_LOAD("suono hk_ti tms 27c128-2jl.bin", 0x0000, 0x4000, CRC(02f99a30) SHA1(fec3884150a68b6d3ed29cbcb1ce84ebf2c90dd9)) + + ROM_REGION(0x2000, "reverb", 0) + ROM_LOAD("std.oem 4-2-87 alesis 4d49 a_nmc27c64q 200.bin", 0x0000, 0x2000, CRC(44319276) SHA1(b916d8e88ec28f6b49eb814c5328a35dc8ed857f)) + + ROM_REGION(0x10000, "pcm", 0) + ROM_LOAD("timbri pcm_ti tms 27c512-20jl.bin", 0x00000, 0x10000, CRC(dd573584) SHA1(1d554e11dbcbab390d3fc995976daf122908bad0)) + + ROM_REGION(0x8000, "slotpcb", 0) + ROM_LOAD("akk hk v2_ti tms 27c512-20jl.bin", 0x0000, 0x8000, CRC(74f6461b) SHA1(b2c1b44842b8825123beaad4c0e6692a57e1a9ed)) + ROM_CONTINUE(0x0000, 0x8000) // 0xxxxxxxxxxxxxxx = 0xFF +ROM_END + +} // anonymous namespace + + +SYST(198?, hk1000, 0, 0, hk1000, hk1000, hk1000_state, empty_init, "Orla", "HK1000", MACHINE_IS_SKELETON) diff --git a/src/mame/orla/xm200.cpp b/src/mame/orla/xm200.cpp new file mode 100644 index 00000000000..b491b9ed991 --- /dev/null +++ b/src/mame/orla/xm200.cpp @@ -0,0 +1,64 @@ +// license:BSD-3-Clause +// copyright-holders:AJR +/*************************************************************************** + + Skeleton driver for Orla XM200 PCM sound module. + +***************************************************************************/ + +#include "emu.h" +#include "cpu/st9/st905x.h" + + +namespace { + +class xm200_state : public driver_device +{ +public: + xm200_state(const machine_config &mconfig, device_type type, const char *tag) + : driver_device(mconfig, type, tag) + , m_maincpu(*this, "maincpu") + { + } + + void xm200(machine_config &config); + +private: + void mem_map(address_map &map); + + required_device m_maincpu; +}; + + +void xm200_state::mem_map(address_map &map) +{ + map(0x0000, 0x7fff).rom().region("program", 0); + map(0xe000, 0xefff).ram(); +} + + +static INPUT_PORTS_START(xm200) +INPUT_PORTS_END + +void xm200_state::xm200(machine_config &config) +{ + ST90R50(config, m_maincpu, 11'000'000); // type and clock guessed + m_maincpu->set_addrmap(AS_PROGRAM, &xm200_state::mem_map); +} + +// The dump claims to be from "Commander" rather than Orla. This might be some sort of regional branding, +// since Orla released other sound modules using that name. +ROM_START(xm200) + ROM_REGION(0x8000, "program", 0) + ROM_LOAD("xm200_st m27c25b-orla ok300_q.bin", 0x0000, 0x8000, CRC(fa5dc621) SHA1(867516171028c278eccdbe65ea750deb07a684ff)) + // 0x0100: "***** Orla OK300 Keyboard ***** (c) Richard Watts Associates July 90, V1.0" + + ROM_REGION(0x20000, "pcm", 0) + ROM_LOAD("s r_s 27c512-20 fa.bin", 0x00000, 0x10000, CRC(dab36166) SHA1(c98096c699fcf23e42571ce58e46bf40f569aa1f)) + ROM_LOAD("acc_st m27c512-15fi.bin", 0x10000, 0x10000, CRC(15a7c54e) SHA1(e5ed7806060b6b74f0e71960af5eb5307d1c88d7)) +ROM_END + +} // anonymous namespace + + +SYST(1990, xm200, 0, 0, xm200, xm200, xm200_state, empty_init, "Orla", "XM200 Orchestra Module", MACHINE_IS_SKELETON) -- cgit v1.2.3