static int fsimage_create_p64(disk_image_t *image)
{
TP64MemoryStream P64MemoryStreamInstance;
TP64Image P64Image;
BYTE gcr_track[7928], *gcrptr;
unsigned int track, sector;
fsimage_t *fsimage;
int rc = -1;
fsimage = image->media.fsimage;
P64ImageCreate(&P64Image);
for (track = 0; track < MAX_TRACKS_1541; track++) {
const int raw_track_size[4] = { 6250, 6666, 7142, 7692 };
memset(&gcr_track[0], 0x55, 7928);
gcrptr = &gcr_track[0];
for (sector = 0;
sector < disk_image_sector_per_track(DISK_IMAGE_TYPE_D64, track + 1);
sector++) {
BYTE chksum, id[2], rawdata[260];
int i;
id[0] = id[1] = 0xa0;
memset(rawdata, 0, 260);
rawdata[0] = 7;
chksum = rawdata[1];
for (i = 1; i < 256; i++) {
chksum ^= rawdata[i + 1];
}
rawdata[257] = chksum;
gcr_convert_sector_to_GCR(rawdata, gcrptr, track + 1, sector,
id[0], id[1], 0);
gcrptr += 360;
}
P64PulseStreamConvertFromGCR(&P64Image.PulseStreams[(track + 1) << 1], (void*)&gcr_track[0], raw_track_size[disk_image_speed_map_1541(track)] << 3);
}
P64MemoryStreamCreate(&P64MemoryStreamInstance);
P64MemoryStreamClear(&P64MemoryStreamInstance);
if (P64ImageWriteToStream(&P64Image,&P64MemoryStreamInstance)) {
if (fwrite(P64MemoryStreamInstance.Data, P64MemoryStreamInstance.Size, 1, fsimage->fd) < 1) {
log_error(createdisk_log, "Cannot write image data.");
rc = -1;
} else {
rc = 0;
}
}
P64MemoryStreamDestroy(&P64MemoryStreamInstance);
P64ImageDestroy(&P64Image);
return rc;
}
void drive_shutdown(void)
{
unsigned int dnr;
if (!drive_init_was_called) {
/* happens at the -help command line command*/
return;
}
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
if (drive_context[dnr]->drive->type == DRIVE_TYPE_2000 || drive_context[dnr]->drive->type == DRIVE_TYPE_4000) {
drivecpu65c02_shutdown(drive_context[dnr]);
} else {
drivecpu_shutdown(drive_context[dnr]);
}
if (drive_context[dnr]->drive->gcr) {
gcr_destroy_image(drive_context[dnr]->drive->gcr);
}
if (drive_context[dnr]->drive->p64) {
P64ImageDestroy(drive_context[dnr]->drive->p64);
lib_free(drive_context[dnr]->drive->p64);
}
if (drive_context[dnr]->drive->ds1216) {
ds1216e_destroy(drive_context[dnr]->drive->ds1216, drive_context[dnr]->drive->rtc_save);
}
}
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
lib_free(drive_context[dnr]->drive);
lib_free(drive_context[dnr]);
}
}
static int attach_disk_image(disk_image_t **imgptr, vdrive_t *floppy,
const char *filename, unsigned int unit,
int devicetype)
{
disk_image_t *image;
disk_image_t new_image;
int err = -1;
if (filename == NULL) {
log_error(attach_log, "No name, cannot attach floppy image.");
return -1;
}
new_image.gcr = NULL;
new_image.p64 = lib_calloc(1, sizeof(TP64Image));
new_image.read_only = (unsigned int)attach_device_readonly_enabled[unit - 8];
switch (devicetype) {
case ATTACH_DEVICE_NONE:
case ATTACH_DEVICE_VIRT:
case ATTACH_DEVICE_FS:
new_image.device = DISK_IMAGE_DEVICE_FS;
break;
case ATTACH_DEVICE_RAW:
new_image.device = DISK_IMAGE_DEVICE_RAW;
break;
}
disk_image_media_create(&new_image);
switch (devicetype) {
case ATTACH_DEVICE_NONE:
case ATTACH_DEVICE_VIRT:
case ATTACH_DEVICE_FS:
disk_image_fsimage_name_set(&new_image, filename);
break;
case ATTACH_DEVICE_RAW:
disk_image_rawimage_driver_name_set(&new_image);
break;
}
if (disk_image_open(&new_image) < 0) {
P64ImageDestroy((PP64Image) new_image.p64);
lib_free(new_image.p64);
disk_image_media_destroy(&new_image);
return -1;
}
detach_disk_image_and_free(*imgptr, floppy, unit);
*imgptr = disk_image_create();
image = *imgptr;
memcpy(image, &new_image, sizeof(disk_image_t));
switch (unit) {
case 8:
case 9:
case 10:
case 11:
err = drive_image_attach(image, unit);
err &= vdrive_attach_image(image, unit, floppy);
err &= machine_drive_image_attach(image, unit);
break;
}
if (err) {
disk_image_close(image);
disk_image_media_destroy(image);
disk_image_destroy(image);
*imgptr = NULL;
}
return err;
}
