Previous 15994 Revisions Next

r5672 Thursday 10th September, 2009 at 13:16:00 UTC by Miodrag Milanović
Floppy cleanup for DSK format
[src/mess]mess.mak
[src/mess/devices]dsk.c dsk.h
[src/mess/drivers]amstrad.c einstein.c elwro800.c pcw.c specpls3.c
[src/mess/formats]dsk_dsk.c* dsk_dsk.h*

src/mess/mess.mak
r5671r5672
393393   $(MESS_DEVICES)/cartslot.o   \
394394   $(MESS_DEVICES)/cassette.o   \
395395   $(MESS_DEVICES)/chd_cd.o   \
396   $(MESS_DEVICES)/dsk.o      \
396   $(MESS_FORMATS)/dsk_dsk.o   \
397397   $(MESS_DEVICES)/flopdrv.o   \
398398   $(MESS_DEVICES)/harddriv.o   \
399399   $(MESS_DEVICES)/mflopimg.o   \
src/mess/devices/dsk.c
r5671r5672
1/***************************************************************************
2
3  dsk.c
4
5 CPCEMU standard and extended disk image support.
6 Used on Amstrad CPC and Spectrum +3 drivers.
7
8 KT - 27/2/00 - Moved Disk Image handling code into this file
9                     - Fixed a few bugs
10                     - Cleaned code up a bit
11***************************************************************************/
12
13#include "driver.h"
14#include "dsk.h"
15#include "flopdrv.h"
16
17
18/* disk image and extended disk image support code */
19/* supports up to 84 tracks and 2 sides */
20
21#define dsk_MAX_TRACKS 84
22#define dsk_MAX_SIDES   2
23#define dsk_NUM_DRIVES 4
24#define dsk_SECTORS_PER_TRACK   20
25
26typedef struct
27{
28   unsigned char *data; /* the whole image data */
29   unsigned long track_offsets[dsk_MAX_TRACKS*dsk_MAX_SIDES]; /* offset within data for each track */
30   unsigned long sector_offsets[dsk_SECTORS_PER_TRACK]; /* offset within current track for sector data */
31   int current_track;      /* current track */
32   int disk_image_type;  /* image type: standard or extended */
33} dsk_drive;
34
35static void dsk_disk_image_init(dsk_drive *);
36
37static void dsk_seek_callback(const device_config *img, int physical_track);
38static void dsk_get_id_callback(const device_config *img, struct chrn_id *id, int id_index, int side);
39static int dsk_get_sectors_per_track(const device_config *img, int side);
40
41static void dsk_write_sector_data_from_buffer(const device_config *img, int sector_index, int side, const char *ptr, int length, int ddam);
42static void dsk_read_sector_data_into_buffer(const device_config *img, int sector_index, int side, char *ptr, int length);
43
44static const floppy_interface dsk_floppy_interface =
45{
46   dsk_seek_callback,
47   dsk_get_sectors_per_track,
48   dsk_get_id_callback,
49   dsk_read_sector_data_into_buffer,
50   dsk_write_sector_data_from_buffer,
51   NULL,
52   NULL
53};
54
55static dsk_drive drives[dsk_NUM_DRIVES]; /* the drives */
56
57static dsk_drive *get_drive(const device_config *img)
58{
59   return &drives[image_index_in_device(img)];
60}
61
62static int dsk_floppy_verify(UINT8 *diskimage_data)
63{
64   if ( (memcmp(diskimage_data, "MV - CPC", 8)==0) ||    /* standard disk image? */
65       (memcmp(diskimage_data, "EXTENDED", 8)==0))   /* extended disk image? */
66   {
67      return IMAGE_VERIFY_PASS;
68   }
69   return IMAGE_VERIFY_FAIL;
70}
71
72
73
74static DEVICE_START( dsk_floppy )
75{
76   floppy_drive_init(device, NULL);
77}
78
79
80
81/* load floppy */
82static DEVICE_IMAGE_LOAD( dsk_floppy )
83{
84   int id = image_index_in_device(image);
85   dsk_drive *thedrive = &drives[id];
86
87   /* load disk image */
88   thedrive->data = (unsigned char *) image_ptr(image);
89   if (thedrive->data)
90   {
91      dsk_disk_image_init(thedrive); /* initialise dsk */
92      floppy_drive_set_disk_image_interface(image, &dsk_floppy_interface);
93      if(dsk_floppy_verify(thedrive->data) == IMAGE_VERIFY_PASS)
94           return INIT_PASS;
95      else
96           return INIT_PASS;
97   }
98   return INIT_PASS;
99}
100
101static int dsk_save(const device_config *img, unsigned char **ptr)
102{
103   int datasize;
104   unsigned char *data;
105
106   /* get file size */
107   datasize = image_length(img);
108
109   if (datasize!=0)
110   {
111      data = *ptr;
112      if (data!=NULL)
113      {
114         image_fwrite(img, data, datasize);
115
116         /* ok! */
117         return 1;
118      }
119   }
120
121   return 0;
122}
123
124
125static DEVICE_IMAGE_UNLOAD( dsk_floppy )
126{
127   int id = image_index_in_device(image);
128   dsk_drive *thedrive = &drives[id];
129
130   if (thedrive->data)
131      dsk_save(image, &thedrive->data);
132   thedrive->data = NULL;
133}
134
135
136
137static void dsk_dsk_init_track_offsets(dsk_drive *thedrive)
138{
139   int track_offset;
140   int i;
141   int track_size;
142   int tracks, sides;
143   int skip, length,offs;
144   unsigned char *file_loaded = thedrive->data;
145
146
147   /* get size of each track from main header. Size of each
148   track includes a 0x0100 byte header, and the actual sector data for
149   all sectors on the track */
150   track_size = file_loaded[0x032] | (file_loaded[0x033]<<8);
151
152   /* main header is 0x0100 in size */
153   track_offset = 0x0100;
154
155   sides = file_loaded[0x031];
156   tracks = file_loaded[0x030];
157
158
159   /* single sided? */
160   if (sides==1)
161   {
162      skip = 2;
163      length = tracks;
164   }
165   else
166   {
167      skip = 1;
168      length = tracks*sides;
169   }
170
171   offs = 0;
172   for (i=0; i<length; i++)
173   {
174      thedrive->track_offsets[offs] = track_offset;
175      track_offset+=track_size;
176      offs+=skip;
177   }
178
179}
180
181static void dsk_dsk_init_sector_offsets(dsk_drive *thedrive,int track,int side)
182{
183   int track_offset;
184
185   side = side & 0x01;
186
187   /* get offset to track header in image */
188   track_offset = thedrive->track_offsets[(track<<1) + side];
189
190   if (track_offset!=0)
191   {
192      int spt;
193      int sector_offset;
194      int sector_size;
195      int i;
196
197      unsigned char *track_header;
198
199      track_header= &thedrive->data[track_offset];
200
201      /* sectors per track as specified in nec765 format command */
202      /* sectors on this track */
203      spt = track_header[0x015];
204
205      sector_size = (1<<(track_header[0x014]+7));
206
207      /* track header is 0x0100 bytes in size */
208      sector_offset = 0x0100;
209
210      for (i=0; i<spt; i++)
211      {
212         thedrive->sector_offsets[i] = sector_offset;
213         sector_offset+=sector_size;
214      }
215   }
216}
217
218static void    dsk_extended_dsk_init_track_offsets(dsk_drive *thedrive)
219{
220   int track_offset;
221   int i;
222   int track_size;
223   int tracks, sides;
224   int offs, skip, length;
225   unsigned char *file_loaded = thedrive->data;
226
227   sides = file_loaded[0x031];
228   tracks = file_loaded[0x030];
229
230   if (sides==1)
231   {
232      skip = 2;
233      length = tracks;
234   }
235   else
236   {
237      skip = 1;
238      length = tracks*sides;
239   }
240
241   /* main header is 0x0100 in size */
242   track_offset = 0x0100;
243   offs = 0;
244   for (i=0; i<length; i++)
245   {
246      int track_size_high_byte;
247
248      /* track size is specified as a byte, and is multiplied
249      by 256 to get size in bytes. If 0, track doesn't exist and
250      is unformatted, otherwise it exists. Track size includes 0x0100
251      header */
252      track_size_high_byte = file_loaded[0x034 + i];
253
254      if (track_size_high_byte != 0)
255      {
256         /* formatted track */
257         track_size = track_size_high_byte<<8;
258
259         thedrive->track_offsets[offs] = track_offset;
260         track_offset+=track_size;
261      }
262
263      offs+=skip;
264   }
265}
266
267
268static void dsk_extended_dsk_init_sector_offsets(dsk_drive *thedrive,int track,int side)
269{
270   int track_offset;
271
272   side = side & 0x01;
273
274   /* get offset to track header in image */
275   track_offset = thedrive->track_offsets[(track<<1) + side];
276
277   if (track_offset!=0)
278   {
279      int spt;
280      int sector_offset;
281      int sector_size;
282      int i;
283      unsigned char *id_info;
284      unsigned char *track_header;
285
286      track_header= &thedrive->data[track_offset];
287
288      /* sectors per track as specified in nec765 format command */
289      /* sectors on this track */
290      spt = track_header[0x015];
291
292      id_info = track_header + 0x018;
293
294      /* track header is 0x0100 bytes in size */
295      sector_offset = 0x0100;
296
297      for (i=0; i<spt; i++)
298      {
299                        sector_size = id_info[(i<<3) + 6] + (id_info[(i<<3) + 7]<<8);
300
301         thedrive->sector_offsets[i] = sector_offset;
302         sector_offset+=sector_size;
303      }
304   }
305}
306
307
308
309static void dsk_disk_image_init(dsk_drive *thedrive)
310{
311   /*-----------------27/02/00 11:26-------------------
312    clear offsets
313   --------------------------------------------------*/
314   memset(&thedrive->track_offsets[0], 0, dsk_MAX_TRACKS*dsk_MAX_SIDES*sizeof(unsigned long));
315   memset(&thedrive->sector_offsets[0], 0, 20*sizeof(unsigned long));
316
317   if (memcmp(thedrive->data,"MV - CPC",8)==0)
318   {
319      thedrive->disk_image_type = 0;
320
321      /* standard disk image */
322      dsk_dsk_init_track_offsets(thedrive);
323
324   }
325   else
326   if (memcmp(thedrive->data,"EXTENDED",8)==0)
327   {
328      thedrive->disk_image_type = 1;
329
330      /* extended disk image */
331      dsk_extended_dsk_init_track_offsets(thedrive);
332   }
333}
334
335
336static void dsk_seek_callback(const device_config *img, int physical_track)
337{
338   get_drive(img)->current_track = physical_track;
339}
340
341static int get_track_offset(const device_config *img, int side)
342{
343   dsk_drive *thedrive = get_drive(img);
344   side = side & 0x01;
345   return thedrive->track_offsets[(thedrive->current_track<<1) + side];
346}
347
348static unsigned char *get_floppy_data(const device_config *img)
349{
350   return get_drive(img)->data;
351}
352
353static void dsk_get_id_callback(const device_config *img, chrn_id *id, int id_index, int side)
354{
355   int id_offset;
356   int track_offset;
357   unsigned char *track_header;
358   unsigned char *data;
359
360   side = side & 0x01;
361
362   /* get offset to track header in image */
363   track_offset = get_track_offset(img, side);
364
365   /* track exists? */
366   if (track_offset==0)
367      return;
368
369   /* yes */
370   data = get_floppy_data(img);
371
372   if (data==0)
373      return;
374
375   track_header = data + track_offset;
376
377   id_offset = 0x018 + (id_index<<3);
378
379   id->C = track_header[id_offset + 0];
380   id->H = track_header[id_offset + 1];
381   id->R = track_header[id_offset + 2];
382   id->N = track_header[id_offset + 3];
383   id->flags = 0;
384   id->data_id = id_index;
385
386   if (track_header[id_offset + 5] & 0x040)
387   {
388      id->flags |= ID_FLAG_DELETED_DATA;
389   }
390
391
392
393
394//   id->ST0 = track_header[id_offset + 4];
395//   id->ST1 = track_header[id_offset + 5];
396
397}
398
399
400static void dsk_set_ddam(const device_config *img, int id_index, int side, int ddam)
401{
402   int id_offset;
403   int track_offset;
404   unsigned char *track_header;
405   unsigned char *data;
406
407   side = side & 0x01;
408
409   /* get offset to track header in image */
410   track_offset = get_track_offset(img, side);
411
412   /* track exists? */
413   if (track_offset==0)
414      return;
415
416   /* yes */
417   data = get_floppy_data(img);
418
419   if (data==0)
420      return;
421
422   track_header = data + track_offset;
423
424   id_offset = 0x018 + (id_index<<3);
425
426   track_header[id_offset + 5] &= ~0x040;
427
428   if (ddam)
429   {
430      track_header[id_offset + 5] |= 0x040;
431   }
432}
433
434
435static char * dsk_get_sector_ptr_callback(const device_config *img, int sector_index, int side)
436{
437   int track_offset;
438   int sector_offset;
439   int track;
440   dsk_drive *thedrive;
441   unsigned char *data;
442
443   side = side & 0x01;
444
445   thedrive = get_drive(img);
446
447   track = thedrive->current_track;
448
449   /* offset to track header in image */
450   track_offset = get_track_offset(img, side);
451
452   /* track exists? */
453   if (track_offset==0)
454      return NULL;
455
456
457   /* setup sector offsets */
458   switch (thedrive->disk_image_type)
459   {
460   case 0:
461      dsk_dsk_init_sector_offsets(thedrive,track, side);
462      break;
463
464
465   case 1:
466      dsk_extended_dsk_init_sector_offsets(thedrive, track, side);
467      break;
468
469   default:
470      break;
471   }
472
473   sector_offset = thedrive->sector_offsets[sector_index];
474
475   data = get_floppy_data(img);
476
477   if (data==0)
478      return NULL;
479
480   return (char *)(data + track_offset + sector_offset);
481}
482
483static void dsk_write_sector_data_from_buffer(const device_config *img, int side, int index1, const char *ptr, int length, int ddam)
484{
485   char * pSectorData;
486
487   pSectorData = dsk_get_sector_ptr_callback(img, index1, side);
488
489   if (pSectorData!=NULL)
490   {
491      memcpy(pSectorData, ptr, length);
492   }
493
494   /* set ddam */
495   dsk_set_ddam(img, index1, side,ddam);
496}
497
498static void dsk_read_sector_data_into_buffer(const device_config *img, int side, int index1, char *ptr, int length)
499{
500   char *pSectorData;
501
502   pSectorData = dsk_get_sector_ptr_callback(img, index1, side);
503
504   if (pSectorData!=NULL)
505      memcpy(ptr, pSectorData, length);
506}
507
508static int dsk_get_sectors_per_track(const device_config *img, int side)
509{
510   int track_offset;
511   unsigned char *track_header;
512   unsigned char *data;
513
514   side = side & 0x01;
515
516   /* get offset to track header in image */
517   track_offset = get_track_offset(img, side);
518
519   /* track exists? */
520   if (track_offset==0)
521      return 0;
522
523   data = get_floppy_data(img);
524
525   if (data==0)
526      return 0;
527
528   /* yes, get sectors per track */
529   track_header = data  + track_offset;
530
531   return track_header[0x015];
532}
533
534
535
536void legacydsk_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
537{
538   switch(state)
539   {
540      /* --- the following bits of info are returned as 64-bit signed integers --- */
541      case MESS_DEVINFO_INT_TYPE:                     info->i = IO_FLOPPY; break;
542      case MESS_DEVINFO_INT_READABLE:                  info->i = 1; break;
543      case MESS_DEVINFO_INT_WRITEABLE:                  info->i = 1; break;
544      case MESS_DEVINFO_INT_CREATABLE:                  info->i = 0; break;
545
546      /* --- the following bits of info are returned as pointers to data or functions --- */
547      case MESS_DEVINFO_PTR_START:                     info->start = DEVICE_START_NAME(dsk_floppy); break;
548      case MESS_DEVINFO_PTR_LOAD:                     info->load = DEVICE_IMAGE_LOAD_NAME(dsk_floppy); break;
549      case MESS_DEVINFO_PTR_UNLOAD:                  info->unload = DEVICE_IMAGE_UNLOAD_NAME(dsk_floppy); break;
550
551      /* --- the following bits of info are returned as NULL-terminated strings --- */
552      case MESS_DEVINFO_STR_DEV_FILE:                  strcpy(info->s = device_temp_str(), __FILE__); break;
553      case MESS_DEVINFO_STR_FILE_EXTENSIONS:            strcpy(info->s = device_temp_str(), "dsk"); break;
554   }
555}
556
src/mess/devices/dsk.h
r5671r5672
1#ifndef DSK_H
2#define DSK_H
3
4#include "device.h"
5#include "image.h"
6
7
8void legacydsk_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info);
9
10
11#endif /* DSK_H */
src/mess/formats/dsk_dsk.c
r0r5672
1/*********************************************************************
2
3   formats/dsk_dsk.c
4
5   DSK disk images
6
7*********************************************************************/
8
9#include <string.h>
10#include "driver.h"
11#include "formats/dsk_dsk.h"
12#include "devices/flopdrv.h"
13
14#define MV_CPC     "MV - CPC"
15#define EXTENDED   "EXTENDED"
16
17#define dskDSK_TAG   "dskdsktag"
18
19struct dskdsk_tag
20{
21   int disk_image_type;  /* image type: standard or extended */
22   int heads;
23   int tracks;
24   int tracksize;
25   int sector_size;
26};
27
28
29static struct dskdsk_tag *get_tag(floppy_image *floppy)
30{
31   struct dskdsk_tag *tag;
32   tag = floppy_tag(floppy, dskDSK_TAG);
33   return tag;
34}
35
36
37
38static FLOPPY_IDENTIFY(dsk_dsk_identify)
39{
40   UINT8 header[8];
41   
42   floppy_image_read(floppy, header, 0, 8);
43   if ( memcmp( header, MV_CPC, 8 ) ==0) {     
44      *vote = 100;
45   } else
46   if ( memcmp( header, EXTENDED, 8 ) ==0) {   
47      *vote = 100;
48   } else {
49      *vote = 0;
50   }
51   return FLOPPY_ERROR_SUCCESS;
52}
53
54static int dsk_get_heads_per_disk(floppy_image *floppy)
55{
56   return get_tag(floppy)->heads;
57}
58
59static int dsk_get_tracks_per_disk(floppy_image *floppy)
60{
61   return get_tag(floppy)->tracks;
62}
63
64static UINT64 dsk_get_track_offset(floppy_image *floppy, int head, int track)
65{
66   return 0x100 + get_tag(floppy)->tracksize * ((track * get_tag(floppy)->heads) + head);
67}
68
69static floperr_t get_offset(floppy_image *floppy, int head, int track, int sector, int sector_is_index, UINT64 *offset)
70{
71   UINT64 offs;
72   UINT64 track_offset;
73   UINT8 track_info[0x100];
74   UINT8 sectors_per_track;
75   int i;
76   /* translate the sector to a raw sector */
77   
78   if (!sector_is_index)
79   {
80      sector -= 1;
81   }
82   
83   /* check to see if we are out of range */
84   if ((head < 0) || (head >= get_tag(floppy)->heads) || (track < 0) || (track >= get_tag(floppy)->tracks)
85         || (sector < 0) )
86      return FLOPPY_ERROR_SEEKERROR;
87   
88   track_offset = dsk_get_track_offset(floppy, head, track);   
89   
90   floppy_image_read(floppy, track_info, track_offset, 0x100);
91     
92   sectors_per_track = track_info[0x015];
93   if (sector >= sectors_per_track) {
94      return FLOPPY_ERROR_SEEKERROR;
95   }
96
97   if (get_tag(floppy)->disk_image_type==0) {
98      get_tag(floppy)->sector_size = (1<<(track_info[0x014]+7));     
99      offs = track_offset + 0x100 +sector * get_tag(floppy)->sector_size;
100   } else {   
101      get_tag(floppy)->sector_size = track_info[0x18 + (sector<<3) + 6] + (track_info[0x18+(sector<<3) + 7]<<8);           
102      offs = track_offset + 0x100;     
103      for (i=0;i<sector;i++) {
104         offs += track_info[0x18 + (i<<3) + 6] + (track_info[0x18+(i<<3) + 7]<<8);         
105      }         
106   }
107   
108   if (offset)
109      *offset = offs;
110   return FLOPPY_ERROR_SUCCESS;
111}
112
113
114
115static floperr_t internal_dsk_read_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, void *buffer, size_t buflen)
116{
117   UINT64 offset;
118   floperr_t err;   
119   err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
120   if (err)
121      return err;
122   floppy_image_read(floppy, buffer, offset, buflen);
123   return FLOPPY_ERROR_SUCCESS;
124}
125
126
127
128static floperr_t internal_dsk_write_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, const void *buffer, size_t buflen, int ddam)
129{
130   UINT64 offset;
131   floperr_t err;
132
133   err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
134   if (err)
135      return err;
136
137   floppy_image_write(floppy, buffer, offset, buflen);
138   return FLOPPY_ERROR_SUCCESS;
139}
140
141
142
143static floperr_t dsk_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
144{
145   return internal_dsk_read_sector(floppy, head, track, sector, FALSE, buffer, buflen);
146}
147
148static floperr_t dsk_write_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam)
149{
150   return internal_dsk_write_sector(floppy, head, track, sector, FALSE, buffer, buflen, ddam);
151}
152
153static floperr_t dsk_read_indexed_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
154{
155   return internal_dsk_read_sector(floppy, head, track, sector, TRUE, buffer, buflen);
156}
157
158static floperr_t dsk_write_indexed_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam)
159{
160   return internal_dsk_write_sector(floppy, head, track, sector, TRUE, buffer, buflen, ddam);
161}
162
163static floperr_t dsk_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length)
164{
165   floperr_t err;   
166   err = get_offset(floppy, head, track, sector, FALSE, NULL);
167   if (err)
168      return err;
169
170   if (sector_length) {
171      *sector_length = get_tag(floppy)->sector_size;
172   }
173   return FLOPPY_ERROR_SUCCESS;
174}
175
176static floperr_t dsk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length, unsigned long *flags)
177{
178   floperr_t retVal;
179   UINT64 offset;
180   UINT8 sector_info[0x100];
181   int pos;
182   
183   retVal = get_offset(floppy, head, track, sector_index+1, TRUE, NULL);
184   offset = dsk_get_track_offset(floppy,head,track);
185   pos = 0x18 + (sector_index << 3);
186   floppy_image_read(floppy, sector_info, offset, 0x100);
187   if (cylinder)
188      *cylinder = sector_info[pos + 0];
189   if (side)
190      *side = sector_info[pos + 1];
191   if (sector)
192      *sector = sector_info[pos + 2];         
193   if (sector_length) {
194      *sector_length = 1 << (sector_info[pos + 3] + 7);
195   }         
196   if (flags)
197      *flags = (sector_info[pos + 5] & 0x40) ? ID_FLAG_DELETED_DATA : 0;
198   return retVal;
199}
200
201
202static FLOPPY_CONSTRUCT(dsk_dsk_construct)
203{
204   struct FloppyCallbacks *callbacks;
205   struct dskdsk_tag *tag;
206   UINT8 header[0x100];
207   
208   floppy_image_read(floppy, header, 0, 0x100);
209     
210   tag = (struct dskdsk_tag *) floppy_create_tag(floppy, dskDSK_TAG, sizeof(struct dskdsk_tag));
211   if (!tag)
212      return FLOPPY_ERROR_OUTOFMEMORY;
213
214   tag->heads   = header[0x31];
215   tag->tracks  = header[0x30];   
216   
217   if ( memcmp( header, MV_CPC, 8 ) ==0) {     
218      tag->disk_image_type = 0;
219      tag->tracksize = pick_integer_le(header, 0x32, 2);
220   } else  {
221      tag->disk_image_type = 1;
222      tag->tracksize = header[0x34] << 8;
223   }
224
225   callbacks = floppy_callbacks(floppy);
226   callbacks->read_sector = dsk_read_sector;
227   callbacks->write_sector = dsk_write_sector;
228   callbacks->read_indexed_sector = dsk_read_indexed_sector;
229   callbacks->write_indexed_sector = dsk_write_indexed_sector;
230   callbacks->get_sector_length = dsk_get_sector_length;
231   callbacks->get_heads_per_disk = dsk_get_heads_per_disk;
232   callbacks->get_tracks_per_disk = dsk_get_tracks_per_disk;
233   callbacks->get_indexed_sector_info = dsk_get_indexed_sector_info;   
234   return FLOPPY_ERROR_SUCCESS;   
235}
236/* ----------------------------------------------------------------------- */
237
238FLOPPY_OPTIONS_START(dsk )
239   FLOPPY_OPTION( dsk, "dsk", "DSK floppy disk image",   dsk_dsk_identify, dsk_dsk_construct, NULL)
240FLOPPY_OPTIONS_END
src/mess/formats/dsk_dsk.h
r0r5672
1/*********************************************************************
2
3   formats/dsk_dsk.h
4
5   DSK disk images
6
7*********************************************************************/
8
9#ifndef DSK_DSK_H
10#define DSK_DSK_H
11
12#include "formats/flopimg.h"
13
14/**************************************************************************/
15
16FLOPPY_OPTIONS_EXTERN(dsk);
17
18#endif /* DSK_DSK_H */
src/mess/drivers/pcw.c
r5671r5672
9696#include "cpu/z80/z80.h"
9797// nec765 interface
9898#include "machine/nec765.h"
99#include "devices/dsk.h"
99#include "formats/dsk_dsk.h"
100#include "devices/mflopimg.h"
100101// pcw video hardware
101102#include "includes/pcw.h"
102103// pcw/pcw16 beeper
r5671r5672
10521053      /* --- the following bits of info are returned as 64-bit signed integers --- */
10531054      case MESS_DEVINFO_INT_COUNT:                     info->i = 2; break;
10541055
1055      default:                              legacydsk_device_getinfo(devclass, state, info); break;
1056      /* --- the following bits of info are returned as pointers to data or functions --- */
1057      case MESS_DEVINFO_PTR_FLOPPY_OPTIONS:            info->p = (void *) floppyoptions_dsk; break;
1058
1059      default:                              floppy_device_getinfo(devclass, state, info); break;
10561060   }
10571061}
10581062
1063
10591064static SYSTEM_CONFIG_START(generic_pcw)
10601065   CONFIG_DEVICE(generic_pcw_floppy_getinfo)
10611066SYSTEM_CONFIG_END
src/mess/drivers/einstein.c
r5671r5672
5757#include "machine/wd17xx.h"
5858#include "machine/ctronics.h"
5959#include "machine/msm8251.h"
60#include "devices/dsk.h"
60#include "formats/dsk_dsk.h"
61#include "devices/mflopimg.h"
6162#include "sound/ay8910.h"
6263#include "video/mc6845.h"
6364#include "rendlay.h"
r5671r5672
973974/***************************************************************************
974975    SYSTEM CONFIG
975976***************************************************************************/
976
977977static void einstein_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
978978{
979979   /* floppy */
980980   switch(state)
981981   {
982982      /* --- the following bits of info are returned as 64-bit signed integers --- */
983      case MESS_DEVINFO_INT_COUNT:   info->i = 4; break;
983      case MESS_DEVINFO_INT_COUNT:                     info->i = 4; break;
984984
985      default:                  legacydsk_device_getinfo(devclass, state, info); break;
985      /* --- the following bits of info are returned as pointers to data or functions --- */
986      case MESS_DEVINFO_PTR_FLOPPY_OPTIONS:            info->p = (void *) floppyoptions_dsk; break;
987
988      default:                              floppy_device_getinfo(devclass, state, info); break;
986989   }
987990}
988991
src/mess/drivers/amstrad.c
r5671r5672
9898#include "machine/ctronics.h"
9999
100100/* Devices */
101#include "devices/dsk.h"      /* for CPCEMU style disk images */
101#include "formats/dsk_dsk.h"      /* for CPCEMU style disk images */
102102#include "devices/mflopimg.h"
103103#include "formats/basicdsk.h"
104104#include "includes/msx_slot.h"
r5671r5672
11271127      /* --- the following bits of info are returned as 64-bit signed integers --- */
11281128      case MESS_DEVINFO_INT_COUNT:                     info->i = 2; break;
11291129
1130      default:                              legacydsk_device_getinfo(devclass, state, info); break;
1130      /* --- the following bits of info are returned as pointers to data or functions --- */
1131      case MESS_DEVINFO_PTR_FLOPPY_OPTIONS:            info->p = (void *) floppyoptions_dsk; break;
1132
1133      default:                              floppy_device_getinfo(devclass, state, info); break;
11311134   }
1135
11321136}
11331137
11341138static void aleste_floppy_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
src/mess/drivers/specpls3.c
r5671r5672
156156
157157/* +3 hardware */
158158#include "machine/nec765.h"
159#include "devices/dsk.h"
159#include "formats/dsk_dsk.h"
160#include "devices/mflopimg.h"
160161
161162
162163/****************************************************************************************************/
r5671r5672
457458      /* --- the following bits of info are returned as 64-bit signed integers --- */
458459      case MESS_DEVINFO_INT_COUNT:                     info->i = 2; break;
459460
460      default:                              legacydsk_device_getinfo(devclass, state, info); break;
461      /* --- the following bits of info are returned as pointers to data or functions --- */
462      case MESS_DEVINFO_PTR_FLOPPY_OPTIONS:            info->p = (void *) floppyoptions_dsk; break;
463
464      default:                              floppy_device_getinfo(devclass, state, info); break;
461465   }
462466}
463467
468
464469static SYSTEM_CONFIG_START(specpls3)
465470   CONFIG_DEVICE(specpls3_floppy_getinfo)
466471   CONFIG_RAM_DEFAULT(128 * 1024)
src/mess/drivers/elwro800.c
r5671r5672
3232#include "machine/msm8251.h"
3333
3434/* Devices */
35#include "devices/dsk.h"      /* for CPCEMU style disk images */
35#include "formats/dsk_dsk.h"
36#include "devices/mflopimg.h"
3637#include "devices/cassette.h"
3738#include "formats/tzx_cas.h"
3839
r5671r5672
522523      /* --- the following bits of info are returned as 64-bit signed integers --- */
523524      case MESS_DEVINFO_INT_COUNT:                     info->i = 2; break;
524525
525      default:                              legacydsk_device_getinfo(devclass, state, info); break;
526      /* --- the following bits of info are returned as pointers to data or functions --- */
527      case MESS_DEVINFO_PTR_FLOPPY_OPTIONS:            info->p = (void *) floppyoptions_dsk; break;
528
529      default:                              floppy_device_getinfo(devclass, state, info); break;
526530   }
527531}
528532
533
529534static SYSTEM_CONFIG_START(elwro800)
530535   CONFIG_RAM_DEFAULT(64 * 1024)
531536   CONFIG_DEVICE(elwro800jr_floppy_getinfo)

Previous 15994 Revisions Next


© 1998-2018 The MESS Team