Пример #1
0
int fdc_detach_image(disk_image_t *image, unsigned int unit)
{
    int drive_no, imgno;

#ifdef FDC_DEBUG
    log_message(fdc_log, "fdc_detach_image(image=%p, unit=%d)",
                image, unit);
#endif

    if (image == NULL || unit < 8 || unit >= (8+DRIVE_NUM))
        return -1;

    {
        int drive0 = mk_drive0(unit - 8);

        if (fdc[drive0].num_drives == 2) {
            drive_no = drive0;
        } else {
            drive_no = unit - 8;
        }
    }

    imgno = unit - 8;

    fdc[imgno].realimage = NULL;

    if (fdc[drive_no].drive_type == DRIVE_TYPE_8050
        || fdc[drive_no].drive_type == DRIVE_TYPE_8250
        || fdc[drive_no].drive_type == DRIVE_TYPE_1001) {
        switch(image->type) {
          case DISK_IMAGE_TYPE_D80:
          case DISK_IMAGE_TYPE_D82:
            disk_image_detach_log(image, fdc_log, unit);
            break;
          default:
            return -1;
        }
    } else {
        switch(image->type) {
          case DISK_IMAGE_TYPE_D64:
          case DISK_IMAGE_TYPE_D67:
          case DISK_IMAGE_TYPE_G64:
          case DISK_IMAGE_TYPE_P64:
          case DISK_IMAGE_TYPE_X64:
            disk_image_detach_log(image, fdc_log, unit);
            break;
          default:
            return -1;
        }
    }

    fdc[imgno].wps_change += 2;
    fdc[imgno].image = NULL;
    return 0;
}
Пример #2
0
void vdrive_detach_image(disk_image_t *image, unsigned int unit,
                         vdrive_t *vdrive)
{
	if (image == NULL)
		return;

	disk_image_detach_log(image, 0, unit);
	vdrive_close_all_channels(vdrive);
	vdrive->image = NULL;
}
Пример #3
0
/* Detach a disk image from the true drive emulation. */
int drive_image_detach(disk_image_t *image, unsigned int unit)
{
    unsigned int dnr, i;
    drive_t *drive;

    if (unit < 8 || unit >= 8 + DRIVE_NUM) {
        return -1;
    }

    dnr = unit - 8;
    drive = drive_context[dnr]->drive;

    if (drive->image != NULL) {
        switch (image->type) {
            case DISK_IMAGE_TYPE_D64:
            case DISK_IMAGE_TYPE_D67:
            case DISK_IMAGE_TYPE_D71:
            case DISK_IMAGE_TYPE_G64:
            case DISK_IMAGE_TYPE_P64:
            case DISK_IMAGE_TYPE_X64:
                disk_image_detach_log(image, driveimage_log, unit);
                break;
            default:
                return -1;
        }
    }

    if (drive->P64_image_loaded && drive->P64_dirty) {
        drive->P64_dirty = 0;
        if (disk_image_write_p64_image(drive->image) < 0) {
            log_error(drive->log, "Cannot write disk image back.");
        }
    } else {
        drive_gcr_data_writeback(drive);
    }

    for (i = 0; i < MAX_GCR_TRACKS; i++) {
        if (drive->gcr->tracks[i].data) {
            lib_free(drive->gcr->tracks[i].data);
            drive->gcr->tracks[i].data = NULL;
            drive->gcr->tracks[i].size = 0;
        }
    }
    drive->detach_clk = drive_clk[dnr];
    drive->GCR_image_loaded = 0;
    drive->P64_image_loaded = 0;
    drive->read_only = 0;
    drive->image = NULL;
    drive_set_half_track(drive->current_half_track, drive->side, drive);

    return 0;
}
Пример #4
0
void vdrive_detach_image(disk_image_t *image, unsigned int unit,
                         vdrive_t *vdrive)
{
    if (image == NULL) {
        return;
    }

    disk_image_detach_log(image, vdrive_log, unit);
    vdrive_close_all_channels(vdrive);
    lib_free(vdrive->bam);
    vdrive->bam = NULL;
    vdrive->image = NULL;
}
Пример #5
0
int wd1770_detach_image(disk_image_t *image, unsigned int unit)
{
    if (image == NULL || unit < 8 || unit > 8 + DRIVE_NUM)
        return -1;

    switch(image->type) {
      case DISK_IMAGE_TYPE_D81:
        disk_image_detach_log(image, wd1770_log, unit, "D81");
        break;
      default:
        return -1;
    }

    wd1770[unit - 8].image = NULL;
    return 0;
}
Пример #6
0
void vdrive_detach_image(disk_image_t *image, unsigned int unit,
                         vdrive_t *vdrive)
{
	if (image == NULL)
		return;

    switch(image->type) {
      case DISK_IMAGE_TYPE_D64:
        disk_image_detach_log(image, vdrive_log, unit, "D64");
        break;
      case DISK_IMAGE_TYPE_D67:
        disk_image_detach_log(image, vdrive_log, unit, "D67");
        break;
      case DISK_IMAGE_TYPE_D71:
        disk_image_detach_log(image, vdrive_log, unit, "D71");
        break;
      case DISK_IMAGE_TYPE_D81:
        disk_image_detach_log(image, vdrive_log, unit, "D81");
        break;
      case DISK_IMAGE_TYPE_D80:
        disk_image_detach_log(image, vdrive_log, unit, "D80");
        break;
      case DISK_IMAGE_TYPE_D82:
        disk_image_detach_log(image, vdrive_log, unit, "D82");
        break;
      case DISK_IMAGE_TYPE_G64:
        disk_image_detach_log(image, vdrive_log, unit, "G64");
        break;
      case DISK_IMAGE_TYPE_X64:
        disk_image_detach_log(image, vdrive_log, unit, "X64");
        break;
      default:
        return;
    }
    vdrive_close_all_channels(vdrive);
    vdrive->image = NULL;
}
Пример #7
0
/* Detach a disk image from the true drive emulation. */
int drive_image_detach(disk_image_t *image, unsigned int unit)
{
    unsigned int dnr;
    drive_t *drive;

    if (unit < 8 || unit >= 8 + DRIVE_NUM)
        return -1;

    dnr = unit - 8;
    drive = drive_context[dnr]->drive;

    if (drive->image != NULL)
    {
	    switch(image->type)
	    {
		    case DISK_IMAGE_TYPE_D64:
		    case DISK_IMAGE_TYPE_D67:
		    case DISK_IMAGE_TYPE_D71:
		    case DISK_IMAGE_TYPE_G64:
		    case DISK_IMAGE_TYPE_X64:
			    disk_image_detach_log(image, 0, unit);
			    break;
		    default:
			    return -1;
	    }
    }

    drive_gcr_data_writeback(drive);
    memset(drive->gcr->data, 0, MAX_GCR_TRACKS * NUM_MAX_BYTES_TRACK);
    drive->detach_clk = drive_clk[dnr];
    drive->GCR_image_loaded = 0;
    drive->read_only = 0;
    drive->image = NULL;

    return 0;
}