fdc.c@ 31128

Last change on this file since 31128 was 31128, checked in by vboxsync, 14 years ago
Main/Console,Storage/DrvVD+fdc: Allow readonly floppy images (suppress runtime error on VM start for readonly media), and take this as the signal to make the floppy medium readonly. Never attempt to write to such images, and signal the appropriate error.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 95.3 KB

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

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

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

Download in other formats: