Previous 199869 Revisions Next

r17455 Friday 24th August, 2012 at 22:22:41 UTC by O. Galibert
floppy: Harmless intermediate commit that could help Micko (nw)
[src/emu/imagedev]floppy.c floppy.h
[src/lib]lib.mak
[src/lib/formats]d88_dsk.c d88_dsk.h flopimg.h upd765_dsk.c upd765_dsk.h xdf_dsk.c xdf_dsk.h

trunk/src/emu/imagedev/floppy.c
r17454r17455
1212
1313// device type definition
1414const device_type FLOPPY_CONNECTOR = &device_creator<floppy_connector>;
15const device_type FLOPPY_3_SSDD = &device_creator<floppy_3_ssdd>;
16const device_type FLOPPY_3_DSDD = &device_creator<floppy_3_dsdd>;
1517const device_type FLOPPY_35_DD = &device_creator<floppy_35_dd>;
1618const device_type FLOPPY_35_DD_NOSD = &device_creator<floppy_35_dd_nosd>;
1719const device_type FLOPPY_35_HD = &device_creator<floppy_35_hd>;
1820const device_type FLOPPY_35_ED = &device_creator<floppy_35_ed>;
21const device_type FLOPPY_525_SSDD = &device_creator<floppy_525_ssdd>;
1922const device_type FLOPPY_525_DD = &device_creator<floppy_525_dd>;
23const device_type FLOPPY_525_QD = &device_creator<floppy_525_qd>;
2024const device_type FLOPPY_525_HD = &device_creator<floppy_525_hd>;
25const device_type FLOPPY_8_SSSD = &device_creator<floppy_8_sssd>;
2126
2227floppy_connector::floppy_connector(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
2328   device_t(mconfig, FLOPPY_CONNECTOR, "Floppy drive connector abstraction", tag, owner, clock),
r17454r17455
175180
176181   /* motor off */
177182   mon = 1;
178   /* set write protect on */
179   wpt = 0;
180183
181184   cyl = 0;
182185   ss  = 1;
r17454r17455
344347   }
345348}
346349
347int floppy_image_device::ready_r()
350bool floppy_image_device::ready_r()
348351{
349352   if (exists())
350353   {
r17454r17455
412415      revc++;
413416   }
414417
415   return (delta*(rpm/300)).as_ticks(1000000000);
418   return (delta*rpm/300).as_ticks(1000000000);
416419}
417420
418421attotime floppy_image_device::get_next_transition(attotime from_when)
r17454r17455
441444   else
442445      next_position = 200000000 + (buf[1] & floppy_image::TIME_MASK);
443446
444
445   return base + attotime::from_nsec(next_position*(300/rpm));
447   //   logerror("Floppy: cuspos=%d nextpos=%d\n", position, next_position);
448   return base + attotime::from_nsec(UINT64(next_position)*300/rpm);
446449}
447450
448451void floppy_image_device::write_flux(attotime start, attotime end, int transition_count, const attotime *transitions)
r17454r17455
760763   }
761764}
762765
766floppy_3_ssdd::floppy_3_ssdd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
767   floppy_image_device(mconfig, FLOPPY_3_SSDD, "3\" double sided floppy drive", tag, owner, clock)
768{
769}
770
771floppy_3_ssdd::~floppy_3_ssdd()
772{
773}
774
775void floppy_3_ssdd::setup_characteristics()
776{
777   form_factor = floppy_image::FF_3;
778   tracks = 42;
779   sides = 2;
780   set_rpm(300);
781}
782
783void floppy_3_ssdd::handled_variants(UINT32 *variants, int &var_count) const
784{
785   var_count = 0;
786   variants[var_count++] = floppy_image::SSDD;
787}
788
789floppy_3_dsdd::floppy_3_dsdd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
790   floppy_image_device(mconfig, FLOPPY_3_DSDD, "3\" single sided floppy drive", tag, owner, clock)
791{
792}
793
794floppy_3_dsdd::~floppy_3_dsdd()
795{
796}
797
798void floppy_3_dsdd::setup_characteristics()
799{
800   form_factor = floppy_image::FF_3;
801   tracks = 42;
802   sides = 1;
803   set_rpm(300);
804}
805
806void floppy_3_dsdd::handled_variants(UINT32 *variants, int &var_count) const
807{
808   var_count = 0;
809   variants[var_count++] = floppy_image::SSDD;
810   variants[var_count++] = floppy_image::DSDD;
811}
812
763813floppy_35_dd::floppy_35_dd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
764814   floppy_image_device(mconfig, FLOPPY_35_DD, "3.5\" double density floppy drive", tag, owner, clock)
765815{
r17454r17455
862912   variants[var_count++] = floppy_image::DSED;
863913}
864914
915floppy_525_ssdd::floppy_525_ssdd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
916   floppy_image_device(mconfig, FLOPPY_525_SSDD, "5.25\" single-sided double density floppy drive", tag, owner, clock)
917{
918}
919
920floppy_525_ssdd::~floppy_525_ssdd()
921{
922}
923
924void floppy_525_ssdd::setup_characteristics()
925{
926   form_factor = floppy_image::FF_525;
927   tracks = 42;
928   sides = 1;
929   set_rpm(300);
930}
931
932void floppy_525_ssdd::handled_variants(UINT32 *variants, int &var_count) const
933{
934   var_count = 0;
935   variants[var_count++] = floppy_image::SSSD;
936   variants[var_count++] = floppy_image::SSDD;
937}
938
865939floppy_525_dd::floppy_525_dd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
866940   floppy_image_device(mconfig, FLOPPY_525_DD, "5.25\" double density floppy drive", tag, owner, clock)
867941{
r17454r17455
884958   var_count = 0;
885959   variants[var_count++] = floppy_image::SSSD;
886960   variants[var_count++] = floppy_image::SSDD;
961   variants[var_count++] = floppy_image::DSDD;
887962}
888963
964floppy_525_qd::floppy_525_qd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
965   floppy_image_device(mconfig, FLOPPY_525_QD, "5.25\" quad density floppy drive", tag, owner, clock)
966{
967}
968
969floppy_525_qd::~floppy_525_qd()
970{
971}
972
973void floppy_525_qd::setup_characteristics()
974{
975   form_factor = floppy_image::FF_525;
976   tracks = 84;
977   sides = 2;
978   set_rpm(300);
979}
980
981void floppy_525_qd::handled_variants(UINT32 *variants, int &var_count) const
982{
983   var_count = 0;
984   variants[var_count++] = floppy_image::SSSD;
985   variants[var_count++] = floppy_image::SSDD;
986   variants[var_count++] = floppy_image::SSQD;
987   variants[var_count++] = floppy_image::DSDD;
988   variants[var_count++] = floppy_image::DSQD;
989}
990
889991floppy_525_hd::floppy_525_hd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
890992   floppy_image_device(mconfig, FLOPPY_525_HD, "5.25\" high density floppy drive", tag, owner, clock)
891993{
r17454r17455
8981000void floppy_525_hd::setup_characteristics()
8991001{
9001002   form_factor = floppy_image::FF_525;
901   tracks = 82;
1003   tracks = 84;
9021004   sides = 2;
903   set_rpm(300);
1005   set_rpm(360);
9041006}
9051007
9061008void floppy_525_hd::handled_variants(UINT32 *variants, int &var_count) const
r17454r17455
9081010   var_count = 0;
9091011   variants[var_count++] = floppy_image::SSSD;
9101012   variants[var_count++] = floppy_image::SSDD;
1013   variants[var_count++] = floppy_image::SSQD;
9111014   variants[var_count++] = floppy_image::DSDD;
1015   variants[var_count++] = floppy_image::DSQD;
9121016   variants[var_count++] = floppy_image::DSHD;
913   
9141017}
1018
1019floppy_8_sssd::floppy_8_sssd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
1020   floppy_image_device(mconfig, FLOPPY_8_SSSD, "8\" single density floppy drive", tag, owner, clock)
1021{
1022}
1023
1024floppy_8_sssd::~floppy_8_sssd()
1025{
1026}
1027
1028void floppy_8_sssd::setup_characteristics()
1029{
1030   form_factor = floppy_image::FF_8;
1031   tracks = 77;
1032   sides = 1;
1033   set_rpm(300);
1034}
1035
1036void floppy_8_sssd::handled_variants(UINT32 *variants, int &var_count) const
1037{
1038   var_count = 0;
1039   variants[var_count++] = floppy_image::SSSD;
1040}
trunk/src/emu/imagedev/floppy.h
r17454r17455
6666   UINT32 get_len() { return image->get_track_size(cyl, ss ^ 1); }
6767
6868   void mon_w(int state);
69   int ready_r();
69   bool ready_r();
7070   double get_pos();
7171
72   int wpt_r() { return wpt; }
72   bool wpt_r() { return output_format == 0; }
7373   int dskchg_r() { return dskchg; }
7474   bool trk00_r() { return cyl != 0; }
7575   int idx_r() { return idx; }
76   bool ss_r() { return ss; }
7677
7778   void stp_w(int state);
7879   void dir_w(int state) { dir = state; }
r17454r17455
160161   virtual void hook_load(astring filename, bool softlist);
161162};
162163
164class floppy_3_ssdd : public floppy_image_device {
165public:
166   floppy_3_ssdd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
167   virtual ~floppy_3_ssdd();
168   virtual void handled_variants(UINT32 *variants, int &var_count) const;
169   virtual void device_config_complete() { m_shortname = "floppy_3_ssdd"; }
170   virtual const char *image_interface() const { return "floppy_3"; }
171protected:
172   virtual void setup_characteristics();
173};
174
175class floppy_3_dsdd : public floppy_image_device {
176public:
177   floppy_3_dsdd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
178   virtual ~floppy_3_dsdd();
179   virtual void handled_variants(UINT32 *variants, int &var_count) const;
180   virtual void device_config_complete() { m_shortname = "floppy_3_dsdd"; }
181   virtual const char *image_interface() const { return "floppy_3"; }
182protected:
183   virtual void setup_characteristics();
184};
185
163186class floppy_35_dd : public floppy_image_device {
164187public:
165188   floppy_35_dd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
r17454r17455
204227   virtual void setup_characteristics();
205228};
206229
230class floppy_525_ssdd : public floppy_image_device {
231public:
232   floppy_525_ssdd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
233   virtual ~floppy_525_ssdd();
234   virtual void handled_variants(UINT32 *variants, int &var_count) const;
235   virtual void device_config_complete() { m_shortname = "floppy_525_ssdd"; }
236   virtual const char *image_interface() const { return "floppy_5_25"; }
237protected:
238   virtual void setup_characteristics();
239};
240
207241class floppy_525_dd : public floppy_image_device {
208242public:
209243   floppy_525_dd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
r17454r17455
215249   virtual void setup_characteristics();
216250};
217251
252class floppy_525_qd : public floppy_image_device {
253public:
254   floppy_525_qd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
255   virtual ~floppy_525_qd();
256   virtual void handled_variants(UINT32 *variants, int &var_count) const;
257   virtual void device_config_complete() { m_shortname = "floppy_525_qd"; }
258   virtual const char *image_interface() const { return "floppy_5_25"; }
259protected:
260   virtual void setup_characteristics();
261};
218262
219263class floppy_525_hd : public floppy_image_device {
220264public:
r17454r17455
227271   virtual void setup_characteristics();
228272};
229273
274class floppy_8_sssd : public floppy_image_device {
275public:
276   floppy_8_sssd(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
277   virtual ~floppy_8_sssd();
278   virtual void handled_variants(UINT32 *variants, int &var_count) const;
279   virtual void device_config_complete() { m_shortname = "floppy_8_sssd"; }
280   virtual const char *image_interface() const { return "floppy_8"; }
281protected:
282   virtual void setup_characteristics();
283};
284
230285class floppy_connector: public device_t,
231286                  public device_slot_interface
232287{
r17454r17455
248303
249304// device type definition
250305extern const device_type FLOPPY_CONNECTOR;
306extern const device_type FLOPPY_3_SSDD;
307extern const device_type FLOPPY_3_DSDD;
251308extern const device_type FLOPPY_35_DD;
252309extern const device_type FLOPPY_35_DD_NOSD;
253310extern const device_type FLOPPY_35_HD;
254311extern const device_type FLOPPY_35_ED;
312extern const device_type FLOPPY_525_SSDD;
255313extern const device_type FLOPPY_525_DD;
314extern const device_type FLOPPY_525_QD;
256315extern const device_type FLOPPY_525_HD;
316extern const device_type FLOPPY_8_SSSD;
257317
258318#endif /* FLOPPY_H */
trunk/src/lib/formats/d88_dsk.c
r17454r17455
376376
377377   return FLOPPY_ERROR_SUCCESS;
378378}
379
380
381
382/***************************************************************************
383
384    Copyright Olivier Galibert
385    All rights reserved.
386
387    Redistribution and use in source and binary forms, with or without
388    modification, are permitted provided that the following conditions are
389    met:
390
391        * Redistributions of source code must retain the above copyright
392          notice, this list of conditions and the following disclaimer.
393        * Redistributions in binary form must reproduce the above copyright
394          notice, this list of conditions and the following disclaimer in
395          the documentation and/or other materials provided with the
396          distribution.
397        * Neither the name 'MAME' nor the names of its contributors may be
398          used to endorse or promote products derived from this software
399          without specific prior written permission.
400
401    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
402    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
403    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
404    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
405    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
406    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
407    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
408    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
409    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
410    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
411    POSSIBILITY OF SUCH DAMAGE.
412
413****************************************************************************/
414
415/*********************************************************************
416
417    formats/d88_dsk.h
418
419    D88 disk images
420
421*********************************************************************/
422
423#include "emu.h"
424#include "d88_dsk.h"
425
426d88_format::d88_format()
427{
428}
429
430const char *d88_format::name() const
431{
432   return "d88";
433}
434
435const char *d88_format::description() const
436{
437   return "D88 disk image";
438}
439
440const char *d88_format::extensions() const
441{
442   return "d77,d88,1dd";
443}
444
445int d88_format::identify(io_generic *io, UINT32 form_factor)
446{
447   int size = io_generic_size(io);
448   UINT8 h[32];
449   
450   io_generic_read(io, h, 0, 32);
451   if((LITTLE_ENDIANIZE_INT32(*(UINT32 *)(h+0x1c)) == size) &&
452      (h[0x1b] == 0x00 || h[0x1b] == 0x10 || h[0x1b] == 0x20 || h[0x1b] == 0x30 || h[0x1b] == 0x40))
453      return 100;
454
455   return 0;
456}
457
458bool d88_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
459{
460   UINT8 h[32];
461   
462   io_generic_read(io, h, 0, 32);
463
464   int cell_count = 0;
465   int track_count = 0;
466   int head_count = 0;
467   switch(h[0x1b]) {
468   case 0x00:
469      cell_count = 100000;
470      track_count = 42;
471      head_count = 2;
472      image->set_variant(floppy_image::DSDD);
473      break;
474
475   case 0x10:
476      cell_count = 100000;
477      track_count = 82;
478      head_count = 2;
479      image->set_variant(floppy_image::DSQD);
480      break;
481
482   case 0x20:
483      cell_count = form_factor == floppy_image::FF_35 ? 200000 : 166666;
484      track_count = 82;
485      head_count = 2;
486      image->set_variant(floppy_image::DSHD);
487      break;
488
489   case 0x30:
490      cell_count = 100000;
491      track_count = 42;
492      head_count = 1;
493      image->set_variant(floppy_image::SSDD);
494      break;
495
496   case 0x40:
497      cell_count = 100000;
498      track_count = 82;
499      head_count = 1;
500      image->set_variant(floppy_image::SSQD);
501      break;
502   }
503
504   if(!head_count)
505      return false;
506
507   UINT32 track_pos[164];
508   io_generic_read(io, track_pos, 32, 164*4);
509
510   for(int track=0; track < track_count; track++)
511      for(int head=0; head < head_count; head++) {
512         int pos = LITTLE_ENDIANIZE_INT32(track_pos[track * head_count + head]);
513         if(!pos)
514            continue;
515
516         UINT32 track_data[210000];
517         UINT8 sect_data[65536];
518         int tpos = 0;
519
520         // gap 4a , IAM and gap 1
521         for(int i=0; i<80; i++) mfm_w(track_data, tpos, 8, 0x4e);
522         for(int i=0; i<12; i++) mfm_w(track_data, tpos, 8, 0x00);
523         for(int i=0; i< 3; i++) raw_w(track_data, tpos, 16, 0x5224);
524         mfm_w(track_data, tpos, 8, 0xfc);
525         for(int i=0; i<50; i++) mfm_w(track_data, tpos, 8, 0x4e);
526
527         // Updated after reading the first header
528         int sector_count = 1;
529         int gap3 = 84;
530         for(int i=0; i<sector_count; i++) {
531            UINT8 hs[16];
532            io_generic_read(io, hs, pos, 16);
533            UINT16 size = LITTLE_ENDIANIZE_INT16(*(UINT16 *)(hs+14));
534            io_generic_read(io, sect_data, pos+16, size);
535            pos += 16+size;
536
537            if(i == 0) {
538               sector_count = LITTLE_ENDIANIZE_INT16(*(UINT16 *)(hs+4));
539               if(size < 512)
540                  gap3 = form_factor == floppy_image::FF_35 ? 54 : 50;
541               else
542                  gap3 = form_factor == floppy_image::FF_35 ? 84 : 80;
543            }
544
545            int cpos;
546            UINT16 crc;
547            // sync and IDAM and gap 2
548            for(int j=0; j<12; j++) mfm_w(track_data, tpos, 8, 0x00);
549            cpos = tpos;
550            for(int j=0; j< 3; j++) raw_w(track_data, tpos, 16, 0x4489);
551            mfm_w(track_data, tpos, 8, 0xfe);
552            mfm_w(track_data, tpos, 8, hs[0]);
553            mfm_w(track_data, tpos, 8, hs[1]);
554            mfm_w(track_data, tpos, 8, hs[2]);
555            mfm_w(track_data, tpos, 8, hs[3]);
556            crc = calc_crc_ccitt(track_data, cpos, tpos);
557            mfm_w(track_data, tpos, 16, crc);
558            for(int j=0; j<22; j++) mfm_w(track_data, tpos, 8, 0x4e);
559
560            // sync, DAM, data and gap 3
561            for(int j=0; j<12; j++) mfm_w(track_data, tpos, 8, 0x00);
562            cpos = tpos;
563            for(int j=0; j< 3; j++) raw_w(track_data, tpos, 16, 0x4489);
564            mfm_w(track_data, tpos, 8, 0xfb);
565            for(int j=0; j<size; j++) mfm_w(track_data, tpos, 8, sect_data[j]);
566            crc = calc_crc_ccitt(track_data, cpos, tpos);
567            mfm_w(track_data, tpos, 16, crc);
568            for(int j=0; j<gap3; j++) mfm_w(track_data, tpos, 8, 0x4e);
569         }
570
571         // Gap 4b
572
573         if(tpos > cell_count)
574            throw emu_fatalerror("d88_format: Incorrect layout on track %d head %d, expected_size=%d, current_size=%d", track, head, cell_count, tpos);
575         while(tpos < cell_count-15) mfm_w(track_data, tpos, 8, 0x4e);
576         raw_w(track_data, tpos, cell_count-tpos, 0x9254 >> (16+tpos-cell_count));
577
578         generate_track_from_levels(track, head, track_data, cell_count, 0, image);
579      }
580
581   return true;
582}
583
584
585bool d88_format::save(io_generic *io, floppy_image *image)
586{
587   return true;
588}
589
590bool d88_format::supports_save() const
591{
592   return true;
593}
594
595const floppy_format_type FLOPPY_D88_FORMAT = &floppy_image_format_creator<d88_format>;
trunk/src/lib/formats/d88_dsk.h
r17454r17455
1/*********************************************************************
2
3    formats/d88_dsk.h
4
5    D88 disk images
6
7*********************************************************************/
8
9#ifndef D88_DSK_H
10#define D88_DSK_H
11
12#include "flopimg.h"
13
14
15class d88_format : public floppy_image_format_t
16{
17public:
18   d88_format();
19
20   virtual int identify(io_generic *io, UINT32 form_factor);
21   virtual bool load(io_generic *io, UINT32 form_factor, floppy_image *image);
22   virtual bool save(io_generic *io, floppy_image *image);
23
24   virtual const char *name() const;
25   virtual const char *description() const;
26   virtual const char *extensions() const;
27   virtual bool supports_save() const;
28};
29
30extern const floppy_format_type FLOPPY_D88_FORMAT;
31
32#endif /* D88_DSK_H */
trunk/src/lib/formats/flopimg.h
r17454r17455
608608   //! Form factors
609609   enum {
610610      FF_UNKNOWN  = 0x00000000, //!< Unknown, useful when converting
611      FF_3        = 0x20202033, //!< "3   " 3 inch disk
611612      FF_35       = 0x20203533, //!< "35  " 3.5 inch disk
612613      FF_525      = 0x20353235, //!< "525 " 5.25 inch disk
614      FF_8        = 0x20202038, //!< "8   " 8 inch disk
613615   };
614616
615617   //! Variants
616618   enum {
617619      SSSD  = 0x44535353, //!< "SSSD", Single-sided single-density
618      SSDD  = 0x44445353, //!< "DSSD", Double-sided single-density
619      DSDD  = 0x44445344, //!< "DSDD", Double-sided double-density (720K)
620      SSDD  = 0x44445353, //!< "SSDD", Single-sided double-density
621      SSQD  = 0x44515353, //!< "SSQD", Single-sided quad-density
622      DSDD  = 0x44445344, //!< "DSDD", Double-sided double-density (720K in 3.5, 360K in 5.25)
623      DSQD  = 0x44515344, //!< "DSQD", Double-sided quad-density (720K in 5.25, means DD+80 tracks)
620624      DSHD  = 0x44485344, //!< "DSHD", Double-sided high-density (1440K)
621625      DSED  = 0x44455344, //!< "DSED", Double-sided extra-density (2880K)
622626   };
trunk/src/lib/formats/xdf_dsk.c
r17454r17455
1/***************************************************************************
2
3    Copyright Olivier Galibert
4    All rights reserved.
5
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions are
8    met:
9
10        * Redistributions of source code must retain the above copyright
11          notice, this list of conditions and the following disclaimer.
12        * Redistributions in binary form must reproduce the above copyright
13          notice, this list of conditions and the following disclaimer in
14          the documentation and/or other materials provided with the
15          distribution.
16        * Neither the name 'MAME' nor the names of its contributors may be
17          used to endorse or promote products derived from this software
18          without specific prior written permission.
19
20    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
21    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
24    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
28    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
29    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30    POSSIBILITY OF SUCH DAMAGE.
31
32****************************************************************************/
33
34/*********************************************************************
35
36    formats/xdf_dsk.c
37
38    x68k bare-bones formats
39
40*********************************************************************/
41
42#include "emu.h"
43#include "formats/xdf_dsk.h"
44
45xdf_format::xdf_format() : upd765_format(formats)
46{
47}
48
49const char *xdf_format::name() const
50{
51   return "xdf";
52}
53
54const char *xdf_format::description() const
55{
56   return "XDF disk image";
57}
58
59const char *xdf_format::extensions() const
60{
61   return "xdf,hdm,2hd";
62}
63
64// Unverified gap sizes
65const xdf_format::format xdf_format::formats[] = {
66   {
67      floppy_image::FF_525, floppy_image::DSHD,
68      1200, // 1us, 360rpm
69      8, 77, 2,
70      1024, {},
71      1, {},
72      80, 50, 22, 84
73   },
74   {}
75};
76
77const floppy_format_type FLOPPY_XDF_FORMAT = &floppy_image_format_creator<xdf_format>;
trunk/src/lib/formats/xdf_dsk.h
r17454r17455
1/*********************************************************************
2
3   formats/xdf_dsk.h
4
5   x68k bare-bones formats
6
7*********************************************************************/
8
9#ifndef XDF_DSK_H_
10#define XDF_DSK_H_
11
12#include "upd765_dsk.h"
13
14class xdf_format : public upd765_format {
15public:
16   xdf_format();
17
18   virtual const char *name() const;
19   virtual const char *description() const;
20   virtual const char *extensions() const;
21
22private:
23   static const format formats[];
24};
25
26extern const floppy_format_type FLOPPY_XDF_FORMAT;
27
28#endif
trunk/src/lib/formats/upd765_dsk.c
r17454r17455
1/***************************************************************************
2
3    Copyright Olivier Galibert
4    All rights reserved.
5
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions are
8    met:
9
10        * Redistributions of source code must retain the above copyright
11          notice, this list of conditions and the following disclaimer.
12        * Redistributions in binary form must reproduce the above copyright
13          notice, this list of conditions and the following disclaimer in
14          the documentation and/or other materials provided with the
15          distribution.
16        * Neither the name 'MAME' nor the names of its contributors may be
17          used to endorse or promote products derived from this software
18          without specific prior written permission.
19
20    THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
21    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23    DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
24    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
28    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
29    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30    POSSIBILITY OF SUCH DAMAGE.
31
32****************************************************************************/
33
34/*********************************************************************
35
36    formats/upd765_dsk.h
37
38    helper for simple upd765-formatted disk images
39
40*********************************************************************/
41
42#include "emu.h"
43#include "formats/upd765_dsk.h"
44
45upd765_format::upd765_format(const format *_formats)
46{
47   formats = _formats;
48}
49
50int upd765_format::find_size(io_generic *io, UINT32 form_factor)
51{
52   int size = io_generic_size(io);
53   for(int i=0; formats[i].form_factor; i++) {
54      if(form_factor != floppy_image::FF_UNKNOWN && form_factor != formats[i].form_factor)
55         continue;
56
57      int format_size;
58      if(formats[i].sector_base_size)
59         format_size = formats[i].sector_base_size * formats[i].sector_count;
60      else {
61         format_size = 0;
62         for(int j=0; j != formats[i].sector_count; j++)
63            format_size += formats[i].per_sector_size[j];
64      }
65
66      format_size *= formats[i].track_count * formats[i].head_count;
67
68      if(size == format_size)
69         return i;
70   }
71   return -1;
72}
73
74int upd765_format::identify(io_generic *io, UINT32 form_factor)
75{
76   int type = find_size(io, form_factor);
77
78   if(type != -1)
79      return 50;
80   return 0;
81}
82
83bool upd765_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
84{
85   int type = find_size(io, form_factor);
86   if(type == -1)
87      return false;
88
89   const format &f = formats[type];
90
91   floppy_image_format_t::desc_e desc[] = {
92      /* 00 */ { MFM, 0x4e, f.gap_4a },
93      /* 01 */ { MFM, 0x00, 12 },
94      /* 02 */ { RAW, 0x5224, 3 },
95      /* 03 */ { MFM, 0xfc, 1 },
96      /* 04 */ { MFM, 0x4e, f.gap_1 },
97      /* 05 */ { SECTOR_LOOP_START, 0, f.sector_count-1 },
98      /* 06 */ {   MFM, 0x00, 12 },
99      /* 07 */ {   CRC_CCITT_START, 1 },
100      /* 08 */ {     RAW, 0x4489, 3 },
101      /* 09 */ {     MFM, 0xfe, 1 },
102      /* 10 */ {     TRACK_ID },
103      /* 11 */ {     HEAD_ID },
104      /* 12 */ {     SECTOR_ID },
105      /* 13 */ {     SIZE_ID },
106      /* 14 */ {   CRC_END, 1 },
107      /* 15 */ {   CRC, 1 },
108      /* 16 */ {   MFM, 0x4e, f.gap_2 },
109      /* 17 */ {   MFM, 0x00, 12 },
110      /* 18 */ {   CRC_CCITT_START, 2 },
111      /* 19 */ {     RAW, 0x4489, 3 },
112      /* 20 */ {     MFM, 0xfb, 1 },
113      /* 21 */ {     SECTOR_DATA, -1 },
114      /* 22 */ {   CRC_END, 2 },
115      /* 23 */ {   CRC, 2 },
116      /* 24 */ {   MFM, 0x4e, f.gap_3 },
117      /* 25 */ { SECTOR_LOOP_END },
118      /* 26 */ { MFM, 0x4e, 0 },
119      /* 27 */ { RAWBITS, 0x9254, 0 },
120      /* 28 */ { END }
121   };
122
123   int current_size = (f.gap_4a+12+3+1+f.gap_1)*16;
124   if(f.sector_base_size)
125      current_size += f.sector_base_size * f.sector_count * 16;
126   else {
127      for(int j=0; j != f.sector_count; j++)
128         current_size += f.per_sector_size[j] * 16;
129   }
130   current_size += (12+3+1+4+2+f.gap_2+12+3+1+2+f.gap_3) * f.sector_count * 16;
131
132   int total_size = 200000000/f.cell_size;
133   int remaining_size = total_size - current_size;
134   if(remaining_size < 0)
135      throw emu_fatalerror("upd765_format: Incorrect track layout, max_size=%d, current_size=%d", total_size, current_size);
136
137   // Fixup the end gap
138   desc[26].p2 = remaining_size / 16;
139   desc[27].p2 = remaining_size & 15;
140   desc[27].p1 >>= 16-(remaining_size & 15);
141
142   int track_size;
143   if(f.sector_base_size)
144      track_size = f.sector_base_size * f.sector_count;
145   else {
146      track_size = 0;
147      for(int i=0; i != f.sector_count; i++)
148         track_size += f.per_sector_size[i];
149   }
150
151   UINT8 sectdata[40*512];
152   desc_s sectors[40];
153   if(f.sector_base_id == -1) {
154      for(int i=0; i<f.sector_count; i++) {
155         int cur_offset = 0;
156         for(int j=0; j<f.sector_count; j++)
157            if(f.per_sector_id[j] < f.per_sector_id[i])
158               cur_offset += f.sector_base_size ? f.sector_base_size : f.per_sector_size[j];
159         sectors[i].data = sectdata + cur_offset;
160         sectors[i].size = f.sector_base_size ? f.sector_base_size : f.per_sector_size[i];
161         sectors[i].sector_id = f.per_sector_id[i];
162      }
163   } else {
164      int cur_offset = 0;
165      for(int i=0; i<f.sector_count; i++) {
166         sectors[i].data = sectdata + cur_offset;
167         sectors[i].size = f.sector_base_size ? f.sector_base_size : f.per_sector_size[i];
168         cur_offset += sectors[i].size;
169         sectors[i].sector_id = i + f.sector_base_id;
170      }
171   }
172
173   for(int track=0; track < f.track_count; track++)
174      for(int head=0; head < f.head_count; head++) {
175         io_generic_read(io, sectdata, (track*f.head_count + head)*track_size, track_size);
176         generate_track(desc, track, head, sectors, f.sector_count, total_size, image);
177      }
178
179   image->set_variant(f.variant);
180
181   return true;
182}
183
184
185bool upd765_format::save(io_generic *io, floppy_image *image)
186{
187   return true;
188}
189
190bool upd765_format::supports_save() const
191{
192   return true;
193}
194
trunk/src/lib/formats/upd765_dsk.h
r17454r17455
1/*********************************************************************
2
3    formats/upd765_dsk.h
4
5    helper for simple upd765-formatted disk images
6
7*********************************************************************/
8
9#ifndef UPD765_DSK_H
10#define UPD765_DSK_H
11
12#include "flopimg.h"
13
14class upd765_format : public floppy_image_format_t
15{
16public:
17   struct format {
18      UINT32 form_factor;      // See floppy_image for possible values
19      UINT32 variant;          // See floppy_image for possible values
20
21      int cell_size;           // See floppy_image_format_t for details
22      int sector_count;
23      int track_count;
24      int head_count;
25      int sector_base_size;
26      int per_sector_size[40]; // if sector_base_size is 0
27      int sector_base_id;      // 0 or 1 usually, -1 if there's interleave
28      int per_sector_id[40];   // if sector_base_id is -1.  If both per are used, then sector per_sector_id[i] has size per_sector_size[i]
29      int gap_4a;              // Usually 80 - number of 4e between index and IAM sync
30      int gap_1;               // Usually 50 - number of 4e between IAM and first IDAM sync
31      int gap_2;               // 22 for <=1.44Mb, 41 for 2.88Mb - number of 4e between sector header and data sync
32      int gap_3;               // Usually 84 - number of 4e between sector crc and next IDAM
33   };
34
35   // End the array with {}
36   upd765_format(const format *formats);
37
38   virtual int identify(io_generic *io, UINT32 form_factor);
39   virtual bool load(io_generic *io, UINT32 form_factor, floppy_image *image);
40   virtual bool save(io_generic *io, floppy_image *image);
41   virtual bool supports_save() const;
42
43private:
44   const format *formats;
45   int find_size(io_generic *io, UINT32 form_factor);
46};
47
48#endif /* UPD765_DSK_H */
trunk/src/lib/lib.mak
r17454r17455
161161   $(LIBOBJ)/formats/tvc_cas.o      \
162162   $(LIBOBJ)/formats/tzx_cas.o      \
163163   $(LIBOBJ)/formats/uef_cas.o      \
164   $(LIBOBJ)/formats/upd765_dsk.o      \
164165   $(LIBOBJ)/formats/vg5k_cas.o   \
165166   $(LIBOBJ)/formats/vt_cas.o      \
166167   $(LIBOBJ)/formats/vt_dsk.o      \
r17454r17455
168169   $(LIBOBJ)/formats/wavfile.o      \
169170   $(LIBOBJ)/formats/x07_cas.o      \
170171   $(LIBOBJ)/formats/x1_tap.o      \
172   $(LIBOBJ)/formats/xdf_dsk.o      \
171173   $(LIBOBJ)/formats/z80ne_dsk.o   \
172174   $(LIBOBJ)/formats/zx81_p.o      \
173175   $(LIBOBJ)/formats/hxcmfm_dsk.o   \

Previous 199869 Revisions Next

© 1997-2024 The MAME Team