void z80ctc_init(int which, z80ctc_interface *intf)
{
z80ctc *ctc = &ctcs[which];
assert(which < MAX_CTC);
memset(ctc, 0, sizeof(*ctc));
ctc->clock = intf->baseclock;
ctc->invclock16 = 16.0 / (double)intf->baseclock;
ctc->invclock256 = 256.0 / (double)intf->baseclock;
ctc->notimer = intf->notimer;
ctc->intr = intf->intr;
ctc->timer[0] = timer_alloc(timercallback);
ctc->timer[1] = timer_alloc(timercallback);
ctc->timer[2] = timer_alloc(timercallback);
ctc->timer[3] = timer_alloc(timercallback);
ctc->zc[0] = intf->zc0;
ctc->zc[1] = intf->zc1;
ctc->zc[2] = intf->zc2;
ctc->zc[3] = 0;
z80ctc_reset(which);
state_save_register_item("z80ctc", which, ctc->vector);
state_save_register_item_array("z80ctc", which, ctc->mode);
state_save_register_item_array("z80ctc", which, ctc->tconst);
state_save_register_item_array("z80ctc", which, ctc->down);
state_save_register_item_array("z80ctc", which, ctc->extclk);
state_save_register_item_array("z80ctc", which, ctc->int_state);
}
static void tms7000_init(int index, int clock, const void *config, int (*irqcallback)(int))
{
int cpu = cpu_getactivecpu();
tms7000.irq_callback = irqcallback;
memset(tms7000.pf, 0, 0x100);
memset(tms7000.rf, 0, 0x80);
/* Save register state */
state_save_register_item("tms7000", cpu, pPC);
state_save_register_item("tms7000", cpu, pSP);
state_save_register_item("tms7000", cpu, pSR);
/* Save Interrupt state */
state_save_register_item_array("tms7000", cpu, tms7000.irq_state);
/* Save register and perpherial file state */
state_save_register_item_array("tms7000", cpu, tms7000.rf);
state_save_register_item_array("tms7000", cpu, tms7000.pf);
/* Save timer state */
state_save_register_item("tms7000", cpu, tms7000.t1_prescaler);
state_save_register_item("tms7000", cpu, tms7000.t1_capture_latch);
state_save_register_item("tms7000", cpu, tms7000.t1_decrementer);
state_save_register_item("tms7000", cpu, tms7000.idle_state);
tms7000.irq_callback = irqcallback;
}
void microtouch_init(running_machine &machine, microtouch_tx_func tx_cb, microtouch_touch_func touch_cb)
{
memset(µtouch, 0, sizeof(microtouch));
microtouch.last_touch_state = -1;
microtouch.tx_callback = tx_cb;
microtouch.touch_callback = touch_cb;
microtouch.timer = machine.scheduler().timer_alloc(FUNC(microtouch_timer_callback));
microtouch.timer->adjust(attotime::from_hz(167*5), 0, attotime::from_hz(167*5));
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.reset_done);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.format_tablet);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.mode_inactive);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.mode_stream);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_touch_state);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_x);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_y);
state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.rx_buffer);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.rx_buffer_ptr);
state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.tx_buffer);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_num);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_ptr);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.format_decimal);
};
void microtouch_init(running_machine *machine, microtouch_tx_func tx_cb, microtouch_touch_func touch_cb)
{
memset(µtouch, 0, sizeof(microtouch));
microtouch.last_touch_state = -1;
microtouch.tx_callback = tx_cb;
microtouch.touch_callback = touch_cb;
microtouch.timer = timer_alloc(machine, microtouch_timer_callback, NULL);
timer_adjust_periodic(microtouch.timer, ATTOTIME_IN_HZ(167*5), 0, ATTOTIME_IN_HZ(167*5));
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.reset_done);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.format_tablet);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.mode_inactive);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.mode_stream);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_touch_state);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_x);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.last_y);
state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.rx_buffer);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.rx_buffer_ptr);
state_save_register_item_array(machine, "microtouch", NULL, 0, microtouch.tx_buffer);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_num);
state_save_register_item(machine, "microtouch", NULL, 0, microtouch.tx_buffer_ptr);
};
static void arm_init(int index, int clock, const void *config, int (*irqcallback)(int))
{
arm.irq_callback = irqcallback;
state_save_register_item_array("arm", index, arm.sArmRegister);
state_save_register_item_array("arm", index, arm.coproRegister);
state_save_register_item("arm", index, arm.pendingIrq);
state_save_register_item("arm", index, arm.pendingFiq);
}
void init_konami_cgboard(running_machine *machine, int num_boards, int type)
{
int i;
num_cgboards = num_boards;
for (i=0; i < num_boards; i++)
{
dsp_comm_ppc[i][0] = 0x00;
dsp_shared_ram[i] = auto_alloc_array(machine, UINT32, DSP_BANK_SIZE * 2/4);
dsp_shared_ram_bank[i] = 0;
dsp_state[i] = 0x80;
texture_bank[i] = -1;
pci_bridge_enable[i] = 0;
nwk_device_sel[i] = 0;
nwk_fifo_read_ptr[i] = 0;
nwk_fifo_write_ptr[i] = 0;
nwk_fifo[i] = auto_alloc_array(machine, UINT32, 0x800);
nwk_ram[i] = auto_alloc_array(machine, UINT32, 0x2000);
state_save_register_item_array(machine, "konppc", NULL, i, dsp_comm_ppc[i]);
state_save_register_item_array(machine, "konppc", NULL, i, dsp_comm_sharc[i]);
state_save_register_item(machine, "konppc", NULL, i, dsp_shared_ram_bank[i]);
state_save_register_item_pointer(machine, "konppc", NULL, i, dsp_shared_ram[i], DSP_BANK_SIZE * 2 / sizeof(dsp_shared_ram[i][0]));
state_save_register_item(machine, "konppc", NULL, i, dsp_state[i]);
state_save_register_item(machine, "konppc", NULL, i, texture_bank[i]);
state_save_register_item(machine, "konppc", NULL, i, pci_bridge_enable[i]);
state_save_register_item(machine, "konppc", NULL, i, nwk_device_sel[i]);
state_save_register_item(machine, "konppc", NULL, i, nwk_fifo_read_ptr[i]);
state_save_register_item(machine, "konppc", NULL, i, nwk_fifo_write_ptr[i]);
state_save_register_item_pointer(machine, "konppc", NULL, i, nwk_fifo[i], 0x800);
state_save_register_item_pointer(machine, "konppc", NULL, i, nwk_ram[i], 0x2000);
}
state_save_register_item(machine, "konppc", NULL, 0, cgboard_id);
cgboard_type = type;
if (type == CGBOARD_TYPE_NWKTR)
{
nwk_fifo_half_full_r = 0x100;
nwk_fifo_half_full_w = 0xff;
nwk_fifo_full = 0x1ff;
nwk_fifo_mask = 0x1ff;
}
if (type == CGBOARD_TYPE_HANGPLT)
{
nwk_fifo_half_full_r = 0x3ff;
nwk_fifo_half_full_w = 0x400;
nwk_fifo_full = 0x7ff;
nwk_fifo_mask = 0x7ff;
}
}
void TTL74181_init( int chip )
{
struct TTL74181_chip *c = auto_malloc( sizeof( struct TTL74181_chip ) );
memset( c->inputs, 0, sizeof( c->inputs ) );
memset( c->outputs, 0, sizeof( c->outputs ) );
c->dirty = 1;
state_save_register_item_array( "TTL74181", chip, c->inputs );
state_save_register_item_array( "TTL74181", chip, c->outputs );
state_save_register_item( "TTL74181", chip, c->dirty );
chips[ chip ] = c;
}
struct crtc6845 *crtc6845_init(const struct crtc6845_config *config)
{
struct crtc6845 *crtc;
int idx;
crtc = auto_malloc(sizeof(struct crtc6845));
memset(crtc, 0, sizeof(*crtc));
crtc->cursor_time = timer_get_time();
crtc->config = *config;
crtc6845 = crtc;
/* Hardwire the values which can't be changed in the PC1512 version */
if (config->personality == M6845_PERSONALITY_PC1512)
{
for (idx = 0; idx < sizeof(pc1512_defaults); idx++)
{
crtc->reg[idx] = pc1512_defaults[idx];
}
}
state_save_register_item_array("crtc6845", 0, crtc->reg);
state_save_register_item("crtc6845", 0, crtc->idx);
state_save_register_func_postload(crtc6845_state_postload);
return crtc;
}
void x76f100_init( running_machine *machine, int chip, UINT8 *data )
{
int offset;
struct x76f100_chip *c;
if( chip >= X76F100_MAXCHIP )
{
verboselog( machine, 0, "x76f100_init( %d ) chip out of range\n", chip );
return;
}
c = &x76f100[ chip ];
if( data == NULL )
{
data = auto_alloc_array( machine, UINT8,
SIZE_RESPONSE_TO_RESET +
SIZE_READ_PASSWORD +
SIZE_WRITE_PASSWORD +
SIZE_DATA );
}
c->cs = 0;
c->rst = 0;
c->scl = 0;
c->sdaw = 0;
c->sdar = 0;
c->state = STATE_STOP;
c->shift = 0;
c->bit = 0;
c->byte = 0;
c->command = 0;
memset( c->write_buffer, 0, SIZE_WRITE_BUFFER );
offset = 0;
c->response_to_reset = &data[ offset ];
offset += SIZE_RESPONSE_TO_RESET;
c->write_password = &data[ offset ];
offset += SIZE_WRITE_PASSWORD;
c->read_password = &data[ offset ];
offset += SIZE_READ_PASSWORD;
c->data = &data[ offset ];
offset += SIZE_DATA;
state_save_register_item( machine, "x76f100", NULL, chip, c->cs );
state_save_register_item( machine, "x76f100", NULL, chip, c->rst );
state_save_register_item( machine, "x76f100", NULL, chip, c->scl );
state_save_register_item( machine, "x76f100", NULL, chip, c->sdaw );
state_save_register_item( machine, "x76f100", NULL, chip, c->sdar );
state_save_register_item( machine, "x76f100", NULL, chip, c->state );
state_save_register_item( machine, "x76f100", NULL, chip, c->shift );
state_save_register_item( machine, "x76f100", NULL, chip, c->bit );
state_save_register_item( machine, "x76f100", NULL, chip, c->byte );
state_save_register_item( machine, "x76f100", NULL, chip, c->command );
state_save_register_item_array( machine, "x76f100", NULL, chip, c->write_buffer );
state_save_register_item_pointer( machine, "x76f100", NULL, chip, c->response_to_reset, SIZE_RESPONSE_TO_RESET );
state_save_register_item_pointer( machine, "x76f100", NULL, chip, c->write_password, SIZE_WRITE_PASSWORD );
state_save_register_item_pointer( machine, "x76f100", NULL, chip, c->read_password, SIZE_READ_PASSWORD );
state_save_register_item_pointer( machine, "x76f100", NULL, chip, c->data, SIZE_DATA );
}
void generic_machine_init(running_machine *machine)
{
int counternum;
/* reset coin counters */
for (counternum = 0; counternum < COIN_COUNTERS; counternum++)
{
lastcoin[counternum] = 0;
coinlockedout[counternum] = 0;
servicecoinlockedout[counternum] = 0;
}
/* reset NVRAM size and pointers */
generic_nvram_size = 0;
generic_nvram = NULL;
generic_nvram16 = NULL;
generic_nvram32 = NULL;
/* reset memory card info */
memcard_inserted = -1;
/* register a reset callback and save state for interrupt enable */
add_reset_callback(machine, interrupt_reset);
state_save_register_item_array("cpu", 0, interrupt_enable);
/* register for configuration */
config_register("counters", counters_load, counters_save);
/* for memory cards, request save state and an exit callback */
if (machine->drv->memcard_handler != NULL)
{
state_save_register_global(memcard_inserted);
add_exit_callback(machine, memcard_eject);
}
}
static void scsidev_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
{
running_machine *machine = scsiInstance->machine;
SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
state_save_register_item_array( machine, "scsidev", diskregion, 0, our_this->command );
state_save_register_item( machine, "scsidev", diskregion, 0, our_this->commandLength );
state_save_register_item( machine, "scsidev", diskregion, 0, our_this->phase );
}
static void at28c16_init( int chip )
{
struct at28c16_chip *c;
if( chip >= MAX_AT28C16_CHIPS )
{
logerror( "at28c16_init: invalid chip %d\n", chip );
return;
}
c = &at28c16[ chip ];
c->a9_12v = 0;
memset( c->data, 0, DATA_SIZE );
memset( c->id, 0, ID_SIZE );
state_save_register_item_array( "at28c16", chip, c->data );
state_save_register_item_array( "at28c16", chip, c->id );
state_save_register_item( "at28c16", chip, c->a9_12v );
}
void v810_init(int index, int clock, const void *config, int (*irqcallback)(int))
{
v810.irq_line = CLEAR_LINE;
v810.nmi_line = CLEAR_LINE;
v810.irq_cb = irqcallback;
state_save_register_item_array("v810", index, v810.reg);
state_save_register_item("v810", index, v810.irq_line);
state_save_register_item("v810", index, v810.nmi_line);
state_save_register_item("v810", index, v810.PPC);
}
static void cr589_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
{
running_machine *machine = scsiInstance->machine;
SCSICr589 *our_this = (SCSICr589 *)SCSIThis( &SCSIClassCr589, scsiInstance );
our_this->download = 0;
memcpy( &our_this->buffer[ identity_offset ], "MATSHITACD-ROM CR-589 GS0N", 28 );
state_save_register_item( machine, "cr589", diskregion, 0, our_this->download );
state_save_register_item_array( machine, "cr589", diskregion, 0, our_this->buffer );
state_save_register_item( machine, "cr589", diskregion, 0, our_this->bufferOffset );
}
static void ay8910_statesave(ay8910_context *psg, int sndindex)
{
state_save_register_item("AY8910", sndindex, psg->register_latch);
state_save_register_item_array("AY8910", sndindex, psg->regs);
state_save_register_item("AY8910", sndindex, psg->last_enable);
state_save_register_item_array("AY8910", sndindex, psg->count);
state_save_register_item("AY8910", sndindex, psg->count_noise);
state_save_register_item("AY8910", sndindex, psg->count_env);
state_save_register_item("AY8910", sndindex, psg->env_volume);
state_save_register_item_array("AY8910", sndindex, psg->output);
state_save_register_item("AY8910", sndindex, psg->output_noise);
state_save_register_item("AY8910", sndindex, psg->env_step);
state_save_register_item("AY8910", sndindex, psg->hold);
state_save_register_item("AY8910", sndindex, psg->alternate);
state_save_register_item("AY8910", sndindex, psg->attack);
state_save_register_item("AY8910", sndindex, psg->holding);
state_save_register_item("AY8910", sndindex, psg->rng);
}
void *tms5220_create(int index)
{
struct tms5220 *tms;
tms = malloc(sizeof(*tms));
memset(tms, 0, sizeof(*tms));
state_save_register_item_array("tms5220", index, tms->fifo);
state_save_register_item("tms5220", index, tms->fifo_head);
state_save_register_item("tms5220", index, tms->fifo_tail);
state_save_register_item("tms5220", index, tms->fifo_count);
state_save_register_item("tms5220", index, tms->fifo_bits_taken);
state_save_register_item("tms5220", index, tms->tms5220_speaking);
state_save_register_item("tms5220", index, tms->speak_external);
state_save_register_item("tms5220", index, tms->talk_status);
state_save_register_item("tms5220", index, tms->first_frame);
state_save_register_item("tms5220", index, tms->last_frame);
state_save_register_item("tms5220", index, tms->buffer_low);
state_save_register_item("tms5220", index, tms->buffer_empty);
state_save_register_item("tms5220", index, tms->irq_pin);
state_save_register_item("tms5220", index, tms->old_energy);
state_save_register_item("tms5220", index, tms->old_pitch);
state_save_register_item_array("tms5220", index, tms->old_k);
state_save_register_item("tms5220", index, tms->new_energy);
state_save_register_item("tms5220", index, tms->new_pitch);
state_save_register_item_array("tms5220", index, tms->new_k);
state_save_register_item("tms5220", index, tms->current_energy);
state_save_register_item("tms5220", index, tms->current_pitch);
state_save_register_item_array("tms5220", index, tms->current_k);
state_save_register_item("tms5220", index, tms->target_energy);
state_save_register_item("tms5220", index, tms->target_pitch);
state_save_register_item_array("tms5220", index, tms->target_k);
state_save_register_item("tms5220", index, tms->interp_count);
state_save_register_item("tms5220", index, tms->sample_count);
state_save_register_item("tms5220", index, tms->pitch_count);
state_save_register_item_array("tms5220", index, tms->u);
state_save_register_item_array("tms5220", index, tms->x);
state_save_register_item("tms5220", index, tms->RNG);
state_save_register_item("tms5220", index, tms->schedule_dummy_read);
state_save_register_item("tms5220", index, tms->data_register);
state_save_register_item("tms5220", index, tms->RDB_flag);
return tms;
}
void z80pio_init(int which, z80pio_interface *intf)
{
z80pio *pio = pios + which;
assert(which < MAX_PIO);
memset(pio, 0, sizeof(*pio));
pio->intr = intf->intr;
pio->rdyr[0] = intf->rdyA;
pio->rdyr[1] = intf->rdyB;
z80pio_reset(which);
state_save_register_item_array("z80pio", which, pio->vector);
state_save_register_item_array("z80pio", which, pio->mode);
state_save_register_item_array("z80pio", which, pio->enable);
state_save_register_item_array("z80pio", which, pio->mask);
state_save_register_item_array("z80pio", which, pio->dir);
state_save_register_item_array("z80pio", which, pio->rdy);
state_save_register_item_array("z80pio", which, pio->in);
state_save_register_item_array("z80pio", which, pio->out);
state_save_register_item_array("z80pio", which, pio->strobe);
state_save_register_item_array("z80pio", which, pio->int_state);
}
void segaic16_memory_mapper_init(running_device *cpu, const segaic16_memory_map_entry *entrylist, void (*sound_w_callback)(running_machine *, UINT8), UINT8 (*sound_r_callback)(running_machine *))
{
struct memory_mapper_chip *chip = &memory_mapper;
/* reset the chip structure */
memset(chip, 0, sizeof(*chip));
chip->cpu = cpu;
chip->map = entrylist;
chip->sound_w = sound_w_callback;
chip->sound_r = sound_r_callback;
/* create the initial regions */
update_memory_mapping(cpu->machine, chip, 0);
state_save_register_item_array(cpu->machine, "segaic16_mapper", NULL, 0, chip->regs);
}
static void AY8910_statesave(struct AY8910 *PSG, int sndindex)
{
state_save_register_item("AY8910", sndindex, PSG->register_latch);
state_save_register_item_array("AY8910", sndindex, PSG->Regs);
state_save_register_item("AY8910", sndindex, PSG->lastEnable);
state_save_register_item("AY8910", sndindex, PSG->PeriodA);
state_save_register_item("AY8910", sndindex, PSG->PeriodB);
state_save_register_item("AY8910", sndindex, PSG->PeriodC);
state_save_register_item("AY8910", sndindex, PSG->PeriodN);
state_save_register_item("AY8910", sndindex, PSG->PeriodE);
state_save_register_item("AY8910", sndindex, PSG->CountA);
state_save_register_item("AY8910", sndindex, PSG->CountB);
state_save_register_item("AY8910", sndindex, PSG->CountC);
state_save_register_item("AY8910", sndindex, PSG->CountN);
state_save_register_item("AY8910", sndindex, PSG->CountE);
state_save_register_item("AY8910", sndindex, PSG->VolA);
state_save_register_item("AY8910", sndindex, PSG->VolB);
state_save_register_item("AY8910", sndindex, PSG->VolC);
state_save_register_item("AY8910", sndindex, PSG->VolE);
state_save_register_item("AY8910", sndindex, PSG->EnvelopeA);
state_save_register_item("AY8910", sndindex, PSG->EnvelopeB);
state_save_register_item("AY8910", sndindex, PSG->EnvelopeC);
state_save_register_item("AY8910", sndindex, PSG->OutputA);
state_save_register_item("AY8910", sndindex, PSG->OutputB);
state_save_register_item("AY8910", sndindex, PSG->OutputC);
state_save_register_item("AY8910", sndindex, PSG->OutputN);
state_save_register_item("AY8910", sndindex, PSG->CountEnv);
state_save_register_item("AY8910", sndindex, PSG->Hold);
state_save_register_item("AY8910", sndindex, PSG->Alternate);
state_save_register_item("AY8910", sndindex, PSG->Attack);
state_save_register_item("AY8910", sndindex, PSG->Holding);
state_save_register_item("AY8910", sndindex, PSG->RNG);
}
/****************************************************************************
* Initialize emulation
****************************************************************************/
static void cop410_init(int index, int clock, const void *config, int (*irqcallback)(int))
{
int i;
memset(&R, 0, sizeof(R));
R.G_mask = 0x0F;
R.D_mask = 0x0F;
for (i=0; i<256; i++) InstLen[i]=1;
InstLen[0x60] = InstLen[0x61] = InstLen[0x68] = InstLen[0x69] = InstLen[0x33] = InstLen[0x23] = 2;
for (i=0; i<256; i++) LBIops[i] = 0;
for (i=0x08; i<0x10; i++) LBIops[i] = 1;
for (i=0x18; i<0x20; i++) LBIops[i] = 1;
for (i=0x28; i<0x30; i++) LBIops[i] = 1;
for (i=0x38; i<0x40; i++) LBIops[i] = 1;
state_save_register_item("cop410", index, PC);
state_save_register_item("cop410", index, R.PREVPC);
state_save_register_item("cop410", index, A);
state_save_register_item("cop410", index, B);
state_save_register_item("cop410", index, C);
state_save_register_item("cop410", index, EN);
state_save_register_item("cop410", index, G);
state_save_register_item("cop410", index, Q);
state_save_register_item("cop410", index, SA);
state_save_register_item("cop410", index, SB);
state_save_register_item("cop410", index, SIO);
state_save_register_item("cop410", index, SKL);
state_save_register_item("cop410", index, skip);
state_save_register_item("cop410", index, skipLBI);
state_save_register_item_array("cop410", index, R.RAM);
state_save_register_item("cop410", index, R.G_mask);
state_save_register_item("cop410", index, R.D_mask);
}
/* Generate interrupts */
static void Interrupt(void)
{
/* the 6805 latches interrupt requests internally, so we don't clear */
/* pending_interrupts until the interrupt is taken, no matter what the */
/* external IRQ pin does. */
#if (HAS_HD63705)
if( (m6805.pending_interrupts & (1<<HD63705_INT_NMI)) != 0)
{
PUSHWORD(m6805.pc);
PUSHBYTE(m6805.x);
PUSHBYTE(m6805.a);
PUSHBYTE(m6805.cc);
SEI;
/* no vectors supported, just do the callback to clear irq_state if needed */
if (m6805.irq_callback)
(*m6805.irq_callback)(0);
RM16( 0x1ffc, &pPC);
change_pc(PC);
m6805.pending_interrupts &= ~(1<<HD63705_INT_NMI);
m6805_ICount -= 11;
}
else if( (m6805.pending_interrupts & ((1<<M6805_IRQ_LINE)|HD63705_INT_MASK)) != 0 ) {
if ( (CC & IFLAG) == 0 ) {
#else
if( (m6805.pending_interrupts & (1<<M6805_IRQ_LINE)) != 0 ) {
if ( (CC & IFLAG) == 0 ) {
#endif
{
/* standard IRQ */
//#if (HAS_HD63705)
// if(SUBTYPE!=SUBTYPE_HD63705)
//#endif
// PC |= ~AMASK;
PUSHWORD(m6805.pc);
PUSHBYTE(m6805.x);
PUSHBYTE(m6805.a);
PUSHBYTE(m6805.cc);
SEI;
/* no vectors supported, just do the callback to clear irq_state if needed */
if (m6805.irq_callback)
(*m6805.irq_callback)(0);
#if (HAS_HD63705)
if(SUBTYPE==SUBTYPE_HD63705)
{
/* Need to add emulation of other interrupt sources here KW-2/4/99 */
/* This is just a quick patch for Namco System 2 operation */
if((m6805.pending_interrupts&(1<<HD63705_INT_IRQ1))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_IRQ1);
RM16( 0x1ff8, &pPC);
change_pc(PC);
}
else if((m6805.pending_interrupts&(1<<HD63705_INT_IRQ2))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_IRQ2);
RM16( 0x1fec, &pPC);
change_pc(PC);
}
else if((m6805.pending_interrupts&(1<<HD63705_INT_ADCONV))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_ADCONV);
RM16( 0x1fea, &pPC);
change_pc(PC);
}
else if((m6805.pending_interrupts&(1<<HD63705_INT_TIMER1))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_TIMER1);
RM16( 0x1ff6, &pPC);
change_pc(PC);
}
else if((m6805.pending_interrupts&(1<<HD63705_INT_TIMER2))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_TIMER2);
RM16( 0x1ff4, &pPC);
change_pc(PC);
}
else if((m6805.pending_interrupts&(1<<HD63705_INT_TIMER3))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_TIMER3);
RM16( 0x1ff2, &pPC);
change_pc(PC);
}
else if((m6805.pending_interrupts&(1<<HD63705_INT_PCI))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_PCI);
RM16( 0x1ff0, &pPC);
change_pc(PC);
}
else if((m6805.pending_interrupts&(1<<HD63705_INT_SCI))!=0)
{
m6805.pending_interrupts &= ~(1<<HD63705_INT_SCI);
RM16( 0x1fee, &pPC);
change_pc(PC);
}
}
else
#endif
{
RM16( 0xffff - 5, &pPC );
change_pc(PC);
}
} // CC & IFLAG
m6805.pending_interrupts &= ~(1<<M6805_IRQ_LINE);
}
m6805_ICount -= 11;
}
}
static void state_register(const char *type, int index)
{
state_save_register_item(type, index, A);
state_save_register_item(type, index, PC);
state_save_register_item(type, index, S);
state_save_register_item(type, index, X);
state_save_register_item(type, index, CC);
state_save_register_item(type, index, m6805.pending_interrupts);
state_save_register_item_array(type, index, m6805.irq_state);
}
static void m6805_init(int index, int clock, const void *config, int (*irqcallback)(int))
{
state_register("m6805", index);
m6805.irq_callback = irqcallback;
}
void x76f041_init( int chip, UINT8 *data )
{
int offset;
struct x76f041_chip *c;
if( chip >= X76F041_MAXCHIP )
{
verboselog( 0, "x76f041_init( %d ) chip out of range\n", chip );
return;
}
c = &x76f041[ chip ];
if( data == NULL )
{
data = auto_malloc(
SIZE_RESPONSE_TO_RESET +
SIZE_READ_PASSWORD +
SIZE_WRITE_PASSWORD +
SIZE_CONFIGURATION_PASSWORD +
SIZE_CONFIGURATION_REGISTERS +
SIZE_DATA );
}
c->cs = 0;
c->rst = 0;
c->scl = 0;
c->sdaw = 0;
c->sdar = 0;
c->state = STATE_STOP;
c->shift = 0;
c->bit = 0;
c->byte = 0;
c->command = 0;
c->address = 0;
memset( c->write_buffer, 0, SIZE_WRITE_BUFFER );
offset = 0;
c->response_to_reset = &data[ offset ]; offset += SIZE_RESPONSE_TO_RESET;
c->write_password = &data[ offset ]; offset += SIZE_WRITE_PASSWORD;
c->read_password = &data[ offset ]; offset += SIZE_READ_PASSWORD;
c->configuration_password = &data[ offset ]; offset += SIZE_CONFIGURATION_PASSWORD;
c->configuration_registers = &data[ offset ]; offset += SIZE_CONFIGURATION_REGISTERS;
c->data = &data[ offset ]; offset += SIZE_DATA;
state_save_register_item( "x76f041", chip, c->cs );
state_save_register_item( "x76f041", chip, c->rst );
state_save_register_item( "x76f041", chip, c->scl );
state_save_register_item( "x76f041", chip, c->sdaw );
state_save_register_item( "x76f041", chip, c->sdar );
state_save_register_item( "x76f041", chip, c->state );
state_save_register_item( "x76f041", chip, c->shift );
state_save_register_item( "x76f041", chip, c->bit );
state_save_register_item( "x76f041", chip, c->byte );
state_save_register_item( "x76f041", chip, c->command );
state_save_register_item( "x76f041", chip, c->address );
state_save_register_item_array( "x76f041", chip, c->write_buffer );
state_save_register_item_pointer( "x76f041", chip, c->response_to_reset, SIZE_RESPONSE_TO_RESET );
state_save_register_item_pointer( "x76f041", chip, c->write_password, SIZE_WRITE_PASSWORD );
state_save_register_item_pointer( "x76f041", chip, c->read_password, SIZE_READ_PASSWORD );
state_save_register_item_pointer( "x76f041", chip, c->configuration_password, SIZE_CONFIGURATION_PASSWORD );
state_save_register_item_pointer( "x76f041", chip, c->configuration_registers, SIZE_CONFIGURATION_REGISTERS );
state_save_register_item_pointer( "x76f041", chip, c->data, SIZE_DATA );
}
void zs01_init( int chip, unsigned char *data, zs01_write_handler write, zs01_read_handler read, unsigned char *ds2401 )
{
int offset;
struct zs01_chip *c;
if( chip >= ZS01_MAXCHIP )
{
verboselog( 0, "zs01_init( %d ) chip out of range\n", chip );
return;
}
c = &zs01[ chip ];
if( data == NULL )
{
data = auto_malloc(
SIZE_RESPONSE_TO_RESET +
SIZE_KEY +
SIZE_KEY +
SIZE_DATA );
}
if( ds2401 == NULL )
{
ds2401 = auto_malloc( SIZE_DATA_BUFFER );
}
c->cs = 0;
c->rst = 0;
c->scl = 0;
c->sdaw = 0;
c->sdar = 0;
c->state = STATE_STOP;
c->shift = 0;
c->bit = 0;
c->byte = 0;
memset( c->write_buffer, 0, SIZE_WRITE_BUFFER );
memset( c->read_buffer, 0, SIZE_READ_BUFFER );
memset( c->response_key, 0, SIZE_KEY );
offset = 0;
c->response_to_reset = &data[ offset ]; offset += SIZE_RESPONSE_TO_RESET;
c->command_key = &data[ offset ]; offset += SIZE_KEY;
c->data_key = &data[ offset ]; offset += SIZE_KEY;
c->data = &data[ offset ]; offset += SIZE_DATA;
c->ds2401 = ds2401;
c->write = write;
c->read = read;
state_save_register_item( "zs01", chip, c->cs );
state_save_register_item( "zs01", chip, c->rst );
state_save_register_item( "zs01", chip, c->scl );
state_save_register_item( "zs01", chip, c->sdaw );
state_save_register_item( "zs01", chip, c->sdar );
state_save_register_item( "zs01", chip, c->state );
state_save_register_item( "zs01", chip, c->shift );
state_save_register_item( "zs01", chip, c->bit );
state_save_register_item( "zs01", chip, c->byte );
state_save_register_item_array( "zs01", chip, c->write_buffer );
state_save_register_item_array( "zs01", chip, c->read_buffer );
state_save_register_item_array( "zs01", chip, c->response_key );
state_save_register_item_pointer( "zs01", chip, c->response_to_reset, SIZE_RESPONSE_TO_RESET );
state_save_register_item_pointer( "zs01", chip, c->command_key, SIZE_KEY );
state_save_register_item_pointer( "zs01", chip, c->data_key, SIZE_DATA );
}