diff options
Diffstat (limited to 'src/devices/cpu/m68000/m68kcpu.cpp')
-rw-r--r-- | src/devices/cpu/m68000/m68kcpu.cpp | 1164 |
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; +} + |