int drive_num_leds(unsigned int dnr)
{
if (drive_check_old(drive_context[dnr]->drive->type))
return 2;
if ((dnr == 1) && drive_check_dual(drive_context[0]->drive->type))
return 2;
return 1;
}
void fdc_reset(unsigned int fnum, unsigned int drive_type)
{
fdc_t *thefdc = &fdc[fnum];
int drive1 = mk_drive1(fnum);
disk_image_t *saved_image0,
*saved_image1;
#ifdef FDC_DEBUG
log_message(fdc_log, "fdc_reset: drive %d type=%d\n",fnum, drive_type);
#endif
saved_image0 = fdc[fnum].realimage;
saved_image1 = NULL;
/* detach disk images */
if (thefdc->image) {
thefdc->wps_change = 0;
fdc_detach_image(thefdc->image, fnum + 8);
}
if (thefdc->num_drives == 2) {
saved_image1 = fdc[drive1].realimage;
if (fdc[drive1].image) {
fdc[drive1].wps_change = 0;
fdc_detach_image(fdc[drive1].image, drive1 + 8);
}
}
if (drive_check_old(drive_type)) {
thefdc->drive_type = drive_type;
thefdc->num_drives = is_drive1(fnum) ? 1 :
drive_check_dual(drive_type) ? 2 : 1;
thefdc->fdc_state = FDC_RESET0;
alarm_set(thefdc->fdc_alarm, drive_clk[fnum] + 20);
} else {
thefdc->drive_type = DRIVE_TYPE_NONE;
alarm_unset(thefdc->fdc_alarm);
thefdc->fdc_state = FDC_UNUSED;
thefdc->num_drives = 0;
}
/* re-attach disk images */
if (saved_image0) {
#ifdef FDC_DEBUG
printf("ieee/fdc.c:fdc_reset dev %d type %d drive 0 re-attach image %p (drive: %p)\n", fnum+8, drive_type, saved_image0, drive_context[fnum]->drive->image);
#endif
fdc_attach_image(saved_image0, fnum + 8);
}
if (saved_image1) {
#ifdef FDC_DEBUG
printf("ieee/fdc.c:fdc_reset dev %d type %d drive 1 re-attach image %p (drive: %p)\n", fnum+8, drive_type, saved_image0, drive_context[drive1]->drive->image);
#endif
fdc_attach_image(saved_image1, drive1 + 8);
}
}
int ieee_drive_snapshot_write(struct drive_context_s *ctxptr,
struct snapshot_s *s)
{
if (ctxptr->drive->type == DRIVE_TYPE_2031) {
if (viacore_snapshot_write_module(ctxptr->via1d2031, s) < 0)
return -1;
}
if (drive_check_old(ctxptr->drive->type)) {
if (riotcore_snapshot_write_module(ctxptr->riot1, s) < 0
|| riotcore_snapshot_write_module(ctxptr->riot2, s) < 0
|| fdc_snapshot_write_module(s, ctxptr->mynumber) < 0)
return -1;
}
return 0;
}
void ieee_drive_reset(struct drive_context_s *drv)
{
if (drv->drive->type == DRIVE_TYPE_2031)
viacore_reset(drv->via1d2031);
else
viacore_disable(drv->via1d2031);
if (drive_check_old(drv->drive->type)) {
fdc_reset(drv->mynumber, drv->drive->type);
riotcore_reset(drv->riot1);
riotcore_reset(drv->riot2);
} else {
/* alarm is unset by fdc_reset */
fdc_reset(drv->mynumber, drv->drive->type);
riotcore_disable(drv->riot1);
riotcore_disable(drv->riot2);
}
}
int drive_num_leds(unsigned int dnr)
{
drive_t *drive = drive_context[dnr]->drive;
if (drive_check_old(drive->type)) {
return 2;
}
if (drive->drive0) {
return 2;
}
if (drive->type == DRIVE_TYPE_2000
|| drive->type == DRIVE_TYPE_4000) {
return 2;
}
return 1;
}
void riot2_set_atn(riot_context_t *riot_context, int state)
{
drive_context_t *drive_context;
driveriot2_context_t *riot2p;
drive_context = (drive_context_t *)(riot_context->context);
riot2p = (driveriot2_context_t *)(riot_context->prv);
if (drive_check_old(riot2p->drive->type)) {
if (riot2p->r_atn_active && !state) {
riotcore_signal(riot_context, RIOT_SIG_PA7, RIOT_SIG_FALL);
} else
if (state && !(riot2p->r_atn_active)) {
riotcore_signal(riot_context, RIOT_SIG_PA7, RIOT_SIG_RISE);
}
riot2p->r_atn_active = state;
riot1_set_pardata(drive_context->riot1);
set_handshake(riot_context, riot_context->old_pa);
}
}
int drivecpu_snapshot_read_module(drive_context_t *drv, snapshot_t *s)
{
BYTE major, minor;
snapshot_module_t *m;
BYTE a, x, y, sp, status;
WORD pc;
drivecpu_context_t *cpu;
cpu = drv->cpu;
m = snapshot_module_open(s, drv->cpu->snap_module_name, &major, &minor);
if (m == NULL) {
return -1;
}
/* Before we start make sure all devices are reset. */
drivecpu_reset(drv);
/* XXX: Assumes `CLOCK' is the same size as a `DWORD'. */
if (0
|| SMR_DW(m, drv->clk_ptr) < 0
|| SMR_B(m, &a) < 0
|| SMR_B(m, &x) < 0
|| SMR_B(m, &y) < 0
|| SMR_B(m, &sp) < 0
|| SMR_W(m, &pc) < 0
|| SMR_B(m, &status) < 0
|| SMR_DW_UINT(m, &(cpu->last_opcode_info)) < 0
|| SMR_DW(m, &(cpu->last_clk)) < 0
|| SMR_DW(m, &(cpu->cycle_accum)) < 0
|| SMR_DW(m, &(cpu->last_exc_cycles)) < 0
|| SMR_DW(m, &(cpu->stop_clk)) < 0
) {
goto fail;
}
MOS6510_REGS_SET_A(&(cpu->cpu_regs), a);
MOS6510_REGS_SET_X(&(cpu->cpu_regs), x);
MOS6510_REGS_SET_Y(&(cpu->cpu_regs), y);
MOS6510_REGS_SET_SP(&(cpu->cpu_regs), sp);
MOS6510_REGS_SET_PC(&(cpu->cpu_regs), pc);
MOS6510_REGS_SET_STATUS(&(cpu->cpu_regs), status);
log_message(drv->drive->log, "RESET (For undump).");
interrupt_cpu_status_reset(cpu->int_status);
machine_drive_reset(drv);
if (interrupt_read_snapshot(cpu->int_status, m) < 0) {
goto fail;
}
if (drv->drive->type == DRIVE_TYPE_1540
|| drv->drive->type == DRIVE_TYPE_1541
|| drv->drive->type == DRIVE_TYPE_1541II
|| drv->drive->type == DRIVE_TYPE_1551
|| drv->drive->type == DRIVE_TYPE_1570
|| drv->drive->type == DRIVE_TYPE_1571
|| drv->drive->type == DRIVE_TYPE_1571CR
|| drv->drive->type == DRIVE_TYPE_2031) {
if (SMR_BA(m, drv->drive->drive_ram, 0x800) < 0) {
goto fail;
}
}
if (drv->drive->type == DRIVE_TYPE_1581
|| drv->drive->type == DRIVE_TYPE_2000
|| drv->drive->type == DRIVE_TYPE_4000) {
if (SMR_BA(m, drv->drive->drive_ram, 0x2000) < 0) {
goto fail;
}
}
if (drive_check_old(drv->drive->type)) {
if (SMR_BA(m, drv->drive->drive_ram, 0x1100) < 0) {
goto fail;
}
}
/* Update `*bank_base'. */
JUMP(reg_pc);
if (interrupt_read_new_snapshot(drv->cpu->int_status, m) < 0) {
goto fail;
}
return snapshot_module_close(m);
fail:
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
int drivecpu_snapshot_write_module(drive_context_t *drv, snapshot_t *s)
{
snapshot_module_t *m;
drivecpu_context_t *cpu;
cpu = drv->cpu;
m = snapshot_module_create(s, drv->cpu->snap_module_name,
((BYTE)(SNAP_MAJOR)), ((BYTE)(SNAP_MINOR)));
if (m == NULL) {
return -1;
}
if (0
|| SMW_DW(m, (DWORD) *(drv->clk_ptr)) < 0
|| SMW_B(m, (BYTE)MOS6510_REGS_GET_A(&(cpu->cpu_regs))) < 0
|| SMW_B(m, (BYTE)MOS6510_REGS_GET_X(&(cpu->cpu_regs))) < 0
|| SMW_B(m, (BYTE)MOS6510_REGS_GET_Y(&(cpu->cpu_regs))) < 0
|| SMW_B(m, (BYTE)MOS6510_REGS_GET_SP(&(cpu->cpu_regs))) < 0
|| SMW_W(m, (WORD)MOS6510_REGS_GET_PC(&(cpu->cpu_regs))) < 0
|| SMW_B(m, (BYTE)MOS6510_REGS_GET_STATUS(&(cpu->cpu_regs))) < 0
|| SMW_DW(m, (DWORD)(cpu->last_opcode_info)) < 0
|| SMW_DW(m, (DWORD)(cpu->last_clk)) < 0
|| SMW_DW(m, (DWORD)(cpu->cycle_accum)) < 0
|| SMW_DW(m, (DWORD)(cpu->last_exc_cycles)) < 0
|| SMW_DW(m, (DWORD)(cpu->stop_clk)) < 0
) {
goto fail;
}
if (interrupt_write_snapshot(cpu->int_status, m) < 0) {
goto fail;
}
if (drv->drive->type == DRIVE_TYPE_1540
|| drv->drive->type == DRIVE_TYPE_1541
|| drv->drive->type == DRIVE_TYPE_1541II
|| drv->drive->type == DRIVE_TYPE_1551
|| drv->drive->type == DRIVE_TYPE_1570
|| drv->drive->type == DRIVE_TYPE_1571
|| drv->drive->type == DRIVE_TYPE_1571CR
|| drv->drive->type == DRIVE_TYPE_2031) {
if (SMW_BA(m, drv->drive->drive_ram, 0x800) < 0) {
goto fail;
}
}
if (drv->drive->type == DRIVE_TYPE_1581
|| drv->drive->type == DRIVE_TYPE_2000
|| drv->drive->type == DRIVE_TYPE_4000) {
if (SMW_BA(m, drv->drive->drive_ram, 0x2000) < 0) {
goto fail;
}
}
if (drive_check_old(drv->drive->type)) {
if (SMW_BA(m, drv->drive->drive_ram, 0x1100) < 0) {
goto fail;
}
}
if (interrupt_write_new_snapshot(cpu->int_status, m) < 0) {
goto fail;
}
return snapshot_module_close(m);
fail:
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
