From b2c399c61d65063ae95e8387d34b098e9516b1a9 Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Mon, 4 Sep 2023 23:28:59 -0700 Subject: imagedev/floppy.cpp: Add hard-sector floppy support --- src/devices/bus/s100/vectordualmode.cpp | 79 ++++++++++++++++++++++----------- src/devices/bus/s100/vectordualmode.h | 11 +++-- src/devices/imagedev/floppy.cpp | 48 +++++++++++++++++--- src/devices/imagedev/floppy.h | 1 + src/lib/formats/flopimg.cpp | 51 ++++++++++++++++++--- src/lib/formats/flopimg.h | 43 +++++++++++++----- src/lib/formats/fs_unformatted.cpp | 40 ++++++++++++----- src/lib/formats/fs_unformatted.h | 4 ++ src/lib/formats/vgi_dsk.cpp | 8 ++-- 9 files changed, 214 insertions(+), 71 deletions(-) diff --git a/src/devices/bus/s100/vectordualmode.cpp b/src/devices/bus/s100/vectordualmode.cpp index c1aec1d746a..1182fe7388d 100644 --- a/src/devices/bus/s100/vectordualmode.cpp +++ b/src/devices/bus/s100/vectordualmode.cpp @@ -65,10 +65,12 @@ s100_vector_dualmode_device::s100_vector_dualmode_device(const machine_config &m , m_cmar(0) , m_drive(0) , m_sector(0) + , m_fdd_sector_counter(0xf) , m_read(false) + , m_busy(false) + , m_last_sector_pulse(attotime::zero) , m_pll() , m_byte_timer(nullptr) - , m_sector_timer(nullptr) , m_pending_byte(0) , m_pending_size(0) { @@ -81,6 +83,8 @@ TIMER_CALLBACK_MEMBER(s100_vector_dualmode_device::motor_off) if (flop) flop->mon_w(1); } + m_byte_timer->enable(false); + m_busy = false; } bool s100_vector_dualmode_device::hdd_selected() @@ -91,6 +95,8 @@ bool s100_vector_dualmode_device::hdd_selected() uint8_t s100_vector_dualmode_device::s100_sinp_r(offs_t offset) { + if (m_busy) + return 0xff; // 7200-1200-02-1 page 16 (1-10) uint8_t data; if (offset == 0xc0) { // status (0) port @@ -124,7 +130,7 @@ uint8_t s100_vector_dualmode_device::s100_sinp_r(offs_t offset) | 0xc0; } else if (offset == 0xc1) { // status (1) port bool floppy_disk_selected; - bool controller_busy = m_sector_timer->enabled(); + bool controller_busy = m_busy; // returned early if true bool motor_on; // FDD bool type_of_hard_disk = true; if (hdd_selected()) { @@ -157,10 +163,8 @@ uint8_t s100_vector_dualmode_device::s100_sinp_r(offs_t offset) void s100_vector_dualmode_device::s100_sout_w(offs_t offset, uint8_t data) { - // TODO: check actual behavior when controller is busy - if (m_sector_timer->enabled()) { + if (m_busy) return; - } // 7200-1200-02-1 page 14 (1-8) if (offset == 0xc0) { // control (0) port m_drive = BIT(data, 0, 2); @@ -183,6 +187,7 @@ void s100_vector_dualmode_device::s100_sout_w(offs_t offset, uint8_t data) // Software should not change other bits when pulsing step flop->stp_w(!step); flop->dir_w(!step_in); + flop->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&s100_vector_dualmode_device::floppy_index_cb, this)); } } else if (offset == 0xc1) { // control (1) port m_sector = BIT(data, 0, 5); @@ -191,14 +196,7 @@ void s100_vector_dualmode_device::s100_sout_w(offs_t offset, uint8_t data) m_ram[m_cmar++] = data; m_cmar &= 0x1ff; } else if (offset == 0xc3) { // start port - floppy_image_device* flop = m_floppy[m_drive]->get_device(); - if (!flop || flop->time_next_index().is_never()) - return; - const attotime rot_time = attotime::from_msec(200); - attotime sector_time = flop->time_next_index() - machine().time() + (rot_time / 16) * m_sector; - if (sector_time > rot_time) - sector_time -= rot_time; - m_sector_timer->adjust(sector_time, SECTOR_START); + m_busy = m_motor_on_timer->enabled(); } } @@ -213,10 +211,40 @@ bool s100_vector_dualmode_device::get_next_bit(attotime &tm, const attotime &lim return true; } -TIMER_CALLBACK_MEMBER(s100_vector_dualmode_device::sector_cb) +void s100_vector_dualmode_device::floppy_index_cb(floppy_image_device *floppy, int state) +{ + if (hdd_selected() || m_floppy[m_drive]->get_device() != floppy) + return; + if (!state) + return; + attotime now = machine().time(); + // U25 74LS221: 61.9 KOhm * .22 uF * .75 + if (now - m_last_sector_pulse < attotime::from_nsec(10213500)) { + m_fdd_sector_counter = 0xf; + } else { + m_last_sector_pulse = now; + m_fdd_sector_counter++; + m_fdd_sector_counter &= 0xf; + start_of_sector(); + } +} + +void s100_vector_dualmode_device::start_of_sector() { - switch (param) { - case SECTOR_START: + if (!m_busy) + return; + + if (m_byte_timer->enabled()) { + // op completed + m_byte_timer->enable(false); + m_busy = false; + if (m_read) + m_ram[274] = 0; // Ignore ECC + return; + } + + uint8_t cur_sector = m_fdd_sector_counter; + if (cur_sector == m_sector) { if (m_read) { m_pll.set_clock(half_bitcell_size); m_pll.read_reset(machine().time()); @@ -233,14 +261,6 @@ TIMER_CALLBACK_MEMBER(s100_vector_dualmode_device::sector_cb) m_pending_size = 0; m_byte_timer->adjust(attotime::zero); } - m_sector_timer->adjust(attotime::from_msec(200)/16, SECTOR_END); - break; - - case SECTOR_END: - m_byte_timer->enable(false); - if (m_read) - m_ram[274] = 0; // Ignore ECC - break; } } @@ -282,13 +302,20 @@ void s100_vector_dualmode_device::device_start() { m_motor_on_timer = timer_alloc(FUNC(s100_vector_dualmode_device::motor_off), this); m_byte_timer = timer_alloc(FUNC(s100_vector_dualmode_device::byte_cb), this); - m_sector_timer = timer_alloc(FUNC(s100_vector_dualmode_device::sector_cb), this); + + for (auto& f : m_floppy) { + if (f->get_device()) + f->get_device()->setup_index_pulse_cb(floppy_image_device::index_pulse_cb(&s100_vector_dualmode_device::floppy_index_cb, this)); + } save_item(NAME(m_ram)); save_item(NAME(m_cmar)); save_item(NAME(m_drive)); save_item(NAME(m_sector)); + save_item(NAME(m_fdd_sector_counter)); save_item(NAME(m_read)); + save_item(NAME(m_busy)); + save_item(NAME(m_last_sector_pulse)); save_item(NAME(m_pending_byte)); save_item(NAME(m_pending_size)); } @@ -307,7 +334,7 @@ void s100_vector_dualmode_device::device_reset() static void vector4_floppies(device_slot_interface &device) { - device.option_add("525", FLOPPY_525_QD); + device.option_add("525", FLOPPY_525_QD16); } static void vector4_formats(format_registration &fr) diff --git a/src/devices/bus/s100/vectordualmode.h b/src/devices/bus/s100/vectordualmode.h index e3a924a94c3..2df40dd8193 100644 --- a/src/devices/bus/s100/vectordualmode.h +++ b/src/devices/bus/s100/vectordualmode.h @@ -26,26 +26,25 @@ protected: private: TIMER_CALLBACK_MEMBER(motor_off); - TIMER_CALLBACK_MEMBER(sector_cb); TIMER_CALLBACK_MEMBER(byte_cb); bool hdd_selected(); bool get_next_bit(attotime &tm, const attotime &limit); + void floppy_index_cb(floppy_image_device *floppy, int state); + void start_of_sector(); required_device_array m_floppy; uint8_t m_ram[512]; uint16_t m_cmar; uint8_t m_drive; uint8_t m_sector; + uint8_t m_fdd_sector_counter; bool m_read; + bool m_busy; emu_timer *m_motor_on_timer; + attotime m_last_sector_pulse; // fdd - enum sector_timer_state { - SECTOR_START, - SECTOR_END, - }; fdc_pll_t m_pll; emu_timer *m_byte_timer; - emu_timer *m_sector_timer; uint16_t m_pending_byte; uint8_t m_pending_size; }; diff --git a/src/devices/imagedev/floppy.cpp b/src/devices/imagedev/floppy.cpp index f2ba36f4cad..618dedadf11 100644 --- a/src/devices/imagedev/floppy.cpp +++ b/src/devices/imagedev/floppy.cpp @@ -70,6 +70,7 @@ DEFINE_DEVICE_TYPE(FLOPPY_525_SSDD, floppy_525_ssdd, "floppy_525_ssdd", DEFINE_DEVICE_TYPE(FLOPPY_525_DD, floppy_525_dd, "floppy_525_dd", "5.25\" double density floppy drive") DEFINE_DEVICE_TYPE(FLOPPY_525_SSQD, floppy_525_ssqd, "floppy_525_ssqd", "5.25\" single-sided quad density floppy drive") DEFINE_DEVICE_TYPE(FLOPPY_525_QD, floppy_525_qd, "floppy_525_qd", "5.25\" quad density floppy drive") +DEFINE_DEVICE_TYPE(FLOPPY_525_QD16, floppy_525_qd16, "floppy_525_qd16", "5.25\" quad density 16 hard sector floppy drive") DEFINE_DEVICE_TYPE(FLOPPY_525_HD, floppy_525_hd, "floppy_525_hd", "5.25\" high density floppy drive") // generic 8" drives @@ -370,7 +371,7 @@ void floppy_image_device::set_rpm(float _rpm) return; rpm = _rpm; - rev_time = attotime::from_double(60/rpm); + rev_time = attotime::from_double(60.0/rpm); angular_speed = rpm/60.0*2e8; } @@ -903,13 +904,20 @@ TIMER_CALLBACK_MEMBER(floppy_image_device::index_resync) } int position = int(delta.as_double()*angular_speed + 0.5); - int new_idx = position < 2000000; + uint32_t last_index = 0, next_index = 200000000; + // if hard-sectored floppy, has extra IDX pulses + if(image) + image->find_index_hole(position, last_index, next_index); + int new_idx = position - last_index < 2000000; if(new_idx) { - attotime index_up_time = attotime::from_double(2000000/angular_speed); + uint32_t index_up = last_index + 2000000; + attotime index_up_time = attotime::from_double(index_up/angular_speed); index_timer->adjust(index_up_time - delta); - } else - index_timer->adjust(rev_time - delta); + } else { + attotime next_index_time = attotime::from_double(next_index/angular_speed); + index_timer->adjust(next_index_time - delta); + } if(new_idx != idx) { idx = new_idx; @@ -949,7 +957,9 @@ void floppy_image_device::check_led() double floppy_image_device::get_pos() { - return index_timer->elapsed().as_double(); + if(revolution_start_time.is_never()) + return 0; + return (machine().time() - revolution_start_time).as_double(); } bool floppy_image_device::twosid_r() @@ -2174,6 +2184,32 @@ void floppy_525_qd::setup_characteristics() variants.push_back(floppy_image::DSQD); } +//------------------------------------------------- +// 5.25" double-sided quad density 16 hard sector +//------------------------------------------------- + +floppy_525_qd16::floppy_525_qd16(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : + floppy_image_device(mconfig, FLOPPY_525_QD16, tag, owner, clock) +{ +} + +floppy_525_qd16::~floppy_525_qd16() +{ +} + +void floppy_525_qd16::setup_characteristics() +{ + form_factor = floppy_image::FF_525; + tracks = 84; + sides = 2; + set_rpm(300); + + variants.push_back(floppy_image::SSDD16); + variants.push_back(floppy_image::SSQD16); + variants.push_back(floppy_image::DSDD16); + variants.push_back(floppy_image::DSQD16); +} + //------------------------------------------------- // 5.25" high density //------------------------------------------------- diff --git a/src/devices/imagedev/floppy.h b/src/devices/imagedev/floppy.h index ce4e40e1a36..17f71ddb346 100644 --- a/src/devices/imagedev/floppy.h +++ b/src/devices/imagedev/floppy.h @@ -332,6 +332,7 @@ DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_525_SSDD, floppy_525_ssdd, "floppy_5_ DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_525_DD, floppy_525_dd, "floppy_5_25") DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_525_SSQD, floppy_525_ssqd, "floppy_5_25") DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_525_QD, floppy_525_qd, "floppy_5_25") +DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_525_QD16, floppy_525_qd16, "floppy_5_25") DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_525_HD, floppy_525_hd, "floppy_5_25") DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_8_SSSD, floppy_8_sssd, "floppy_8") DECLARE_FLOPPY_IMAGE_DEVICE(FLOPPY_8_DSSD, floppy_8_dssd, "floppy_8") diff --git a/src/lib/formats/flopimg.cpp b/src/lib/formats/flopimg.cpp index d4604530c1e..7dc5613fe6b 100644 --- a/src/lib/formats/flopimg.cpp +++ b/src/lib/formats/flopimg.cpp @@ -35,6 +35,39 @@ floppy_image::~floppy_image() { } +void floppy_image::set_variant(uint32_t _variant) +{ + variant = _variant; + + // Initialize hard sectors + index_array.clear(); + + uint32_t sectors; + switch(variant) { + case SSDD16: + case SSQD16: + case DSDD16: + case DSQD16: + sectors = 16; + break; + default: + sectors = 0; + } + if(sectors) { + uint32_t sector_angle = 200000000/sectors; + for(int i = 1; i < sectors; i++) + index_array.push_back(i*sector_angle); + index_array.push_back((sectors-1)*sector_angle + sector_angle/2); + } +} + +void floppy_image::find_index_hole(uint32_t pos, uint32_t &last, uint32_t &next) +{ + auto nexti = std::lower_bound(index_array.begin(), index_array.end(), pos+1); + next = nexti == index_array.end() ? 200000000 : *nexti; + last = nexti == index_array.begin() ? 0 : *--nexti; +} + void floppy_image::get_maximal_geometry(int &_tracks, int &_heads) const { _tracks = tracks; @@ -100,13 +133,17 @@ bool floppy_image::track_is_formatted(int track, int head, int subtrack) const char *floppy_image::get_variant_name(uint32_t form_factor, uint32_t variant) { switch(variant) { - case SSSD: return "Single side, single density"; - case SSDD: return "Single side, double density"; - case SSQD: return "Single side, quad density"; - case DSDD: return "Double side, double density"; - case DSQD: return "Double side, quad density"; - case DSHD: return "Double side, high density"; - case DSED: return "Double side, extended density"; + case SSSD: return "Single side, single density"; + case SSDD: return "Single side, double density"; + case SSDD16: return "Single side, double density, 16 hard sector"; + case SSQD: return "Single side, quad density"; + case SSQD16: return "Single side, quad density, 16 hard sector"; + case DSDD: return "Double side, double density"; + case DSDD16: return "Double side, double density, 16 hard sector"; + case DSQD: return "Double side, quad density"; + case DSQD16: return "Double side, quad density, 16 hard sector"; + case DSHD: return "Double side, high density"; + case DSED: return "Double side, extended density"; } return "Unknown"; } diff --git a/src/lib/formats/flopimg.h b/src/lib/formats/flopimg.h index 5566a5eb5cc..56cb8b36080 100644 --- a/src/lib/formats/flopimg.h +++ b/src/lib/formats/flopimg.h @@ -525,14 +525,18 @@ public: //! Variants enum { - SSSD = 0x44535353, //!< "SSSD", Single-sided single-density - SSDD = 0x44445353, //!< "SSDD", Single-sided double-density - SSQD = 0x44515353, //!< "SSQD", Single-sided quad-density - DSSD = 0x44535344, //!< "DSSD", Double-sided single-density - DSDD = 0x44445344, //!< "DSDD", Double-sided double-density (720K in 3.5, 360K in 5.25) - DSQD = 0x44515344, //!< "DSQD", Double-sided quad-density (720K in 5.25, means DD+80 tracks) - DSHD = 0x44485344, //!< "DSHD", Double-sided high-density (1440K) - DSED = 0x44455344 //!< "DSED", Double-sided extra-density (2880K) + SSSD = 0x44535353, //!< "SSSD", Single-sided single-density + SSDD = 0x44445353, //!< "SSDD", Single-sided double-density + SSDD16 = 0x36314453, //!< "SD16", Single-sided double-density 16 hard sector + SSQD = 0x44515353, //!< "SSQD", Single-sided quad-density + SSQD16 = 0x36315153, //!< "SQ16", Single-sided quad-density 16 hard sector + DSSD = 0x44535344, //!< "DSSD", Double-sided single-density + DSDD = 0x44445344, //!< "DSDD", Double-sided double-density (720K in 3.5, 360K in 5.25) + DSDD16 = 0x36314444, //!< "DD16", Double-sided double-density 16 hard sector (360K in 5.25) + DSQD = 0x44515344, //!< "DSQD", Double-sided quad-density (720K in 5.25, means DD+80 tracks) + DSQD16 = 0x36315144, //!< "DQ16", Double-sided quad-density 16 hard sector (720K in 5.25, means DD+80 tracks) + DSHD = 0x44485344, //!< "DSHD", Double-sided high-density (1440K) + DSED = 0x44455344 //!< "DSED", Double-sided extra-density (2880K) }; //! Encodings @@ -559,9 +563,20 @@ public: //! @return the variant. uint32_t get_variant() const { return variant; } //! @param v the variant. - void set_variant(uint32_t v) { variant = v; } + void set_variant(uint32_t v); //! @param v the variant. - void set_form_variant(uint32_t f, uint32_t v) { if(form_factor == FF_UNKNOWN) form_factor = f; variant = v; } + void set_form_variant(uint32_t f, uint32_t v) { if(form_factor == FF_UNKNOWN) form_factor = f; set_variant(v); } + + //! Find most recent and next index hole for provided angular position. + //! The most recent hole may be equal to provided position. The next + //! hole will be 200000000 if all holes of the current rotation are in + //! the past. + + /*! @param pos angular position + @param last most recent index hole + @param next next index hole + */ + void find_index_hole(uint32_t pos, uint32_t &last, uint32_t &next); /*! @param track @@ -620,6 +635,14 @@ private: // track number multiplied by 4 then head // last array size may be bigger than actual track size std::vector > track_array; + + // Additional index holes in increasing order. Entries are absolute + // positions of index holes in the same units as cell_data. The + // positions are the start of the hole, not the center of the hole. The + // hole at angular position 0 is implicit, so an empty list encodes a + // regular soft-sectored disk. Additional holes are found on + // hard-sectored disks. + std::vector index_array; }; #endif // MAME_FORMATS_FLOPIMG_H diff --git a/src/lib/formats/fs_unformatted.cpp b/src/lib/formats/fs_unformatted.cpp index f200f11894e..03a795023af 100644 --- a/src/lib/formats/fs_unformatted.cpp +++ b/src/lib/formats/fs_unformatted.cpp @@ -33,11 +33,15 @@ void unformatted_image::enumerate_f(floppy_enumerator &fe) const u32 best_525 = form_factor == floppy_image::FF_525 ? - has_variant(variants, floppy_image::DSHD) ? FSI_525_DSHD : - has_variant(variants, floppy_image::DSQD) ? FSI_525_DSQD : - has_variant(variants, floppy_image::DSDD) ? FSI_525_DSDD : - has_variant(variants, floppy_image::SSQD) ? FSI_525_SSQD : - has_variant(variants, floppy_image::SSDD) ? FSI_525_SSDD : FSI_525_SSSD + has_variant(variants, floppy_image::DSHD) ? FSI_525_DSHD : + has_variant(variants, floppy_image::DSQD16) ? FSI_525_DSQD16 : + has_variant(variants, floppy_image::DSQD) ? FSI_525_DSQD : + has_variant(variants, floppy_image::DSDD16) ? FSI_525_DSDD16 : + has_variant(variants, floppy_image::DSDD) ? FSI_525_DSDD : + has_variant(variants, floppy_image::SSQD16) ? FSI_525_SSQD16 : + has_variant(variants, floppy_image::SSQD) ? FSI_525_SSQD : + has_variant(variants, floppy_image::SSDD16) ? FSI_525_SSDD16 : + has_variant(variants, floppy_image::SSDD) ? FSI_525_SSDD : FSI_525_SSSD : FSI_NONE; u32 best_35 = @@ -59,14 +63,22 @@ void unformatted_image::enumerate_f(floppy_enumerator &fe) const if(all || best_525 == FSI_525_DSHD) fe.add_raw("u525dshd", FSI_525_DSHD, "Unformatted 5\"25 double-sided high-density"); + if(all || best_525 == FSI_525_DSQD16) + fe.add_raw("u525dsqd16", FSI_525_DSQD16, "Unformatted 5\"25 double-sided quad-density 16 hard sectors"); if(all || best_525 == FSI_525_DSQD) fe.add_raw("u525dsqd", FSI_525_DSQD, "Unformatted 5\"25 double-sided quad-density"); + if(all || best_525 == FSI_525_DSDD16) + fe.add_raw("u525dsdd16", FSI_525_DSDD16, "Unformatted 5\"25 double-sided double-density 16 hard sectors"); if(all || best_525 == FSI_525_DSDD) fe.add_raw("u525dsdd", FSI_525_DSDD, "Unformatted 5\"25 double-sided double-density"); if(all) fe.add_raw("u525dssd", FSI_525_DSSD, "Unformatted 5\"25 double-sided single-density"); + if(all || best_525 == FSI_525_SSQD16) + fe.add_raw("u525ssqd16", FSI_525_SSQD16, "Unformatted 5\"25 single-sided quad-density 16 hard sectors"); if(all || best_525 == FSI_525_SSQD) fe.add_raw("u525ssqd", FSI_525_SSQD, "Unformatted 5\"25 single-sided quad-density"); + if(all || best_525 == FSI_525_SSDD16) + fe.add_raw("u525ssdd16", FSI_525_SSDD16, "Unformatted 5\"25 single-sided double-density 16 hard sectors"); if(all || best_525 == FSI_525_SSDD) fe.add_raw("u525ssdd", FSI_525_SSDD, "Unformatted 5\"25 single-sided double-density"); if(all || best_525 == FSI_525_SSSD) @@ -94,13 +106,17 @@ void unformatted_image::format(u32 key, floppy_image *image) case FSI_8_DSSD: image->set_form_variant(floppy_image::FF_8, floppy_image::DSSD); break; case FSI_8_SSSD: image->set_form_variant(floppy_image::FF_8, floppy_image::SSSD); break; - case FSI_525_DSHD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSHD); break; - case FSI_525_DSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSQD); break; - case FSI_525_DSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSDD); break; - case FSI_525_DSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSSD); break; - case FSI_525_SSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSQD); break; - case FSI_525_SSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSDD); break; - case FSI_525_SSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSSD); break; + case FSI_525_DSHD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSHD); break; + case FSI_525_DSQD16: image->set_form_variant(floppy_image::FF_525, floppy_image::DSQD16); break; + case FSI_525_DSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSQD); break; + case FSI_525_DSDD16: image->set_form_variant(floppy_image::FF_525, floppy_image::DSDD16); break; + case FSI_525_DSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSDD); break; + case FSI_525_DSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSSD); break; + case FSI_525_SSQD16: image->set_form_variant(floppy_image::FF_525, floppy_image::SSQD16); break; + case FSI_525_SSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSQD); break; + case FSI_525_SSDD16: image->set_form_variant(floppy_image::FF_525, floppy_image::SSDD16); break; + case FSI_525_SSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSDD); break; + case FSI_525_SSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSSD); break; case FSI_35_DSED: image->set_form_variant(floppy_image::FF_35, floppy_image::DSED); break; case FSI_35_DSHD: image->set_form_variant(floppy_image::FF_35, floppy_image::DSHD); break; diff --git a/src/lib/formats/fs_unformatted.h b/src/lib/formats/fs_unformatted.h index 80973b4e7e3..cf58a6dc0c8 100644 --- a/src/lib/formats/fs_unformatted.h +++ b/src/lib/formats/fs_unformatted.h @@ -23,10 +23,14 @@ public: FSI_525_SSSD, FSI_525_SSDD, + FSI_525_SSDD16, FSI_525_SSQD, + FSI_525_SSQD16, FSI_525_DSSD, FSI_525_DSDD, + FSI_525_DSDD16, FSI_525_DSQD, + FSI_525_DSQD16, FSI_525_DSHD, FSI_35_SSDD, diff --git a/src/lib/formats/vgi_dsk.cpp b/src/lib/formats/vgi_dsk.cpp index c15bba33d86..d367480eb18 100644 --- a/src/lib/formats/vgi_dsk.cpp +++ b/src/lib/formats/vgi_dsk.cpp @@ -32,10 +32,10 @@ struct format { }; static const format formats[] = { - {1, 35, floppy_image::SSDD}, // MOD-I - {2, 35, floppy_image::DSDD}, - {1, 77, floppy_image::SSQD}, // MOD-II - {2, 77, floppy_image::DSQD}, + {1, 35, floppy_image::SSDD16}, // MOD-I + {2, 35, floppy_image::DSDD16}, + {1, 77, floppy_image::SSQD16}, // MOD-II + {2, 77, floppy_image::DSQD16}, {} }; -- cgit v1.2.3