ymmu100: Start adding the MEG [O. Galibert]

scripts/src/cpu.lua

@@ -2818,3 +2818,20 @@ if (CPUS["HPC"]~=null or _OPTIONS["with-tools"]) then
 	table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/hpc/hpcdasm.cpp")
 	table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/hpc/hpcdasm.h")
 end
+
+--------------------------------------------------
+-- Yamaha Multiple Effects Generator
+--@src/devices/sound/meg.h,CPUS["MEG"] = true
+--------------------------------------------------
+
+if (CPUS["MEG"]~=null) then
+	files {
+		MAME_DIR .. "src/devices/sound/meg.cpp",
+		MAME_DIR .. "src/devices/sound/meg.h",
+	}
+end
+
+if (CPUS["MEG"]~=null or _OPTIONS["with-tools"]) then
+	table.insert(disasm_files , MAME_DIR .. "src/devices/sound/megd.cpp")
+	table.insert(disasm_files , MAME_DIR .. "src/devices/sound/megd.h")
+end

scripts/target/mame/mess.lua

@@ -139,6 +139,7 @@ CPUS["CAPRICORN"] = true
 CPUS["ALPHA"] = true
 --CPUS["DSPP"] = true
 CPUS["HPC"] = true
+CPUS["MEG"] = true
 
 --------------------------------------------------
 -- specify available sound cores; some of these are

src/devices/sound/meg.cpp

@@ -0,0 +1,384 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Yamaha MEG - Multiple effects generator
+//
+// Audio dsp dedicated to effects generation
+
+#include "emu.h"
+#include "debugger.h"
+#include "meg.h"
+
+DEFINE_DEVICE_TYPE(MEG, meg_device, "meg", "Multiple Effects Generator (HD62098 / XM309A00)")
+DEFINE_DEVICE_TYPE(MEGEMB, meg_embedded_device, "megemb", "Multiple Effects Generator (embedded)")
+
+void meg_base_device::prg_map(address_map &map)
+{
+	map(0, m_prg_size - 1).ram();
+}
+
+void meg_base_device::fp_map(address_map &map)
+{
+	map(0, m_prg_size - 1).ram();
+}
+
+void meg_base_device::offsets_map(address_map &map)
+{
+	map(0, 0x7f).ram();
+}
+
+meg_base_device::meg_base_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, u32 prg_size) :
+	cpu_device(mconfig, type, tag, owner, clock),
+	m_program_config("program", ENDIANNESS_BIG, 64, prg_size > 256 ? 9 : 8, -3, address_map_constructor(FUNC(meg_base_device::prg_map), this)),
+	m_fp_config("fp", ENDIANNESS_BIG, 16, prg_size > 256 ? 9 : 8, -1, address_map_constructor(FUNC(meg_base_device::fp_map), this)),
+	m_offsets_config("offsets", ENDIANNESS_BIG, 16, prg_size > 256 ? 7 : 7, -1, address_map_constructor(FUNC(meg_base_device::offsets_map), this)),
+	m_prg_size(prg_size)
+{
+}
+
+
+void meg_base_device::prg_w(u16 address, u64 opcode)
+{
+	m_program->write_qword(address, opcode);
+}
+
+void meg_base_device::fp_w(u16 address, u16 value)
+{
+	m_fp->write_word(address, value);
+}
+
+void meg_base_device::offset_w(u16 address, u16 value)
+{
+	m_offsets->write_word(address, value);
+}
+
+void meg_base_device::lfo_w(u8 reg, u16 value)
+{
+	m_lfo[reg] = value;
+
+	static const int dt[8] = { 0, 32, 64, 128, 256, 512,  1024, 2048 };
+	static const int sh[8] = { 0,  0,  1,   2,   3,   4,     5,    6 };
+
+	int scale = (value >> 5) & 7;
+	int step = ((value & 31) << sh[scale]) + dt[scale];
+	logerror("lfo_w %02x freq=%5.2f phase=%6.4f\n", reg, step * 44100.0/4194304, (value >> 8)/256.0);
+}
+
+void meg_base_device::map_w(u8 reg, u16 value)
+{
+	m_map[reg] = value;
+}
+
+u64 meg_base_device::prg_r(u16 address) const
+{
+	return m_program->read_qword(address);
+}
+
+u16 meg_base_device::fp_r(u16 address) const
+{
+	return m_fp->read_word(address);
+}
+
+u16 meg_base_device::offset_r(u16 address) const
+{
+	return m_offsets->read_word(address);
+}
+
+u16 meg_base_device::lfo_r(u8 reg) const
+{
+	return m_lfo[reg];
+}
+
+u16 meg_base_device::map_r(u8 reg) const
+{
+	return m_map[reg];
+}
+
+
+void meg_base_device::device_start()
+{
+	m_program = &space(AS_PROGRAM);
+	m_fp      = &space(AS_FP);
+	m_offsets = &space(AS_OFFSETS);
+
+	state_add(STATE_GENPC,     "GENPC",     m_pc).noshow();
+	state_add(STATE_GENPCBASE, "CURPC",     m_pc).noshow();
+	state_add(0,               "PC",        m_pc);
+
+	set_icountptr(m_icount);
+
+	save_item(NAME(m_lfo));
+	save_item(NAME(m_map));
+	save_item(NAME(m_pc));
+}
+
+void meg_base_device::device_reset()
+{
+	memset(m_lfo, 0, sizeof(m_lfo));
+	memset(m_map, 0, sizeof(m_map));
+	m_pc = 0;
+}
+
+uint32_t meg_base_device::execute_min_cycles() const
+{
+	return 1;
+}
+
+uint32_t meg_base_device::execute_max_cycles() const
+{
+	return 1;
+}
+
+uint32_t meg_base_device::execute_input_lines() const
+{
+	return 0;
+}
+
+void meg_base_device::execute_run()
+{
+	if(machine().debug_flags & DEBUG_FLAG_ENABLED)
+		debugger_instruction_hook(m_pc);
+	m_icount = 0;
+}
+
+device_memory_interface::space_config_vector meg_base_device::memory_space_config() const
+{
+	return space_config_vector {
+		std::make_pair(AS_PROGRAM, &m_program_config),
+		std::make_pair(AS_FP,      &m_fp_config),
+		std::make_pair(AS_OFFSETS, &m_offsets_config)
+	};
+}
+
+void meg_base_device::state_import(const device_state_entry &entry)
+{
+}
+
+void meg_base_device::state_export(const device_state_entry &entry)
+{
+}
+
+void meg_base_device::state_string_export(const device_state_entry &entry, std::string &str) const
+{
+}
+
+std::unique_ptr<util::disasm_interface> meg_base_device::create_disassembler()
+{
+	return std::make_unique<meg_disassembler>(this);
+}
+
+meg_embedded_device::meg_embedded_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) :
+	meg_base_device(mconfig, MEGEMB, tag, owner, clock, 384)
+{
+}
+
+meg_device::meg_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) :
+	meg_base_device(mconfig, MEG, tag, owner, clock, 256)
+{
+}
+
+
+//   vl70:
+// 6d1e: write 1, r0l
+// 6d26: write 2, r0l
+// 6d2e: read 2
+// 6d36: write 3, r0l
+// 6d3e: write reg 4:r0h, r0l
+// 6d52: write reg 5:r0h, r0l-1
+// 6d68: write 7, r0l
+// 6d70: write reg 8:r0h, r0l
+// 6d84: write reg 9:r0h, r0l
+// 6dac: write a, r0l
+// 6db4: write reg cd:r1l, r0
+// 6dd4: write reg e:r0h, r0l
+// 6dee: write reg f:r0h, r0l
+// 6e08: read 10,11
+// 6e1c: write reg 1213:r1l, r0
+// 6e3c: write reg 14:r0h, r0l
+// 6e50: write 15, r0l
+// 6e58: write reg 16:r0h, r0l
+// 6e6c: write reg 17:r0h, r0l
+// 6e80: write reg 18:e0h, e0l
+
+void meg_device::map(address_map &map)
+{
+	map(0x00, 0x00).w(FUNC(meg_device::select_w));
+	map(0x01, 0x01).w(FUNC(meg_device::s1_w));
+	map(0x02, 0x02).rw(FUNC(meg_device::s2_r), FUNC(meg_device::s2_w));
+	map(0x03, 0x03).w(FUNC(meg_device::s3_w));
+	map(0x04, 0x04).w(FUNC(meg_device::s4_w));
+	map(0x05, 0x05).w(FUNC(meg_device::s5_w));
+	map(0x07, 0x07).w(FUNC(meg_device::s7_w));
+	map(0x08, 0x08).w(FUNC(meg_device::s8_w));
+	map(0x09, 0x09).w(FUNC(meg_device::s9_w));
+	map(0x0a, 0x0a).w(FUNC(meg_device::sa_w));
+	map(0x0c, 0x0c).w(FUNC(meg_device::fph_w));
+	map(0x0d, 0x0d).w(FUNC(meg_device::fpl_w));
+	map(0x0e, 0x0e).w(FUNC(meg_device::se_w));
+	map(0x0f, 0x0f).w(FUNC(meg_device::sf_w));
+	map(0x10, 0x10).r(FUNC(meg_device::s10_r));
+	map(0x11, 0x11).r(FUNC(meg_device::s11_r));
+	map(0x12, 0x12).w(FUNC(meg_device::offseth_w));
+	map(0x13, 0x13).w(FUNC(meg_device::offsetl_w));
+	map(0x14, 0x14).w(FUNC(meg_device::s14_w));
+	map(0x15, 0x15).w(FUNC(meg_device::s15_w));
+	map(0x16, 0x16).w(FUNC(meg_device::s16_w));
+	map(0x17, 0x17).w(FUNC(meg_device::s17_w));
+	map(0x18, 0x18).w(FUNC(meg_device::s18_w));
+}
+
+u8 meg_device::s2_r()
+{
+	logerror("read r2 %s\n", machine().describe_context());
+	return 0x00;
+}
+
+void meg_device::select_w(u8 data)
+{
+	m_reg = data;
+}
+
+void meg_device::s1_w(u8 data)
+{
+	logerror("r1 %02x %s\n", data, machine().describe_context());
+}
+
+void meg_device::s2_w(u8 data)
+{
+	logerror("r2 %02x %s\n", data, machine().describe_context());
+}
+
+void meg_device::s3_w(u8 data)
+{
+	logerror("r3 %02x %s\n", data, machine().describe_context());
+}
+
+void meg_device::s4_w(u8 data)
+{
+	if(m_r4[m_reg] != data) {
+		m_r4[m_reg] = data;
+		logerror("r4[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+void meg_device::s5_w(u8 data)
+{
+	if(m_r5[m_reg] != data) {
+		m_r5[m_reg] = data;
+		logerror("r5[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+void meg_device::s7_w(u8 data)
+{
+	logerror("r7 %02x %s\n", data, machine().describe_context());
+}
+
+void meg_device::s8_w(u8 data)
+{
+	if(m_r8[m_reg] != data) {
+		m_r8[m_reg] = data;
+		logerror("r8[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+
+void meg_device::s9_w(u8 data)
+{
+	if(m_r9[m_reg] != data) {
+		m_r9[m_reg] = data;
+		logerror("r9[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+void meg_device::sa_w(u8 data)
+{
+	logerror("ra %02x %s\n", data, machine().describe_context());
+}
+
+void meg_device::fph_w(u8 data)
+{
+	fp_w(m_reg, (fp_r(m_reg) & 0x00ff) | (data << 8));
+}
+
+
+void meg_device::fpl_w(u8 data)
+{
+	fp_w(m_reg, (fp_r(m_reg) & 0xff00) | data);
+}
+
+void meg_device::se_w(u8 data)
+{
+	if(m_re[m_reg] != data) {
+		m_re[m_reg] = data;
+		logerror("re[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+
+void meg_device::sf_w(u8 data)
+{
+	if(m_rf[m_reg] != data) {
+		m_rf[m_reg] = data;
+		logerror("rf[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+u8 meg_device::s10_r()
+{
+	logerror("read r10 %s\n", machine().describe_context());
+	return 0x00;
+}
+
+u8 meg_device::s11_r()
+{
+	logerror("read r11 %s\n", machine().describe_context());
+	return 0x00;
+}
+
+void meg_device::offseth_w(u8 data)
+{
+	offset_w(m_reg, (offset_r(m_reg) & 0x00ff) | (data << 8));
+}
+
+void meg_device::offsetl_w(u8 data)
+{
+	offset_w(m_reg, (offset_r(m_reg) & 0xff00) | data);
+}
+
+void meg_device::s14_w(u8 data)
+{
+	if(m_r14[m_reg] != data) {
+		m_r14[m_reg] = data;
+		logerror("r14[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+void meg_device::s15_w(u8 data)
+{
+	logerror("r15 %02x %s\n", data, machine().describe_context());
+}
+
+void meg_device::s16_w(u8 data)
+{
+	if(m_r16[m_reg] != data) {
+		m_r16[m_reg] = data;
+		logerror("r16[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+void meg_device::s17_w(u8 data)
+{
+	if(m_r17[m_reg] != data) {
+		m_r17[m_reg] = data;
+		logerror("r17[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}
+
+void meg_device::s18_w(u8 data)
+{
+	if(m_r18[m_reg] != data) {
+		m_r18[m_reg] = data;
+		logerror("r18[%02x] = %02x %s\n", m_reg, data, machine().describe_context());
+	}
+}

src/devices/sound/meg.h

@@ -0,0 +1,122 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Yamaha MEG - Multiple effects generator
+//
+// Audio dsp dedicated to effects generation
+
+#ifndef DEVICES_SOUND_MEG_H
+#define DEVICES_SOUND_MEG_H
+
+#pragma once
+
+#include "megd.h"
+
+
+class meg_base_device : public cpu_device, public meg_disassembler::info
+{
+public:
+	enum {
+		AS_FP = 1,
+		AS_OFFSETS = 2
+	};
+
+	meg_base_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, u32 prg_size);
+
+	void prg_w(u16 address, u64 opcode);
+	void fp_w(u16 address, u16 value);
+	void offset_w(u16 address, u16 value);
+	void lfo_w(u8 reg, u16 value);
+	void map_w(u8 reg, u16 value); 
+	u64 prg_r(u16 address) const;
+	virtual u16 fp_r(u16 address) const override;
+	virtual u16 offset_r(u16 address) const override;
+	u16 lfo_r(u8 reg) const;
+	u16 map_r(u8 reg) const;
+
+protected:
+	virtual void device_start() override;
+	virtual void device_reset() override;
+	virtual uint32_t execute_min_cycles() const override;
+	virtual uint32_t execute_max_cycles() const override;
+	virtual uint32_t execute_input_lines() const override;
+	virtual void execute_run() override;
+	virtual space_config_vector memory_space_config() const override;
+	virtual void state_import(const device_state_entry &entry) override;
+	virtual void state_export(const device_state_entry &entry) override;
+	virtual void state_string_export(const device_state_entry &entry, std::string &str) const override;
+	virtual std::unique_ptr<util::disasm_interface> create_disassembler() override;
+
+private:
+	address_space_config m_program_config, m_fp_config, m_offsets_config;
+	address_space *m_program, *m_fp, *m_offsets;
+
+	u32 m_prg_size, m_pc;
+	int m_icount;
+
+	u16 m_lfo[0x18], m_map[8];
+
+	void prg_map(address_map &map);
+	void fp_map(address_map &map);
+	void offsets_map(address_map &map);
+};
+
+class meg_embedded_device : public meg_base_device
+{
+public:
+	meg_embedded_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock = 44100*384);
+};
+
+class meg_device : public meg_base_device
+{
+public:
+	meg_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock = 44100*256);
+	void map(address_map &map);
+
+private:
+	u8 m_r4[256];
+	u8 m_r5[256];
+	u8 m_r8[256];
+	u8 m_r9[256];
+	u8 m_re[256];
+	u8 m_rf[256];
+	u8 m_r12[256];
+	u8 m_r13[256];
+	u8 m_r14[256];
+	u8 m_r16[256];
+	u8 m_r17[256];
+	u8 m_r18[256];
+	u8 m_reg;
+	u8 s2_r();
+	u8 s10_r();
+	u8 s11_r();
+	void select_w(u8 reg);
+	void s1_w(u8 data);
+	void s2_w(u8 data);
+	void s3_w(u8 data);
+	void s4_w(u8 data);
+	void s5_w(u8 data);
+	void s7_w(u8 data);
+	void s8_w(u8 data);
+	void s9_w(u8 data);
+	void sa_w(u8 data);
+	void fph_w(u8 data);
+	void fpl_w(u8 data);
+	void se_w(u8 data);
+	void sf_w(u8 data);
+	void s10_w(u8 data);
+	void s11_w(u8 data);
+	void offseth_w(u8 data);
+	void offsetl_w(u8 data);
+	void s14_w(u8 data);
+	void s15_w(u8 data);
+	void s16_w(u8 data);
+	void s17_w(u8 data);
+	void s18_w(u8 data);
+};
+
+
+DECLARE_DEVICE_TYPE(MEG, meg_device)
+DECLARE_DEVICE_TYPE(MEGEMB, meg_embedded_device)
+
+#endif

src/devices/sound/megd.cpp

@@ -0,0 +1,118 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Yamaha MEG - Multiple effects generator
+//
+// Audio dsp dedicated to effects generation
+//
+// Disassembler
+
+#include "emu.h"
+#include "megd.h"
+
+meg_disassembler::meg_disassembler(info *inf) : m_info(inf)
+{
+}
+
+u32 meg_disassembler::opcode_alignment() const
+{
+	return 1;
+}
+
+std::string meg_disassembler::gfp(offs_t address) const
+{
+	if(!m_info)
+		return util::string_format("fp%03x", address);
+	s16 fp = m_info->fp_r(address);
+	return util::string_format("%g", fp / 16384.0);
+}
+
+std::string meg_disassembler::goffset(offs_t address) const
+{
+	return m_info ? util::string_format("%x", m_info->offset_r(address)) : util::string_format("of%02x", address);
+}
+
+u32 meg_disassembler::b(u64 opc, u32 start, u32 count)
+{
+  return (opc >> start) & ((1 << count) - 1);
+}
+
+void meg_disassembler::append(std::string &r, std::string e)
+{
+	if(r != "")
+		r += " ; ";
+	r += e;
+}
+
+// 33333333 33333333 22222222 22222222 11111111 11111111 00000000 00000000
+// fedcba98 76543210 fedcba98 76543210 fedcba98 76543210 fedcba98 76543210
+
+// 66665555 55555544 44444444 33333333 33222222 22221111 11111100 00000000
+// 32109876 54321098 76543210 98765432 10987654 32109876 54321098 76543210
+// XLB----- -rrrrrrr r--mmmmm m-MM---- -P-----* -----Arr rrrrrrmm mmmm----
+
+// m = low is read port, high is write port, memory register
+// r = low is read port, high is high port, rotating register
+
+// X = used for lo-fi variation only
+// L = lfo read
+// * = compute mul
+// A = mul input = m or r
+// P = P sent for register write
+// B = register write to mbuf
+// M = memory mode, none/read/write/read+1
+
+offs_t meg_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer &params)
+{
+	u64 opc = opcodes.r64(pc);
+
+	std::string r;
+
+	r = util::string_format("[m%02x]", b(opc, 39, 6));
+
+    if(b(opc, 62, 1))
+		append(r, "lfo");
+
+    if(b(opc, 23, 1))
+		switch(b(opc, 24, 2)) {
+		case 0:
+			if(b(opc, 18, 1))
+				append(r, util::string_format("p += %s*m%02x", gfp(pc), b(opc,  4, 6)));
+			else
+				append(r, util::string_format("p += %s*r%02x", gfp(pc), b(opc, 10, 8)));
+			break;
+		case 1:
+			append(r, util::string_format("p = %s*(r%02x+m%02x)", gfp(pc), b(opc, 10, 8), b(opc,  4, 6)));
+			break;
+		case 2:
+			append(r, util::string_format("p ?= %s*(r%02x+m%02x)", gfp(pc), b(opc, 10, 8), b(opc,  4, 6)));
+			break;
+		case 3:
+			if(b(opc, 18, 1))
+				append(r, util::string_format("p = %s*m%02x", gfp(pc), b(opc,  4, 6)));
+			else
+				append(r, util::string_format("p = %s*r%02x", gfp(pc), b(opc, 10, 8)));
+			break;
+		}
+
+    if(b(opc, 30, 1)) {
+		if(b(opc, 61, 1))
+			append(r, "mb = p");
+		else if(b(opc, 46, 1) == 1)
+			append(r, util::string_format("m%02x = p", b(opc, 39, 6)));
+		else
+			append(r, util::string_format("r%02x = p", b(opc, 47, 8)));
+    }
+
+	u32 memmode = b(opc, 36, 2);
+	if(memmode) {
+		static const char *modes[4] = { nullptr, "w", "r", "rw" };
+		
+		append(r, util::string_format("mem_%s %x +%s", modes[memmode], b(opc, 33, 3), goffset(pc/3)));
+			r += util::string_format("-> m%02x", b(opcodes.r64(pc+2), 39, 6));
+    }
+
+	stream << r;
+
+	return 1 | SUPPORTED;
+}

src/devices/sound/megd.h

@@ -0,0 +1,39 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Yamaha MEG - Multiple effects generator
+//
+// Audio dsp dedicated to effects generation
+//
+// Disassembler
+
+#ifndef DEVICES_SOUND_MEGD_H
+#define DEVICES_SOUND_MEGD_H
+
+#pragma once
+
+class meg_disassembler : public util::disasm_interface
+{
+public:
+	class info {
+	public:
+		virtual u16 fp_r(u16 address) const = 0;
+		virtual u16 offset_r(u16 address) const = 0;
+	};
+
+	meg_disassembler(info *inf = nullptr);
+
+	virtual u32 opcode_alignment() const override;
+	virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer &params) override;
+
+private:
+	info *m_info;
+
+	std::string gfp(offs_t address) const;
+	std::string goffset(offs_t address) const;
+
+	static inline u32 b(u64 opc, u32 start, u32 count);
+	static inline void append(std::string &r, std::string e);
+};
+
+#endif

src/devices/sound/swp30.cpp

@@ -150,17 +150,23 @@ DEFINE_DEVICE_TYPE(SWP30, swp30_device, "swp30", "Yamaha SWP30 sound chip")
 swp30_device::swp30_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
 	: device_t(mconfig, SWP30, tag, owner, clock),
 	  device_sound_interface(mconfig, *this),
-	  device_rom_interface(mconfig, *this, 25+2, ENDIANNESS_LITTLE, 32)
+	  device_rom_interface(mconfig, *this, 25+2, ENDIANNESS_LITTLE, 32),
+	  m_meg(*this, "meg")
 {
 }
 
+void swp30_device::device_add_mconfig(machine_config &config)
+{
+	MEGEMB(config, m_meg);
+}
+
 void swp30_device::device_start()
 {
 	m_stream = stream_alloc(0, 2, 44100);
 
 	// Attenuantion for panning is 4.4 floating point.  That means 0
 	// to -96.3dB.  Since it's a nice range, we assume it's the same
-	// for other attenuation values.  Computed value is is 1.16
+	// for other attenuation values.  Computed value is 1.16
 	// format, to avoid overflow
 
 	for(int i=0; i<256; i++)
@@ -328,8 +334,8 @@ void swp30_device::map(address_map &map)
 	rchan(map, 0x27).rw(FUNC(swp30_device::prg_fp_r<3>), FUNC(swp30_device::prg_fp_w<3>));
 	rchan(map, 0x29).rw(FUNC(swp30_device::prg_fp_r<4>), FUNC(swp30_device::prg_fp_w<4>));
 	rchan(map, 0x2b).rw(FUNC(swp30_device::prg_fp_r<5>), FUNC(swp30_device::prg_fp_w<5>));
-	rchan(map, 0x30).rw(FUNC(swp30_device::prg_int_r<0>), FUNC(swp30_device::prg_int_w<0>));
+	rchan(map, 0x30).rw(FUNC(swp30_device::prg_off_r<0>), FUNC(swp30_device::prg_off_w<0>));
-	rchan(map, 0x31).rw(FUNC(swp30_device::prg_int_r<1>), FUNC(swp30_device::prg_int_w<1>));
+	rchan(map, 0x31).rw(FUNC(swp30_device::prg_off_r<1>), FUNC(swp30_device::prg_off_w<1>));
 	rchan(map, 0x3e).rw(FUNC(swp30_device::prg_lfo_r<0>), FUNC(swp30_device::prg_lfo_w<0>));
 	rchan(map, 0x3f).rw(FUNC(swp30_device::prg_lfo_r<1>), FUNC(swp30_device::prg_lfo_w<1>));
 }
@@ -381,14 +387,14 @@ void swp30_device::prg_address_w(u16 data)
 template<int sel> u16 swp30_device::prg_r()
 {
 	constexpr offs_t shift = 48-16*sel;
-	return m_program[m_program_address] >> shift;
+	return m_meg->prg_r(m_program_address) >> shift;
 }
 
 template<int sel> void swp30_device::prg_w(u16 data)
 {
 	constexpr offs_t shift = 48-16*sel;
 	constexpr u64 mask = ~(u64(0xffff) << shift);
-	m_program[m_program_address] = (m_program[m_program_address] & mask) | (u64(data) << shift);
+	m_meg->prg_w(m_program_address, (m_meg->prg_r(m_program_address) & mask) | (u64(data) << shift));
 
 	if(sel == 3) {
 		if(0)
@@ -402,14 +408,12 @@ template<int sel> void swp30_device::prg_w(u16 data)
 
 template<int sel> u16 swp30_device::map_r()
 {
-	return m_map[sel];
+	return m_meg->map_r(sel);
 }
 
 template<int sel> void swp30_device::map_w(u16 data)
 {
-	m_map[sel] = data;
+	m_meg->map_w(sel, data);
-	if(0)
-		logerror("map %d: type=%02x offset=%05x size=%05x\n", sel, data >> 11, (data & 0xff) << 10, 0x400 << ((data >> 8) & 7));
 }
 
 
@@ -656,54 +660,36 @@ void swp30_device::address_l_w(offs_t offset, u16 data)
 }
 
 
-// MEG registers (Multiple Effects Generator)
+// MEG registers forwarding
 
 template<int sel> u16 swp30_device::prg_fp_r(offs_t offset)
 {
-	offs_t adr = (offset >> 6)*6 + sel;
+	return m_meg->fp_r((offset >> 6)*6 + sel);
-	return m_program_pfp[adr];
 }
 
 template<int sel> void swp30_device::prg_fp_w(offs_t offset, u16 data)
 {
-	offs_t adr = (offset >> 6)*6 + sel;
+	m_meg->fp_w((offset >> 6)*6 + sel, data);
-	m_program_pfp[adr] = data;
-	if(0)
-		logerror("prg_fp_w %03x, %04x\n", adr, data);
 }
 
-template<int sel> u16 swp30_device::prg_int_r(offs_t offset)
+template<int sel> u16 swp30_device::prg_off_r(offs_t offset)
 {
-	offs_t adr = (offset >> 6)*2 + sel;
+	return m_meg->offset_r((offset >> 6)*2 + sel);
-	return m_program_pint[adr];
 }
 
-template<int sel> void swp30_device::prg_int_w(offs_t offset, u16 data)
+template<int sel> void swp30_device::prg_off_w(offs_t offset, u16 data)
 {
-	offs_t adr = (offset >> 6)*2 + sel;
+	m_meg->offset_w((offset >> 6)*2 + sel, data);
-	m_program_pint[adr] = data;
-	if(0)
-		logerror("prg_int_w %02x, %04x\n", adr, data);
 }
 
 template<int sel> u16 swp30_device::prg_lfo_r(offs_t offset)
 {
-	offs_t adr = (offset >> 6)*2 + sel;
+	return m_meg->lfo_r((offset >> 6)*2 + sel);
-	return m_program_plfo[adr];
 }
 
 template<int sel> void swp30_device::prg_lfo_w(offs_t offset, u16 data)
 {
-	offs_t adr = (offset >> 6)*2 + sel;
+	m_meg->lfo_w((offset >> 6)*2 + sel, data);
-	m_program_plfo[adr] = data;
-
-	static const int dt[8] = { 0, 32, 64, 128, 256, 512,  1024, 2048 };
-	static const int sh[8] = { 0,  0,  1,   2,   3,   4,     5,    6 };
-
-	int scale = (data >> 5) & 7;
-	int step = ((data & 31) << sh[scale]) + dt[scale];
-	if(0)
-		logerror("prg_lfo_w %02x freq=%5.2f phase=%6.4f\n", adr, step * 44100.0/4194304, (data >> 8)/256.0);
 }
 
 

src/devices/sound/swp30.h

@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include "meg.h"
+
 class swp30_device : public device_t, public device_sound_interface, public device_rom_interface
 {
 public:
@@ -20,8 +22,11 @@ protected:
 	virtual void device_reset() override;
 	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) override;
 	virtual void rom_bank_updated() override;
+	virtual void device_add_mconfig(machine_config &config) override;
 
 private:
+	required_device<meg_embedded_device> m_meg;
+
 	sound_stream *m_stream;
 
 	s32 m_sample_increment[0x4000];
@@ -99,8 +104,8 @@ private:
 	// MEG registers
 	template<int sel> u16 prg_fp_r(offs_t offset);
 	template<int sel> void prg_fp_w(offs_t offset, u16 data);
-	template<int sel> u16 prg_int_r(offs_t offset);
+	template<int sel> u16 prg_off_r(offs_t offset);
-	template<int sel> void prg_int_w(offs_t offset, u16 data);
+	template<int sel> void prg_off_w(offs_t offset, u16 data);
 	template<int sel> u16 prg_lfo_r(offs_t offset);
 	template<int sel> void prg_lfo_w(offs_t offset, u16 data);
 

src/mame/drivers/ymmu100.cpp

@@ -136,6 +136,7 @@
 #include "cpu/h8/h8s2655.h"
 #include "video/hd44780.h"
 #include "sound/swp30.h"
+#include "sound/meg.h"
 
 #include "debugger.h"
 #include "screen.h"
@@ -199,6 +200,7 @@ public:
 		, m_mu80cpu(*this, "mu80cpu")
 		, m_vl70cpu(*this, "vl70cpu")
 		, m_swp30(*this, "swp30")
+		, m_meg(*this, "meg")
 		, m_lcd(*this, "lcd")
 		, m_ioport_p7(*this, "P7")
 		, m_ioport_p8(*this, "P8")
@@ -316,6 +318,7 @@ private:
 	optional_device<h83002_device> m_mu80cpu;
 	optional_device<h83003_device> m_vl70cpu;
 	optional_device<swp30_device> m_swp30;
+	optional_device<meg_device> m_meg;
 	required_device<hd44780_device> m_lcd;
 	optional_ioport m_ioport_p7;
 	optional_ioport m_ioport_p8;
@@ -597,12 +600,14 @@ void mu100_state::mu80_map(address_map &map)
 {
 	map(0x000000, 0x07ffff).rom().region("mu80cpu", 0);
 	map(0x200000, 0x20ffff).ram(); // 64K work RAM
+	map(0x440000, 0x44001f).m(m_meg, FUNC(meg_device::map));
 }
 
 void mu100_state::vl70_map(address_map &map)
 {
 	map(0x000000, 0x1fffff).rom().region("vl70cpu", 0);
 	map(0x200000, 0x20ffff).ram(); // 64K work RAM
+	map(0x600000, 0x60001f).m(m_meg, FUNC(meg_device::map));
 }
 
 void mu100_state::mu100_map(address_map &map)
@@ -991,6 +996,8 @@ void mu100_state::mu80(machine_config &config)
 	m_swp30->add_route(0, "lspeaker", 1.0);
 	m_swp30->add_route(1, "rspeaker", 1.0);
 
+	MEG(config, m_meg);
+
 	auto &mdin_a(MIDI_PORT(config, "mdin_a"));
 	midiin_slot(mdin_a);
 	mdin_a.rxd_handler().set("mu80cpu:sci1", FUNC(h8_sci_device::rx_w));
@@ -1023,6 +1030,8 @@ void mu100_state::vl70(machine_config &config)
 	SPEAKER(config, "lspeaker").front_left();
 	SPEAKER(config, "rspeaker").front_right();
 
+	MEG(config, m_meg);
+
 	auto &mdin_a(MIDI_PORT(config, "mdin_a"));
 	midiin_slot(mdin_a);
 	mdin_a.rxd_handler().set("vl70cpu:sci1", FUNC(h8_sci_device::rx_w));