Adding PCjs's JSON diskette format. Read-only mode ONLY (for installation disks.)
This commit is contained in:
waltje
645
src/floppy/floppy_json.c
Normal file
645
src/floppy/floppy_json.c
Normal file
@@ -0,0 +1,645 @@
|
||||
/*
|
||||
* 86Box A hypervisor and IBM PC system emulator that specializes in
|
||||
* running old operating systems and software designed for IBM
|
||||
* PC systems and compatibles from 1981 through fairly recent
|
||||
* system designs based on the PCI bus.
|
||||
*
|
||||
* This file is part of the 86Box distribution.
|
||||
*
|
||||
* Implementation of the PCjs JSON floppy image format.
|
||||
*
|
||||
* Version: @(#)floppy_json.c 1.0.1 2017/09/12
|
||||
*
|
||||
* Author: Fred N. van Kempen, <decwiz@yahoo.com>
|
||||
* Copyright 2017 Fred N. van Kempen.
|
||||
*/
|
||||
#include <wchar.h>
|
||||
#include <stdlib.h>
|
||||
#include "../ibm.h"
|
||||
#include "floppy.h"
|
||||
#include "fdc.h"
|
||||
#include "fdd.h"
|
||||
#include "floppy_common.h"
|
||||
#include "floppy_json.h"
|
||||
|
||||
|
||||
#define NTRACKS 256
|
||||
#define NSIDES 2
|
||||
#define NSECTORS 128
|
||||
|
||||
|
||||
typedef struct {
|
||||
uint8_t track, /* ID: track number */
|
||||
side, /* side number */
|
||||
sector; /* sector number 1.. */
|
||||
uint16_t size; /* encoded size of sector */
|
||||
uint8_t *data; /* allocated data for it */
|
||||
} sector_t;
|
||||
|
||||
typedef struct {
|
||||
FILE *f;
|
||||
|
||||
/* Geometry. */
|
||||
uint8_t tracks, /* number of tracks */
|
||||
sides, /* number of sides */
|
||||
sectors, /* number of sectors per track */
|
||||
spt[NTRACKS][NSIDES]; /* number of sectors per track */
|
||||
|
||||
uint8_t track, /* current track */
|
||||
side, /* current side */
|
||||
sector[NSIDES]; /* current sector */
|
||||
|
||||
uint8_t dmf; /* disk is DMF format */
|
||||
uint8_t interleave;
|
||||
#if 0
|
||||
uint8_t skew;
|
||||
#endif
|
||||
uint8_t gap2_len;
|
||||
uint8_t gap3_len;
|
||||
int track_width;
|
||||
|
||||
uint16_t disk_flags, /* flags for the entire disk */
|
||||
track_flags; /* flags for the current track */
|
||||
|
||||
uint8_t interleave_ordered[NTRACKS][NSIDES];
|
||||
|
||||
sector_t sects[NTRACKS][NSIDES][NSECTORS];
|
||||
} json_t;
|
||||
|
||||
|
||||
static json_t images[FDD_NUM];
|
||||
|
||||
|
||||
static void
|
||||
handle(json_t *img, char *name, char *str)
|
||||
{
|
||||
sector_t *sec = NULL;
|
||||
uint32_t l, pat;
|
||||
uint8_t *p;
|
||||
char *sp;
|
||||
int i, s;
|
||||
|
||||
/* Point to the currently selected sector. */
|
||||
sec = &img->sects[img->track][img->side][img->dmf-1];
|
||||
|
||||
/* If no name given, assume sector is done. */
|
||||
if (name == NULL) {
|
||||
/* If no buffer, assume one with 00's. */
|
||||
if (sec->data == NULL) {
|
||||
sec->data = (uint8_t *)malloc(sec->size);
|
||||
memset(sec->data, 0x00, sec->size);
|
||||
}
|
||||
|
||||
/* Encode the sector size. */
|
||||
sec->size = floppy_sector_size_code(sec->size);
|
||||
|
||||
/* Set up the rest of the Sector ID. */
|
||||
sec->track = img->track;
|
||||
sec->side = img->side;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (! strcmp(name, "sector")) {
|
||||
sec->sector = atoi(str);
|
||||
sec->size = 512;
|
||||
} else if (! strcmp(name, "length")) {
|
||||
sec->size = atoi(str);
|
||||
} else if (! strcmp(name, "pattern")) {
|
||||
pat = atol(str);
|
||||
|
||||
if (sec->data == NULL)
|
||||
sec->data = (uint8_t *)malloc(sec->size);
|
||||
p = sec->data;
|
||||
s = (sec->size / sizeof(uint32_t));
|
||||
for (i=0; i<s; i++) {
|
||||
l = pat;
|
||||
*p++ = (l & 0x000000ff);
|
||||
l >>= 8;
|
||||
*p++ = (l & 0x000000ff);
|
||||
l >>= 8;
|
||||
*p++ = (l & 0x000000ff);
|
||||
l >>= 8;
|
||||
*p++ = (l & 0x000000ff);
|
||||
}
|
||||
#if 1
|
||||
pclog("JSON: added sector (%d,%d,%d/%d) size=%d pat=%08lx\n",
|
||||
sec->track,sec->side,sec->sector,img->dmf,sec->size,pat);
|
||||
#endif
|
||||
} else if (! strcmp(name, "data")) {
|
||||
if (sec->data == NULL)
|
||||
sec->data = (uint8_t *)malloc(sec->size);
|
||||
p = sec->data;
|
||||
while (str && *str) {
|
||||
sp = strchr(str, ',');
|
||||
if (sp != NULL) *sp++ = '\0';
|
||||
l = atol(str);
|
||||
|
||||
#if 1
|
||||
if (p==sec->data)
|
||||
pclog("JSON: added sector (%d,%d,%d/%d) size=%d data=%08lx\n",
|
||||
sec->track,sec->side,sec->sector,img->dmf,sec->size,l);
|
||||
#endif
|
||||
*p++ = (l & 0x000000ff);
|
||||
l >>= 8;
|
||||
*p++ = (l & 0x000000ff);
|
||||
l >>= 8;
|
||||
*p++ = (l & 0x000000ff);
|
||||
l >>= 8;
|
||||
*p++ = (l & 0x000000ff);
|
||||
|
||||
str = sp;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
unexpect(int c, int state, int level)
|
||||
{
|
||||
pclog("JSON: Unexpected '%c' in state %d/%d.\n", c, state, level);
|
||||
|
||||
return(-1);
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
load_image(json_t *img)
|
||||
{
|
||||
char buff[4096], name[32];
|
||||
int c, i, j, state, level;
|
||||
char *ptr;
|
||||
|
||||
if (img->f == NULL) {
|
||||
pclog("JSON: no file loaded!\n");
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Initialize. */
|
||||
for (i=0; i<NTRACKS; i++) {
|
||||
for (j=0; j<NSIDES; j++)
|
||||
memset(img->sects[i][j], 0x00, sizeof(sector_t));
|
||||
}
|
||||
img->track = img->side = img->dmf = 0; /* "dmf" is "sector#" */
|
||||
|
||||
/* Now run the state machine. */
|
||||
ptr = NULL;
|
||||
level = state = 0;
|
||||
while (state >= 0) {
|
||||
/* Get a character from the input. */
|
||||
c = fgetc(img->f);
|
||||
if ((c == EOF) || ferror(img->f)) {
|
||||
state = -1;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Process it. */
|
||||
switch(state) {
|
||||
case 0: /* read level header */
|
||||
img->dmf = 1;
|
||||
if (c != '[') {
|
||||
state = unexpect(c, state, level);
|
||||
} else {
|
||||
if (++level == 3)
|
||||
state++;
|
||||
}
|
||||
break;
|
||||
|
||||
case 1: /* read sector header */
|
||||
if (c != '{')
|
||||
state = unexpect(c, state, level);
|
||||
else
|
||||
state++;
|
||||
break;
|
||||
|
||||
case 2: /* begin sector data name */
|
||||
if (c != '\"') {
|
||||
state = unexpect(c, state, level);
|
||||
} else {
|
||||
ptr = name;
|
||||
state++;
|
||||
}
|
||||
break;
|
||||
|
||||
case 3: /* read sector data name */
|
||||
if (c == '\"') {
|
||||
*ptr = '\0';
|
||||
state++;
|
||||
} else {
|
||||
*ptr++ = c;
|
||||
}
|
||||
break;
|
||||
|
||||
case 4: /* end of sector data name */
|
||||
if (c != ':') {
|
||||
state = unexpect(c, state, level);
|
||||
} else {
|
||||
ptr = buff;
|
||||
state++;
|
||||
}
|
||||
break;
|
||||
|
||||
case 5: /* read sector value data */
|
||||
switch(c) {
|
||||
case ',':
|
||||
case '}':
|
||||
*ptr = '\0';
|
||||
handle(img, name, buff);
|
||||
|
||||
if (c == '}')
|
||||
state = 7; /* done */
|
||||
else
|
||||
state = 2; /* word */
|
||||
break;
|
||||
|
||||
case '[':
|
||||
state++;
|
||||
break;
|
||||
|
||||
default:
|
||||
*ptr++ = c;
|
||||
}
|
||||
break;
|
||||
|
||||
case 6: /* read sector data complex */
|
||||
if (c != ']')
|
||||
*ptr++ = c;
|
||||
else
|
||||
state = 5;
|
||||
break;
|
||||
|
||||
case 7: /* sector done */
|
||||
handle(img, NULL, NULL);
|
||||
switch(c) {
|
||||
case ',': /* next sector */
|
||||
img->dmf++;
|
||||
state = 1;
|
||||
break;
|
||||
|
||||
case ']': /* all sectors done */
|
||||
if (--level == 0)
|
||||
state = -1;
|
||||
else state++;
|
||||
break;
|
||||
|
||||
default:
|
||||
state = unexpect(c, state, level);
|
||||
}
|
||||
break;
|
||||
|
||||
case 8: /* side done */
|
||||
switch(c) {
|
||||
case ',': /* next side */
|
||||
state = 0;
|
||||
break;
|
||||
|
||||
case ']': /* all sides done */
|
||||
if (--level == 0)
|
||||
state = -1;
|
||||
else state++;
|
||||
break;
|
||||
|
||||
default:
|
||||
state = unexpect(c, state, level);
|
||||
}
|
||||
img->spt[img->track][img->side] = img->dmf;
|
||||
img->side++;
|
||||
break;
|
||||
|
||||
case 9: /* track done */
|
||||
switch(c) {
|
||||
case ',': /* next track */
|
||||
img->side = 0;
|
||||
state = 0;
|
||||
break;
|
||||
|
||||
case ']': /* all tracks done */
|
||||
if (--level == 0)
|
||||
state = -1;
|
||||
else state++;
|
||||
break;
|
||||
|
||||
default:
|
||||
state = unexpect(c, state, level);
|
||||
}
|
||||
img->track++;
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* Save derived values. */
|
||||
img->tracks = img->track;
|
||||
img->sides = img->side;
|
||||
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* Seek the heads to a track, and prepare to read data from that track. */
|
||||
static void
|
||||
json_seek(int drive, int track)
|
||||
{
|
||||
uint8_t id[4] = { 0,0,0,0 };
|
||||
json_t *img = &images[drive];
|
||||
int side, sector;
|
||||
int rate, gap2, gap3, pos;
|
||||
int ssize, rsec, asec;
|
||||
int interleave_type;
|
||||
|
||||
if (img->f == NULL) {
|
||||
pclog("JSON: seek: no file loaded!\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Allow for doublestepping tracks. */
|
||||
if (! img->track_width && fdd_doublestep_40(drive)) track /= 2;
|
||||
|
||||
/* Set the new track. */
|
||||
img->track = track;
|
||||
|
||||
/* Reset the 86F state machine. */
|
||||
d86f_reset_index_hole_pos(drive, 0);
|
||||
d86f_reset_index_hole_pos(drive, 1);
|
||||
d86f_zero_bit_field(drive, 0);
|
||||
d86f_zero_bit_field(drive, 1);
|
||||
|
||||
interleave_type = 0;
|
||||
for (side=0; side<img->sides; side++) {
|
||||
/* Get transfer rate for this side. */
|
||||
rate = img->track_flags & 0x07;
|
||||
if (!rate && (img->track_flags & 0x20)) rate = 4;
|
||||
|
||||
/* Get correct GAP3 value for this side. */
|
||||
gap3 = floppy_get_gap3_size(rate,
|
||||
img->sects[track][side][0].size,
|
||||
img->spt[track][side]);
|
||||
|
||||
/* Get correct GAP2 value for this side. */
|
||||
gap2 = ((img->track_flags & 0x07) >= 3) ? 41 : 22;
|
||||
|
||||
pos = d86f_prepare_pretrack(drive, side, 0);
|
||||
|
||||
for (sector=0; sector<img->spt[track][side]; sector++) {
|
||||
if (interleave_type == 0) {
|
||||
rsec = img->sects[track][side][sector].sector;
|
||||
asec = sector;
|
||||
} else {
|
||||
rsec = floppy_dmf_r[sector];
|
||||
asec = img->interleave_ordered[rsec][side];
|
||||
}
|
||||
id[0] = track;
|
||||
id[1] = side;
|
||||
id[2] = rsec;
|
||||
id[3] = img->sects[track][side][asec].size;
|
||||
ssize = floppy_sector_code_size(img->sects[track][side][asec].size);
|
||||
|
||||
pos = d86f_prepare_sector(
|
||||
drive, side, pos, id,
|
||||
img->sects[track][side][asec].data,
|
||||
ssize, gap2, gap3,
|
||||
0, /*deleted flag*/
|
||||
0 /*bad_crc flag*/
|
||||
);
|
||||
|
||||
if (sector == 0)
|
||||
d86f_initialize_last_sector_id(drive,id[0],id[1],id[2],id[3]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static uint16_t
|
||||
disk_flags(int drive)
|
||||
{
|
||||
return(images[drive].disk_flags);
|
||||
}
|
||||
|
||||
|
||||
static uint16_t
|
||||
track_flags(int drive)
|
||||
{
|
||||
return(images[drive].track_flags);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
|
||||
{
|
||||
json_t *img = &images[drive];
|
||||
int i;
|
||||
|
||||
img->sector[side] = 0;
|
||||
|
||||
/* Make sure we are on the desired track. */
|
||||
if (c != img->track) return;
|
||||
|
||||
/* Set the desired side. */
|
||||
img->side = side;
|
||||
|
||||
/* Now loop over all sector ID's on this side to find our sector. */
|
||||
for (i=0; i<img->spt[c][side]; i++) {
|
||||
if ((img->sects[img->track][side][i].track == c) &&
|
||||
(img->sects[img->track][side][i].side == h) &&
|
||||
(img->sects[img->track][side][i].sector == r) &&
|
||||
(img->sects[img->track][side][i].size == n)) {
|
||||
img->sector[side] = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static uint8_t
|
||||
poll_read_data(int drive, int side, uint16_t pos)
|
||||
{
|
||||
json_t *img = &images[drive];
|
||||
uint8_t sec = img->sector[side];
|
||||
|
||||
return(img->sects[img->track][side][sec].data[pos]);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
json_init(void)
|
||||
{
|
||||
memset(images, 0x00, sizeof(images));
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
json_load(int drive, wchar_t *fn)
|
||||
{
|
||||
json_t *img = &images[drive];
|
||||
sector_t *sec;
|
||||
double bit_rate;
|
||||
int temp_rate;
|
||||
int i;
|
||||
|
||||
/* Just in case- remove ourselves from 86F. */
|
||||
d86f_unregister(drive);
|
||||
|
||||
/* Zap any old data. */
|
||||
memset(img, 0x00, sizeof(json_t));
|
||||
|
||||
/* Open the image file. */
|
||||
img->f = _wfopen(fn, L"rb");
|
||||
if (img->f == NULL) {
|
||||
memset(fn, 0x00, sizeof(wchar_t));
|
||||
return;
|
||||
}
|
||||
|
||||
/* Our images are always RO. */
|
||||
writeprot[drive] = 1;
|
||||
|
||||
/* Load all sectors from the image file. */
|
||||
if (! load_image(img)) {
|
||||
pclog("JSON: failed to initialize\n");
|
||||
(void)fclose(img->f);
|
||||
img->f = NULL;
|
||||
memset(fn, 0x00, sizeof(wchar_t));
|
||||
return;
|
||||
}
|
||||
|
||||
pclog("JSON(%d): %S (%i tracks, %i sides, %i sectors)\n",
|
||||
drive, fn, img->tracks, img->sides, img->spt[0][0]);
|
||||
|
||||
/*
|
||||
* If the image has more than 43 tracks, then
|
||||
* the tracks are thin (96 tpi).
|
||||
*/
|
||||
img->track_width = (img->tracks > 43) ? 1 : 0;
|
||||
|
||||
/* If the image has 2 sides, mark it as such. */
|
||||
img->disk_flags = 0x00;
|
||||
if (img->sides == 2)
|
||||
img->disk_flags |= 0x08;
|
||||
|
||||
/* JSON files are always assumed to be MFM-encoded. */
|
||||
img->track_flags = 0x08;
|
||||
|
||||
img->interleave = 0;
|
||||
#if 0
|
||||
img->skew = 0;
|
||||
#endif
|
||||
|
||||
temp_rate = 0xff;
|
||||
sec = &img->sects[0][0][0];
|
||||
for (i=0; i<6; i++) {
|
||||
if (img->spt[0][0] > floppy_max_sectors[sec->size][i]) continue;
|
||||
|
||||
bit_rate = floppy_bit_rates_300[i];
|
||||
temp_rate = floppy_rates[i];
|
||||
img->disk_flags |= (floppy_holes[i] << 1);
|
||||
|
||||
if ((bit_rate == 500.0) && (img->spt[0][0] == 21) &&
|
||||
(sec->size == 2) && (img->tracks >= 80) &&
|
||||
(img->tracks <= 82) && (img->sides == 2)) {
|
||||
/*
|
||||
* This is a DMF floppy, set the flag so
|
||||
* we know to interleave the sectors.
|
||||
*/
|
||||
img->dmf = 1;
|
||||
} else {
|
||||
if ((bit_rate == 500.0) && (img->spt[0][0] == 22) &&
|
||||
(sec->size == 2) && (img->tracks >= 80) &&
|
||||
(img->tracks <= 82) && (img->sides == 2)) {
|
||||
/*
|
||||
* This is marked specially because of the
|
||||
* track flag (a RPM slow down is needed).
|
||||
*/
|
||||
img->interleave = 2;
|
||||
}
|
||||
|
||||
img->dmf = 0;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (temp_rate == 0xff) {
|
||||
pclog("JSON: invalid image (temp_rate=0xff)\n");
|
||||
(void)fclose(img->f);
|
||||
img->f = NULL;
|
||||
memset(fn, 0x00, sizeof(wchar_t));
|
||||
return;
|
||||
}
|
||||
|
||||
if (img->interleave == 2) {
|
||||
img->interleave = 1;
|
||||
img->disk_flags |= 0x60;
|
||||
}
|
||||
|
||||
img->gap2_len = (temp_rate == 3) ? 41 : 22;
|
||||
if (img->dmf) {
|
||||
img->gap3_len = 8;
|
||||
} else {
|
||||
img->gap3_len = floppy_get_gap3_size(temp_rate,sec->size,img->spt[0][0]);
|
||||
}
|
||||
|
||||
if (! img->gap3_len) {
|
||||
pclog("JSON: image of unknown format was inserted into drive %c:!\n",
|
||||
'C'+drive);
|
||||
(void)fclose(img->f);
|
||||
img->f = NULL;
|
||||
memset(fn, 0x00, sizeof(wchar_t));
|
||||
return;
|
||||
}
|
||||
|
||||
img->track_flags |= (temp_rate & 0x03); /* data rate */
|
||||
if (temp_rate & 0x04)
|
||||
img->track_flags |= 0x20; /* RPM */
|
||||
|
||||
pclog(" disk_flags: 0x%02x, track_flags: 0x%02x, GAP3 length: %i\n",
|
||||
img->disk_flags, img->track_flags, img->gap3_len);
|
||||
pclog(" bit rate 300: %.2f, temporary rate: %i, hole: %i, DMF: %i\n",
|
||||
bit_rate, temp_rate, (img->disk_flags >> 1), img->dmf);
|
||||
|
||||
/* Set up handlers for 86F layer. */
|
||||
d86f_handler[drive].disk_flags = disk_flags;
|
||||
d86f_handler[drive].side_flags = track_flags;
|
||||
d86f_handler[drive].writeback = null_writeback;
|
||||
d86f_handler[drive].set_sector = set_sector;
|
||||
d86f_handler[drive].read_data = poll_read_data;
|
||||
d86f_handler[drive].write_data = null_write_data;
|
||||
d86f_handler[drive].format_conditions = null_format_conditions;
|
||||
d86f_handler[drive].extra_bit_cells = null_extra_bit_cells;
|
||||
d86f_handler[drive].encoded_data = common_encoded_data;
|
||||
d86f_handler[drive].read_revolution = common_read_revolution;
|
||||
d86f_handler[drive].index_hole_pos = null_index_hole_pos;
|
||||
d86f_handler[drive].get_raw_size = common_get_raw_size;
|
||||
d86f_handler[drive].check_crc = 1;
|
||||
d86f_set_version(drive, 0x0063);
|
||||
|
||||
d86f_common_handlers(drive);
|
||||
|
||||
drives[drive].seek = json_seek;
|
||||
}
|
||||
|
||||
|
||||
/* Close the image. */
|
||||
void
|
||||
json_close(int drive)
|
||||
{
|
||||
json_t *img = &images[drive];
|
||||
int t, h, s;
|
||||
|
||||
/* Unlink image from the system. */
|
||||
d86f_unregister(drive);
|
||||
|
||||
/* Release all the sector buffers. */
|
||||
for (t=0; t<256; t++) {
|
||||
for (h=0; h<2; h++) {
|
||||
memset(img->sects[t][h], 0x00, sizeof(sector_t));
|
||||
for (s=0; s<256; s++) {
|
||||
if (img->sects[t][h][s].data != NULL)
|
||||
free(img->sects[t][h][s].data);
|
||||
img->sects[t][h][s].data = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (img->f != NULL) {
|
||||
(void)fclose(img->f);
|
||||
img->f = NULL;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user