From a41b3c38989cda09a607fded2fbb4192a5c83395 Mon Sep 17 00:00:00 2001 From: Olivier Galibert Date: Fri, 9 Mar 2012 18:50:18 +0000 Subject: [PATCH] tms57002: Modernize [O. Galibert] --- .gitattributes | 1 - src/emu/cpu/cpu.mak | 2 - src/emu/cpu/tms57002/57002dsm.c | 19 +- src/emu/cpu/tms57002/tms57002.c | 967 +++++++++++------------------- src/emu/cpu/tms57002/tms57002.h | 221 ++++++- src/emu/cpu/tms57002/tms57kdec.c | 123 +++- src/emu/cpu/tms57002/tms57kpr.h | 171 ------ src/emu/cpu/tms57002/tmsinstr.lst | 200 +++--- src/emu/cpu/tms57002/tmsmake.c | 124 ++-- src/mame/drivers/konamigx.c | 14 +- 10 files changed, 830 insertions(+), 1012 deletions(-) delete mode 100644 src/emu/cpu/tms57002/tms57kpr.h diff --git a/.gitattributes b/.gitattributes index 219f4f2b4f9..a49ca3d2993 100644 --- a/.gitattributes +++ b/.gitattributes @@ -532,7 +532,6 @@ src/emu/cpu/tms57002/57002dsm.c svneol=native#text/plain src/emu/cpu/tms57002/tms57002.c svneol=native#text/plain src/emu/cpu/tms57002/tms57002.h svneol=native#text/plain src/emu/cpu/tms57002/tms57kdec.c svneol=native#text/plain -src/emu/cpu/tms57002/tms57kpr.h svneol=native#text/plain src/emu/cpu/tms57002/tmsinstr.lst svneol=native#text/plain src/emu/cpu/tms57002/tmsmake.c svneol=native#text/plain src/emu/cpu/tms7000/7000dasm.c svneol=native#text/plain diff --git a/src/emu/cpu/cpu.mak b/src/emu/cpu/cpu.mak index 900e7567ff8..9a4c3475b81 100644 --- a/src/emu/cpu/cpu.mak +++ b/src/emu/cpu/cpu.mak @@ -1712,12 +1712,10 @@ endif $(CPUOBJ)/tms57002/tms57002.o: $(CPUSRC)/tms57002/tms57002.c \ $(CPUSRC)/tms57002/tms57002.h \ - $(CPUSRC)/tms57002/tms57kpr.h \ $(CPUOBJ)/tms57002/tms57002.inc $(CPUOBJ)/tms57002/tms57kdec.o: $(CPUSRC)/tms57002/tms57kdec.c \ $(CPUSRC)/tms57002/tms57002.h \ - $(CPUSRC)/tms57002/tms57kpr.h \ $(CPUOBJ)/tms57002/tms57002.inc $(CPUOBJ)/tms57002/57002dsm.o: $(CPUSRC)/tms57002/57002dsm.c \ diff --git a/src/emu/cpu/tms57002/57002dsm.c b/src/emu/cpu/tms57002/57002dsm.c index 1d5a3778dbf..d3c72a963c9 100644 --- a/src/emu/cpu/tms57002/57002dsm.c +++ b/src/emu/cpu/tms57002/57002dsm.c @@ -2,13 +2,7 @@ #include "debugger.h" #include "tms57002.h" -#ifdef __GNUC__ -#define noinline __attribute__((noinline)) -#else -#define noinline /* */ -#endif - -static const char *tms57002_get_memadr(UINT32 opcode, char type) +const char *tms57002_device::get_memadr(UINT32 opcode, char type) { static char buff[2][10]; static int index = 0; @@ -31,8 +25,17 @@ static const char *tms57002_get_memadr(UINT32 opcode, char type) return buf; } +UINT32 tms57002_device::disasm_min_opcode_bytes() const +{ + return 4; +} -CPU_DISASSEMBLE(tms57002) +UINT32 tms57002_device::disasm_max_opcode_bytes() const +{ + return 4; +} + +offs_t tms57002_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) { UINT32 opcode = opram[0] | (opram[1] << 8) | (opram[2] << 16); UINT8 fa = opcode >> 18; diff --git a/src/emu/cpu/tms57002/tms57002.c b/src/emu/cpu/tms57002/tms57002.c index df63908023b..9e9456aa617 100644 --- a/src/emu/cpu/tms57002/tms57002.c +++ b/src/emu/cpu/tms57002/tms57002.c @@ -1,439 +1,299 @@ +/*************************************************************************** + + asap.h + + TMS57002 "DASP" emulator. + +**************************************************************************** + + Copyright Olivier Galibert + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + * Neither the name 'MAME' nor the names of its contributors may be + used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + +***************************************************************************/ + +#define ADDRESS_MAP_MODERN + #include "emu.h" #include "debugger.h" #include "tms57002.h" -#include "tms57kpr.h" -INLINE tms57002_t *get_safe_token(device_t *device) +const device_type TMS57002 = &device_creator; + +// Can't use a DEVICE_ADDRESS_MAP, not yet anyway +static ADDRESS_MAP_START(internal_pgm, AS_PROGRAM, 32, tms57002_device) + AM_RANGE(0x000, 0x3ff) AM_RAM +ADDRESS_MAP_END + +tms57002_device::tms57002_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : cpu_device(mconfig, TMS57002, "TMS57002", tag, owner, clock), + program_config("program", ENDIANNESS_LITTLE, 32, 8, -2, ADDRESS_MAP_NAME(internal_pgm)), + data_config("data", ENDIANNESS_LITTLE, 8, 20) { - assert(device != NULL); - assert(device->type() == TMS57002); - return (tms57002_t *)downcast(device)->token(); } -static void tms57002_cache_flush(tms57002_t *s); -WRITE8_DEVICE_HANDLER(tms57002_pload_w) +WRITE8_MEMBER(tms57002_device::pload_w) { - tms57002_t *s = get_safe_token(device); - UINT8 olds = s->sti; - + UINT8 olds = sti; if(data) - s->sti &= ~IN_PLOAD; + sti &= ~IN_PLOAD; else - s->sti |= IN_PLOAD; - - if(olds ^ s->sti) - s->hidx = 0; + sti |= IN_PLOAD; + if(olds ^ sti) + hidx = 0; } -WRITE8_DEVICE_HANDLER(tms57002_cload_w) +WRITE8_MEMBER(tms57002_device::cload_w) { - tms57002_t *s = get_safe_token(device); - UINT8 olds = s->sti; + UINT8 olds = sti; if(data) - s->sti &= ~IN_CLOAD; + sti &= ~IN_CLOAD; else - s->sti |= IN_CLOAD; - if(olds ^ s->sti) - s->hidx = 0; + sti |= IN_CLOAD; + if(olds ^ sti) + hidx = 0; } -static CPU_RESET(tms57002) +void tms57002_device::device_reset() { - tms57002_t *s = get_safe_token(device); + sti = (sti & ~(SU_MASK|S_READ|S_WRITE|S_BRANCH|S_HOST)) | (SU_ST0|S_IDLE); + pc = 0; + ca = 0; + hidx = 0; + id = 0; + ba0 = 0; + ba1 = 0; + st0 &= ~(ST0_INCS | ST0_DIRI | ST0_FI | ST0_SIM | ST0_PLRI | + ST0_PBCI | ST0_DIRO | ST0_FO | ST0_SOM | ST0_PLRO | + ST0_PBCO | ST0_CNS); + st1 &= ~(ST1_AOV | ST1_SFAI | ST1_SFAO | ST1_MOVM | ST1_MOV | + ST1_SFMA | ST1_SFMO | ST1_RND | ST1_CRM | ST1_DBP); - s->sti = (s->sti & ~(SU_MASK|S_READ|S_WRITE|S_BRANCH|S_HOST)) | (SU_ST0|S_IDLE); - s->pc = 0; - s->ca = 0; - s->hidx = 0; - s->id = 0; - s->ba0 = 0; - s->ba1 = 0; - s->st0 &= ~(ST0_INCS | ST0_DIRI | ST0_FI | ST0_SIM | ST0_PLRI | - ST0_PBCI | ST0_DIRO | ST0_FO | ST0_SOM | ST0_PLRO | - ST0_PBCO | ST0_CNS); - s->st1 &= ~(ST1_AOV | ST1_SFAI | ST1_SFAO | ST1_MOVM | ST1_MOV | - ST1_SFMA | ST1_SFMO | ST1_RND | ST1_CRM | ST1_DBP); + xba = 0; // Not sure but makes sense - s->xba = 0; // Not sure but makes sense - - tms57002_cache_flush(s); + cache_flush(); } - -WRITE8_DEVICE_HANDLER(tms57002_data_w) +WRITE8_MEMBER(tms57002_device::data_w) { - tms57002_t *s = get_safe_token(device); - - switch(s->sti & (IN_PLOAD|IN_CLOAD)) { + switch(sti & (IN_PLOAD|IN_CLOAD)) { case 0: - s->hidx = 0; - s->sti &= ~SU_CVAL; + hidx = 0; + sti &= ~SU_CVAL; break; case IN_PLOAD: - s->host[s->hidx++] = data; - if(s->hidx >= 3) { - UINT32 val = (s->host[0]<<16) | (s->host[1]<<8) | s->host[2]; - s->hidx = 0; + host[hidx++] = data; + if(hidx >= 3) { + UINT32 val = (host[0]<<16) | (host[1]<<8) | host[2]; + hidx = 0; - switch(s->sti & SU_MASK) { + switch(sti & SU_MASK) { case SU_ST0: - s->st0 = val; - s->sti = (s->sti & ~SU_MASK) | SU_ST1; + st0 = val; + sti = (sti & ~SU_MASK) | SU_ST1; break; case SU_ST1: - s->st1 = val; - s->sti = (s->sti & ~SU_MASK) | SU_PRG; + st1 = val; + sti = (sti & ~SU_MASK) | SU_PRG; break; case SU_PRG: - s->program->write_dword((s->pc++) << 2, val); + program->write_dword((pc++) << 2, val); break; } } break; case IN_CLOAD: - if(s->sti & SU_CVAL) { - s->host[s->hidx++] = data; - if(s->hidx >= 4) { - UINT32 val = (s->host[0]<<24) | (s->host[1]<<16) | (s->host[2]<<8) | s->host[3]; - s->cmem[s->sa] = val; - s->sti &= ~SU_CVAL; - s->allow_update = 0; + if(sti & SU_CVAL) { + host[hidx++] = data; + if(hidx >= 4) { + UINT32 val = (host[0]<<24) | (host[1]<<16) | (host[2]<<8) | host[3]; + cmem[sa] = val; + sti &= ~SU_CVAL; + allow_update = 0; } } else { - s->sa = data; - s->hidx = 0; - s->sti |= SU_CVAL; + sa = data; + hidx = 0; + sti |= SU_CVAL; } break; case IN_PLOAD|IN_CLOAD: - s->host[s->hidx++] = data; - if(s->hidx >= 4) { - UINT32 val = (s->host[0]<<24) | (s->host[1]<<16) | (s->host[2]<<8) | s->host[3]; - s->hidx = 0; - s->cmem[s->ca++] = val; + host[hidx++] = data; + if(hidx >= 4) { + UINT32 val = (host[0]<<24) | (host[1]<<16) | (host[2]<<8) | host[3]; + hidx = 0; + cmem[ca++] = val; } break; }; } -READ8_DEVICE_HANDLER(tms57002_data_r) +READ8_MEMBER(tms57002_device::data_r) { - tms57002_t *s = get_safe_token(device); UINT8 res; - if(!(s->sti & S_HOST)) + if(!(sti & S_HOST)) return 0xff; - res = s->host[s->hidx]; - s->hidx++; - if(s->hidx == 4) { - s->hidx = 0; - s->sti &= ~S_HOST; + res = host[hidx]; + hidx++; + if(hidx == 4) { + hidx = 0; + sti &= ~S_HOST; } return res; } -READ8_DEVICE_HANDLER(tms57002_empty_r) +READ8_MEMBER(tms57002_device::empty_r) { return 1; } -READ8_DEVICE_HANDLER(tms57002_dready_r) +READ8_MEMBER(tms57002_device::dready_r) { - tms57002_t *s = get_safe_token(device); - return s->sti & S_HOST ? 0 : 1; + return sti & S_HOST ? 0 : 1; } -void tms57002_sync(device_t *device) +void tms57002_device::sync() { - tms57002_t *s = get_safe_token(device); - - if(s->sti & (IN_PLOAD | IN_CLOAD)) + if(sti & (IN_PLOAD | IN_CLOAD)) return; - s->allow_update = 1; - s->pc = 0; - s->ca = 0; - s->id = 0; - if(!(s->st0 & ST0_INCS)) { - s->ba0--; - s->ba1++; + allow_update = 1; + pc = 0; + ca = 0; + id = 0; + if(!(st0 & ST0_INCS)) { + ba0--; + ba1++; } - s->xba = (s->xba-1) & 0x7ffff; - s->st1 &= ~(ST1_AOV | ST1_MOV); - s->sti &= ~S_IDLE; + xba = (xba-1) & 0x7ffff; + st1 &= ~(ST1_AOV | ST1_MOV); + sti &= ~S_IDLE; } -#ifdef UNUSED_FUNCTION -static UINT32 tms57002_read_c(tms57002_t *s, UINT8 index) +void tms57002_device::xm_init() { - UINT32 v = s->cmem[index]; - if((s->st1 & ST1_CRM) != ST1_CRM_32) { - if((s->st1 & ST1_CRM) == ST1_CRM_16H) - v &= 0xffff0000; - else if((s->st1 & ST1_CRM) == ST1_CRM_16L) - v <<= 16; - } - return v; -} - -static void tms57002_write_c(tms57002_t *s, UINT8 index, UINT32 v) -{ - s->cmem[index] = v; -} - -static void tms57002_write_d(tms57002_t *s, UINT8 index, UINT32 v) -{ - if(s->st1 & ST1_DBP) - s->dmem1[(s->ba1 + index) & 0x1f] = v; - else - s->dmem0[(s->ba0 + index) & 0xff] = v; -} - -static UINT32 tms57002_read_d(tms57002_t *s, UINT8 index) -{ - if(s->st1 & ST1_DBP) - return s->dmem1[(s->ba1 + index) & 0x1f]; - else - return s->dmem0[(s->ba0 + index) & 0xff]; -} - -static void tms57002_opc_write_c(tms57002_t *s, UINT32 opcode, UINT32 v) -{ - if(opcode & 0x400) { - if(opcode & 0x100) - tms57002_write_c(s, opcode & 0xff, v); - else if(opcode & 0x80) - tms57002_write_c(s, s->ca++, v); - else - tms57002_write_c(s, s->ca, v); - } else if(opcode & 0x200) - tms57002_write_c(s, s->ca++, v); - else - tms57002_write_c(s, s->ca, v); -} - -static UINT32 tms57002_opc_read_c(tms57002_t *s, UINT32 opcode) -{ - if(opcode & 0x400) { - if(opcode & 0x100) - return tms57002_read_c(s, opcode & 0xff); - else if(opcode & 0x80) - return tms57002_read_c(s, s->ca++); - else - return tms57002_read_c(s, s->ca); - } else if(opcode & 0x200) - return tms57002_read_c(s, s->ca++); - else - return tms57002_read_c(s, s->ca); -} - -static void tms57002_opc_write_d(tms57002_t *s, UINT32 opcode, UINT32 v) -{ - if(!(opcode & 0x400)) { - if(opcode & 0x100) - tms57002_write_d(s, opcode & 0xff, v); - else if(opcode & 0x80) - tms57002_write_d(s, s->id++, v); - else - tms57002_write_d(s, s->id, v); - } else if(opcode & 0x200) - tms57002_write_d(s, s->id++, v); - else - tms57002_write_d(s, s->id, v); -} - -static UINT32 tms57002_opc_read_d(tms57002_t *s, UINT32 opcode) -{ - if(!(opcode & 0x400)) { - if(opcode & 0x100) - return tms57002_read_d(s, opcode & 0xff); - else if(opcode & 0x80) - return tms57002_read_d(s, s->id++); - else - return tms57002_read_d(s, s->id); - } else if(opcode & 0x200) - return tms57002_read_d(s, s->id++); - else - return tms57002_read_d(s, s->id); -} -#endif - -static void tms57002_xm_init(tms57002_t *s) -{ - UINT32 adr = s->xoa + s->xba; + UINT32 adr = xoa + xba; UINT32 mask = 0; - switch(s->st0 & ST0_M) { + switch(st0 & ST0_M) { case ST0_M_64K: mask = 0x0ffff; break; case ST0_M_256K: mask = 0x3ffff; break; case ST0_M_1M: mask = 0xfffff; break; } - if(s->st0 & ST0_WORD) + if(st0 & ST0_WORD) adr <<= 2; else adr <<= 1; - if(!(s->st0 & ST0_SEL)) + if(!(st0 & ST0_SEL)) adr <<= 1; - s->xm_adr = adr & mask; + xm_adr = adr & mask; } -static void tms57002_xm_step_read(tms57002_t *s) +void tms57002_device::xm_step_read() { - UINT32 adr = s->xm_adr; - UINT8 v = s->data->read_byte(adr); + UINT32 adr = xm_adr; + UINT8 v = data->read_byte(adr); int done; - if(s->st0 & ST0_WORD) { - if(s->st0 & ST0_SEL) { + if(st0 & ST0_WORD) { + if(st0 & ST0_SEL) { int off = (adr & 3) << 3; - s->xrd = (s->xrd & ~(0xff << off)) | (v << off); + xrd = (xrd & ~(0xff << off)) | (v << off); done = off == 16; } else { int off = (adr & 7) << 2; - s->xrd = (s->xrd & ~(0xf << off)) | ((v & 0xf) << off); + xrd = (xrd & ~(0xf << off)) | ((v & 0xf) << off); done = off == 20; } } else { - if(s->st0 & ST0_SEL) { + if(st0 & ST0_SEL) { int off = (adr & 1) << 3; - s->xrd = (s->xrd & ~(0xff << off)) | (v << off); + xrd = (xrd & ~(0xff << off)) | (v << off); done = off == 8; if(done) - s->xrd &= 0x00ffff; + xrd &= 0x00ffff; } else { int off = (adr & 3) << 2; - s->xrd = (s->xrd & ~(0xf << off)) | ((v & 0xf) << off); + xrd = (xrd & ~(0xf << off)) | ((v & 0xf) << off); done = off == 12; if(done) - s->xrd &= 0x00ffff; + xrd &= 0x00ffff; } } if(done) { - s->sti &= ~S_READ; - s->xm_adr = 0; + sti &= ~S_READ; + xm_adr = 0; } else - s->xm_adr = adr+1; + xm_adr = adr+1; } -static void tms57002_xm_step_write(tms57002_t *s) +void tms57002_device::xm_step_write() { - UINT32 adr = s->xm_adr; + UINT32 adr = xm_adr; UINT8 v; int done; - if(s->st0 & ST0_WORD) { - if(s->st0 & ST0_SEL) { + if(st0 & ST0_WORD) { + if(st0 & ST0_SEL) { int off = (adr & 3) << 3; - v = s->xwr >> off; + v = xwr >> off; done = off == 16; } else { int off = (adr & 7) << 2; - v = (s->xwr >> off) & 0xf; + v = (xwr >> off) & 0xf; done = off == 20; } } else { - if(s->st0 & ST0_SEL) { + if(st0 & ST0_SEL) { int off = (adr & 1) << 3; - v = s->xwr >> off; + v = xwr >> off; done = off == 8; } else { int off = (adr & 3) << 2; - v = (s->xwr >> off) & 0xf; + v = (xwr >> off) & 0xf; done = off == 12; } } - s->data->write_byte(adr, v); + data->write_byte(adr, v); if(done) { - s->sti &= ~S_WRITE; - s->xm_adr = 0; + sti &= ~S_WRITE; + xm_adr = 0; } else - s->xm_adr = adr+1; + xm_adr = adr+1; } -#ifdef UNUSED_FUNCTION -static UINT32 tms57002_aacc_to_output(tms57002_t *s) +INT64 tms57002_device::macc_to_output_0(INT64 rounding, UINT64 rmask) { - if(s->st1 & ST1_SFAO) - return s->aacc << 7; - else - return s->aacc; -} - -static INT64 tms57002_macc_to_output(tms57002_t *s) -{ - INT64 m = s->macc; - UINT64 m1; - int over = 0, rmode; - static const INT64 rounding[8] = { - 0, - 1LL << (48-32-1), - 1LL << (48-24-1), - 1LL << (48-30-1), - 1LL << (48-16-1), - 0, 0, 0 - }; - static const UINT64 rmask[8] = { - ~0ULL, - (~0ULL) << (48-32), - (~0ULL) << (48-24), - (~0ULL) << (48-30), - (~0ULL) << (48-16), - ~0ULL, ~0ULL, ~0ULL - }; - - // Overflow detection and shifting - switch((s->st1 & ST1_SFMO) >> ST1_SFMO_SHIFT) { - case 0: // sfmo 0 - m1 = m & 0xf800000000000ULL; - if(m1 && m1 != 0xf800000000000ULL) - over = 1; - break; - case 1: // sfmo 2 - m1 = m & 0xfe00000000000ULL; - if(m1 && m1 != 0xfe00000000000ULL) - over = 1; - m <<= 2; - break; - case 2: // sfmo 4 - m1 = m & 0xff80000000000ULL; - if(m1 && m1 != 0xff80000000000ULL) - over = 1; - m <<= 4; - break; - case 3: // sfmo -8 - m >>= 8; - break; - } - - // Rounder - rmode = (s->st1 & ST1_RND) >> ST1_RND_SHIFT; - m = (m + rounding[rmode]) & rmask[rmode]; - - // Second overflow detection - m1 = m & 0xf800000000000ULL; - if(m1 && m1 != 0xf800000000000ULL) - over = 1; - - // Overflow handling - if(over) { - s->st1 |= ST1_MOV; - if(s->st1 & ST1_MOVM) { - if(m & 0x8000000000000ULL) - m = 0xffff800000000000ULL; - else - m = 0x00007fffffffffffULL; - } - } - return m; -} -#endif - -static noinline INT64 tms57002_macc_to_output_0(tms57002_t *s, INT64 rounding, UINT64 rmask) -{ - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -451,14 +311,14 @@ static noinline INT64 tms57002_macc_to_output_0(tms57002_t *s, INT64 rounding, U // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; } return m; } -static noinline INT64 tms57002_macc_to_output_1(tms57002_t *s, INT64 rounding, UINT64 rmask) +INT64 tms57002_device::macc_to_output_1(INT64 rounding, UINT64 rmask) { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -477,14 +337,14 @@ static noinline INT64 tms57002_macc_to_output_1(tms57002_t *s, INT64 rounding, U // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; } return m; } -static noinline INT64 tms57002_macc_to_output_2(tms57002_t *s, INT64 rounding, UINT64 rmask) +INT64 tms57002_device::macc_to_output_2(INT64 rounding, UINT64 rmask) { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -503,14 +363,14 @@ static noinline INT64 tms57002_macc_to_output_2(tms57002_t *s, INT64 rounding, U // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; } return m; } -static noinline INT64 tms57002_macc_to_output_3(tms57002_t *s, INT64 rounding, UINT64 rmask) +INT64 tms57002_device::macc_to_output_3(INT64 rounding, UINT64 rmask) { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -526,14 +386,14 @@ static noinline INT64 tms57002_macc_to_output_3(tms57002_t *s, INT64 rounding, U // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; } return m; } -static noinline INT64 tms57002_macc_to_output_0s(tms57002_t *s, INT64 rounding, UINT64 rmask) +INT64 tms57002_device::macc_to_output_0s(INT64 rounding, UINT64 rmask) { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -551,7 +411,7 @@ static noinline INT64 tms57002_macc_to_output_0s(tms57002_t *s, INT64 rounding, // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; if(m & 0x8000000000000ULL) m = 0xffff800000000000ULL; else @@ -560,9 +420,9 @@ static noinline INT64 tms57002_macc_to_output_0s(tms57002_t *s, INT64 rounding, return m; } -static noinline INT64 tms57002_macc_to_output_1s(tms57002_t *s, INT64 rounding, UINT64 rmask) +INT64 tms57002_device::macc_to_output_1s(INT64 rounding, UINT64 rmask) { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -581,7 +441,7 @@ static noinline INT64 tms57002_macc_to_output_1s(tms57002_t *s, INT64 rounding, // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; if(m & 0x8000000000000ULL) m = 0xffff800000000000ULL; else @@ -590,9 +450,9 @@ static noinline INT64 tms57002_macc_to_output_1s(tms57002_t *s, INT64 rounding, return m; } -static noinline INT64 tms57002_macc_to_output_2s(tms57002_t *s, INT64 rounding, UINT64 rmask) +INT64 tms57002_device::macc_to_output_2s(INT64 rounding, UINT64 rmask) { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -611,7 +471,7 @@ static noinline INT64 tms57002_macc_to_output_2s(tms57002_t *s, INT64 rounding, // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; if(m & 0x8000000000000ULL) m = 0xffff800000000000ULL; else @@ -620,9 +480,9 @@ static noinline INT64 tms57002_macc_to_output_2s(tms57002_t *s, INT64 rounding, return m; } -static noinline INT64 tms57002_macc_to_output_3s(tms57002_t *s, INT64 rounding, UINT64 rmask) +INT64 tms57002_device::macc_to_output_3s(INT64 rounding, UINT64 rmask) { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; int over = 0; @@ -638,7 +498,7 @@ static noinline INT64 tms57002_macc_to_output_3s(tms57002_t *s, INT64 rounding, // Overflow handling if(over) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; if(m & 0x8000000000000ULL) m = 0xffff800000000000ULL; else @@ -647,101 +507,59 @@ static noinline INT64 tms57002_macc_to_output_3s(tms57002_t *s, INT64 rounding, return m; } -#ifdef UNUSED_FUNCTION -static INT64 tms57002_check_macc_overflow(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_0() { - INT64 m = s->macc; - UINT64 m1; - int over = 0; - - // Overflow detection - switch((s->st1 & ST1_SFMO) >> ST1_SFMO_SHIFT) { - case 0: // sfmo 0 - m1 = m & 0xf800000000000ULL; - if(m1 && m1 != 0xf800000000000ULL) - over = 1; - break; - case 1: // sfmo 2 - m1 = m & 0xfe00000000000ULL; - if(m1 && m1 != 0xfe00000000000ULL) - over = 1; - break; - case 2: // sfmo 4 - m1 = m & 0xff80000000000ULL; - if(m1 && m1 != 0xff80000000000ULL) - over = 1; - break; - case 3: // sfmo -8 - break; - } - - // Overflow handling - if(over) { - s->st1 |= ST1_MOV; - if(s->st1 & ST1_MOVM) { - if(m & 0x8000000000000ULL) - m = 0xffff800000000000ULL; - else - m = 0x00007fffffffffffULL; - } - } - return m; -} -#endif - -static noinline INT64 tms57002_check_macc_overflow_0(tms57002_t *s) -{ - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; // Overflow detection m1 = m & 0xf800000000000ULL; if(m1 && m1 != 0xf800000000000ULL) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; } return m; } -static noinline INT64 tms57002_check_macc_overflow_1(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_1() { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; // Overflow detection m1 = m & 0xfe00000000000ULL; if(m1 && m1 != 0xfe00000000000ULL) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; } return m; } -static noinline INT64 tms57002_check_macc_overflow_2(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_2() { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; // Overflow detection m1 = m & 0xff80000000000ULL; if(m1 && m1 != 0xff80000000000ULL) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; } return m; } -static INT64 tms57002_check_macc_overflow_3(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_3() { - return s->macc; + return macc; } -static noinline INT64 tms57002_check_macc_overflow_0s(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_0s() { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; // Overflow detection m1 = m & 0xf800000000000ULL; if(m1 && m1 != 0xf800000000000ULL) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; if(m & 0x8000000000000ULL) m = 0xffff800000000000ULL; else @@ -750,15 +568,15 @@ static noinline INT64 tms57002_check_macc_overflow_0s(tms57002_t *s) return m; } -static noinline INT64 tms57002_check_macc_overflow_1s(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_1s() { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; // Overflow detection m1 = m & 0xfe00000000000ULL; if(m1 && m1 != 0xfe00000000000ULL) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; if(m & 0x8000000000000ULL) m = 0xffff800000000000ULL; else @@ -767,15 +585,15 @@ static noinline INT64 tms57002_check_macc_overflow_1s(tms57002_t *s) return m; } -static noinline INT64 tms57002_check_macc_overflow_2s(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_2s() { - INT64 m = s->macc; + INT64 m = macc; UINT64 m1; // Overflow detection m1 = m & 0xff80000000000ULL; if(m1 && m1 != 0xff80000000000ULL) { - s->st1 |= ST1_MOV; + st1 |= ST1_MOV; if(m & 0x8000000000000ULL) m = 0xffff800000000000ULL; else @@ -784,279 +602,153 @@ static noinline INT64 tms57002_check_macc_overflow_2s(tms57002_t *s) return m; } -static INT64 tms57002_check_macc_overflow_3s(tms57002_t *s) +INT64 tms57002_device::check_macc_overflow_3s() { - return s->macc; + return macc; } -#ifdef UNUSED_FUNCTION -static INT64 tms57002_macc_to_loop(tms57002_t *s) -{ - INT64 m = s->macc; - - // sfma shifting - switch((s->st1 & ST1_SFMA) >> ST1_SFMA_SHIFT) { - case 0: // sfma 0 - break; - case 1: // sfma 2 - m <<= 2; - break; - case 2: // sfma 4 - m <<= 4; - break; - case 3: // sfma -16 - if(m & 0x8000000000000ULL) - m |= 0xfff0000000000000ULL; - m >>= 16; - break; - } - - return m; -} - -static void tms57002_execute_cat1(tms57002_t *s, UINT32 opcode) -{ - UINT32 c, d; - INT64 r; - switch(opcode >> 18) { - case 0x00: // nop - break; - -#define INTRP1 -#include "cpu/tms57002/tms57002.inc" -#undef INTRP1 - - default: - fatalerror("Unhandled case in tms57002_execute_cat1"); - } -} - -static void tms57002_execute_cat2_pre(tms57002_t *s, UINT32 opcode) -{ - switch((opcode >> 11) & 0x7f) { - case 0x00: // nop - break; - -#define INTRP2A -#include "cpu/tms57002/tms57002.inc" -#undef INTRP2A - - default: - fatalerror("Unhandled case in tms57002_execute_cat2_pre"); - } -} - -static void tms57002_execute_cat2_post(tms57002_t *s, UINT32 opcode) -{ - UINT32 c; - switch((opcode >> 11) & 0x7f) { - case 0x00: // nop - break; - -#define INTRP2B -#include "cpu/tms57002/tms57002.inc" -#undef INTRP2B - - default: - fatalerror("Unhandled case in tms57002_execute_cat2_post"); - } -} - -static void tms57002_execute_cat3(tms57002_t *s, UINT32 opcode) -{ - switch((opcode >> 11) & 0x7f) { - case 0x00: // nop - break; - -#define INTRP3 -#include "cpu/tms57002/tms57002.inc" -#undef INTRP3 - - default: - fatalerror("Unhandled case in tms57002_execute_cat3"); - } -} - -void tms57002_execute(tms57002_t *s) -{ - while(!(s->sti & (S_IDLE | IN_PLOAD | IN_CLOAD))) { - UINT32 opcode = s->program->read_dword(s->pc << 2); - - if(s->sti & (S_READ|S_WRITE)) { - if(s->sti & S_READ) - tms57002_xm_step_read(s); - else - tms57002_xm_step_write(s); - } - - if((opcode & 0xfc0000) == 0xfc0000) - tms57002_execute_cat3(s, opcode); - else { - tms57002_execute_cat2_pre(s, opcode); - tms57002_execute_cat1(s, opcode); - tms57002_execute_cat2_post(s, opcode); - } - - if(s->rptc) - s->rptc--; - else if(s->sti & S_BRANCH) - s->sti &= ~S_BRANCH; - else - s->pc++; // Wraps if it reaches 256 - - if(s->rptc_next) { - s->rptc = s->rptc_next; - s->rptc_next = 0; - } - } -} -#endif - -static void tms57002_cache_flush(tms57002_t *s) +void tms57002_device::cache_flush() { int i; - s->cache.hused = s->cache.iused = 0; + cache.hused = cache.iused = 0; for(i=0; i != 256; i++) - s->cache.hashbase[i] = -1; + cache.hashbase[i] = -1; for(i=0; i != HBS; i++) { - s->cache.hashnode[i].st1 = 0; - s->cache.hashnode[i].ipc = -1; - s->cache.hashnode[i].next = -1; + cache.hashnode[i].st1 = 0; + cache.hashnode[i].ipc = -1; + cache.hashnode[i].next = -1; } for(i=0; i != IBS; i++) { - s->cache.inst[i].op = 0; - s->cache.inst[i].next = -1; - s->cache.inst[i].param = 0; + cache.inst[i].op = 0; + cache.inst[i].next = -1; + cache.inst[i].param = 0; } } -static void tms57002_add_one(tms57002_t *s, cstate *cs, unsigned short op, UINT8 param) +void tms57002_device::add_one(cstate *cs, unsigned short op, UINT8 param) { - short ipc = s->cache.iused++; - s->cache.inst[ipc].op = op; - s->cache.inst[ipc].param = param; - s->cache.inst[ipc].next = -1; + short ipc = cache.iused++; + cache.inst[ipc].op = op; + cache.inst[ipc].param = param; + cache.inst[ipc].next = -1; if(cs->ipc != -1) - s->cache.inst[cs->ipc].next = ipc; + cache.inst[cs->ipc].next = ipc; cs->ipc = ipc; if(cs->hnode != -1) { - s->cache.hashnode[cs->hnode].ipc = ipc; + cache.hashnode[cs->hnode].ipc = ipc; cs->hnode = -1; } } -static void tms57002_decode_one(tms57002_t *s, UINT32 opcode, cstate *cs, void (*dec)(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs)) +void tms57002_device::decode_one(UINT32 opcode, cstate *cs, void (tms57002_device::*dec)(UINT32 opcode, unsigned short *op, cstate *cs)) { unsigned short op = 0; - dec(s, opcode, &op, cs); + (this->*dec)(opcode, &op, cs); if(!op) return; - tms57002_add_one(s, cs, op, opcode & 0xff); + add_one(cs, op, opcode & 0xff); } -static short tms57002_get_hash(tms57002_t *s, unsigned char adr, UINT32 st1, short *pnode) +short tms57002_device::get_hash(unsigned char adr, UINT32 st1, short *pnode) { short hnode; st1 &= ST1_CACHE; *pnode = -1; - hnode = s->cache.hashbase[adr]; + hnode = cache.hashbase[adr]; while(hnode != -1) { - if(s->cache.hashnode[hnode].st1 == st1) - return s->cache.hashnode[hnode].ipc; + if(cache.hashnode[hnode].st1 == st1) + return cache.hashnode[hnode].ipc; *pnode = hnode; - hnode = s->cache.hashnode[hnode].next; + hnode = cache.hashnode[hnode].next; } return -1; } -static short tms57002_get_hashnode(tms57002_t *s, unsigned char adr, UINT32 st1, short pnode) +short tms57002_device::get_hashnode(unsigned char adr, UINT32 st1, short pnode) { - short hnode = s->cache.hused++; - s->cache.hashnode[hnode].st1 = st1 & ST1_CACHE; - s->cache.hashnode[hnode].ipc = -1; - s->cache.hashnode[hnode].next = -1; + short hnode = cache.hused++; + cache.hashnode[hnode].st1 = st1 & ST1_CACHE; + cache.hashnode[hnode].ipc = -1; + cache.hashnode[hnode].next = -1; if(pnode == -1) - s->cache.hashbase[adr] = hnode; + cache.hashbase[adr] = hnode; else - s->cache.hashnode[pnode].next = hnode; + cache.hashnode[pnode].next = hnode; return hnode; } -static int tms57002_decode_get_pc(tms57002_t *s) +int tms57002_device::decode_get_pc() { - UINT32 st1 = s->st1; short pnode, res; cstate cs; - UINT8 adr = s->pc; + UINT8 adr = pc; - res = tms57002_get_hash(s, adr, st1, &pnode); + res = get_hash(adr, st1, &pnode); if(res != -1) return res; - if(HBS - s->cache.hused < 256 || IBS - s->cache.iused < 256*3) { - tms57002_cache_flush(s); + if(HBS - cache.hused < 256 || IBS - cache.iused < 256*3) { + cache_flush(); pnode = -1; } - cs.hnode = res = tms57002_get_hashnode(s, adr, st1, pnode); + cs.hnode = res = get_hashnode(adr, st1, pnode); cs.ipc = -1; cs.branch = 0; for(;;) { short ipc; - UINT32 opcode = s->program->read_dword(adr << 2); + UINT32 opcode = program->read_dword(adr << 2); if((opcode & 0xfc0000) == 0xfc0000) - tms57002_decode_one(s, opcode, &cs, tms57002_decode_cat3); + decode_one(opcode, &cs, &tms57002_device::decode_cat3); else { - tms57002_decode_one(s, opcode, &cs, tms57002_decode_cat2_pre); - tms57002_decode_one(s, opcode, &cs, tms57002_decode_cat1); - tms57002_decode_one(s, opcode, &cs, tms57002_decode_cat2_post); + decode_one(opcode, &cs, &tms57002_device::decode_cat2_pre); + decode_one(opcode, &cs, &tms57002_device::decode_cat1); + decode_one(opcode, &cs, &tms57002_device::decode_cat2_post); } - tms57002_add_one(s, &cs, 0, 0); + add_one(&cs, 0, 0); if(cs.branch) break; adr++; - ipc = tms57002_get_hash(s, adr, st1, &pnode); + ipc = get_hash(adr, st1, &pnode); if(ipc != -1) { - s->cache.inst[cs.ipc].next = ipc; + cache.inst[cs.ipc].next = ipc; break; } - cs.hnode = tms57002_get_hashnode(s, adr, s->st1, pnode); + cs.hnode = get_hashnode(adr, st1, pnode); } - s->st1 = st1; - return s->cache.hashnode[res].ipc; + return cache.hashnode[res].ipc; } -static CPU_EXECUTE(tms57002) +void tms57002_device::execute_run() { - tms57002_t *s = get_safe_token(device); int ipc = -1; - while(s->icount > 0 && !(s->sti & (S_IDLE | IN_PLOAD | IN_CLOAD))) { + while(icount > 0 && !(sti & (S_IDLE | IN_PLOAD | IN_CLOAD))) { int iipc; - debugger_instruction_hook(device, s->pc); + debugger_instruction_hook(this, pc); if(ipc == -1) - ipc = tms57002_decode_get_pc(s); + ipc = decode_get_pc(); iipc = ipc; - if(s->sti & (S_READ|S_WRITE)) { - if(s->sti & S_READ) - tms57002_xm_step_read(s); + if(sti & (S_READ|S_WRITE)) { + if(sti & S_READ) + xm_step_read(); else - tms57002_xm_step_write(s); + xm_step_write(); } for(;;) { UINT32 c, d; INT64 r; - const icd *i = s->cache.inst + ipc; + const icd *i = cache.inst + ipc; ipc = i->next; switch(i->op) { @@ -1072,81 +764,92 @@ static CPU_EXECUTE(tms57002) } } inst: - s->icount--; + icount--; - if(s->rptc) { - s->rptc--; + if(rptc) { + rptc--; ipc = iipc; - } else if(s->sti & S_BRANCH) { - s->sti &= ~S_BRANCH; + } else if(sti & S_BRANCH) { + sti &= ~S_BRANCH; ipc = -1; } else - s->pc++; // Wraps if it reaches 256, next wraps too + pc++; // Wraps if it reaches 256, next wraps too - if(s->rptc_next) { - s->rptc = s->rptc_next; - s->rptc_next = 0; + if(rptc_next) { + rptc = rptc_next; + rptc_next = 0; } } - if(s->icount > 0) - s->icount = 0; + if(icount > 0) + icount = 0; } -static CPU_INIT(tms57002) +void tms57002_device::device_start() { - tms57002_t *s = get_safe_token(device); - tms57002_cache_flush(s); - s->sti = S_IDLE; - s->program = device->space(AS_PROGRAM); - s->data = device->space(AS_DATA); + sti = S_IDLE; + program = space(AS_PROGRAM); + data = space(AS_DATA); + + state_add(STATE_GENPC,"GENPC", pc).noshow(); + + m_icountptr = &icount; + + save_item(NAME(macc)); + + save_item(NAME(cmem)); + save_item(NAME(dmem0)); + save_item(NAME(dmem1)); + + save_item(NAME(si)); + save_item(NAME(so)); + + save_item(NAME(st0)); + save_item(NAME(st1)); + save_item(NAME(sti)); + save_item(NAME(aacc)); + save_item(NAME(xoa)); + save_item(NAME(xba)); + save_item(NAME(xwr)); + save_item(NAME(xrd)); + save_item(NAME(creg)); + + save_item(NAME(pc)); + save_item(NAME(ca)); + save_item(NAME(id)); + save_item(NAME(ba0)); + save_item(NAME(ba1)); + save_item(NAME(rptc)); + save_item(NAME(rptc_next)); + save_item(NAME(sa)); + + save_item(NAME(xm_adr)); + + save_item(NAME(host)); + save_item(NAME(hidx)); + save_item(NAME(allow_update)); } - -static CPU_SET_INFO(tms57002) +UINT32 tms57002_device::execute_min_cycles() const { + return 1; } -static ADDRESS_MAP_START(internal_pgm, AS_PROGRAM, 32) - AM_RANGE(0x000, 0x3ff) AM_RAM -ADDRESS_MAP_END - -CPU_GET_INFO(tms57002) +UINT32 tms57002_device::execute_max_cycles() const { - tms57002_t *s = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL; + return 3; +} - switch(state) { - case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(tms57002_t); break; - case CPUINFO_INT_INPUT_LINES: info->i = 0; break; - case DEVINFO_INT_ENDIANNESS: info->i = ENDIANNESS_LITTLE; break; - case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break; - case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break; - case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 4; break; - case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 4; break; - case CPUINFO_INT_MIN_CYCLES: info->i = 1; break; - case CPUINFO_INT_MAX_CYCLES: info->i = 3; break; - case DEVINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 32; break; - case DEVINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 8; break; - case DEVINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = -2; break; - case DEVINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 8; break; - case DEVINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 20; break; - case DEVINFO_INT_ADDRBUS_SHIFT + AS_DATA: info->i = 0; break; - case DEVINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 0; break; - case DEVINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 0; break; - case DEVINFO_INT_ADDRBUS_SHIFT + AS_IO: info->i = 0; break; - case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(tms57002); break; - case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(tms57002); break; - case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(tms57002); break; - case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(tms57002); break; - case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(tms57002); break; - case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &s->icount; break; - case DEVINFO_PTR_INTERNAL_MEMORY_MAP + AS_PROGRAM:info->internal_map32 = ADDRESS_MAP_NAME(internal_pgm); break; - case DEVINFO_STR_NAME: strcpy( info->s, "TMS57002" ); break; - case DEVINFO_STR_FAMILY: strcpy( info->s, "Texas Instruments TMS57002 (DASP)" ); break; - case DEVINFO_STR_VERSION: strcpy( info->s, "1.0" ); break; - case DEVINFO_STR_SOURCE_FILE: strcpy( info->s, __FILE__ ); break; - case DEVINFO_STR_CREDITS: strcpy( info->s, "Copyright Olivier Galibert" ); break; +UINT32 tms57002_device::execute_input_lines() const +{ + return 0; +} + +const address_space_config *tms57002_device::memory_space_config(address_spacenum spacenum) const +{ + switch(spacenum) { + case AS_PROGRAM: return &program_config; + case AS_DATA: return &data_config; + default: return 0; } } - -DEFINE_LEGACY_CPU_DEVICE(TMS57002, tms57002); diff --git a/src/emu/cpu/tms57002/tms57002.h b/src/emu/cpu/tms57002/tms57002.h index f8ea1813c16..05f899cb401 100644 --- a/src/emu/cpu/tms57002/tms57002.h +++ b/src/emu/cpu/tms57002/tms57002.h @@ -1,24 +1,223 @@ +/*************************************************************************** + + asap.h + + TMS57002 "DASP" emulator. + +**************************************************************************** + + Copyright Olivier Galibert + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + * Neither the name 'MAME' nor the names of its contributors may be + used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + +***************************************************************************/ #pragma once #ifndef __TMS57002_H__ #define __TMS57002_H__ +class tms57002_device : public cpu_device { +public: + tms57002_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + + DECLARE_READ8_MEMBER(data_r); + DECLARE_WRITE8_MEMBER(data_w); + + DECLARE_WRITE8_MEMBER(pload_w); + DECLARE_WRITE8_MEMBER(cload_w); + DECLARE_READ8_MEMBER(empty_r); + DECLARE_READ8_MEMBER(dready_r); + + void sync(); + +protected: + virtual void device_start(); + virtual void device_reset(); + virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const; + virtual UINT32 execute_min_cycles() const; + virtual UINT32 execute_max_cycles() const; + virtual UINT32 execute_input_lines() const; + virtual void execute_run(); + virtual UINT32 disasm_min_opcode_bytes() const; + virtual UINT32 disasm_max_opcode_bytes() const; + virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options); + +private: + enum { + IN_PLOAD = 0x00000001, + IN_CLOAD = 0x00000002, + SU_CVAL = 0x00000004, + SU_MASK = 0x00000018, SU_ST0 = 0x00, SU_ST1 = 0x08, SU_PRG = 0x10, + S_IDLE = 0x00000020, + S_READ = 0x00000040, + S_WRITE = 0x00000080, + S_BRANCH = 0x00000100, + S_HOST = 0x00000200 + }; + + enum { + ST0_INCS = 0x000001, + ST0_DIRI = 0x000002, + ST0_FI = 0x000004, + ST0_SIM = 0x000008, + ST0_PLRI = 0x000020, + ST0_PBCI = 0x000040, + ST0_DIRO = 0x000080, + ST0_FO = 0x000100, + ST0_SOM = 0x000600, + ST0_PLRO = 0x000800, + ST0_PBCO = 0x001000, + ST0_CNS = 0x002000, + ST0_WORD = 0x004000, + ST0_SEL = 0x008000, + ST0_M = 0x030000, ST0_M_64K = 0x000000, ST0_M_256K = 0x010000, ST0_M_1M = 0x020000, + ST0_SRAM = 0x200000, + + ST1_AOV = 0x000001, + ST1_SFAI = 0x000002, + ST1_SFAO = 0x000004, + ST1_MOVM = 0x000020, + ST1_MOV = 0x000040, + ST1_SFMA = 0x000180, ST1_SFMA_SHIFT = 7, + ST1_SFMO = 0x001800, ST1_SFMO_SHIFT = 11, + ST1_RND = 0x038000, ST1_RND_SHIFT = 15, + ST1_CRM = 0x0C0000, ST1_CRM_SHIFT = 18, ST1_CRM_32 = 0x000000, ST1_CRM_16H = 0x040000, ST1_CRM_16L = 0x080000, + ST1_DBP = 0x100000, + ST1_CAS = 0x200000, + + ST1_CACHE = ST1_SFAI|ST1_SFAO|ST1_MOVM|ST1_SFMA|ST1_SFMO|ST1_RND|ST1_CRM|ST1_DBP + }; + + + enum { BR_UB, BR_CB, BR_IDLE }; + + enum { IBS = 8192, HBS = 4096 }; + + struct icd { + unsigned short op; + short next; + unsigned char param; + }; + + struct hcd { + unsigned int st1; + short ipc; + short next; + }; + + struct cd { + short hashbase[256]; + hcd hashnode[HBS]; + icd inst[IBS]; + int hused, iused; + }; + + struct cstate { + int branch; + short hnode; + short ipc; + }; + + INT64 macc; + + UINT32 cmem[256]; + UINT32 dmem0[256]; + UINT32 dmem1[32]; + + UINT32 si[4], so[4]; + + UINT32 st0, st1, sti; + UINT32 aacc, xoa, xba, xwr, xrd, creg; + + UINT8 pc, ca, id, ba0, ba1, rptc, rptc_next, sa; + + UINT32 xm_adr; + + UINT8 host[4], hidx, allow_update; + + cd cache; + + const address_space_config program_config, data_config; + + address_space *program, *data; + int icount; + int unsupported_inst_warning; + + void decode_error(UINT32 opcode); + void decode_cat1(UINT32 opcode, unsigned short *op, cstate *cs); + void decode_cat2_pre(UINT32 opcode, unsigned short *op, cstate *cs); + void decode_cat3(UINT32 opcode, unsigned short *op, cstate *cs); + void decode_cat2_post(UINT32 opcode, unsigned short *op, cstate *cs); + + inline int xmode(UINT32 opcode, char type); + inline int sfao(UINT32 st1); + inline int dbp(UINT32 st1); + inline int crm(UINT32 st1); + inline int sfai(UINT32 st1); + inline int sfmo(UINT32 st1); + inline int rnd(UINT32 st1); + inline int movm(UINT32 st1); + inline int sfma(UINT32 st1); + + const char *get_memadr(UINT32 opcode, char type); + + void xm_init(); + void xm_step_read(); + void xm_step_write(); + INT64 macc_to_output_0(INT64 rounding, UINT64 rmask); + INT64 macc_to_output_1(INT64 rounding, UINT64 rmask); + INT64 macc_to_output_2(INT64 rounding, UINT64 rmask); + INT64 macc_to_output_3(INT64 rounding, UINT64 rmask); + INT64 macc_to_output_0s(INT64 rounding, UINT64 rmask); + INT64 macc_to_output_1s(INT64 rounding, UINT64 rmask); + INT64 macc_to_output_2s(INT64 rounding, UINT64 rmask); + INT64 macc_to_output_3s(INT64 rounding, UINT64 rmask); + INT64 check_macc_overflow_0(); + INT64 check_macc_overflow_1(); + INT64 check_macc_overflow_2(); + INT64 check_macc_overflow_3(); + INT64 check_macc_overflow_0s(); + INT64 check_macc_overflow_1s(); + INT64 check_macc_overflow_2s(); + INT64 check_macc_overflow_3s(); + void cache_flush(); + void add_one(cstate *cs, unsigned short op, UINT8 param); + void decode_one(UINT32 opcode, cstate *cs, void (tms57002_device::*dec)(UINT32 opcode, unsigned short *op, cstate *cs)); + short get_hash(unsigned char adr, UINT32 st1, short *pnode); + short get_hashnode(unsigned char adr, UINT32 st1, short pnode); + int decode_get_pc(); +}; enum { TMS57002_PC=1 }; -DECLARE_LEGACY_CPU_DEVICE(TMS57002, tms57002); - -WRITE8_DEVICE_HANDLER(tms57002_data_w); -READ8_DEVICE_HANDLER(tms57002_data_r); - -WRITE8_DEVICE_HANDLER(tms57002_pload_w); -WRITE8_DEVICE_HANDLER(tms57002_cload_w); -READ8_DEVICE_HANDLER(tms57002_empty_r); -READ8_DEVICE_HANDLER(tms57002_dready_r); - -void tms57002_sync(device_t *cpu); +extern const device_type TMS57002; #endif diff --git a/src/emu/cpu/tms57002/tms57kdec.c b/src/emu/cpu/tms57002/tms57kdec.c index cd6ad44c708..2e8344a4521 100644 --- a/src/emu/cpu/tms57002/tms57kdec.c +++ b/src/emu/cpu/tms57002/tms57kdec.c @@ -1,31 +1,118 @@ +/*************************************************************************** + + asap.h + + TMS57002 "DASP" emulator. + +**************************************************************************** + + Copyright Olivier Galibert + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + * Neither the name 'MAME' nor the names of its contributors may be + used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + +***************************************************************************/ + #include "emu.h" #include "debugger.h" #include "tms57002.h" -#include "tms57kpr.h" -#ifdef __GNUC__ -#define noinline __attribute__((noinline)) -#else -#define noinline /* */ -#endif +inline int tms57002_device::xmode(UINT32 opcode, char type) +{ + if(((opcode & 0x400) && (type == 'c')) || (!(opcode & 0x400) && (type == 'd'))) { + if(opcode & 0x100) + return 0; + else if(opcode & 0x80) + return 2; + else + return 1; + } else if(opcode & 0x200) + return 2; -static void tms57002_decode_error(tms57002_t *s, UINT32 opcode) + return 1; +} + +inline int tms57002_device::sfao(UINT32 st1) +{ + return st1 & ST1_SFAO ? 1 : 0; +} + +inline int tms57002_device::dbp(UINT32 st1) +{ + return st1 & ST1_DBP ? 1 : 0; +} + +inline int tms57002_device::crm(UINT32 st1) +{ + return (st1 & ST1_CRM) >> ST1_CRM_SHIFT; +} + +inline int tms57002_device::sfai(UINT32 st1) +{ + return st1 & ST1_SFAI ? 1 : 0; +} + +inline int tms57002_device::sfmo(UINT32 st1) +{ + return (st1 & ST1_SFMO) >> ST1_SFMO_SHIFT; +} + +inline int tms57002_device::rnd(UINT32 st1) +{ + return (st1 & ST1_RND) >> ST1_RND_SHIFT; +} + +inline int tms57002_device::movm(UINT32 st1) +{ + return st1 & ST1_MOVM ? 1 : 0; +} + +inline int tms57002_device::sfma(UINT32 st1) +{ + return (st1 & ST1_SFMA) >> ST1_SFMA_SHIFT; +} + +void tms57002_device::decode_error(UINT32 opcode) { char buf[256]; UINT8 opr[3]; - if(s->unsupported_inst_warning) + if(unsupported_inst_warning) return; - s->unsupported_inst_warning = 1; + unsupported_inst_warning = 1; opr[0] = opcode; opr[1] = opcode >> 8; opr[2] = opcode >> 16; - CPU_DISASSEMBLE_NAME(tms57002)(0, buf, s->pc, opr, opr, 0); + // CPU_DECODEEMBLE_NAME(tms57002)(0, buf, s->pc, opr, opr, 0); popmessage("tms57002: %s - Contact Mamedev", buf); } -void tms57002_decode_cat1(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs) +void tms57002_device::decode_cat1(UINT32 opcode, unsigned short *op, cstate *cs) { switch(opcode >> 18) { case 0x00: // nop @@ -36,12 +123,12 @@ void tms57002_decode_cat1(tms57002_t *s, UINT32 opcode, unsigned short *op, csta #undef CDEC1 default: - tms57002_decode_error(s, opcode); + decode_error(opcode); break; } } -void tms57002_decode_cat2_pre(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs) +void tms57002_device::decode_cat2_pre(UINT32 opcode, unsigned short *op, cstate *cs) { switch((opcode >> 11) & 0x7f) { case 0x00: // nop @@ -52,12 +139,12 @@ void tms57002_decode_cat2_pre(tms57002_t *s, UINT32 opcode, unsigned short *op, #undef CDEC2A default: - tms57002_decode_error(s, opcode); + decode_error(opcode); break; } } -void tms57002_decode_cat2_post(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs) +void tms57002_device::decode_cat2_post(UINT32 opcode, unsigned short *op, cstate *cs) { switch((opcode >> 11) & 0x7f) { case 0x00: // nop @@ -68,12 +155,12 @@ void tms57002_decode_cat2_post(tms57002_t *s, UINT32 opcode, unsigned short *op, #undef CDEC2B default: - tms57002_decode_error(s, opcode); + decode_error(opcode); break; } } -void tms57002_decode_cat3(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs) +void tms57002_device::decode_cat3(UINT32 opcode, unsigned short *op, cstate *cs) { switch((opcode >> 11) & 0x7f) { case 0x00: // nop @@ -84,7 +171,7 @@ void tms57002_decode_cat3(tms57002_t *s, UINT32 opcode, unsigned short *op, csta #undef CDEC3 default: - tms57002_decode_error(s, opcode); + decode_error(opcode); break; } } diff --git a/src/emu/cpu/tms57002/tms57kpr.h b/src/emu/cpu/tms57002/tms57kpr.h deleted file mode 100644 index 5192974ae8c..00000000000 --- a/src/emu/cpu/tms57002/tms57kpr.h +++ /dev/null @@ -1,171 +0,0 @@ -#ifndef TMS57KPRIVATE_H -#define TMS57KPRIVATE_H - -CPU_DISASSEMBLE(tms57002); - -#ifdef __GNUC__ -#define noinline __attribute__((noinline)) -#else -#define noinline /* */ -#endif - -enum { - IN_PLOAD = 0x00000001, - IN_CLOAD = 0x00000002, - SU_CVAL = 0x00000004, - SU_MASK = 0x00000018, SU_ST0 = 0x00, SU_ST1 = 0x08, SU_PRG = 0x10, - S_IDLE = 0x00000020, - S_READ = 0x00000040, - S_WRITE = 0x00000080, - S_BRANCH = 0x00000100, - S_HOST = 0x00000200 -}; - -enum { - ST0_INCS = 0x000001, - ST0_DIRI = 0x000002, - ST0_FI = 0x000004, - ST0_SIM = 0x000008, - ST0_PLRI = 0x000020, - ST0_PBCI = 0x000040, - ST0_DIRO = 0x000080, - ST0_FO = 0x000100, - ST0_SOM = 0x000600, - ST0_PLRO = 0x000800, - ST0_PBCO = 0x001000, - ST0_CNS = 0x002000, - ST0_WORD = 0x004000, - ST0_SEL = 0x008000, - ST0_M = 0x030000, ST0_M_64K = 0x000000, ST0_M_256K = 0x010000, ST0_M_1M = 0x020000, - ST0_SRAM = 0x200000, - - ST1_AOV = 0x000001, - ST1_SFAI = 0x000002, - ST1_SFAO = 0x000004, - ST1_MOVM = 0x000020, - ST1_MOV = 0x000040, - ST1_SFMA = 0x000180, ST1_SFMA_SHIFT = 7, - ST1_SFMO = 0x001800, ST1_SFMO_SHIFT = 11, - ST1_RND = 0x038000, ST1_RND_SHIFT = 15, - ST1_CRM = 0x0C0000, ST1_CRM_SHIFT = 18, ST1_CRM_32 = 0x000000, ST1_CRM_16H = 0x040000, ST1_CRM_16L = 0x080000, - ST1_DBP = 0x100000, - ST1_CAS = 0x200000, - - ST1_CACHE = ST1_SFAI|ST1_SFAO|ST1_MOVM|ST1_SFMA|ST1_SFMO|ST1_RND|ST1_CRM|ST1_DBP -}; - -enum { BR_UB, BR_CB, BR_IDLE }; - -enum { IBS = 8192, HBS = 4096 }; - -typedef struct { - unsigned short op; - short next; - unsigned char param; -} icd; - -typedef struct { - unsigned int st1; - short ipc; - short next; -} hcd; - -typedef struct { - short hashbase[256]; - hcd hashnode[HBS]; - icd inst[IBS]; - int hused, iused; -} cd; - -typedef struct { - int branch; - short hnode; - short ipc; -} cstate; - -typedef struct { - INT64 macc; - - UINT32 cmem[256]; - UINT32 dmem0[256]; - UINT32 dmem1[32]; - - UINT32 si[4], so[4]; - - UINT32 st0, st1, sti; - UINT32 aacc, xoa, xba, xwr, xrd, creg; - - UINT8 pc, ca, id, ba0, ba1, rptc, rptc_next, sa; - - UINT32 xm_adr; - - UINT8 host[4], hidx, allow_update; - - cd cache; - - address_space *program, *data; - int icount; - int unsupported_inst_warning; -} tms57002_t; - -void tms57002_decode_cat1(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs); -void tms57002_decode_cat2_pre(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs); -void tms57002_decode_cat3(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs); -void tms57002_decode_cat2_post(tms57002_t *s, UINT32 opcode, unsigned short *op, cstate *cs); - -INLINE int xmode(UINT32 opcode, char type) -{ - if(((opcode & 0x400) && (type == 'c')) || (!(opcode & 0x400) && (type == 'd'))) { - if(opcode & 0x100) - return 0; - else if(opcode & 0x80) - return 2; - else - return 1; - } else if(opcode & 0x200) - return 2; - - return 1; -} - -INLINE int sfao(UINT32 st1) -{ - return st1 & ST1_SFAO ? 1 : 0; -} - -INLINE int dbp(UINT32 st1) -{ - return st1 & ST1_DBP ? 1 : 0; -} - -INLINE int crm(UINT32 st1) -{ - return (st1 & ST1_CRM) >> ST1_CRM_SHIFT; -} - -INLINE int sfai(UINT32 st1) -{ - return st1 & ST1_SFAI ? 1 : 0; -} - -INLINE int sfmo(UINT32 st1) -{ - return (st1 & ST1_SFMO) >> ST1_SFMO_SHIFT; -} - -INLINE int rnd(UINT32 st1) -{ - return (st1 & ST1_RND) >> ST1_RND_SHIFT; -} - -INLINE int movm(UINT32 st1) -{ - return st1 & ST1_MOVM ? 1 : 0; -} - -INLINE int sfma(UINT32 st1) -{ - return (st1 & ST1_SFMA) >> ST1_SFMA_SHIFT; -} - -#endif diff --git a/src/emu/cpu/tms57002/tmsinstr.lst b/src/emu/cpu/tms57002/tmsinstr.lst index 6c1583f1e4e..6081d429fe2 100644 --- a/src/emu/cpu/tms57002/tmsinstr.lst +++ b/src/emu/cpu/tms57002/tmsinstr.lst @@ -1,10 +1,10 @@ abs 1 01 1 n abs - s->aacc = %a; - if(((INT32)s->aacc) < 0) { - s->aacc = - s->aacc; - if(((INT32)s->aacc) < 0) - s->st1 |= ST1_AOV; + aacc = %a; + if(((INT32)aacc) < 0) { + aacc = - aacc; + if(((INT32)aacc) < 0) + st1 |= ST1_AOV; } add 1 03 1 y @@ -40,16 +40,16 @@ ampy 1 2c 2 y and 1 14 1 n and %d,a %sfai(d, %d); - s->aacc &= d; + aacc &= d; and 1 15 1 n and %c,a - s->aacc &= %c; + aacc &= %c; and 1 16 1 n and %d,%c %sfai(d, %d); - s->aacc = %c & d; + aacc = %c & d; b 3 48 3 n b b %i @@ -57,7 +57,7 @@ b 3 48 3 n b bgz 3 50 3 n cb bgz %i - if(((INT32)s->aacc) > 0) { + if(((INT32)aacc) > 0) { %b(%i); } @@ -66,20 +66,20 @@ bioz 3 70 3 n cb blz 3 58 3 n cb blz %i - if(((INT32)s->aacc) < 0) { + if(((INT32)aacc) < 0) { %b(%i); } bnz 3 60 3 n cb bnz %i - if(s->aacc) { + if(aacc) { %b(%i); } bv 3 78 3 n cb bv %i - if(s->st1 & ST1_AOV) { - s->st1 &= ~ST1_AOV; + if(st1 & ST1_AOV) { + st1 &= ~ST1_AOV; %b(%i); } @@ -112,35 +112,35 @@ diml 2a 1b 1 n dis 2a 10 1 n dis si0_l,%d - %wd(s->si[0]); + %wd(si[0]); dis 2a 11 1 n dis si0_r,%d - %wd(s->si[1]); + %wd(si[1]); dis 2a 12 1 n dis si1_l,%d - %wd(s->si[2]); + %wd(si[2]); dis 2a 13 1 n dis si1_r,%d - %wd(s->si[3]); + %wd(si[3]); domh 2a 20 1 n domh so0_l - s->so[0] = (%mo >> 24) & 0xffffff; + so[0] = (%mo >> 24) & 0xffffff; domh 2a 21 1 n domh so0_r - s->so[1] = (%mo >> 24) & 0xffffff; + so[1] = (%mo >> 24) & 0xffffff; domh 2a 22 1 n domh so1_l - s->so[2] = (%mo >> 24) & 0xffffff; + so[2] = (%mo >> 24) & 0xffffff; domh 2a 23 1 n domh so1_r - s->so[3] = (%mo >> 24) & 0xffffff; + so[3] = (%mo >> 24) & 0xffffff; doml 2a 24 1 n doml so0_l @@ -168,78 +168,78 @@ dos 2b 1f 1 n idle 3 08 1 n i idle - s->sti |= S_IDLE; + sti |= S_IDLE; incd 2a 42 1 y incd lacc 1 12 1 n lacc %c - s->aacc = %c; + aacc = %c; lacd 1 11 1 n lacd %d %sfai(d, %d); - s->aacc = d; + aacc = d; lbrk 3 28 1 n lbrk %i lcaa 2a 08 1 y lcaa - s->ca = %a >> 24; + ca = %a >> 24; lcac 3 40 1 n lcac %i - if(((INT32)s->aacc) >= 0) - s->ca = %i; + if(((INT32)aacc) >= 0) + ca = %i; lcak 3 18 1 n lcak %i - s->ca = %i; + ca = %i; ldpk 2a 44 1 n f ldpk 0 - s->st1 &= ~ST1_DBP; + st1 &= ~ST1_DBP; ldpk 2a 45 1 n f ldpk 1 - s->st1 |= ST1_DBP; + st1 |= ST1_DBP; ld0t 2b 0c 1 y ld0t %d lira 2a 09 1 y lira - s->id = %a >> 24; + id = %a >> 24; lirk 3 20 1 n lirk %i - s->id = %i; + id = %i; lmhc 1 33 1 n lmhc %c - s->macc = ((INT64)(INT32)%c) << 16; + macc = ((INT64)(INT32)%c) << 16; lmhd 1 31 1 n lmhd %d - s->macc = ((INT64)(INT32)%d) << 16; + macc = ((INT64)(INT32)%d) << 16; lmld 1 32 1 n lmld %d - s->macc = (s->macc & ~0xffffffULL) | %d24; + macc = (macc & ~0xffffffULL) | %d24; lpc 2b 31 1 n lpc %c - if(s->sti & S_HOST) + if(sti & S_HOST) break; c = %c; - s->host[0] = c >> 24; - s->host[1] = c >> 16; - s->host[2] = c >> 8; - s->host[3] = c; - s->hidx = 0; - s->sti |= S_HOST; + host[0] = c >> 24; + host[1] = c >> 16; + host[2] = c >> 8; + host[3] = c; + hidx = 0; + sti |= S_HOST; lpd 2b 30 1 n lpd %d @@ -249,63 +249,63 @@ mac 1 24 1 y d = %d24; if(d & 0x00800000) d |= 0xff000000; - s->creg = c = %c; + creg = c = %c; r = (INT64)(INT32)c * (INT64)(INT32)d; - s->macc = %ml + (r >> 7); + macc = %ml + (r >> 7); mac 1 25 1 y mac a,%d mac 1 26 1 y mac %c,a - s->creg = c = %c; + creg = c = %c; r = (INT64)(INT32)c * (INT64)(INT32)%a; - s->macc = %ml + (r >> 15); + macc = %ml + (r >> 15); macs 1 2e 1 y macs %c,a - s->creg = c = %c; + creg = c = %c; r = (INT64)(INT32)c * (INT64)(INT32)%a; - s->macc = %ml + (r >> 14); + macc = %ml + (r >> 14); macu 1 29 1 y macu %d,%c d = %d24; // d is 24bits unsigned - s->creg = c = %c; + creg = c = %c; r = (INT64)(INT32)c * (INT64)d; - s->macc = %ml + (r >> 7); + macc = %ml + (r >> 7); macu 1 2a 1 y macu a,%d d = %d24; // d is 24bits unsigned - s->creg = c = %a; + creg = c = %a; r = (INT64)(INT32)c * (INT64)d; - s->macc = %ml + (r >> 7); + macc = %ml + (r >> 7); mpy 1 21 1 y mpy %d,%c d = %d24; if(d & 0x00800000) d |= 0xff000000; - s->creg = c = %c; + creg = c = %c; r = (INT64)(INT32)c * (INT64)(INT32)d; - s->macc = r >> 7; + macc = r >> 7; mpy 1 22 1 y mpy %c,a - s->creg = c = %c; + creg = c = %c; r = (INT64)(INT32)c * (INT64)(INT32)%a; - s->macc = r >> 15; + macc = r >> 15; mpy 1 23 1 y mpy creg,%d mpyu 1 28 1 y mpyu %d,%c - s->creg = c = %c; + creg = c = %c; d = %d24; // d is 24bits unsigned r = (INT64)(INT32)c * (INT64)d; - s->macc = r >> 7; + macc = r >> 7; neg 1 02 1 n neg @@ -313,27 +313,27 @@ neg 1 02 1 n or 1 17 1 n or %d,a %sfai(d, %d); - s->aacc |= d; + aacc |= d; or 1 18 1 n or %c,a - s->aacc |= %c; + aacc |= %c; or 1 19 1 n or %d,%c %sfai(d, %d); - s->aacc = %c | d; + aacc = %c | d; raov 2a 38 1 n raov rde 1 39 1 n rde %c - if(s->sti & (S_READ|S_WRITE)) + if(sti & (S_READ|S_WRITE)) break; - s->xoa = %c; - tms57002_xm_init(s); - s->sti |= S_READ; + xoa = %c; + xm_init(); + sti |= S_READ; ref 2a 0e 1 n ref @@ -341,47 +341,47 @@ ref 2a 0e 1 n rmom 2a 40 1 n f rmom - s->st1 &= ~ST1_MOVM; + st1 &= ~ST1_MOVM; rmov 2a 3a 1 n rmov - s->st1 &= ~ST1_MOV; + st1 &= ~ST1_MOV; rnd 2a 68 1 n f rnd 48 - s->st1 = (s->st1 & ~ST1_RND) | (0 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (0 << ST1_RND_SHIFT); rnd 2a 69 1 n f rnd 32 - s->st1 = (s->st1 & ~ST1_RND) | (1 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (1 << ST1_RND_SHIFT); rnd 2a 6a 1 n f rnd 24 - s->st1 = (s->st1 & ~ST1_RND) | (2 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (2 << ST1_RND_SHIFT); rnd 2a 6b 1 n f rnd 20 - s->st1 = (s->st1 & ~ST1_RND) | (3 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (3 << ST1_RND_SHIFT); rnd 2a 6c 1 n f rnd 16 - s->st1 = (s->st1 & ~ST1_RND) | (4 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (4 << ST1_RND_SHIFT); rnd 2a 6d 1 n f rnd <5> - s->st1 = (s->st1 & ~ST1_RND) | (5 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (5 << ST1_RND_SHIFT); rnd 2a 6e 1 n f rnd <6> - s->st1 = (s->st1 & ~ST1_RND) | (6 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (6 << ST1_RND_SHIFT); rnd 2a 6f 1 n f rnd <7> - s->st1 = (s->st1 & ~ST1_RND) | (7 << ST1_RND_SHIFT); + st1 = (st1 & ~ST1_RND) | (7 << ST1_RND_SHIFT); rptk 3 10 1 n rptk %i - s->rptc_next = %i; + rptc_next = %i; sacc 2a 01 1 y sacc %c @@ -393,71 +393,71 @@ sacd 2a 02 1 y scrm 2a 48 1 n f scrm 32 - s->st1 = (s->st1 & ~ST1_CRM) | (0 << ST1_CRM_SHIFT); + st1 = (st1 & ~ST1_CRM) | (0 << ST1_CRM_SHIFT); scrm 2a 49 1 n f scrm 16h - s->st1 = (s->st1 & ~ST1_CRM) | (1 << ST1_CRM_SHIFT); + st1 = (st1 & ~ST1_CRM) | (1 << ST1_CRM_SHIFT); scrm 2a 4a 1 n f scrm 16l - s->st1 = (s->st1 & ~ST1_CRM) | (2 << ST1_CRM_SHIFT); + st1 = (st1 & ~ST1_CRM) | (2 << ST1_CRM_SHIFT); scrm 2a 4b 1 n f scrm <3> - s->st1 = (s->st1 & ~ST1_CRM) | (3 << ST1_CRM_SHIFT); + st1 = (st1 & ~ST1_CRM) | (3 << ST1_CRM_SHIFT); sfai 2b 54 1 n f sfai 0 - s->st1 &= ~ST1_SFAI; + st1 &= ~ST1_SFAI; sfai 2b 55 1 n f sfai -1 - s->st1 |= ST1_SFAI; + st1 |= ST1_SFAI; sfao 2a 50 1 n f sfao 0 - s->st1 &= ~ST1_SFAO; + st1 &= ~ST1_SFAO; sfao 2a 51 1 n f sfao 7 - s->st1 |= ST1_SFAI; + st1 |= ST1_SFAI; sfma 2b 58 1 n f sfma 0 - s->st1 = (s->st1 & ~ST1_SFMA) | (0 << ST1_SFMA_SHIFT); + st1 = (st1 & ~ST1_SFMA) | (0 << ST1_SFMA_SHIFT); sfma 2b 59 1 n f sfma 2 - s->st1 = (s->st1 & ~ST1_SFMA) | (1 << ST1_SFMA_SHIFT); + st1 = (st1 & ~ST1_SFMA) | (1 << ST1_SFMA_SHIFT); sfma 2b 5a 1 n f sfma 4 - s->st1 = (s->st1 & ~ST1_SFMA) | (2 << ST1_SFMA_SHIFT); + st1 = (st1 & ~ST1_SFMA) | (2 << ST1_SFMA_SHIFT); sfma 2b 5b 1 n f sfma -16 - s->st1 = (s->st1 & ~ST1_SFMA) | (3 << ST1_SFMA_SHIFT); + st1 = (st1 & ~ST1_SFMA) | (3 << ST1_SFMA_SHIFT); sfml 1 34 1 y sfml - s->macc = (s->macc & 0x8000000000000ULL) | ((s->macc << 1) & 0x7ffffffffffffULL); + macc = (macc & 0x8000000000000ULL) | ((macc << 1) & 0x7ffffffffffffULL); sfmo 2a 60 1 n f sfmo 0 - s->st1 = (s->st1 & ~ST1_SFMO) | (0 << ST1_SFMO_SHIFT); + st1 = (st1 & ~ST1_SFMO) | (0 << ST1_SFMO_SHIFT); sfmo 2a 61 1 n f sfmo 2 - s->st1 = (s->st1 & ~ST1_SFMO) | (1 << ST1_SFMO_SHIFT); + st1 = (st1 & ~ST1_SFMO) | (1 << ST1_SFMO_SHIFT); sfmo 2a 62 1 n f sfmo 4 - s->st1 = (s->st1 & ~ST1_SFMO) | (2 << ST1_SFMO_SHIFT); + st1 = (st1 & ~ST1_SFMO) | (2 << ST1_SFMO_SHIFT); sfmo 2a 63 1 n f sfmo -8 - s->st1 = (s->st1 & ~ST1_SFMO) | (3 << ST1_SFMO_SHIFT); + st1 = (st1 & ~ST1_SFMO) | (3 << ST1_SFMO_SHIFT); sfmr 1 35 1 y sfmr @@ -483,11 +483,11 @@ smld 2a 04 1 y smom 2a 41 1 n f smom - s->st1 |= ST1_MOVM; + st1 |= ST1_MOVM; srbd 2a 0f 1 y srbd %d - %wd(s->xrd); + %wd(xrd); std1 2a 0d 1 y std1 %d @@ -512,12 +512,12 @@ sub 1 0d 1 y wre 1 38 1 n wre %d,%c - if(s->sti & (S_READ|S_WRITE)) + if(sti & (S_READ|S_WRITE)) break; - s->xwr = %d24; - s->xoa = %c; - tms57002_xm_init(s); - s->sti |= S_WRITE; + xwr = %d24; + xoa = %c; + xm_init(); + sti |= S_WRITE; xor 1 1a 1 n xor %d,a diff --git a/src/emu/cpu/tms57002/tmsmake.c b/src/emu/cpu/tms57002/tmsmake.c index 22cb92f16f3..20b7002524c 100644 --- a/src/emu/cpu/tms57002/tmsmake.c +++ b/src/emu/cpu/tms57002/tmsmake.c @@ -86,14 +86,14 @@ enum { IxCMODE, IxDMODE, IxSFAI, IxCRM, IxDBP, IxSFAO, IxSFMO, IxRND, IxMOVM, Ix static const vinfo vinf[] = { { I_CMODE, 3, "cmode", "xmode(opcode, 'c')" }, { I_DMODE, 3, "dmode", "xmode(opcode, 'd')" }, - { I_SFAI, 2, "sfai", "sfai(s->st1)" }, - { I_CRM, 4, "crm", "crm(s->st1)" }, - { I_DBP, 2, "dbp", "dbp(s->st1)" }, - { I_SFAO, 2, "sfao", "sfao(s->st1)" }, - { I_SFMO, 4, "sfmo", "sfmo(s->st1)" }, - { I_RND, 8, "rnd", "rnd(s->st1)" }, - { I_MOVM, 2, "movm", "movm(s->st1)" }, - { I_SFMA, 4, "sfma", "sfma(s->st1)" }, + { I_SFAI, 2, "sfai", "sfai(st1)" }, + { I_CRM, 4, "crm", "crm(st1)" }, + { I_DBP, 2, "dbp", "dbp(st1)" }, + { I_SFAO, 2, "sfao", "sfao(st1)" }, + { I_SFMO, 4, "sfmo", "sfmo(st1)" }, + { I_RND, 8, "rnd", "rnd(st1)" }, + { I_MOVM, 2, "movm", "movm(st1)" }, + { I_SFMA, 4, "sfma", "sfma(st1)" }, { 0 } }; @@ -453,10 +453,10 @@ static void save_dasm_cat(FILE *f, const char *def, instr *il, int count) for(j=0; j != pc; j++) switch(par[j]) { case PC: - fprintf(f, ", tms57002_get_memadr(opcode, 'c')"); + fprintf(f, ", get_memadr(opcode, 'c')"); break; case PD: - fprintf(f, ", tms57002_get_memadr(opcode, 'd')"); + fprintf(f, ", get_memadr(opcode, 'd')"); break; case PI: fprintf(f, ", opcode & 0xff"); @@ -482,15 +482,15 @@ static void intrp_expand(char **p, int s, int e) break; case PA: - scs(p, "tms57002_aacc_to_output(s)"); + scs(p, "aacc_to_output()"); break; case PC: - scs(p, "tms57002_opc_read_c(s, opcode)"); + scs(p, "opc_read_c(opcode)"); break; case PD: - scs(p, "(tms57002_opc_read_d(s, opcode) << 8)"); + scs(p, "(opc_read_d(opcode) << 8)"); break; case PI: @@ -498,26 +498,26 @@ static void intrp_expand(char **p, int s, int e) break; case PD24: - scs(p, "tms57002_opc_read_d(s, opcode)"); + scs(p, "opc_read_d(opcode)"); break; case PML: - scs(p, "tms57002_macc_to_loop(s)"); + scs(p, "macc_to_loop()"); break; case PMO: - scs(p, "tms57002_macc_to_output(s)"); + scs(p, "macc_to_output()"); break; case PMV: - scs(p, "tms57002_check_macc_overflow(s)"); + scs(p, "check_macc_overflow()"); break; case PB: - scs(p, "s->pc = "); + scs(p, "pc = "); intrp_expand(p, parse_res[i].ppos[0], parse_res[i].ppos[1]); scs(p, ";\n"); - scs(p, " s->sti |= S_BRANCH"); + scs(p, " sti |= S_BRANCH"); break; case PWA: @@ -525,18 +525,18 @@ static void intrp_expand(char **p, int s, int e) intrp_expand(p, parse_res[i].ppos[0], parse_res[i].ppos[1]); scs(p, ";\n"); scs(p, " if(r < -0x80000000 || r > 0x7fffffff)\n"); - scs(p, " s->st1 |= ST1_AOV;\n"); - scs(p, " s->aacc = r"); + scs(p, " st1 |= ST1_AOV;\n"); + scs(p, " aacc = r"); break; case PWC: - scs(p, "tms57002_opc_write_c(s, opcode, "); + scs(p, "opc_write_c(opcode, "); intrp_expand(p, parse_res[i].ppos[0], parse_res[i].ppos[1]); scs(p, ")"); break; case PWD: - scs(p, "tms57002_opc_write_d(s, opcode, "); + scs(p, "opc_write_d(opcode, "); intrp_expand(p, parse_res[i].ppos[0], parse_res[i].ppos[1]); scs(p, ")"); break; @@ -546,7 +546,7 @@ static void intrp_expand(char **p, int s, int e) scs(p, " = "); intrp_expand(p, parse_res[i].ppos[1], parse_res[i].ppos[2]); scs(p, ";\n"); - scs(p, " if(s->st1 & ST1_SFAI)\n"); + scs(p, " if(st1 & ST1_SFAI)\n"); scs(p, " "); intrp_expand(p, parse_res[i].ppos[0], parse_res[i].ppos[1]); scs(p, " = ((INT32)"); @@ -636,19 +636,19 @@ static void cintrp_expand(char **p, int s, int e, const int *cv) case PA: if(cv[IxSFAO]) - scs(p, "(s->aacc << 7)"); + scs(p, "(aacc << 7)"); else - scs(p, "s->aacc"); + scs(p, "aacc"); break; case PC: { const char *r = NULL; if(cv[IxCMODE] == 0) - r = "s->cmem[i->param]"; + r = "cmem[i->param]"; else if(cv[IxCMODE] == 1) - r = "s->cmem[s->ca]"; + r = "cmem[ca]"; else if(cv[IxCMODE] == 2) - r = "s->cmem[s->ca++]"; + r = "cmem[ca++]"; else abort(); @@ -670,19 +670,19 @@ static void cintrp_expand(char **p, int s, int e, const int *cv) case PD: if(cv[IxDMODE] == 0) if(cv[IxDBP]) - scs(p, "(s->dmem1[(i->param + s->ba1) & 0x1f] << 8)"); + scs(p, "(dmem1[(i->param + ba1) & 0x1f] << 8)"); else - scs(p, "(s->dmem0[(i->param + s->ba0) & 0xff] << 8)"); + scs(p, "(dmem0[(i->param + ba0) & 0xff] << 8)"); else if(cv[IxDMODE] == 1) if(cv[IxDBP]) - scs(p, "(s->dmem1[(s->id + s->ba1) & 0x1f] << 8)"); + scs(p, "(dmem1[(id + ba1) & 0x1f] << 8)"); else - scs(p, "(s->dmem0[(s->id + s->ba0) & 0xff] << 8)"); + scs(p, "(dmem0[(id + ba0) & 0xff] << 8)"); else if(cv[IxDMODE] == 2) if(cv[IxDBP]) - scs(p, "(s->dmem1[((s->id++) + s->ba1) & 0x1f] << 8)"); + scs(p, "(dmem1[((id++) + ba1) & 0x1f] << 8)"); else - scs(p, "(s->dmem0[((s->id++) + s->ba0) & 0xff] << 8)"); + scs(p, "(dmem0[((id++) + ba0) & 0xff] << 8)"); else abort(); break; @@ -694,32 +694,32 @@ static void cintrp_expand(char **p, int s, int e, const int *cv) case PD24: if(cv[IxDMODE] == 0) if(cv[IxDBP]) - scs(p, "s->dmem1[(i->param + s->ba1) & 0x1f]"); + scs(p, "dmem1[(i->param + ba1) & 0x1f]"); else - scs(p, "s->dmem0[(i->param + s->ba0) & 0xff]"); + scs(p, "dmem0[(i->param + ba0) & 0xff]"); else if(cv[IxDMODE] == 1) if(cv[IxDBP]) - scs(p, "s->dmem1[(s->id + s->ba1) & 0x1f]"); + scs(p, "dmem1[(id + ba1) & 0x1f]"); else - scs(p, "s->dmem0[(s->id + s->ba0) & 0xff]"); + scs(p, "dmem0[(id + ba0) & 0xff]"); else if(cv[IxDMODE] == 2) if(cv[IxDBP]) - scs(p, "s->dmem1[((s->id++) + s->ba1) & 0x1f]"); + scs(p, "dmem1[((id++) + ba1) & 0x1f]"); else - scs(p, "s->dmem0[((s->id++) + s->ba0) & 0xff]"); + scs(p, "dmem0[((id++) + ba0) & 0xff]"); else abort(); break; case PML: if(cv[IxSFMA] == 0) - scs(p, "s->macc"); + scs(p, "macc"); else if(cv[IxSFMA] == 1) - scs(p, "(s->macc << 2)"); + scs(p, "(macc << 2)"); else if(cv[IxSFMA] == 2) - scs(p, "(s->macc << 4)"); + scs(p, "(macc << 4)"); else if(cv[IxSFMA] == 3) - scs(p, "(s->macc >> 16)"); + scs(p, "(macc >> 16)"); else abort(); break; @@ -743,23 +743,23 @@ static void cintrp_expand(char **p, int s, int e, const int *cv) }; char r[256]; - sprintf(r, "tms57002_macc_to_output_%d%s(s, 0x%016" I64FMT "xULL, 0x%016" I64FMT "xULL)", cv[IxSFMO], cv[IxMOVM] ? "s" : "", rounding[cv[IxRND]], rmask[cv[IxRND]]); + sprintf(r, "macc_to_output_%d%s(0x%016" I64FMT "xULL, 0x%016" I64FMT "xULL)", cv[IxSFMO], cv[IxMOVM] ? "s" : "", rounding[cv[IxRND]], rmask[cv[IxRND]]); scs(p, r); break; } case PMV: { char r[256]; - sprintf(r, "tms57002_check_macc_overflow_%d%s(s)", cv[IxSFMO], cv[IxMOVM] ? "s" : ""); + sprintf(r, "check_macc_overflow_%d%s()", cv[IxSFMO], cv[IxMOVM] ? "s" : ""); scs(p, r); break; } case PB: - scs(p, "s->pc = "); + scs(p, "pc = "); cintrp_expand(p, parse_res[i].ppos[0], parse_res[i].ppos[1], cv); scs(p, ";\n"); - scs(p, " s->sti |= S_BRANCH"); + scs(p, " sti |= S_BRANCH"); break; case PWA: @@ -767,17 +767,17 @@ static void cintrp_expand(char **p, int s, int e, const int *cv) cintrp_expand(p, parse_res[i].ppos[0], parse_res[i].ppos[1], cv); scs(p, ";\n"); scs(p, " if(r < -0x80000000 || r > 0x7fffffff)\n"); - scs(p, " s->st1 |= ST1_AOV;\n"); - scs(p, " s->aacc = r"); + scs(p, " st1 |= ST1_AOV;\n"); + scs(p, " aacc = r"); break; case PWC: if(cv[IxCMODE] == 0) - scs(p, "s->cmem[i->param] = "); + scs(p, "cmem[i->param] = "); else if(cv[IxCMODE] == 1) - scs(p, "s->cmem[s->ca] = "); + scs(p, "cmem[ca] = "); else if(cv[IxCMODE] == 2) - scs(p, "s->cmem[s->ca++] = "); + scs(p, "cmem[ca++] = "); else abort(); @@ -787,19 +787,19 @@ static void cintrp_expand(char **p, int s, int e, const int *cv) case PWD: if(cv[IxDMODE] == 0) if(cv[IxDBP]) - scs(p, "s->dmem1[(i->param + s->ba1) & 0x1f] = "); + scs(p, "dmem1[(i->param + ba1) & 0x1f] = "); else - scs(p, "s->dmem0[(i->param + s->ba0) & 0xff] = "); + scs(p, "dmem0[(i->param + ba0) & 0xff] = "); else if(cv[IxDMODE] == 1) if(cv[IxDBP]) - scs(p, "s->dmem1[(s->id + s->ba1) & 0x1f] = "); + scs(p, "dmem1[(id + ba1) & 0x1f] = "); else - scs(p, "s->dmem0[(s->id + s->ba0) & 0xff] = "); + scs(p, "dmem0[(id + ba0) & 0xff] = "); else if(cv[IxDMODE] == 2) if(cv[IxDBP]) - scs(p, "s->dmem1[((s->id++) + s->ba1) & 0x1f] = "); + scs(p, "dmem1[((id++) + ba1) & 0x1f] = "); else - scs(p, "s->dmem0[((s->id++) + s->ba0) & 0xff] = "); + scs(p, "dmem0[((id++) + ba0) & 0xff] = "); else abort(); @@ -876,7 +876,7 @@ static void save_dasm(FILE *f) save_dasm_cat(f, "DASM3", cat3, 0x80); } -static void save_intrp(FILE *f) +void save_intrp(FILE *f) { save_intrp_cat(f, "INTRP1", cat1, 0x40, 0, 0); save_intrp_cat(f, "INTRP2A", cat2, 0x80, I_POST, 0); @@ -916,7 +916,7 @@ static void save(const char *fname) compute_cache_ids(); save_dasm(f); - save_intrp(f); + // save_intrp(f); save_cdec(f); save_cintrp(f); diff --git a/src/mame/drivers/konamigx.c b/src/mame/drivers/konamigx.c index 7f6ac76c0b5..44589247841 100644 --- a/src/mame/drivers/konamigx.c +++ b/src/mame/drivers/konamigx.c @@ -1257,32 +1257,32 @@ static WRITE16_HANDLER( sndcomm68k_w ) static INTERRUPT_GEN(tms_sync) { - tms57002_sync(device); + downcast(device)->sync(); } static READ16_HANDLER(tms57002_data_word_r) { - return tms57002_data_r(space->machine().device("dasp"), 0); + return space->machine().device("dasp")->data_r(*space, 0); } static WRITE16_HANDLER(tms57002_data_word_w) { if (ACCESSING_BITS_0_7) - tms57002_data_w(space->machine().device("dasp"), 0, data); + space->machine().device("dasp")->data_w(*space, 0, data); } static READ16_HANDLER(tms57002_status_word_r) { - return (tms57002_dready_r(space->machine().device("dasp"), 0) ? 4 : 0) | - (tms57002_empty_r(space->machine().device("dasp"), 0) ? 1 : 0); + return (space->machine().device("dasp")->dready_r(*space, 0) ? 4 : 0) | + (space->machine().device("dasp")->empty_r(*space, 0) ? 1 : 0); } static WRITE16_HANDLER(tms57002_control_word_w) { if (ACCESSING_BITS_0_7) { - tms57002_pload_w(space->machine().device("dasp"), 0, data & 4); - tms57002_cload_w(space->machine().device("dasp"), 0, data & 8); + space->machine().device("dasp")->pload_w(*space, 0, data & 4); + space->machine().device("dasp")->cload_w(*space, 0, data & 8); cputag_set_input_line(space->machine(), "dasp", INPUT_LINE_RESET, !(data & 16) ? ASSERT_LINE : CLEAR_LINE); } }