Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-05 08:41:31 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Merge pull request #4926 from cam900/asic65_args

Browse Source 
asic65.cpp : Updates
This commit is contained in:
R. Belmont 2019-04-26 12:12:42 -04:00 committed by GitHub
commit 3991aba388
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 138 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/mame/drivers/harddriv.cpp
View File

@ -4862,9 +4862,9 @@ void harddriv_state::init_dsk()
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x910000, 0x910fff, read8_delegate(FUNC(eeprom_parallel_28xx_device::read), m_dsk_30c.target()), write8_delegate(FUNC(eeprom_parallel_28xx_device::write), m_dsk_30c.target()), 0x00ff); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x910000, 0x910fff, read8_delegate(FUNC(eeprom_parallel_28xx_device::read), m_dsk_30c.target()), write8_delegate(FUNC(eeprom_parallel_28xx_device::write), m_dsk_30c.target()), 0x00ff);
/* install ASIC65 */ /* install ASIC65 */
m_maincpu->space(AS_PROGRAM).install_write_handler(0x914000, 0x917fff, write16_delegate(FUNC(asic65_device::data_w), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x914000, 0x917fff, write16sm_delegate(FUNC(asic65_device::data_w), (asic65_device*)m_asic65));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x914000, 0x917fff, read16_delegate(FUNC(asic65_device::read), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x914000, 0x917fff, read16smo_delegate(FUNC(asic65_device::read), (asic65_device*)m_asic65));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x918000, 0x91bfff, read16_delegate(FUNC(asic65_device::io_r), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x918000, 0x91bfff, read16smo_delegate(FUNC(asic65_device::io_r), (asic65_device*)m_asic65));
/* install extra ROM */ /* install extra ROM */
m_maincpu->space(AS_PROGRAM).install_read_handler(0x940000, 0x9fffff, read16_delegate(FUNC(harddriv_state::hd68k_dsk_small_rom_r), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x940000, 0x9fffff, read16_delegate(FUNC(harddriv_state::hd68k_dsk_small_rom_r), this));
@ -4878,9 +4878,9 @@ void harddriv_state::init_dsk2()
uint8_t *usr3 = memregion("user3")->base(); uint8_t *usr3 = memregion("user3")->base();
/* install ASIC65 */ /* install ASIC65 */
m_maincpu->space(AS_PROGRAM).install_write_handler(0x824000, 0x824003, write16_delegate(FUNC(asic65_device::data_w), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x824000, 0x824003, write16sm_delegate(FUNC(asic65_device::data_w), (asic65_device*)m_asic65));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x824000, 0x824003, read16_delegate(FUNC(asic65_device::read), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x824000, 0x824003, read16smo_delegate(FUNC(asic65_device::read), (asic65_device*)m_asic65));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x825000, 0x825001, read16_delegate(FUNC(asic65_device::io_r), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x825000, 0x825001, read16smo_delegate(FUNC(asic65_device::io_r), (asic65_device*)m_asic65));
/* install ASIC61 */ /* install ASIC61 */
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x827000, 0x8277ff, read16_delegate(FUNC(harddriv_state::hd68k_dsk_dsp32_r), this), write16_delegate(FUNC(harddriv_state::hd68k_dsk_dsp32_w), this)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x827000, 0x8277ff, read16_delegate(FUNC(harddriv_state::hd68k_dsk_dsp32_r), this), write16_delegate(FUNC(harddriv_state::hd68k_dsk_dsp32_w), this));
@ -4902,9 +4902,9 @@ void harddriv_state::init_dsk2()
void harddriv_state::init_dspcom() void harddriv_state::init_dspcom()
{ {
/* install ASIC65 */ /* install ASIC65 */
m_maincpu->space(AS_PROGRAM).install_write_handler(0x900000, 0x900003, write16_delegate(FUNC(asic65_device::data_w), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x900000, 0x900003, write16sm_delegate(FUNC(asic65_device::data_w), (asic65_device*)m_asic65));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x900000, 0x900003, read16_delegate(FUNC(asic65_device::read), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x900000, 0x900003, read16smo_delegate(FUNC(asic65_device::read), (asic65_device*)m_asic65));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x901000, 0x910001, read16_delegate(FUNC(asic65_device::io_r), (asic65_device*)m_asic65)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x901000, 0x910001, read16smo_delegate(FUNC(asic65_device::io_r), (asic65_device*)m_asic65));
/* install DSPCOM control */ /* install DSPCOM control */
m_maincpu->space(AS_PROGRAM).install_write_handler(0x904000, 0x90401f, write16_delegate(FUNC(harddriv_state::hddspcom_control_w), this)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x904000, 0x90401f, write16_delegate(FUNC(harddriv_state::hddspcom_control_w), this));

192
src/mame/machine/asic65.cpp
View File

@ -9,6 +9,7 @@
#include "emu.h" #include "emu.h"
#include "asic65.h" #include "asic65.h"
#include <algorithm>
#define LOG_ASIC 0 #define LOG_ASIC 0
@ -36,7 +37,7 @@
#define MAX_COMMANDS 0x2b #define MAX_COMMANDS 0x2b
static const uint8_t command_map[3][MAX_COMMANDS] = static const u8 command_map[3][MAX_COMMANDS] =
{ {
{ {
/* standard version */ /* standard version */
@ -84,28 +85,25 @@ static const uint8_t command_map[3][MAX_COMMANDS] =
DEFINE_DEVICE_TYPE(ASIC65, asic65_device, "asic65", "Atari ASIC65") DEFINE_DEVICE_TYPE(ASIC65, asic65_device, "asic65", "Atari ASIC65")
asic65_device::asic65_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) asic65_device::asic65_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, ASIC65, tag, owner, clock), : device_t(mconfig, ASIC65, tag, owner, clock)
m_asic65_type(0), , m_asic65_type(0)
m_command(0), , m_command(0)
m_yorigin(0x1800), , m_yorigin(0x1800)
m_param_index(0), , m_param_index(0)
m_result_index(0), , m_result_index(0)
m_reset_state(0), , m_reset_state(0)
m_last_bank(0), , m_last_bank(0)
m_ourcpu(*this, "asic65cpu"), , m_ourcpu(*this, "asic65cpu")
m_tfull(0), , m_tfull(0)
m_68full(0), , m_68full(0)
m_cmd(0), , m_cmd(0)
m_xflg(0), , m_xflg(0)
m_68data(0), , m_68data(0)
m_tdata(0), , m_tdata(0)
m_log(nullptr) , m_log(nullptr)
{ {
for (auto & elem : m_param) std::fill(std::begin(m_param), std::end(m_param), 0);
{
elem = 0;
}
} }
//------------------------------------------------- //-------------------------------------------------
@ -140,8 +138,6 @@ void asic65_device::device_reset()
void asic65_device::reset_line(int state) void asic65_device::reset_line(int state)
{ {
address_space &space = subdevice("^maincpu")->memory().space(AS_PROGRAM);
/* rom-based means reset and clear states */ /* rom-based means reset and clear states */
if (m_asic65_type == ASIC65_ROMBASED) if (m_asic65_type == ASIC65_ROMBASED)
m_ourcpu->set_input_line(INPUT_LINE_RESET, state ? ASSERT_LINE : CLEAR_LINE); m_ourcpu->set_input_line(INPUT_LINE_RESET, state ? ASSERT_LINE : CLEAR_LINE);
@ -159,7 +155,7 @@ void asic65_device::reset_line(int state)
else if (!state && m_reset_state) else if (!state && m_reset_state)
{ {
if (m_command != -1) if (m_command != -1)
data_w(space, 1, m_command, 0xffff); data_w(1, m_command);
} }
/* update the state */ /* update the state */
@ -190,7 +186,7 @@ void asic65_device::device_timer(emu_timer &timer, device_timer_id id, int param
} }
WRITE16_MEMBER( asic65_device::data_w ) void asic65_device::data_w(offs_t offset, u16 data)
{ {
/* logging */ /* logging */
if (LOG_ASIC && !m_log) m_log = fopen("m_log", "w"); if (LOG_ASIC && !m_log) m_log = fopen("m_log", "w");
@ -227,16 +223,19 @@ WRITE16_MEMBER( asic65_device::data_w )
} }
READ16_MEMBER( asic65_device::read ) u16 asic65_device::read()
{ {
int64_t element, result64 = 0; s64 element, result64 = 0;
uint16_t result = 0; u16 result = 0;
/* rom-based just returns latched data */ /* rom-based just returns latched data */
if (m_asic65_type == ASIC65_ROMBASED) if (m_asic65_type == ASIC65_ROMBASED)
{ {
m_68full = 0; if (!machine().side_effects_disabled())
machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(5)); {
m_68full = 0;
machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(5));
}
return m_68data; return m_68data;
} }
@ -246,7 +245,8 @@ READ16_MEMBER( asic65_device::read )
switch (command) switch (command)
{ {
case OP_UNKNOWN: /* return bogus data */ case OP_UNKNOWN: /* return bogus data */
popmessage("ASIC65: Unknown cmd %02X", m_command); if (!machine().side_effects_disabled())
popmessage("ASIC65: Unknown cmd %02X", m_command);
break; break;
case OP_REFLECT: /* reflect data */ case OP_REFLECT: /* reflect data */
@ -267,26 +267,27 @@ READ16_MEMBER( asic65_device::read )
break; break;
case OP_RESET: /* reset */ case OP_RESET: /* reset */
m_result_index = m_param_index = 0; if (!machine().side_effects_disabled())
m_result_index = m_param_index = 0;
break; break;
case OP_SIN: /* sin */ case OP_SIN: /* sin */
if (m_param_index >= 1) if (m_param_index >= 1)
result = (int)(16384. * sin(M_PI * (double)(int16_t)m_param[0] / 32768.)); result = (int)(16384. * sin(M_PI * (double)(s16)m_param[0] / 32768.));
break; break;
case OP_COS: /* cos */ case OP_COS: /* cos */
if (m_param_index >= 1) if (m_param_index >= 1)
result = (int)(16384. * cos(M_PI * (double)(int16_t)m_param[0] / 32768.)); result = (int)(16384. * cos(M_PI * (double)(s16)m_param[0] / 32768.));
break; break;
case OP_ATAN: /* vector angle */ case OP_ATAN: /* vector angle */
if (m_param_index >= 4) if (m_param_index >= 4)
{ {
int32_t xint = (int32_t)((m_param[0] << 16) | m_param[1]); s32 xint = (s32)((m_param[0] << 16) | m_param[1]);
int32_t yint = (int32_t)((m_param[2] << 16) | m_param[3]); s32 yint = (s32)((m_param[2] << 16) | m_param[3]);
double a = atan2((double)yint, (double)xint); double a = atan2((double)yint, (double)xint);
result = (int16_t)(a * 32768. / M_PI); result = (s16)(a * 32768. / M_PI);
} }
break; break;
@ -295,78 +296,83 @@ READ16_MEMBER( asic65_device::read )
/* in Race Drivin' will be off */ /* in Race Drivin' will be off */
if (m_param_index >= 9+6) if (m_param_index >= 9+6)
{ {
int32_t v0 = (int32_t)((m_param[9] << 16) | m_param[10]); s32 v0 = (s32)((m_param[9] << 16) | m_param[10]);
int32_t v1 = (int32_t)((m_param[11] << 16) | m_param[12]); s32 v1 = (s32)((m_param[11] << 16) | m_param[12]);
int32_t v2 = (int32_t)((m_param[13] << 16) | m_param[14]); s32 v2 = (s32)((m_param[13] << 16) | m_param[14]);
/* 2 results per element */ /* 2 results per element */
switch (m_result_index / 2) switch (m_result_index / 2)
{ {
case 0: case 0:
result64 = (int64_t)v0 * (int16_t)m_param[0] + result64 = (s64)v0 * (s16)m_param[0] +
(int64_t)v1 * (int16_t)m_param[3] + (s64)v1 * (s16)m_param[3] +
(int64_t)v2 * (int16_t)m_param[6]; (s64)v2 * (s16)m_param[6];
break; break;
case 1: case 1:
result64 = (int64_t)v0 * (int16_t)m_param[1] + result64 = (s64)v0 * (s16)m_param[1] +
(int64_t)v1 * (int16_t)m_param[4] + (s64)v1 * (s16)m_param[4] +
(int64_t)v2 * (int16_t)m_param[7]; (s64)v2 * (s16)m_param[7];
break; break;
case 2: case 2:
result64 = (int64_t)v0 * (int16_t)m_param[2] + result64 = (s64)v0 * (s16)m_param[2] +
(int64_t)v1 * (int16_t)m_param[5] + (s64)v1 * (s16)m_param[5] +
(int64_t)v2 * (int16_t)m_param[8]; (s64)v2 * (s16)m_param[8];
break; break;
} }
/* remove lower 14 bits and pass back either upper or lower words */ /* remove lower 14 bits and pass back either upper or lower words */
result64 >>= 14; result64 >>= 14;
result = (m_result_index & 1) ? (result64 & 0xffff) : ((result64 >> 16) & 0xffff); result = (m_result_index & 1) ? (result64 & 0xffff) : ((result64 >> 16) & 0xffff);
m_result_index++; if (!machine().side_effects_disabled())
m_result_index++;
} }
break; break;
case OP_MATRIXMULT: /* matrix multiply???? */ case OP_MATRIXMULT: /* matrix multiply???? */
if (m_param_index >= 9+6) if (m_param_index >= 9+6)
{ {
int32_t v0 = (int32_t)((m_param[9] << 16) | m_param[10]); s32 v0 = (s32)((m_param[9] << 16) | m_param[10]);
int32_t v1 = (int32_t)((m_param[11] << 16) | m_param[12]); s32 v1 = (s32)((m_param[11] << 16) | m_param[12]);
int32_t v2 = (int32_t)((m_param[13] << 16) | m_param[14]); s32 v2 = (s32)((m_param[13] << 16) | m_param[14]);
/* 2 results per element */ /* 2 results per element */
switch (m_result_index / 2) switch (m_result_index / 2)
{ {
case 0: case 0:
result64 = (int64_t)v0 * (int16_t)m_param[0] + result64 = (s64)v0 * (s16)m_param[0] +
(int64_t)v1 * (int16_t)m_param[1] + (s64)v1 * (s16)m_param[1] +
(int64_t)v2 * (int16_t)m_param[2]; (s64)v2 * (s16)m_param[2];
break; break;
case 1: case 1:
result64 = (int64_t)v0 * (int16_t)m_param[3] + result64 = (s64)v0 * (s16)m_param[3] +
(int64_t)v1 * (int16_t)m_param[4] + (s64)v1 * (s16)m_param[4] +
(int64_t)v2 * (int16_t)m_param[5]; (s64)v2 * (s16)m_param[5];
break; break;
case 2: case 2:
result64 = (int64_t)v0 * (int16_t)m_param[6] + result64 = (s64)v0 * (s16)m_param[6] +
(int64_t)v1 * (int16_t)m_param[7] + (s64)v1 * (s16)m_param[7] +
(int64_t)v2 * (int16_t)m_param[8]; (s64)v2 * (s16)m_param[8];
break; break;
} }
/* remove lower 14 bits and pass back either upper or lower words */ /* remove lower 14 bits and pass back either upper or lower words */
result64 >>= 14; result64 >>= 14;
result = (m_result_index & 1) ? (result64 & 0xffff) : ((result64 >> 16) & 0xffff); result = (m_result_index & 1) ? (result64 & 0xffff) : ((result64 >> 16) & 0xffff);
m_result_index++; if (!machine().side_effects_disabled())
m_result_index++;
} }
break; break;
case OP_YORIGIN: case OP_YORIGIN:
if (m_param_index >= 1) if (m_param_index >= 1)
m_yorigin = m_param[m_param_index - 1]; {
if (!machine().side_effects_disabled())
m_yorigin = m_param[m_param_index - 1];
}
break; break;
case OP_TRANSFORM: /* 3d transform */ case OP_TRANSFORM: /* 3d transform */
@ -379,40 +385,41 @@ READ16_MEMBER( asic65_device::read )
/* return 0 == scale factor for 1/z */ /* return 0 == scale factor for 1/z */
/* return 1 == transformed X */ /* return 1 == transformed X */
/* return 2 == transformed Y, taking height into account */ /* return 2 == transformed Y, taking height into account */
element = (int16_t)m_param[0]; element = (s16)m_param[0];
if (m_param_index == 2) if (m_param_index == 2)
{ {
result64 = (element * (int16_t)m_param[1]) >> 8; result64 = (element * (s16)m_param[1]) >> 8;
result64 -= 1; result64 -= 1;
if (result64 > 0x3fff) result64 = 0; if (result64 > 0x3fff) result64 = 0;
} }
else if (m_param_index == 3) else if (m_param_index == 3)
{ {
result64 = (element * (int16_t)m_param[2]) >> 15; result64 = (element * (s16)m_param[2]) >> 15;
result64 += 0xa8; result64 += 0xa8;
} }
else if (m_param_index == 4) else if (m_param_index == 4)
{ {
result64 = (int16_t)((element * (int16_t)m_param[3]) >> 10); result64 = (s16)((element * (s16)m_param[3]) >> 10);
result64 = (int16_t)m_yorigin - result64 - (result64 << 1); result64 = (s16)m_yorigin - result64 - (result64 << 1);
} }
result = result64 & 0xffff; result = result64 & 0xffff;
} }
break; break;
case OP_INITBANKS: /* initialize banking */ case OP_INITBANKS: /* initialize banking */
m_last_bank = 0; if (!machine().side_effects_disabled())
m_last_bank = 0;
break; break;
case OP_SETBANK: /* set a bank */ case OP_SETBANK: /* set a bank */
{ {
static const uint8_t banklist[] = static const u8 banklist[] =
{ {
1,4,0,4,4,3,4,2, 4,4,4,4,4,4,4,4, 1,4,0,4,4,3,4,2, 4,4,4,4,4,4,4,4,
3,3,4,4,1,1,0,0, 4,4,4,4,2,2,4,4, 3,3,4,4,1,1,0,0, 4,4,4,4,2,2,4,4,
4,4 4,4
}; };
static const uint16_t bankaddr[][8] = static const u16 bankaddr[][8] =
{ {
{ 0x77c0,0x77ce,0x77c2,0x77cc,0x77c4,0x77ca,0x77c6,0x77c8 }, { 0x77c0,0x77ce,0x77c2,0x77cc,0x77c4,0x77ca,0x77c6,0x77c8 },
{ 0x77d0,0x77de,0x77d2,0x77dc,0x77d4,0x77da,0x77d6,0x77d8 }, { 0x77d0,0x77de,0x77d2,0x77dc,0x77d4,0x77da,0x77d6,0x77d8 },
@ -423,16 +430,20 @@ READ16_MEMBER( asic65_device::read )
if (m_param_index >= 1) if (m_param_index >= 1)
{ {
if (m_param_index < sizeof(banklist) && banklist[m_param[0]] < 4) if (m_param_index < sizeof(banklist) && banklist[m_param[0]] < 4)
m_last_bank = banklist[m_param[0]]; {
if (!machine().side_effects_disabled())
m_last_bank = banklist[m_param[0]];
}
result = bankaddr[m_last_bank][(m_result_index < 8) ? m_result_index : 7]; result = bankaddr[m_last_bank][(m_result_index < 8) ? m_result_index : 7];
m_result_index++; if (!machine().side_effects_disabled())
m_result_index++;
} }
break; break;
} }
case OP_VERIFYBANK: /* verify a bank */ case OP_VERIFYBANK: /* verify a bank */
{ {
static const uint16_t bankverify[] = static const u16 bankverify[] =
{ {
0x0eb2,0x1000,0x171b,0x3d28 0x0eb2,0x1000,0x171b,0x3d28
}; };
@ -448,7 +459,7 @@ READ16_MEMBER( asic65_device::read )
} }
READ16_MEMBER( asic65_device::io_r ) u16 asic65_device::io_r()
{ {
if (m_asic65_type == ASIC65_ROMBASED) if (m_asic65_type == ASIC65_ROMBASED)
{ {
@ -456,7 +467,8 @@ READ16_MEMBER( asic65_device::io_r )
/* bit 14 = 68FULL */ /* bit 14 = 68FULL */
/* bit 13 = XFLG */ /* bit 13 = XFLG */
/* bit 12 = controlled by jumper */ /* bit 12 = controlled by jumper */
machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(5)); if (!machine().side_effects_disabled())
machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(5));
return (m_tfull << 15) | (m_68full << 14) | (m_xflg << 13) | 0x0000; return (m_tfull << 15) | (m_68full << 14) | (m_xflg << 13) | 0x0000;
} }
else else
@ -474,29 +486,32 @@ READ16_MEMBER( asic65_device::io_r )
* *
*************************************/ *************************************/
WRITE16_MEMBER( asic65_device::m68k_w ) void asic65_device::m68k_w(u16 data)
{ {
m_68full = 1; m_68full = 1;
m_68data = data; m_68data = data;
} }
READ16_MEMBER( asic65_device::m68k_r ) u16 asic65_device::m68k_r()
{ {
m_tfull = 0; if (!machine().side_effects_disabled())
if (m_asic65_type == ASIC65_ROMBASED) {
m_ourcpu->set_input_line(0, CLEAR_LINE); m_tfull = 0;
if (m_asic65_type == ASIC65_ROMBASED)
m_ourcpu->set_input_line(0, CLEAR_LINE);
}
return m_tdata; return m_tdata;
} }
WRITE16_MEMBER( asic65_device::stat_w ) void asic65_device::stat_w(u16 data)
{ {
m_xflg = data & 1; m_xflg = data & 1;
} }
READ16_MEMBER( asic65_device::stat_r ) u16 asic65_device::stat_r()
{ {
/* bit 15 = 68FULL */ /* bit 15 = 68FULL */
/* bit 14 = TFULL */ /* bit 14 = TFULL */
@ -508,8 +523,11 @@ READ16_MEMBER( asic65_device::stat_r )
READ_LINE_MEMBER( asic65_device::get_bio ) READ_LINE_MEMBER( asic65_device::get_bio )
{ {
if (!m_tfull) if (!machine().side_effects_disabled())
m_ourcpu->spin_until_interrupt(); {
if (!m_tfull)
m_ourcpu->spin_until_interrupt();
}
return m_tfull ? CLEAR_LINE : ASSERT_LINE; return m_tfull ? CLEAR_LINE : ASSERT_LINE;
} }

48
src/mame/machine/asic65.h
View File

@ -22,26 +22,26 @@ enum {
class asic65_device : public device_t class asic65_device : public device_t
{ {
public: public:
asic65_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock, uint8_t type) asic65_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock, u8 type)
: asic65_device(mconfig, tag, owner, clock) : asic65_device(mconfig, tag, owner, clock)
{ {
set_type(type); set_type(type);
} }
asic65_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); asic65_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
// configuration helpers // configuration helpers
void set_type(uint8_t type) { m_asic65_type = type; } void set_type(u8 type) { m_asic65_type = type; }
void reset_line(int state); void reset_line(int state);
DECLARE_WRITE16_MEMBER( data_w ); void data_w(offs_t offset, u16 data);
DECLARE_READ16_MEMBER( read ); u16 read();
DECLARE_READ16_MEMBER( io_r ); u16 io_r();
DECLARE_WRITE16_MEMBER( m68k_w ); void m68k_w(u16 data);
DECLARE_READ16_MEMBER( m68k_r ); u16 m68k_r();
DECLARE_WRITE16_MEMBER( stat_w ); void stat_w(u16 data);
DECLARE_READ16_MEMBER( stat_r ); u16 stat_r();
enum enum
{ {
@ -58,23 +58,23 @@ protected:
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override; virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
private: private:
uint8_t m_asic65_type; u8 m_asic65_type;
int m_command; int m_command;
uint16_t m_param[32]; u16 m_param[32];
uint16_t m_yorigin; u16 m_yorigin;
uint8_t m_param_index; u8 m_param_index;
uint8_t m_result_index; u8 m_result_index;
uint8_t m_reset_state; u8 m_reset_state;
uint8_t m_last_bank; u8 m_last_bank;
/* ROM-based interface states */ /* ROM-based interface states */
required_device<tms32010_device> m_ourcpu; required_device<tms32010_device> m_ourcpu;
uint8_t m_tfull; u8 m_tfull;
uint8_t m_68full; u8 m_68full;
uint8_t m_cmd; u8 m_cmd;
uint8_t m_xflg; u8 m_xflg;
uint16_t m_68data; u16 m_68data;
uint16_t m_tdata; u16 m_tdata;
FILE * m_log; FILE * m_log;