fdc.c@ 6581

Last change on this file since 6581 was 6318, checked in by vboxsync, 17 years ago
PDMDevHlp*, cosmetics
Property svn:eol-style set to `native`
File size: 95.3 KB

Line
1	#ifdef VBOX
2	/** @file
3	*
4	* VBox storage devices:
5	* Floppy disk controller
6	*/
7
8	/*
9	* Copyright (C) 2006-2007 innotek GmbH
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	* --------------------------------------------------------------------
19	*
20	* This code is based on:
21	*
22	* QEMU Floppy disk emulator (Intel 82078)
23	*
24	* Copyright (c) 2003 Jocelyn Mayer
25	*
26	* Permission is hereby granted, free of charge, to any person obtaining a copy
27	* of this software and associated documentation files (the "Software"), to deal
28	* in the Software without restriction, including without limitation the rights
29	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
30	* copies of the Software, and to permit persons to whom the Software is
31	* furnished to do so, subject to the following conditions:
32	*
33	* The above copyright notice and this permission notice shall be included in
34	* all copies or substantial portions of the Software.
35	*
36	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
37	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
38	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
39	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
40	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
41	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
42	* THE SOFTWARE.
43	*
44	*/
45
46
47	/*******************************************************************************
48	* Header Files *
49	*******************************************************************************/
50	#define LOG_GROUP LOG_GROUP_DEV_FDC
51	#include <VBox/pdmdev.h>
52	#include <iprt/assert.h>
53	#include <iprt/uuid.h>
54	#include <iprt/string.h>
55
56	#include "Builtins.h"
57	#include "../vl_vbox.h"
58
59	#define MAX_FD 2
60
61	#define PDMIBASE_2_FDRIVE(pInterface) \
62	((fdrive_t *)((uintptr_t)(pInterface) - RT_OFFSETOF(fdrive_t, IBase)))
63
64	#define PDMIMOUNTNOTIFY_2_FDRIVE(p) \
65	((fdrive_t *)((uintptr_t)(p) - RT_OFFSETOF(fdrive_t, IMountNotify)))
66
67	#endif /* VBOX */
68
69	#ifndef VBOX
70	#include "vl.h"
71	#endif /* !VBOX */
72
73	/********************************************************/
74	/* debug Floppy devices */
75	/* #define DEBUG_FLOPPY */
76
77	#ifndef VBOX
78	#ifdef DEBUG_FLOPPY
79	#define FLOPPY_DPRINTF(fmt, args...) \
80	do { printf("FLOPPY: " fmt , ##args); } while (0)
81	#endif
82	#else /* !VBOX */
83	# ifdef LOG_ENABLED
84	static void FLOPPY_DPRINTF (const char *fmt, ...)
85	{
86	if (LogIsEnabled ()) {
87	va_list args;
88	va_start (args, fmt);
89	RTLogLogger (NULL, NULL, "floppy: %N", fmt, &args); /* %N - nested va_list * type formatting call. */
90	va_end (args);
91	}
92	}
93	# else
94	DECLINLINE(void) FLOPPY_DPRINTF(const char *pszFmt, ...) {}
95	# endif
96	#endif /* !VBOX */
97
98	#ifndef VBOX
99	#define FLOPPY_ERROR(fmt, args...) \
100	do { printf("FLOPPY ERROR: %s: " fmt, __func__ , ##args); } while (0)
101	#else /* VBOX */
102	# define FLOPPY_ERROR RTLogPrintf
103	#endif /* VBOX */
104
105	#ifdef VBOX
106	typedef struct fdctrl_t fdctrl_t;
107	#endif /* VBOX */
108
109	/********************************************************/
110	/* Floppy drive emulation */
111
112	/* Will always be a fixed parameter for us */
113	#define FD_SECTOR_LEN 512
114	#define FD_SECTOR_SC 2 /* Sector size code */
115
116	/* Floppy disk drive emulation */
117	typedef enum fdisk_type_t {
118	FDRIVE_DISK_288 = 0x01, /* 2.88 MB disk */
119	FDRIVE_DISK_144 = 0x02, /* 1.44 MB disk */
120	FDRIVE_DISK_720 = 0x03, /* 720 kB disk */
121	FDRIVE_DISK_USER = 0x04, /* User defined geometry */
122	FDRIVE_DISK_NONE = 0x05 /* No disk */
123	} fdisk_type_t;
124
125	typedef enum fdrive_type_t {
126	FDRIVE_DRV_144 = 0x00, /* 1.44 MB 3"5 drive */
127	FDRIVE_DRV_288 = 0x01, /* 2.88 MB 3"5 drive */
128	FDRIVE_DRV_120 = 0x02, /* 1.2 MB 5"25 drive */
129	FDRIVE_DRV_NONE = 0x03 /* No drive connected */
130	} fdrive_type_t;
131
132	typedef enum fdrive_flags_t {
133	FDRIVE_MOTOR_ON = 0x01, /* motor on/off */
134	FDRIVE_REVALIDATE = 0x02 /* Revalidated */
135	} fdrive_flags_t;
136
137	typedef enum fdisk_flags_t {
138	FDISK_DBL_SIDES = 0x01
139	} fdisk_flags_t;
140
141	typedef struct fdrive_t {
142	#ifndef VBOX
143	BlockDriverState *bs;
144	#else /* VBOX */
145	/** Pointer to the attached driver's base interface. */
146	R3PTRTYPE(PPDMIBASE) pDrvBase;
147	/** Pointer to the attached driver's block interface. */
148	R3PTRTYPE(PPDMIBLOCK) pDrvBlock;
149	/** Pointer to the attached driver's block bios interface. */
150	R3PTRTYPE(PPDMIBLOCKBIOS) pDrvBlockBios;
151	/** Pointer to the attached driver's mount interface.
152	* This is NULL if the driver isn't a removable unit. */
153	R3PTRTYPE(PPDMIMOUNT) pDrvMount;
154	/** The base interface. */
155	PDMIBASE IBase;
156	/** The block port interface. */
157	PDMIBLOCKPORT IPort;
158	/** The mount notify interface. */
159	PDMIMOUNTNOTIFY IMountNotify;
160	/** The LUN #. */
161	RTUINT iLUN;
162	/** The LED for this LUN. */
163	PDMLED Led;
164	/** The Diskette present/missing flag. */
165	bool fMediaPresent;
166	#endif
167	/* Drive status */
168	fdrive_type_t drive;
169	fdrive_flags_t drflags;
170	uint8_t perpendicular; /* 2.88 MB access mode */
171	/* Position */
172	uint8_t head;
173	uint8_t track;
174	uint8_t sect;
175	/* Last operation status */
176	uint8_t dir; /* Direction */
177	uint8_t rw; /* Read/write */
178	/* Media */
179	fdisk_flags_t flags;
180	uint8_t last_sect; /* Nb sector per track */
181	uint8_t max_track; /* Nb of tracks */
182	uint16_t bps; /* Bytes per sector */
183	uint8_t ro; /* Is read-only */
184	} fdrive_t;
185
186	#ifndef VBOX
187	static void fd_init (fdrive_t drv, BlockDriverState bs)
188	{
189	/* Drive */
190	drv->bs = bs;
191	drv->drive = FDRIVE_DRV_NONE;
192	drv->drflags = 0;
193	drv->perpendicular = 0;
194	/* Disk */
195	drv->last_sect = 0;
196	drv->max_track = 0;
197	}
198	#endif
199
200	static int _fd_sector (uint8_t head, uint8_t track,
201	uint8_t sect, uint8_t last_sect)
202	{
203	return (((track * 2) + head) * last_sect) + sect - 1;
204	}
205
206	/* Returns current position, in sectors, for given drive */
207	static int fd_sector (fdrive_t *drv)
208	{
209	return _fd_sector(drv->head, drv->track, drv->sect, drv->last_sect);
210	}
211
212	static int fd_seek (fdrive_t *drv, uint8_t head, uint8_t track, uint8_t sect,
213	int enable_seek)
214	{
215	uint32_t sector;
216	int ret;
217
218	if (track > drv->max_track \|\|
219	(head != 0 && (drv->flags & FDISK_DBL_SIDES) == 0)) {
220	FLOPPY_DPRINTF("try to read %d %02x %02x (max=%d %d %02x %02x)\n",
221	head, track, sect, 1,
222	(drv->flags & FDISK_DBL_SIDES) == 0 ? 0 : 1,
223	drv->max_track, drv->last_sect);
224	return 2;
225	}
226	if (sect > drv->last_sect) {
227	FLOPPY_DPRINTF("try to read %d %02x %02x (max=%d %d %02x %02x)\n",
228	head, track, sect, 1,
229	(drv->flags & FDISK_DBL_SIDES) == 0 ? 0 : 1,
230	drv->max_track, drv->last_sect);
231	return 3;
232	}
233	sector = _fd_sector(head, track, sect, drv->last_sect);
234	ret = 0;
235	if (sector != fd_sector(drv)) {
236	#if 0
237	if (!enable_seek) {
238	FLOPPY_ERROR("no implicit seek %d %02x %02x (max=%d %02x %02x)\n",
239	head, track, sect, 1, drv->max_track, drv->last_sect);
240	return 4;
241	}
242	#endif
243	drv->head = head;
244	if (drv->track != track)
245	ret = 1;
246	drv->track = track;
247	drv->sect = sect;
248	}
249
250	return ret;
251	}
252
253	/* Set drive back to track 0 */
254	static void fd_recalibrate (fdrive_t *drv)
255	{
256	FLOPPY_DPRINTF("recalibrate\n");
257	drv->head = 0;
258	drv->track = 0;
259	drv->sect = 1;
260	drv->dir = 1;
261	drv->rw = 0;
262	}
263
264	/* Recognize floppy formats */
265	typedef struct fd_format_t {
266	fdrive_type_t drive;
267	fdisk_type_t disk;
268	uint8_t last_sect;
269	uint8_t max_track;
270	uint8_t max_head;
271	const char *str;
272	} fd_format_t;
273
274	static fd_format_t fd_formats[] = {
275	/* First entry is default format */
276	/* 1.44 MB 3"1/2 floppy disks */
277	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 18, 80, 1, "1.44 MB 3\"1/2", },
278	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 20, 80, 1, "1.6 MB 3\"1/2", },
279	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 21, 80, 1, "1.68 MB 3\"1/2", },
280	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 21, 82, 1, "1.72 MB 3\"1/2", },
281	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 21, 83, 1, "1.74 MB 3\"1/2", },
282	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 22, 80, 1, "1.76 MB 3\"1/2", },
283	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 23, 80, 1, "1.84 MB 3\"1/2", },
284	{ FDRIVE_DRV_144, FDRIVE_DISK_144, 24, 80, 1, "1.92 MB 3\"1/2", },
285	/* 2.88 MB 3"1/2 floppy disks */
286	{ FDRIVE_DRV_288, FDRIVE_DISK_288, 36, 80, 1, "2.88 MB 3\"1/2", },
287	{ FDRIVE_DRV_288, FDRIVE_DISK_288, 39, 80, 1, "3.12 MB 3\"1/2", },
288	{ FDRIVE_DRV_288, FDRIVE_DISK_288, 40, 80, 1, "3.2 MB 3\"1/2", },
289	{ FDRIVE_DRV_288, FDRIVE_DISK_288, 44, 80, 1, "3.52 MB 3\"1/2", },
290	{ FDRIVE_DRV_288, FDRIVE_DISK_288, 48, 80, 1, "3.84 MB 3\"1/2", },
291	/* 720 kB 3"1/2 floppy disks */
292	{ FDRIVE_DRV_144, FDRIVE_DISK_720, 9, 80, 1, "720 kB 3\"1/2", },
293	{ FDRIVE_DRV_144, FDRIVE_DISK_720, 10, 80, 1, "800 kB 3\"1/2", },
294	{ FDRIVE_DRV_144, FDRIVE_DISK_720, 10, 82, 1, "820 kB 3\"1/2", },
295	{ FDRIVE_DRV_144, FDRIVE_DISK_720, 10, 83, 1, "830 kB 3\"1/2", },
296	{ FDRIVE_DRV_144, FDRIVE_DISK_720, 13, 80, 1, "1.04 MB 3\"1/2", },
297	{ FDRIVE_DRV_144, FDRIVE_DISK_720, 14, 80, 1, "1.12 MB 3\"1/2", },
298	/* 1.2 MB 5"1/4 floppy disks */
299	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 15, 80, 1, "1.2 kB 5\"1/4", },
300	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 18, 80, 1, "1.44 MB 5\"1/4", },
301	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 18, 82, 1, "1.48 MB 5\"1/4", },
302	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 18, 83, 1, "1.49 MB 5\"1/4", },
303	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 20, 80, 1, "1.6 MB 5\"1/4", },
304	/* 720 kB 5"1/4 floppy disks */
305	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 9, 80, 1, "720 kB 5\"1/4", },
306	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 11, 80, 1, "880 kB 5\"1/4", },
307	/* 360 kB 5"1/4 floppy disks */
308	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 9, 40, 1, "360 kB 5\"1/4", },
309	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 9, 40, 0, "180 kB 5\"1/4", },
310	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 10, 41, 1, "410 kB 5\"1/4", },
311	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 10, 42, 1, "420 kB 5\"1/4", },
312	/* 320 kB 5"1/4 floppy disks */
313	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 8, 40, 1, "320 kB 5\"1/4", },
314	{ FDRIVE_DRV_120, FDRIVE_DISK_288, 8, 40, 0, "160 kB 5\"1/4", },
315	/* 360 kB must match 5"1/4 better than 3"1/2... */
316	{ FDRIVE_DRV_144, FDRIVE_DISK_720, 9, 80, 0, "360 kB 3\"1/2", },
317	/* end */
318	{ FDRIVE_DRV_NONE, FDRIVE_DISK_NONE, -1, -1, 0, NULL, },
319	};
320
321	/* Revalidate a disk drive after a disk change */
322	static void fd_revalidate (fdrive_t *drv)
323	{
324	fd_format_t *parse;
325	int64_t nb_sectors, size;
326	int i, first_match, match;
327	int nb_heads, max_track, last_sect, ro;
328
329	FLOPPY_DPRINTF("revalidate\n");
330	drv->drflags &= ~FDRIVE_REVALIDATE;
331	#ifndef VBOX
332	if (drv->bs != NULL && bdrv_is_inserted(drv->bs)) {
333	ro = bdrv_is_read_only(drv->bs);
334	bdrv_get_geometry_hint(drv->bs, &nb_heads, &max_track, &last_sect);
335	#else /* VBOX */
336	/** @todo / /* @todo r=bird: todo what exactly? */
337	if (drv->pDrvBlock
338	&& drv->pDrvMount
339	&& drv->pDrvMount->pfnIsMounted (drv->pDrvMount)) {
340	ro = drv->pDrvBlock->pfnIsReadOnly (drv->pDrvBlock);
341	nb_heads = 0;
342	max_track = 0;
343	last_sect = 0;
344	#endif /* VBOX */
345	if (nb_heads != 0 && max_track != 0 && last_sect != 0) {
346	FLOPPY_DPRINTF("User defined disk (%d %d %d)",
347	nb_heads - 1, max_track, last_sect);
348	} else {
349	#ifndef VBOX
350	bdrv_get_geometry(drv->bs, &nb_sectors);
351	#else /* VBOX */
352	/* @todo / /* @todo r=bird: todo what exactly?!?!? */
353	{
354	uint64_t size = drv->pDrvBlock->pfnGetSize (drv->pDrvBlock);
355	nb_sectors = size / 512;
356	}
357	#endif /* VBOX */
358	match = -1;
359	first_match = -1;
360	for (i = 0;; i++) {
361	parse = &fd_formats[i];
362	if (parse->drive == FDRIVE_DRV_NONE)
363	break;
364	if (drv->drive == parse->drive \|\|
365	drv->drive == FDRIVE_DRV_NONE) {
366	size = (parse->max_head + 1) * parse->max_track *
367	parse->last_sect;
368	if (nb_sectors == size) {
369	match = i;
370	break;
371	}
372	if (first_match == -1)
373	first_match = i;
374	}
375	}
376	if (match == -1) {
377	if (first_match == -1)
378	match = 1;
379	else
380	match = first_match;
381	parse = &fd_formats[match];
382	}
383	nb_heads = parse->max_head + 1;
384	max_track = parse->max_track;
385	last_sect = parse->last_sect;
386	drv->drive = parse->drive;
387	FLOPPY_DPRINTF("%s floppy disk (%d h %d t %d s) %s\n", parse->str,
388	nb_heads, max_track, last_sect, ro ? "ro" : "rw");
389	}
390	if (nb_heads == 1) {
391	drv->flags &= ~FDISK_DBL_SIDES;
392	} else {
393	drv->flags \|= FDISK_DBL_SIDES;
394	}
395	drv->max_track = max_track;
396	drv->last_sect = last_sect;
397	drv->ro = ro;
398	#ifdef VBOX
399	drv->fMediaPresent = true;
400	#endif
401	} else {
402	FLOPPY_DPRINTF("No disk in drive\n");
403	drv->last_sect = 0;
404	drv->max_track = 0;
405	drv->flags &= ~FDISK_DBL_SIDES;
406	#ifdef VBOX
407	drv->fMediaPresent = false;
408	#endif
409	}
410	drv->drflags \|= FDRIVE_REVALIDATE;
411	}
412
413	/* Motor control */
414	static void fd_start (fdrive_t *drv)
415	{
416	drv->drflags \|= FDRIVE_MOTOR_ON;
417	}
418
419	static void fd_stop (fdrive_t *drv)
420	{
421	drv->drflags &= ~FDRIVE_MOTOR_ON;
422	}
423
424	/* Re-initialise a drives (motor off, repositioned) */
425	static void fd_reset (fdrive_t *drv)
426	{
427	fd_stop(drv);
428	fd_recalibrate(drv);
429	}
430
431	/********************************************************/
432	/* Intel 82078 floppy disk controller emulation */
433
434	#define target_ulong uint32_t
435	static void fdctrl_reset (fdctrl_t *fdctrl, int do_irq);
436	static void fdctrl_reset_fifo (fdctrl_t *fdctrl);
437	#ifndef VBOX
438	static int fdctrl_transfer_handler (void *opaque, int nchan, int dma_pos, int dma_len);
439	#else /* VBOX: */
440	static DECLCALLBACK(uint32_t) fdctrl_transfer_handler (PPDMDEVINS pDevIns,
441	void *opaque,
442	unsigned nchan,
443	uint32_t dma_pos,
444	uint32_t dma_len);
445	#endif /* VBOX */
446	static void fdctrl_raise_irq (fdctrl_t *fdctrl, uint8_t status);
447	static void fdctrl_result_timer(void *opaque);
448
449	static uint32_t fdctrl_read_statusB (fdctrl_t *fdctrl);
450	static uint32_t fdctrl_read_dor (fdctrl_t *fdctrl);
451	static void fdctrl_write_dor (fdctrl_t *fdctrl, uint32_t value);
452	static uint32_t fdctrl_read_tape (fdctrl_t *fdctrl);
453	static void fdctrl_write_tape (fdctrl_t *fdctrl, uint32_t value);
454	static uint32_t fdctrl_read_main_status (fdctrl_t *fdctrl);
455	static void fdctrl_write_rate (fdctrl_t *fdctrl, uint32_t value);
456	static uint32_t fdctrl_read_data (fdctrl_t *fdctrl);
457	static void fdctrl_write_data (fdctrl_t *fdctrl, uint32_t value);
458	static uint32_t fdctrl_read_dir (fdctrl_t *fdctrl);
459
460	enum {
461	FD_CTRL_ACTIVE = 0x01, /* XXX: suppress that */
462	FD_CTRL_RESET = 0x02,
463	FD_CTRL_SLEEP = 0x04, /* XXX: suppress that */
464	FD_CTRL_BUSY = 0x08, /* dma transfer in progress */
465	FD_CTRL_INTR = 0x10
466	};
467
468	enum {
469	FD_DIR_WRITE = 0,
470	FD_DIR_READ = 1,
471	FD_DIR_SCANE = 2,
472	FD_DIR_SCANL = 3,
473	FD_DIR_SCANH = 4
474	};
475
476	enum {
477	FD_STATE_CMD = 0x00,
478	FD_STATE_STATUS = 0x01,
479	FD_STATE_DATA = 0x02,
480	FD_STATE_STATE = 0x03,
481	FD_STATE_MULTI = 0x10,
482	FD_STATE_SEEK = 0x20,
483	FD_STATE_FORMAT = 0x40
484	};
485
486	#define FD_STATE(state) ((state) & FD_STATE_STATE)
487	#define FD_SET_STATE(state, new_state) \
488	do { (state) = ((state) & ~FD_STATE_STATE) \| (new_state); } while (0)
489	#define FD_MULTI_TRACK(state) ((state) & FD_STATE_MULTI)
490	#define FD_DID_SEEK(state) ((state) & FD_STATE_SEEK)
491	#define FD_FORMAT_CMD(state) ((state) & FD_STATE_FORMAT)
492
493	struct fdctrl_t {
494	#ifndef VBOX
495	fdctrl_t *fdctrl;
496	#endif
497	/* Controller's identification */
498	uint8_t version;
499	/* HW */
500	#ifndef VBOX
501	int irq_lvl;
502	int dma_chann;
503	#else
504	uint8_t irq_lvl;
505	uint8_t dma_chann;
506	#endif
507	uint32_t io_base;
508	/* Controller state */
509	QEMUTimer *result_timer;
510	uint8_t state;
511	uint8_t dma_en;
512	uint8_t cur_drv;
513	uint8_t bootsel;
514	/* Command FIFO */
515	uint8_t fifo[FD_SECTOR_LEN];
516	uint32_t data_pos;
517	uint32_t data_len;
518	uint8_t data_state;
519	uint8_t data_dir;
520	uint8_t int_status;
521	uint8_t eot; /* last wanted sector */
522	/* States kept only to be returned back */
523	/* Timers state */
524	uint8_t timer0;
525	uint8_t timer1;
526	/* precompensation */
527	uint8_t precomp_trk;
528	uint8_t config;
529	uint8_t lock;
530	/* Power down config (also with status regB access mode */
531	uint8_t pwrd;
532	/* Floppy drives */
533	fdrive_t drives[2];
534	#ifdef VBOX
535	/** Pointer to device instance. */
536	PPDMDEVINS pDevIns;
537
538	/** Status Port - The base interface. */
539	PDMIBASE IBaseStatus;
540	/** Status Port - The Leds interface. */
541	PDMILEDPORTS ILeds;
542	/** Status Port - The Partner of ILeds. */
543	PPDMILEDCONNECTORS pLedsConnector;
544	#endif
545	};
546
547	static uint32_t fdctrl_read (void *opaque, uint32_t reg)
548	{
549	fdctrl_t *fdctrl = opaque;
550	uint32_t retval;
551
552	switch (reg & 0x07) {
553	case 0x01:
554	retval = fdctrl_read_statusB(fdctrl);
555	break;
556	case 0x02:
557	retval = fdctrl_read_dor(fdctrl);
558	break;
559	case 0x03:
560	retval = fdctrl_read_tape(fdctrl);
561	break;
562	case 0x04:
563	retval = fdctrl_read_main_status(fdctrl);
564	break;
565	case 0x05:
566	retval = fdctrl_read_data(fdctrl);
567	break;
568	case 0x07:
569	retval = fdctrl_read_dir(fdctrl);
570	break;
571	default:
572	retval = (uint32_t)(-1);
573	break;
574	}
575	FLOPPY_DPRINTF("read reg%d: 0x%02x\n", reg & 7, retval);
576
577	return retval;
578	}
579
580	static void fdctrl_write (void *opaque, uint32_t reg, uint32_t value)
581	{
582	fdctrl_t *fdctrl = opaque;
583
584	FLOPPY_DPRINTF("write reg%d: 0x%02x\n", reg & 7, value);
585
586	switch (reg & 0x07) {
587	case 0x02:
588	fdctrl_write_dor(fdctrl, value);
589	break;
590	case 0x03:
591	fdctrl_write_tape(fdctrl, value);
592	break;
593	case 0x04:
594	fdctrl_write_rate(fdctrl, value);
595	break;
596	case 0x05:
597	fdctrl_write_data(fdctrl, value);
598	break;
599	default:
600	break;
601	}
602	}
603
604	#ifndef VBOX
605	static void fd_change_cb (void *opaque)
606	{
607	fdrive_t *drv = opaque;
608
609	FLOPPY_DPRINTF("disk change\n");
610	fd_revalidate(drv);
611	#if 0
612	fd_recalibrate(drv);
613	fdctrl_reset_fifo(drv->fdctrl);
614	fdctrl_raise_irq(drv->fdctrl, 0x20);
615	#endif
616	}
617
618	#else /* VBOX */
619	/**
620	* Called when a media is mounted.
621	*
622	* @param pInterface Pointer to the interface structure
623	* containing the called function pointer.
624	*/
625	static DECLCALLBACK(void) fdMountNotify(PPDMIMOUNTNOTIFY pInterface)
626	{
627	fdrive_t *drv = PDMIMOUNTNOTIFY_2_FDRIVE (pInterface);
628	LogFlow(("fdMountNotify:\n"));
629	fd_revalidate (drv);
630	}
631
632	/**
633	* Called when a media is unmounted
634	* @param pInterface Pointer to the interface structure containing the called function pointer.
635	*/
636	static DECLCALLBACK(void) fdUnmountNotify(PPDMIMOUNTNOTIFY pInterface)
637	{
638	fdrive_t *drv = PDMIMOUNTNOTIFY_2_FDRIVE (pInterface);
639	LogFlow(("fdUnmountNotify:\n"));
640	fd_revalidate (drv);
641	}
642	#endif
643
644	#ifndef VBOX
645	fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
646	uint32_t io_base,
647	BlockDriverState **fds)
648	{
649	fdctrl_t *fdctrl;
650	/* // int io_mem; */
651	int i;
652
653	FLOPPY_DPRINTF("init controller\n");
654	fdctrl = qemu_mallocz(sizeof(fdctrl_t));
655	if (!fdctrl)
656	return NULL;
657	fdctrl->result_timer = qemu_new_timer(vm_clock,
658	fdctrl_result_timer, fdctrl);
659
660	fdctrl->version = 0x90; /* Intel 82078 controller */
661	fdctrl->irq_lvl = irq_lvl;
662	fdctrl->dma_chann = dma_chann;
663	fdctrl->io_base = io_base;
664	fdctrl->config = 0x60; /* Implicit seek, polling & FIFO enabled */
665	if (fdctrl->dma_chann != -1) {
666	fdctrl->dma_en = 1;
667	DMA_register_channel(dma_chann, &fdctrl_transfer_handler, fdctrl);
668	} else {
669	fdctrl->dma_en = 0;
670	}
671	for (i = 0; i < 2; i++) {
672	fd_init(&fdctrl->drives[i], fds[i]);
673	if (fds[i]) {
674	bdrv_set_change_cb(fds[i],
675	&fd_change_cb, &fdctrl->drives[i]);
676	}
677	}
678	fdctrl_reset(fdctrl, 0);
679	fdctrl->state = FD_CTRL_ACTIVE;
680	if (mem_mapped) {
681	FLOPPY_ERROR("memory mapped floppy not supported by now !\n");
682	#if 0
683	io_mem = cpu_register_io_memory(0, fdctrl_mem_read, fdctrl_mem_write);
684	cpu_register_physical_memory(base, 0x08, io_mem);
685	#endif
686	} else {
687	register_ioport_read(io_base + 0x01, 5, 1, &fdctrl_read, fdctrl);
688	register_ioport_read(io_base + 0x07, 1, 1, &fdctrl_read, fdctrl);
689	register_ioport_write(io_base + 0x01, 5, 1, &fdctrl_write, fdctrl);
690	register_ioport_write(io_base + 0x07, 1, 1, &fdctrl_write, fdctrl);
691	}
692	for (i = 0; i < 2; i++) {
693	fd_revalidate(&fdctrl->drives[i]);
694	}
695
696	return fdctrl;
697	}
698
699	/* XXX: may change if moved to bdrv */
700	int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num)
701	{
702	return fdctrl->drives[drive_num].drive;
703	}
704	#endif
705
706	/* Change IRQ state */
707	static void fdctrl_reset_irq (fdctrl_t *fdctrl)
708	{
709	FLOPPY_DPRINTF("Reset interrupt\n");
710	#ifdef VBOX
711	PDMDevHlpISASetIrq (fdctrl->pDevIns, fdctrl->irq_lvl, 0);
712	#else
713	pic_set_irq(fdctrl->irq_lvl, 0);
714	#endif
715	fdctrl->state &= ~FD_CTRL_INTR;
716	}
717
718	static void fdctrl_raise_irq (fdctrl_t *fdctrl, uint8_t status)
719	{
720	if (~(fdctrl->state & FD_CTRL_INTR)) {
721	#ifdef VBOX
722	PDMDevHlpISASetIrq (fdctrl->pDevIns, fdctrl->irq_lvl, 1);
723	#else
724	pic_set_irq(fdctrl->irq_lvl, 1);
725	#endif
726	fdctrl->state \|= FD_CTRL_INTR;
727	}
728	FLOPPY_DPRINTF("Set interrupt status to 0x%02x\n", status);
729	fdctrl->int_status = status;
730	}
731
732	/* Reset controller */
733	static void fdctrl_reset (fdctrl_t *fdctrl, int do_irq)
734	{
735	int i;
736
737	FLOPPY_DPRINTF("reset controller\n");
738	fdctrl_reset_irq(fdctrl);
739	/* Initialise controller */
740	fdctrl->cur_drv = 0;
741	/* FIFO state */
742	fdctrl->data_pos = 0;
743	fdctrl->data_len = 0;
744	fdctrl->data_state = FD_STATE_CMD;
745	fdctrl->data_dir = FD_DIR_WRITE;
746	for (i = 0; i < MAX_FD; i++)
747	fd_reset(&fdctrl->drives[i]);
748	fdctrl_reset_fifo(fdctrl);
749	if (do_irq)
750	fdctrl_raise_irq(fdctrl, 0xc0);
751	}
752
753	static inline fdrive_t drv0 (fdctrl_t fdctrl)
754	{
755	return &fdctrl->drives[fdctrl->bootsel];
756	}
757
758	static inline fdrive_t drv1 (fdctrl_t fdctrl)
759	{
760	return &fdctrl->drives[1 - fdctrl->bootsel];
761	}
762
763	static fdrive_t get_cur_drv (fdctrl_t fdctrl)
764	{
765	return fdctrl->cur_drv == 0 ? drv0(fdctrl) : drv1(fdctrl);
766	}
767
768	/* Status B register : 0x01 (read-only) */
769	static uint32_t fdctrl_read_statusB (fdctrl_t *fdctrl)
770	{
771	FLOPPY_DPRINTF("status register: 0x00\n");
772	return 0;
773	}
774
775	/* Digital output register : 0x02 */
776	static uint32_t fdctrl_read_dor (fdctrl_t *fdctrl)
777	{
778	uint32_t retval = 0;
779
780	/* Drive motors state indicators */
781	#ifndef VBOX
782	if (drv0(fdctrl)->drflags & FDRIVE_MOTOR_ON)
783	retval \|= 1 << 5;
784	if (drv1(fdctrl)->drflags & FDRIVE_MOTOR_ON)
785	retval \|= 1 << 4;
786	#else
787	/* bit4: 0 = drive 0 motor off/1 = on */
788	if (drv0(fdctrl)->drflags & FDRIVE_MOTOR_ON)
789	retval \|= RT_BIT(4);
790	/* bit5: 0 = drive 1 motor off/1 = on */
791	if (drv1(fdctrl)->drflags & FDRIVE_MOTOR_ON)
792	retval \|= RT_BIT(5);
793	#endif
794	/* DMA enable */
795	retval \|= fdctrl->dma_en << 3;
796	/* Reset indicator */
797	retval \|= (fdctrl->state & FD_CTRL_RESET) == 0 ? 0x04 : 0;
798	/* Selected drive */
799	retval \|= fdctrl->cur_drv;
800	FLOPPY_DPRINTF("digital output register: 0x%02x\n", retval);
801
802	return retval;
803	}
804
805	static void fdctrl_write_dor (fdctrl_t *fdctrl, uint32_t value)
806	{
807	/* Reset mode */
808	if (fdctrl->state & FD_CTRL_RESET) {
809	if (!(value & 0x04)) {
810	FLOPPY_DPRINTF("Floppy controller in RESET state !\n");
811	return;
812	}
813	}
814	FLOPPY_DPRINTF("digital output register set to 0x%02x\n", value);
815	/* Drive motors state indicators */
816	if (value & 0x20)
817	fd_start(drv1(fdctrl));
818	else
819	fd_stop(drv1(fdctrl));
820	if (value & 0x10)
821	fd_start(drv0(fdctrl));
822	else
823	fd_stop(drv0(fdctrl));
824	/* DMA enable */
825	#if 0
826	if (fdctrl->dma_chann != -1)
827	fdctrl->dma_en = 1 - ((value >> 3) & 1);
828	#endif
829	/* Reset */
830	if (!(value & 0x04)) {
831	if (!(fdctrl->state & FD_CTRL_RESET)) {
832	FLOPPY_DPRINTF("controller enter RESET state\n");
833	fdctrl->state \|= FD_CTRL_RESET;
834	}
835	} else {
836	if (fdctrl->state & FD_CTRL_RESET) {
837	FLOPPY_DPRINTF("controller out of RESET state\n");
838	fdctrl_reset(fdctrl, 1);
839	fdctrl->state &= ~(FD_CTRL_RESET \| FD_CTRL_SLEEP);
840	}
841	}
842	/* Selected drive */
843	fdctrl->cur_drv = value & 1;
844	}
845
846	/* Tape drive register : 0x03 */
847	static uint32_t fdctrl_read_tape (fdctrl_t *fdctrl)
848	{
849	uint32_t retval = 0;
850
851	/* Disk boot selection indicator */
852	retval \|= fdctrl->bootsel << 2;
853	/* Tape indicators: never allowed */
854	FLOPPY_DPRINTF("tape drive register: 0x%02x\n", retval);
855
856	return retval;
857	}
858
859	static void fdctrl_write_tape (fdctrl_t *fdctrl, uint32_t value)
860	{
861	/* Reset mode */
862	if (fdctrl->state & FD_CTRL_RESET) {
863	FLOPPY_DPRINTF("Floppy controller in RESET state !\n");
864	return;
865	}
866	FLOPPY_DPRINTF("tape drive register set to 0x%02x\n", value);
867	/* Disk boot selection indicator */
868	fdctrl->bootsel = (value >> 2) & 1;
869	/* Tape indicators: never allow */
870	}
871
872	/* Main status register : 0x04 (read) */
873	static uint32_t fdctrl_read_main_status (fdctrl_t *fdctrl)
874	{
875	uint32_t retval = 0;
876
877	fdctrl->state &= ~(FD_CTRL_SLEEP \| FD_CTRL_RESET);
878	if (!(fdctrl->state & FD_CTRL_BUSY)) {
879	/* Data transfer allowed */
880	retval \|= 0x80;
881	/* Data transfer direction indicator */
882	if (fdctrl->data_dir == FD_DIR_READ)
883	retval \|= 0x40;
884	}
885	/* Should handle 0x20 for SPECIFY command */
886	/* Command busy indicator */
887	if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA \|\|
888	FD_STATE(fdctrl->data_state) == FD_STATE_STATUS)
889	retval \|= 0x10;
890	FLOPPY_DPRINTF("main status register: 0x%02x\n", retval);
891
892	return retval;
893	}
894
895	/* Data select rate register : 0x04 (write) */
896	static void fdctrl_write_rate (fdctrl_t *fdctrl, uint32_t value)
897	{
898	/* Reset mode */
899	if (fdctrl->state & FD_CTRL_RESET) {
900	FLOPPY_DPRINTF("Floppy controller in RESET state !\n");
901	return;
902	}
903	FLOPPY_DPRINTF("select rate register set to 0x%02x\n", value);
904	/* Reset: autoclear */
905	if (value & 0x80) {
906	fdctrl->state \|= FD_CTRL_RESET;
907	fdctrl_reset(fdctrl, 1);
908	fdctrl->state &= ~FD_CTRL_RESET;
909	}
910	if (value & 0x40) {
911	fdctrl->state \|= FD_CTRL_SLEEP;
912	fdctrl_reset(fdctrl, 1);
913	}
914	/* // fdctrl.precomp = (value >> 2) & 0x07; */
915	}
916
917	/* Digital input register : 0x07 (read-only) */
918	static uint32_t fdctrl_read_dir (fdctrl_t *fdctrl)
919	{
920	uint32_t retval = 0;
921
922	#ifndef VBOX
923	if (drv0(fdctrl)->drflags & FDRIVE_REVALIDATE \|\|
924	drv1(fdctrl)->drflags & FDRIVE_REVALIDATE)
925	#else
926	fdrive_t *cur_drv = get_cur_drv(fdctrl);
927	if ( drv0(fdctrl)->drflags & FDRIVE_REVALIDATE
928	\|\| drv1(fdctrl)->drflags & FDRIVE_REVALIDATE
929	\|\| !cur_drv->fMediaPresent)
930	#endif
931	retval \|= 0x80;
932	if (retval != 0)
933	FLOPPY_DPRINTF("Floppy digital input register: 0x%02x\n", retval);
934	drv0(fdctrl)->drflags &= ~FDRIVE_REVALIDATE;
935	drv1(fdctrl)->drflags &= ~FDRIVE_REVALIDATE;
936
937	return retval;
938	}
939
940	/* FIFO state control */
941	static void fdctrl_reset_fifo (fdctrl_t *fdctrl)
942	{
943	fdctrl->data_dir = FD_DIR_WRITE;
944	fdctrl->data_pos = 0;
945	FD_SET_STATE(fdctrl->data_state, FD_STATE_CMD);
946	}
947
948	/* Set FIFO status for the host to read */
949	static void fdctrl_set_fifo (fdctrl_t *fdctrl, int fifo_len, int do_irq)
950	{
951	fdctrl->data_dir = FD_DIR_READ;
952	fdctrl->data_len = fifo_len;
953	fdctrl->data_pos = 0;
954	FD_SET_STATE(fdctrl->data_state, FD_STATE_STATUS);
955	if (do_irq)
956	fdctrl_raise_irq(fdctrl, 0x00);
957	}
958
959	/* Set an error: unimplemented/unknown command */
960	static void fdctrl_unimplemented (fdctrl_t *fdctrl)
961	{
962	#if 0
963	fdrive_t *cur_drv;
964
965	cur_drv = get_cur_drv(fdctrl);
966	fdctrl->fifo[0] = 0x60 \| (cur_drv->head << 2) \| fdctrl->cur_drv;
967	fdctrl->fifo[1] = 0x00;
968	fdctrl->fifo[2] = 0x00;
969	fdctrl_set_fifo(fdctrl, 3, 1);
970	#else
971	/* // fdctrl_reset_fifo(fdctrl); */
972	fdctrl->fifo[0] = 0x80;
973	fdctrl_set_fifo(fdctrl, 1, 0);
974	#endif
975	}
976
977	/* Callback for transfer end (stop or abort) */
978	static void fdctrl_stop_transfer (fdctrl_t *fdctrl, uint8_t status0,
979	uint8_t status1, uint8_t status2)
980	{
981	fdrive_t *cur_drv;
982
983	cur_drv = get_cur_drv(fdctrl);
984	FLOPPY_DPRINTF("transfer status: %02x %02x %02x (%02x)\n",
985	status0, status1, status2,
986	status0 \| (cur_drv->head << 2) \| fdctrl->cur_drv);
987	fdctrl->fifo[0] = status0 \| (cur_drv->head << 2) \| fdctrl->cur_drv;
988	fdctrl->fifo[1] = status1;
989	fdctrl->fifo[2] = status2;
990	fdctrl->fifo[3] = cur_drv->track;
991	fdctrl->fifo[4] = cur_drv->head;
992	fdctrl->fifo[5] = cur_drv->sect;
993	fdctrl->fifo[6] = FD_SECTOR_SC;
994	fdctrl->data_dir = FD_DIR_READ;
995	if (fdctrl->state & FD_CTRL_BUSY) {
996	#ifdef VBOX
997	PDMDevHlpDMASetDREQ (fdctrl->pDevIns, fdctrl->dma_chann, 0);
998	#else
999	DMA_release_DREQ(fdctrl->dma_chann);
1000	#endif
1001	fdctrl->state &= ~FD_CTRL_BUSY;
1002	}
1003	fdctrl_set_fifo(fdctrl, 7, 1);
1004	}
1005
1006	/* Prepare a data transfer (either DMA or FIFO) */
1007	static void fdctrl_start_transfer (fdctrl_t *fdctrl, int direction)
1008	{
1009	fdrive_t *cur_drv;
1010	uint8_t kh, kt, ks;
1011	int did_seek;
1012
1013	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
1014	cur_drv = get_cur_drv(fdctrl);
1015	kt = fdctrl->fifo[2];
1016	kh = fdctrl->fifo[3];
1017	ks = fdctrl->fifo[4];
1018	FLOPPY_DPRINTF("Start transfer at %d %d %02x %02x (%d)\n",
1019	fdctrl->cur_drv, kh, kt, ks,
1020	_fd_sector(kh, kt, ks, cur_drv->last_sect));
1021	did_seek = 0;
1022	switch (fd_seek(cur_drv, kh, kt, ks, fdctrl->config & 0x40)) {
1023	case 2:
1024	/* sect too big */
1025	fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00);
1026	fdctrl->fifo[3] = kt;
1027	fdctrl->fifo[4] = kh;
1028	fdctrl->fifo[5] = ks;
1029	return;
1030	case 3:
1031	/* track too big */
1032	fdctrl_stop_transfer(fdctrl, 0x40, 0x80, 0x00);
1033	fdctrl->fifo[3] = kt;
1034	fdctrl->fifo[4] = kh;
1035	fdctrl->fifo[5] = ks;
1036	return;
1037	case 4:
1038	/* No seek enabled */
1039	fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00);
1040	fdctrl->fifo[3] = kt;
1041	fdctrl->fifo[4] = kh;
1042	fdctrl->fifo[5] = ks;
1043	return;
1044	case 1:
1045	did_seek = 1;
1046	break;
1047	default:
1048	break;
1049	}
1050	/* Set the FIFO state */
1051	fdctrl->data_dir = direction;
1052	fdctrl->data_pos = 0;
1053	FD_SET_STATE(fdctrl->data_state, FD_STATE_DATA); /* FIFO ready for data */
1054	if (fdctrl->fifo[0] & 0x80)
1055	fdctrl->data_state \|= FD_STATE_MULTI;
1056	else
1057	fdctrl->data_state &= ~FD_STATE_MULTI;
1058	if (did_seek)
1059	fdctrl->data_state \|= FD_STATE_SEEK;
1060	else
1061	fdctrl->data_state &= ~FD_STATE_SEEK;
1062	if (fdctrl->fifo[5] == 00) {
1063	fdctrl->data_len = fdctrl->fifo[8];
1064	} else {
1065	int tmp;
1066	fdctrl->data_len = 128 << fdctrl->fifo[5];
1067	tmp = (cur_drv->last_sect - ks + 1);
1068	if (fdctrl->fifo[0] & 0x80)
1069	tmp += cur_drv->last_sect;
1070	fdctrl->data_len *= tmp;
1071	}
1072	fdctrl->eot = fdctrl->fifo[6];
1073	if (fdctrl->dma_en) {
1074	int dma_mode;
1075	/* DMA transfer are enabled. Check if DMA channel is well programmed */
1076	#ifndef VBOX
1077	dma_mode = DMA_get_channel_mode(fdctrl->dma_chann);
1078	#else
1079	dma_mode = PDMDevHlpDMAGetChannelMode (fdctrl->pDevIns, fdctrl->dma_chann);
1080	#endif
1081	dma_mode = (dma_mode >> 2) & 3;
1082	FLOPPY_DPRINTF("dma_mode=%d direction=%d (%d - %d)\n",
1083	dma_mode, direction,
1084	(128 << fdctrl->fifo[5]) *
1085	(cur_drv->last_sect - ks + 1), fdctrl->data_len);
1086	if (((direction == FD_DIR_SCANE \|\| direction == FD_DIR_SCANL \|\|
1087	direction == FD_DIR_SCANH) && dma_mode == 0) \|\|
1088	(direction == FD_DIR_WRITE && dma_mode == 2) \|\|
1089	(direction == FD_DIR_READ && dma_mode == 1)) {
1090	/* No access is allowed until DMA transfer has completed */
1091	fdctrl->state \|= FD_CTRL_BUSY;
1092	/* Now, we just have to wait for the DMA controller to
1093	* recall us...
1094	*/
1095	#ifndef VBOX
1096	DMA_hold_DREQ(fdctrl->dma_chann);
1097	DMA_schedule(fdctrl->dma_chann);
1098	#else
1099	PDMDevHlpDMASetDREQ (fdctrl->pDevIns, fdctrl->dma_chann, 1);
1100	PDMDevHlpDMASchedule (fdctrl->pDevIns);
1101	#endif
1102	return;
1103	} else {
1104	FLOPPY_ERROR("dma_mode=%d direction=%d\n", dma_mode, direction);
1105	}
1106	}
1107	FLOPPY_DPRINTF("start non-DMA transfer\n");
1108	/* IO based transfer: calculate len */
1109	fdctrl_raise_irq(fdctrl, 0x00);
1110
1111	return;
1112	}
1113
1114	/* Prepare a transfer of deleted data */
1115	static void fdctrl_start_transfer_del (fdctrl_t *fdctrl, int direction)
1116	{
1117	/* We don't handle deleted data,
1118	* so we don't return ANYTHING
1119	*/
1120	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1121	}
1122
1123	#if 0
1124	#include <stdio.h>
1125	#include <stdlib.h>
1126
1127	static FILE * f;
1128	static void dump (void *p, size_t len)
1129	{
1130	size_t n;
1131
1132	if (!f) {
1133	f = fopen ("dump", "wb");
1134	if (!f)
1135	exit (0);
1136	}
1137
1138	n = fwrite (p, len, 1, f);
1139	if (n != 1) {
1140	AssertMsgFailed (("failed to dump\n"));
1141	exit (0);
1142	}
1143	}
1144	#else
1145	#define dump(a,b) do { } while (0)
1146	#endif
1147
1148	/* handlers for DMA transfers */
1149	#ifdef VBOX
1150	static DECLCALLBACK(uint32_t) fdctrl_transfer_handler (PPDMDEVINS pDevIns,
1151	void *opaque,
1152	unsigned nchan,
1153	uint32_t dma_pos,
1154	uint32_t dma_len)
1155	#else
1156	static int fdctrl_transfer_handler (void *opaque, int nchan,
1157	int dma_pos, int dma_len)
1158	#endif
1159	{
1160	fdctrl_t *fdctrl;
1161	fdrive_t *cur_drv;
1162	#ifdef VBOX
1163	int rc;
1164	uint32_t len, start_pos, rel_pos;
1165	#else
1166	int len, start_pos, rel_pos;
1167	#endif
1168	uint8_t status0 = 0x00, status1 = 0x00, status2 = 0x00;
1169
1170	fdctrl = opaque;
1171	if (!(fdctrl->state & FD_CTRL_BUSY)) {
1172	FLOPPY_DPRINTF("Not in DMA transfer mode !\n");
1173	return 0;
1174	}
1175	cur_drv = get_cur_drv(fdctrl);
1176	if (fdctrl->data_dir == FD_DIR_SCANE \|\| fdctrl->data_dir == FD_DIR_SCANL \|\|
1177	fdctrl->data_dir == FD_DIR_SCANH)
1178	status2 = 0x04;
1179	if (dma_len > fdctrl->data_len)
1180	dma_len = fdctrl->data_len;
1181	#ifndef VBOX
1182	if (cur_drv->bs == NULL) {
1183	#else /* !VBOX */
1184	if (cur_drv->pDrvBlock == NULL) {
1185	#endif
1186	if (fdctrl->data_dir == FD_DIR_WRITE)
1187	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1188	else
1189	fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00);
1190	len = 0;
1191	goto transfer_error;
1192	}
1193	rel_pos = fdctrl->data_pos % FD_SECTOR_LEN;
1194	for (start_pos = fdctrl->data_pos; fdctrl->data_pos < dma_len;) {
1195	len = dma_len - fdctrl->data_pos;
1196	if (len + rel_pos > FD_SECTOR_LEN)
1197	len = FD_SECTOR_LEN - rel_pos;
1198	FLOPPY_DPRINTF("copy %d bytes (%d %d %d) %d pos %d %02x "
1199	"(%d-0x%08x 0x%08x)\n", len, dma_len, fdctrl->data_pos,
1200	fdctrl->data_len, fdctrl->cur_drv, cur_drv->head,
1201	cur_drv->track, cur_drv->sect, fd_sector(cur_drv),
1202	fd_sector(cur_drv) * 512);
1203	if (fdctrl->data_dir != FD_DIR_WRITE \|\|
1204	len < FD_SECTOR_LEN \|\| rel_pos != 0) {
1205	/* READ & SCAN commands and realign to a sector for WRITE */
1206	#ifndef VBOX
1207	if (bdrv_read(cur_drv->bs, fd_sector(cur_drv),
1208	fdctrl->fifo, 1) < 0) {
1209	FLOPPY_DPRINTF("Floppy: error getting sector %d\n",
1210	fd_sector(cur_drv));
1211	/* Sure, image size is too small... */
1212	memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
1213	}
1214	#else
1215	cur_drv->Led.Asserted.s.fReading
1216	= cur_drv->Led.Actual.s.fReading = 1;
1217
1218	rc = cur_drv->pDrvBlock->pfnRead (
1219	cur_drv->pDrvBlock,
1220	fd_sector (cur_drv) * 512,
1221	fdctrl->fifo,
1222	1 * 512
1223	);
1224
1225	cur_drv->Led.Actual.s.fReading = 0;
1226
1227	if (VBOX_FAILURE (rc)) {
1228	AssertMsgFailed (
1229	("Floppy: error getting sector %d, rc = %Vrc",
1230	fd_sector (cur_drv), rc));
1231	memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
1232	}
1233	#endif
1234	}
1235	switch (fdctrl->data_dir) {
1236	case FD_DIR_READ:
1237	/* READ commands */
1238	#ifdef VBOX
1239	{
1240	uint32_t read;
1241	int rc = PDMDevHlpDMAWriteMemory(fdctrl->pDevIns, nchan,
1242	fdctrl->fifo + rel_pos,
1243	fdctrl->data_pos,
1244	len, &read);
1245	dump (fdctrl->fifo + rel_pos, len);
1246	AssertMsgRC (rc, ("DMAWriteMemory -> %Vrc\n", rc));
1247	}
1248	#else
1249	DMA_write_memory (nchan, fdctrl->fifo + rel_pos,
1250	fdctrl->data_pos, len);
1251	#endif
1252	/* cpu_physical_memory_write(addr + fdctrl->data_pos, */
1253	/* fdctrl->fifo + rel_pos, len); */
1254	break;
1255	case FD_DIR_WRITE:
1256	/* WRITE commands */
1257	#ifdef VBOX
1258	{
1259	uint32_t written;
1260	int rc = PDMDevHlpDMAReadMemory(fdctrl->pDevIns, nchan,
1261	fdctrl->fifo + rel_pos,
1262	fdctrl->data_pos,
1263	len, &written);
1264	AssertMsgRC (rc, ("DMAReadMemory -> %Vrc\n", rc));
1265	}
1266	#else
1267	DMA_read_memory (nchan, fdctrl->fifo + rel_pos,
1268	fdctrl->data_pos, len);
1269	#endif
1270	/* cpu_physical_memory_read(addr + fdctrl->data_pos, */
1271	/* fdctrl->fifo + rel_pos, len); */
1272	#ifndef VBOX
1273	if (bdrv_write(cur_drv->bs, fd_sector(cur_drv),
1274	fdctrl->fifo, 1) < 0) {
1275	FLOPPY_ERROR("writting sector %d\n", fd_sector(cur_drv));
1276	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1277	goto transfer_error;
1278	}
1279	#else /* VBOX */
1280	cur_drv->Led.Asserted.s.fWriting
1281	= cur_drv->Led.Actual.s.fWriting = 1;
1282
1283	rc = cur_drv->pDrvBlock->pfnWrite (
1284	cur_drv->pDrvBlock,
1285	fd_sector (cur_drv) * 512,
1286	fdctrl->fifo,
1287	1 * 512
1288	);
1289
1290	cur_drv->Led.Actual.s.fWriting = 0;
1291
1292	if (VBOX_FAILURE (rc)) {
1293	AssertMsgFailed (("Floppy: error writing sector %d. rc=%Vrc",
1294	fd_sector (cur_drv), rc));
1295	fdctrl_stop_transfer (fdctrl, 0x60, 0x00, 0x00);
1296	goto transfer_error;
1297	}
1298	#endif
1299	break;
1300	default:
1301	/* SCAN commands */
1302	{
1303	uint8_t tmpbuf[FD_SECTOR_LEN];
1304	int ret;
1305	#ifdef VBOX
1306	int rc;
1307	uint32_t read;
1308
1309	rc = PDMDevHlpDMAReadMemory (fdctrl->pDevIns, nchan, tmpbuf,
1310	fdctrl->data_pos, len, &read);
1311	AssertMsg (VBOX_SUCCESS (rc), ("DMAReadMemory -> %Vrc\n", rc));
1312	#else
1313	DMA_read_memory (nchan, tmpbuf, fdctrl->data_pos, len);
1314	#endif
1315	/* cpu_physical_memory_read(addr + fdctrl->data_pos, */
1316	/* tmpbuf, len); */
1317	ret = memcmp(tmpbuf, fdctrl->fifo + rel_pos, len);
1318	if (ret == 0) {
1319	status2 = 0x08;
1320	goto end_transfer;
1321	}
1322	if ((ret < 0 && fdctrl->data_dir == FD_DIR_SCANL) \|\|
1323	(ret > 0 && fdctrl->data_dir == FD_DIR_SCANH)) {
1324	status2 = 0x00;
1325	goto end_transfer;
1326	}
1327	}
1328	break;
1329	}
1330	fdctrl->data_pos += len;
1331	rel_pos = fdctrl->data_pos % FD_SECTOR_LEN;
1332	if (rel_pos == 0) {
1333	/* Seek to next sector */
1334	FLOPPY_DPRINTF("seek to next sector (%d %02x %02x => %d) (%d)\n",
1335	cur_drv->head, cur_drv->track, cur_drv->sect,
1336	fd_sector(cur_drv),
1337	fdctrl->data_pos - len);
1338	/* XXX: cur_drv->sect >= cur_drv->last_sect should be an
1339	error in fact */
1340	if (cur_drv->sect >= cur_drv->last_sect \|\|
1341	cur_drv->sect == fdctrl->eot) {
1342	cur_drv->sect = 1;
1343	if (FD_MULTI_TRACK(fdctrl->data_state)) {
1344	if (cur_drv->head == 0 &&
1345	(cur_drv->flags & FDISK_DBL_SIDES) != 0) {
1346	cur_drv->head = 1;
1347	} else {
1348	cur_drv->head = 0;
1349	cur_drv->track++;
1350	if ((cur_drv->flags & FDISK_DBL_SIDES) == 0)
1351	break;
1352	}
1353	} else {
1354	cur_drv->track++;
1355	break;
1356	}
1357	FLOPPY_DPRINTF("seek to next track (%d %02x %02x => %d)\n",
1358	cur_drv->head, cur_drv->track,
1359	cur_drv->sect, fd_sector(cur_drv));
1360	} else {
1361	cur_drv->sect++;
1362	}
1363	}
1364	}
1365	end_transfer:
1366	len = fdctrl->data_pos - start_pos;
1367	FLOPPY_DPRINTF("end transfer %d %d %d\n",
1368	fdctrl->data_pos, len, fdctrl->data_len);
1369	if (fdctrl->data_dir == FD_DIR_SCANE \|\|
1370	fdctrl->data_dir == FD_DIR_SCANL \|\|
1371	fdctrl->data_dir == FD_DIR_SCANH)
1372	status2 = 0x08;
1373	if (FD_DID_SEEK(fdctrl->data_state))
1374	status0 \|= 0x20;
1375	fdctrl->data_len -= len;
1376	/* if (fdctrl->data_len == 0) */
1377	fdctrl_stop_transfer(fdctrl, status0, status1, status2);
1378	transfer_error:
1379
1380	return len;
1381	}
1382
1383	#if 0
1384	{
1385	fdctrl_t *fdctrl;
1386	fdrive_t *cur_drv;
1387	int len, start_pos, rel_pos;
1388	uint8_t status0 = 0x00, status1 = 0x00, status2 = 0x00;
1389
1390	fdctrl = opaque;
1391	if (!(fdctrl->state & FD_CTRL_BUSY)) {
1392	FLOPPY_DPRINTF("Not in DMA transfer mode !\n");
1393	return 0;
1394	}
1395	cur_drv = get_cur_drv(fdctrl);
1396	if (fdctrl->data_dir == FD_DIR_SCANE \|\| fdctrl->data_dir == FD_DIR_SCANL \|\|
1397	fdctrl->data_dir == FD_DIR_SCANH)
1398	status2 = 0x04;
1399	if (size > fdctrl->data_len)
1400	size = fdctrl->data_len;
1401	#ifndef VBOX
1402	if (cur_drv->bs == NULL) {
1403	#else
1404	if (cur_drv->pDrvBase == NULL) {
1405	#endif
1406	if (fdctrl->data_dir == FD_DIR_WRITE)
1407	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1408	else
1409	fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00);
1410	len = 0;
1411	goto transfer_error;
1412	}
1413	rel_pos = fdctrl->data_pos % FD_SECTOR_LEN;
1414	for (start_pos = fdctrl->data_pos; fdctrl->data_pos < size;) {
1415	len = size - fdctrl->data_pos;
1416	if (len + rel_pos > FD_SECTOR_LEN)
1417	len = FD_SECTOR_LEN - rel_pos;
1418	FLOPPY_DPRINTF("copy %d bytes (%d %d %d) %d pos %d %02x %02x "
1419	"(%d-0x%08x 0x%08x)\n", len, size, fdctrl->data_pos,
1420	fdctrl->data_len, fdctrl->cur_drv, cur_drv->head,
1421	cur_drv->track, cur_drv->sect, fd_sector(cur_drv),
1422	fd_sector(cur_drv) * 512, addr);
1423	if (fdctrl->data_dir != FD_DIR_WRITE \|\|
1424	len < FD_SECTOR_LEN \|\| rel_pos != 0) {
1425	/* READ & SCAN commands and realign to a sector for WRITE */
1426	#ifndef VBOX
1427	if (bdrv_read(cur_drv->bs, fd_sector(cur_drv),
1428	fdctrl->fifo, 1) < 0) {
1429	FLOPPY_DPRINTF("Floppy: error getting sector %d\n",
1430	fd_sector(cur_drv));
1431	/* Sure, image size is too small... */
1432	memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
1433	}
1434	#else
1435	int rc;
1436
1437	cur_drv->Led.Asserted.s.fReading
1438	= cur_drv->Led.Actual.s.fReading = 1;
1439
1440	rc = cur_drv->pDrvBlock->pfnRead (
1441	cur_drv->pDrvBlock,
1442	fd_sector (cur_drv) * 512,
1443	fdctrl->fifo,
1444	1 * 512
1445	);
1446
1447	cur_drv->Led.Actual.s.fReading = 0;
1448
1449	if (VBOX_FAILURE (rc)) {
1450	AssertMsgFailed (
1451	("Floppy: error getting sector %d. rc=%Vrc\n",
1452	fd_sector(cur_drv), rc));
1453	/* Sure, image size is too small... */
1454	memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
1455	}
1456	/* p_fd_activity = 1; /
1457	#endif
1458	}
1459	switch (fdctrl->data_dir) {
1460	case FD_DIR_READ:
1461	/* READ commands */
1462	#ifdef VBOX
1463	PDMDevHlpPhysWrite (fdctrl->pDevIns, addr + fdctrl->data_pos,
1464	fdctrl->fifo + rel_pos, len);
1465	#else
1466	cpu_physical_memory_write(addr + fdctrl->data_pos,
1467	fdctrl->fifo + rel_pos, len);
1468	#endif
1469	break;
1470	case FD_DIR_WRITE:
1471	/* WRITE commands */
1472	#ifdef VBOX
1473	{
1474	int rc;
1475
1476	PDMDevHlpPhysRead (fdctrl->pDevIns, addr + fdctrl->data_pos,
1477	fdctrl->fifo + rel_pos, len);
1478
1479	cur_drv->Led.Asserted.s.fWriting
1480	= cur_drv->Led.Actual.s.fWriting = 1;
1481
1482	rc = cur_drv->pDrvBlock->pfnWrite (
1483	cur_drv->pDrvBlock,
1484	fd_sector (cur_drv) * 512,
1485	fdctrl->fifo,
1486	1 * 512
1487	);
1488
1489	cur_drv->Led.Actual.s.fWriting = 0;
1490
1491	if (VBOX_FAILURE (rc)) {
1492	AssertMsgFailed (
1493	("Floppy: error writting sector %d. rc=%Vrc\n",
1494	fd_sector(cur_drv), rc));
1495	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1496	goto transfer_error;
1497	}
1498	}
1499	/* p_fd_activity = 2; /
1500	#else /* !VBOX */
1501	cpu_physical_memory_read(addr + fdctrl->data_pos,
1502	fdctrl->fifo + rel_pos, len);
1503	if (bdrv_write(cur_drv->bs, fd_sector(cur_drv),
1504	fdctrl->fifo, 1) < 0) {
1505	FLOPPY_ERROR("writting sector %d\n", fd_sector(cur_drv));
1506	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1507	goto transfer_error;
1508	}
1509	#endif
1510	break;
1511	default:
1512	/* SCAN commands */
1513	{
1514	uint8_t tmpbuf[FD_SECTOR_LEN];
1515	int ret;
1516	#ifdef VBOX
1517	PDMDevHlpPhysRead (fdctrl->pDevIns, addr + fdctrl->data_pos,
1518	tmpbuf, len);
1519	#else
1520	cpu_physical_memory_read(addr + fdctrl->data_pos,
1521	tmpbuf, len);
1522	#endif
1523	ret = memcmp(tmpbuf, fdctrl->fifo + rel_pos, len);
1524	if (ret == 0) {
1525	status2 = 0x08;
1526	goto end_transfer;
1527	}
1528	if ((ret < 0 && fdctrl->data_dir == FD_DIR_SCANL) \|\|
1529	(ret > 0 && fdctrl->data_dir == FD_DIR_SCANH)) {
1530	status2 = 0x00;
1531	goto end_transfer;
1532	}
1533	}
1534	break;
1535	}
1536	fdctrl->data_pos += len;
1537	rel_pos = fdctrl->data_pos % FD_SECTOR_LEN;
1538	if (rel_pos == 0) {
1539	/* Seek to next sector */
1540	FLOPPY_DPRINTF("seek to next sector (%d %02x %02x => %d) (%d)\n",
1541	cur_drv->head, cur_drv->track, cur_drv->sect,
1542	fd_sector(cur_drv),
1543	fdctrl->data_pos - size);
1544	/* XXX: cur_drv->sect >= cur_drv->last_sect should be an
1545	error in fact */
1546	if (cur_drv->sect >= cur_drv->last_sect \|\|
1547	cur_drv->sect == fdctrl->eot) {
1548	cur_drv->sect = 1;
1549	if (FD_MULTI_TRACK(fdctrl->data_state)) {
1550	if (cur_drv->head == 0 &&
1551	(cur_drv->flags & FDISK_DBL_SIDES) != 0) {
1552	cur_drv->head = 1;
1553	} else {
1554	cur_drv->head = 0;
1555	cur_drv->track++;
1556	if ((cur_drv->flags & FDISK_DBL_SIDES) == 0)
1557	break;
1558	}
1559	} else {
1560	cur_drv->track++;
1561	break;
1562	}
1563	FLOPPY_DPRINTF("seek to next track (%d %02x %02x => %d)\n",
1564	cur_drv->head, cur_drv->track,
1565	cur_drv->sect, fd_sector(cur_drv));
1566	} else {
1567	cur_drv->sect++;
1568	}
1569	}
1570	}
1571	end_transfer:
1572	len = fdctrl->data_pos - start_pos;
1573	FLOPPY_DPRINTF("end transfer %d %d %d\n",
1574	fdctrl->data_pos, len, fdctrl->data_len);
1575	if (fdctrl->data_dir == FD_DIR_SCANE \|\|
1576	fdctrl->data_dir == FD_DIR_SCANL \|\|
1577	fdctrl->data_dir == FD_DIR_SCANH)
1578	status2 = 0x08;
1579	if (FD_DID_SEEK(fdctrl->data_state))
1580	status0 \|= 0x20;
1581	fdctrl->data_len -= len;
1582	/* // if (fdctrl->data_len == 0) */
1583	fdctrl_stop_transfer(fdctrl, status0, status1, status2);
1584	transfer_error:
1585
1586	return len;
1587	}
1588	#endif
1589
1590	/* Data register : 0x05 */
1591	static uint32_t fdctrl_read_data (fdctrl_t *fdctrl)
1592	{
1593	fdrive_t *cur_drv;
1594	uint32_t retval = 0;
1595	int pos, len;
1596	#ifdef VBOX
1597	int rc;
1598	#endif
1599
1600	cur_drv = get_cur_drv(fdctrl);
1601	fdctrl->state &= ~FD_CTRL_SLEEP;
1602	if (FD_STATE(fdctrl->data_state) == FD_STATE_CMD) {
1603	FLOPPY_ERROR("can't read data in CMD state\n");
1604	return 0;
1605	}
1606	pos = fdctrl->data_pos;
1607	if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA) {
1608	pos %= FD_SECTOR_LEN;
1609	if (pos == 0) {
1610	len = fdctrl->data_len - fdctrl->data_pos;
1611	if (len > FD_SECTOR_LEN)
1612	len = FD_SECTOR_LEN;
1613	#ifdef VBOX
1614	cur_drv->Led.Asserted.s.fReading
1615	= cur_drv->Led.Actual.s.fReading = 1;
1616
1617	rc = cur_drv->pDrvBlock->pfnRead (
1618	cur_drv->pDrvBlock,
1619	fd_sector (cur_drv) * 512,
1620	fdctrl->fifo,
1621	len * 512
1622	);
1623
1624	cur_drv->Led.Actual.s.fReading = 0;
1625
1626	if (VBOX_FAILURE (rc)) {
1627	AssertMsgFailed (
1628	("Floppy: Failure to read sector %d. rc=%Vrc",
1629	fd_sector (cur_drv), rc));
1630	}
1631	#else
1632	bdrv_read(cur_drv->bs, fd_sector(cur_drv),
1633	fdctrl->fifo, len);
1634	#endif
1635	}
1636	}
1637	retval = fdctrl->fifo[pos];
1638	if (++fdctrl->data_pos == fdctrl->data_len) {
1639	fdctrl->data_pos = 0;
1640	/* Switch from transfer mode to status mode
1641	* then from status mode to command mode
1642	*/
1643	if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA) {
1644	fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00);
1645	} else {
1646	fdctrl_reset_fifo(fdctrl);
1647	fdctrl_reset_irq(fdctrl);
1648	}
1649	}
1650	FLOPPY_DPRINTF("data register: 0x%02x\n", retval);
1651
1652	return retval;
1653	}
1654
1655	static void fdctrl_format_sector (fdctrl_t *fdctrl)
1656	{
1657	fdrive_t *cur_drv;
1658	uint8_t kh, kt, ks;
1659	int did_seek;
1660	#ifdef VBOX
1661	int ok = 0, rc;
1662	#endif
1663
1664	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
1665	cur_drv = get_cur_drv(fdctrl);
1666	kt = fdctrl->fifo[6];
1667	kh = fdctrl->fifo[7];
1668	ks = fdctrl->fifo[8];
1669	FLOPPY_DPRINTF("format sector at %d %d %02x %02x (%d)\n",
1670	fdctrl->cur_drv, kh, kt, ks,
1671	_fd_sector(kh, kt, ks, cur_drv->last_sect));
1672	did_seek = 0;
1673	switch (fd_seek(cur_drv, kh, kt, ks, fdctrl->config & 0x40)) {
1674	case 2:
1675	/* sect too big */
1676	fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00);
1677	fdctrl->fifo[3] = kt;
1678	fdctrl->fifo[4] = kh;
1679	fdctrl->fifo[5] = ks;
1680	return;
1681	case 3:
1682	/* track too big */
1683	fdctrl_stop_transfer(fdctrl, 0x40, 0x80, 0x00);
1684	fdctrl->fifo[3] = kt;
1685	fdctrl->fifo[4] = kh;
1686	fdctrl->fifo[5] = ks;
1687	return;
1688	case 4:
1689	/* No seek enabled */
1690	fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00);
1691	fdctrl->fifo[3] = kt;
1692	fdctrl->fifo[4] = kh;
1693	fdctrl->fifo[5] = ks;
1694	return;
1695	case 1:
1696	did_seek = 1;
1697	fdctrl->data_state \|= FD_STATE_SEEK;
1698	break;
1699	default:
1700	break;
1701	}
1702	memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
1703	#ifdef VBOX
1704	/* p_fd_activity = 2; /
1705	if (cur_drv->pDrvBlock) {
1706	cur_drv->Led.Asserted.s.fWriting = cur_drv->Led.Actual.s.fWriting = 1;
1707
1708	rc = cur_drv->pDrvBlock->pfnWrite (
1709	cur_drv->pDrvBlock,
1710	fd_sector (cur_drv) * 512,
1711	fdctrl->fifo,
1712	1 * 512
1713	);
1714
1715	cur_drv->Led.Actual.s.fWriting = 0;
1716
1717	if (VBOX_FAILURE (rc)) {
1718	AssertMsgFailed (("Floppy: error formating sector %d. rc=%Vrc\n",
1719	fd_sector (cur_drv), rc));
1720	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1721	}
1722	else {
1723	ok = 1;
1724	}
1725	}
1726	if (ok) {
1727	#else
1728	if (cur_drv->bs == NULL \|\|
1729	bdrv_write(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) {
1730	FLOPPY_ERROR("formating sector %d\n", fd_sector(cur_drv));
1731	fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00);
1732	} else {
1733	#endif
1734	if (cur_drv->sect == cur_drv->last_sect) {
1735	fdctrl->data_state &= ~FD_STATE_FORMAT;
1736	/* Last sector done */
1737	if (FD_DID_SEEK(fdctrl->data_state))
1738	fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00);
1739	else
1740	fdctrl_stop_transfer(fdctrl, 0x00, 0x00, 0x00);
1741	} else {
1742	/* More to do */
1743	fdctrl->data_pos = 0;
1744	fdctrl->data_len = 4;
1745	}
1746	}
1747	}
1748
1749	static void fdctrl_write_data (fdctrl_t *fdctrl, uint32_t value)
1750	{
1751	fdrive_t *cur_drv;
1752
1753	cur_drv = get_cur_drv(fdctrl);
1754	/* Reset mode */
1755	if (fdctrl->state & FD_CTRL_RESET) {
1756	FLOPPY_DPRINTF("Floppy controller in RESET state !\n");
1757	return;
1758	}
1759	fdctrl->state &= ~FD_CTRL_SLEEP;
1760	if (FD_STATE(fdctrl->data_state) == FD_STATE_STATUS) {
1761	FLOPPY_ERROR("can't write data in status mode\n");
1762	return;
1763	}
1764	/* Is it write command time ? */
1765	if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA) {
1766	/* FIFO data write */
1767	fdctrl->fifo[fdctrl->data_pos++] = value;
1768	if (fdctrl->data_pos % FD_SECTOR_LEN == (FD_SECTOR_LEN - 1) \|\|
1769	fdctrl->data_pos == fdctrl->data_len) {
1770	#ifdef VBOX
1771	int rc;
1772	/* p_fd_activity = 2; /
1773	cur_drv->Led.Asserted.s.fWriting
1774	= cur_drv->Led.Actual.s.fWriting = 1;
1775
1776	rc = cur_drv->pDrvBlock->pfnWrite (
1777	cur_drv->pDrvBlock,
1778	fd_sector (cur_drv) * 512,
1779	fdctrl->fifo,
1780	FD_SECTOR_LEN * 512
1781	);
1782
1783	cur_drv->Led.Actual.s.fWriting = 0;
1784
1785	if (VBOX_FAILURE (rc)) {
1786	AssertMsgFailed (
1787	("Floppy: failed to write sector %d. rc=%Vrc\n",
1788	fd_sector (cur_drv), rc));
1789	}
1790	#else
1791	bdrv_write(cur_drv->bs, fd_sector(cur_drv),
1792	fdctrl->fifo, FD_SECTOR_LEN);
1793	#endif
1794	}
1795	/* Switch from transfer mode to status mode
1796	* then from status mode to command mode
1797	*/
1798	if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA)
1799	fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00);
1800	return;
1801	}
1802	if (fdctrl->data_pos == 0) {
1803	/* Command */
1804	switch (value & 0x5F) {
1805	case 0x46:
1806	/* READ variants */
1807	FLOPPY_DPRINTF("READ command\n");
1808	/* 8 parameters cmd */
1809	fdctrl->data_len = 9;
1810	goto enqueue;
1811	case 0x4C:
1812	/* READ_DELETED variants */
1813	FLOPPY_DPRINTF("READ_DELETED command\n");
1814	/* 8 parameters cmd */
1815	fdctrl->data_len = 9;
1816	goto enqueue;
1817	case 0x50:
1818	/* SCAN_EQUAL variants */
1819	FLOPPY_DPRINTF("SCAN_EQUAL command\n");
1820	/* 8 parameters cmd */
1821	fdctrl->data_len = 9;
1822	goto enqueue;
1823	case 0x56:
1824	/* VERIFY variants */
1825	FLOPPY_DPRINTF("VERIFY command\n");
1826	/* 8 parameters cmd */
1827	fdctrl->data_len = 9;
1828	goto enqueue;
1829	case 0x59:
1830	/* SCAN_LOW_OR_EQUAL variants */
1831	FLOPPY_DPRINTF("SCAN_LOW_OR_EQUAL command\n");
1832	/* 8 parameters cmd */
1833	fdctrl->data_len = 9;
1834	goto enqueue;
1835	case 0x5D:
1836	/* SCAN_HIGH_OR_EQUAL variants */
1837	FLOPPY_DPRINTF("SCAN_HIGH_OR_EQUAL command\n");
1838	/* 8 parameters cmd */
1839	fdctrl->data_len = 9;
1840	goto enqueue;
1841	default:
1842	break;
1843	}
1844	switch (value & 0x7F) {
1845	case 0x45:
1846	/* WRITE variants */
1847	FLOPPY_DPRINTF("WRITE command\n");
1848	/* 8 parameters cmd */
1849	fdctrl->data_len = 9;
1850	goto enqueue;
1851	case 0x49:
1852	/* WRITE_DELETED variants */
1853	FLOPPY_DPRINTF("WRITE_DELETED command\n");
1854	/* 8 parameters cmd */
1855	fdctrl->data_len = 9;
1856	goto enqueue;
1857	default:
1858	break;
1859	}
1860	switch (value) {
1861	case 0x03:
1862	/* SPECIFY */
1863	FLOPPY_DPRINTF("SPECIFY command\n");
1864	/* 1 parameter cmd */
1865	fdctrl->data_len = 3;
1866	goto enqueue;
1867	case 0x04:
1868	/* SENSE_DRIVE_STATUS */
1869	FLOPPY_DPRINTF("SENSE_DRIVE_STATUS command\n");
1870	/* 1 parameter cmd */
1871	fdctrl->data_len = 2;
1872	goto enqueue;
1873	case 0x07:
1874	/* RECALIBRATE */
1875	FLOPPY_DPRINTF("RECALIBRATE command\n");
1876	/* 1 parameter cmd */
1877	fdctrl->data_len = 2;
1878	goto enqueue;
1879	case 0x08:
1880	/* SENSE_INTERRUPT_STATUS */
1881	FLOPPY_DPRINTF("SENSE_INTERRUPT_STATUS command (%02x)\n",
1882	fdctrl->int_status);
1883	/* No parameters cmd: returns status if no interrupt */
1884	#if 0
1885	fdctrl->fifo[0] =
1886	fdctrl->int_status \| (cur_drv->head << 2) \| fdctrl->cur_drv;
1887	#else
1888	/* XXX: int_status handling is broken for read/write
1889	commands, so we do this hack. It should be suppressed
1890	ASAP */
1891	fdctrl->fifo[0] =
1892	0x20 \| (cur_drv->head << 2) \| fdctrl->cur_drv;
1893	#endif
1894	fdctrl->fifo[1] = cur_drv->track;
1895	fdctrl_set_fifo(fdctrl, 2, 0);
1896	fdctrl_reset_irq(fdctrl);
1897	fdctrl->int_status = 0xC0;
1898	return;
1899	case 0x0E:
1900	/* DUMPREG */
1901	FLOPPY_DPRINTF("DUMPREG command\n");
1902	/* Drives position */
1903	fdctrl->fifo[0] = drv0(fdctrl)->track;
1904	fdctrl->fifo[1] = drv1(fdctrl)->track;
1905	fdctrl->fifo[2] = 0;
1906	fdctrl->fifo[3] = 0;
1907	/* timers */
1908	fdctrl->fifo[4] = fdctrl->timer0;
1909	fdctrl->fifo[5] = (fdctrl->timer1 << 1) \| fdctrl->dma_en;
1910	fdctrl->fifo[6] = cur_drv->last_sect;
1911	fdctrl->fifo[7] = (fdctrl->lock << 7) \|
1912	(cur_drv->perpendicular << 2);
1913	fdctrl->fifo[8] = fdctrl->config;
1914	fdctrl->fifo[9] = fdctrl->precomp_trk;
1915	fdctrl_set_fifo(fdctrl, 10, 0);
1916	return;
1917	case 0x0F:
1918	/* SEEK */
1919	FLOPPY_DPRINTF("SEEK command\n");
1920	/* 2 parameters cmd */
1921	fdctrl->data_len = 3;
1922	goto enqueue;
1923	case 0x10:
1924	/* VERSION */
1925	FLOPPY_DPRINTF("VERSION command\n");
1926	/* No parameters cmd */
1927	/* Controller's version */
1928	fdctrl->fifo[0] = fdctrl->version;
1929	fdctrl_set_fifo(fdctrl, 1, 1);
1930	return;
1931	case 0x12:
1932	/* PERPENDICULAR_MODE */
1933	FLOPPY_DPRINTF("PERPENDICULAR_MODE command\n");
1934	/* 1 parameter cmd */
1935	fdctrl->data_len = 2;
1936	goto enqueue;
1937	case 0x13:
1938	/* CONFIGURE */
1939	FLOPPY_DPRINTF("CONFIGURE command\n");
1940	/* 3 parameters cmd */
1941	fdctrl->data_len = 4;
1942	goto enqueue;
1943	case 0x14:
1944	/* UNLOCK */
1945	FLOPPY_DPRINTF("UNLOCK command\n");
1946	/* No parameters cmd */
1947	fdctrl->lock = 0;
1948	fdctrl->fifo[0] = 0;
1949	fdctrl_set_fifo(fdctrl, 1, 0);
1950	return;
1951	case 0x17:
1952	/* POWERDOWN_MODE */
1953	FLOPPY_DPRINTF("POWERDOWN_MODE command\n");
1954	/* 2 parameters cmd */
1955	fdctrl->data_len = 3;
1956	goto enqueue;
1957	case 0x18:
1958	/* PART_ID */
1959	FLOPPY_DPRINTF("PART_ID command\n");
1960	/* No parameters cmd */
1961	fdctrl->fifo[0] = 0x41; /* Stepping 1 */
1962	fdctrl_set_fifo(fdctrl, 1, 0);
1963	return;
1964	case 0x2C:
1965	/* SAVE */
1966	FLOPPY_DPRINTF("SAVE command\n");
1967	/* No parameters cmd */
1968	fdctrl->fifo[0] = 0;
1969	fdctrl->fifo[1] = 0;
1970	/* Drives position */
1971	fdctrl->fifo[2] = drv0(fdctrl)->track;
1972	fdctrl->fifo[3] = drv1(fdctrl)->track;
1973	fdctrl->fifo[4] = 0;
1974	fdctrl->fifo[5] = 0;
1975	/* timers */
1976	fdctrl->fifo[6] = fdctrl->timer0;
1977	fdctrl->fifo[7] = fdctrl->timer1;
1978	fdctrl->fifo[8] = cur_drv->last_sect;
1979	fdctrl->fifo[9] = (fdctrl->lock << 7) \|
1980	(cur_drv->perpendicular << 2);
1981	fdctrl->fifo[10] = fdctrl->config;
1982	fdctrl->fifo[11] = fdctrl->precomp_trk;
1983	fdctrl->fifo[12] = fdctrl->pwrd;
1984	fdctrl->fifo[13] = 0;
1985	fdctrl->fifo[14] = 0;
1986	fdctrl_set_fifo(fdctrl, 15, 1);
1987	return;
1988	case 0x33:
1989	/* OPTION */
1990	FLOPPY_DPRINTF("OPTION command\n");
1991	/* 1 parameter cmd */
1992	fdctrl->data_len = 2;
1993	goto enqueue;
1994	case 0x42:
1995	/* READ_TRACK */
1996	FLOPPY_DPRINTF("READ_TRACK command\n");
1997	/* 8 parameters cmd */
1998	fdctrl->data_len = 9;
1999	goto enqueue;
2000	case 0x4A:
2001	/* READ_ID */
2002	FLOPPY_DPRINTF("READ_ID command\n");
2003	/* 1 parameter cmd */
2004	fdctrl->data_len = 2;
2005	goto enqueue;
2006	case 0x4C:
2007	/* RESTORE */
2008	FLOPPY_DPRINTF("RESTORE command\n");
2009	/* 17 parameters cmd */
2010	fdctrl->data_len = 18;
2011	goto enqueue;
2012	case 0x4D:
2013	/* FORMAT_TRACK */
2014	FLOPPY_DPRINTF("FORMAT_TRACK command\n");
2015	/* 5 parameters cmd */
2016	fdctrl->data_len = 6;
2017	goto enqueue;
2018	case 0x8E:
2019	/* DRIVE_SPECIFICATION_COMMAND */
2020	FLOPPY_DPRINTF("DRIVE_SPECIFICATION_COMMAND command\n");
2021	/* 5 parameters cmd */
2022	fdctrl->data_len = 6;
2023	goto enqueue;
2024	case 0x8F:
2025	/* RELATIVE_SEEK_OUT */
2026	FLOPPY_DPRINTF("RELATIVE_SEEK_OUT command\n");
2027	/* 2 parameters cmd */
2028	fdctrl->data_len = 3;
2029	goto enqueue;
2030	case 0x94:
2031	/* LOCK */
2032	FLOPPY_DPRINTF("LOCK command\n");
2033	/* No parameters cmd */
2034	fdctrl->lock = 1;
2035	fdctrl->fifo[0] = 0x10;
2036	fdctrl_set_fifo(fdctrl, 1, 1);
2037	return;
2038	case 0xCD:
2039	/* FORMAT_AND_WRITE */
2040	FLOPPY_DPRINTF("FORMAT_AND_WRITE command\n");
2041	/* 10 parameters cmd */
2042	fdctrl->data_len = 11;
2043	goto enqueue;
2044	case 0xCF:
2045	/* RELATIVE_SEEK_IN */
2046	FLOPPY_DPRINTF("RELATIVE_SEEK_IN command\n");
2047	/* 2 parameters cmd */
2048	fdctrl->data_len = 3;
2049	goto enqueue;
2050	default:
2051	/* Unknown command */
2052	FLOPPY_ERROR("unknown command: 0x%02x\n", value);
2053	fdctrl_unimplemented(fdctrl);
2054	return;
2055	}
2056	}
2057	enqueue:
2058	FLOPPY_DPRINTF("%s: %02x\n", __func__, value);
2059	fdctrl->fifo[fdctrl->data_pos] = value;
2060	if (++fdctrl->data_pos == fdctrl->data_len) {
2061	/* We now have all parameters
2062	* and will be able to treat the command
2063	*/
2064	if (fdctrl->data_state & FD_STATE_FORMAT) {
2065	fdctrl_format_sector(fdctrl);
2066	return;
2067	}
2068	switch (fdctrl->fifo[0] & 0x1F) {
2069	case 0x06:
2070	{
2071	/* READ variants */
2072	FLOPPY_DPRINTF("treat READ command\n");
2073	fdctrl_start_transfer(fdctrl, FD_DIR_READ);
2074	return;
2075	}
2076	case 0x0C:
2077	/* READ_DELETED variants */
2078	/* // FLOPPY_DPRINTF("treat READ_DELETED command\n"); */
2079	FLOPPY_ERROR("treat READ_DELETED command\n");
2080	fdctrl_start_transfer_del(fdctrl, FD_DIR_READ);
2081	return;
2082	case 0x16:
2083	/* VERIFY variants */
2084	/* // FLOPPY_DPRINTF("treat VERIFY command\n"); */
2085	FLOPPY_ERROR("treat VERIFY command\n");
2086	fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00);
2087	return;
2088	case 0x10:
2089	/* SCAN_EQUAL variants */
2090	/* // FLOPPY_DPRINTF("treat SCAN_EQUAL command\n"); */
2091	FLOPPY_ERROR("treat SCAN_EQUAL command\n");
2092	fdctrl_start_transfer(fdctrl, FD_DIR_SCANE);
2093	return;
2094	case 0x19:
2095	/* SCAN_LOW_OR_EQUAL variants */
2096	/* // FLOPPY_DPRINTF("treat SCAN_LOW_OR_EQUAL command\n"); */
2097	FLOPPY_ERROR("treat SCAN_LOW_OR_EQUAL command\n");
2098	fdctrl_start_transfer(fdctrl, FD_DIR_SCANL);
2099	return;
2100	case 0x1D:
2101	/* SCAN_HIGH_OR_EQUAL variants */
2102	/* // FLOPPY_DPRINTF("treat SCAN_HIGH_OR_EQUAL command\n"); */
2103	FLOPPY_ERROR("treat SCAN_HIGH_OR_EQUAL command\n");
2104	fdctrl_start_transfer(fdctrl, FD_DIR_SCANH);
2105	return;
2106	default:
2107	break;
2108	}
2109	switch (fdctrl->fifo[0] & 0x3F) {
2110	case 0x05:
2111	/* WRITE variants */
2112	FLOPPY_DPRINTF("treat WRITE command (%02x)\n", fdctrl->fifo[0]);
2113	fdctrl_start_transfer(fdctrl, FD_DIR_WRITE);
2114	return;
2115	case 0x09:
2116	/* WRITE_DELETED variants */
2117	/* // FLOPPY_DPRINTF("treat WRITE_DELETED command\n"); */
2118	FLOPPY_ERROR("treat WRITE_DELETED command\n");
2119	fdctrl_start_transfer_del(fdctrl, FD_DIR_WRITE);
2120	return;
2121	default:
2122	break;
2123	}
2124	switch (fdctrl->fifo[0]) {
2125	case 0x03:
2126	/* SPECIFY */
2127	FLOPPY_DPRINTF("treat SPECIFY command\n");
2128	fdctrl->timer0 = (fdctrl->fifo[1] >> 4) & 0xF;
2129	fdctrl->timer1 = fdctrl->fifo[2] >> 1;
2130	fdctrl->dma_en = 1 - (fdctrl->fifo[2] & 1) ;
2131	/* No result back */
2132	fdctrl_reset_fifo(fdctrl);
2133	break;
2134	case 0x04:
2135	/* SENSE_DRIVE_STATUS */
2136	FLOPPY_DPRINTF("treat SENSE_DRIVE_STATUS command\n");
2137	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
2138	cur_drv = get_cur_drv(fdctrl);
2139	cur_drv->head = (fdctrl->fifo[1] >> 2) & 1;
2140	/* 1 Byte status back */
2141	fdctrl->fifo[0] = (cur_drv->ro << 6) \|
2142	(cur_drv->track == 0 ? 0x10 : 0x00) \|
2143	(cur_drv->head << 2) \|
2144	fdctrl->cur_drv \|
2145	0x28;
2146	fdctrl_set_fifo(fdctrl, 1, 0);
2147	break;
2148	case 0x07:
2149	/* RECALIBRATE */
2150	FLOPPY_DPRINTF("treat RECALIBRATE command\n");
2151	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
2152	cur_drv = get_cur_drv(fdctrl);
2153	fd_recalibrate(cur_drv);
2154	fdctrl_reset_fifo(fdctrl);
2155	/* Raise Interrupt */
2156	fdctrl_raise_irq(fdctrl, 0x20);
2157	break;
2158	case 0x0F:
2159	/* SEEK */
2160	FLOPPY_DPRINTF("treat SEEK command\n");
2161	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
2162	cur_drv = get_cur_drv(fdctrl);
2163	fd_start(cur_drv);
2164	if (fdctrl->fifo[2] <= cur_drv->track)
2165	cur_drv->dir = 1;
2166	else
2167	cur_drv->dir = 0;
2168	fdctrl_reset_fifo(fdctrl);
2169	#ifndef VBOX
2170	if (fdctrl->fifo[2] > cur_drv->max_track) {
2171	#else
2172	if ( fdctrl->fifo[2] > cur_drv->max_track
2173	&& cur_drv->fMediaPresent) {
2174	#endif
2175	fdctrl_raise_irq(fdctrl, 0x60);
2176	} else {
2177	cur_drv->track = fdctrl->fifo[2];
2178	/* Raise Interrupt */
2179	fdctrl_raise_irq(fdctrl, 0x20);
2180	}
2181	break;
2182	case 0x12:
2183	/* PERPENDICULAR_MODE */
2184	FLOPPY_DPRINTF("treat PERPENDICULAR_MODE command\n");
2185	if (fdctrl->fifo[1] & 0x80)
2186	cur_drv->perpendicular = fdctrl->fifo[1] & 0x7;
2187	/* No result back */
2188	fdctrl_reset_fifo(fdctrl);
2189	break;
2190	case 0x13:
2191	/* CONFIGURE */
2192	FLOPPY_DPRINTF("treat CONFIGURE command\n");
2193	fdctrl->config = fdctrl->fifo[2];
2194	fdctrl->precomp_trk = fdctrl->fifo[3];
2195	/* No result back */
2196	fdctrl_reset_fifo(fdctrl);
2197	break;
2198	case 0x17:
2199	/* POWERDOWN_MODE */
2200	FLOPPY_DPRINTF("treat POWERDOWN_MODE command\n");
2201	fdctrl->pwrd = fdctrl->fifo[1];
2202	fdctrl->fifo[0] = fdctrl->fifo[1];
2203	fdctrl_set_fifo(fdctrl, 1, 1);
2204	break;
2205	case 0x33:
2206	/* OPTION */
2207	FLOPPY_DPRINTF("treat OPTION command\n");
2208	/* No result back */
2209	fdctrl_reset_fifo(fdctrl);
2210	break;
2211	case 0x42:
2212	/* READ_TRACK */
2213	/* // FLOPPY_DPRINTF("treat READ_TRACK command\n"); */
2214	FLOPPY_ERROR("treat READ_TRACK command\n");
2215	fdctrl_start_transfer(fdctrl, FD_DIR_READ);
2216	break;
2217	case 0x4A:
2218	/* READ_ID */
2219	FLOPPY_DPRINTF("treat READ_ID command\n");
2220	/* XXX: should set main status register to busy */
2221	cur_drv->head = (fdctrl->fifo[1] >> 2) & 1;
2222	#ifdef VBOX
2223	TMTimerSetMillies(fdctrl->result_timer, 1000 / 50);
2224	#else
2225	qemu_mod_timer(fdctrl->result_timer,
2226	qemu_get_clock(vm_clock) + (ticks_per_sec / 50));
2227	#endif
2228	break;
2229	case 0x4C:
2230	/* RESTORE */
2231	FLOPPY_DPRINTF("treat RESTORE command\n");
2232	/* Drives position */
2233	drv0(fdctrl)->track = fdctrl->fifo[3];
2234	drv1(fdctrl)->track = fdctrl->fifo[4];
2235	/* timers */
2236	fdctrl->timer0 = fdctrl->fifo[7];
2237	fdctrl->timer1 = fdctrl->fifo[8];
2238	cur_drv->last_sect = fdctrl->fifo[9];
2239	fdctrl->lock = fdctrl->fifo[10] >> 7;
2240	cur_drv->perpendicular = (fdctrl->fifo[10] >> 2) & 0xF;
2241	fdctrl->config = fdctrl->fifo[11];
2242	fdctrl->precomp_trk = fdctrl->fifo[12];
2243	fdctrl->pwrd = fdctrl->fifo[13];
2244	fdctrl_reset_fifo(fdctrl);
2245	break;
2246	case 0x4D:
2247	/* FORMAT_TRACK */
2248	FLOPPY_DPRINTF("treat FORMAT_TRACK command\n");
2249	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
2250	cur_drv = get_cur_drv(fdctrl);
2251	fdctrl->data_state \|= FD_STATE_FORMAT;
2252	if (fdctrl->fifo[0] & 0x80)
2253	fdctrl->data_state \|= FD_STATE_MULTI;
2254	else
2255	fdctrl->data_state &= ~FD_STATE_MULTI;
2256	fdctrl->data_state &= ~FD_STATE_SEEK;
2257	cur_drv->bps =
2258	fdctrl->fifo[2] > 7 ? 16384 : 128 << fdctrl->fifo[2];
2259	#if 0
2260	cur_drv->last_sect =
2261	cur_drv->flags & FDISK_DBL_SIDES ? fdctrl->fifo[3] :
2262	fdctrl->fifo[3] / 2;
2263	#else
2264	cur_drv->last_sect = fdctrl->fifo[3];
2265	#endif
2266	/* Bochs BIOS is buggy and don't send format informations
2267	* for each sector. So, pretend all's done right now...
2268	*/
2269	fdctrl->data_state &= ~FD_STATE_FORMAT;
2270	fdctrl_stop_transfer(fdctrl, 0x00, 0x00, 0x00);
2271	break;
2272	case 0x8E:
2273	/* DRIVE_SPECIFICATION_COMMAND */
2274	FLOPPY_DPRINTF("treat DRIVE_SPECIFICATION_COMMAND command\n");
2275	if (fdctrl->fifo[fdctrl->data_pos - 1] & 0x80) {
2276	/* Command parameters done */
2277	if (fdctrl->fifo[fdctrl->data_pos - 1] & 0x40) {
2278	fdctrl->fifo[0] = fdctrl->fifo[1];
2279	fdctrl->fifo[2] = 0;
2280	fdctrl->fifo[3] = 0;
2281	fdctrl_set_fifo(fdctrl, 4, 1);
2282	} else {
2283	fdctrl_reset_fifo(fdctrl);
2284	}
2285	} else if (fdctrl->data_len > 7) {
2286	/* ERROR */
2287	fdctrl->fifo[0] = 0x80 \|
2288	(cur_drv->head << 2) \| fdctrl->cur_drv;
2289	fdctrl_set_fifo(fdctrl, 1, 1);
2290	}
2291	break;
2292	case 0x8F:
2293	/* RELATIVE_SEEK_OUT */
2294	FLOPPY_DPRINTF("treat RELATIVE_SEEK_OUT command\n");
2295	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
2296	cur_drv = get_cur_drv(fdctrl);
2297	fd_start(cur_drv);
2298	cur_drv->dir = 0;
2299	if (fdctrl->fifo[2] + cur_drv->track >= cur_drv->max_track) {
2300	cur_drv->track = cur_drv->max_track - 1;
2301	} else {
2302	cur_drv->track += fdctrl->fifo[2];
2303	}
2304	fdctrl_reset_fifo(fdctrl);
2305	fdctrl_raise_irq(fdctrl, 0x20);
2306	break;
2307	case 0xCD:
2308	/* FORMAT_AND_WRITE */
2309	/* // FLOPPY_DPRINTF("treat FORMAT_AND_WRITE command\n"); */
2310	FLOPPY_ERROR("treat FORMAT_AND_WRITE command\n");
2311	fdctrl_unimplemented(fdctrl);
2312	break;
2313	case 0xCF:
2314	/* RELATIVE_SEEK_IN */
2315	FLOPPY_DPRINTF("treat RELATIVE_SEEK_IN command\n");
2316	fdctrl->cur_drv = fdctrl->fifo[1] & 1;
2317	cur_drv = get_cur_drv(fdctrl);
2318	fd_start(cur_drv);
2319	cur_drv->dir = 1;
2320	if (fdctrl->fifo[2] > cur_drv->track) {
2321	cur_drv->track = 0;
2322	} else {
2323	cur_drv->track -= fdctrl->fifo[2];
2324	}
2325	fdctrl_reset_fifo(fdctrl);
2326	/* Raise Interrupt */
2327	fdctrl_raise_irq(fdctrl, 0x20);
2328	break;
2329	}
2330	}
2331	}
2332
2333	static void fdctrl_result_timer(void *opaque)
2334	{
2335	fdctrl_t *fdctrl = opaque;
2336	fdctrl_stop_transfer(fdctrl, 0x00, 0x00, 0x00);
2337	}
2338
2339
2340	#ifdef VBOX
2341	static DECLCALLBACK(void) fdc_timer (PPDMDEVINS pDevIns, PTMTIMER pTimer)
2342	{
2343	fdctrl_t fdctrl = PDMINS2DATA (pDevIns, fdctrl_t );
2344	fdctrl_result_timer (fdctrl);
2345	}
2346
2347	static DECLCALLBACK(int) fdc_io_write (PPDMDEVINS pDevIns,
2348	void *pvUser,
2349	RTIOPORT Port,
2350	uint32_t u32,
2351	unsigned cb)
2352	{
2353	if (cb == 1) {
2354	fdctrl_write (pvUser, Port, u32);
2355	}
2356	else {
2357	AssertMsgFailed(("Port=%#x cb=%d u32=%#x\n", Port, cb, u32));
2358	}
2359	return VINF_SUCCESS;
2360	}
2361
2362	static DECLCALLBACK(int) fdc_io_read (PPDMDEVINS pDevIns,
2363	void *pvUser,
2364	RTIOPORT Port,
2365	uint32_t *pu32,
2366	unsigned cb)
2367	{
2368	if (cb == 1) {
2369	*pu32 = fdctrl_read (pvUser, Port);
2370	return VINF_SUCCESS;
2371	}
2372	else {
2373	return VERR_IOM_IOPORT_UNUSED;
2374	}
2375	}
2376
2377	static DECLCALLBACK(int) SaveExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
2378	{
2379	fdctrl_t s = PDMINS2DATA (pDevIns, fdctrl_t );
2380	QEMUFile *f = pSSMHandle;
2381	unsigned int i;
2382
2383	qemu_put_8s (f, &s->version);
2384	qemu_put_8s (f, &s->irq_lvl);
2385	qemu_put_8s (f, &s->dma_chann);
2386	qemu_put_be32s (f, &s->io_base);
2387	qemu_put_8s (f, &s->state);
2388	qemu_put_8s (f, &s->dma_en);
2389	qemu_put_8s (f, &s->cur_drv);
2390	qemu_put_8s (f, &s->bootsel);
2391	qemu_put_buffer (f, s->fifo, FD_SECTOR_LEN);
2392	qemu_put_be32s (f, &s->data_pos);
2393	qemu_put_be32s (f, &s->data_len);
2394	qemu_put_8s (f, &s->data_state);
2395	qemu_put_8s (f, &s->data_dir);
2396	qemu_put_8s (f, &s->int_status);
2397	qemu_put_8s (f, &s->eot);
2398	qemu_put_8s (f, &s->timer0);
2399	qemu_put_8s (f, &s->timer1);
2400	qemu_put_8s (f, &s->precomp_trk);
2401	qemu_put_8s (f, &s->config);
2402	qemu_put_8s (f, &s->lock);
2403	qemu_put_8s (f, &s->pwrd);
2404
2405	for (i = 0; i < sizeof (s->drives) / sizeof (s->drives[0]); ++i) {
2406	fdrive_t *d = &s->drives[i];
2407
2408	SSMR3PutMem (pSSMHandle, &d->Led, sizeof (d->Led));
2409	qemu_put_be32s (f, &d->drive);
2410	qemu_put_be32s (f, &d->drflags);
2411	qemu_put_8s (f, &d->perpendicular);
2412	qemu_put_8s (f, &d->head);
2413	qemu_put_8s (f, &d->track);
2414	qemu_put_8s (f, &d->sect);
2415	qemu_put_8s (f, &d->dir);
2416	qemu_put_8s (f, &d->rw);
2417	qemu_put_be32s (f, &d->flags);
2418	qemu_put_8s (f, &d->last_sect);
2419	qemu_put_8s (f, &d->max_track);
2420	qemu_put_be16s (f, &d->bps);
2421	qemu_put_8s (f, &d->ro);
2422	}
2423	return TMR3TimerSave (s->result_timer, pSSMHandle);
2424	}
2425
2426	static DECLCALLBACK(int) LoadExec (PPDMDEVINS pDevIns,
2427	PSSMHANDLE pSSMHandle,
2428	uint32_t u32Version)
2429	{
2430	fdctrl_t s = PDMINS2DATA (pDevIns, fdctrl_t );
2431	QEMUFile *f = pSSMHandle;
2432	unsigned int i;
2433
2434	if (u32Version != 1) {
2435	AssertMsgFailed(("u32Version=%d\n", u32Version));
2436	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
2437	}
2438
2439	qemu_get_8s (f, &s->version);
2440	qemu_get_8s (f, &s->irq_lvl);
2441	qemu_get_8s (f, &s->dma_chann);
2442	qemu_get_be32s (f, &s->io_base);
2443	qemu_get_8s (f, &s->state);
2444	qemu_get_8s (f, &s->dma_en);
2445	qemu_get_8s (f, &s->cur_drv);
2446	qemu_get_8s (f, &s->bootsel);
2447	qemu_get_buffer (f, s->fifo, FD_SECTOR_LEN);
2448	qemu_get_be32s (f, &s->data_pos);
2449	qemu_get_be32s (f, &s->data_len);
2450	qemu_get_8s (f, &s->data_state);
2451	qemu_get_8s (f, &s->data_dir);
2452	qemu_get_8s (f, &s->int_status);
2453	qemu_get_8s (f, &s->eot);
2454	qemu_get_8s (f, &s->timer0);
2455	qemu_get_8s (f, &s->timer1);
2456	qemu_get_8s (f, &s->precomp_trk);
2457	qemu_get_8s (f, &s->config);
2458	qemu_get_8s (f, &s->lock);
2459	qemu_get_8s (f, &s->pwrd);
2460
2461	for (i = 0; i < sizeof (s->drives) / sizeof (s->drives[0]); ++i) {
2462	fdrive_t *d = &s->drives[i];
2463
2464	SSMR3GetMem (pSSMHandle, &d->Led, sizeof (d->Led));
2465	qemu_get_be32s (f, &d->drive);
2466	qemu_get_be32s (f, &d->drflags);
2467	qemu_get_8s (f, &d->perpendicular);
2468	qemu_get_8s (f, &d->head);
2469	qemu_get_8s (f, &d->track);
2470	qemu_get_8s (f, &d->sect);
2471	qemu_get_8s (f, &d->dir);
2472	qemu_get_8s (f, &d->rw);
2473	qemu_get_be32s (f, &d->flags);
2474	qemu_get_8s (f, &d->last_sect);
2475	qemu_get_8s (f, &d->max_track);
2476	qemu_get_be16s (f, &d->bps);
2477	qemu_get_8s (f, &d->ro);
2478	}
2479	return TMR3TimerLoad (s->result_timer, pSSMHandle);
2480	}
2481
2482	/**
2483	* Queries an interface to the driver.
2484	*
2485	* @returns Pointer to interface.
2486	* @returns NULL if the interface was not supported by the device.
2487	* @param pInterface Pointer to IDEState::IBase.
2488	* @param enmInterface The requested interface identification.
2489	*/
2490	static DECLCALLBACK(void *) fdQueryInterface (PPDMIBASE pInterface,
2491	PDMINTERFACE enmInterface)
2492	{
2493	fdrive_t *drv = PDMIBASE_2_FDRIVE(pInterface);
2494	switch (enmInterface) {
2495	case PDMINTERFACE_BASE:
2496	return &drv->IBase;
2497	case PDMINTERFACE_BLOCK_PORT:
2498	return &drv->IPort;
2499	case PDMINTERFACE_MOUNT_NOTIFY:
2500	return &drv->IMountNotify;
2501	default:
2502	return NULL;
2503	}
2504	}
2505
2506	/**
2507	* Gets the pointer to the status LED of a unit.
2508	*
2509	* @returns VBox status code.
2510	* @param pInterface Pointer to the interface structure containing the called function pointer.
2511	* @param iLUN The unit which status LED we desire.
2512	* @param ppLed Where to store the LED pointer.
2513	*/
2514	static DECLCALLBACK(int) fdcStatusQueryStatusLed (PPDMILEDPORTS pInterface,
2515	unsigned iLUN,
2516	PPDMLED *ppLed)
2517	{
2518	fdctrl_t fdctrl = (fdctrl_t )
2519	((uintptr_t )pInterface - RT_OFFSETOF (fdctrl_t, ILeds));
2520	if (iLUN < ELEMENTS(fdctrl->drives)) {
2521	*ppLed = &fdctrl->drives[iLUN].Led;
2522	Assert ((*ppLed)->u32Magic == PDMLED_MAGIC);
2523	return VINF_SUCCESS;
2524	}
2525	return VERR_PDM_LUN_NOT_FOUND;
2526	}
2527
2528
2529	/**
2530	* Queries an interface to the status LUN.
2531	*
2532	* @returns Pointer to interface.
2533	* @returns NULL if the interface was not supported by the device.
2534	* @param pInterface Pointer to IDEState::IBase.
2535	* @param enmInterface The requested interface identification.
2536	*/
2537	static DECLCALLBACK(void *) fdcStatusQueryInterface (PPDMIBASE pInterface,
2538	PDMINTERFACE enmInterface)
2539	{
2540	fdctrl_t fdctrl = (fdctrl_t )
2541	((uintptr_t)pInterface - RT_OFFSETOF (fdctrl_t, IBaseStatus));
2542	switch (enmInterface) {
2543	case PDMINTERFACE_BASE:
2544	return &fdctrl->IBaseStatus;
2545	case PDMINTERFACE_LED_PORTS:
2546	return &fdctrl->ILeds;
2547	default:
2548	return NULL;
2549	}
2550	}
2551
2552
2553	/**
2554	* Configure a drive.
2555	*
2556	* @returns VBox status code.
2557	* @param drv The drive in question.
2558	* @param pDevIns The driver instance.
2559	*/
2560	static int fdConfig (fdrive_t *drv, PPDMDEVINS pDevIns)
2561	{
2562	static const char *descs[] = {"Floppy Drive A:", "Floppy Drive B"};
2563	int rc;
2564
2565	/*
2566	* Reset the LED just to be on the safe side.
2567	*/
2568	Assert (ELEMENTS(descs) > drv->iLUN);
2569	Assert (drv->Led.u32Magic == PDMLED_MAGIC);
2570	drv->Led.Actual.u32 = 0;
2571	drv->Led.Asserted.u32 = 0;
2572
2573	/*
2574	* Try attach the block device and get the interfaces.
2575	*/
2576	rc = PDMDevHlpDriverAttach (pDevIns, drv->iLUN, &drv->IBase, &drv->pDrvBase, descs[drv->iLUN]);
2577	if (VBOX_SUCCESS (rc))
2578	{
2579	drv->pDrvBlock = drv->pDrvBase->pfnQueryInterface (
2580	drv->pDrvBase,
2581	PDMINTERFACE_BLOCK
2582	);
2583	if (drv->pDrvBlock) {
2584	drv->pDrvBlockBios = drv->pDrvBase->pfnQueryInterface (
2585	drv->pDrvBase,
2586	PDMINTERFACE_BLOCK_BIOS
2587	);
2588	if (drv->pDrvBlockBios) {
2589	drv->pDrvMount = drv->pDrvBase->pfnQueryInterface (
2590	drv->pDrvBase,
2591	PDMINTERFACE_MOUNT
2592	);
2593	if (drv->pDrvMount) {
2594	/*
2595	* Init the state.
2596	*/
2597	drv->drive = FDRIVE_DRV_NONE;
2598	drv->drflags = 0;
2599	drv->perpendicular = 0;
2600	/* Disk */
2601	drv->last_sect = 0;
2602	drv->max_track = 0;
2603	drv->fMediaPresent = false;
2604	}
2605	else {
2606	AssertMsgFailed (("Configuration error: LUN#%d without mountable interface!\n", drv->iLUN));
2607	rc = VERR_PDM_MISSING_INTERFACE;
2608	}
2609
2610	}
2611	else {
2612	AssertMsgFailed (("Configuration error: LUN#%d hasn't a block BIOS interface!\n", drv->iLUN));
2613	rc = VERR_PDM_MISSING_INTERFACE;
2614	}
2615
2616	}
2617	else {
2618	AssertMsgFailed (("Configuration error: LUN#%d hasn't a block interface!\n", drv->iLUN));
2619	rc = VERR_PDM_MISSING_INTERFACE;
2620	}
2621	}
2622	else {
2623	AssertMsg (rc == VERR_PDM_NO_ATTACHED_DRIVER,
2624	("Failed to attach LUN#%d. rc=%Vrc\n", drv->iLUN, rc));
2625	}
2626
2627	if (VBOX_FAILURE (rc)) {
2628	drv->pDrvBase = NULL;
2629	drv->pDrvBlock = NULL;
2630	drv->pDrvBlockBios = NULL;
2631	drv->pDrvMount = NULL;
2632	}
2633	LogFlow (("fdConfig: returns %Vrc\n", rc));
2634	return rc;
2635	}
2636
2637
2638	/**
2639	* Attach command.
2640	*
2641	* This is called when we change block driver for a floppy drive.
2642	*
2643	* @returns VBox status code.
2644	* @param pDevIns The device instance.
2645	* @param iLUN The logical unit which is being detached.
2646	*/
2647	static DECLCALLBACK(int) fdcAttach (PPDMDEVINS pDevIns,
2648	unsigned iLUN)
2649	{
2650	fdctrl_t fdctrl = PDMINS2DATA (pDevIns, fdctrl_t );
2651	fdrive_t *drv;
2652	int rc;
2653	LogFlow (("ideDetach: iLUN=%u\n", iLUN));
2654
2655	/*
2656	* Validate.
2657	*/
2658	if (iLUN > 2) {
2659	AssertMsgFailed (("Configuration error: cannot attach or detach any but the first two LUNs - iLUN=%u\n",
2660	iLUN));
2661	return VERR_PDM_DEVINS_NO_ATTACH;
2662	}
2663
2664	/*
2665	* Locate the drive and stuff.
2666	*/
2667	drv = &fdctrl->drives[iLUN];
2668
2669	/* the usual paranoia */
2670	AssertRelease (!drv->pDrvBase);
2671	AssertRelease (!drv->pDrvBlock);
2672	AssertRelease (!drv->pDrvBlockBios);
2673	AssertRelease (!drv->pDrvMount);
2674
2675	rc = fdConfig (drv, pDevIns);
2676	AssertMsg (rc != VERR_PDM_NO_ATTACHED_DRIVER,
2677	("Configuration error: failed to configure drive %d, rc=%Vrc\n", rc));
2678	if (VBOX_SUCCESS(rc)) {
2679	fd_revalidate (drv);
2680	}
2681
2682	LogFlow (("floppyAttach: returns %Vrc\n", rc));
2683	return rc;
2684	}
2685
2686
2687	/**
2688	* Detach notification.
2689	*
2690	* The floppy drive has been temporarily 'unplugged'.
2691	*
2692	* @param pDevIns The device instance.
2693	* @param iLUN The logical unit which is being detached.
2694	*/
2695	static DECLCALLBACK(void) fdcDetach (PPDMDEVINS pDevIns,
2696	unsigned iLUN)
2697	{
2698	fdctrl_t fdctrl = PDMINS2DATA (pDevIns, fdctrl_t );
2699	LogFlow (("ideDetach: iLUN=%u\n", iLUN));
2700
2701	switch (iLUN) {
2702	case 0:
2703	case 1: {
2704	fdrive_t *drv = &fdctrl->drives[iLUN];
2705	drv->pDrvBase = NULL;
2706	drv->pDrvBlock = NULL;
2707	drv->pDrvBlockBios = NULL;
2708	drv->pDrvMount = NULL;
2709	break;
2710	}
2711
2712	default:
2713	AssertMsgFailed (("Cannot detach LUN#%d!\n", iLUN));
2714	break;
2715	}
2716	}
2717
2718
2719	/**
2720	* Handle reset.
2721	*
2722	* I haven't check the specs on what's supposed to happen on reset, but we
2723	* should get any 'FATAL: floppy recal:f07 ctrl not ready' when resetting
2724	* at wrong time like we do if this was all void.
2725	*
2726	* @param pDevIns The device instance.
2727	*/
2728	static DECLCALLBACK(void) fdcReset (PPDMDEVINS pDevIns)
2729	{
2730	fdctrl_t fdctrl = PDMINS2DATA (pDevIns, fdctrl_t );
2731	int i;
2732	LogFlow (("fdcReset:\n"));
2733
2734	fdctrl_reset(fdctrl, 0);
2735	fdctrl->state = FD_CTRL_ACTIVE;
2736
2737	for (i = 0; i < ELEMENTS(fdctrl->drives); i++) {
2738	fd_revalidate(&fdctrl->drives[i]);
2739	}
2740	}
2741
2742
2743	/**
2744	* Construct a device instance for a VM.
2745	*
2746	* @returns VBox status.
2747	* @param pDevIns The device instance data.
2748	* If the registration structure is needed, pDevIns->pDevReg points to it.
2749	* @param iInstance Instance number. Use this to figure out which registers and such to use.
2750	* The device number is also found in pDevIns->iInstance, but since it's
2751	* likely to be freqently used PDM passes it as parameter.
2752	* @param pCfgHandle Configuration node handle for the device. Use this to obtain the configuration
2753	* of the device instance. It's also found in pDevIns->pCfgHandle, but like
2754	* iInstance it's expected to be used a bit in this function.
2755	*/
2756	static DECLCALLBACK(int) fdcConstruct (PPDMDEVINS pDevIns,
2757	int iInstance,
2758	PCFGMNODE pCfgHandle)
2759	{
2760	int rc;
2761	fdctrl_t fdctrl = PDMINS2DATA(pDevIns, fdctrl_t);
2762	int i;
2763	bool mem_mapped;
2764	uint16_t io_base;
2765	uint8_t irq_lvl, dma_chann;
2766	PPDMIBASE pBase;
2767
2768	Assert(iInstance == 0);
2769
2770	/*
2771	* Validate configuration.
2772	*/
2773	if (!CFGMR3AreValuesValid(pCfgHandle, "IRQ\0DMA\0MemMapped\0IOBase\0"))
2774	return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
2775
2776	/*
2777	* Read the configuration.
2778	*/
2779	rc = CFGMR3QueryU8 (pCfgHandle, "IRQ", &irq_lvl);
2780	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
2781	irq_lvl = 6;
2782	else if (VBOX_FAILURE (rc))
2783	{
2784	AssertMsgFailed (("Configuration error: Failed to read U8 IRQ, rc=%Vrc\n", rc));
2785	return rc;
2786	}
2787
2788	rc = CFGMR3QueryU8 (pCfgHandle, "DMA", &dma_chann);
2789	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
2790	dma_chann = 2;
2791	else if (VBOX_FAILURE (rc))
2792	{
2793	AssertMsgFailed (("Configuration error: Failed to read U8 DMA, rc=%Vrc\n", rc));
2794	return rc;
2795	}
2796
2797	rc = CFGMR3QueryU16 (pCfgHandle, "IOBase", &io_base);
2798	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
2799	io_base = 0x3f0;
2800	else if (VBOX_FAILURE (rc))
2801	{
2802	AssertMsgFailed (("Configuration error: Failed to read U16 IOBase, rc=%Vrc\n", rc));
2803	return rc;
2804	}
2805
2806	rc = CFGMR3QueryBool (pCfgHandle, "MemMapped", &mem_mapped);
2807	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
2808	mem_mapped = false;
2809	else if (VBOX_FAILURE (rc))
2810	{
2811	AssertMsgFailed (("Configuration error: Failed to read bool value MemMapped rc=%Vrc\n", rc));
2812	return rc;
2813	}
2814
2815	/*
2816	* Initialize data.
2817	*/
2818	LogFlow(("fdcConstruct: irq_lvl=%d dma_chann=%d io_base=%#x\n", irq_lvl, dma_chann, io_base));
2819	fdctrl->pDevIns = pDevIns;
2820	fdctrl->version = 0x90; /* Intel 82078 controller */
2821	fdctrl->irq_lvl = irq_lvl;
2822	fdctrl->dma_chann = dma_chann;
2823	fdctrl->io_base = io_base;
2824	fdctrl->config = 0x60; /* Implicit seek, polling & FIFO enabled */
2825
2826	fdctrl->IBaseStatus.pfnQueryInterface = fdcStatusQueryInterface;
2827	fdctrl->ILeds.pfnQueryStatusLed = fdcStatusQueryStatusLed;
2828
2829	for (i = 0; i < ELEMENTS(fdctrl->drives); ++i)
2830	{
2831	fdrive_t *drv = &fdctrl->drives[i];
2832
2833	drv->drive = FDRIVE_DRV_NONE;
2834	drv->iLUN = i;
2835
2836	drv->IBase.pfnQueryInterface = fdQueryInterface;
2837	drv->IMountNotify.pfnMountNotify = fdMountNotify;
2838	drv->IMountNotify.pfnUnmountNotify = fdUnmountNotify;
2839	drv->Led.u32Magic = PDMLED_MAGIC;
2840	}
2841
2842	/*
2843	* Create the FDC timer.
2844	*/
2845	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, fdc_timer, "FDC Timer", &fdctrl->result_timer);
2846	if (VBOX_FAILURE (rc))
2847	return rc;
2848
2849	/*
2850	* Register DMA channel.
2851	*/
2852	if (fdctrl->dma_chann != 0xff)
2853	{
2854	fdctrl->dma_en = 1;
2855	rc = PDMDevHlpDMARegister (pDevIns, dma_chann, &fdctrl_transfer_handler, fdctrl);
2856	if (VBOX_FAILURE (rc))
2857	return rc;
2858	}
2859	else
2860	fdctrl->dma_en = 0;
2861
2862	/*
2863	* IO / MMIO.
2864	*/
2865	if (mem_mapped)
2866	{
2867	AssertMsgFailed (("Memory mapped floppy not support by now\n"));
2868	return VERR_NOT_SUPPORTED;
2869	#if 0
2870	FLOPPY_ERROR("memory mapped floppy not supported by now !\n");
2871	io_mem = cpu_register_io_memory(0, fdctrl_mem_read, fdctrl_mem_write);
2872	cpu_register_physical_memory(base, 0x08, io_mem);
2873	#endif
2874	}
2875	else
2876	{
2877	rc = PDMDevHlpIOPortRegister (pDevIns, io_base + 0x1, 5, fdctrl,
2878	fdc_io_write, fdc_io_read, NULL, NULL, "FDC#1");
2879	if (VBOX_FAILURE (rc))
2880	return rc;
2881
2882	rc = PDMDevHlpIOPortRegister (pDevIns, io_base + 0x7, 1, fdctrl,
2883	fdc_io_write, fdc_io_read, NULL, NULL, "FDC#2");
2884	if (VBOX_FAILURE (rc))
2885	return rc;
2886	}
2887
2888	/*
2889	* Register the saved state data unit.
2890	*/
2891	rc = PDMDevHlpSSMRegister (pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1, sizeof(*fdctrl),
2892	NULL, SaveExec, NULL, NULL, LoadExec, NULL);
2893	if (VBOX_FAILURE(rc))
2894	return rc;
2895
2896	/*
2897	* Attach the status port (optional).
2898	*/
2899	rc = PDMDevHlpDriverAttach (pDevIns, PDM_STATUS_LUN, &fdctrl->IBaseStatus, &pBase, "Status Port");
2900	if (VBOX_SUCCESS (rc)) {
2901	fdctrl->pLedsConnector =
2902	pBase->pfnQueryInterface (pBase, PDMINTERFACE_LED_CONNECTORS);
2903	}
2904	else if (rc != VERR_PDM_NO_ATTACHED_DRIVER) {
2905	AssertMsgFailed (("Failed to attach to status driver. rc=%Vrc\n",
2906	rc));
2907	return rc;
2908	}
2909
2910	/*
2911	* Initialize drives.
2912	*/
2913	for (i = 0; i < ELEMENTS(fdctrl->drives); i++)
2914	{
2915	fdrive_t *drv = &fdctrl->drives[i];
2916	rc = fdConfig (drv, pDevIns);
2917	if ( VBOX_FAILURE (rc)
2918	&& rc != VERR_PDM_NO_ATTACHED_DRIVER)
2919	{
2920	AssertMsgFailed (("Configuration error: failed to configure drive %d, rc=%Vrc\n", rc));
2921	return rc;
2922	}
2923	}
2924
2925	fdctrl_reset(fdctrl, 0);
2926	fdctrl->state = FD_CTRL_ACTIVE;
2927
2928	for (i = 0; i < ELEMENTS(fdctrl->drives); i++)
2929	fd_revalidate(&fdctrl->drives[i]);
2930
2931	return VINF_SUCCESS;
2932	}
2933
2934	/**
2935	* The device registration structure.
2936	*/
2937	const PDMDEVREG g_DeviceFloppyController =
2938	{
2939	/* u32Version */
2940	PDM_DEVREG_VERSION,
2941	/* szDeviceName */
2942	"i82078",
2943	/* szGCMod */
2944	"",
2945	/* szR0Mod */
2946	"",
2947	/* pszDescription */
2948	"Floppy drive controller (Intel 82078)",
2949	/* fFlags */
2950	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT,
2951	/* fClass */
2952	PDM_DEVREG_CLASS_STORAGE,
2953	/* cMaxInstances */
2954	1,
2955	/* cbInstance */
2956	sizeof(fdctrl_t),
2957	/* pfnConstruct */
2958	fdcConstruct,
2959	/* pfnDestruct */
2960	NULL,
2961	/* pfnRelocate */
2962	NULL,
2963	/* pfnIOCtl */
2964	NULL,
2965	/* pfnPowerOn */
2966	NULL,
2967	/* pfnReset */
2968	fdcReset,
2969	/* pfnSuspend */
2970	NULL,
2971	/* pfnResume */
2972	NULL,
2973	/* pfnAttach */
2974	fdcAttach,
2975	/* pfnDetach */
2976	fdcDetach,
2977	/* pfnQueryInterface. */
2978	NULL
2979	};
2980
2981	#endif /* VBOX */
2982
2983	/*
2984	* Local Variables:
2985	* mode: c
2986	* c-file-style: "k&r"
2987	* indent-tabs-mode: nil
2988	* End:
2989	*/
2990

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Storage/fdc.c@ 6581

Download in other formats: