]>
Commit | Line | Data |
---|---|---|
8977f3c1 FB |
1 | /* |
2 | * QEMU Floppy disk emulator | |
3 | * | |
4 | * Copyright (c) 2003 Jocelyn Mayer | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
8977f3c1 FB |
24 | #include "vl.h" |
25 | ||
26 | /********************************************************/ | |
27 | /* debug Floppy devices */ | |
28 | //#define DEBUG_FLOPPY | |
29 | ||
30 | #ifdef DEBUG_FLOPPY | |
31 | #define FLOPPY_DPRINTF(fmt, args...) \ | |
32 | do { printf("FLOPPY: " fmt , ##args); } while (0) | |
33 | #else | |
34 | #define FLOPPY_DPRINTF(fmt, args...) | |
35 | #endif | |
36 | ||
37 | #define FLOPPY_ERROR(fmt, args...) \ | |
38 | do { printf("FLOPPY ERROR: %s: " fmt, __func__ , ##args); } while (0) | |
39 | ||
40 | /********************************************************/ | |
41 | /* Floppy drive emulation */ | |
42 | ||
43 | /* Will always be a fixed parameter for us */ | |
44 | #define FD_SECTOR_LEN 512 | |
45 | #define FD_SECTOR_SC 2 /* Sector size code */ | |
46 | ||
47 | /* Floppy disk drive emulation */ | |
48 | typedef enum fdisk_type_t { | |
49 | FDRIVE_DISK_288 = 0x01, /* 2.88 MB disk */ | |
50 | FDRIVE_DISK_144 = 0x02, /* 1.44 MB disk */ | |
51 | FDRIVE_DISK_720 = 0x03, /* 720 kB disk */ | |
baca51fa FB |
52 | FDRIVE_DISK_USER = 0x04, /* User defined geometry */ |
53 | FDRIVE_DISK_NONE = 0x05, /* No disk */ | |
8977f3c1 FB |
54 | } fdisk_type_t; |
55 | ||
56 | typedef enum fdrive_type_t { | |
57 | FDRIVE_DRV_144 = 0x00, /* 1.44 MB 3"5 drive */ | |
58 | FDRIVE_DRV_288 = 0x01, /* 2.88 MB 3"5 drive */ | |
59 | FDRIVE_DRV_120 = 0x02, /* 1.2 MB 5"25 drive */ | |
60 | FDRIVE_DRV_NONE = 0x03, /* No drive connected */ | |
61 | } fdrive_type_t; | |
62 | ||
baca51fa FB |
63 | typedef enum fdrive_flags_t { |
64 | FDRIVE_MOTOR_ON = 0x01, /* motor on/off */ | |
65 | FDRIVE_REVALIDATE = 0x02, /* Revalidated */ | |
66 | } fdrive_flags_t; | |
67 | ||
68 | typedef enum fdisk_flags_t { | |
69 | FDISK_DBL_SIDES = 0x01, | |
70 | } fdisk_flags_t; | |
71 | ||
8977f3c1 FB |
72 | typedef struct fdrive_t { |
73 | BlockDriverState *bs; | |
74 | /* Drive status */ | |
75 | fdrive_type_t drive; | |
baca51fa | 76 | fdrive_flags_t drflags; |
8977f3c1 | 77 | uint8_t perpendicular; /* 2.88 MB access mode */ |
8977f3c1 FB |
78 | /* Position */ |
79 | uint8_t head; | |
80 | uint8_t track; | |
81 | uint8_t sect; | |
82 | /* Last operation status */ | |
83 | uint8_t dir; /* Direction */ | |
84 | uint8_t rw; /* Read/write */ | |
85 | /* Media */ | |
baca51fa | 86 | fdisk_flags_t flags; |
8977f3c1 FB |
87 | uint8_t last_sect; /* Nb sector per track */ |
88 | uint8_t max_track; /* Nb of tracks */ | |
baca51fa | 89 | uint16_t bps; /* Bytes per sector */ |
8977f3c1 FB |
90 | uint8_t ro; /* Is read-only */ |
91 | } fdrive_t; | |
92 | ||
caed8802 | 93 | static void fd_init (fdrive_t *drv, BlockDriverState *bs) |
8977f3c1 FB |
94 | { |
95 | /* Drive */ | |
caed8802 FB |
96 | drv->bs = bs; |
97 | if (bs) | |
98 | drv->drive = FDRIVE_DRV_144; | |
99 | else | |
100 | drv->drive = FDRIVE_DRV_NONE; | |
baca51fa | 101 | drv->drflags = 0; |
8977f3c1 | 102 | drv->perpendicular = 0; |
8977f3c1 | 103 | /* Disk */ |
baca51fa | 104 | drv->last_sect = 0; |
8977f3c1 FB |
105 | drv->max_track = 0; |
106 | } | |
107 | ||
108 | static int _fd_sector (uint8_t head, uint8_t track, | |
109 | uint8_t sect, uint8_t last_sect) | |
110 | { | |
111 | return (((track * 2) + head) * last_sect) + sect - 1; | |
112 | } | |
113 | ||
114 | /* Returns current position, in sectors, for given drive */ | |
115 | static int fd_sector (fdrive_t *drv) | |
116 | { | |
117 | return _fd_sector(drv->head, drv->track, drv->sect, drv->last_sect); | |
118 | } | |
119 | ||
120 | static int fd_seek (fdrive_t *drv, uint8_t head, uint8_t track, uint8_t sect, | |
121 | int enable_seek) | |
122 | { | |
123 | uint32_t sector; | |
baca51fa FB |
124 | int ret; |
125 | ||
126 | if (track > drv->max_track || | |
127 | (head != 0 && (drv->flags & FDISK_DBL_SIDES) == 0)) { | |
128 | FLOPPY_ERROR("try to read %d %02x %02x (max=%d %d %02x %02x)\n", | |
129 | head, track, sect, 1, | |
130 | (drv->flags & FDISK_DBL_SIDES) == 0 ? 0 : 1, | |
131 | drv->max_track, drv->last_sect); | |
8977f3c1 FB |
132 | return 2; |
133 | } | |
134 | if (sect > drv->last_sect) { | |
baca51fa FB |
135 | FLOPPY_ERROR("try to read %d %02x %02x (max=%d %d %02x %02x)\n", |
136 | head, track, sect, 1, | |
137 | (drv->flags & FDISK_DBL_SIDES) == 0 ? 0 : 1, | |
138 | drv->max_track, drv->last_sect); | |
8977f3c1 FB |
139 | return 3; |
140 | } | |
141 | sector = _fd_sector(head, track, sect, drv->last_sect); | |
baca51fa | 142 | ret = 0; |
8977f3c1 FB |
143 | if (sector != fd_sector(drv)) { |
144 | #if 0 | |
145 | if (!enable_seek) { | |
146 | FLOPPY_ERROR("no implicit seek %d %02x %02x (max=%d %02x %02x)\n", | |
147 | head, track, sect, 1, drv->max_track, drv->last_sect); | |
148 | return 4; | |
149 | } | |
150 | #endif | |
151 | drv->head = head; | |
baca51fa FB |
152 | if (drv->track != track) |
153 | ret = 1; | |
8977f3c1 FB |
154 | drv->track = track; |
155 | drv->sect = sect; | |
8977f3c1 FB |
156 | } |
157 | ||
baca51fa | 158 | return ret; |
8977f3c1 FB |
159 | } |
160 | ||
161 | /* Set drive back to track 0 */ | |
162 | static void fd_recalibrate (fdrive_t *drv) | |
163 | { | |
164 | FLOPPY_DPRINTF("recalibrate\n"); | |
165 | drv->head = 0; | |
166 | drv->track = 0; | |
167 | drv->sect = 1; | |
168 | drv->dir = 1; | |
169 | drv->rw = 0; | |
170 | } | |
171 | ||
a541f297 FB |
172 | /* Recognize floppy formats */ |
173 | typedef struct fd_format_t { | |
174 | fdrive_type_t drive; | |
175 | fdisk_type_t disk; | |
176 | uint8_t last_sect; | |
177 | uint8_t max_track; | |
178 | uint8_t max_head; | |
179 | const unsigned char *str; | |
180 | } fd_format_t; | |
181 | ||
182 | static fd_format_t fd_formats[] = { | |
183 | /* First entry is default format */ | |
184 | /* 1.44 MB 3"1/2 floppy disks */ | |
185 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 18, 80, 1, "1.44 MB 3\"1/2", }, | |
186 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 20, 80, 1, "1.6 MB 3\"1/2", }, | |
187 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 21, 80, 1, "1.68 MB 3\"1/2", }, | |
188 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 21, 82, 1, "1.72 MB 3\"1/2", }, | |
189 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 21, 83, 1, "1.74 MB 3\"1/2", }, | |
190 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 22, 80, 1, "1.76 MB 3\"1/2", }, | |
191 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 23, 80, 1, "1.84 MB 3\"1/2", }, | |
192 | { FDRIVE_DRV_144, FDRIVE_DISK_144, 24, 80, 1, "1.92 MB 3\"1/2", }, | |
193 | /* 2.88 MB 3"1/2 floppy disks */ | |
194 | { FDRIVE_DRV_288, FDRIVE_DISK_288, 36, 80, 1, "2.88 MB 3\"1/2", }, | |
195 | { FDRIVE_DRV_288, FDRIVE_DISK_288, 39, 80, 1, "3.12 MB 3\"1/2", }, | |
196 | { FDRIVE_DRV_288, FDRIVE_DISK_288, 40, 80, 1, "3.2 MB 3\"1/2", }, | |
197 | { FDRIVE_DRV_288, FDRIVE_DISK_288, 44, 80, 1, "3.52 MB 3\"1/2", }, | |
198 | { FDRIVE_DRV_288, FDRIVE_DISK_288, 48, 80, 1, "3.84 MB 3\"1/2", }, | |
199 | /* 720 kB 3"1/2 floppy disks */ | |
200 | { FDRIVE_DRV_144, FDRIVE_DISK_720, 9, 80, 1, "720 kB 3\"1/2", }, | |
201 | { FDRIVE_DRV_144, FDRIVE_DISK_720, 10, 80, 1, "800 kB 3\"1/2", }, | |
202 | { FDRIVE_DRV_144, FDRIVE_DISK_720, 10, 82, 1, "820 kB 3\"1/2", }, | |
203 | { FDRIVE_DRV_144, FDRIVE_DISK_720, 10, 83, 1, "830 kB 3\"1/2", }, | |
204 | { FDRIVE_DRV_144, FDRIVE_DISK_720, 13, 80, 1, "1.04 MB 3\"1/2", }, | |
205 | { FDRIVE_DRV_144, FDRIVE_DISK_720, 14, 80, 1, "1.12 MB 3\"1/2", }, | |
206 | /* 1.2 MB 5"1/4 floppy disks */ | |
207 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 15, 80, 1, "1.2 kB 5\"1/4", }, | |
208 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 18, 80, 1, "1.44 MB 5\"1/4", }, | |
209 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 18, 82, 1, "1.48 MB 5\"1/4", }, | |
210 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 18, 83, 1, "1.49 MB 5\"1/4", }, | |
211 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 20, 80, 1, "1.6 MB 5\"1/4", }, | |
212 | /* 720 kB 5"1/4 floppy disks */ | |
213 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 9, 80, 1, "720 kB 5\"1/4", }, | |
214 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 11, 80, 1, "880 kB 5\"1/4", }, | |
215 | /* 360 kB 5"1/4 floppy disks */ | |
216 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 9, 40, 1, "360 kB 5\"1/4", }, | |
217 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 9, 40, 0, "180 kB 5\"1/4", }, | |
218 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 10, 41, 1, "410 kB 5\"1/4", }, | |
219 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 10, 42, 1, "420 kB 5\"1/4", }, | |
220 | /* 320 kB 5"1/4 floppy disks */ | |
221 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 8, 40, 1, "320 kB 5\"1/4", }, | |
222 | { FDRIVE_DRV_120, FDRIVE_DISK_288, 8, 40, 0, "160 kB 5\"1/4", }, | |
223 | /* 360 kB must match 5"1/4 better than 3"1/2... */ | |
224 | { FDRIVE_DRV_144, FDRIVE_DISK_720, 9, 80, 0, "360 kB 3\"1/2", }, | |
225 | /* end */ | |
226 | { FDRIVE_DRV_NONE, FDRIVE_DISK_NONE, -1, -1, 0, NULL, }, | |
227 | }; | |
228 | ||
8977f3c1 | 229 | /* Revalidate a disk drive after a disk change */ |
caed8802 | 230 | static void fd_revalidate (fdrive_t *drv) |
8977f3c1 | 231 | { |
a541f297 FB |
232 | fd_format_t *parse; |
233 | int64_t nb_sectors, size; | |
234 | int i, first_match, match; | |
baca51fa | 235 | int nb_heads, max_track, last_sect, ro; |
8977f3c1 FB |
236 | |
237 | FLOPPY_DPRINTF("revalidate\n"); | |
baca51fa | 238 | drv->drflags &= ~FDRIVE_REVALIDATE; |
a541f297 | 239 | if (drv->bs != NULL && bdrv_is_inserted(drv->bs)) { |
baca51fa | 240 | ro = bdrv_is_read_only(drv->bs); |
a541f297 | 241 | bdrv_get_geometry_hint(drv->bs, &nb_heads, &max_track, &last_sect); |
baca51fa | 242 | if (nb_heads != 0 && max_track != 0 && last_sect != 0) { |
baca51fa FB |
243 | printf("User defined disk (%d %d %d)", |
244 | nb_heads - 1, max_track, last_sect); | |
a541f297 FB |
245 | } else { |
246 | bdrv_get_geometry(drv->bs, &nb_sectors); | |
247 | match = -1; | |
248 | first_match = -1; | |
249 | for (i = 0;; i++) { | |
250 | parse = &fd_formats[i]; | |
251 | if (parse->drive == FDRIVE_DRV_NONE) | |
252 | break; | |
253 | if (drv->drive == parse->drive || | |
254 | drv->drive == FDRIVE_DRV_NONE) { | |
255 | size = (parse->max_head + 1) * parse->max_track * | |
256 | parse->last_sect; | |
257 | if (nb_sectors == size) { | |
258 | match = i; | |
259 | break; | |
260 | } | |
261 | if (first_match == -1) | |
262 | first_match = i; | |
263 | } | |
264 | } | |
265 | if (match == -1) { | |
266 | if (first_match == -1) | |
267 | match = 1; | |
268 | else | |
269 | match = first_match; | |
270 | parse = &fd_formats[match]; | |
271 | } | |
272 | nb_heads = parse->max_head + 1; | |
273 | max_track = parse->max_track; | |
274 | last_sect = parse->last_sect; | |
275 | drv->drive = parse->drive; | |
276 | printf("%s floppy disk (%d h %d t %d s) %s\n", parse->str, | |
277 | nb_heads, max_track, last_sect, ro ? "ro" : "rw"); | |
278 | } | |
baca51fa FB |
279 | if (nb_heads == 1) { |
280 | drv->flags &= ~FDISK_DBL_SIDES; | |
281 | } else { | |
282 | drv->flags |= FDISK_DBL_SIDES; | |
283 | } | |
284 | drv->max_track = max_track; | |
285 | drv->last_sect = last_sect; | |
baca51fa | 286 | drv->ro = ro; |
8977f3c1 | 287 | } else { |
baca51fa | 288 | printf("No disk in drive\n"); |
baca51fa FB |
289 | drv->last_sect = 0; |
290 | drv->max_track = 0; | |
291 | drv->flags &= ~FDISK_DBL_SIDES; | |
8977f3c1 | 292 | } |
baca51fa | 293 | drv->drflags |= FDRIVE_REVALIDATE; |
caed8802 FB |
294 | } |
295 | ||
8977f3c1 FB |
296 | /* Motor control */ |
297 | static void fd_start (fdrive_t *drv) | |
298 | { | |
baca51fa | 299 | drv->drflags |= FDRIVE_MOTOR_ON; |
8977f3c1 FB |
300 | } |
301 | ||
302 | static void fd_stop (fdrive_t *drv) | |
303 | { | |
baca51fa | 304 | drv->drflags &= ~FDRIVE_MOTOR_ON; |
8977f3c1 FB |
305 | } |
306 | ||
307 | /* Re-initialise a drives (motor off, repositioned) */ | |
308 | static void fd_reset (fdrive_t *drv) | |
309 | { | |
310 | fd_stop(drv); | |
311 | fd_recalibrate(drv); | |
312 | } | |
313 | ||
314 | /********************************************************/ | |
315 | /* Intel 82078 floppy disk controler emulation */ | |
316 | ||
baca51fa FB |
317 | static void fdctrl_reset (fdctrl_t *fdctrl, int do_irq); |
318 | static void fdctrl_reset_fifo (fdctrl_t *fdctrl); | |
f9e92e97 | 319 | static int fdctrl_transfer_handler (void *opaque, target_ulong addr, int size); |
baca51fa FB |
320 | static void fdctrl_raise_irq (fdctrl_t *fdctrl, uint8_t status); |
321 | ||
322 | static uint32_t fdctrl_read_statusB (fdctrl_t *fdctrl); | |
323 | static uint32_t fdctrl_read_dor (fdctrl_t *fdctrl); | |
324 | static void fdctrl_write_dor (fdctrl_t *fdctrl, uint32_t value); | |
325 | static uint32_t fdctrl_read_tape (fdctrl_t *fdctrl); | |
326 | static void fdctrl_write_tape (fdctrl_t *fdctrl, uint32_t value); | |
327 | static uint32_t fdctrl_read_main_status (fdctrl_t *fdctrl); | |
328 | static void fdctrl_write_rate (fdctrl_t *fdctrl, uint32_t value); | |
329 | static uint32_t fdctrl_read_data (fdctrl_t *fdctrl); | |
330 | static void fdctrl_write_data (fdctrl_t *fdctrl, uint32_t value); | |
331 | static uint32_t fdctrl_read_dir (fdctrl_t *fdctrl); | |
8977f3c1 FB |
332 | |
333 | enum { | |
334 | FD_CTRL_ACTIVE = 0x01, | |
335 | FD_CTRL_RESET = 0x02, | |
336 | FD_CTRL_SLEEP = 0x04, | |
337 | FD_CTRL_BUSY = 0x08, | |
338 | FD_CTRL_INTR = 0x10, | |
339 | }; | |
340 | ||
341 | enum { | |
342 | FD_DIR_WRITE = 0, | |
343 | FD_DIR_READ = 1, | |
344 | FD_DIR_SCANE = 2, | |
345 | FD_DIR_SCANL = 3, | |
346 | FD_DIR_SCANH = 4, | |
347 | }; | |
348 | ||
349 | enum { | |
350 | FD_STATE_CMD = 0x00, | |
351 | FD_STATE_STATUS = 0x01, | |
352 | FD_STATE_DATA = 0x02, | |
353 | FD_STATE_STATE = 0x03, | |
354 | FD_STATE_MULTI = 0x10, | |
355 | FD_STATE_SEEK = 0x20, | |
baca51fa | 356 | FD_STATE_FORMAT = 0x40, |
8977f3c1 FB |
357 | }; |
358 | ||
359 | #define FD_STATE(state) ((state) & FD_STATE_STATE) | |
baca51fa FB |
360 | #define FD_SET_STATE(state, new_state) \ |
361 | do { (state) = ((state) & ~FD_STATE_STATE) | (new_state); } while (0) | |
8977f3c1 FB |
362 | #define FD_MULTI_TRACK(state) ((state) & FD_STATE_MULTI) |
363 | #define FD_DID_SEEK(state) ((state) & FD_STATE_SEEK) | |
baca51fa | 364 | #define FD_FORMAT_CMD(state) ((state) & FD_STATE_FORMAT) |
8977f3c1 | 365 | |
baca51fa FB |
366 | struct fdctrl_t { |
367 | fdctrl_t *fdctrl; | |
8977f3c1 FB |
368 | /* Controler's identification */ |
369 | uint8_t version; | |
370 | /* HW */ | |
371 | int irq_lvl; | |
372 | int dma_chann; | |
baca51fa | 373 | uint32_t io_base; |
8977f3c1 FB |
374 | /* Controler state */ |
375 | uint8_t state; | |
376 | uint8_t dma_en; | |
377 | uint8_t cur_drv; | |
378 | uint8_t bootsel; | |
379 | /* Command FIFO */ | |
380 | uint8_t fifo[FD_SECTOR_LEN]; | |
381 | uint32_t data_pos; | |
382 | uint32_t data_len; | |
383 | uint8_t data_state; | |
384 | uint8_t data_dir; | |
385 | uint8_t int_status; | |
386 | /* States kept only to be returned back */ | |
387 | /* Timers state */ | |
388 | uint8_t timer0; | |
389 | uint8_t timer1; | |
390 | /* precompensation */ | |
391 | uint8_t precomp_trk; | |
392 | uint8_t config; | |
393 | uint8_t lock; | |
394 | /* Power down config (also with status regB access mode */ | |
395 | uint8_t pwrd; | |
396 | /* Floppy drives */ | |
397 | fdrive_t drives[2]; | |
baca51fa FB |
398 | }; |
399 | ||
400 | static uint32_t fdctrl_read (void *opaque, uint32_t reg) | |
401 | { | |
402 | fdctrl_t *fdctrl = opaque; | |
403 | uint32_t retval; | |
404 | ||
a541f297 FB |
405 | switch (reg & 0x07) { |
406 | case 0x01: | |
baca51fa | 407 | retval = fdctrl_read_statusB(fdctrl); |
a541f297 FB |
408 | break; |
409 | case 0x02: | |
baca51fa | 410 | retval = fdctrl_read_dor(fdctrl); |
a541f297 FB |
411 | break; |
412 | case 0x03: | |
baca51fa | 413 | retval = fdctrl_read_tape(fdctrl); |
a541f297 FB |
414 | break; |
415 | case 0x04: | |
baca51fa | 416 | retval = fdctrl_read_main_status(fdctrl); |
a541f297 FB |
417 | break; |
418 | case 0x05: | |
baca51fa | 419 | retval = fdctrl_read_data(fdctrl); |
a541f297 FB |
420 | break; |
421 | case 0x07: | |
baca51fa | 422 | retval = fdctrl_read_dir(fdctrl); |
a541f297 FB |
423 | break; |
424 | default: | |
baca51fa | 425 | retval = (uint32_t)(-1); |
a541f297 FB |
426 | break; |
427 | } | |
baca51fa FB |
428 | |
429 | return retval; | |
430 | } | |
431 | ||
432 | static void fdctrl_write (void *opaque, uint32_t reg, uint32_t value) | |
433 | { | |
434 | fdctrl_t *fdctrl = opaque; | |
435 | ||
a541f297 FB |
436 | switch (reg & 0x07) { |
437 | case 0x02: | |
baca51fa | 438 | fdctrl_write_dor(fdctrl, value); |
a541f297 FB |
439 | break; |
440 | case 0x03: | |
baca51fa | 441 | fdctrl_write_tape(fdctrl, value); |
a541f297 FB |
442 | break; |
443 | case 0x04: | |
baca51fa | 444 | fdctrl_write_rate(fdctrl, value); |
a541f297 FB |
445 | break; |
446 | case 0x05: | |
baca51fa | 447 | fdctrl_write_data(fdctrl, value); |
a541f297 FB |
448 | break; |
449 | default: | |
450 | break; | |
451 | } | |
baca51fa FB |
452 | } |
453 | ||
454 | static void fd_change_cb (void *opaque) | |
455 | { | |
456 | fdrive_t *drv = opaque; | |
8977f3c1 | 457 | |
baca51fa | 458 | FLOPPY_DPRINTF("disk change\n"); |
baca51fa FB |
459 | fd_revalidate(drv); |
460 | #if 0 | |
461 | fd_recalibrate(drv); | |
462 | fdctrl_reset_fifo(drv->fdctrl); | |
463 | fdctrl_raise_irq(drv->fdctrl, 0x20); | |
464 | #endif | |
465 | } | |
8977f3c1 | 466 | |
baca51fa FB |
467 | fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped, |
468 | uint32_t io_base, | |
469 | BlockDriverState **fds) | |
8977f3c1 | 470 | { |
baca51fa | 471 | fdctrl_t *fdctrl; |
8977f3c1 FB |
472 | // int io_mem; |
473 | int i; | |
474 | ||
475 | FLOPPY_DPRINTF("init controler\n"); | |
baca51fa FB |
476 | fdctrl = qemu_mallocz(sizeof(fdctrl_t)); |
477 | if (!fdctrl) | |
478 | return NULL; | |
479 | fdctrl->version = 0x90; /* Intel 82078 controler */ | |
480 | fdctrl->irq_lvl = irq_lvl; | |
481 | fdctrl->dma_chann = dma_chann; | |
482 | fdctrl->io_base = io_base; | |
a541f297 | 483 | fdctrl->config = 0x60; /* Implicit seek, polling & FIFO enabled */ |
baca51fa FB |
484 | if (fdctrl->dma_chann != -1) { |
485 | fdctrl->dma_en = 1; | |
486 | DMA_register_channel(dma_chann, &fdctrl_transfer_handler, fdctrl); | |
8977f3c1 | 487 | } else { |
baca51fa | 488 | fdctrl->dma_en = 0; |
8977f3c1 | 489 | } |
baca51fa FB |
490 | for (i = 0; i < 2; i++) { |
491 | fd_init(&fdctrl->drives[i], fds[i]); | |
492 | if (fds[i]) { | |
493 | bdrv_set_change_cb(fds[i], | |
494 | &fd_change_cb, &fdctrl->drives[i]); | |
495 | } | |
caed8802 | 496 | } |
baca51fa FB |
497 | fdctrl_reset(fdctrl, 0); |
498 | fdctrl->state = FD_CTRL_ACTIVE; | |
8977f3c1 FB |
499 | if (mem_mapped) { |
500 | FLOPPY_ERROR("memory mapped floppy not supported by now !\n"); | |
501 | #if 0 | |
502 | io_mem = cpu_register_io_memory(0, fdctrl_mem_read, fdctrl_mem_write); | |
503 | cpu_register_physical_memory(base, 0x08, io_mem); | |
504 | #endif | |
505 | } else { | |
baca51fa FB |
506 | register_ioport_read(io_base + 0x01, 5, 1, &fdctrl_read, fdctrl); |
507 | register_ioport_read(io_base + 0x07, 1, 1, &fdctrl_read, fdctrl); | |
508 | register_ioport_write(io_base + 0x01, 5, 1, &fdctrl_write, fdctrl); | |
509 | register_ioport_write(io_base + 0x07, 1, 1, &fdctrl_write, fdctrl); | |
8977f3c1 | 510 | } |
a541f297 | 511 | for (i = 0; i < 2; i++) { |
baca51fa | 512 | fd_revalidate(&fdctrl->drives[i]); |
8977f3c1 | 513 | } |
a541f297 | 514 | |
baca51fa | 515 | return fdctrl; |
caed8802 | 516 | } |
8977f3c1 | 517 | |
baca51fa FB |
518 | /* XXX: may change if moved to bdrv */ |
519 | int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num) | |
caed8802 | 520 | { |
baca51fa | 521 | return fdctrl->drives[drive_num].drive; |
8977f3c1 FB |
522 | } |
523 | ||
524 | /* Change IRQ state */ | |
baca51fa | 525 | static void fdctrl_reset_irq (fdctrl_t *fdctrl) |
8977f3c1 | 526 | { |
baca51fa FB |
527 | if (fdctrl->state & FD_CTRL_INTR) { |
528 | pic_set_irq(fdctrl->irq_lvl, 0); | |
529 | fdctrl->state &= ~(FD_CTRL_INTR | FD_CTRL_SLEEP | FD_CTRL_BUSY); | |
8977f3c1 FB |
530 | } |
531 | } | |
532 | ||
baca51fa | 533 | static void fdctrl_raise_irq (fdctrl_t *fdctrl, uint8_t status) |
8977f3c1 | 534 | { |
baca51fa FB |
535 | if (~(fdctrl->state & FD_CTRL_INTR)) { |
536 | pic_set_irq(fdctrl->irq_lvl, 1); | |
537 | fdctrl->state |= FD_CTRL_INTR; | |
8977f3c1 FB |
538 | } |
539 | FLOPPY_DPRINTF("Set interrupt status to 0x%02x\n", status); | |
baca51fa | 540 | fdctrl->int_status = status; |
8977f3c1 FB |
541 | } |
542 | ||
543 | /* Reset controler */ | |
baca51fa | 544 | static void fdctrl_reset (fdctrl_t *fdctrl, int do_irq) |
8977f3c1 FB |
545 | { |
546 | int i; | |
547 | ||
548 | FLOPPY_DPRINTF("reset controler\n"); | |
baca51fa | 549 | fdctrl_reset_irq(fdctrl); |
8977f3c1 | 550 | /* Initialise controler */ |
baca51fa | 551 | fdctrl->cur_drv = 0; |
8977f3c1 | 552 | /* FIFO state */ |
baca51fa FB |
553 | fdctrl->data_pos = 0; |
554 | fdctrl->data_len = 0; | |
555 | fdctrl->data_state = FD_STATE_CMD; | |
556 | fdctrl->data_dir = FD_DIR_WRITE; | |
8977f3c1 | 557 | for (i = 0; i < MAX_FD; i++) |
baca51fa FB |
558 | fd_reset(&fdctrl->drives[i]); |
559 | fdctrl_reset_fifo(fdctrl); | |
8977f3c1 | 560 | if (do_irq) |
baca51fa FB |
561 | fdctrl_raise_irq(fdctrl, 0x20); |
562 | } | |
563 | ||
564 | static inline fdrive_t *drv0 (fdctrl_t *fdctrl) | |
565 | { | |
566 | return &fdctrl->drives[fdctrl->bootsel]; | |
567 | } | |
568 | ||
569 | static inline fdrive_t *drv1 (fdctrl_t *fdctrl) | |
570 | { | |
571 | return &fdctrl->drives[1 - fdctrl->bootsel]; | |
572 | } | |
573 | ||
574 | static fdrive_t *get_cur_drv (fdctrl_t *fdctrl) | |
575 | { | |
576 | return fdctrl->cur_drv == 0 ? drv0(fdctrl) : drv1(fdctrl); | |
8977f3c1 FB |
577 | } |
578 | ||
579 | /* Status B register : 0x01 (read-only) */ | |
baca51fa | 580 | static uint32_t fdctrl_read_statusB (fdctrl_t *fdctrl) |
8977f3c1 | 581 | { |
baca51fa | 582 | fdctrl_reset_irq(fdctrl); |
8977f3c1 FB |
583 | FLOPPY_DPRINTF("status register: 0x00\n"); |
584 | ||
585 | return 0; | |
586 | } | |
587 | ||
588 | /* Digital output register : 0x02 */ | |
baca51fa | 589 | static uint32_t fdctrl_read_dor (fdctrl_t *fdctrl) |
8977f3c1 | 590 | { |
8977f3c1 FB |
591 | uint32_t retval = 0; |
592 | ||
8977f3c1 | 593 | /* Drive motors state indicators */ |
baca51fa FB |
594 | if (drv0(fdctrl)->drflags & FDRIVE_MOTOR_ON) |
595 | retval |= 1 << 5; | |
596 | if (drv1(fdctrl)->drflags & FDRIVE_MOTOR_ON) | |
597 | retval |= 1 << 4; | |
8977f3c1 | 598 | /* DMA enable */ |
baca51fa | 599 | retval |= fdctrl->dma_en << 3; |
8977f3c1 | 600 | /* Reset indicator */ |
baca51fa | 601 | retval |= (fdctrl->state & FD_CTRL_RESET) == 0 ? 0x04 : 0; |
8977f3c1 | 602 | /* Selected drive */ |
baca51fa | 603 | retval |= fdctrl->cur_drv; |
8977f3c1 FB |
604 | FLOPPY_DPRINTF("digital output register: 0x%02x\n", retval); |
605 | ||
606 | return retval; | |
607 | } | |
608 | ||
baca51fa | 609 | static void fdctrl_write_dor (fdctrl_t *fdctrl, uint32_t value) |
8977f3c1 | 610 | { |
baca51fa | 611 | fdctrl_reset_irq(fdctrl); |
8977f3c1 | 612 | /* Reset mode */ |
baca51fa | 613 | if (fdctrl->state & FD_CTRL_RESET) { |
8977f3c1 FB |
614 | if (!(value & 0x04)) { |
615 | FLOPPY_DPRINTF("Floppy controler in RESET state !\n"); | |
616 | return; | |
617 | } | |
618 | } | |
619 | FLOPPY_DPRINTF("digital output register set to 0x%02x\n", value); | |
620 | /* Drive motors state indicators */ | |
621 | if (value & 0x20) | |
baca51fa | 622 | fd_start(drv1(fdctrl)); |
8977f3c1 | 623 | else |
baca51fa | 624 | fd_stop(drv1(fdctrl)); |
8977f3c1 | 625 | if (value & 0x10) |
baca51fa | 626 | fd_start(drv0(fdctrl)); |
8977f3c1 | 627 | else |
baca51fa | 628 | fd_stop(drv0(fdctrl)); |
8977f3c1 FB |
629 | /* DMA enable */ |
630 | #if 0 | |
baca51fa FB |
631 | if (fdctrl->dma_chann != -1) |
632 | fdctrl->dma_en = 1 - ((value >> 3) & 1); | |
8977f3c1 FB |
633 | #endif |
634 | /* Reset */ | |
635 | if (!(value & 0x04)) { | |
baca51fa | 636 | if (!(fdctrl->state & FD_CTRL_RESET)) { |
8977f3c1 | 637 | FLOPPY_DPRINTF("controler enter RESET state\n"); |
baca51fa | 638 | fdctrl->state |= FD_CTRL_RESET; |
8977f3c1 FB |
639 | } |
640 | } else { | |
baca51fa | 641 | if (fdctrl->state & FD_CTRL_RESET) { |
8977f3c1 | 642 | FLOPPY_DPRINTF("controler out of RESET state\n"); |
fb6cf1d0 | 643 | fdctrl_reset(fdctrl, 1); |
baca51fa | 644 | fdctrl->state &= ~(FD_CTRL_RESET | FD_CTRL_SLEEP); |
8977f3c1 FB |
645 | } |
646 | } | |
647 | /* Selected drive */ | |
baca51fa | 648 | fdctrl->cur_drv = value & 1; |
8977f3c1 FB |
649 | } |
650 | ||
651 | /* Tape drive register : 0x03 */ | |
baca51fa | 652 | static uint32_t fdctrl_read_tape (fdctrl_t *fdctrl) |
8977f3c1 FB |
653 | { |
654 | uint32_t retval = 0; | |
655 | ||
baca51fa | 656 | fdctrl_reset_irq(fdctrl); |
8977f3c1 | 657 | /* Disk boot selection indicator */ |
baca51fa | 658 | retval |= fdctrl->bootsel << 2; |
8977f3c1 FB |
659 | /* Tape indicators: never allowed */ |
660 | FLOPPY_DPRINTF("tape drive register: 0x%02x\n", retval); | |
661 | ||
662 | return retval; | |
663 | } | |
664 | ||
baca51fa | 665 | static void fdctrl_write_tape (fdctrl_t *fdctrl, uint32_t value) |
8977f3c1 | 666 | { |
baca51fa | 667 | fdctrl_reset_irq(fdctrl); |
8977f3c1 | 668 | /* Reset mode */ |
baca51fa | 669 | if (fdctrl->state & FD_CTRL_RESET) { |
8977f3c1 FB |
670 | FLOPPY_DPRINTF("Floppy controler in RESET state !\n"); |
671 | return; | |
672 | } | |
673 | FLOPPY_DPRINTF("tape drive register set to 0x%02x\n", value); | |
674 | /* Disk boot selection indicator */ | |
baca51fa | 675 | fdctrl->bootsel = (value >> 2) & 1; |
8977f3c1 FB |
676 | /* Tape indicators: never allow */ |
677 | } | |
678 | ||
679 | /* Main status register : 0x04 (read) */ | |
baca51fa | 680 | static uint32_t fdctrl_read_main_status (fdctrl_t *fdctrl) |
8977f3c1 FB |
681 | { |
682 | uint32_t retval = 0; | |
683 | ||
baca51fa FB |
684 | fdctrl_reset_irq(fdctrl); |
685 | fdctrl->state &= ~(FD_CTRL_SLEEP | FD_CTRL_RESET); | |
686 | if (!(fdctrl->state & FD_CTRL_BUSY)) { | |
8977f3c1 FB |
687 | /* Data transfer allowed */ |
688 | retval |= 0x80; | |
689 | /* Data transfer direction indicator */ | |
baca51fa | 690 | if (fdctrl->data_dir == FD_DIR_READ) |
8977f3c1 FB |
691 | retval |= 0x40; |
692 | } | |
693 | /* Should handle 0x20 for SPECIFY command */ | |
694 | /* Command busy indicator */ | |
baca51fa FB |
695 | if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA || |
696 | FD_STATE(fdctrl->data_state) == FD_STATE_STATUS) | |
8977f3c1 FB |
697 | retval |= 0x10; |
698 | FLOPPY_DPRINTF("main status register: 0x%02x\n", retval); | |
699 | ||
700 | return retval; | |
701 | } | |
702 | ||
703 | /* Data select rate register : 0x04 (write) */ | |
baca51fa | 704 | static void fdctrl_write_rate (fdctrl_t *fdctrl, uint32_t value) |
8977f3c1 | 705 | { |
baca51fa | 706 | fdctrl_reset_irq(fdctrl); |
8977f3c1 | 707 | /* Reset mode */ |
baca51fa | 708 | if (fdctrl->state & FD_CTRL_RESET) { |
8977f3c1 FB |
709 | FLOPPY_DPRINTF("Floppy controler in RESET state !\n"); |
710 | return; | |
711 | } | |
8977f3c1 FB |
712 | FLOPPY_DPRINTF("select rate register set to 0x%02x\n", value); |
713 | /* Reset: autoclear */ | |
714 | if (value & 0x80) { | |
baca51fa FB |
715 | fdctrl->state |= FD_CTRL_RESET; |
716 | fdctrl_reset(fdctrl, 1); | |
717 | fdctrl->state &= ~FD_CTRL_RESET; | |
8977f3c1 FB |
718 | } |
719 | if (value & 0x40) { | |
baca51fa FB |
720 | fdctrl->state |= FD_CTRL_SLEEP; |
721 | fdctrl_reset(fdctrl, 1); | |
8977f3c1 FB |
722 | } |
723 | // fdctrl.precomp = (value >> 2) & 0x07; | |
724 | } | |
725 | ||
726 | /* Digital input register : 0x07 (read-only) */ | |
baca51fa | 727 | static uint32_t fdctrl_read_dir (fdctrl_t *fdctrl) |
8977f3c1 | 728 | { |
8977f3c1 FB |
729 | uint32_t retval = 0; |
730 | ||
baca51fa FB |
731 | fdctrl_reset_irq(fdctrl); |
732 | if (drv0(fdctrl)->drflags & FDRIVE_REVALIDATE || | |
733 | drv1(fdctrl)->drflags & FDRIVE_REVALIDATE) | |
8977f3c1 FB |
734 | retval |= 0x80; |
735 | if (retval != 0) | |
baca51fa FB |
736 | FLOPPY_DPRINTF("Floppy digital input register: 0x%02x\n", retval); |
737 | drv0(fdctrl)->drflags &= ~FDRIVE_REVALIDATE; | |
738 | drv1(fdctrl)->drflags &= ~FDRIVE_REVALIDATE; | |
8977f3c1 FB |
739 | |
740 | return retval; | |
741 | } | |
742 | ||
743 | /* FIFO state control */ | |
baca51fa | 744 | static void fdctrl_reset_fifo (fdctrl_t *fdctrl) |
8977f3c1 | 745 | { |
baca51fa FB |
746 | fdctrl->data_dir = FD_DIR_WRITE; |
747 | fdctrl->data_pos = 0; | |
748 | FD_SET_STATE(fdctrl->data_state, FD_STATE_CMD); | |
8977f3c1 FB |
749 | } |
750 | ||
751 | /* Set FIFO status for the host to read */ | |
baca51fa | 752 | static void fdctrl_set_fifo (fdctrl_t *fdctrl, int fifo_len, int do_irq) |
8977f3c1 | 753 | { |
baca51fa FB |
754 | fdctrl->data_dir = FD_DIR_READ; |
755 | fdctrl->data_len = fifo_len; | |
756 | fdctrl->data_pos = 0; | |
757 | FD_SET_STATE(fdctrl->data_state, FD_STATE_STATUS); | |
8977f3c1 | 758 | if (do_irq) |
baca51fa | 759 | fdctrl_raise_irq(fdctrl, 0x00); |
8977f3c1 FB |
760 | } |
761 | ||
762 | /* Set an error: unimplemented/unknown command */ | |
baca51fa | 763 | static void fdctrl_unimplemented (fdctrl_t *fdctrl) |
8977f3c1 FB |
764 | { |
765 | #if 0 | |
baca51fa FB |
766 | fdrive_t *cur_drv; |
767 | ||
768 | cur_drv = get_cur_drv(fdctrl); | |
769 | fdctrl->fifo[0] = 0x60 | (cur_drv->head << 1) | fdctrl->cur_drv; | |
770 | fdctrl->fifo[1] = 0x00; | |
771 | fdctrl->fifo[2] = 0x00; | |
772 | fdctrl_set_fifo(fdctrl, 3, 1); | |
8977f3c1 | 773 | #else |
baca51fa FB |
774 | // fdctrl_reset_fifo(fdctrl); |
775 | fdctrl->fifo[0] = 0x80; | |
776 | fdctrl_set_fifo(fdctrl, 1, 0); | |
8977f3c1 FB |
777 | #endif |
778 | } | |
779 | ||
780 | /* Callback for transfer end (stop or abort) */ | |
baca51fa FB |
781 | static void fdctrl_stop_transfer (fdctrl_t *fdctrl, uint8_t status0, |
782 | uint8_t status1, uint8_t status2) | |
8977f3c1 | 783 | { |
baca51fa | 784 | fdrive_t *cur_drv; |
8977f3c1 | 785 | |
baca51fa | 786 | cur_drv = get_cur_drv(fdctrl); |
8977f3c1 FB |
787 | FLOPPY_DPRINTF("transfer status: %02x %02x %02x (%02x)\n", |
788 | status0, status1, status2, | |
baca51fa FB |
789 | status0 | (cur_drv->head << 1) | fdctrl->cur_drv); |
790 | fdctrl->fifo[0] = status0 | (cur_drv->head << 1) | fdctrl->cur_drv; | |
791 | fdctrl->fifo[1] = status1; | |
792 | fdctrl->fifo[2] = status2; | |
793 | fdctrl->fifo[3] = cur_drv->track; | |
794 | fdctrl->fifo[4] = cur_drv->head; | |
795 | fdctrl->fifo[5] = cur_drv->sect; | |
796 | fdctrl->fifo[6] = FD_SECTOR_SC; | |
797 | fdctrl->data_dir = FD_DIR_READ; | |
798 | if (fdctrl->state & FD_CTRL_BUSY) | |
799 | DMA_release_DREQ(fdctrl->dma_chann); | |
800 | fdctrl_set_fifo(fdctrl, 7, 1); | |
8977f3c1 FB |
801 | } |
802 | ||
803 | /* Prepare a data transfer (either DMA or FIFO) */ | |
baca51fa | 804 | static void fdctrl_start_transfer (fdctrl_t *fdctrl, int direction) |
8977f3c1 | 805 | { |
baca51fa | 806 | fdrive_t *cur_drv; |
8977f3c1 FB |
807 | uint8_t kh, kt, ks; |
808 | int did_seek; | |
809 | ||
baca51fa FB |
810 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; |
811 | cur_drv = get_cur_drv(fdctrl); | |
812 | kt = fdctrl->fifo[2]; | |
813 | kh = fdctrl->fifo[3]; | |
814 | ks = fdctrl->fifo[4]; | |
8977f3c1 | 815 | FLOPPY_DPRINTF("Start tranfert at %d %d %02x %02x (%d)\n", |
baca51fa | 816 | fdctrl->cur_drv, kh, kt, ks, |
8977f3c1 FB |
817 | _fd_sector(kh, kt, ks, cur_drv->last_sect)); |
818 | did_seek = 0; | |
baca51fa | 819 | switch (fd_seek(cur_drv, kh, kt, ks, fdctrl->config & 0x40)) { |
8977f3c1 FB |
820 | case 2: |
821 | /* sect too big */ | |
baca51fa FB |
822 | fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00); |
823 | fdctrl->fifo[3] = kt; | |
824 | fdctrl->fifo[4] = kh; | |
825 | fdctrl->fifo[5] = ks; | |
8977f3c1 FB |
826 | return; |
827 | case 3: | |
828 | /* track too big */ | |
baca51fa FB |
829 | fdctrl_stop_transfer(fdctrl, 0x40, 0x80, 0x00); |
830 | fdctrl->fifo[3] = kt; | |
831 | fdctrl->fifo[4] = kh; | |
832 | fdctrl->fifo[5] = ks; | |
8977f3c1 FB |
833 | return; |
834 | case 4: | |
835 | /* No seek enabled */ | |
baca51fa FB |
836 | fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00); |
837 | fdctrl->fifo[3] = kt; | |
838 | fdctrl->fifo[4] = kh; | |
839 | fdctrl->fifo[5] = ks; | |
8977f3c1 FB |
840 | return; |
841 | case 1: | |
842 | did_seek = 1; | |
843 | break; | |
844 | default: | |
845 | break; | |
846 | } | |
847 | /* Set the FIFO state */ | |
baca51fa FB |
848 | fdctrl->data_dir = direction; |
849 | fdctrl->data_pos = 0; | |
850 | FD_SET_STATE(fdctrl->data_state, FD_STATE_DATA); /* FIFO ready for data */ | |
851 | if (fdctrl->fifo[0] & 0x80) | |
852 | fdctrl->data_state |= FD_STATE_MULTI; | |
853 | else | |
854 | fdctrl->data_state &= ~FD_STATE_MULTI; | |
8977f3c1 | 855 | if (did_seek) |
baca51fa FB |
856 | fdctrl->data_state |= FD_STATE_SEEK; |
857 | else | |
858 | fdctrl->data_state &= ~FD_STATE_SEEK; | |
859 | if (fdctrl->fifo[5] == 00) { | |
860 | fdctrl->data_len = fdctrl->fifo[8]; | |
861 | } else { | |
862 | int tmp; | |
863 | fdctrl->data_len = 128 << fdctrl->fifo[5]; | |
864 | tmp = (cur_drv->last_sect - ks + 1); | |
865 | if (fdctrl->fifo[0] & 0x80) | |
866 | tmp += cur_drv->last_sect; | |
867 | fdctrl->data_len *= tmp; | |
868 | } | |
869 | if (fdctrl->dma_en) { | |
8977f3c1 FB |
870 | int dma_mode; |
871 | /* DMA transfer are enabled. Check if DMA channel is well programmed */ | |
baca51fa | 872 | dma_mode = DMA_get_channel_mode(fdctrl->dma_chann); |
8977f3c1 | 873 | dma_mode = (dma_mode >> 2) & 3; |
baca51fa FB |
874 | FLOPPY_DPRINTF("dma_mode=%d direction=%d (%d - %d)\n", |
875 | dma_mode, direction, | |
876 | (128 << fdctrl->fifo[5]) * | |
877 | (cur_drv->last_sect - ks + 1), fdctrl->data_len); | |
8977f3c1 FB |
878 | if (((direction == FD_DIR_SCANE || direction == FD_DIR_SCANL || |
879 | direction == FD_DIR_SCANH) && dma_mode == 0) || | |
880 | (direction == FD_DIR_WRITE && dma_mode == 2) || | |
881 | (direction == FD_DIR_READ && dma_mode == 1)) { | |
882 | /* No access is allowed until DMA transfer has completed */ | |
baca51fa | 883 | fdctrl->state |= FD_CTRL_BUSY; |
8977f3c1 FB |
884 | /* Now, we just have to wait for the DMA controler to |
885 | * recall us... | |
886 | */ | |
baca51fa FB |
887 | DMA_hold_DREQ(fdctrl->dma_chann); |
888 | DMA_schedule(fdctrl->dma_chann); | |
8977f3c1 | 889 | return; |
baca51fa FB |
890 | } else { |
891 | FLOPPY_ERROR("dma_mode=%d direction=%d\n", dma_mode, direction); | |
8977f3c1 FB |
892 | } |
893 | } | |
894 | FLOPPY_DPRINTF("start non-DMA transfer\n"); | |
895 | /* IO based transfer: calculate len */ | |
baca51fa | 896 | fdctrl_raise_irq(fdctrl, 0x00); |
8977f3c1 FB |
897 | |
898 | return; | |
899 | } | |
900 | ||
901 | /* Prepare a transfer of deleted data */ | |
baca51fa | 902 | static void fdctrl_start_transfer_del (fdctrl_t *fdctrl, int direction) |
8977f3c1 FB |
903 | { |
904 | /* We don't handle deleted data, | |
905 | * so we don't return *ANYTHING* | |
906 | */ | |
baca51fa | 907 | fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00); |
8977f3c1 FB |
908 | } |
909 | ||
910 | /* handlers for DMA transfers */ | |
f9e92e97 | 911 | static int fdctrl_transfer_handler (void *opaque, target_ulong addr, int size) |
8977f3c1 | 912 | { |
baca51fa FB |
913 | fdctrl_t *fdctrl; |
914 | fdrive_t *cur_drv; | |
915 | int len, start_pos, rel_pos; | |
8977f3c1 FB |
916 | uint8_t status0 = 0x00, status1 = 0x00, status2 = 0x00; |
917 | ||
baca51fa FB |
918 | fdctrl = opaque; |
919 | fdctrl_reset_irq(fdctrl); | |
920 | if (!(fdctrl->state & FD_CTRL_BUSY)) { | |
8977f3c1 FB |
921 | FLOPPY_DPRINTF("Not in DMA transfer mode !\n"); |
922 | return 0; | |
923 | } | |
baca51fa FB |
924 | cur_drv = get_cur_drv(fdctrl); |
925 | if (fdctrl->data_dir == FD_DIR_SCANE || fdctrl->data_dir == FD_DIR_SCANL || | |
926 | fdctrl->data_dir == FD_DIR_SCANH) | |
8977f3c1 | 927 | status2 = 0x04; |
baca51fa FB |
928 | if (size > fdctrl->data_len) |
929 | size = fdctrl->data_len; | |
69e5bc90 | 930 | if (cur_drv->bs == NULL) { |
baca51fa FB |
931 | if (fdctrl->data_dir == FD_DIR_WRITE) |
932 | fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00); | |
933 | else | |
934 | fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00); | |
935 | len = 0; | |
69e5bc90 FB |
936 | goto transfer_error; |
937 | } | |
baca51fa FB |
938 | rel_pos = fdctrl->data_pos % FD_SECTOR_LEN; |
939 | for (start_pos = fdctrl->data_pos; fdctrl->data_pos < size;) { | |
940 | len = size - fdctrl->data_pos; | |
941 | if (len + rel_pos > FD_SECTOR_LEN) | |
942 | len = FD_SECTOR_LEN - rel_pos; | |
943 | FLOPPY_DPRINTF("copy %d bytes (%d %d %d) %d pos %d %02x %02x " | |
944 | "(%d-0x%08x 0x%08x)\n", len, size, fdctrl->data_pos, | |
945 | fdctrl->data_len, fdctrl->cur_drv, cur_drv->head, | |
946 | cur_drv->track, cur_drv->sect, fd_sector(cur_drv), | |
947 | fd_sector(cur_drv) * 512, addr); | |
948 | if (fdctrl->data_dir != FD_DIR_WRITE || | |
949 | len < FD_SECTOR_LEN || rel_pos != 0) { | |
950 | /* READ & SCAN commands and realign to a sector for WRITE */ | |
951 | if (bdrv_read(cur_drv->bs, fd_sector(cur_drv), | |
952 | fdctrl->fifo, 1) < 0) { | |
8977f3c1 FB |
953 | FLOPPY_DPRINTF("Floppy: error getting sector %d\n", |
954 | fd_sector(cur_drv)); | |
955 | /* Sure, image size is too small... */ | |
baca51fa | 956 | memset(fdctrl->fifo, 0, FD_SECTOR_LEN); |
8977f3c1 | 957 | } |
8977f3c1 | 958 | } |
baca51fa FB |
959 | switch (fdctrl->data_dir) { |
960 | case FD_DIR_READ: | |
961 | /* READ commands */ | |
962 | cpu_physical_memory_write(addr + fdctrl->data_pos, | |
963 | fdctrl->fifo + rel_pos, len); | |
964 | break; | |
965 | case FD_DIR_WRITE: | |
966 | /* WRITE commands */ | |
967 | cpu_physical_memory_read(addr + fdctrl->data_pos, | |
968 | fdctrl->fifo + rel_pos, len); | |
969 | if (bdrv_write(cur_drv->bs, fd_sector(cur_drv), | |
970 | fdctrl->fifo, 1) < 0) { | |
971 | FLOPPY_ERROR("writting sector %d\n", fd_sector(cur_drv)); | |
972 | fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00); | |
973 | goto transfer_error; | |
f9e92e97 | 974 | } |
baca51fa FB |
975 | break; |
976 | default: | |
977 | /* SCAN commands */ | |
978 | { | |
979 | uint8_t tmpbuf[FD_SECTOR_LEN]; | |
980 | int ret; | |
981 | cpu_physical_memory_read(addr + fdctrl->data_pos, | |
982 | tmpbuf, len); | |
983 | ret = memcmp(tmpbuf, fdctrl->fifo + rel_pos, len); | |
8977f3c1 FB |
984 | if (ret == 0) { |
985 | status2 = 0x08; | |
986 | goto end_transfer; | |
987 | } | |
baca51fa FB |
988 | if ((ret < 0 && fdctrl->data_dir == FD_DIR_SCANL) || |
989 | (ret > 0 && fdctrl->data_dir == FD_DIR_SCANH)) { | |
8977f3c1 FB |
990 | status2 = 0x00; |
991 | goto end_transfer; | |
992 | } | |
993 | } | |
baca51fa | 994 | break; |
8977f3c1 | 995 | } |
baca51fa FB |
996 | fdctrl->data_pos += len; |
997 | rel_pos = fdctrl->data_pos % FD_SECTOR_LEN; | |
998 | if (rel_pos == 0) { | |
8977f3c1 | 999 | /* Seek to next sector */ |
baca51fa FB |
1000 | cur_drv->sect++; |
1001 | FLOPPY_DPRINTF("seek to next sector (%d %02x %02x => %d) (%d)\n", | |
1002 | cur_drv->head, cur_drv->track, cur_drv->sect, | |
1003 | fd_sector(cur_drv), | |
1004 | fdctrl->data_pos - size); | |
1005 | if (cur_drv->sect > cur_drv->last_sect) { | |
1006 | cur_drv->sect = 1; | |
1007 | if (FD_MULTI_TRACK(fdctrl->data_state)) { | |
1008 | if (cur_drv->head == 0 && | |
1009 | (cur_drv->flags & FDISK_DBL_SIDES) != 0) { | |
8977f3c1 FB |
1010 | cur_drv->head = 1; |
1011 | } else { | |
8977f3c1 | 1012 | cur_drv->head = 0; |
baca51fa FB |
1013 | cur_drv->track++; |
1014 | if ((cur_drv->flags & FDISK_DBL_SIDES) == 0) | |
1015 | break; | |
8977f3c1 FB |
1016 | } |
1017 | } else { | |
baca51fa FB |
1018 | cur_drv->track++; |
1019 | break; | |
1020 | } | |
1021 | FLOPPY_DPRINTF("seek to next track (%d %02x %02x => %d)\n", | |
1022 | cur_drv->head, cur_drv->track, | |
1023 | cur_drv->sect, fd_sector(cur_drv)); | |
8977f3c1 FB |
1024 | } |
1025 | } | |
1026 | } | |
1027 | end_transfer: | |
baca51fa FB |
1028 | len = fdctrl->data_pos - start_pos; |
1029 | FLOPPY_DPRINTF("end transfer %d %d %d\n", | |
1030 | fdctrl->data_pos, len, fdctrl->data_len); | |
1031 | if (fdctrl->data_dir == FD_DIR_SCANE || | |
1032 | fdctrl->data_dir == FD_DIR_SCANL || | |
1033 | fdctrl->data_dir == FD_DIR_SCANH) | |
8977f3c1 | 1034 | status2 = 0x08; |
baca51fa | 1035 | if (FD_DID_SEEK(fdctrl->data_state)) |
8977f3c1 | 1036 | status0 |= 0x20; |
baca51fa FB |
1037 | fdctrl->data_len -= len; |
1038 | // if (fdctrl->data_len == 0) | |
1039 | fdctrl_stop_transfer(fdctrl, status0, status1, status2); | |
8977f3c1 FB |
1040 | transfer_error: |
1041 | ||
baca51fa | 1042 | return len; |
8977f3c1 FB |
1043 | } |
1044 | ||
8977f3c1 | 1045 | /* Data register : 0x05 */ |
baca51fa | 1046 | static uint32_t fdctrl_read_data (fdctrl_t *fdctrl) |
8977f3c1 | 1047 | { |
baca51fa | 1048 | fdrive_t *cur_drv; |
8977f3c1 FB |
1049 | uint32_t retval = 0; |
1050 | int pos, len; | |
1051 | ||
baca51fa FB |
1052 | fdctrl_reset_irq(fdctrl); |
1053 | cur_drv = get_cur_drv(fdctrl); | |
1054 | fdctrl->state &= ~FD_CTRL_SLEEP; | |
1055 | if (FD_STATE(fdctrl->data_state) == FD_STATE_CMD) { | |
8977f3c1 FB |
1056 | FLOPPY_ERROR("can't read data in CMD state\n"); |
1057 | return 0; | |
1058 | } | |
baca51fa FB |
1059 | pos = fdctrl->data_pos; |
1060 | if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA) { | |
8977f3c1 FB |
1061 | pos %= FD_SECTOR_LEN; |
1062 | if (pos == 0) { | |
baca51fa | 1063 | len = fdctrl->data_len - fdctrl->data_pos; |
8977f3c1 FB |
1064 | if (len > FD_SECTOR_LEN) |
1065 | len = FD_SECTOR_LEN; | |
1066 | bdrv_read(cur_drv->bs, fd_sector(cur_drv), | |
baca51fa | 1067 | fdctrl->fifo, len); |
8977f3c1 FB |
1068 | } |
1069 | } | |
baca51fa FB |
1070 | retval = fdctrl->fifo[pos]; |
1071 | if (++fdctrl->data_pos == fdctrl->data_len) { | |
1072 | fdctrl->data_pos = 0; | |
8977f3c1 FB |
1073 | /* Switch from transfert mode to status mode |
1074 | * then from status mode to command mode | |
1075 | */ | |
baca51fa FB |
1076 | if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA) |
1077 | fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00); | |
8977f3c1 | 1078 | else |
baca51fa | 1079 | fdctrl_reset_fifo(fdctrl); |
8977f3c1 FB |
1080 | } |
1081 | FLOPPY_DPRINTF("data register: 0x%02x\n", retval); | |
1082 | ||
1083 | return retval; | |
1084 | } | |
1085 | ||
baca51fa | 1086 | static void fdctrl_format_sector (fdctrl_t *fdctrl) |
8977f3c1 | 1087 | { |
baca51fa FB |
1088 | fdrive_t *cur_drv; |
1089 | uint8_t kh, kt, ks; | |
1090 | int did_seek; | |
8977f3c1 | 1091 | |
baca51fa FB |
1092 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; |
1093 | cur_drv = get_cur_drv(fdctrl); | |
1094 | kt = fdctrl->fifo[6]; | |
1095 | kh = fdctrl->fifo[7]; | |
1096 | ks = fdctrl->fifo[8]; | |
1097 | FLOPPY_DPRINTF("format sector at %d %d %02x %02x (%d)\n", | |
1098 | fdctrl->cur_drv, kh, kt, ks, | |
1099 | _fd_sector(kh, kt, ks, cur_drv->last_sect)); | |
1100 | did_seek = 0; | |
1101 | switch (fd_seek(cur_drv, kh, kt, ks, fdctrl->config & 0x40)) { | |
1102 | case 2: | |
1103 | /* sect too big */ | |
1104 | fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00); | |
1105 | fdctrl->fifo[3] = kt; | |
1106 | fdctrl->fifo[4] = kh; | |
1107 | fdctrl->fifo[5] = ks; | |
1108 | return; | |
1109 | case 3: | |
1110 | /* track too big */ | |
1111 | fdctrl_stop_transfer(fdctrl, 0x40, 0x80, 0x00); | |
1112 | fdctrl->fifo[3] = kt; | |
1113 | fdctrl->fifo[4] = kh; | |
1114 | fdctrl->fifo[5] = ks; | |
1115 | return; | |
1116 | case 4: | |
1117 | /* No seek enabled */ | |
1118 | fdctrl_stop_transfer(fdctrl, 0x40, 0x00, 0x00); | |
1119 | fdctrl->fifo[3] = kt; | |
1120 | fdctrl->fifo[4] = kh; | |
1121 | fdctrl->fifo[5] = ks; | |
1122 | return; | |
1123 | case 1: | |
1124 | did_seek = 1; | |
1125 | fdctrl->data_state |= FD_STATE_SEEK; | |
1126 | break; | |
1127 | default: | |
1128 | break; | |
1129 | } | |
1130 | memset(fdctrl->fifo, 0, FD_SECTOR_LEN); | |
1131 | if (cur_drv->bs == NULL || | |
1132 | bdrv_write(cur_drv->bs, fd_sector(cur_drv), fdctrl->fifo, 1) < 0) { | |
1133 | FLOPPY_ERROR("formating sector %d\n", fd_sector(cur_drv)); | |
1134 | fdctrl_stop_transfer(fdctrl, 0x60, 0x00, 0x00); | |
1135 | } else { | |
1136 | if (cur_drv->sect == cur_drv->last_sect) { | |
1137 | fdctrl->data_state &= ~FD_STATE_FORMAT; | |
1138 | /* Last sector done */ | |
1139 | if (FD_DID_SEEK(fdctrl->data_state)) | |
1140 | fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00); | |
1141 | else | |
1142 | fdctrl_stop_transfer(fdctrl, 0x00, 0x00, 0x00); | |
1143 | } else { | |
1144 | /* More to do */ | |
1145 | fdctrl->data_pos = 0; | |
1146 | fdctrl->data_len = 4; | |
1147 | } | |
1148 | } | |
1149 | } | |
1150 | ||
1151 | static void fdctrl_write_data (fdctrl_t *fdctrl, uint32_t value) | |
1152 | { | |
1153 | fdrive_t *cur_drv; | |
1154 | ||
1155 | fdctrl_reset_irq(fdctrl); | |
1156 | cur_drv = get_cur_drv(fdctrl); | |
8977f3c1 | 1157 | /* Reset mode */ |
baca51fa | 1158 | if (fdctrl->state & FD_CTRL_RESET) { |
8977f3c1 FB |
1159 | FLOPPY_DPRINTF("Floppy controler in RESET state !\n"); |
1160 | return; | |
1161 | } | |
baca51fa FB |
1162 | fdctrl->state &= ~FD_CTRL_SLEEP; |
1163 | if (FD_STATE(fdctrl->data_state) == FD_STATE_STATUS) { | |
8977f3c1 FB |
1164 | FLOPPY_ERROR("can't write data in status mode\n"); |
1165 | return; | |
1166 | } | |
1167 | /* Is it write command time ? */ | |
baca51fa | 1168 | if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA) { |
8977f3c1 | 1169 | /* FIFO data write */ |
baca51fa FB |
1170 | fdctrl->fifo[fdctrl->data_pos++] = value; |
1171 | if (fdctrl->data_pos % FD_SECTOR_LEN == (FD_SECTOR_LEN - 1) || | |
1172 | fdctrl->data_pos == fdctrl->data_len) { | |
8977f3c1 | 1173 | bdrv_write(cur_drv->bs, fd_sector(cur_drv), |
baca51fa | 1174 | fdctrl->fifo, FD_SECTOR_LEN); |
8977f3c1 FB |
1175 | } |
1176 | /* Switch from transfert mode to status mode | |
1177 | * then from status mode to command mode | |
1178 | */ | |
baca51fa FB |
1179 | if (FD_STATE(fdctrl->data_state) == FD_STATE_DATA) |
1180 | fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00); | |
8977f3c1 FB |
1181 | return; |
1182 | } | |
baca51fa | 1183 | if (fdctrl->data_pos == 0) { |
8977f3c1 FB |
1184 | /* Command */ |
1185 | switch (value & 0x5F) { | |
1186 | case 0x46: | |
1187 | /* READ variants */ | |
1188 | FLOPPY_DPRINTF("READ command\n"); | |
1189 | /* 8 parameters cmd */ | |
baca51fa | 1190 | fdctrl->data_len = 9; |
8977f3c1 FB |
1191 | goto enqueue; |
1192 | case 0x4C: | |
1193 | /* READ_DELETED variants */ | |
1194 | FLOPPY_DPRINTF("READ_DELETED command\n"); | |
1195 | /* 8 parameters cmd */ | |
baca51fa | 1196 | fdctrl->data_len = 9; |
8977f3c1 FB |
1197 | goto enqueue; |
1198 | case 0x50: | |
1199 | /* SCAN_EQUAL variants */ | |
1200 | FLOPPY_DPRINTF("SCAN_EQUAL command\n"); | |
1201 | /* 8 parameters cmd */ | |
baca51fa | 1202 | fdctrl->data_len = 9; |
8977f3c1 FB |
1203 | goto enqueue; |
1204 | case 0x56: | |
1205 | /* VERIFY variants */ | |
1206 | FLOPPY_DPRINTF("VERIFY command\n"); | |
1207 | /* 8 parameters cmd */ | |
baca51fa | 1208 | fdctrl->data_len = 9; |
8977f3c1 FB |
1209 | goto enqueue; |
1210 | case 0x59: | |
1211 | /* SCAN_LOW_OR_EQUAL variants */ | |
1212 | FLOPPY_DPRINTF("SCAN_LOW_OR_EQUAL command\n"); | |
1213 | /* 8 parameters cmd */ | |
baca51fa | 1214 | fdctrl->data_len = 9; |
8977f3c1 FB |
1215 | goto enqueue; |
1216 | case 0x5D: | |
1217 | /* SCAN_HIGH_OR_EQUAL variants */ | |
1218 | FLOPPY_DPRINTF("SCAN_HIGH_OR_EQUAL command\n"); | |
1219 | /* 8 parameters cmd */ | |
baca51fa | 1220 | fdctrl->data_len = 9; |
8977f3c1 FB |
1221 | goto enqueue; |
1222 | default: | |
1223 | break; | |
1224 | } | |
1225 | switch (value & 0x7F) { | |
1226 | case 0x45: | |
1227 | /* WRITE variants */ | |
1228 | FLOPPY_DPRINTF("WRITE command\n"); | |
1229 | /* 8 parameters cmd */ | |
baca51fa | 1230 | fdctrl->data_len = 9; |
8977f3c1 FB |
1231 | goto enqueue; |
1232 | case 0x49: | |
1233 | /* WRITE_DELETED variants */ | |
1234 | FLOPPY_DPRINTF("WRITE_DELETED command\n"); | |
1235 | /* 8 parameters cmd */ | |
baca51fa | 1236 | fdctrl->data_len = 9; |
8977f3c1 FB |
1237 | goto enqueue; |
1238 | default: | |
1239 | break; | |
1240 | } | |
1241 | switch (value) { | |
1242 | case 0x03: | |
1243 | /* SPECIFY */ | |
1244 | FLOPPY_DPRINTF("SPECIFY command\n"); | |
1245 | /* 1 parameter cmd */ | |
baca51fa | 1246 | fdctrl->data_len = 3; |
8977f3c1 FB |
1247 | goto enqueue; |
1248 | case 0x04: | |
1249 | /* SENSE_DRIVE_STATUS */ | |
1250 | FLOPPY_DPRINTF("SENSE_DRIVE_STATUS command\n"); | |
1251 | /* 1 parameter cmd */ | |
baca51fa | 1252 | fdctrl->data_len = 2; |
8977f3c1 FB |
1253 | goto enqueue; |
1254 | case 0x07: | |
1255 | /* RECALIBRATE */ | |
1256 | FLOPPY_DPRINTF("RECALIBRATE command\n"); | |
1257 | /* 1 parameter cmd */ | |
baca51fa | 1258 | fdctrl->data_len = 2; |
8977f3c1 FB |
1259 | goto enqueue; |
1260 | case 0x08: | |
1261 | /* SENSE_INTERRUPT_STATUS */ | |
1262 | FLOPPY_DPRINTF("SENSE_INTERRUPT_STATUS command (%02x)\n", | |
baca51fa | 1263 | fdctrl->int_status); |
8977f3c1 | 1264 | /* No parameters cmd: returns status if no interrupt */ |
baca51fa FB |
1265 | fdctrl->fifo[0] = |
1266 | fdctrl->int_status | (cur_drv->head << 2) | fdctrl->cur_drv; | |
1267 | fdctrl->fifo[1] = cur_drv->track; | |
1268 | fdctrl_set_fifo(fdctrl, 2, 0); | |
1269 | fdctrl_reset_irq(fdctrl); | |
1270 | fdctrl->int_status = 0xC0; | |
8977f3c1 FB |
1271 | return; |
1272 | case 0x0E: | |
1273 | /* DUMPREG */ | |
1274 | FLOPPY_DPRINTF("DUMPREG command\n"); | |
1275 | /* Drives position */ | |
baca51fa FB |
1276 | fdctrl->fifo[0] = drv0(fdctrl)->track; |
1277 | fdctrl->fifo[1] = drv1(fdctrl)->track; | |
1278 | fdctrl->fifo[2] = 0; | |
1279 | fdctrl->fifo[3] = 0; | |
8977f3c1 | 1280 | /* timers */ |
baca51fa FB |
1281 | fdctrl->fifo[4] = fdctrl->timer0; |
1282 | fdctrl->fifo[5] = (fdctrl->timer1 << 1) | fdctrl->dma_en; | |
1283 | fdctrl->fifo[6] = cur_drv->last_sect; | |
1284 | fdctrl->fifo[7] = (fdctrl->lock << 7) | | |
8977f3c1 | 1285 | (cur_drv->perpendicular << 2); |
baca51fa FB |
1286 | fdctrl->fifo[8] = fdctrl->config; |
1287 | fdctrl->fifo[9] = fdctrl->precomp_trk; | |
1288 | fdctrl_set_fifo(fdctrl, 10, 0); | |
8977f3c1 FB |
1289 | return; |
1290 | case 0x0F: | |
1291 | /* SEEK */ | |
1292 | FLOPPY_DPRINTF("SEEK command\n"); | |
1293 | /* 2 parameters cmd */ | |
baca51fa | 1294 | fdctrl->data_len = 3; |
8977f3c1 FB |
1295 | goto enqueue; |
1296 | case 0x10: | |
1297 | /* VERSION */ | |
1298 | FLOPPY_DPRINTF("VERSION command\n"); | |
1299 | /* No parameters cmd */ | |
1300 | /* Controler's version */ | |
baca51fa FB |
1301 | fdctrl->fifo[0] = fdctrl->version; |
1302 | fdctrl_set_fifo(fdctrl, 1, 1); | |
8977f3c1 FB |
1303 | return; |
1304 | case 0x12: | |
1305 | /* PERPENDICULAR_MODE */ | |
1306 | FLOPPY_DPRINTF("PERPENDICULAR_MODE command\n"); | |
1307 | /* 1 parameter cmd */ | |
baca51fa | 1308 | fdctrl->data_len = 2; |
8977f3c1 FB |
1309 | goto enqueue; |
1310 | case 0x13: | |
1311 | /* CONFIGURE */ | |
1312 | FLOPPY_DPRINTF("CONFIGURE command\n"); | |
1313 | /* 3 parameters cmd */ | |
baca51fa | 1314 | fdctrl->data_len = 4; |
8977f3c1 FB |
1315 | goto enqueue; |
1316 | case 0x14: | |
1317 | /* UNLOCK */ | |
1318 | FLOPPY_DPRINTF("UNLOCK command\n"); | |
1319 | /* No parameters cmd */ | |
baca51fa FB |
1320 | fdctrl->lock = 0; |
1321 | fdctrl->fifo[0] = 0; | |
1322 | fdctrl_set_fifo(fdctrl, 1, 0); | |
8977f3c1 FB |
1323 | return; |
1324 | case 0x17: | |
1325 | /* POWERDOWN_MODE */ | |
1326 | FLOPPY_DPRINTF("POWERDOWN_MODE command\n"); | |
1327 | /* 2 parameters cmd */ | |
baca51fa | 1328 | fdctrl->data_len = 3; |
8977f3c1 FB |
1329 | goto enqueue; |
1330 | case 0x18: | |
1331 | /* PART_ID */ | |
1332 | FLOPPY_DPRINTF("PART_ID command\n"); | |
1333 | /* No parameters cmd */ | |
baca51fa FB |
1334 | fdctrl->fifo[0] = 0x41; /* Stepping 1 */ |
1335 | fdctrl_set_fifo(fdctrl, 1, 0); | |
8977f3c1 FB |
1336 | return; |
1337 | case 0x2C: | |
1338 | /* SAVE */ | |
1339 | FLOPPY_DPRINTF("SAVE command\n"); | |
1340 | /* No parameters cmd */ | |
baca51fa FB |
1341 | fdctrl->fifo[0] = 0; |
1342 | fdctrl->fifo[1] = 0; | |
8977f3c1 | 1343 | /* Drives position */ |
baca51fa FB |
1344 | fdctrl->fifo[2] = drv0(fdctrl)->track; |
1345 | fdctrl->fifo[3] = drv1(fdctrl)->track; | |
1346 | fdctrl->fifo[4] = 0; | |
1347 | fdctrl->fifo[5] = 0; | |
8977f3c1 | 1348 | /* timers */ |
baca51fa FB |
1349 | fdctrl->fifo[6] = fdctrl->timer0; |
1350 | fdctrl->fifo[7] = fdctrl->timer1; | |
1351 | fdctrl->fifo[8] = cur_drv->last_sect; | |
1352 | fdctrl->fifo[9] = (fdctrl->lock << 7) | | |
8977f3c1 | 1353 | (cur_drv->perpendicular << 2); |
baca51fa FB |
1354 | fdctrl->fifo[10] = fdctrl->config; |
1355 | fdctrl->fifo[11] = fdctrl->precomp_trk; | |
1356 | fdctrl->fifo[12] = fdctrl->pwrd; | |
1357 | fdctrl->fifo[13] = 0; | |
1358 | fdctrl->fifo[14] = 0; | |
1359 | fdctrl_set_fifo(fdctrl, 15, 1); | |
8977f3c1 FB |
1360 | return; |
1361 | case 0x33: | |
1362 | /* OPTION */ | |
1363 | FLOPPY_DPRINTF("OPTION command\n"); | |
1364 | /* 1 parameter cmd */ | |
baca51fa | 1365 | fdctrl->data_len = 2; |
8977f3c1 FB |
1366 | goto enqueue; |
1367 | case 0x42: | |
1368 | /* READ_TRACK */ | |
1369 | FLOPPY_DPRINTF("READ_TRACK command\n"); | |
1370 | /* 8 parameters cmd */ | |
baca51fa | 1371 | fdctrl->data_len = 9; |
8977f3c1 FB |
1372 | goto enqueue; |
1373 | case 0x4A: | |
1374 | /* READ_ID */ | |
1375 | FLOPPY_DPRINTF("READ_ID command\n"); | |
1376 | /* 1 parameter cmd */ | |
baca51fa | 1377 | fdctrl->data_len = 2; |
8977f3c1 FB |
1378 | goto enqueue; |
1379 | case 0x4C: | |
1380 | /* RESTORE */ | |
1381 | FLOPPY_DPRINTF("RESTORE command\n"); | |
1382 | /* 17 parameters cmd */ | |
baca51fa | 1383 | fdctrl->data_len = 18; |
8977f3c1 FB |
1384 | goto enqueue; |
1385 | case 0x4D: | |
1386 | /* FORMAT_TRACK */ | |
1387 | FLOPPY_DPRINTF("FORMAT_TRACK command\n"); | |
1388 | /* 5 parameters cmd */ | |
baca51fa | 1389 | fdctrl->data_len = 6; |
8977f3c1 FB |
1390 | goto enqueue; |
1391 | case 0x8E: | |
1392 | /* DRIVE_SPECIFICATION_COMMAND */ | |
1393 | FLOPPY_DPRINTF("DRIVE_SPECIFICATION_COMMAND command\n"); | |
1394 | /* 5 parameters cmd */ | |
baca51fa | 1395 | fdctrl->data_len = 6; |
8977f3c1 FB |
1396 | goto enqueue; |
1397 | case 0x8F: | |
1398 | /* RELATIVE_SEEK_OUT */ | |
1399 | FLOPPY_DPRINTF("RELATIVE_SEEK_OUT command\n"); | |
1400 | /* 2 parameters cmd */ | |
baca51fa | 1401 | fdctrl->data_len = 3; |
8977f3c1 FB |
1402 | goto enqueue; |
1403 | case 0x94: | |
1404 | /* LOCK */ | |
1405 | FLOPPY_DPRINTF("LOCK command\n"); | |
1406 | /* No parameters cmd */ | |
baca51fa FB |
1407 | fdctrl->lock = 1; |
1408 | fdctrl->fifo[0] = 0x10; | |
1409 | fdctrl_set_fifo(fdctrl, 1, 1); | |
8977f3c1 FB |
1410 | return; |
1411 | case 0xCD: | |
1412 | /* FORMAT_AND_WRITE */ | |
1413 | FLOPPY_DPRINTF("FORMAT_AND_WRITE command\n"); | |
1414 | /* 10 parameters cmd */ | |
baca51fa | 1415 | fdctrl->data_len = 11; |
8977f3c1 FB |
1416 | goto enqueue; |
1417 | case 0xCF: | |
1418 | /* RELATIVE_SEEK_IN */ | |
1419 | FLOPPY_DPRINTF("RELATIVE_SEEK_IN command\n"); | |
1420 | /* 2 parameters cmd */ | |
baca51fa | 1421 | fdctrl->data_len = 3; |
8977f3c1 FB |
1422 | goto enqueue; |
1423 | default: | |
1424 | /* Unknown command */ | |
1425 | FLOPPY_ERROR("unknown command: 0x%02x\n", value); | |
baca51fa | 1426 | fdctrl_unimplemented(fdctrl); |
8977f3c1 FB |
1427 | return; |
1428 | } | |
1429 | } | |
1430 | enqueue: | |
baca51fa FB |
1431 | FLOPPY_DPRINTF("%s: %02x\n", __func__, value); |
1432 | fdctrl->fifo[fdctrl->data_pos] = value; | |
1433 | if (++fdctrl->data_pos == fdctrl->data_len) { | |
8977f3c1 FB |
1434 | /* We now have all parameters |
1435 | * and will be able to treat the command | |
1436 | */ | |
baca51fa FB |
1437 | if (fdctrl->data_state & FD_STATE_FORMAT) { |
1438 | fdctrl_format_sector(fdctrl); | |
1439 | return; | |
1440 | } | |
1441 | switch (fdctrl->fifo[0] & 0x1F) { | |
8977f3c1 FB |
1442 | case 0x06: |
1443 | { | |
1444 | /* READ variants */ | |
1445 | FLOPPY_DPRINTF("treat READ command\n"); | |
baca51fa | 1446 | fdctrl_start_transfer(fdctrl, FD_DIR_READ); |
8977f3c1 FB |
1447 | return; |
1448 | } | |
1449 | case 0x0C: | |
1450 | /* READ_DELETED variants */ | |
1451 | // FLOPPY_DPRINTF("treat READ_DELETED command\n"); | |
1452 | FLOPPY_ERROR("treat READ_DELETED command\n"); | |
baca51fa | 1453 | fdctrl_start_transfer_del(fdctrl, FD_DIR_READ); |
8977f3c1 FB |
1454 | return; |
1455 | case 0x16: | |
1456 | /* VERIFY variants */ | |
1457 | // FLOPPY_DPRINTF("treat VERIFY command\n"); | |
1458 | FLOPPY_ERROR("treat VERIFY command\n"); | |
baca51fa | 1459 | fdctrl_stop_transfer(fdctrl, 0x20, 0x00, 0x00); |
8977f3c1 FB |
1460 | return; |
1461 | case 0x10: | |
1462 | /* SCAN_EQUAL variants */ | |
1463 | // FLOPPY_DPRINTF("treat SCAN_EQUAL command\n"); | |
1464 | FLOPPY_ERROR("treat SCAN_EQUAL command\n"); | |
baca51fa | 1465 | fdctrl_start_transfer(fdctrl, FD_DIR_SCANE); |
8977f3c1 FB |
1466 | return; |
1467 | case 0x19: | |
1468 | /* SCAN_LOW_OR_EQUAL variants */ | |
1469 | // FLOPPY_DPRINTF("treat SCAN_LOW_OR_EQUAL command\n"); | |
1470 | FLOPPY_ERROR("treat SCAN_LOW_OR_EQUAL command\n"); | |
baca51fa | 1471 | fdctrl_start_transfer(fdctrl, FD_DIR_SCANL); |
8977f3c1 FB |
1472 | return; |
1473 | case 0x1D: | |
1474 | /* SCAN_HIGH_OR_EQUAL variants */ | |
1475 | // FLOPPY_DPRINTF("treat SCAN_HIGH_OR_EQUAL command\n"); | |
1476 | FLOPPY_ERROR("treat SCAN_HIGH_OR_EQUAL command\n"); | |
baca51fa | 1477 | fdctrl_start_transfer(fdctrl, FD_DIR_SCANH); |
8977f3c1 FB |
1478 | return; |
1479 | default: | |
1480 | break; | |
1481 | } | |
baca51fa | 1482 | switch (fdctrl->fifo[0] & 0x3F) { |
8977f3c1 FB |
1483 | case 0x05: |
1484 | /* WRITE variants */ | |
baca51fa FB |
1485 | FLOPPY_DPRINTF("treat WRITE command (%02x)\n", fdctrl->fifo[0]); |
1486 | fdctrl_start_transfer(fdctrl, FD_DIR_WRITE); | |
8977f3c1 FB |
1487 | return; |
1488 | case 0x09: | |
1489 | /* WRITE_DELETED variants */ | |
1490 | // FLOPPY_DPRINTF("treat WRITE_DELETED command\n"); | |
1491 | FLOPPY_ERROR("treat WRITE_DELETED command\n"); | |
baca51fa | 1492 | fdctrl_start_transfer_del(fdctrl, FD_DIR_WRITE); |
8977f3c1 FB |
1493 | return; |
1494 | default: | |
1495 | break; | |
1496 | } | |
baca51fa | 1497 | switch (fdctrl->fifo[0]) { |
8977f3c1 FB |
1498 | case 0x03: |
1499 | /* SPECIFY */ | |
1500 | FLOPPY_DPRINTF("treat SPECIFY command\n"); | |
baca51fa FB |
1501 | fdctrl->timer0 = (fdctrl->fifo[1] >> 4) & 0xF; |
1502 | fdctrl->timer1 = fdctrl->fifo[1] >> 1; | |
1503 | fdctrl->dma_en = 1 - (fdctrl->fifo[2] & 1) ; | |
8977f3c1 | 1504 | /* No result back */ |
baca51fa | 1505 | fdctrl_reset_fifo(fdctrl); |
8977f3c1 FB |
1506 | break; |
1507 | case 0x04: | |
1508 | /* SENSE_DRIVE_STATUS */ | |
1509 | FLOPPY_DPRINTF("treat SENSE_DRIVE_STATUS command\n"); | |
baca51fa FB |
1510 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; |
1511 | cur_drv = get_cur_drv(fdctrl); | |
1512 | cur_drv->head = (fdctrl->fifo[1] >> 2) & 1; | |
8977f3c1 | 1513 | /* 1 Byte status back */ |
baca51fa | 1514 | fdctrl->fifo[0] = (cur_drv->ro << 6) | |
8977f3c1 | 1515 | (cur_drv->track == 0 ? 0x10 : 0x00) | |
baca51fa FB |
1516 | fdctrl->cur_drv; |
1517 | fdctrl_set_fifo(fdctrl, 1, 0); | |
8977f3c1 FB |
1518 | break; |
1519 | case 0x07: | |
1520 | /* RECALIBRATE */ | |
1521 | FLOPPY_DPRINTF("treat RECALIBRATE command\n"); | |
baca51fa FB |
1522 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; |
1523 | cur_drv = get_cur_drv(fdctrl); | |
8977f3c1 | 1524 | fd_recalibrate(cur_drv); |
baca51fa | 1525 | fdctrl_reset_fifo(fdctrl); |
8977f3c1 | 1526 | /* Raise Interrupt */ |
baca51fa | 1527 | fdctrl_raise_irq(fdctrl, 0x20); |
8977f3c1 FB |
1528 | break; |
1529 | case 0x0F: | |
1530 | /* SEEK */ | |
1531 | FLOPPY_DPRINTF("treat SEEK command\n"); | |
baca51fa FB |
1532 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; |
1533 | cur_drv = get_cur_drv(fdctrl); | |
1534 | fd_start(cur_drv); | |
1535 | if (fdctrl->fifo[2] <= cur_drv->track) | |
8977f3c1 FB |
1536 | cur_drv->dir = 1; |
1537 | else | |
1538 | cur_drv->dir = 0; | |
baca51fa FB |
1539 | fdctrl_reset_fifo(fdctrl); |
1540 | if (fdctrl->fifo[2] > cur_drv->max_track) { | |
1541 | fdctrl_raise_irq(fdctrl, 0x60); | |
8977f3c1 | 1542 | } else { |
baca51fa | 1543 | cur_drv->track = fdctrl->fifo[2]; |
8977f3c1 | 1544 | /* Raise Interrupt */ |
baca51fa | 1545 | fdctrl_raise_irq(fdctrl, 0x20); |
8977f3c1 FB |
1546 | } |
1547 | break; | |
1548 | case 0x12: | |
1549 | /* PERPENDICULAR_MODE */ | |
1550 | FLOPPY_DPRINTF("treat PERPENDICULAR_MODE command\n"); | |
baca51fa FB |
1551 | if (fdctrl->fifo[1] & 0x80) |
1552 | cur_drv->perpendicular = fdctrl->fifo[1] & 0x7; | |
8977f3c1 | 1553 | /* No result back */ |
baca51fa | 1554 | fdctrl_reset_fifo(fdctrl); |
8977f3c1 FB |
1555 | break; |
1556 | case 0x13: | |
1557 | /* CONFIGURE */ | |
1558 | FLOPPY_DPRINTF("treat CONFIGURE command\n"); | |
baca51fa FB |
1559 | fdctrl->config = fdctrl->fifo[2]; |
1560 | fdctrl->precomp_trk = fdctrl->fifo[3]; | |
8977f3c1 | 1561 | /* No result back */ |
baca51fa | 1562 | fdctrl_reset_fifo(fdctrl); |
8977f3c1 FB |
1563 | break; |
1564 | case 0x17: | |
1565 | /* POWERDOWN_MODE */ | |
1566 | FLOPPY_DPRINTF("treat POWERDOWN_MODE command\n"); | |
baca51fa FB |
1567 | fdctrl->pwrd = fdctrl->fifo[1]; |
1568 | fdctrl->fifo[0] = fdctrl->fifo[1]; | |
1569 | fdctrl_set_fifo(fdctrl, 1, 1); | |
8977f3c1 FB |
1570 | break; |
1571 | case 0x33: | |
1572 | /* OPTION */ | |
1573 | FLOPPY_DPRINTF("treat OPTION command\n"); | |
1574 | /* No result back */ | |
baca51fa | 1575 | fdctrl_reset_fifo(fdctrl); |
8977f3c1 FB |
1576 | break; |
1577 | case 0x42: | |
1578 | /* READ_TRACK */ | |
1579 | // FLOPPY_DPRINTF("treat READ_TRACK command\n"); | |
1580 | FLOPPY_ERROR("treat READ_TRACK command\n"); | |
baca51fa | 1581 | fdctrl_start_transfer(fdctrl, FD_DIR_READ); |
8977f3c1 FB |
1582 | break; |
1583 | case 0x4A: | |
1584 | /* READ_ID */ | |
baca51fa FB |
1585 | FLOPPY_DPRINTF("treat READ_ID command\n"); |
1586 | fdctrl_stop_transfer(fdctrl, 0x00, 0x00, 0x00); | |
8977f3c1 FB |
1587 | break; |
1588 | case 0x4C: | |
1589 | /* RESTORE */ | |
1590 | FLOPPY_DPRINTF("treat RESTORE command\n"); | |
1591 | /* Drives position */ | |
baca51fa FB |
1592 | drv0(fdctrl)->track = fdctrl->fifo[3]; |
1593 | drv1(fdctrl)->track = fdctrl->fifo[4]; | |
8977f3c1 | 1594 | /* timers */ |
baca51fa FB |
1595 | fdctrl->timer0 = fdctrl->fifo[7]; |
1596 | fdctrl->timer1 = fdctrl->fifo[8]; | |
1597 | cur_drv->last_sect = fdctrl->fifo[9]; | |
1598 | fdctrl->lock = fdctrl->fifo[10] >> 7; | |
1599 | cur_drv->perpendicular = (fdctrl->fifo[10] >> 2) & 0xF; | |
1600 | fdctrl->config = fdctrl->fifo[11]; | |
1601 | fdctrl->precomp_trk = fdctrl->fifo[12]; | |
1602 | fdctrl->pwrd = fdctrl->fifo[13]; | |
1603 | fdctrl_reset_fifo(fdctrl); | |
8977f3c1 FB |
1604 | break; |
1605 | case 0x4D: | |
1606 | /* FORMAT_TRACK */ | |
baca51fa FB |
1607 | FLOPPY_DPRINTF("treat FORMAT_TRACK command\n"); |
1608 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; | |
1609 | cur_drv = get_cur_drv(fdctrl); | |
1610 | fdctrl->data_state |= FD_STATE_FORMAT; | |
1611 | if (fdctrl->fifo[0] & 0x80) | |
1612 | fdctrl->data_state |= FD_STATE_MULTI; | |
1613 | else | |
1614 | fdctrl->data_state &= ~FD_STATE_MULTI; | |
1615 | fdctrl->data_state &= ~FD_STATE_SEEK; | |
1616 | cur_drv->bps = | |
1617 | fdctrl->fifo[2] > 7 ? 16384 : 128 << fdctrl->fifo[2]; | |
1618 | #if 0 | |
1619 | cur_drv->last_sect = | |
1620 | cur_drv->flags & FDISK_DBL_SIDES ? fdctrl->fifo[3] : | |
1621 | fdctrl->fifo[3] / 2; | |
1622 | #else | |
1623 | cur_drv->last_sect = fdctrl->fifo[3]; | |
1624 | #endif | |
1625 | /* Bochs BIOS is buggy and don't send format informations | |
1626 | * for each sector. So, pretend all's done right now... | |
1627 | */ | |
1628 | fdctrl->data_state &= ~FD_STATE_FORMAT; | |
1629 | fdctrl_stop_transfer(fdctrl, 0x00, 0x00, 0x00); | |
8977f3c1 FB |
1630 | break; |
1631 | case 0x8E: | |
1632 | /* DRIVE_SPECIFICATION_COMMAND */ | |
1633 | FLOPPY_DPRINTF("treat DRIVE_SPECIFICATION_COMMAND command\n"); | |
baca51fa | 1634 | if (fdctrl->fifo[fdctrl->data_pos - 1] & 0x80) { |
8977f3c1 | 1635 | /* Command parameters done */ |
baca51fa FB |
1636 | if (fdctrl->fifo[fdctrl->data_pos - 1] & 0x40) { |
1637 | fdctrl->fifo[0] = fdctrl->fifo[1]; | |
1638 | fdctrl->fifo[2] = 0; | |
1639 | fdctrl->fifo[3] = 0; | |
1640 | fdctrl_set_fifo(fdctrl, 4, 1); | |
8977f3c1 | 1641 | } else { |
baca51fa | 1642 | fdctrl_reset_fifo(fdctrl); |
8977f3c1 | 1643 | } |
baca51fa | 1644 | } else if (fdctrl->data_len > 7) { |
8977f3c1 | 1645 | /* ERROR */ |
baca51fa FB |
1646 | fdctrl->fifo[0] = 0x80 | |
1647 | (cur_drv->head << 2) | fdctrl->cur_drv; | |
1648 | fdctrl_set_fifo(fdctrl, 1, 1); | |
8977f3c1 FB |
1649 | } |
1650 | break; | |
1651 | case 0x8F: | |
1652 | /* RELATIVE_SEEK_OUT */ | |
1653 | FLOPPY_DPRINTF("treat RELATIVE_SEEK_OUT command\n"); | |
baca51fa FB |
1654 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; |
1655 | cur_drv = get_cur_drv(fdctrl); | |
1656 | fd_start(cur_drv); | |
8977f3c1 | 1657 | cur_drv->dir = 0; |
baca51fa FB |
1658 | if (fdctrl->fifo[2] + cur_drv->track >= cur_drv->max_track) { |
1659 | cur_drv->track = cur_drv->max_track - 1; | |
1660 | } else { | |
1661 | cur_drv->track += fdctrl->fifo[2]; | |
8977f3c1 | 1662 | } |
baca51fa FB |
1663 | fdctrl_reset_fifo(fdctrl); |
1664 | fdctrl_raise_irq(fdctrl, 0x20); | |
8977f3c1 FB |
1665 | break; |
1666 | case 0xCD: | |
1667 | /* FORMAT_AND_WRITE */ | |
1668 | // FLOPPY_DPRINTF("treat FORMAT_AND_WRITE command\n"); | |
1669 | FLOPPY_ERROR("treat FORMAT_AND_WRITE command\n"); | |
baca51fa | 1670 | fdctrl_unimplemented(fdctrl); |
8977f3c1 FB |
1671 | break; |
1672 | case 0xCF: | |
1673 | /* RELATIVE_SEEK_IN */ | |
1674 | FLOPPY_DPRINTF("treat RELATIVE_SEEK_IN command\n"); | |
baca51fa FB |
1675 | fdctrl->cur_drv = fdctrl->fifo[1] & 1; |
1676 | cur_drv = get_cur_drv(fdctrl); | |
1677 | fd_start(cur_drv); | |
8977f3c1 | 1678 | cur_drv->dir = 1; |
baca51fa FB |
1679 | if (fdctrl->fifo[2] > cur_drv->track) { |
1680 | cur_drv->track = 0; | |
1681 | } else { | |
1682 | cur_drv->track -= fdctrl->fifo[2]; | |
8977f3c1 | 1683 | } |
baca51fa FB |
1684 | fdctrl_reset_fifo(fdctrl); |
1685 | /* Raise Interrupt */ | |
1686 | fdctrl_raise_irq(fdctrl, 0x20); | |
8977f3c1 FB |
1687 | break; |
1688 | } | |
1689 | } | |
1690 | } |