/*
track_count = 40;
sector_count = 9; // [VT 180]
expected_size = 512 * track_count * head_count * sector_count;
if (size == expected_size)
return;
track_count = 40;
sector_count = 8; // [DOS]
expected_size = 512 * track_count * head_count * sector_count;
if (size == expected_size)
return;
*/
track_count = head_count = sector_count = 0;
}
int rx50img_format::identify(io_generic *io, uint32_t form_factor)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
if(track_count)
return 50;
return 0;
}
// /* Sectors are numbered 1 to 10 */
bool rx50img_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
if(track_count == 0)
return false;
uint8_t sectdata[10*512];
desc_s sectors[10];
for(int i=0; i<sector_count; i++) {
sectors[i].data = sectdata + 512*i;
sectors[i].size = 512;
sectors[i].sector_id = i + 1; // SECTOR_ID +1 <===
}
int track_size = sector_count*512;
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
generate_track(rx50_10_desc, track, head, sectors, sector_count, 102064, image); // 98480
}
}
image->set_variant(floppy_image::SSQD);
return true;
}
bool esqimg_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
int track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
UINT8 sectdata[10*512];
desc_s sectors[10];
for(int i=0; i<sector_count; i++) {
sectors[i].data = sectdata + 512*i;
sectors[i].size = 512;
sectors[i].sector_id = i;
}
int track_size = sector_count*512;
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
generate_track(esq_10_desc, track, head, sectors, sector_count, 110528, image);
}
}
image->set_variant(floppy_image::DSDD);
return true;
}
bool st_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
uint8_t sectdata[11*512];
desc_s sectors[11];
for(int i=0; i<sector_count; i++) {
sectors[i].data = sectdata + 512*i;
sectors[i].size = 512;
sectors[i].sector_id = i + 1;
}
int track_size = sector_count*512;
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
generate_track(atari_st_fcp_get_desc(track, head, head_count, sector_count),
track, head, sectors, sector_count, 100000, image);
}
}
image->set_variant(floppy_image::DSDD);
return true;
}
bool upd765_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
{
int type = find_size(io, form_factor);
if(type == -1)
return false;
// format shouldn't exceed image geometry
const format &f = formats[type];
int img_tracks, img_heads;
image->get_maximal_geometry(img_tracks, img_heads);
if (f.track_count > img_tracks || f.head_count > img_heads)
return false;
floppy_image_format_t::desc_e *desc;
int current_size;
int end_gap_index;
switch (f.encoding)
{
case floppy_image::FM:
desc = get_desc_fm(f, current_size, end_gap_index);
break;
case floppy_image::MFM:
default:
desc = get_desc_mfm(f, current_size, end_gap_index);
break;
}
int total_size = 200000000/f.cell_size;
int remaining_size = total_size - current_size;
if(remaining_size < 0)
throw emu_fatalerror("upd765_format: Incorrect track layout, max_size=%d, current_size=%d", total_size, current_size);
// Fixup the end gap
desc[end_gap_index].p2 = remaining_size / 16;
desc[end_gap_index + 1].p2 = remaining_size & 15;
desc[end_gap_index + 1].p1 >>= 16-(remaining_size & 15);
int track_size = compute_track_size(f);
uint8_t sectdata[40*512];
desc_s sectors[40];
for(int track=0; track < f.track_count; track++)
for(int head=0; head < f.head_count; head++) {
build_sector_description(f, sectdata, sectors, track, head);
io_generic_read(io, sectdata, (track*f.head_count + head)*track_size, track_size);
generate_track(desc, track, head, sectors, f.sector_count, total_size, image);
}
image->set_variant(f.variant);
return true;
}
bool wd177x_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
int type = find_size(io, form_factor);
if(type == -1)
return false;
const format &f = formats[type];
floppy_image_format_t::desc_e *desc;
int current_size;
int end_gap_index;
switch (f.encoding)
{
case floppy_image::FM:
desc = get_desc_fm(f, current_size, end_gap_index);
break;
case floppy_image::MFM:
default:
desc = get_desc_mfm(f, current_size, end_gap_index);
break;
}
int total_size = 200000000/f.cell_size;
int remaining_size = total_size - current_size;
if(remaining_size < 0)
throw emu_fatalerror("wd177x_format: Incorrect track layout, max_size=%d, current_size=%d", total_size, current_size);
// Fixup the end gap
desc[end_gap_index].p2 = remaining_size / 16;
desc[end_gap_index + 1].p2 = remaining_size & 15;
desc[end_gap_index + 1].p1 >>= 16-(remaining_size & 15);
int track_size = compute_track_size(f);
UINT8 sectdata[40*512];
desc_s sectors[40];
build_sector_description(f, sectdata, sectors);
for(int track=0; track < f.track_count; track++)
for(int head=0; head < f.head_count; head++) {
if (f.encoding == floppy_image::FM)
desc[14].p1 = get_track_dam_fm(f, head, track);
else
desc[16].p1 = get_track_dam_mfm(f, head, track);
io_generic_read(io, sectdata, get_image_offset(f, head, track), track_size);
generate_track(desc, track, head, sectors, f.sector_count, total_size, image);
}
image->set_variant(f.variant);
return true;
}
bool victor9k_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
int type = find_size(io, form_factor);
if(type == -1)
return false;
const format &f = formats[type];
UINT64 size = io_generic_size(io);
dynamic_buffer img;
img.resize(size);
io_generic_read(io, img, 0, size);
log_boot_sector(img);
int track_offset = 0;
for (int head = 0; head < f.head_count; head++) {
for (int track = 0; track < f.track_count; track++) {
int current_size = 0;
int total_size = 200000000./cell_size[speed_zone[head][track]];
int sector_count = sectors_per_track[head][track];
int track_size = sector_count*f.sector_base_size;
floppy_image_format_t::desc_e *desc = get_sector_desc(f, current_size, sector_count);
int remaining_size = total_size - current_size;
if(remaining_size < 0)
throw emu_fatalerror("victor9k_format: Incorrect track layout, max_size=%d, current_size=%d", total_size, current_size);
// Fixup the end gap
desc[18].p2 = remaining_size / 8;
desc[19].p2 = remaining_size & 7;
desc[19].p1 >>= remaining_size & 0x01;
desc_s sectors[40];
build_sector_description(f, img, track_offset, sectors, sector_count);
generate_track(desc, track, head, sectors, sector_count, total_size, image);
track_offset += track_size;
}
}
image->set_variant(f.variant);
return true;
}
bool esq8img_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
int track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
UINT8 sectdata[(5*1024) + 512];
desc_s sectors[6];
for(int i=0; i<sector_count; i++) {
if (i < 5)
{
sectors[i].data = sectdata + (1024*i); // 5 1024 byte sectors
sectors[i].size = 1024;
sectors[i].sector_id = i;
}
else
{
sectors[i].data = sectdata + (5*1024); // 1 512 byte sector
sectors[i].size = 512;
sectors[i].sector_id = i;
}
}
int track_size = (5*1024) + 512;
for(int track=0; track < track_count; track++)
{
for(int head=0; head < head_count; head++)
{
io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
generate_track(esq_6_desc, track, head, sectors, sector_count, 109376, image);
}
}
image->set_variant(floppy_image::DSDD);
return true;
}
bool mgt_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
{
uint64_t size = io_generic_size(io);
int sector_count = size == 737280 ? 9 : 10;
uint8_t sectdata[10*512];
desc_s sectors[10];
for(int i=0; i<sector_count; i++) {
sectors[i].data = sectdata + 512*i;
sectors[i].size = 512;
sectors[i].sector_id = i + 1;
}
int track_size = sector_count*512;
for(int head=0; head < 2; head++) {
for(int track=0; track < 80; track++) {
io_generic_read(io, sectdata, (track*2+head)*track_size, track_size);
generate_track(desc_10, track, head, sectors, sector_count+1, 100000, image);
}
}
image->set_variant(floppy_image::DSDD);
return true;
}
bool d81_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
int type = find_size(io, form_factor);
if(type == -1)
return false;
const format &f = formats[type];
floppy_image_format_t::desc_e desc[] = {
/* 00 */ { MFM, 0x4e, f.gap_1 },
/* 01 */ { SECTOR_LOOP_START, 0, f.sector_count-1 },
/* 02 */ { MFM, 0x00, 12 },
/* 03 */ { CRC_CCITT_START, 1 },
/* 04 */ { RAW, 0x4489, 3 },
/* 05 */ { MFM, 0xfe, 1 },
/* 06 */ { TRACK_ID },
/* 07 */ { HEAD_ID_SWAP },
/* 08 */ { SECTOR_ID },
/* 09 */ { SIZE_ID },
/* 10 */ { CRC_END, 1 },
/* 11 */ { CRC, 1 },
/* 12 */ { MFM, 0x4e, f.gap_2 },
/* 13 */ { MFM, 0x00, 12 },
/* 14 */ { CRC_CCITT_START, 2 },
/* 15 */ { RAW, 0x4489, 3 },
/* 16 */ { MFM, 0xfb, 1 },
/* 17 */ { SECTOR_DATA, -1 },
/* 18 */ { CRC_END, 2 },
/* 19 */ { CRC, 2 },
/* 20 */ { MFM, 0x4e, f.gap_3 },
/* 21 */ { SECTOR_LOOP_END },
/* 22 */ { MFM, 0x4e, 0 },
/* 23 */ { RAWBITS, 0x9254, 0 },
/* 24 */ { END }
};
int current_size = f.gap_1*16;
if(f.sector_base_size)
current_size += f.sector_base_size * f.sector_count * 16;
else {
for(int j=0; j != f.sector_count; j++)
current_size += f.per_sector_size[j] * 16;
}
current_size += (12+3+1+4+2+f.gap_2+12+3+1+2+f.gap_3) * f.sector_count * 16;
int total_size = 200000000/f.cell_size;
int remaining_size = total_size - current_size;
if(remaining_size < 0)
throw emu_fatalerror("d81_format: Incorrect track layout, max_size=%d, current_size=%d", total_size, current_size);
// Fixup the end gap
desc[22].p2 = remaining_size / 16;
desc[23].p2 = remaining_size & 15;
desc[23].p1 >>= 16-(remaining_size & 15);
int track_size = compute_track_size(f);
UINT8 sectdata[40*512];
desc_s sectors[40];
build_sector_description(f, sectdata, sectors);
for(int track=0; track < f.track_count; track++)
for(int head=0; head < f.head_count; head++) {
io_generic_read(io, sectdata, (track*f.head_count + !head)*track_size, track_size);
generate_track(desc, track, head, sectors, f.sector_count, total_size, image);
}
image->set_variant(f.variant);
return true;
}
