summaryrefslogtreecommitdiffstatshomepage
path: root/src/devices/cpu/m68000/m68kcpu.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/devices/cpu/m68000/m68kcpu.cpp')
-rw-r--r--src/devices/cpu/m68000/m68kcpu.cpp1164
1 files changed, 539 insertions, 625 deletions
diff --git a/src/devices/cpu/m68000/m68kcpu.cpp b/src/devices/cpu/m68000/m68kcpu.cpp
index 896a046cd77..19d1063e026 100644
--- a/src/devices/cpu/m68000/m68kcpu.cpp
+++ b/src/devices/cpu/m68000/m68kcpu.cpp
@@ -9,7 +9,7 @@ static const char copyright_notice[] =
"MUSASHI\n"
"Version 4.95 (2012-02-19)\n"
"A portable Motorola M68xxx/CPU32/ColdFire processor emulation engine.\n"
-"Copyright Karl Stenerud. All rights reserved.\n"
+"Copyright Karl Stenerud.\n"
;
#endif
@@ -25,21 +25,20 @@ static const char copyright_notice[] =
/* ======================================================================== */
#include "emu.h"
-#include "debugger.h"
-#include "m68000.h"
+#include "m68kmusashi.h"
#include "m68kdasm.h"
// Generated data
-u16 m68000_base_device::m68ki_instruction_state_table[NUM_CPU_TYPES][0x10000]; /* opcode handler jump table */
-unsigned char m68000_base_device::m68ki_cycles[NUM_CPU_TYPES][0x10000]; /* Cycles used by CPU type */
+u16 m68000_musashi_device::m68ki_instruction_state_table[NUM_CPU_TYPES][0x10000]; /* opcode handler jump table */
+unsigned char m68000_musashi_device::m68ki_cycles[NUM_CPU_TYPES][0x10000]; /* Cycles used by CPU type */
/* ======================================================================== */
/* ================================= DATA ================================= */
/* ======================================================================== */
/* Used by shift & rotate instructions */
-const u8 m68000_base_device::m68ki_shift_8_table[65] =
+const u8 m68000_musashi_device::m68ki_shift_8_table[65] =
{
0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -48,7 +47,7 @@ const u8 m68000_base_device::m68ki_shift_8_table[65] =
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff
};
-const u16 m68000_base_device::m68ki_shift_16_table[65] =
+const u16 m68000_musashi_device::m68ki_shift_16_table[65] =
{
0x0000, 0x8000, 0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00,
0xff80, 0xffc0, 0xffe0, 0xfff0, 0xfff8, 0xfffc, 0xfffe, 0xffff, 0xffff,
@@ -59,7 +58,7 @@ const u16 m68000_base_device::m68ki_shift_16_table[65] =
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff
};
-const u32 m68000_base_device::m68ki_shift_32_table[65] =
+const u32 m68000_musashi_device::m68ki_shift_32_table[65] =
{
0x00000000, 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 0xf8000000,
0xfc000000, 0xfe000000, 0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
@@ -78,7 +77,7 @@ const u32 m68000_base_device::m68ki_shift_32_table[65] =
/* Number of clock cycles to use for exception processing.
* I used 4 for any vectors that are undocumented for processing times.
*/
-const u8 m68000_base_device::m68ki_exception_cycle_table[NUM_CPU_TYPES][256] =
+const u8 m68000_musashi_device::m68ki_exception_cycle_table[NUM_CPU_TYPES][256] =
{
{ /* 000 */
40, /* 0: Reset - Initial Stack Pointer */
@@ -666,7 +665,7 @@ const u8 m68000_base_device::m68ki_exception_cycle_table[NUM_CPU_TYPES][256] =
},
};
-const u8 m68000_base_device::m68ki_ea_idx_cycle_table[64] =
+const u8 m68000_musashi_device::m68ki_ea_idx_cycle_table[64] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, /* ..01.000 no memory indirect, base nullptr */
@@ -706,7 +705,7 @@ const u8 m68000_base_device::m68ki_ea_idx_cycle_table[64] =
/* ================================= API ================================== */
/* ======================================================================== */
-void m68000_base_device::set_irq_line(int irqline, int state)
+void m68000_musashi_device::set_irq_line(int irqline, int state)
{
u32 old_level = m_int_level;
u32 vstate = m_virq_state;
@@ -729,18 +728,20 @@ void m68000_base_device::set_irq_line(int irqline, int state)
/* A transition from < 7 to 7 always interrupts (NMI) */
/* Note: Level 7 can also level trigger like a normal IRQ */
+ // FIXME: This may cause unintended level 7 interrupts if one or two IPL lines are asserted
+ // immediately before others are cleared. The actual 68000 imposes an input hold time.
if(old_level != 0x0700 && m_int_level == 0x0700)
m_nmi_pending = true;
}
-void m68000_base_device::presave()
+void m68000_musashi_device::device_pre_save()
{
m_save_sr = m68ki_get_sr();
m_save_stopped = (m_stopped & STOP_LEVEL_STOP) != 0;
m_save_halted = (m_stopped & STOP_LEVEL_HALT) != 0;
}
-void m68000_base_device::postload()
+void m68000_musashi_device::device_post_load()
{
m68ki_set_sr_noint_nosp(m_save_sr);
//fprintf(stderr, "Reloaded, pc=%x\n", REG_PC(m68k));
@@ -748,7 +749,7 @@ void m68000_base_device::postload()
m68ki_jump(m_pc);
}
-void m68000_base_device::m68k_cause_bus_error()
+void m68000_musashi_device::m68k_cause_bus_error()
{
m_mmu_tmp_buserror_fc = m_mmu_tmp_fc;
m_mmu_tmp_buserror_rw = m_mmu_tmp_rw;
@@ -761,7 +762,7 @@ void m68000_base_device::m68k_cause_bus_error()
return;
}
- u32 sr = m68ki_init_exception();
+ u32 sr = m68ki_init_exception(EXCEPTION_BUS_ERROR);
m_run_mode = RUN_MODE_BERR_AERR_RESET_WSF;
@@ -773,12 +774,12 @@ void m68000_base_device::m68k_cause_bus_error()
else if (CPU_TYPE_IS_010())
{
/* only the 68010 throws this unique type-1000 frame */
- m68ki_stack_frame_1000(m_ppc, sr, EXCEPTION_BUS_ERROR);
+ m68ki_stack_frame_1000(m_ppc, sr, EXCEPTION_BUS_ERROR, m_mmu_tmp_buserror_address);
}
else if (CPU_TYPE_IS_070())
{
/* only the 68070 throws this unique type-1111 frame */
- m68ki_stack_frame_1111(m_ppc, sr, EXCEPTION_BUS_ERROR);
+ m68ki_stack_frame_1111(m_ppc, sr, EXCEPTION_BUS_ERROR, m_mmu_tmp_buserror_address);
}
else if (m_mmu_tmp_buserror_address == m_ppc)
{
@@ -793,12 +794,13 @@ void m68000_base_device::m68k_cause_bus_error()
m_run_mode = RUN_MODE_BERR_AERR_RESET;
}
-bool m68000_base_device::memory_translate(int space, int intention, offs_t &address)
+bool m68000_musashi_device::memory_translate(int spacenum, int intention, offs_t &address, address_space *&target_space)
{
+ target_space = &space(spacenum);
/* only applies to the program address space and only does something if the MMU's enabled */
{
/* 68040 needs to call the MMU even when disabled so transparent translation works */
- if ((space == AS_PROGRAM) && ((m_pmmu_enabled) || (CPU_TYPE_IS_040_PLUS())))
+ if ((spacenum == AS_PROGRAM) && ((m_pmmu_enabled) || (CPU_TYPE_IS_040_PLUS())))
{
// FIXME: m_mmu_tmp_sr will be overwritten in pmmu_translate_addr_with_fc
u16 temp_mmu_tmp_sr = m_mmu_tmp_sr;
@@ -833,7 +835,7 @@ bool m68000_base_device::memory_translate(int space, int intention, offs_t &addr
-void m68000_base_device::execute_run()
+void m68000_musashi_device::execute_run()
{
m_initial_cycles = m_icount;
@@ -878,6 +880,7 @@ void m68000_base_device::execute_run()
}
if(m_stopped)
{
+ debugger_wait_hook();
if (m_icount > 0)
m_icount = 0;
return;
@@ -899,7 +902,7 @@ void m68000_base_device::execute_run()
try
{
- if (!m_pmmu_enabled)
+ if (!m_can_instruction_restart)
{
m_run_mode = RUN_MODE_NORMAL;
/* Read an instruction and call its handler */
@@ -920,7 +923,7 @@ void m68000_base_device::execute_run()
tmp_dar[i] = REG_DA()[i];
}
- m_mmu_tmp_buserror_occurred = 0;
+ m_mmu_tmp_buserror_occurred = false;
/* Read an instruction and call its handler */
m_ir = m68ki_read_imm_16();
@@ -936,7 +939,7 @@ void m68000_base_device::execute_run()
{
u32 sr;
- m_mmu_tmp_buserror_occurred = 0;
+ m_mmu_tmp_buserror_occurred = false;
// restore cpu address registers to value at start of instruction
for (i = 15; i >= 0; i--)
@@ -949,32 +952,47 @@ void m68000_base_device::execute_run()
}
}
- sr = m68ki_init_exception();
-
- m_run_mode = RUN_MODE_BERR_AERR_RESET;
-
- if (!CPU_TYPE_IS_020_PLUS())
+ // for a simple restart request, simply back up the program counter
+ if (m_restart_instruction)
{
- /* Note: This is implemented for 68000 only! */
- m68ki_stack_frame_buserr(sr);
+ m_restart_instruction = false;
+ m_pc = m_ppc;
}
- else if(!CPU_TYPE_IS_040_PLUS()) {
- if (m_mmu_tmp_buserror_address == m_ppc)
+ else
+ {
+ sr = m68ki_init_exception(EXCEPTION_BUS_ERROR);
+
+ m_run_mode = RUN_MODE_BERR_AERR_RESET;
+
+ if (!CPU_TYPE_IS_020_PLUS())
{
- m68ki_stack_frame_1010(sr, EXCEPTION_BUS_ERROR, m_ppc, m_mmu_tmp_buserror_address);
+ if (CPU_TYPE_IS_010())
+ {
+ m68ki_stack_frame_1000(m_ppc, sr, EXCEPTION_BUS_ERROR, m_mmu_tmp_buserror_address);
+ }
+ else
+ {
+ /* Note: This is implemented for 68000 only! */
+ m68ki_stack_frame_buserr(sr);
+ }
+ }
+ else if(!CPU_TYPE_IS_040_PLUS()) {
+ if (m_mmu_tmp_buserror_address == m_ppc)
+ {
+ m68ki_stack_frame_1010(sr, EXCEPTION_BUS_ERROR, m_ppc, m_mmu_tmp_buserror_address);
+ }
+ else
+ {
+ m68ki_stack_frame_1011(sr, EXCEPTION_BUS_ERROR, m_ppc, m_mmu_tmp_buserror_address);
+ }
}
else
{
- m68ki_stack_frame_1011(sr, EXCEPTION_BUS_ERROR, m_ppc, m_mmu_tmp_buserror_address);
+ m68ki_stack_frame_0111(sr, EXCEPTION_BUS_ERROR, m_ppc, m_mmu_tmp_buserror_address, true);
}
- }
- else
- {
- m68ki_stack_frame_0111(sr, EXCEPTION_BUS_ERROR, m_ppc, m_mmu_tmp_buserror_address, true);
- }
-
- m68ki_jump_vector(EXCEPTION_BUS_ERROR);
+ m68ki_jump_vector(EXCEPTION_BUS_ERROR);
+ }
// TODO:
/* Use up some clock cycles and undo the instruction's cycles */
// m_icount -= m_cyc_exception[EXCEPTION_BUS_ERROR] - m_cyc_instruction[m_ir];
@@ -1006,7 +1024,7 @@ void m68000_base_device::execute_run()
-void m68000_base_device::init_cpu_common(void)
+void m68000_musashi_device::init_cpu_common(void)
{
static u32 emulation_initialized = 0;
@@ -1016,10 +1034,12 @@ void m68000_base_device::init_cpu_common(void)
m_cpu_space = &space(m_cpu_space_id);
/* disable all MMUs */
- m_has_pmmu = 0;
- m_has_hmmu = 0;
- m_pmmu_enabled = 0;
+ m_has_pmmu = false;
+ m_has_hmmu = false;
+ m_pmmu_enabled = false;
m_hmmu_enabled = 0;
+ m_emmu_enabled = false;
+ m_can_instruction_restart = false;
/* The first call to this function initializes the opcode handler jump table */
if(!emulation_initialized)
@@ -1053,6 +1073,9 @@ void m68000_base_device::init_cpu_common(void)
save_item(NAME(m_has_hmmu));
save_item(NAME(m_pmmu_enabled));
save_item(NAME(m_hmmu_enabled));
+ save_item(NAME(m_emmu_enabled));
+ save_item(NAME(m_can_instruction_restart));
+ save_item(NAME(m_restart_instruction));
save_item(NAME(m_mmu_crp_aptr));
save_item(NAME(m_mmu_crp_limit));
@@ -1076,24 +1099,21 @@ void m68000_base_device::init_cpu_common(void)
save_item(NAME(m_mmu_last_page_entry));
save_item(NAME(m_mmu_last_page_entry_addr));
- for (int i=0; i<MMU_ATC_ENTRIES;i++) {
- save_item(NAME(m_mmu_atc_tag[i]), i);
- save_item(NAME(m_mmu_atc_data[i]), i);
- }
-
- machine().save().register_presave(save_prepost_delegate(FUNC(m68000_base_device::presave), this));
- machine().save().register_postload(save_prepost_delegate(FUNC(m68000_base_device::postload), this));
+ save_item(NAME(m_mmu_atc_tag));
+ save_item(NAME(m_mmu_atc_data));
set_icountptr(m_icount);
m_icount = 0;
}
-void m68000_base_device::device_reset()
+void m68000_musashi_device::device_reset()
{
/* Disable the PMMU/HMMU on reset, if any */
- m_pmmu_enabled = 0;
+ m_pmmu_enabled = false;
m_hmmu_enabled = 0;
+ m_emmu_enabled = false;
+ m_can_instruction_restart = false;
m_mmu_tc = 0;
m_mmu_tt0 = 0;
@@ -1111,8 +1131,6 @@ void m68000_base_device::device_reset()
m68ki_clear_trace();
/* Interrupt mask to level 7 */
m_int_mask = 0x0700;
- m_int_level = 0;
- m_virq_state = 0;
/* Reset VBR */
m_vbr = 0;
/* Go to supervisor mode */
@@ -1143,7 +1161,7 @@ void m68000_base_device::device_reset()
* STATE IMPORT/EXPORT
**************************************************************************/
-void m68000_base_device::state_import(const device_state_entry &entry)
+void m68000_musashi_device::state_import(const device_state_entry &entry)
{
switch (entry.index())
{
@@ -1189,7 +1207,7 @@ void m68000_base_device::state_import(const device_state_entry &entry)
-void m68000_base_device::state_export(const device_state_entry &entry)
+void m68000_musashi_device::state_export(const device_state_entry &entry)
{
switch (entry.index())
{
@@ -1225,7 +1243,7 @@ void m68000_base_device::state_export(const device_state_entry &entry)
}
}
-void m68000_base_device::state_string_export(const device_state_entry &entry, std::string &str) const
+void m68000_musashi_device::state_string_export(const device_state_entry &entry, std::string &str) const
{
u16 sr;
@@ -1290,12 +1308,19 @@ void m68000_base_device::state_string_export(const device_state_entry &entry, st
/* global access */
-void m68000_base_device::set_hmmu_enable(int enable)
+void m68000_musashi_device::set_hmmu_enable(int enable)
{
m_hmmu_enabled = enable;
}
-void m68000_base_device::set_fpu_enable(int enable)
+/* set for external MMU and instruction restart */
+void m68000_musashi_device::set_emmu_enable(bool enable)
+{
+ m_emmu_enabled = enable;
+ m_can_instruction_restart = m_pmmu_enabled || m_emmu_enabled;
+}
+
+void m68000_musashi_device::set_fpu_enable(bool enable)
{
m_has_fpu = enable;
}
@@ -1304,38 +1329,40 @@ void m68000_base_device::set_fpu_enable(int enable)
* 8-bit data memory interface
****************************************************************************/
-void m68000_base_device::init8(address_space &space, address_space &ospace)
+void m68000_musashi_device::init8(address_space &space, address_space &ospace)
{
m_space = &space;
m_ospace = &ospace;
- auto ocache = ospace.cache<0, 0, ENDIANNESS_BIG>();
-
- m_readimm16 = [ocache](offs_t address) -> u16 { return ocache->read_word(address); };
- m_read8 = [this](offs_t address) -> u8 { return m_space->read_byte(address); };
- m_read16 = [this](offs_t address) -> u16 { return m_space->read_word(address); };
- m_read32 = [this](offs_t address) -> u32 { return m_space->read_dword(address); };
- m_write8 = [this](offs_t address, u8 data) { m_space->write_byte(address, data); };
- m_write16 = [this](offs_t address, u16 data) { m_space->write_word(address, data); };
- m_write32 = [this](offs_t address, u32 data) { m_space->write_dword(address, data); };
+ ospace.cache(m_oprogram8);
+ space.specific(m_program8);
+
+ m_readimm16 = [this](offs_t address) -> u16 { return m_oprogram8.read_word(address); };
+ m_read8 = [this](offs_t address) -> u8 { return m_program8.read_byte(address); };
+ m_read16 = [this](offs_t address) -> u16 { return m_program8.read_word(address); };
+ m_read32 = [this](offs_t address) -> u32 { return m_program8.read_dword(address); };
+ m_write8 = [this](offs_t address, u8 data) { m_program8.write_byte(address, data); };
+ m_write16 = [this](offs_t address, u16 data) { m_program8.write_word(address, data); };
+ m_write32 = [this](offs_t address, u32 data) { m_program8.write_dword(address, data); };
}
/****************************************************************************
* 16-bit data memory interface
****************************************************************************/
-void m68000_base_device::init16(address_space &space, address_space &ospace)
+void m68000_musashi_device::init16(address_space &space, address_space &ospace)
{
m_space = &space;
m_ospace = &ospace;
- auto ocache = ospace.cache<1, 0, ENDIANNESS_BIG>();
-
- m_readimm16 = [ocache](offs_t address) -> u16 { return ocache->read_word(address); };
- m_read8 = [this](offs_t address) -> u8 { return m_space->read_byte(address); };
- m_read16 = [this](offs_t address) -> u16 { return m_space->read_word(address); };
- m_read32 = [this](offs_t address) -> u32 { return m_space->read_dword(address); };
- m_write8 = [this](offs_t address, u8 data) { m_space->write_word(address & ~1, data | (data << 8), address & 1 ? 0x00ff : 0xff00); };
- m_write16 = [this](offs_t address, u16 data) { m_space->write_word(address, data); };
- m_write32 = [this](offs_t address, u32 data) { m_space->write_dword(address, data); };
+ ospace.cache(m_oprogram16);
+ space.specific(m_program16);
+
+ m_readimm16 = [this](offs_t address) -> u16 { return m_oprogram16.read_word(address); };
+ m_read8 = [this](offs_t address) -> u8 { return m_program16.read_byte(address); };
+ m_read16 = [this](offs_t address) -> u16 { return m_program16.read_word(address); };
+ m_read32 = [this](offs_t address) -> u32 { return m_program16.read_dword(address); };
+ m_write8 = [this](offs_t address, u8 data) { m_program16.write_word(address & ~1, data | (data << 8), address & 1 ? 0x00ff : 0xff00); };
+ m_write16 = [this](offs_t address, u16 data) { m_program16.write_word(address, data); };
+ m_write32 = [this](offs_t address, u32 data) { m_program16.write_dword(address, data); };
}
/****************************************************************************
@@ -1347,78 +1374,80 @@ static inline u32 dword_from_word(u16 data) { return data * 0x00010001U; }
static inline u32 dword_from_unaligned_word(u16 data) { return u32(data) << 8 | ((data >> 8) * 0x01000001U); }
/* interface for 32-bit data bus (68EC020, 68020) */
-void m68000_base_device::init32(address_space &space, address_space &ospace)
+void m68000_musashi_device::init32(address_space &space, address_space &ospace)
{
m_space = &space;
m_ospace = &ospace;
- auto ocache = ospace.cache<2, 0, ENDIANNESS_BIG>();
+ ospace.cache(m_oprogram32);
+ space.specific(m_program32);
- m_readimm16 = [ocache](offs_t address) -> u16 { return ocache->read_word(address); };
- m_read8 = [this](offs_t address) -> u8 { return m_space->read_byte(address); };
- m_read16 = [this](offs_t address) -> u16 { return m_space->read_word_unaligned(address); };
- m_read32 = [this](offs_t address) -> u32 { return m_space->read_dword_unaligned(address); };
+ m_readimm16 = [this](offs_t address) -> u16 { return m_oprogram32.read_word(address); };
+ m_read8 = [this](offs_t address) -> u8 { return m_program32.read_byte(address); };
+ m_read16 = [this](offs_t address) -> u16 { return m_program32.read_word_unaligned(address); };
+ m_read32 = [this](offs_t address) -> u32 { return m_program32.read_dword_unaligned(address); };
m_write8 = [this](offs_t address, u8 data) {
- m_space->write_dword(address & 0xfffffffcU, dword_from_byte(data), 0xff000000U >> 8 * (address & 3));
+ m_program32.write_dword(address & 0xfffffffcU, dword_from_byte(data), 0xff000000U >> 8 * (address & 3));
};
m_write16 = [this](offs_t address, u16 data) {
switch (address & 3) {
case 0:
- m_space->write_dword(address, dword_from_word(data), 0xffff0000U);
+ m_program32.write_dword(address, dword_from_word(data), 0xffff0000U);
break;
case 1:
- m_space->write_dword(address - 1, dword_from_unaligned_word(data), 0x00ffff00);
+ m_program32.write_dword(address - 1, dword_from_unaligned_word(data), 0x00ffff00);
break;
case 2:
- m_space->write_dword(address - 2, dword_from_word(data), 0x0000ffff);
+ m_program32.write_dword(address - 2, dword_from_word(data), 0x0000ffff);
break;
case 3:
- m_space->write_dword(address - 3, dword_from_unaligned_word(data), 0x000000ff);
- m_space->write_dword(address + 1, dword_from_byte(data & 0x00ff), 0xff000000U);
+ m_program32.write_dword(address - 3, dword_from_unaligned_word(data), 0x000000ff);
+ m_program32.write_dword(address + 1, dword_from_byte(data & 0x00ff), 0xff000000U);
break;
}
};
m_write32 = [this](offs_t address, u32 data) {
switch (address & 3) {
case 0:
- m_space->write_dword(address, data, 0xffffffffU);
+ m_program32.write_dword(address, data, 0xffffffffU);
break;
case 1:
- m_space->write_dword(address - 1, (data & 0xff000000U) | (data & 0xffffff00U) >> 8, 0x00ffffff);
- m_space->write_dword(address + 3, dword_from_byte(data & 0x000000ff), 0xff000000U);
+ m_program32.write_dword(address - 1, (data & 0xff000000U) | (data & 0xffffff00U) >> 8, 0x00ffffff);
+ m_program32.write_dword(address + 3, dword_from_byte(data & 0x000000ff), 0xff000000U);
break;
case 2:
- m_space->write_dword(address - 2, dword_from_word((data & 0xffff0000U) >> 16), 0x0000ffff);
- m_space->write_dword(address + 2, dword_from_word(data & 0x0000ffff), 0xffff0000U);
+ m_program32.write_dword(address - 2, dword_from_word((data & 0xffff0000U) >> 16), 0x0000ffff);
+ m_program32.write_dword(address + 2, dword_from_word(data & 0x0000ffff), 0xffff0000U);
break;
case 3:
- m_space->write_dword(address - 3, dword_from_unaligned_word((data & 0xffff0000U) >> 16), 0x000000ff);
- m_space->write_dword(address + 1, (data & 0x00ffffff) << 8 | (data & 0xff000000U) >> 24, 0xffffff00U);
+ m_program32.write_dword(address - 3, dword_from_unaligned_word((data & 0xffff0000U) >> 16), 0x000000ff);
+ m_program32.write_dword(address + 1, rotl_32(data, 8), 0xffffff00U);
break;
}
};
}
/* interface for 32-bit data bus with PMMU */
-void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
+void m68000_musashi_device::init32mmu(address_space &space, address_space &ospace)
{
m_space = &space;
m_ospace = &ospace;
- auto ocache = ospace.cache<2, 0, ENDIANNESS_BIG>();
+ ospace.cache(m_oprogram32);
+ space.specific(m_program32);
- m_readimm16 = [this, ocache](offs_t address) -> u16 {
+ m_readimm16 = [this](offs_t address) -> u16 {
if (m_pmmu_enabled) {
address = pmmu_translate_addr(address, 1);
if (m_mmu_tmp_buserror_occurred)
return ~0;
}
- return ocache->read_word(address);
+ return m_oprogram32.read_word(address);
};
m_read8 = [this](offs_t address) -> u8 {
@@ -1427,7 +1456,7 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
if (m_mmu_tmp_buserror_occurred)
return ~0;
}
- return m_space->read_byte(address);
+ return m_program32.read_byte(address);
};
m_read16 = [this](offs_t address) -> u16 {
@@ -1436,14 +1465,14 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
if (m_mmu_tmp_buserror_occurred)
return ~0;
if (WORD_ALIGNED(address))
- return m_space->read_word(address0);
+ return m_program32.read_word(address0);
u32 address1 = pmmu_translate_addr(address + 1, 1);
if (m_mmu_tmp_buserror_occurred)
return ~0;
- u16 result = m_space->read_byte(address0) << 8;
- return result | m_space->read_byte(address1);
+ u16 result = m_program32.read_byte(address0) << 8;
+ return result | m_program32.read_byte(address1);
}
- return m_space->read_word_unaligned(address);
+ return m_program32.read_word_unaligned(address);
};
m_read32 = [this](offs_t address) -> u32 {
@@ -1455,25 +1484,25 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
// not at page boundary; use default code
address = address0;
else if (DWORD_ALIGNED(address)) // 0
- return m_space->read_dword(address0);
+ return m_program32.read_dword(address0);
else {
u32 address2 = pmmu_translate_addr(address+2, 1);
if (m_mmu_tmp_buserror_occurred)
return ~0;
if (WORD_ALIGNED(address)) { // 2
- u32 result = m_space->read_word(address0) << 16;
- return result | m_space->read_word(address2);
+ u32 result = m_program32.read_word(address0) << 16;
+ return result | m_program32.read_word(address2);
}
u32 address1 = pmmu_translate_addr(address+1, 1);
u32 address3 = pmmu_translate_addr(address+3, 1);
if (m_mmu_tmp_buserror_occurred)
return ~0;
- u32 result = m_space->read_byte(address0) << 24;
- result |= m_space->read_word(address1) << 8;
- return result | m_space->read_byte(address3);
+ u32 result = m_program32.read_byte(address0) << 24;
+ result |= m_program32.read_word(address1) << 8;
+ return result | m_program32.read_byte(address3);
}
}
- return m_space->read_dword_unaligned(address);
+ return m_program32.read_dword_unaligned(address);
};
m_write8 = [this](offs_t address, u8 data) {
@@ -1482,7 +1511,7 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
if (m_mmu_tmp_buserror_occurred)
return;
}
- m_space->write_dword(address & 0xfffffffcU, dword_from_byte(data), 0xff000000U >> 8 * (address & 3));
+ m_program32.write_dword(address & 0xfffffffcU, dword_from_byte(data), 0xff000000U >> 8 * (address & 3));
};
m_write16 = [this](offs_t address, u16 data) {
@@ -1494,15 +1523,15 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
}
switch (address & 3) {
case 0:
- m_space->write_dword(address0, dword_from_word(data), 0xffff0000U);
+ m_program32.write_dword(address0, dword_from_word(data), 0xffff0000U);
break;
case 1:
- m_space->write_dword(address0 - 1, dword_from_unaligned_word(data), 0x00ffff00);
+ m_program32.write_dword(address0 - 1, dword_from_unaligned_word(data), 0x00ffff00);
break;
case 2:
- m_space->write_dword(address0 - 2, dword_from_word(data), 0x0000ffff);
+ m_program32.write_dword(address0 - 2, dword_from_word(data), 0x0000ffff);
break;
case 3:
@@ -1513,8 +1542,8 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
if (m_mmu_tmp_buserror_occurred)
return;
}
- m_space->write_dword(address0 - 3, dword_from_unaligned_word(data), 0x000000ff);
- m_space->write_dword(address1, dword_from_byte(data & 0x00ff), 0xff000000U);
+ m_program32.write_dword(address0 - 3, dword_from_unaligned_word(data), 0x000000ff);
+ m_program32.write_dword(address1, dword_from_byte(data & 0x00ff), 0xff000000U);
break;
}
}
@@ -1529,7 +1558,7 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
}
switch (address & 3) {
case 0:
- m_space->write_dword(address0, data, 0xffffffffU);
+ m_program32.write_dword(address0, data, 0xffffffffU);
break;
case 1:
@@ -1540,8 +1569,8 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
if (m_mmu_tmp_buserror_occurred)
return;
}
- m_space->write_dword(address0 - 1, (data & 0xff000000U) | (data & 0xffffff00U) >> 8, 0x00ffffff);
- m_space->write_dword(address3, dword_from_byte(data & 0x000000ff), 0xff000000U);
+ m_program32.write_dword(address0 - 1, (data & 0xff000000U) | (data & 0xffffff00U) >> 8, 0x00ffffff);
+ m_program32.write_dword(address3, dword_from_byte(data & 0x000000ff), 0xff000000U);
break;
}
@@ -1553,8 +1582,8 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
if (m_mmu_tmp_buserror_occurred)
return;
}
- m_space->write_dword(address0 - 2, dword_from_word((data & 0xffff0000U) >> 16), 0x0000ffff);
- m_space->write_dword(address2, dword_from_word(data & 0x0000ffff), 0xffff0000U);
+ m_program32.write_dword(address0 - 2, dword_from_word((data & 0xffff0000U) >> 16), 0x0000ffff);
+ m_program32.write_dword(address2, dword_from_word(data & 0x0000ffff), 0xffff0000U);
break;
}
@@ -1566,39 +1595,272 @@ void m68000_base_device::init32mmu(address_space &space, address_space &ospace)
if (m_mmu_tmp_buserror_occurred)
return;
}
- m_space->write_dword(address0 - 3, dword_from_unaligned_word((data & 0xffff0000U) >> 16), 0x000000ff);
- m_space->write_dword(address1, (data & 0x00ffffff) << 8 | (data & 0xff000000U) >> 24, 0xffffff00U);
+ m_program32.write_dword(address0 - 3, dword_from_unaligned_word((data & 0xffff0000U) >> 16), 0x000000ff);
+ m_program32.write_dword(address1, rotl_32(data, 8), 0xffffff00U);
break;
}
}
};
}
-void m68000_base_device::init32hmmu(address_space &space, address_space &ospace)
+/* interface for 32-bit data bus without byte smearing 68040) */
+void m68000_musashi_device::init32_no_smear(address_space &space, address_space &ospace)
+{
+ m_space = &space;
+ m_ospace = &ospace;
+ ospace.cache(m_oprogram32);
+ space.specific(m_program32);
+
+ m_readimm16 = [this](offs_t address) -> u16
+ { return m_oprogram32.read_word(address); };
+ m_read8 = [this](offs_t address) -> u8
+ { return m_program32.read_byte(address); };
+ m_read16 = [this](offs_t address) -> u16
+ { return m_program32.read_word_unaligned(address); };
+ m_read32 = [this](offs_t address) -> u32
+ { return m_program32.read_dword_unaligned(address); };
+ m_write8 = [this](offs_t address, u8 data)
+ { return m_program32.write_byte(address, data); };
+ m_write16 = [this](offs_t address, u16 data)
+ {
+ if (address & 1)
+ {
+ m_program32.write_byte(address, data >> 8);
+ m_program32.write_byte(address + 1, data & 0xff);
+ }
+ else
+ {
+ m_program32.write_word(address, data);
+ }
+ return;
+ };
+ m_write32 = [this](offs_t address, u32 data)
+ {
+ switch (address & 3)
+ {
+ case 0:
+ m_program32.write_dword(address, data, 0xffffffffU);
+ break;
+
+ case 1:
+ m_program32.write_dword(address - 1, (data & 0xff000000U) | (data & 0xffffff00U) >> 8, 0x00ffffff);
+ m_program32.write_dword(address + 3, dword_from_byte(data & 0x000000ff), 0xff000000U);
+ break;
+
+ case 2:
+ m_program32.write_dword(address - 2, dword_from_word((data & 0xffff0000U) >> 16), 0x0000ffff);
+ m_program32.write_dword(address + 2, dword_from_word(data & 0x0000ffff), 0xffff0000U);
+ break;
+
+ case 3:
+ m_program32.write_dword(address - 3, dword_from_unaligned_word((data & 0xffff0000U) >> 16), 0x000000ff);
+ m_program32.write_dword(address + 1, rotl_32(data, 8), 0xffffff00U);
+ break;
+ }
+ };
+}
+
+/* interface for 32-bit data bus with PMMU without byte smearing (68040)*/
+void m68000_musashi_device::init32mmu_no_smear(address_space &space, address_space &ospace)
{
m_space = &space;
m_ospace = &ospace;
- auto ocache = ospace.cache<2, 0, ENDIANNESS_BIG>();
+ ospace.cache(m_oprogram32);
+ space.specific(m_program32);
+
+ m_readimm16 = [this](offs_t address) -> u16
+ {
+ if (m_pmmu_enabled)
+ {
+ address = pmmu_translate_addr(address, 1);
+ if (m_mmu_tmp_buserror_occurred)
+ return ~0;
+ }
+
+ return m_oprogram32.read_word(address);
+ };
+
+ m_read8 = [this](offs_t address) -> u8
+ {
+ if (m_pmmu_enabled)
+ {
+ address = pmmu_translate_addr(address, 1);
+ if (m_mmu_tmp_buserror_occurred)
+ return ~0;
+ }
+ return m_program32.read_byte(address);
+ };
+
+ m_read16 = [this](offs_t address) -> u16
+ {
+ if (m_pmmu_enabled)
+ {
+ u32 address0 = pmmu_translate_addr(address, 1);
+ if (m_mmu_tmp_buserror_occurred)
+ return ~0;
+ if (WORD_ALIGNED(address))
+ return m_program32.read_word(address0);
+ u32 address1 = pmmu_translate_addr(address + 1, 1);
+ if (m_mmu_tmp_buserror_occurred)
+ return ~0;
+ u16 result = m_program32.read_byte(address0) << 8;
+ return result | m_program32.read_byte(address1);
+ }
+ return m_program32.read_word_unaligned(address);
+ };
+
+ m_read32 = [this](offs_t address) -> u32
+ {
+ if (m_pmmu_enabled)
+ {
+ u32 address0 = pmmu_translate_addr(address, 1);
+ if (m_mmu_tmp_buserror_occurred)
+ return ~0;
+ if ((address + 3) & 0xfc)
+ // not at page boundary; use default code
+ address = address0;
+ else if (DWORD_ALIGNED(address)) // 0
+ return m_program32.read_dword(address0);
+ else
+ {
+ u32 address2 = pmmu_translate_addr(address + 2, 1);
+ if (m_mmu_tmp_buserror_occurred)
+ return ~0;
+ if (WORD_ALIGNED(address))
+ { // 2
+ u32 result = m_program32.read_word(address0) << 16;
+ return result | m_program32.read_word(address2);
+ }
+ u32 address1 = pmmu_translate_addr(address + 1, 1);
+ u32 address3 = pmmu_translate_addr(address + 3, 1);
+ if (m_mmu_tmp_buserror_occurred)
+ return ~0;
+ u32 result = m_program32.read_byte(address0) << 24;
+ result |= m_program32.read_word(address1) << 8;
+ return result | m_program32.read_byte(address3);
+ }
+ }
+ return m_program32.read_dword_unaligned(address);
+ };
- m_readimm16 = [this, ocache](offs_t address) -> u16 {
+ m_write8 = [this](offs_t address, u8 data)
+ {
+ u32 address0 = address;
+ if (m_pmmu_enabled)
+ {
+ address0 = pmmu_translate_addr(address, 0);
+ if (m_mmu_tmp_buserror_occurred)
+ return;
+ }
+ m_program32.write_byte(address0, data);
+ };
+
+ m_write16 = [this](offs_t address, u16 data)
+ {
+ u32 address0 = address;
+ if (m_pmmu_enabled)
+ {
+ address0 = pmmu_translate_addr(address0, 0);
+ if (m_mmu_tmp_buserror_occurred)
+ return;
+ }
+ if (address0 & 1)
+ {
+ m_program32.write_byte(address0, data >> 8);
+ m_program32.write_byte(address0 + 1, data & 0xff);
+ }
+ else
+ {
+ m_program32.write_word(address0, data);
+ }
+ };
+
+ m_write32 = [this](offs_t address, u32 data)
+ {
+ u32 address0 = address;
+ if (m_pmmu_enabled)
+ {
+ address0 = pmmu_translate_addr(address0, 0);
+ if (m_mmu_tmp_buserror_occurred)
+ return;
+ }
+ switch (address & 3)
+ {
+ case 0:
+ m_program32.write_dword(address0, data, 0xffffffffU);
+ break;
+
+ case 1:
+ {
+ u32 address3 = address + 3;
+ if (m_pmmu_enabled)
+ {
+ address3 = pmmu_translate_addr(address3, 0);
+ if (m_mmu_tmp_buserror_occurred)
+ return;
+ }
+ m_program32.write_dword(address0 - 1, (data & 0xff000000U) | (data & 0xffffff00U) >> 8, 0x00ffffff);
+ m_program32.write_dword(address3, dword_from_byte(data & 0x000000ff), 0xff000000U);
+ break;
+ }
+
+ case 2:
+ {
+ u32 address2 = address + 2;
+ if (m_pmmu_enabled)
+ {
+ address2 = pmmu_translate_addr(address2, 0);
+ if (m_mmu_tmp_buserror_occurred)
+ return;
+ }
+ m_program32.write_dword(address0 - 2, dword_from_word((data & 0xffff0000U) >> 16), 0x0000ffff);
+ m_program32.write_dword(address2, dword_from_word(data & 0x0000ffff), 0xffff0000U);
+ break;
+ }
+
+ case 3:
+ {
+ u32 address1 = address + 1;
+ if (m_pmmu_enabled)
+ {
+ address1 = pmmu_translate_addr(address1, 0);
+ if (m_mmu_tmp_buserror_occurred)
+ return;
+ }
+ m_program32.write_dword(address0 - 3, dword_from_unaligned_word((data & 0xffff0000U) >> 16), 0x000000ff);
+ m_program32.write_dword(address1, rotl_32(data, 8), 0xffffff00U);
+ break;
+ }
+ }
+ };
+}
+
+void m68000_musashi_device::init32hmmu(address_space &space, address_space &ospace)
+{
+ m_space = &space;
+ m_ospace = &ospace;
+ ospace.cache(m_oprogram32);
+ space.specific(m_program32);
+
+ m_readimm16 = [this](offs_t address) -> u16 {
if (m_hmmu_enabled)
address = hmmu_translate_addr(address);
- return ocache->read_word(address);
+ return m_oprogram32.read_word(address);
};
m_read8 = [this](offs_t address) -> u8 {
if (m_hmmu_enabled)
address = hmmu_translate_addr(address);
- return m_space->read_byte(address);
+ return m_program32.read_byte(address);
};
m_read16 = [this](offs_t address) -> u16 {
if (m_hmmu_enabled)
address = hmmu_translate_addr(address);
if (WORD_ALIGNED(address))
- return m_space->read_word(address);
- u16 result = m_space->read_byte(address) << 8;
- return result | m_space->read_byte(address + 1);
+ return m_program32.read_word(address);
+ u16 result = m_program32.read_byte(address) << 8;
+ return result | m_program32.read_byte(address + 1);
};
m_read32 = [this](offs_t address) -> u32 {
@@ -1606,31 +1868,31 @@ void m68000_base_device::init32hmmu(address_space &space, address_space &ospace)
address = hmmu_translate_addr(address);
if (DWORD_ALIGNED(address))
- return m_space->read_dword(address);
+ return m_program32.read_dword(address);
if (WORD_ALIGNED(address)) {
- u32 result = m_space->read_word(address) << 16;
- return result | m_space->read_word(address + 2);
+ u32 result = m_program32.read_word(address) << 16;
+ return result | m_program32.read_word(address + 2);
}
- u32 result = m_space->read_byte(address) << 24;
- result |= m_space->read_word(address + 1) << 8;
- return result | m_space->read_byte(address + 3);
+ u32 result = m_program32.read_byte(address) << 24;
+ result |= m_program32.read_word(address + 1) << 8;
+ return result | m_program32.read_byte(address + 3);
};
m_write8 = [this](offs_t address, u8 data) {
if (m_hmmu_enabled)
address = hmmu_translate_addr(address);
- m_space->write_byte(address, data);
+ m_program32.write_byte(address, data);
};
m_write16 = [this](offs_t address, u16 data) {
if (m_hmmu_enabled)
address = hmmu_translate_addr(address);
if (WORD_ALIGNED(address)) {
- m_space->write_word(address, data);
+ m_program32.write_word(address, data);
return;
}
- m_space->write_byte(address, data >> 8);
- m_space->write_byte(address + 1, data);
+ m_program32.write_byte(address, data >> 8);
+ m_program32.write_byte(address + 1, data);
};
m_write32 = [this](offs_t address, u32 data) {
@@ -1638,52 +1900,48 @@ void m68000_base_device::init32hmmu(address_space &space, address_space &ospace)
address = hmmu_translate_addr(address);
if (DWORD_ALIGNED(address)) {
- m_space->write_dword(address, data);
+ m_program32.write_dword(address, data);
return;
}
if (WORD_ALIGNED(address)) {
- m_space->write_word(address, data >> 16);
- m_space->write_word(address + 2, data);
+ m_program32.write_word(address, data >> 16);
+ m_program32.write_word(address + 2, data);
return;
}
- m_space->write_byte(address, data >> 24);
- m_space->write_word(address + 1, data >> 8);
- m_space->write_byte(address + 3, data);
+ m_program32.write_byte(address, data >> 24);
+ m_program32.write_word(address + 1, data >> 8);
+ m_program32.write_byte(address + 3, data);
};
}
-void m68000_base_device::set_reset_callback(write_line_delegate callback)
-{
- m_reset_instr_callback = callback;
-}
-
// fault_addr = address to indicate fault at
// rw = 1 for read, 0 for write
// fc = 3-bit function code of access (usually you'd just put what m68k_get_fc() returns here)
-void m68000_base_device::set_buserror_details(u32 fault_addr, u8 rw, u8 fc)
+// rerun = trigger bus error and rerun instruction after RTE, intended for external MMU use
+// do not call set_input_line(M68K_LINE_BUSERROR) when using rerun flag
+void m68000_musashi_device::set_buserror_details(u32 fault_addr, u8 rw, u8 fc, bool rerun)
{
+ if (m_can_instruction_restart && rerun) m_mmu_tmp_buserror_occurred = true; // hack for external MMU
+
+ // save values for 68000 specific bus error
m_aerr_address = fault_addr;
m_aerr_write_mode = (rw << 4);
m_aerr_fc = fc;
- m_mmu_tmp_buserror_address = fault_addr; // Hack for x68030
-}
-void m68000_base_device::set_cmpild_callback(write32_delegate callback)
-{
- m_cmpild_instr_callback = callback;
-}
-
-void m68000_base_device::set_rte_callback(write_line_delegate callback)
-{
- m_rte_instr_callback = callback;
+ // Hack for x68030 and external MMU
+ m_mmu_tmp_buserror_address = fault_addr;
+ m_mmu_tmp_buserror_rw = m_mmu_tmp_rw;
+ m_mmu_tmp_buserror_fc = m_mmu_tmp_fc;
+ m_mmu_tmp_buserror_sz = m_mmu_tmp_sz;
}
-void m68000_base_device::set_tas_write_callback(write8_delegate callback)
+void m68000_musashi_device::restart_this_instruction()
{
- m_tas_write_callback = callback;
+ m_mmu_tmp_buserror_occurred = true;
+ m_restart_instruction = true;
}
-u16 m68000_base_device::get_fc()
+u16 m68000_musashi_device::get_fc() const noexcept
{
return m_mmu_tmp_fc;
}
@@ -1692,7 +1950,7 @@ u16 m68000_base_device::get_fc()
* State definition
****************************************************************************/
-void m68000_base_device::define_state(void)
+void m68000_musashi_device::define_state(void)
{
u32 addrmask = (m_cpu_type & MASK_24BIT_SPACE) ? 0xffffff : 0xffffffff;
@@ -1701,7 +1959,6 @@ void m68000_base_device::define_state(void)
state_add(M68K_SR, "SR", m_iotemp).callimport().callexport().mask(m_sr_mask);
state_add(STATE_GENFLAGS, "GENFLAGS", m_iotemp).noshow().callimport().callexport().formatstr("%16s");
state_add(M68K_SP, "SP", m_dar[15]);
- state_add(STATE_GENSP, "GENSP", m_dar[15]).noshow();
state_add(M68K_USP, "USP", m_iotemp).callimport().callexport();
if (m_cpu_type & MASK_020_OR_LATER)
{
@@ -1786,7 +2043,7 @@ void m68000_base_device::define_state(void)
****************/
-void m68000_base_device::init_cpu_m68000(void)
+void m68000_musashi_device::init_cpu_m68000(void)
{
init_cpu_common();
@@ -1802,12 +2059,12 @@ void m68000_base_device::init_cpu_m68000(void)
m_cyc_dbcc_f_noexp = -2;
m_cyc_dbcc_f_exp = 2;
m_cyc_scc_r_true = 2;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 3;
- m_cyc_shift = 1;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 8;
+ m_cyc_shift = 2;
m_cyc_reset = 132;
m_has_pmmu = 0;
- m_has_hmmu = 0;
+ m_has_hmmu = false;
m_has_fpu = 0;
define_state();
@@ -1815,7 +2072,7 @@ void m68000_base_device::init_cpu_m68000(void)
}
-void m68000_base_device::init_cpu_m68008(void)
+void m68000_musashi_device::init_cpu_m68008(void)
{
init_cpu_common();
@@ -1831,9 +2088,9 @@ void m68000_base_device::init_cpu_m68008(void)
m_cyc_dbcc_f_noexp = -2;
m_cyc_dbcc_f_exp = 2;
m_cyc_scc_r_true = 2;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 3;
- m_cyc_shift = 1;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 8;
+ m_cyc_shift = 2;
m_cyc_reset = 132;
m_has_pmmu = 0;
m_has_fpu = 0;
@@ -1843,7 +2100,7 @@ void m68000_base_device::init_cpu_m68008(void)
}
-void m68000_base_device::init_cpu_m68010(void)
+void m68000_musashi_device::init_cpu_m68010(void)
{
init_cpu_common();
m_cpu_type = CPU_TYPE_010;
@@ -1858,9 +2115,9 @@ void m68000_base_device::init_cpu_m68010(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 6;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 3;
- m_cyc_shift = 1;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 8;
+ m_cyc_shift = 2;
m_cyc_reset = 130;
m_has_pmmu = 0;
m_has_fpu = 0;
@@ -1869,7 +2126,7 @@ void m68000_base_device::init_cpu_m68010(void)
}
-void m68000_base_device::init_cpu_m68020(void)
+void m68000_musashi_device::init_cpu_m68020(void)
{
init_cpu_common();
m_cpu_type = CPU_TYPE_020;
@@ -1884,22 +2141,22 @@ void m68000_base_device::init_cpu_m68020(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
define_state();
}
-void m68000_base_device::init_cpu_m68020fpu(void)
+void m68000_musashi_device::init_cpu_m68020fpu(void)
{
init_cpu_m68020();
m_has_fpu = 1;
}
-void m68000_base_device::init_cpu_m68020pmmu(void)
+void m68000_musashi_device::init_cpu_m68020pmmu(void)
{
init_cpu_m68020();
@@ -1912,18 +2169,18 @@ void m68000_base_device::init_cpu_m68020pmmu(void)
-void m68000_base_device::init_cpu_m68020hmmu(void)
+void m68000_musashi_device::init_cpu_m68020hmmu(void)
{
init_cpu_m68020();
- m_has_hmmu = 1;
+ m_has_hmmu = true;
m_has_fpu = 1;
init32hmmu(*m_program, *m_oprogram);
}
-void m68000_base_device::init_cpu_m68ec020(void)
+void m68000_musashi_device::init_cpu_m68ec020(void)
{
init_cpu_common();
@@ -1940,9 +2197,9 @@ void m68000_base_device::init_cpu_m68ec020(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
m_has_pmmu = 0;
m_has_fpu = 0;
@@ -1951,7 +2208,7 @@ void m68000_base_device::init_cpu_m68ec020(void)
}
-void m68000_base_device::init_cpu_m68030(void)
+void m68000_musashi_device::init_cpu_m68030(void)
{
init_cpu_common();
@@ -1968,19 +2225,18 @@ void m68000_base_device::init_cpu_m68030(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
m_has_pmmu = 1;
- m_has_fpu = 1;
define_state();
}
-void m68000_base_device::init_cpu_m68ec030(void)
+void m68000_musashi_device::init_cpu_m68ec030(void)
{
init_cpu_common();
@@ -1997,9 +2253,9 @@ void m68000_base_device::init_cpu_m68ec030(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
m_has_pmmu = 0; /* EC030 lacks the PMMU and is effectively a die-shrink 68020 */
m_has_fpu = 1;
@@ -2009,14 +2265,14 @@ void m68000_base_device::init_cpu_m68ec030(void)
-void m68000_base_device::init_cpu_m68040(void)
+void m68000_musashi_device::init_cpu_m68040(void)
{
init_cpu_common();
m_cpu_type = CPU_TYPE_040;
- init32mmu(*m_program, *m_oprogram);
+ init32mmu_no_smear(*m_program, *m_oprogram);
m_sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m_state_table = m68ki_instruction_state_table[5];
m_cyc_instruction = m68ki_cycles[5];
@@ -2026,25 +2282,24 @@ void m68000_base_device::init_cpu_m68040(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
m_has_pmmu = 1;
- m_has_fpu = 1;
define_state();
}
-void m68000_base_device::init_cpu_m68ec040(void)
+void m68000_musashi_device::init_cpu_m68ec040(void)
{
init_cpu_common();
m_cpu_type = CPU_TYPE_EC040;
- init32(*m_program, *m_oprogram);
+ init32_no_smear(*m_program, *m_oprogram);
m_sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m_state_table = m68ki_instruction_state_table[5];
m_cyc_instruction = m68ki_cycles[5];
@@ -2054,9 +2309,9 @@ void m68000_base_device::init_cpu_m68ec040(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
m_has_pmmu = 0;
m_has_fpu = 0;
@@ -2065,14 +2320,14 @@ void m68000_base_device::init_cpu_m68ec040(void)
}
-void m68000_base_device::init_cpu_m68lc040(void)
+void m68000_musashi_device::init_cpu_m68lc040(void)
{
init_cpu_common();
m_cpu_type = CPU_TYPE_LC040;
- init32mmu(*m_program, *m_oprogram);
+ init32mmu_no_smear(*m_program, *m_oprogram);
m_sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m_state_table = m68ki_instruction_state_table[5];
m_cyc_instruction = m68ki_cycles[5];
@@ -2082,9 +2337,9 @@ void m68000_base_device::init_cpu_m68lc040(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
m_has_pmmu = 1;
m_has_fpu = 0;
@@ -2093,26 +2348,25 @@ void m68000_base_device::init_cpu_m68lc040(void)
}
-void m68000_base_device::init_cpu_scc68070(void)
+void m68000_musashi_device::init_cpu_scc68070(void)
{
init_cpu_common();
m_cpu_type = CPU_TYPE_SCC070;
- // TODO: most of this is subtly different
init16(*m_program, *m_oprogram);
m_sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */
m_state_table = m68ki_instruction_state_table[1];
m_cyc_instruction = m68ki_cycles[1];
m_cyc_exception = m68ki_exception_cycle_table[1];
- m_cyc_bcc_notake_b = -4;
+ m_cyc_bcc_notake_b = 0;
m_cyc_bcc_notake_w = 0;
- m_cyc_dbcc_f_noexp = 0;
- m_cyc_dbcc_f_exp = 6;
+ m_cyc_dbcc_f_noexp = 3;
+ m_cyc_dbcc_f_exp = 3;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 3;
- m_cyc_shift = 1;
- m_cyc_reset = 130;
+ m_cyc_movem_w = 7;
+ m_cyc_movem_l = 11;
+ m_cyc_shift = 3;
+ m_cyc_reset = 154;
m_has_pmmu = 0;
m_has_fpu = 0;
@@ -2120,14 +2374,14 @@ void m68000_base_device::init_cpu_scc68070(void)
}
-void m68000_base_device::init_cpu_fscpu32(void)
+void m68000_musashi_device::init_cpu_fscpu32(void)
{
init_cpu_common();
m_cpu_type = CPU_TYPE_FSCPU32;
- init32(*m_program, *m_oprogram);
+ init16(*m_program, *m_oprogram);
m_sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m_state_table = m68ki_instruction_state_table[6];
m_cyc_instruction = m68ki_cycles[6];
@@ -2137,9 +2391,9 @@ void m68000_base_device::init_cpu_fscpu32(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
define_state();
@@ -2147,7 +2401,7 @@ void m68000_base_device::init_cpu_fscpu32(void)
-void m68000_base_device::init_cpu_coldfire(void)
+void m68000_musashi_device::init_cpu_coldfire(void)
{
init_cpu_common();
@@ -2164,107 +2418,22 @@ void m68000_base_device::init_cpu_coldfire(void)
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 4;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 2;
- m_cyc_movem_l = 2;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 4;
+ m_cyc_movem_l = 4;
+ m_cyc_shift = 1;
m_cyc_reset = 518;
define_state();
}
-std::unique_ptr<util::disasm_interface> m68000_base_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68000);
-}
-
-std::unique_ptr<util::disasm_interface> m68000_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68000);
-}
-
-std::unique_ptr<util::disasm_interface> m68008_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68008);
-}
-
-std::unique_ptr<util::disasm_interface> m68008fn_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68008);
-}
-
-std::unique_ptr<util::disasm_interface> m68010_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68010);
-}
-
-std::unique_ptr<util::disasm_interface> m68ec020_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68020);
-}
-
-std::unique_ptr<util::disasm_interface> m68020_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68020);
-}
-
-std::unique_ptr<util::disasm_interface> m68020fpu_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68020);
-}
-
-std::unique_ptr<util::disasm_interface> m68020pmmu_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68020);
-}
-
-std::unique_ptr<util::disasm_interface> m68020hmmu_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68020);
-}
-
-std::unique_ptr<util::disasm_interface> m68ec030_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68030);
-}
-
-std::unique_ptr<util::disasm_interface> m68030_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68030);
-}
-
-std::unique_ptr<util::disasm_interface> m68ec040_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68040);
-}
-
-std::unique_ptr<util::disasm_interface> m68lc040_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68040);
-}
-
-std::unique_ptr<util::disasm_interface> m68040_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68040);
-}
-
-std::unique_ptr<util::disasm_interface> scc68070_base_device::create_disassembler()
+std::unique_ptr<util::disasm_interface> m68000_musashi_device::create_disassembler()
{
return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68000);
}
-std::unique_ptr<util::disasm_interface> fscpu32_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_68340);
-}
-
-std::unique_ptr<util::disasm_interface> mcf5206e_device::create_disassembler()
-{
- return std::make_unique<m68k_disassembler>(m68k_disassembler::TYPE_COLDFIRE);
-}
-
/* Service an interrupt request and start exception processing */
-void m68000_base_device::m68ki_exception_interrupt(u32 int_level)
+void m68000_musashi_device::m68ki_exception_interrupt(u32 int_level)
{
u32 vector;
u32 sr;
@@ -2284,11 +2453,11 @@ void m68000_base_device::m68ki_exception_interrupt(u32 int_level)
/* Inform the device than an interrupt is taken */
if(m_interrupt_mixer)
- standard_irq_callback(int_level);
+ standard_irq_callback(int_level, m_pc);
else
for(int i=0; i<3; i++)
if(int_level & (1<<i))
- standard_irq_callback(i);
+ standard_irq_callback(i, m_pc);
/* Acknowledge the interrupt by reading the cpu space. */
/* We require the handlers for autovector to return the correct
@@ -2302,7 +2471,7 @@ void m68000_base_device::m68ki_exception_interrupt(u32 int_level)
vector = m_cpu_space->read_word(0xfffffff0 | (int_level << 1)) & 0xff;
/* Start exception processing */
- sr = m68ki_init_exception();
+ sr = m68ki_init_exception(vector);
/* Set the interrupt mask to the level of the one being serviced */
m_int_mask = int_level<<8;
@@ -2332,35 +2501,31 @@ void m68000_base_device::m68ki_exception_interrupt(u32 int_level)
//-------------------------------------------------
-// m68000_base_device - constructor
+// m68000_musashi_device - constructor
//-------------------------------------------------
-m68000_base_device::m68000_base_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock,
+m68000_musashi_device::m68000_musashi_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock,
const device_type type, u32 prg_data_width, u32 prg_address_bits, address_map_constructor internal_map)
- : cpu_device(mconfig, type, tag, owner, clock),
+ : m68000_base_device(mconfig, type, tag, owner, clock),
m_program_config("program", ENDIANNESS_BIG, prg_data_width, prg_address_bits, 0, internal_map),
m_oprogram_config("decrypted_opcodes", ENDIANNESS_BIG, prg_data_width, prg_address_bits, 0, internal_map),
- m_cpu_space_config("cpu space", ENDIANNESS_BIG, prg_data_width, prg_address_bits, 0, address_map_constructor(FUNC(m68000_base_device::default_autovectors_map), this)),
- m_interrupt_mixer(true),
- m_cpu_space_id(AS_CPU_SPACE)
+ m_cpu_space_config("cpu_space", ENDIANNESS_BIG, prg_data_width, prg_address_bits, 0, address_map_constructor(FUNC(m68000_musashi_device::default_autovectors_map), this))
{
clear_all();
}
-m68000_base_device::m68000_base_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock,
+m68000_musashi_device::m68000_musashi_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock,
const device_type type, u32 prg_data_width, u32 prg_address_bits)
- : cpu_device(mconfig, type, tag, owner, clock),
+ : m68000_base_device(mconfig, type, tag, owner, clock),
m_program_config("program", ENDIANNESS_BIG, prg_data_width, prg_address_bits),
m_oprogram_config("decrypted_opcodes", ENDIANNESS_BIG, prg_data_width, prg_address_bits),
- m_cpu_space_config("cpu space", ENDIANNESS_BIG, prg_data_width, prg_address_bits, 0, address_map_constructor(FUNC(m68000_base_device::default_autovectors_map), this)),
- m_interrupt_mixer(true),
- m_cpu_space_id(AS_CPU_SPACE)
+ m_cpu_space_config("cpu_space", ENDIANNESS_BIG, prg_data_width, prg_address_bits, 0, address_map_constructor(FUNC(m68000_musashi_device::default_autovectors_map), this))
{
clear_all();
}
-void m68000_base_device::clear_all()
+void m68000_musashi_device::clear_all()
{
m_cpu_type= 0;
//
@@ -2398,10 +2563,12 @@ void m68000_base_device::clear_all()
m_sr_mask= 0;
m_instr_mode= 0;
m_run_mode= 0;
- m_has_pmmu= 0;
- m_has_hmmu= 0;
- m_pmmu_enabled= 0;
+ m_has_pmmu= false;
+ m_has_hmmu= false;
+ m_pmmu_enabled= false;
m_hmmu_enabled= 0;
+ m_emmu_enabled= false;
+ m_can_instruction_restart= false;
m_has_fpu= 0;
m_fpu_just_reset= 0;
@@ -2410,9 +2577,9 @@ void m68000_base_device::clear_all()
m_cyc_dbcc_f_noexp = 0;
m_cyc_dbcc_f_exp = 0;
m_cyc_scc_r_true = 0;
- m_cyc_movem_w = 0;
- m_cyc_movem_l = 0;
- m_cyc_shift = 0;
+ m_cyc_movem_w = 1;
+ m_cyc_movem_l = 1;
+ m_cyc_shift = 1;
m_cyc_reset = 0;
m_initial_cycles = 0;
@@ -2462,7 +2629,8 @@ void m68000_base_device::clear_all()
m_mmu_tmp_fc = 0;
m_mmu_tmp_rw = 0;
m_mmu_tmp_buserror_address = 0;
- m_mmu_tmp_buserror_occurred = 0;
+ m_mmu_tmp_buserror_occurred = false;
+ m_restart_instruction = false;
m_mmu_tmp_buserror_fc = 0;
m_mmu_tmp_buserror_rw = 0;
@@ -2476,39 +2644,18 @@ void m68000_base_device::clear_all()
m_internal = nullptr;
}
-void m68000_base_device::autovectors_map(address_map &map)
-{
- // Eventually add the sync to E due to vpa
- // 8-bit handlers are used here to be compatible with all bus widths
- map(0x3, 0x3).lr8("avec1", []() -> u8 { return autovector(1); });
- map(0x5, 0x5).lr8("avec2", []() -> u8 { return autovector(2); });
- map(0x7, 0x7).lr8("avec3", []() -> u8 { return autovector(3); });
- map(0x9, 0x9).lr8("avec4", []() -> u8 { return autovector(4); });
- map(0xb, 0xb).lr8("avec5", []() -> u8 { return autovector(5); });
- map(0xd, 0xd).lr8("avec6", []() -> u8 { return autovector(6); });
- map(0xf, 0xf).lr8("avec7", []() -> u8 { return autovector(7); });
-}
-
-void m68000_base_device::default_autovectors_map(address_map &map)
-{
- if(m_cpu_space_id == AS_CPU_SPACE && !has_configured_map(AS_CPU_SPACE)) {
- offs_t mask = make_bitmask<offs_t>(m_program_config.addr_width());
- map(mask - 0xf, mask).m(*this, FUNC(m68000_base_device::autovectors_map));
- }
-}
-
-void m68000_base_device::device_start()
+void m68000_musashi_device::device_start()
{
}
-void m68000_base_device::device_stop()
+void m68000_musashi_device::device_stop()
{
}
-void m68000_base_device::execute_set_input(int inputnum, int state)
+void m68000_musashi_device::execute_set_input(int inputnum, int state)
{
switch (inputnum)
{
@@ -2535,7 +2682,7 @@ void m68000_base_device::execute_set_input(int inputnum, int state)
}
-device_memory_interface::space_config_vector m68000_base_device::memory_space_config() const
+device_memory_interface::space_config_vector m68000_musashi_device::memory_space_config() const
{
if(has_configured_map(AS_OPCODES))
if(m_cpu_space_id == AS_CPU_SPACE)
@@ -2561,254 +2708,7 @@ device_memory_interface::space_config_vector m68000_base_device::memory_space_co
};
}
-
-
-DEFINE_DEVICE_TYPE(M68000, m68000_device, "m68000", "Motorola MC68000")
-DEFINE_DEVICE_TYPE(M68008, m68008_device, "m68008", "Motorola MC68008") // 48-pin plastic or ceramic DIP
-DEFINE_DEVICE_TYPE(M68008FN, m68008fn_device, "m68008fn", "Motorola MC68008FN") // 52-pin PLCC
-DEFINE_DEVICE_TYPE(M68010, m68010_device, "m68010", "Motorola MC68010")
-DEFINE_DEVICE_TYPE(M68EC020, m68ec020_device, "m68ec020", "Motorola MC68EC020")
-DEFINE_DEVICE_TYPE(M68020, m68020_device, "m68020", "Motorola MC68020")
-DEFINE_DEVICE_TYPE(M68020FPU, m68020fpu_device, "m68020fpu", "Motorola MC68020FPU")
-DEFINE_DEVICE_TYPE(M68020PMMU, m68020pmmu_device, "m68020pmmu", "Motorola MC68020PMMU")
-DEFINE_DEVICE_TYPE(M68020HMMU, m68020hmmu_device, "m68020hmmu", "Motorola MC68020HMMU")
-DEFINE_DEVICE_TYPE(M68EC030, m68ec030_device, "m68ec030", "Motorola MC68EC030")
-DEFINE_DEVICE_TYPE(M68030, m68030_device, "m68030", "Motorola MC68030")
-DEFINE_DEVICE_TYPE(M68EC040, m68ec040_device, "m68ec040", "Motorola MC68EC040")
-DEFINE_DEVICE_TYPE(M68LC040, m68lc040_device, "m68lc040", "Motorola MC68LC040")
-DEFINE_DEVICE_TYPE(M68040, m68040_device, "m68040", "Motorola MC68040")
-DEFINE_DEVICE_TYPE(FSCPU32, fscpu32_device, "fscpu32", "Freescale CPU32 Core")
-DEFINE_DEVICE_TYPE(MCF5206E, mcf5206e_device, "mcf5206e", "Freescale MCF5206E")
-
-m68000_device::m68000_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_device(mconfig, M68000, tag, owner, clock)
-{
-}
-
-m68000_device::m68000_device(const machine_config &mconfig, const device_type type, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, type, 16,24)
-{
-}
-
-void m68000_device::device_start()
-{
- init_cpu_m68000();
-}
-
-m68000_device::m68000_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock,
- const device_type type, u32 prg_data_width, u32 prg_address_bits, address_map_constructor internal_map)
- : m68000_base_device(mconfig, tag, owner, clock, type, prg_data_width, prg_address_bits, internal_map)
-{
-}
-
-
-
-
-
-
-/* m68008_device */
-
-m68008_device::m68008_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68008, 8,20)
-{
-}
-
-void m68008_device::device_start()
-{
- init_cpu_m68008();
-}
-
-
-m68008fn_device::m68008fn_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68008FN, 8,22)
-{
-}
-
-void m68008fn_device::device_start()
-{
- init_cpu_m68008();
-}
-
-
-
-m68010_device::m68010_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68010, 16,24)
-{
-}
-
-void m68010_device::device_start()
-{
- init_cpu_m68010();
-}
-
-
-
-m68020_device::m68020_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68020, 32,32)
-{
-}
-
-void m68020_device::device_start()
-{
- init_cpu_m68020();
-}
-
-
-m68020fpu_device::m68020fpu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68020FPU, 32,32)
-{
-}
-
-void m68020fpu_device::device_start()
-{
- init_cpu_m68020fpu();
-}
-
-// 68020 with 68851 PMMU
-m68020pmmu_device::m68020pmmu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68020PMMU, 32,32)
-{
-}
-
-void m68020pmmu_device::device_start()
-{
- init_cpu_m68020pmmu();
-}
-
-bool m68020hmmu_device::memory_translate(int space, int intention, offs_t &address)
-{
- /* only applies to the program address space and only does something if the MMU's enabled */
- {
- if ((space == AS_PROGRAM) && (m_hmmu_enabled))
- {
- address = hmmu_translate_addr(address);
- }
- }
- return true;
-}
-
-
-// 68020 with Apple HMMU & 68881 FPU
-// case CPUINFO_FCT_TRANSLATE: info->translate = CPU_TRANSLATE_NAME(m68khmmu); break;
-m68020hmmu_device::m68020hmmu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68020HMMU, 32,32)
-{
-}
-
-void m68020hmmu_device::device_start()
-{
- init_cpu_m68020hmmu();
-}
-
-
-m68ec020_device::m68ec020_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68EC020, 32,24)
-{
-}
-
-void m68ec020_device::device_start()
-{
- init_cpu_m68ec020();
-}
-
-m68030_device::m68030_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68030, 32,32)
-{
-}
-
-void m68030_device::device_start()
-{
- init_cpu_m68030();
-}
-
-m68ec030_device::m68ec030_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68EC030, 32,32)
-{
-}
-
-void m68ec030_device::device_start()
-{
- init_cpu_m68ec030();
-}
-
-m68040_device::m68040_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68040, 32,32)
-{
-}
-
-
-void m68040_device::device_start()
-{
- init_cpu_m68040();
-}
-
-
-
-m68ec040_device::m68ec040_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68EC040, 32,32)
-{
-}
-
-void m68ec040_device::device_start()
-{
- init_cpu_m68ec040();
-}
-
-
-
-m68lc040_device::m68lc040_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, M68LC040, 32,32)
-{
-}
-
-void m68lc040_device::device_start()
-{
- init_cpu_m68lc040();
-}
-
-
-scc68070_base_device::scc68070_base_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock,
- const device_type type, address_map_constructor internal_map)
- : m68000_base_device(mconfig, tag, owner, clock, type, 16,32, internal_map)
-{
-}
-
-void scc68070_base_device::device_start()
-{
- init_cpu_scc68070();
-}
-
-
-fscpu32_device::fscpu32_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, FSCPU32, 32,32)
-{
-}
-
-fscpu32_device::fscpu32_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock,
- const device_type type, u32 prg_data_width, u32 prg_address_bits, address_map_constructor internal_map)
- : m68000_base_device(mconfig, tag, owner, clock, type, prg_data_width, prg_address_bits, internal_map)
-{
-}
-
-
-void fscpu32_device::device_start()
-{
- init_cpu_fscpu32();
-}
-
-
-
-mcf5206e_device::mcf5206e_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
- : m68000_base_device(mconfig, tag, owner, clock, MCF5206E, 32,32)
-{
-}
-
-void mcf5206e_device::device_start()
-{
- init_cpu_coldfire();
-}
-
-void m68000_base_device::m68ki_set_one(unsigned short opcode, u16 state, const opcode_handler_struct &s)
+void m68000_musashi_device::m68ki_set_one(unsigned short opcode, u16 state, const opcode_handler_struct &s)
{
for(int i=0; i<NUM_CPU_TYPES; i++)
if(s.cycles[i] != 0xff) {
@@ -2817,7 +2717,7 @@ void m68000_base_device::m68ki_set_one(unsigned short opcode, u16 state, const o
}
}
-void m68000_base_device::m68ki_build_opcode_table()
+void m68000_musashi_device::m68ki_build_opcode_table()
{
for(int i = 0; i < 0x10000; i++)
{
@@ -2840,3 +2740,17 @@ void m68000_base_device::m68ki_build_opcode_table()
} while(extraval);
}
}
+
+void m68000_musashi_device::default_autovectors_map(address_map &map)
+{
+ if(m_cpu_space_id == AS_CPU_SPACE && !has_configured_map(AS_CPU_SPACE)) {
+ offs_t mask = make_bitmask<offs_t>(m_program_config.addr_width());
+ map(mask - 0xf, mask).m(*this, FUNC(m68000_musashi_device::autovectors_map));
+ }
+}
+
+bool m68000_musashi_device::supervisor_mode() const noexcept
+{
+ return m_s_flag;
+}
+