Previous

15994 Revisions

Next

r5705 Saturday 12th September, 2009 at 10:33:58 UTC by Miodrag Milanović
Joining code of flopdrv and mflopimg in one (just merge, no cleanup yet)

[src/mess]	mess.mak
[src/mess/devices]	appldriv.c flopdrv.c flopdrv.h mflopimg.c mflopimg.h sonydriv.c
[src/mess/drivers]	abc80.c abc80x.c adam.c amstrad.c apf.c apple2.c apple2gs.c apple3.c aquarius.c at.c atarist.c atom.c b2m.c bbc.c bebox.c bw12.c bw2.c cgenie.c coco.c compis.c comx35.c concept.c dgn_beta.c einstein.c elwro800.c enterp.c exidy.c fm7.c geneve.c kaypro.c kc.c mbee.c mikromik.c msx.c nanos.c nascom1.c nc.c newbrain.c oric.c orion.c osborne1.c osi.c partner.c pc.c pc8801.c pcw.c pcw16.c pk8020.c prof80.c pyl601.c ql.c samcoupe.c sg1000.c sord.c special.c specpls3.c svi318.c thomson.c ti990_4.c ti99_4p.c ti99_4x.c ti99_8.c tiki100.c tmc2000e.c tmc600.c trs80.c v1050.c vector06.c x1.c x68k.c xerox820.c xor100.c z80ne.c
[src/mess/machine]	990_dk.c 99_dsk.c beta.c exidy.c msx.c osborne1.c svi318.c

src/mess/machine/99_dsk.c

r5704	r5705
31	31	#include "99_dsk.h"
32	32	#include "mm58274c.h"
33	33	#include "formats/basicdsk.h"
34		#include "devices/mflopimg.h"
	34	#include "devices/flopdrv.h"
35	35
36	36
37	37	#define MAX_FLOPPIES 4

src/mess/machine/990_dk.c

r5704	r5705
12	12
13	13	#include "990_dk.h"
14	14	#include "formats/basicdsk.h"
15		#include "devices/mflopimg.h"
	15	#include "devices/flopdrv.h"
16	16
17	17	#define MAX_FLOPPIES 4
18	18

src/mess/machine/osborne1.c

r5704	r5705
22	22	#include "cpu/z80/z80daisy.h"
23	23	#include "sound/beep.h"
24	24	#include "includes/osborne1.h"
25		#include "devices/mflopimg.h"
	25	#include "devices/flopdrv.h"
26	26
27	27	#define RAMMODE      (0x01)
28	28

src/mess/machine/svi318.c

r5704	r5705
14	14	#include "machine/ins8250.h"
15	15	#include "machine/wd17xx.h"
16	16	#include "machine/ctronics.h"
17		#include "devices/mflopimg.h"
	17	#include "devices/flopdrv.h"
18	18	#include "devices/cassette.h"
19	19	#include "formats/svi_cas.h"
20	20	#include "sound/dac.h"

src/mess/machine/msx.c

r5704	r5705
17	17	#include "includes/msx.h"
18	18	#include "machine/tc8521.h"
19	19	#include "machine/wd17xx.h"
20		#include "devices/mflopimg.h"
	20	#include "devices/flopdrv.h"
21	21	#include "formats/basicdsk.h"
22	22	#include "video/tms9928a.h"
23	23	#include "cpu/z80/z80.h"

src/mess/machine/beta.c

r5704	r5705
8	8
9	9	*********************************************************************/
10	10	#include "driver.h"
11		#include "devices/mflopimg.h"
	11	#include "devices/flopdrv.h"
12	12	#include "formats/trd_dsk.h"
13	13	#include "machine/wd17xx.h"
14	14	#include "machine/beta.h"

src/mess/machine/exidy.c

r5704	r5705
13	13	#include "devices/cartslot.h"
14	14	#include "machine/ay31015.h"
15	15	#include "includes/exidy.h"
16		#include "devices/mflopimg.h"
	16	#include "devices/flopdrv.h"
17	17
18	18
19	19	static const device_config *exidy_ay31015;

src/mess/mess.mak

r5704	r5705
395	395	$(MESS_FORMATS)/dsk_dsk.o   \
396	396	$(MESS_DEVICES)/flopdrv.o   \
397	397	$(MESS_DEVICES)/harddriv.o   \
398		$(MESS_DEVICES)/mflopimg.o   \
399	398	$(MESS_DEVICES)/microdrv.o   \
400	399	$(MESS_DEVICES)/multcart.o   \
401	400	$(MESS_DEVICES)/printer.o   \

src/mess/devices/mflopimg.c

r5704	r5705
1		/*********************************************************************
2
3		mflopimg.c
4
5		MESS interface to the floppy disk image abstraction code
6
7		*********************************************************************/
8
9		#include "mame.h"
10		#include "mflopimg.h"
11		#include "flopdrv.h"
12		#include "formats/flopimg.h"
13
14
15
16		/***************************************************************************
17		CONSTANTS
18		***************************************************************************/
19
20		#define FLOPPY_TAG      "floptag"
21		#define LOG_FLOPPY      0
22
23
24
25		/***************************************************************************
26		TYPE DEFINITIONS
27		***************************************************************************/
28
29		typedef struct _mess_flopimg mess_flopimg;
30		struct _mess_flopimg
31		{
32		floppy_image *floppy;
33		int track;
34		void (*load_proc)(const device_config *image);
35		void (*unload_proc)(const device_config *image);
36		int (*tracktranslate_proc)(const device_config *image, floppy_image *floppy, int physical_track);
37		};
38
39
40
41		typedef struct _floppy_error_map floppy_error_map;
42		struct _floppy_error_map
43		{
44		floperr_t ferr;
45		image_error_t ierr;
46		const char *message;
47		};
48
49
50
51		/***************************************************************************
52		GLOBAL VARIABLES
53		***************************************************************************/
54
55		static const floppy_error_map errmap[] =
56		{
57		{ FLOPPY_ERROR_SUCCESS,         IMAGE_ERROR_SUCCESS },
58		{ FLOPPY_ERROR_INTERNAL,      IMAGE_ERROR_INTERNAL },
59		{ FLOPPY_ERROR_UNSUPPORTED,      IMAGE_ERROR_UNSUPPORTED },
60		{ FLOPPY_ERROR_OUTOFMEMORY,      IMAGE_ERROR_OUTOFMEMORY },
61		{ FLOPPY_ERROR_INVALIDIMAGE,   IMAGE_ERROR_INVALIDIMAGE }
62		};
63
64		/***************************************************************************
65		IMPLEMENTATION
66		***************************************************************************/
67
68		static mess_flopimg *get_flopimg(const device_config *image)
69		{
70		return (mess_flopimg *) image_lookuptag(image, FLOPPY_TAG);
71		}
72
73
74
75		floppy_image *flopimg_get_image(const device_config *image)
76		{
77		return get_flopimg(image)->floppy;
78		}
79
80
81
82		static void flopimg_seek_callback(const device_config *image, int physical_track)
83		{
84		mess_flopimg *flopimg;
85
86		flopimg = get_flopimg(image);
87		if (!flopimg || !flopimg->floppy)
88		return;
89
90		/* translate the track number if necessary */
91		if (flopimg->tracktranslate_proc)
92		physical_track = flopimg->tracktranslate_proc(image, flopimg->floppy, physical_track);
93
94		flopimg->track = physical_track;
95		}
96
97
98
99		static int flopimg_get_sectors_per_track(const device_config *image, int side)
100		{
101		mess_flopimg *flopimg;
102		floperr_t err;
103		int sector_count;
104
105		flopimg = get_flopimg(image);
106		if (!flopimg || !flopimg->floppy)
107		return 0;
108
109		err = floppy_get_sector_count(flopimg->floppy, side, flopimg->track, &sector_count);
110		if (err)
111		return 0;
112		return sector_count;
113		}
114
115
116
117		static void flopimg_get_id_callback(const device_config *image, chrn_id *id, int id_index, int side)
118		{
119		mess_flopimg *flopimg;
120		int cylinder, sector, N;
121		unsigned long flags;
122		UINT32 sector_length;
123
124		flopimg = get_flopimg(image);
125		if (!flopimg || !flopimg->floppy)
126		return;
127
128		floppy_get_indexed_sector_info(flopimg->floppy, side, flopimg->track, id_index, &cylinder, &side, &sector, &sector_length, &flags);
129
130		N = compute_log2(sector_length);
131
132		id->C = cylinder;
133		id->H = side;
134		id->R = sector;
135		id->data_id = id_index;
136		id->flags = flags;
137		id->N = ((N >= 7) && (N <= 10)) ? N - 7 : 0;
138		}
139
140
141
142		static void log_readwrite(const char *name, int head, int track, int sector, const char *buf, int length)
143		{
144		char membuf[1024];
145		int i;
146		for (i = 0; i < length; i++)
147		sprintf(membuf + i*2, "%02x", (int) (UINT8) buf[i]);
148		logerror("%s:  head=%i track=%i sector=%i buffer='%s'\n", name, head, track, sector, membuf);
149		}
150
151
152
153		static void flopimg_read_sector_data_into_buffer(const device_config *image, int side, int index1, char *ptr, int length)
154		{
155		mess_flopimg *flopimg;
156
157		flopimg = get_flopimg(image);
158		if (!flopimg || !flopimg->floppy)
159		return;
160
161		floppy_read_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length);
162
163		if (LOG_FLOPPY)
164		log_readwrite("sector_read", side, flopimg->track, index1, ptr, length);
165		}
166
167
168
169		static void flopimg_write_sector_data_from_buffer(const device_config *image, int side, int index1, const char *ptr, int length, int ddam)
170		{
171		mess_flopimg *flopimg;
172
173		flopimg = get_flopimg(image);
174		if (!flopimg || !flopimg->floppy)
175		return;
176
177		if (LOG_FLOPPY)
178		log_readwrite("sector_write", side, flopimg->track, index1, ptr, length);
179
180		floppy_write_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length, ddam);
181		}
182
183
184
185		static void flopimg_read_track_data_info_buffer(const device_config *image, int side, void *ptr, int *length)
186		{
187		mess_flopimg *flopimg;
188
189		flopimg = get_flopimg(image);
190		if (!flopimg || !flopimg->floppy)
191		return;
192
193		floppy_read_track_data(flopimg->floppy, side, flopimg->track, ptr, *length);
194		}
195
196
197
198		static void flopimg_write_track_data_info_buffer(const device_config *image, int side, const void *ptr, int *length)
199		{
200		mess_flopimg *flopimg;
201
202		flopimg = get_flopimg(image);
203		if (!flopimg || !flopimg->floppy)
204		return;
205
206		floppy_write_track_data(flopimg->floppy, side, flopimg->track, ptr, *length);
207		}
208
209
210
211		static const floppy_interface mess_floppy_interface =
212		{
213		flopimg_seek_callback,
214		flopimg_get_sectors_per_track,
215		flopimg_get_id_callback,
216		flopimg_read_sector_data_into_buffer,
217		flopimg_write_sector_data_from_buffer,
218		flopimg_read_track_data_info_buffer,
219		flopimg_write_track_data_info_buffer,
220		NULL
221		};
222
223		/* ----------------------------------------------------------------------- */
224
225		static int image_fseek_thunk(void *file, INT64 offset, int whence)
226		{
227		return image_fseek((const device_config *) file, offset, whence);
228		}
229
230		static size_t image_fread_thunk(void *file, void *buffer, size_t length)
231		{
232		return image_fread((const device_config *) file, buffer, length);
233		}
234
235		static size_t image_fwrite_thunk(void *file, const void *buffer, size_t length)
236		{
237		return image_fwrite((const device_config *) file, buffer, length);
238		}
239
240		static UINT64 image_fsize_thunk(void *file)
241		{
242		return image_length((const device_config *) file);
243		}
244
245		/* ----------------------------------------------------------------------- */
246
247		const struct io_procs mess_ioprocs =
248		{
249		NULL,
250		image_fseek_thunk,
251		image_fread_thunk,
252		image_fwrite_thunk,
253		image_fsize_thunk
254		};
255
256
257
258
259		/* ----------------------------------------------------------------------- */
260
261
262		static DEVICE_START( floppy )
263		{
264		image_alloctag(device, FLOPPY_TAG, sizeof(mess_flopimg));
265		floppy_drive_init(device, &mess_floppy_interface);
266		}
267
268
269
270		static int internal_floppy_device_load(const device_config *image, int create_format, option_resolution *create_args)
271		{
272		floperr_t err;
273		mess_flopimg *flopimg;
274		const mess_device_class *devclass;
275		const struct FloppyFormat *floppy_options;
276		int floppy_flags, i;
277		const char *extension;
278		int keep_geometry = 0;
279
280		/* look up instance data */
281		flopimg = get_flopimg(image);
282
283		/* figure out the floppy options */
284		devclass = mess_devclass_from_core_device(image);
285		floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
286
287		if (image_has_been_created(image))
288		{
289		/* creating an image */
290		assert(create_format >= 0);
291		err = floppy_create((void *) image, &mess_ioprocs, &floppy_options[create_format], create_args, &flopimg->floppy);
292		if (err)
293		goto error;
294		}
295		else
296		{
297		/* opening an image */
298		floppy_flags = image_is_writable(image) ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
299		extension = image_filetype(image);
300		err = floppy_open_choices((void *) image, &mess_ioprocs, extension, floppy_options, floppy_flags, &flopimg->floppy);
301		if (err)
302		goto error;
303		}
304
305		/* if we can get head and track counts, then set the geometry accordingly
306		However, at least the ti99 system family requires that medium track
307		count and drive track count be handled separately.
308		It is possible to insert a 40 track medium in an 80 track drive; the
309		TI controllers read the track count from sector 0 and automatically
310		apply double steps. Setting the track count of the drive to the
311		medium track count will then lead to unreachable tracks.
312		*/
313		keep_geometry = (int)mess_device_get_info_int(mess_devclass_from_core_device(image), MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY);
314
315		if (!keep_geometry
316		&& floppy_callbacks(flopimg->floppy)->get_heads_per_disk
317		&& floppy_callbacks(flopimg->floppy)->get_tracks_per_disk)
318		{
319		floppy_drive_set_geometry_absolute(image,
320		floppy_get_tracks_per_disk(flopimg->floppy),
321		floppy_get_heads_per_disk(flopimg->floppy));
322		}
323		return INIT_PASS;
324
325		error:
326		for (i = 0; i < sizeof(errmap) / sizeof(errmap[0]); i++)
327		{
328		if (err == errmap[i].ferr)
329		image_seterror(image, errmap[i].ierr, errmap[i].message);
330		}
331		return INIT_FAIL;
332		}
333
334
335
336		static DEVICE_IMAGE_LOAD( floppy )
337		{
338		mess_flopimg *flopimg;
339		int retVal = internal_floppy_device_load(image, -1, NULL);
340		flopimg = image_lookuptag(image, FLOPPY_TAG);
341		if (retVal==INIT_PASS) {
342		/* if we have one of our hacky unload procs, call it */
343		if (flopimg->load_proc)
344		flopimg->load_proc(image);
345		}
346		return retVal;
347		}
348
349
350
351		static DEVICE_IMAGE_CREATE( floppy )
352		{
353		return internal_floppy_device_load(image, create_format, create_args);
354		}
355
356
357
358		static DEVICE_IMAGE_UNLOAD( floppy )
359		{
360		mess_flopimg *flopimg;
361		flopimg = image_lookuptag(image, FLOPPY_TAG);
362
363		/* if we have one of our hacky unload procs, call it */
364		if (flopimg->unload_proc)
365		flopimg->unload_proc(image);
366
367		floppy_close(flopimg->floppy);
368		flopimg->floppy = NULL;
369		}
370
371
372
373		/*************************************
374		*
375		*   Hacks for specific systems
376		*
377		*************************************/
378
379		void floppy_install_load_proc(const device_config *image, void (*proc)(const device_config *image))
380		{
381		mess_flopimg *flopimg;
382		flopimg = image_lookuptag(image, FLOPPY_TAG);
383		flopimg->load_proc = proc;
384		}
385
386		void floppy_install_unload_proc(const device_config *image, void (*proc)(const device_config *image))
387		{
388		mess_flopimg *flopimg;
389		flopimg = image_lookuptag(image, FLOPPY_TAG);
390		flopimg->unload_proc = proc;
391		}
392
393
394
395		void floppy_install_tracktranslate_proc(const device_config *image, int (*proc)(const device_config *image, floppy_image *floppy, int physical_track))
396		{
397		mess_flopimg *flopimg;
398		flopimg = image_lookuptag(image, FLOPPY_TAG);
399		flopimg->tracktranslate_proc = proc;
400		}
401
402		/*************************************
403		*
404		*   Device specification function
405		*
406		*************************************/
407
408		void floppy_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
409		{
410		char *s;
411		int i, count;
412		const struct FloppyFormat *floppy_options;
413
414		switch(state)
415		{
416		/* --- the following bits of info are returned as 64-bit signed integers --- */
417		case MESS_DEVINFO_INT_TYPE:            info->i = IO_FLOPPY; break;
418		case MESS_DEVINFO_INT_READABLE:         info->i = 1; break;
419		case MESS_DEVINFO_INT_WRITEABLE:         info->i = 1; break;
420		case MESS_DEVINFO_INT_CREATABLE:
421		floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
422		info->i = floppy_options->param_guidelines ? 1 : 0;
423		break;
424
425		case MESS_DEVINFO_INT_CREATE_OPTCOUNT:
426		/* count total floppy options */
427		floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
428		for (count = 0; floppy_options[count].construct; count++)
429		;
430		info->i = count;
431		break;
432
433		case MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY:
434		info->i = 0;
435		break;
436
437		/* --- the following bits of info are returned as NULL-terminated strings --- */
438		case MESS_DEVINFO_STR_FILE_EXTENSIONS:
439		/* retrieve the floppy options */
440		floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
441
442		/* set up a temporary string */
443		s = device_temp_str();
444		info->s = s;
445		s[0] = '\0';
446
447		/* append each of the extensions */
448		for (i = 0; floppy_options[i].construct; i++)
449		specify_extension(s, 256, floppy_options[i].extensions);
450		break;
451
452		/* --- the following bits of info are returned as pointers to data or functions --- */
453		case MESS_DEVINFO_PTR_START:            info->start = DEVICE_START_NAME(floppy); break;
454		case MESS_DEVINFO_PTR_LOAD:            info->load = DEVICE_IMAGE_LOAD_NAME(floppy); break;
455		case MESS_DEVINFO_PTR_CREATE:         info->create = DEVICE_IMAGE_CREATE_NAME(floppy); break;
456		case MESS_DEVINFO_PTR_UNLOAD:         info->unload = DEVICE_IMAGE_UNLOAD_NAME(floppy); break;
457		case MESS_DEVINFO_PTR_CREATE_OPTGUIDE:   info->p = (void *) floppy_option_guide; break;
458
459		default:
460		floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
461		if ((state >= MESS_DEVINFO_STR_CREATE_OPTNAME) && (state < MESS_DEVINFO_STR_CREATE_OPTNAME + DEVINFO_CREATE_OPTMAX))
462		{
463		info->s = (void *) floppy_options[state - MESS_DEVINFO_STR_CREATE_OPTNAME].name;
464		}
465		else if ((state >= MESS_DEVINFO_STR_CREATE_OPTDESC) && (state < MESS_DEVINFO_STR_CREATE_OPTDESC + DEVINFO_CREATE_OPTMAX))
466		{
467		info->s = (void *) floppy_options[state - MESS_DEVINFO_STR_CREATE_OPTDESC].description;
468		}
469		else if ((state >= MESS_DEVINFO_STR_CREATE_OPTEXTS) && (state < MESS_DEVINFO_STR_CREATE_OPTEXTS + DEVINFO_CREATE_OPTMAX))
470		{
471		info->s = (void *) floppy_options[state - MESS_DEVINFO_STR_CREATE_OPTEXTS].extensions;
472		}
473		else if ((state >= MESS_DEVINFO_PTR_CREATE_OPTSPEC) && (state < MESS_DEVINFO_PTR_CREATE_OPTSPEC + DEVINFO_CREATE_OPTMAX))
474		{
475		info->p = (void *) floppy_options[state - MESS_DEVINFO_PTR_CREATE_OPTSPEC].param_guidelines;
476		}
477		break;
478		}
479		}
480

src/mess/devices/mflopimg.h

r5704	r5705
1		/*********************************************************************
2
3		mflopimg.h
4
5		MESS interface to the floppy disk image abstraction code
6
7		*********************************************************************/
8
9		#ifndef MFLOPIMG_H
10		#define MFLOPIMG_H
11
12		#include "device.h"
13		#include "image.h"
14		#include "flopdrv.h"
15		#include "formats/flopimg.h"
16
17
18		enum
19		{
20		MESS_DEVINFO_PTR_FLOPPY_OPTIONS = MESS_DEVINFO_PTR_DEV_SPECIFIC,
21		MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY = MESS_DEVINFO_INT_DEV_SPECIFIC
22		};
23
24		floppy_image *flopimg_get_image(const device_config *image);
25
26		void floppy_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info);
27
28		/* hack for apple II; replace this when we think of something better */
29		void floppy_install_unload_proc(const device_config *image, void (*proc)(const device_config *image));
30
31		void floppy_install_load_proc(const device_config *image, void (*proc)(const device_config *image));
32
33		/* hack for TI99; replace this when we think of something better */
34		void floppy_install_tracktranslate_proc(const device_config *image, int (*proc)(const device_config *image, floppy_image *floppy, int physical_track));
35
36		#endif /* MFLOPIMG_H */

src/mess/devices/flopdrv.c

r5704	r5705
519	519	drv->controller = controller;
520	520	}
521	521
	522
	523
	524	/***************************************************************************
	525	CONSTANTS
	526	***************************************************************************/
	527
	528	#define FLOPPY_TAG      "floptag"
	529	#define LOG_FLOPPY      0
	530
	531
	532
	533	/***************************************************************************
	534	TYPE DEFINITIONS
	535	***************************************************************************/
	536
	537	typedef struct _mess_flopimg mess_flopimg;
	538	struct _mess_flopimg
	539	{
	540	floppy_image *floppy;
	541	int track;
	542	void (*load_proc)(const device_config *image);
	543	void (*unload_proc)(const device_config *image);
	544	int (*tracktranslate_proc)(const device_config *image, floppy_image *floppy, int physical_track);
	545	};
	546
	547
	548
	549	typedef struct _floppy_error_map floppy_error_map;
	550	struct _floppy_error_map
	551	{
	552	floperr_t ferr;
	553	image_error_t ierr;
	554	const char *message;
	555	};
	556
	557
	558
	559	/***************************************************************************
	560	GLOBAL VARIABLES
	561	***************************************************************************/
	562
	563	static const floppy_error_map errmap[] =
	564	{
	565	{ FLOPPY_ERROR_SUCCESS,         IMAGE_ERROR_SUCCESS },
	566	{ FLOPPY_ERROR_INTERNAL,      IMAGE_ERROR_INTERNAL },
	567	{ FLOPPY_ERROR_UNSUPPORTED,      IMAGE_ERROR_UNSUPPORTED },
	568	{ FLOPPY_ERROR_OUTOFMEMORY,      IMAGE_ERROR_OUTOFMEMORY },
	569	{ FLOPPY_ERROR_INVALIDIMAGE,   IMAGE_ERROR_INVALIDIMAGE }
	570	};
	571
	572	/***************************************************************************
	573	IMPLEMENTATION
	574	***************************************************************************/
	575
	576	static mess_flopimg *get_flopimg(const device_config *image)
	577	{
	578	return (mess_flopimg *) image_lookuptag(image, FLOPPY_TAG);
	579	}
	580
	581
	582
	583	floppy_image *flopimg_get_image(const device_config *image)
	584	{
	585	return get_flopimg(image)->floppy;
	586	}
	587
	588
	589
	590	static void flopimg_seek_callback(const device_config *image, int physical_track)
	591	{
	592	mess_flopimg *flopimg;
	593
	594	flopimg = get_flopimg(image);
	595	if (!flopimg || !flopimg->floppy)
	596	return;
	597
	598	/* translate the track number if necessary */
	599	if (flopimg->tracktranslate_proc)
	600	physical_track = flopimg->tracktranslate_proc(image, flopimg->floppy, physical_track);
	601
	602	flopimg->track = physical_track;
	603	}
	604
	605
	606
	607	static int flopimg_get_sectors_per_track(const device_config *image, int side)
	608	{
	609	mess_flopimg *flopimg;
	610	floperr_t err;
	611	int sector_count;
	612
	613	flopimg = get_flopimg(image);
	614	if (!flopimg || !flopimg->floppy)
	615	return 0;
	616
	617	err = floppy_get_sector_count(flopimg->floppy, side, flopimg->track, &sector_count);
	618	if (err)
	619	return 0;
	620	return sector_count;
	621	}
	622
	623
	624
	625	static void flopimg_get_id_callback(const device_config *image, chrn_id *id, int id_index, int side)
	626	{
	627	mess_flopimg *flopimg;
	628	int cylinder, sector, N;
	629	unsigned long flags;
	630	UINT32 sector_length;
	631
	632	flopimg = get_flopimg(image);
	633	if (!flopimg || !flopimg->floppy)
	634	return;
	635
	636	floppy_get_indexed_sector_info(flopimg->floppy, side, flopimg->track, id_index, &cylinder, &side, &sector, &sector_length, &flags);
	637
	638	N = compute_log2(sector_length);
	639
	640	id->C = cylinder;
	641	id->H = side;
	642	id->R = sector;
	643	id->data_id = id_index;
	644	id->flags = flags;
	645	id->N = ((N >= 7) && (N <= 10)) ? N - 7 : 0;
	646	}
	647
	648
	649
	650	static void log_readwrite(const char *name, int head, int track, int sector, const char *buf, int length)
	651	{
	652	char membuf[1024];
	653	int i;
	654	for (i = 0; i < length; i++)
	655	sprintf(membuf + i*2, "%02x", (int) (UINT8) buf[i]);
	656	logerror("%s:  head=%i track=%i sector=%i buffer='%s'\n", name, head, track, sector, membuf);
	657	}
	658
	659
	660
	661	static void flopimg_read_sector_data_into_buffer(const device_config *image, int side, int index1, char *ptr, int length)
	662	{
	663	mess_flopimg *flopimg;
	664
	665	flopimg = get_flopimg(image);
	666	if (!flopimg || !flopimg->floppy)
	667	return;
	668
	669	floppy_read_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length);
	670
	671	if (LOG_FLOPPY)
	672	log_readwrite("sector_read", side, flopimg->track, index1, ptr, length);
	673	}
	674
	675
	676
	677	static void flopimg_write_sector_data_from_buffer(const device_config *image, int side, int index1, const char *ptr, int length, int ddam)
	678	{
	679	mess_flopimg *flopimg;
	680
	681	flopimg = get_flopimg(image);
	682	if (!flopimg || !flopimg->floppy)
	683	return;
	684
	685	if (LOG_FLOPPY)
	686	log_readwrite("sector_write", side, flopimg->track, index1, ptr, length);
	687
	688	floppy_write_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length, ddam);
	689	}
	690
	691
	692
	693	static void flopimg_read_track_data_info_buffer(const device_config *image, int side, void *ptr, int *length)
	694	{
	695	mess_flopimg *flopimg;
	696
	697	flopimg = get_flopimg(image);
	698	if (!flopimg || !flopimg->floppy)
	699	return;
	700
	701	floppy_read_track_data(flopimg->floppy, side, flopimg->track, ptr, *length);
	702	}
	703
	704
	705
	706	static void flopimg_write_track_data_info_buffer(const device_config *image, int side, const void *ptr, int *length)
	707	{
	708	mess_flopimg *flopimg;
	709
	710	flopimg = get_flopimg(image);
	711	if (!flopimg || !flopimg->floppy)
	712	return;
	713
	714	floppy_write_track_data(flopimg->floppy, side, flopimg->track, ptr, *length);
	715	}
	716
	717
	718
	719	static const floppy_interface mess_floppy_interface =
	720	{
	721	flopimg_seek_callback,
	722	flopimg_get_sectors_per_track,
	723	flopimg_get_id_callback,
	724	flopimg_read_sector_data_into_buffer,
	725	flopimg_write_sector_data_from_buffer,
	726	flopimg_read_track_data_info_buffer,
	727	flopimg_write_track_data_info_buffer,
	728	NULL
	729	};
	730
	731	/* ----------------------------------------------------------------------- */
	732
	733	static int image_fseek_thunk(void *file, INT64 offset, int whence)
	734	{
	735	return image_fseek((const device_config *) file, offset, whence);
	736	}
	737
	738	static size_t image_fread_thunk(void *file, void *buffer, size_t length)
	739	{
	740	return image_fread((const device_config *) file, buffer, length);
	741	}
	742
	743	static size_t image_fwrite_thunk(void *file, const void *buffer, size_t length)
	744	{
	745	return image_fwrite((const device_config *) file, buffer, length);
	746	}
	747
	748	static UINT64 image_fsize_thunk(void *file)
	749	{
	750	return image_length((const device_config *) file);
	751	}
	752
	753	/* ----------------------------------------------------------------------- */
	754
	755	const struct io_procs mess_ioprocs =
	756	{
	757	NULL,
	758	image_fseek_thunk,
	759	image_fread_thunk,
	760	image_fwrite_thunk,
	761	image_fsize_thunk
	762	};
	763
	764
	765
	766
	767	/* ----------------------------------------------------------------------- */
	768
	769
	770	static DEVICE_START( floppy )
	771	{
	772	image_alloctag(device, FLOPPY_TAG, sizeof(mess_flopimg));
	773	floppy_drive_init(device, &mess_floppy_interface);
	774	}
	775
	776
	777
	778	static int internal_floppy_device_load(const device_config *image, int create_format, option_resolution *create_args)
	779	{
	780	floperr_t err;
	781	mess_flopimg *flopimg;
	782	const mess_device_class *devclass;
	783	const struct FloppyFormat *floppy_options;
	784	int floppy_flags, i;
	785	const char *extension;
	786	int keep_geometry = 0;
	787
	788	/* look up instance data */
	789	flopimg = get_flopimg(image);
	790
	791	/* figure out the floppy options */
	792	devclass = mess_devclass_from_core_device(image);
	793	floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
	794
	795	if (image_has_been_created(image))
	796	{
	797	/* creating an image */
	798	assert(create_format >= 0);
	799	err = floppy_create((void *) image, &mess_ioprocs, &floppy_options[create_format], create_args, &flopimg->floppy);
	800	if (err)
	801	goto error;
	802	}
	803	else
	804	{
	805	/* opening an image */
	806	floppy_flags = image_is_writable(image) ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
	807	extension = image_filetype(image);
	808	err = floppy_open_choices((void *) image, &mess_ioprocs, extension, floppy_options, floppy_flags, &flopimg->floppy);
	809	if (err)
	810	goto error;
	811	}
	812
	813	/* if we can get head and track counts, then set the geometry accordingly
	814	However, at least the ti99 system family requires that medium track
	815	count and drive track count be handled separately.
	816	It is possible to insert a 40 track medium in an 80 track drive; the
	817	TI controllers read the track count from sector 0 and automatically
	818	apply double steps. Setting the track count of the drive to the
	819	medium track count will then lead to unreachable tracks.
	820	*/
	821	keep_geometry = (int)mess_device_get_info_int(mess_devclass_from_core_device(image), MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY);
	822
	823	if (!keep_geometry
	824	&& floppy_callbacks(flopimg->floppy)->get_heads_per_disk
	825	&& floppy_callbacks(flopimg->floppy)->get_tracks_per_disk)
	826	{
	827	floppy_drive_set_geometry_absolute(image,
	828	floppy_get_tracks_per_disk(flopimg->floppy),
	829	floppy_get_heads_per_disk(flopimg->floppy));
	830	}
	831	return INIT_PASS;
	832
	833	error:
	834	for (i = 0; i < sizeof(errmap) / sizeof(errmap[0]); i++)
	835	{
	836	if (err == errmap[i].ferr)
	837	image_seterror(image, errmap[i].ierr, errmap[i].message);
	838	}
	839	return INIT_FAIL;
	840	}
	841
	842
	843
	844	static DEVICE_IMAGE_LOAD( floppy )
	845	{
	846	mess_flopimg *flopimg;
	847	int retVal = internal_floppy_device_load(image, -1, NULL);
	848	flopimg = image_lookuptag(image, FLOPPY_TAG);
	849	if (retVal==INIT_PASS) {
	850	/* if we have one of our hacky unload procs, call it */
	851	if (flopimg->load_proc)
	852	flopimg->load_proc(image);
	853	}
	854	return retVal;
	855	}
	856
	857
	858
	859	static DEVICE_IMAGE_CREATE( floppy )
	860	{
	861	return internal_floppy_device_load(image, create_format, create_args);
	862	}
	863
	864
	865
	866	static DEVICE_IMAGE_UNLOAD( floppy )
	867	{
	868	mess_flopimg *flopimg;
	869	flopimg = image_lookuptag(image, FLOPPY_TAG);
	870
	871	/* if we have one of our hacky unload procs, call it */
	872	if (flopimg->unload_proc)
	873	flopimg->unload_proc(image);
	874
	875	floppy_close(flopimg->floppy);
	876	flopimg->floppy = NULL;
	877	}
	878
	879
	880
	881	/*************************************
	882	*
	883	*   Hacks for specific systems
	884	*
	885	*************************************/
	886
	887	void floppy_install_load_proc(const device_config *image, void (*proc)(const device_config *image))
	888	{
	889	mess_flopimg *flopimg;
	890	flopimg = image_lookuptag(image, FLOPPY_TAG);
	891	flopimg->load_proc = proc;
	892	}
	893
	894	void floppy_install_unload_proc(const device_config *image, void (*proc)(const device_config *image))
	895	{
	896	mess_flopimg *flopimg;
	897	flopimg = image_lookuptag(image, FLOPPY_TAG);
	898	flopimg->unload_proc = proc;
	899	}
	900
	901
	902
	903	void floppy_install_tracktranslate_proc(const device_config *image, int (*proc)(const device_config *image, floppy_image *floppy, int physical_track))
	904	{
	905	mess_flopimg *flopimg;
	906	flopimg = image_lookuptag(image, FLOPPY_TAG);
	907	flopimg->tracktranslate_proc = proc;
	908	}
	909
	910	/*************************************
	911	*
	912	*   Device specification function
	913	*
	914	*************************************/
	915
	916	void floppy_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info)
	917	{
	918	char *s;
	919	int i, count;
	920	const struct FloppyFormat *floppy_options;
	921
	922	switch(state)
	923	{
	924	/* --- the following bits of info are returned as 64-bit signed integers --- */
	925	case MESS_DEVINFO_INT_TYPE:            info->i = IO_FLOPPY; break;
	926	case MESS_DEVINFO_INT_READABLE:         info->i = 1; break;
	927	case MESS_DEVINFO_INT_WRITEABLE:         info->i = 1; break;
	928	case MESS_DEVINFO_INT_CREATABLE:
	929	floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
	930	info->i = floppy_options->param_guidelines ? 1 : 0;
	931	break;
	932
	933	case MESS_DEVINFO_INT_CREATE_OPTCOUNT:
	934	/* count total floppy options */
	935	floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
	936	for (count = 0; floppy_options[count].construct; count++)
	937	;
	938	info->i = count;
	939	break;
	940
	941	case MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY:
	942	info->i = 0;
	943	break;
	944
	945	/* --- the following bits of info are returned as NULL-terminated strings --- */
	946	case MESS_DEVINFO_STR_FILE_EXTENSIONS:
	947	/* retrieve the floppy options */
	948	floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
	949
	950	/* set up a temporary string */
	951	s = device_temp_str();
	952	info->s = s;
	953	s[0] = '\0';
	954
	955	/* append each of the extensions */
	956	for (i = 0; floppy_options[i].construct; i++)
	957	specify_extension(s, 256, floppy_options[i].extensions);
	958	break;
	959
	960	/* --- the following bits of info are returned as pointers to data or functions --- */
	961	case MESS_DEVINFO_PTR_START:            info->start = DEVICE_START_NAME(floppy); break;
	962	case MESS_DEVINFO_PTR_LOAD:            info->load = DEVICE_IMAGE_LOAD_NAME(floppy); break;
	963	case MESS_DEVINFO_PTR_CREATE:         info->create = DEVICE_IMAGE_CREATE_NAME(floppy); break;
	964	case MESS_DEVINFO_PTR_UNLOAD:         info->unload = DEVICE_IMAGE_UNLOAD_NAME(floppy); break;
	965	case MESS_DEVINFO_PTR_CREATE_OPTGUIDE:   info->p = (void *) floppy_option_guide; break;
	966
	967	default:
	968	floppy_options = mess_device_get_info_ptr(devclass, MESS_DEVINFO_PTR_FLOPPY_OPTIONS);
	969	if ((state >= MESS_DEVINFO_STR_CREATE_OPTNAME) && (state < MESS_DEVINFO_STR_CREATE_OPTNAME + DEVINFO_CREATE_OPTMAX))
	970	{
	971	info->s = (void *) floppy_options[state - MESS_DEVINFO_STR_CREATE_OPTNAME].name;
	972	}
	973	else if ((state >= MESS_DEVINFO_STR_CREATE_OPTDESC) && (state < MESS_DEVINFO_STR_CREATE_OPTDESC + DEVINFO_CREATE_OPTMAX))
	974	{
	975	info->s = (void *) floppy_options[state - MESS_DEVINFO_STR_CREATE_OPTDESC].description;
	976	}
	977	else if ((state >= MESS_DEVINFO_STR_CREATE_OPTEXTS) && (state < MESS_DEVINFO_STR_CREATE_OPTEXTS + DEVINFO_CREATE_OPTMAX))
	978	{
	979	info->s = (void *) floppy_options[state - MESS_DEVINFO_STR_CREATE_OPTEXTS].extensions;
	980	}
	981	else if ((state >= MESS_DEVINFO_PTR_CREATE_OPTSPEC) && (state < MESS_DEVINFO_PTR_CREATE_OPTSPEC + DEVINFO_CREATE_OPTMAX))
	982	{
	983	info->p = (void *) floppy_options[state - MESS_DEVINFO_PTR_CREATE_OPTSPEC].param_guidelines;
	984	}
	985	break;
	986	}
	987	}
	988

src/mess/devices/sonydriv.c

r5704	r5705
41	41	#include "sonydriv.h"
42	42	#include "formats/ap_dsk35.h"
43	43	#include "flopdrv.h"
44		#include "mflopimg.h"
45	44
46	45
47	46	#ifdef MAME_DEBUG

src/mess/devices/flopdrv.h

r5704	r5705
6	6
7	7	#include "device.h"
8	8	#include "image.h"
	9	#include "formats/flopimg.h"
9	10
10	11
11	12	typedef enum
r5704	r5705
167	168	void floppy_drive_set_rpm(const device_config *image, float rpm);
168	169
169	170	void floppy_drive_set_controller(const device_config *img, const device_config *controller);
	171
	172	enum
	173	{
	174	MESS_DEVINFO_PTR_FLOPPY_OPTIONS = MESS_DEVINFO_PTR_DEV_SPECIFIC,
	175	MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY = MESS_DEVINFO_INT_DEV_SPECIFIC
	176	};
	177
	178	floppy_image *flopimg_get_image(const device_config *image);
	179
	180	void floppy_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info);
	181
	182	/* hack for apple II; replace this when we think of something better */
	183	void floppy_install_unload_proc(const device_config *image, void (*proc)(const device_config *image));
	184
	185	void floppy_install_load_proc(const device_config *image, void (*proc)(const device_config *image));
	186
	187	/* hack for TI99; replace this when we think of something better */
	188	void floppy_install_tracktranslate_proc(const device_config *image, int (*proc)(const device_config *image, floppy_image *floppy, int physical_track));
	189
	190
170	191	#endif /* FLOPDRV_H */

src/mess/devices/appldriv.c

r5704	r5705
8	8
9	9	#include "appldriv.h"
10	10	#include "flopdrv.h"
11		#include "mflopimg.h"
12	11	#include "formats/ap2_dsk.h"
13	12
14	13

src/mess/drivers/dgn_beta.c

r5704	r5705
45	45	#include "includes/dgn_beta.h"
46	46	#include "machine/6551.h"
47	47	#include "formats/coco_dsk.h"
48		#include "devices/mflopimg.h"
	48	#include "devices/flopdrv.h"
49	49	#include "devices/coco_vhd.h"
50	50
51	51	/*

src/mess/drivers/apple3.c

r5704	r5705
14	14	#include "cpu/m6502/m6502.h"
15	15	#include "includes/apple3.h"
16	16	#include "includes/apple2.h"
17		#include "devices/mflopimg.h"
	17	#include "devices/flopdrv.h"
18	18	#include "formats/ap2_dsk.h"
19	19	#include "machine/6551.h"
20	20	#include "machine/6522via.h"

src/mess/drivers/adam.c

r5704	r5705
191	191	#include "includes/adam.h"
192	192	#include "cpu/m6800/m6800.h"
193	193	#include "devices/cartslot.h"
194		#include "devices/mflopimg.h"
	194	#include "devices/flopdrv.h"
195	195	#include "formats/adam_dsk.h"
196	196
197	197	static ADDRESS_MAP_START( adam_mem, ADDRESS_SPACE_PROGRAM, 8)

src/mess/drivers/mbee.c

r5704	r5705
66	66	#include "cpu/z80/z80.h"
67	67	#include "cpu/z80/z80daisy.h"
68	68	#include "sound/wave.h"
69		#include "devices/mflopimg.h"
	69	#include "devices/flopdrv.h"
70	70	#include "formats/basicdsk.h"
71	71	#include "includes/mbee.h"
72	72

src/mess/drivers/coco.c

r5704	r5705
38	38	#include "formats/coco_dsk.h"
39	39	#include "formats/coco_cas.h"
40	40	#include "devices/printer.h"
41		#include "devices/mflopimg.h"
	41	#include "devices/flopdrv.h"
42	42	#include "devices/cassette.h"
43	43	#include "devices/bitbngr.h"
44	44	#include "devices/snapquik.h"

src/mess/drivers/ti99_8.c

r5704	r5705
169	169	#include "machine/99_dsk.h"
170	170	#include "machine/99_ide.h"
171	171	#include "cpu/tms9900/tms9900.h"
172		#include "devices/mflopimg.h"
	172	#include "devices/flopdrv.h"
173	173	#include "devices/cassette.h"
174	174	#include "devices/cartslot.h"
175	175	#include "machine/smartmed.h"

src/mess/drivers/x1.c

r5704	r5705
153	153
154	154	#include "machine/wd17xx.h"
155	155	#include "devices/cassette.h"
156		#include "devices/mflopimg.h"
	156	#include "devices/flopdrv.h"
157	157	#include "formats/basicdsk.h"
158	158	#include "formats/fm7_dsk.h"
159	159	#include "formats/x1_tap.h"

src/mess/drivers/xor100.c

r5704	r5705
42	42	#include "includes/xor100.h"
43	43	#include "cpu/z80/z80.h"
44	44	#include "formats/basicdsk.h"
45		#include "devices/mflopimg.h"
	45	#include "devices/flopdrv.h"
46	46	#include "devices/cassette.h"
47	47	#include "machine/com8116.h"
48	48	#include "machine/i8255a.h"

src/mess/drivers/tmc600.c

r5704	r5705
81	81
82	82	#include "driver.h"
83	83	#include "machine/ctronics.h"
84		#include "devices/mflopimg.h"
	84	#include "devices/flopdrv.h"
85	85	#include "formats/basicdsk.h"
86	86	#include "devices/cassette.h"
87	87	#include "devices/snapquik.h"

src/mess/drivers/b2m.c

r5704	r5705
15	15	#include "machine/pic8259.h"
16	16	#include "machine/msm8251.h"
17	17	#include "machine/wd17xx.h"
18		#include "devices/mflopimg.h"
	18	#include "devices/flopdrv.h"
19	19	#include "formats/basicdsk.h"
20	20	#include "includes/b2m.h"
21	21

src/mess/drivers/thomson.c

r5704	r5705
75	75	#include "includes/thomson.h"
76	76	#include "machine/6821pia.h"
77	77	#include "machine/ctronics.h"
78		#include "devices/mflopimg.h"
	78	#include "devices/flopdrv.h"
79	79	#include "formats/basicdsk.h"
80	80
81	81	/**************************** common *******************************/

src/mess/drivers/abc80.c

r5704	r5705
87	87	#include "machine/conkort.h"
88	88
89	89	/* Devices */
90		#include "devices/mflopimg.h"
	90	#include "devices/flopdrv.h"
91	91	#include "devices/cassette.h"
92	92	#include "devices/printer.h"
93	93

src/mess/drivers/atarist.c

r5704	r5705
3	3	#include "cpu/m68000/m68000.h"
4	4	#include "cpu/m6800/m6800.h"
5	5	#include "formats/atarist_dsk.h"
6		#include "devices/mflopimg.h"
	6	#include "devices/flopdrv.h"
7	7	#include "devices/cartslot.h"
8	8	#include "machine/ctronics.h"
9	9	#include "includes/serial.h"

src/mess/drivers/sg1000.c

r5704	r5705
66	66	#include "driver.h"
67	67	#include "cpu/z80/z80.h"
68	68	#include "includes/sg1000.h"
69		#include "devices/mflopimg.h"
	69	#include "devices/flopdrv.h"
70	70	#include "formats/basicdsk.h"
71	71	#include "devices/cartslot.h"
72	72	#include "devices/cassette.h"

src/mess/drivers/mikromik.c

r5704	r5705
1	1	#include "driver.h"
2	2	#include "includes/mikromik.h"
3	3	#include "formats/basicdsk.h"
4		#include "devices/mflopimg.h"
	4	#include "devices/flopdrv.h"
5	5	#include "cpu/i8085/i8085.h"
6	6	#include "machine/8237dma.h"
7	7	#include "machine/i8212.h"

src/mess/drivers/pcw.c

r5704	r5705
97	97	// nec765 interface
98	98	#include "machine/nec765.h"
99	99	#include "formats/dsk_dsk.h"
100		#include "devices/mflopimg.h"
	100	#include "devices/flopdrv.h"
101	101	// pcw video hardware
102	102	#include "includes/pcw.h"
103	103	// pcw/pcw16 beeper

src/mess/drivers/osi.c

r5704	r5705
183	183	#include "machine/6821pia.h"
184	184	#include "sound/discrete.h"
185	185	#include "sound/beep.h"
186		#include "devices/mflopimg.h"
	186	#include "devices/flopdrv.h"
187	187	#include "formats/basicdsk.h"
188	188	#include "devices/cassette.h"
189	189

src/mess/drivers/oric.c

r5704	r5705
21	21	#include "sound/wave.h"
22	22	#include "includes/oric.h"
23	23	#include "machine/ctronics.h"
24		#include "devices/mflopimg.h"
	24	#include "devices/flopdrv.h"
25	25	#include "devices/cassette.h"
26	26	#include "formats/oric_dsk.h"
27	27	#include "formats/ap2_dsk.h"

src/mess/drivers/at.c

r5704	r5705
43	43
44	44	#include "machine/pcshare.h"
45	45
46		#include "devices/mflopimg.h"
	46	#include "devices/flopdrv.h"
47	47	#include "devices/harddriv.h"
48	48	#include "formats/pc_dsk.h"
49	49

src/mess/drivers/vector06.c

r5704	r5705
15	15	#include "machine/wd17xx.h"
16	16	#include "devices/cassette.h"
17	17	#include "devices/cartslot.h"
18		#include "devices/mflopimg.h"
	18	#include "devices/flopdrv.h"
19	19	#include "formats/basicdsk.h"
20	20	#include "includes/vector06.h"
21	21

src/mess/drivers/v1050.c

r5704	r5705
113	113	#include "cpu/m6502/m6502.h"
114	114	#include "cpu/mcs48/mcs48.h"
115	115	#include "formats/basicdsk.h"
116		#include "devices/mflopimg.h"
	116	#include "devices/flopdrv.h"
117	117	#include "machine/ctronics.h"
118	118	#include "machine/i8214.h"
119	119	#include "machine/i8255a.h"

src/mess/drivers/ql.c

r5704	r5705
42	42	#include "includes/ql.h"
43	43	#include "cpu/mcs48/mcs48.h"
44	44	#include "cpu/m68000/m68000.h"
45		#include "devices/mflopimg.h"
	45	#include "devices/flopdrv.h"
46	46	#include "formats/basicdsk.h"
47	47	#include "devices/cartslot.h"
48	48	#include "devices/microdrv.h"

src/mess/drivers/abc80x.c

r5704	r5705
80	80	#include "sound/discrete.h"
81	81
82	82	/* Devices */
83		#include "devices/mflopimg.h"
	83	#include "devices/flopdrv.h"
84	84	#include "devices/cassette.h"
85	85	#include "devices/printer.h"
86	86

src/mess/drivers/orion.c

r5704	r5705
16	16	#include "sound/wave.h"
17	17	#include "machine/mc146818.h"
18	18	#include "machine/wd17xx.h"
19		#include "devices/mflopimg.h"
	19	#include "devices/flopdrv.h"
20	20	#include "formats/basicdsk.h"
21	21	#include "devices/cassette.h"
22	22	#include "devices/cartslot.h"

src/mess/drivers/nascom1.c

r5704	r5705
59	59	#include "machine/z80pio.h"
60	60
61	61	/* Devices */
62		#include "devices/mflopimg.h"
	62	#include "devices/flopdrv.h"
63	63	#include "formats/basicdsk.h"
64	64	#include "devices/cartslot.h"
65	65	#include "devices/cassette.h"

src/mess/drivers/newbrain.c

r5704	r5705
9	9	#include "machine/z80sio.h"
10	10	#include "includes/newbrain.h"
11	11	#include "includes/serial.h"
12		#include "devices/mflopimg.h"
	12	#include "devices/flopdrv.h"
13	13	#include "formats/basicdsk.h"
14	14	#include "devices/cassette.h"
15	15	#include "machine/rescap.h"

src/mess/drivers/einstein.c

r5704	r5705
58	58	#include "machine/ctronics.h"
59	59	#include "machine/msm8251.h"
60	60	#include "formats/dsk_dsk.h"
61		#include "devices/mflopimg.h"
	61	#include "devices/flopdrv.h"
62	62	#include "sound/ay8910.h"
63	63	#include "video/mc6845.h"
64	64	#include "rendlay.h"

src/mess/drivers/osborne1.c

r5704	r5705
38	38	#include "cpu/z80/z80.h"
39	39	#include "cpu/z80/z80daisy.h"
40	40	#include "sound/beep.h"
41		#include "devices/mflopimg.h"
	41	#include "devices/flopdrv.h"
42	42	#include "formats/basicdsk.h"
43	43	#include "machine/wd17xx.h"
44	44	#include "machine/6821pia.h"

src/mess/drivers/amstrad.c

r5704	r5705
99	99
100	100	/* Devices */
101	101	#include "formats/dsk_dsk.h"      /* for CPCEMU style disk images */
102		#include "devices/mflopimg.h"
	102	#include "devices/flopdrv.h"
103	103	#include "formats/basicdsk.h"
104	104	#include "includes/msx_slot.h"
105	105	#include "includes/msx.h"  /* MSX floppy device load */

src/mess/drivers/samcoupe.c

r5704	r5705
42	42	#include "sound/speaker.h"
43	43
44	44	/* devices */
45		#include "devices/mflopimg.h"
	45	#include "devices/flopdrv.h"
46	46	#include "formats/coupedsk.h"
47	47	#include "formats/dsk_dsk.h"
48	48

src/mess/drivers/comx35.c

r5704	r5705
15	15	#include "cpu/cdp1802/cdp1802.h"
16	16	#include "sound/cdp1869.h"
17	17	#include "sound/wave.h"
18		#include "devices/mflopimg.h"
	18	#include "devices/flopdrv.h"
19	19	#include "formats/comx35_dsk.h"
20	20	#include "devices/cassette.h"
21	21	#include "devices/printer.h"

src/mess/drivers/trs80.c

r5704	r5705
145	145	#include "sound/speaker.h"
146	146
147	147	/* Devices */
148		#include "devices/mflopimg.h"
	148	#include "devices/flopdrv.h"
149	149	#include "formats/trs_dsk.h"
150	150	#include "devices/cassette.h"
151	151	#include "formats/trs_cas.h"

src/mess/drivers/tiki100.c

r5704	r5705
27	27	#include "includes/tiki100.h"
28	28	#include "cpu/z80/z80.h"
29	29	#include "cpu/z80/z80daisy.h"
30		#include "devices/mflopimg.h"
	30	#include "devices/flopdrv.h"
31	31	#include "formats/basicdsk.h"
32	32	#include "machine/z80ctc.h"
33	33	#include "machine/z80dart.h"

src/mess/drivers/svi318.c

r5704	r5705
18	18	#include "machine/i8255a.h"
19	19	#include "machine/wd17xx.h"
20	20	#include "machine/ctronics.h"
21		#include "devices/mflopimg.h"
	21	#include "devices/flopdrv.h"
22	22	#include "formats/svi_dsk.h"
23	23	#include "devices/cartslot.h"
24	24	#include "devices/cassette.h"

src/mess/drivers/nanos.c

r5704	r5705
13	13	#include "machine/z80sio.h"
14	14	#include "machine/z80ctc.h"
15	15	#include "machine/nec765.h"
16		#include "devices/mflopimg.h"
	16	#include "devices/flopdrv.h"
17	17	#include "formats/basicdsk.h"
18	18
19	19	static const UINT8 *FNT;

src/mess/drivers/fm7.c

r5704	r5705
45	45	#include "devices/cassette.h"
46	46	#include "formats/fm7_cas.h"
47	47	#include "machine/wd17xx.h"
48		#include "devices/mflopimg.h"
	48	#include "devices/flopdrv.h"
49	49	#include "formats/fm7_dsk.h"
50	50	#include "machine/ctronics.h"
51	51

src/mess/drivers/compis.c

r5704	r5705
37	37	#include "machine/ctronics.h"
38	38	#include "includes/compis.h"
39	39	#include "video/i82720.h"
40		#include "devices/mflopimg.h"
	40	#include "devices/flopdrv.h"
41	41	#include "machine/pit8253.h"
42	42	#include "machine/pic8259.h"
43	43	#include "machine/mm58274c.h"

src/mess/drivers/z80ne.c

r5704	r5705
92	92	#include "driver.h"
93	93	#include "cpu/z80/z80.h"
94	94	#include "includes/z80ne.h"
95		#include "devices/mflopimg.h"
	95	#include "devices/flopdrv.h"
96	96	#include "devices/cassette.h"
97	97	#include "formats/z80ne_dsk.h"
98	98

src/mess/drivers/apple2gs.c

r5704	r5705
44	44	#include "cpu/g65816/g65816.h"
45	45	#include "includes/apple2.h"
46	46	#include "machine/ay3600.h"
47		#include "devices/mflopimg.h"
	47	#include "devices/flopdrv.h"
48	48	#include "formats/ap2_dsk.h"
49	49	#include "includes/apple2gs.h"
50	50	#include "devices/sonydriv.h"

src/mess/drivers/nc.c

r5704	r5705
102	102	#include "machine/mc146818.h"   /* for NC200 real time clock */
103	103	#include "machine/tc8521.h"   /* for NC100 real time clock */
104	104	#include "machine/nec765.h"      /* for NC200 disk drive interface */
105		#include "devices/mflopimg.h"   /* for NC200 disk image */
	105	#include "devices/flopdrv.h"   /* for NC200 disk image */
106	106	#include "formats/pc_dsk.h"      /* for NC200 disk image */
107	107	#include "devices/cartslot.h"
108	108	#include "sound/beep.h"

src/mess/drivers/sord.c

r5704	r5705
40	40
41	41	/* FD-5 floppy support */
42	42	#include "machine/8255ppi.h"
43		#include "devices/mflopimg.h"
	43	#include "devices/flopdrv.h"
44	44	#include "formats/basicdsk.h"
45	45	#include "machine/nec765.h"
46	46

src/mess/drivers/bw12.c

r5704	r5705
26	26	#include "driver.h"
27	27	#include "includes/bw12.h"
28	28	#include "cpu/z80/z80.h"
29		#include "devices/mflopimg.h"
	29	#include "devices/flopdrv.h"
30	30	#include "formats/basicdsk.h"
31	31	#include "machine/6821pia.h"
32	32	#include "machine/ctronics.h"

src/mess/drivers/concept.c

r5704	r5705
31	31	#include "driver.h"
32	32	#include "cpu/m68000/m68000.h"
33	33	#include "includes/concept.h"
34		#include "devices/mflopimg.h"
	34	#include "devices/flopdrv.h"
35	35	#include "formats/basicdsk.h"
36	36	#include "devices/harddriv.h"
37	37	#include "machine/mm58274c.h"

src/mess/drivers/pcw16.c

r5704	r5705
103	103
104	104	/* Devices */
105	105	#include "formats/pc_dsk.h"      /* pc disk images */
106		#include "devices/mflopimg.h"
	106	#include "devices/flopdrv.h"
107	107
108	108
109	109	// interrupt counter

src/mess/drivers/ti990_4.c

r5704	r5705
44	44	#else
45	45	#include "video/733_asr.h"
46	46	#endif
47		#include "devices/mflopimg.h"
	47	#include "devices/flopdrv.h"
48	48
49	49	static MACHINE_RESET(ti990_4)
50	50	{

src/mess/drivers/msx.c

r5704	r5705
286	286	#include "machine/ctronics.h"
287	287	#include "includes/msx_slot.h"
288	288	#include "includes/msx.h"
289		#include "devices/mflopimg.h"
	289	#include "devices/flopdrv.h"
290	290	#include "devices/cartslot.h"
291	291	#include "devices/cassette.h"
292	292	#include "formats/fmsx_cas.h"

src/mess/drivers/prof80.c

r5704	r5705
39	39	#include "machine/z80sti.h"
40	40	#include "machine/ctronics.h"
41	41	#include "machine/rescap.h"
42		#include "devices/mflopimg.h"
	42	#include "devices/flopdrv.h"
43	43	#include "formats/basicdsk.h"
44	44
45	45

src/mess/drivers/aquarius.c

r5704	r5705
23	23	#include "cpu/z80/z80.h"
24	24	#include "sound/ay8910.h"
25	25	#include "sound/speaker.h"
26		#include "devices/mflopimg.h"
	26	#include "devices/flopdrv.h"
27	27	#include "formats/basicdsk.h"
28	28	#include "devices/cartslot.h"
29	29	#include "devices/cassette.h"

src/mess/drivers/cgenie.c

r5704	r5705
29	29	#include "driver.h"
30	30	#include "cpu/z80/z80.h"
31	31	#include "includes/cgenie.h"
32		#include "devices/mflopimg.h"
	32	#include "devices/flopdrv.h"
33	33	#include "formats/basicdsk.h"
34	34	#include "devices/cartslot.h"
35	35	#include "devices/cassette.h"

src/mess/drivers/specpls3.c

r5704	r5705
157	157	/* +3 hardware */
158	158	#include "machine/nec765.h"
159	159	#include "formats/dsk_dsk.h"
160		#include "devices/mflopimg.h"
	160	#include "devices/flopdrv.h"
161	161
162	162
163	163	/****************************************************************************************************/

src/mess/drivers/x68k.c

r5704	r5705
128	128	#include "machine/8530scc.h"
129	129	#include "machine/hd63450.h"
130	130	#include "machine/rp5c15.h"
131		#include "devices/mflopimg.h"
	131	#include "devices/flopdrv.h"
132	132	#include "formats/basicdsk.h"
133	133	#include "formats/dim_dsk.h"
134	134	#include "devices/harddriv.h"

src/mess/drivers/kaypro.c

r5704	r5705
41	41	#include "machine/kay_kbd.h"
42	42	#include "sound/beep.h"
43	43	#include "devices/snapquik.h"
44		#include "devices/mflopimg.h"
	44	#include "devices/flopdrv.h"
45	45	#include "formats/basicdsk.h"
46	46	#include "includes/kaypro.h"
47	47

src/mess/drivers/geneve.c

r5704	r5705
212	212	#include "machine/994x_ser.h"
213	213	#include "machine/99_dsk.h"
214	214	#include "machine/99_ide.h"
215		#include "devices/mflopimg.h"
	215	#include "devices/flopdrv.h"
216	216	#include "machine/smartmed.h"
217	217	#include "devices/harddriv.h"
218	218	#include "machine/idectrl.h"

src/mess/drivers/exidy.c

r5704	r5705
146	146	#include "devices/snapquik.h"
147	147	#include "devices/cartslot.h"
148	148	#include "machine/ay31015.h"
149		#include "devices/mflopimg.h"
	149	#include "devices/flopdrv.h"
150	150	#include "formats/basicdsk.h"
151	151	#include "includes/exidy.h"
152	152

src/mess/drivers/pc8801.c

r5704	r5705
88	88	#include "machine/8255ppi.h"
89	89	#include "includes/pc8801.h"
90	90	#include "machine/nec765.h"
91		#include "devices/mflopimg.h"
	91	#include "devices/flopdrv.h"
92	92	#include "formats/fm7_dsk.h"
93	93	#include "sound/2203intf.h"
94	94

src/mess/drivers/bw2.c

r5704	r5705
36	36	#include "machine/msm8251.h"
37	37	#include "machine/wd17xx.h"
38	38	#include "machine/pit8253.h"
39		#include "devices/mflopimg.h"
	39	#include "devices/flopdrv.h"
40	40	#include "formats/basicdsk.h"
41	41	#include "video/msm6255.h"
42	42

src/mess/drivers/enterp.c

r5704	r5705
20	20	#include "audio/dave.h"
21	21	#include "video/epnick.h"
22	22	#include "machine/wd17xx.h"
23		#include "devices/mflopimg.h"
	23	#include "devices/flopdrv.h"
24	24	#include "formats/basicdsk.h"
25	25
26	26	#define ENTERPRISE_XTAL_X1   XTAL_8MHz

src/mess/drivers/atom.c

r5704	r5705
69	69	#include "video/m6847.h"
70	70
71	71	/* Devices */
72		#include "devices/mflopimg.h"
	72	#include "devices/flopdrv.h"
73	73	#include "formats/basicdsk.h"
74	74	#include "devices/cassette.h"
75	75	#include "devices/snapquik.h"

src/mess/drivers/apf.c

r5704	r5705
20	20
21	21	#include "machine/6821pia.h"
22	22	#include "machine/wd17xx.h"
23		#include "devices/mflopimg.h"
	23	#include "devices/flopdrv.h"
24	24	#include "formats/basicdsk.h"
25	25	#include "devices/cassette.h"
26	26	#include "devices/cartslot.h"

src/mess/drivers/partner.c

r5704	r5705
15	15	#include "machine/wd17xx.h"
16	16	#include "video/i8275.h"
17	17	#include "devices/cassette.h"
18		#include "devices/mflopimg.h"
	18	#include "devices/flopdrv.h"
19	19	#include "formats/basicdsk.h"
20	20	#include "formats/rk_cas.h"
21	21	#include "includes/radio86.h"

src/mess/drivers/tmc2000e.c

r5704	r5705
33	33	#include "includes/tmc2000e.h"
34	34	#include "cpu/cdp1802/cdp1802.h"
35	35	#include "devices/printer.h"
36		#include "devices/mflopimg.h"
	36	#include "devices/flopdrv.h"
37	37	#include "formats/basicdsk.h"
38	38	#include "devices/cassette.h"
39	39	#include "video/cdp1864.h"

src/mess/drivers/bebox.c

r5704	r5705
30	30	#include "machine/mpc105.h"
31	31
32	32	/* Devices */
33		#include "devices/mflopimg.h"
	33	#include "devices/flopdrv.h"
34	34	#include "devices/chd_cd.h"
35	35	#include "devices/harddriv.h"
36	36	#include "formats/pc_dsk.h"

src/mess/drivers/elwro800.c

r5704	r5705
33	33
34	34	/* Devices */
35	35	#include "formats/dsk_dsk.h"
36		#include "devices/mflopimg.h"
	36	#include "devices/flopdrv.h"
37	37	#include "devices/cassette.h"
38	38	#include "formats/tzx_cas.h"
39	39

src/mess/drivers/special.c

r5704	r5705
17	17	#include "machine/i8255a.h"
18	18	#include "machine/pit8253.h"
19	19	#include "devices/cassette.h"
20		#include "devices/mflopimg.h"
	20	#include "devices/flopdrv.h"
21	21	#include "formats/basicdsk.h"
22	22	#include "formats/rk_cas.h"
23	23	#include "machine/wd17xx.h"

src/mess/drivers/pyl601.c

r5704	r5705
9	9	#include "driver.h"
10	10	#include "cpu/m6800/m6800.h"
11	11	#include "video/mc6845.h"
12		#include "devices/mflopimg.h"
	12	#include "devices/flopdrv.h"
13	13	#include "formats/basicdsk.h"
14	14	#include "machine/nec765.h"
15	15

src/mess/drivers/apple2.c

r5704	r5705
184	184	#include "cpu/m6502/m6502.h"
185	185	#include "deprecat.h"
186	186	#include "devices/appldriv.h"
187		#include "devices/mflopimg.h"
	187	#include "devices/flopdrv.h"
188	188	#include "formats/ap2_dsk.h"
189	189	#include "includes/apple2.h"
190	190	#include "machine/ay3600.h"

src/mess/drivers/xerox820.c

r5704	r5705
34	34	#include "machine/z80sio.h"
35	35	#include "machine/wd17xx.h"
36	36	#include "machine/com8116.h"
37		#include "devices/mflopimg.h"
	37	#include "devices/flopdrv.h"
38	38	#include "formats/basicdsk.h"
39	39
40	40	INLINE const device_config *get_floppy_image(running_machine *machine, int drive)

src/mess/drivers/ti99_4p.c

r5704	r5705
42	42	#include "machine/994x_ser.h"
43	43	#include "machine/99_dsk.h"
44	44	#include "machine/99_ide.h"
45		#include "devices/mflopimg.h"
	45	#include "devices/flopdrv.h"
46	46	#include "devices/cassette.h"
47	47	#include "machine/smartmed.h"
48	48	#include "devices/harddriv.h"

src/mess/drivers/pc.c

r5704	r5705
146	146	#include "includes/pc.h"
147	147
148	148	#include "machine/pc_hdc.h"
149		#include "devices/mflopimg.h"
	149	#include "devices/flopdrv.h"
150	150	#include "devices/harddriv.h"
151	151	#include "devices/cassette.h"
152	152	#include "devices/cartslot.h"

src/mess/drivers/ti99_4x.c

r5704	r5705
34	34	#include "machine/99_dsk.h"
35	35	#include "machine/99_ide.h"
36	36	#include "machine/99_hsgpl.h"
37		#include "devices/mflopimg.h"
	37	#include "devices/flopdrv.h"
38	38	#include "devices/harddriv.h"
39	39	#include "devices/cassette.h"
40	40	#include "machine/smartmed.h"
r5704	r5705
885	885	/* --- the following bits of info are returned as 64-bit signed integers --- */
886	886	case MESS_DEVINFO_INT_COUNT:                     info->i = 4; break;
887	887
888		/* Used within mflopimg.c. */
889		case MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY:                                  info->i = 1; break;
	888	case MESS_DEVINFO_INT_KEEP_DRIVE_GEOMETRY:                                  info->i = 1; break;
890	889	/* --- the following bits of info are returned as pointers to data or functions --- */
891	890	case MESS_DEVINFO_PTR_FLOPPY_OPTIONS:            info->p = (void *) floppyoptions_ti99; break;
892	891

src/mess/drivers/pk8020.c

r5704	r5705
10	10	#include "driver.h"
11	11	#include "cpu/i8085/i8085.h"
12	12	#include "machine/i8255a.h"
13		#include "devices/mflopimg.h"
	13	#include "devices/flopdrv.h"
14	14	#include "formats/basicdsk.h"
15	15	#include "includes/pk8020.h"
16	16

src/mess/drivers/bbc.c

r5704	r5705
17	17	#include "includes/bbc.h"
18	18	#include "machine/upd7002.h"
19	19	#include "machine/ctronics.h"
20		#include "devices/mflopimg.h"
	20	#include "devices/flopdrv.h"
21	21	#include "formats/basicdsk.h"
22	22	#include "devices/cartslot.h"
23	23	#include "devices/cassette.h"

src/mess/drivers/kc.c

r5704	r5705
27	27
28	28	/* Devices */
29	29	#include "devices/cassette.h"
30		#include "devices/mflopimg.h"
	30	#include "devices/flopdrv.h"
31	31	#include "formats/basicdsk.h"
32	32
33	33	static READ8_HANDLER(kc85_4_port_r)

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team