fdc.c@ 1

Last change on this file since 1 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native`
File size: 97.3 KB

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

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

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

Download in other formats: