![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to floppy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src|
Return to floppy.c CVS log | Up to [Previous NeXT emulator] / previous_trunk / src |
1.1 root 1: /* Floppy drive emulation */
2:
3:
4: #include "ioMem.h"
5: #include "ioMemTables.h"
6: #include "m68000.h"
7: #include "configuration.h"
8: #include "sysReg.h"
9: #include "dma.h"
10: #include "floppy.h"
11: #include "cycInt.h"
12: #include "file.h"
13: #include "statusbar.h"
14:
15:
16: #define LOG_FLP_REG_LEVEL LOG_DEBUG
17: #define LOG_FLP_CMD_LEVEL LOG_DEBUG
18:
19: #define IO_SEG_MASK 0x1FFFF
20:
21:
22: /* Controller */
23: struct {
24: Uint8 sra; /* Status Register A (ro) */
25: Uint8 srb; /* Status Register B (ro) */
26: Uint8 dor; /* Digital Output Register (rw) */
27: Uint8 msr; /* Main Status Register (ro) */
28: Uint8 dsr; /* Data Rate Select Register (wo) */
29: Uint8 fifo[16]; /* Data FIFO (rw) */
30: Uint8 din; /* Digital Input Register (wo) */
31: Uint8 ccr; /* Configuration Control Register (ro) */
32: Uint8 ctrl; /* External Control (rw) */
33:
34: Uint8 st[4]; /* Internal Status Registers */
35: Uint8 pcn; /* Cylinder Number */
36:
37: Uint8 sel;
38: Uint8 eis;
39: } flp;
40:
41: Uint8 floppy_select = 0;
42:
43: /* Drives */
44: struct {
45: Uint8 cyl;
46: Uint8 head;
47: Uint8 sector;
48: Uint8 blocksize;
49:
50: FILE* dsk;
51: Uint32 floppysize;
52:
53: Uint32 seekoffset;
54:
55: bool spinning;
56:
57: bool protected;
58: bool inserted;
59: bool connected;
60: } flpdrv[FLP_MAX_DRIVES];
61:
62:
63: /* Register bits */
64:
65: #define SRA_INT 0x80
66: #define SRA_DRV1_N 0x40
67: #define SRA_STEP 0x20
68: #define SRA_TRK0_N 0x10
69: #define SRA_HDSEL 0x08
70: #define SRA_INDEX_N 0x04
71: #define SRA_WP_N 0x02
72: #define SRA_DIR 0x01
73:
74: #define SRB_ALL1 0xC0
75: #define SRB_DRVSEL0_N 0x20
76: #define SRB_W_TOGGLE 0x10
77: #define SRB_R_TOGGLE 0x08
78: #define SRB_W_ENABLE 0x04
79: #define SRB_MOTEN_MASK 0x03
80:
81: #define DOR_MOT3EN 0x80
82: #define DOR_MOT2EN 0x40
83: #define DOR_MOT1EN 0x20
84: #define DOR_MOT0EN 0x10
85: #define DOR_MOTEN_MASK 0xF0
86: #define DOR_DMA_N 0x08
87: #define DOR_RESET_N 0x04
88: #define DOR_SEL_MSK 0x03
89:
90: #define STAT_RQM 0x80
91: #define STAT_DIO 0x40 /* read = 1 */
92: #define STAT_NONDMA 0x20
93: #define STAT_CMDBSY 0x10
94: #define STAT_DRV3BSY 0x08
95: #define STAT_DRV2BSY 0x04
96: #define STAT_DRV1BSY 0x02
97: #define STAT_DRV0BSY 0x01
98: #define STAT_BSY_MASK 0x0F
99:
100: #define DSR_RESET 0x80
101: #define DSR_PDOWN 0x40
102: #define DSR_0 0x20
103: #define DSR_PRE_MASK 0x1C
104: #define DSR_RATE_MASK 0x03
105:
106: #define DIR_DSKCHG 0x80
107: #define DIR_HIDENS_N 0x01
108:
109: #define CCR_RATE_MASK 0x03
110:
111: #define CTRL_EJECT 0x80
112: #define CTRL_82077 0x40
113: #define CTRL_DRV_ID 0x04
114: #define CTRL_MEDIA_ID1 0x02
115: #define CTRL_MEDIA_ID0 0x01
116:
117:
118: /* Functions */
119: void floppy_reset(bool hard);
120: Uint8 floppy_fifo_read(void);
121: void floppy_fifo_write(Uint8 val);
122: Uint8 floppy_dor_read(void);
123: void floppy_dor_write(Uint8 val);
124: Uint8 floppy_sra_read(void);
125:
126:
127: void FLP_StatA_Read(void) { // 0x02014100
128: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = floppy_sra_read();
129: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Status A read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
130: }
131:
132: void FLP_StatB_Read(void) { // 0x02014101
133: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = flp.srb|SRB_ALL1;
134: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Status B read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
135: }
136:
137: void FLP_DataOut_Read(void) { // 0x02014102
138: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = floppy_dor_read();
139: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Data out read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
140: }
141:
142: void FLP_DataOut_Write(void) {
143: floppy_dor_write(IoMem[IoAccessCurrentAddress & IO_SEG_MASK]);
144: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Data out write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
145: }
146:
147: void FLP_Status_Read(void) { // 0x02014104
148: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = flp.msr;
149: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Main status read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
150: }
151:
152: void FLP_DataRate_Write(void) {
153: flp.dsr = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
154: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Data rate write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
155:
156: if (flp.dsr&DSR_RESET) {
157: floppy_reset(false);
158: flp.dsr&=~DSR_RESET;
159: }
160: }
161:
162: void FLP_FIFO_Read(void) { // 0x02014105
163: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = floppy_fifo_read();
164: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] FIFO read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
165: }
166:
167: void FLP_FIFO_Write(void) {
168: Uint8 val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
169: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] FIFO write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
170:
171: floppy_fifo_write(val);
172: }
173:
174: void FLP_DataIn_Read(void) { // 0x02014107
175: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = flp.din;
176: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Data in read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
177: }
178:
179: void FLP_Configuration_Write(void) {
180: flp.ccr = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
181: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Configuration write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
182: }
183:
184: void FLP_Control_Read(void) { // 0x02014108
185: Uint8 val;
186: if (ConfigureParams.System.nMachineType==NEXT_CUBE030)
187: val=flp.ctrl&~CTRL_DRV_ID;
188: else
189: val=flp.ctrl;
190:
191: IoMem[IoAccessCurrentAddress & IO_SEG_MASK] = val;
192: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Control read at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
193: }
194:
195: void FLP_Select_Write(void) {
196: Uint8 val;
197: val = IoMem[IoAccessCurrentAddress & IO_SEG_MASK];
198: Log_Printf(LOG_DEBUG,"[Floppy] Select write at $%08x val=$%02x PC=$%08x\n", IoAccessCurrentAddress, IoMem[IoAccessCurrentAddress & IO_SEG_MASK], m68k_getpc());
199:
200: if (ConfigureParams.System.nMachineType!=NEXT_CUBE030) {
201: set_floppy_select(val&CTRL_82077,false);
202: }
203:
204: if (val&CTRL_EJECT) {
205: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Ejecting floppy disk");
206: Floppy_Eject(-1);
207: }
208: }
209:
210: void set_floppy_select(Uint8 sel, bool osp) {
211: if (sel) {
212: Log_Printf(LOG_DEBUG,"[%s] Selecting floppy controller",osp?"OSP":"Floppy");
213: floppy_select = 1;
214: } else {
215: Log_Printf(LOG_FLP_REG_LEVEL,"[%s] Selecting SCSI controller",osp?"OSP":"Floppy");
216: floppy_select = 0;
217: }
218: }
219:
220: enum {
221: FLP_STATE_WRITE,
222: FLP_STATE_READ,
223: FLP_STATE_FORMAT,
224: FLP_STATE_INTERRUPT,
225: FLP_STATE_DONE
226: } flp_io_state;
227:
228: int flp_sector_counter = 0;
229: int flp_io_drv = 0;
230:
231:
232: /* Internal registers */
233:
234: #define ST0_IC 0xC0 /* Interrupt Code (0 = normal termination) */
235: #define ST0_SE 0x20 /* Seek End */
236: #define ST0_EC 0x10 /* Equipment Check */
237: #define ST0_H 0x04 /* Head Address */
238: #define ST0_DS 0x03 /* Drive Select */
239:
240: #define ST1_EN 0x80 /* End of Cylinder */
241: #define ST1_DE 0x20 /* Data Error */
242: #define ST1_OR 0x10 /* Overrun/Underrun */
243: #define ST1_ND 0x04 /* No Data */
244: #define ST1_NW 0x02 /* Not writable */
245: #define ST1_MA 0x01 /* Missing Address Mark */
246:
247: #define ST2_CM 0x40 /* Control Mark */
248: #define ST2_DD 0x20 /* Data Error in Data Field */
249: #define ST2_WC 0x10 /* Wrong Cylinder */
250: #define ST2_BC 0x02 /* Bad Cylinder */
251: #define ST2_MD 0x01 /* Missing Data Address Mark */
252:
253: #define ST3_WP 0x40 /* Write Protected */
254: #define ST3_T0 0x10 /* Track 0 */
255: #define ST3_HD 0x04 /* Head Address */
256: #define ST3_DS 0x03 /* Drive Select */
257:
258:
259: #define IC_NORMAL 0x00
260: #define IC_ABNORMAL 0x40
261: #define IC_INV_CMD 0x80
262:
263:
264:
265: void floppy_reset(bool hard) {
266: Log_Printf(LOG_WARN,"[Floppy] Reset.");
267:
268: flp.sra &= ~(SRA_INT|SRA_STEP|SRA_HDSEL|SRA_DIR);
269: flp.srb &= ~(SRB_R_TOGGLE|SRB_W_TOGGLE);
270: flp.msr |= STAT_RQM;
271: flp.msr &= ~STAT_DIO;
272:
273: if (hard) {
274: flp_io_state = FLP_STATE_DONE;
275: flp.dor &= ~DOR_RESET_N;
276: flp.srb &= ~(SRB_MOTEN_MASK|SRB_DRVSEL0_N);
277: flp.din &= ~DIR_HIDENS_N;
278: flp.st[0]=flp.st[1]=flp.st[2]=flp.st[3]=0;
279: flp.pcn=0;
280: } else {
281: /* Single poll interrupt after reset (delay = 250 ms) */
282: flp_io_state = FLP_STATE_INTERRUPT;
283: CycInt_AddRelativeInterruptUs(250*1000, 0, INTERRUPT_FLP_IO);
284: }
285: }
286:
287: /* Floppy commands */
288:
289: #define CMD_MT_MSK 0x80
290: #define CMD_MFM_MSK 0x40
291: #define CMD_SK_MSK 0x20
292: #define CMD_OPCODE_MSK 0x1F
293:
294: #define CMD_READ 0x06
295: #define CMD_READ_DEL 0x0C
296: #define CMD_WRITE 0x05
297: #define CMD_WRITE_DEL 0x09
298: #define CMD_READ_TRK 0x02
299: #define CMD_VERIFY 0x16
300: #define CMD_VERSION 0x10
301: #define CMD_FORMAT 0x0D
302: #define CMD_SCAN_E 0x11
303: #define CMD_SCAN_LE 0x19
304: #define CMD_SCAN_HE 0x1D
305: #define CMD_RECAL 0x07
306: #define CMD_INTSTAT 0x08
307: #define CMD_SPECIFY 0x03
308: #define CMD_DRV_STATUS 0x04
309: #define CMD_SEEK 0x0F
310: #define CMD_CONFIGURE 0x13
311: #define CMD_DUMPREG 0x0E
312: #define CMD_READ_ID 0x0A
313: #define CMD_PERPEND 0x12
314: #define CMD_LOCK 0x14
315:
316: Uint8 cmd_data_size[] = {
317: 0,0,8,2,1,8,8,1,
318: 0,8,1,0,8,5,0,2,
319: 0,8,1,3,0,0,8,0,
320: 0,8,0,0,0,8,0,0
321: };
322:
323: bool cmd_phase = false;
324: int cmd_size = 0;
325: int cmd_limit = 0;
326: Uint8 command;
327: Uint8 cmd_data[8];
328:
329: int result_size = 0;
330:
331: static void floppy_interrupt(void) {
332: Log_Printf(LOG_FLP_CMD_LEVEL,"[Floppy] Interrupt.");
333:
334: if (result_size>0) {
335: /* Go to result phase */
336: flp.msr |= (STAT_RQM|STAT_DIO);
337: } else {
338: flp.msr |= STAT_RQM;
339: }
340:
341: flp.msr &= ~(STAT_BSY_MASK);
342: flp.sra |= SRA_INT;
343: set_interrupt(INT_PHONE, SET_INT);
344: }
345:
346: /* -- Helpers -- */
347:
348: /* Geometry */
349: #define SIZE_720K 737280
350: #define SIZE_1440K 1474560
351: #define SIZE_2880K 2949120
352:
353: #define NUM_CYLINDERS 80
354: #define TRACKS_PER_CYL 2
355:
356: static Uint32 physical_to_logical_sector(Uint8 c, Uint8 h, Uint8 s, int drive) {
357: Uint32 disksize = flpdrv[drive].floppysize;
358: Uint32 blocksize = 0x80<<flpdrv[drive].blocksize;
359: Uint32 spt = disksize/blocksize/TRACKS_PER_CYL/NUM_CYLINDERS;
360:
361: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Geometry: Cylinders: %i, Tracks per cylinder: %i, Sectors per track: %i, Blocksize: %i",
362: NUM_CYLINDERS,TRACKS_PER_CYL,spt,blocksize);
363:
364: if (s>spt) {
365: Log_Printf(LOG_WARN, "[Floppy] Geometry error: sector (%i) beyond limit (%i)!",s,spt);
366: flp.st[0] |= IC_ABNORMAL;
367: flp.st[1] |= ST1_EN;
368: }
369:
370: return (((c*TRACKS_PER_CYL)+h)*spt)+s-1;
371: }
372:
373: static void check_blocksize(int drive, Uint8 blocksize) {
374: if (blocksize!=flpdrv[drive].blocksize) {
375: Log_Printf(LOG_WARN, "[Floppy] Geometry error: Blocksize not supported (%i)!",blocksize);
376: flp.st[0] |= IC_ABNORMAL;
377: flp.st[1] |= ST1_ND;
378: }
379: }
380:
381: static void check_protection(int drive) {
382: if (flpdrv[drive].protected) {
383: Log_Printf(LOG_WARN, "[Floppy] Protection error: Disk is read-only!");
384: flp.st[0] |= IC_ABNORMAL;
385: flp.st[1] |= ST1_NW;
386: }
387: }
388:
389: static void floppy_seek_track(Uint8 c, Uint8 h, int drive) {
390: if (c>(NUM_CYLINDERS-1)) /* CHECK: does this cause an error? */
391: c=(NUM_CYLINDERS-1);
392:
393: flp.st[0] |= ST0_SE;
394:
395: flpdrv[drive].seekoffset = (flpdrv[drive].cyl < c) ? (c - flpdrv[drive].cyl) : (flpdrv[drive].cyl - c);
396: flpdrv[drive].cyl = c;
397: flpdrv[drive].head = h;
398: }
399:
400: /* Timings */
401: #define FLP_SEEK_TIME 200000 /* 200 ms */
402:
403: static int get_sector_time(int drive) {
404: switch (flpdrv[drive].floppysize) {
405: case SIZE_720K: return 22000;
406: case SIZE_1440K: return 11000;
407: case SIZE_2880K: return 5500;
408: default: return 1000;
409: }
410: }
411:
412: static int get_seek_time(int drive) {
413: if (flpdrv[drive].seekoffset > NUM_CYLINDERS) {
414: return FLP_SEEK_TIME;
415: }
416:
417: return (flpdrv[drive].seekoffset * FLP_SEEK_TIME / NUM_CYLINDERS);
418: }
419:
420: /* Media IDs for control register */
421: #define MEDIA_ID_NONE 0
422: #define MEDIA_ID_720K 3
423: #define MEDIA_ID_1440K 2
424: #define MEDIA_ID_2880K 1
425: #define MEDIA_ID_MSK 3
426:
427: static Uint8 get_media_id(int drive) {
428: if (!flpdrv[drive].inserted) {
429: return MEDIA_ID_NONE;
430: } else {
431: switch (flpdrv[drive].floppysize) {
432: case SIZE_720K: return MEDIA_ID_720K;
433: case SIZE_1440K: return MEDIA_ID_1440K;
434: case SIZE_2880K: return MEDIA_ID_2880K;
435: default: return MEDIA_ID_NONE;
436: }
437: }
438: }
439:
440: /* Validate data rate */
441: #define CCR_RATE250 0x02
442: #define CCR_RATE500 0x00
443: #define CCR_RATE1000 0x03
444:
445: static void check_data_rate(int drive) {
446: switch (flpdrv[drive].floppysize) {
447: case SIZE_720K:
448: if ((flp.ccr&CCR_RATE_MASK)==CCR_RATE250) {
449: return;
450: }
451: break;
452: case SIZE_1440K:
453: if ((flp.ccr&CCR_RATE_MASK)==CCR_RATE500) {
454: return;
455: }
456: break;
457: case SIZE_2880K:
458: if ((flp.ccr&CCR_RATE_MASK)==CCR_RATE1000) {
459: return;
460: }
461: break;
462:
463: default:
464: break;
465: }
466: Log_Printf(LOG_WARN, "[Floppy] Invalid data rate %02X",flp.ccr&CCR_RATE_MASK);
467: flp.st[0] |= IC_ABNORMAL;
468: flp.st[1] |= ST1_ND;
469: }
470:
471: static void send_rw_status(int drive) {
472: flp.st[0] |= drive|(flpdrv[drive].head<<2);
473: flp.fifo[0] = flp.st[0];
474: flp.fifo[1] = flp.st[1];
475: flp.fifo[2] = flp.st[2];
476: flp.fifo[3] = flpdrv[drive].cyl;
477: flp.fifo[4] = flpdrv[drive].head;
478: flp.fifo[5] = flpdrv[drive].sector;
479: flp.fifo[6] = flpdrv[drive].blocksize;
480: result_size = 7;
481: }
482:
483: /* -- Floppy commands -- */
484:
485: static void floppy_read(void) {
486: int drive = cmd_data[0]&0x03;
487: int head = (cmd_data[0]&0x04)>>2;
488: Uint8 c = cmd_data[1];
489: Uint8 h = cmd_data[2];
490: Uint8 s = cmd_data[3];
491: Uint8 bs = cmd_data[4];
492:
493: Uint32 sector_size, num_sectors, logical_sec;
494:
495: flp.st[0] = flp.st[1] = flp.st[2] = 0;
496:
497: /* If implied seek is enabled, seek track */
498: if (flp.eis) {
499: floppy_seek_track(c, h, drive);
500: }
501: /* Set start sector */
502: flpdrv[drive].sector = s;
503:
504: /* Match actual track with specified track */
505: if (flpdrv[drive].cyl!=c || flpdrv[drive].head!=h || flpdrv[drive].head!=head) {
506: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Read: track mismatch!");
507: flp.st[0]|=IC_ABNORMAL;
508: flp.st[2]|=ST2_WC;
509: }
510: /* Validate blocksize */
511: check_blocksize(drive,bs);
512: sector_size = 0x80<<bs;
513:
514: /* Validate data rate */
515: check_data_rate(drive);
516:
517: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Read: Cylinder=%i, Head=%i, Sector=%i, Blocksize=%i",
518: flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,sector_size);
519:
520: /* Get sector transfer count and logical sector offset */
521: num_sectors = cmd_data[5]-cmd_data[3]+1;
522: logical_sec = physical_to_logical_sector(flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,drive);
523:
524: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Read %i sectors at offset %i",num_sectors,logical_sec);
525:
526: if (flp.st[0]&IC_ABNORMAL) {
527: send_rw_status(drive);
528: flp_io_state = FLP_STATE_INTERRUPT;
529: } else {
530: flp_buffer.size = 0;
531: flp_buffer.limit = sector_size;
532: flp_sector_counter = num_sectors;
533: flp_io_drv = drive;
534: flp_io_state = FLP_STATE_READ;
535: }
536: CycInt_AddRelativeInterruptUs(get_seek_time(drive) + get_sector_time(drive), 100, INTERRUPT_FLP_IO);
537: }
538:
539: static void floppy_write(void) {
540: int drive = cmd_data[0]&0x03;
541: int head = (cmd_data[0]&0x04)>>2;
542: Uint8 c = cmd_data[1];
543: Uint8 h = cmd_data[2];
544: Uint8 s = cmd_data[3];
545: Uint8 bs = cmd_data[4];
546:
547: Uint32 sector_size, num_sectors, logical_sec;
548:
549: flp.st[0] = flp.st[1] = flp.st[2] = 0;
550:
551: /* If implied seek is enabled, seek track */
552: if (flp.eis) {
553: floppy_seek_track(c, h, drive);
554: }
555: /* Set start sector */
556: flpdrv[drive].sector = s;
557:
558: /* Match actual track with specified track */
559: if (flpdrv[drive].cyl!=c || flpdrv[drive].head!=h || flpdrv[drive].head!=head) {
560: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Write: track mismatch!");
561: flp.st[0]|=IC_ABNORMAL;
562: flp.st[2]|=ST2_WC;
563: }
564: /* Validate blocksize */
565: check_blocksize(drive,bs);
566: sector_size = 0x80<<bs;
567:
568: /* Validate data rate */
569: check_data_rate(drive);
570:
571: /* Check protection */
572: check_protection(drive);
573:
574: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Write: Cylinder=%i, Head=%i, Sector=%i, Blocksize=%i",
575: flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,sector_size);
576:
577: /* Get sector transfer count and logical sector offset */
578: num_sectors = cmd_data[5]-cmd_data[3]+1;
579: logical_sec = physical_to_logical_sector(flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,drive);
580:
581: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Write %i sectors at offset %i",num_sectors,logical_sec);
582:
583: if (flp.st[0]&IC_ABNORMAL) {
584: send_rw_status(drive);
585: flp_io_state = FLP_STATE_INTERRUPT;
586: } else {
587: flp_buffer.size = 0;
588: flp_buffer.limit = sector_size;
589: flp_sector_counter = num_sectors;
590: flp_io_drv = drive;
591: flp_io_state = FLP_STATE_WRITE;
592: }
593: CycInt_AddRelativeInterruptUs(get_seek_time(drive) + get_sector_time(drive), 100, INTERRUPT_FLP_IO);
594: }
595:
596: static void floppy_format(void) {
597: int drive = cmd_data[0]&0x03;
598: int head = (cmd_data[0]&0x04)>>2;
599:
600: flp.st[0] = flp.st[1] = flp.st[2] = 0;
601:
602: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Format: Cylinder=%i, Head=%i",flpdrv[drive].cyl,head);
603:
604: /* Validate data rate */
605: check_data_rate(drive);
606:
607: /* Check protection */
608: check_protection(drive);
609:
610: if (flp.st[0]&IC_ABNORMAL) {
611: send_rw_status(drive);
612: flp_io_state = FLP_STATE_INTERRUPT;
613: } else {
614: flp_buffer.size = 0;
615: flp_buffer.limit = 4;
616: flp_io_drv = drive;
617: flp_io_state = FLP_STATE_FORMAT;
618: CycInt_AddRelativeInterruptUs(get_seek_time(drive) + get_sector_time(drive), 100, INTERRUPT_FLP_IO);
619: }
620: }
621:
622: static void floppy_read_id(void) {
623: int drive = cmd_data[0]&0x03;
624: int head = (cmd_data[0]&0x04)>>2;
625:
626: Uint32 sec_size = 0x80<<flpdrv[drive].blocksize;
627:
628: if (flpdrv[drive].head!=head)
629: abort();
630:
631: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Read ID: Cylinder=%i, Head=%i, Sector=%i, Blocksize=%i",
632: flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,sec_size);
633:
634: flp.st[0] = flp.st[1] = flp.st[2] = 0;
635:
636: check_data_rate(drive); /* check data rate */
637: send_rw_status(drive);
638:
639: flp_io_state = FLP_STATE_INTERRUPT;
640: CycInt_AddRelativeInterruptUs(get_seek_time(drive), 100, INTERRUPT_FLP_IO);
641: }
642:
643: static void floppy_recalibrate(void) {
644: int drive = cmd_data[0]&0x03;
645: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Drive = %i",drive);
646:
647: if (flpdrv[drive].connected) {
648: flp.msr |= (1<<drive); /* drive busy */
649: flp.dor &= 0xFC; /* CHECK: really needed? */
650: flp.dor |= drive;
651: flpdrv[drive].cyl = flp.pcn = 0;
652:
653: flp.st[0] = flp.st[1] = flp.st[2] = 0;
654: floppy_seek_track(0, 0, drive);
655:
656: /* Done */
657: flp.st[0] = IC_NORMAL|ST0_SE;
658: flp.sra &= ~SRA_TRK0_N;
659:
660: flp_io_state = FLP_STATE_INTERRUPT;
661: CycInt_AddRelativeInterruptUs(get_seek_time(drive), 100, INTERRUPT_FLP_IO);
662: }
663: }
664:
665: static void floppy_seek(Uint8 relative) {
666: int drive = cmd_data[0]&0x03;
667: int head = (cmd_data[0]&0x04)>>2;
668: flp.st[0] = flp.st[1] = flp.st[2] = 0;
669:
670: if (relative) {
671: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Relative seek: Head %i: %i cylinders",head,0);
672: abort();
673: } else {
674: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Seek: Head %i to cylinder %i",head,flpdrv[drive].cyl);
675: flp.st[0] = IC_NORMAL;
676:
677: floppy_seek_track(cmd_data[1], head, drive);
678: if (!(flp.st[0]&IC_ABNORMAL)) {
679: flp.pcn = flpdrv[drive].cyl;
680: }
681: }
682:
683: flp_io_state = FLP_STATE_INTERRUPT;
684: CycInt_AddRelativeInterruptUs(get_seek_time(drive), 100, INTERRUPT_FLP_IO);
685: }
686:
687: static void floppy_interrupt_status(void) {
688: /* Release interrupt */
689: set_interrupt(INT_PHONE, RELEASE_INT);
690: flp.sra &= ~SRA_INT;
691: /* Go to result phase */
692: flp.msr |= (STAT_RQM|STAT_DIO);
693: /* Return data */
694: flp.fifo[0] = flp.st[0];
695: flp.fifo[1] = flp.pcn;
696: result_size = 2;
697: }
698:
699: static void floppy_specify(void) {
700: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Specify: %02X %02X",cmd_data[0],cmd_data[1]);
701:
702: if (cmd_data[1]&0x01) {
703: Log_Printf(LOG_WARN, "[Floppy] Specify: Non-DMA mode");
704: } else {
705: Log_Printf(LOG_WARN, "[Floppy] Specify: DMA mode");
706: }
707: flp.msr |= STAT_RQM;
708: }
709:
710: static void floppy_configure(void) {
711: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Configure: %02X %02X %02X",cmd_data[0],cmd_data[1],cmd_data[2]);
712:
713: flp.eis = cmd_data[1]&0x40; /* Enable or disable implied seek */
714:
715: if (cmd_data[1]&0x10) {
716: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Configure: disable polling");
717: if (CycInt_InterruptActive(INTERRUPT_FLP_IO)) {
718: Log_Printf(LOG_WARN, "[Floppy] Disable pending reset poll interrupt");
719: CycInt_RemovePendingInterrupt(INTERRUPT_FLP_IO);
720: }
721: }
722: if (cmd_data[2]) {
723: abort();
724: }
725: flp.msr |= STAT_RQM;
726: }
727:
728: static void floppy_perpendicular(void) {
729: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Perpendicular: %02X",cmd_data[0]);
730: flp.msr |= STAT_RQM;
731: }
732:
733: static void floppy_unimplemented(void) {
734: flp.st[0] = IC_INV_CMD;
735:
736: flp.fifo[0] = flp.st[0];
737: result_size = 1;
738:
739: flp_io_state = FLP_STATE_INTERRUPT;
740: CycInt_AddRelativeInterruptUs(1000, 100, INTERRUPT_FLP_IO);
741: }
742:
743: static void floppy_execute_cmd(void) {
744: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Executing %02X",command);
745:
746: switch (command&CMD_OPCODE_MSK) {
747: case CMD_READ:
748: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Read");
749: floppy_read();
750: break;
751: case CMD_READ_DEL:
752: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Read and delete");
753: abort();
754: break;
755: case CMD_WRITE:
756: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Write");
757: floppy_write();
758: break;
759: case CMD_WRITE_DEL:
760: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Write and delete");
761: abort();
762: break;
763: case CMD_READ_TRK:
764: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Read track");
765: abort();
766: break;
767: case CMD_VERIFY:
768: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Verify");
769: abort();
770: break;
771: case CMD_VERSION:
772: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Version");
773: abort();
774: break;
775: case CMD_FORMAT:
776: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Format");
777: floppy_format();
778: break;
779: case CMD_SCAN_E:
780: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Scan equal");
781: abort();
782: break;
783: case CMD_SCAN_LE:
784: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Scan lower or equal");
785: abort();
786: break;
787: case CMD_SCAN_HE:
788: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Scan higher or equal");
789: abort();
790: break;
791: case CMD_RECAL:
792: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Recalibrate");
793: floppy_recalibrate();
794: break;
795: case CMD_INTSTAT:
796: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Interrupt status");
797: floppy_interrupt_status();
798: break;
799: case CMD_SPECIFY:
800: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Specify");
801: floppy_specify();
802: break;
803: case CMD_DRV_STATUS:
804: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Drive status");
805: abort();
806: break;
807: case CMD_SEEK:
808: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Seek");
809: floppy_seek(command&0x80);
810: break;
811: case CMD_CONFIGURE:
812: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Configure");
813: floppy_configure();
814: break;
815: case CMD_DUMPREG:
816: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Dump register");
817: abort();
818: break;
819: case CMD_READ_ID:
820: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Read ID");
821: floppy_read_id();
822: break;
823: case CMD_PERPEND:
824: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Perpendicular");
825: floppy_perpendicular();
826: break;
827: case CMD_LOCK:
828: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Command: Lock");
829: abort();
830: break;
831:
832: default:
833: Log_Printf(LOG_WARN, "[Floppy] Command: Unknown");
834: floppy_unimplemented();
835: break;
836: }
837: Statusbar_BlinkLed(DEVICE_LED_FD);
838: }
839:
840: void floppy_fifo_write(Uint8 val) {
841:
842: flp.msr &= ~STAT_RQM;
843:
844: if (!cmd_phase) {
845: cmd_phase = true;
846: command = val;
847: cmd_limit = cmd_size = cmd_data_size[val&CMD_OPCODE_MSK];
848: flp.msr |= STAT_RQM;
849: } else if (cmd_size>0) {
850: cmd_data[cmd_limit-cmd_size]=val;
851: cmd_size--;
852: flp.msr |= STAT_RQM;
853: }
854:
855: if (cmd_size==0) {
856: cmd_phase = false;
857: floppy_execute_cmd();
858: }
859: }
860:
861: Uint8 floppy_fifo_read(void) {
862: int i;
863: Uint8 val;
864: if (result_size>0) {
865: val = flp.fifo[0];
866: for (i=0; i<(16-1); i++)
867: flp.fifo[i]=flp.fifo[i+1];
868: flp.fifo[16-1] = 0x00;
869: result_size--;
870: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] FIFO reading byte, val=%02x", val);
871: } else {
872: Log_Printf(LOG_WARN,"[Floppy] FIFO is emtpy!");
873: val = 0;
874: }
875:
876: if (result_size==0) {
877: flp.msr |= STAT_RQM;
878: flp.msr &= ~STAT_DIO;
879: /* FIXME: does this really belong here? */
880: set_interrupt(INT_PHONE, RELEASE_INT);
881: flp.sra &= ~SRA_INT;
882: }
883:
884: return val;
885: }
886:
887: void floppy_dor_write(Uint8 val) {
888: if ((val&DOR_SEL_MSK)!=flp.sel) {
889: Log_Printf(LOG_FLP_CMD_LEVEL,"[Floppy] Selecting drive %i.",val&DOR_SEL_MSK);
890: }
891: flp.sel = val&DOR_SEL_MSK;
892:
893: flp.dor &= ~DOR_SEL_MSK;
894: flp.dor |= flp.sel;
895:
896:
897: if (!(val&DOR_RESET_N)) {
898: flp.dor &= ~DOR_RESET_N;
899: floppy_reset(false);
900: } else {
901: flp.dor |= DOR_RESET_N;
902: Log_Printf(LOG_FLP_REG_LEVEL,"[Floppy] Clear reset state.");
903: }
904: if (flpdrv[flp.sel].connected) {
905: flp.ctrl &= ~CTRL_DRV_ID;
906:
907: if (val&(0x10<<flp.sel)) { /* motor enable */
908: Log_Printf(LOG_FLP_CMD_LEVEL,"[Floppy] Starting motor of drive %i.",flp.sel);
909: flp.ctrl &= ~MEDIA_ID_MSK;
910: flp.ctrl |= get_media_id(flp.sel);
911: flpdrv[flp.sel].spinning = true;
912: } else {
913: Log_Printf(LOG_FLP_CMD_LEVEL,"[Floppy] Stopping motor of drive %i.",flp.sel);
914: flp.ctrl &= ~MEDIA_ID_MSK; /* CHECK: really delete ID? */
915: flpdrv[flp.sel].spinning = false;
916: }
917: } else {
918: flp.ctrl |= CTRL_DRV_ID;
919: }
920: }
921:
922: Uint8 floppy_dor_read(void) {
923: int i;
924: Uint8 val = flp.dor&~DOR_MOTEN_MASK; /* clear motor bits */
925: for (i=0; i<FLP_MAX_DRIVES; i++) {
926: if (flpdrv[i].spinning) { /* set motor bit if motor is on */
927: val |= 0x10<<i;
928: }
929: }
930: return val;
931: }
932:
933: Uint8 floppy_sra_read(void) {
934: Uint8 val = flp.sra;
935: if (!flpdrv[flp.sel].protected) {
936: val|=SRA_WP_N;
937: }
938: return val;
939: }
940:
941:
942: /* -- Floppy I/O functions -- */
943:
944: static void floppy_rw_nodata(void) {
945: Log_Printf(LOG_WARN, "[Floppy] Write: No more data from DMA. Stopping.");
946: /* Stop transfer */
947: flp_sector_counter=0;
948: flp.st[0] |= IC_ABNORMAL;
949: flp.st[1] |= ST1_OR;
950: send_rw_status(flp_io_drv);
951: }
952:
953: static void floppy_format_done(void) {
954: int drive = flp_io_drv;
955:
956: Log_Printf(LOG_WARN, "[Floppy] Format: No more data from DMA. Done.");
957:
958: flp.st[0] = IC_NORMAL;
959: send_rw_status(drive);
960: }
961:
962: static void floppy_read_sector(void) {
963: int drive = flp_io_drv;
964:
965: /* Read from image */
966: Uint32 sec_size = 0x80<<flpdrv[drive].blocksize;
967: Uint32 logical_sec = physical_to_logical_sector(flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,drive);
968:
969: if (flp.st[0]&IC_ABNORMAL) {
970: Log_Printf(LOG_WARN, "[Floppy] Read error. Bad sector offset (%i).",logical_sec);
971: flp_sector_counter=0; /* stop the transfer */
972: flp_io_state = FLP_STATE_INTERRUPT;
973: send_rw_status(drive);
974: return;
975: } else {
976: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Read sector at offset %i",logical_sec);
977:
978: flp_buffer.size = flp_buffer.limit = sec_size;
979: File_Read(flp_buffer.data, flp_buffer.size, logical_sec*sec_size, flpdrv[drive].dsk);
980: flpdrv[drive].sector++;
981: flp_sector_counter--;
982: }
983:
984: if (flp_sector_counter==0) {
985: flp.st[0] = IC_ABNORMAL; /* Strange behavior of NeXT hardware */
986: flp.st[1] |= ST1_EN;
987: send_rw_status(drive);
988: }
989: }
990:
991: static void floppy_write_sector(void) {
992: int drive = flp_io_drv;
993:
994: /* Write to image */
995: Uint32 sec_size = 0x80<<flpdrv[drive].blocksize;
996: Uint32 logical_sec = physical_to_logical_sector(flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,drive);
997:
998: if (flp.st[0]&IC_ABNORMAL) {
999: Log_Printf(LOG_WARN, "[Floppy] Write error. Bad sector offset (%i).",logical_sec);
1000: flp_sector_counter=0; /* stop the transfer */
1001: flp_io_state = FLP_STATE_INTERRUPT;
1002: send_rw_status(drive);
1003: return;
1004: } else {
1005: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Write sector at offset %i",logical_sec);
1006:
1007: File_Write(flp_buffer.data, flp_buffer.size, logical_sec*sec_size, flpdrv[drive].dsk);
1008: flp_buffer.size = 0;
1009: flp_buffer.limit = sec_size;
1010: flpdrv[drive].sector++;
1011: flp_sector_counter--;
1012: }
1013:
1014: if (flp_sector_counter==0) {
1015: flp.st[0] = IC_ABNORMAL; /* Strange behavior of NeXT hardware */
1016: flp.st[1] |= ST1_EN;
1017: send_rw_status(drive);
1018: }
1019: }
1020:
1021: static void floppy_format_sector(void) {
1022: int drive = flp_io_drv;
1023: Uint8 c = flp_buffer.data[0];
1024: Uint8 h = flp_buffer.data[1];
1025: Uint8 s = flp_buffer.data[2];
1026: Uint8 bs = flp_buffer.data[3];
1027:
1028: if (c!=flpdrv[drive].cyl || h!=flpdrv[drive].head || bs!=flpdrv[drive].blocksize) {
1029: Log_Printf(LOG_WARN, "[Floppy] Format error. Bad sector data. Stopping.");
1030: flp_io_state = FLP_STATE_INTERRUPT; /* This is a hack */
1031: floppy_format_done();
1032: flp_buffer.size = 0;
1033: return;
1034: }
1035: flpdrv[drive].sector = s;
1036:
1037: /* Erase data */
1038: Uint32 sec_size = 0x80<<bs;
1039: Uint32 logical_sec = physical_to_logical_sector(flpdrv[drive].cyl,flpdrv[drive].head,flpdrv[drive].sector,drive);
1040: flp_buffer.size = sec_size;
1041: memset(flp_buffer.data, 0, flp_buffer.size);
1042:
1043: if (flp.st[0]&IC_ABNORMAL) {
1044: Log_Printf(LOG_WARN, "[Floppy] Format error. Bad sector offset (%i).",logical_sec);
1045: flp_buffer.size = flp_buffer.limit = 0;
1046: send_rw_status(drive);
1047: } else {
1048: Log_Printf(LOG_FLP_CMD_LEVEL, "[Floppy] Format sector at offset %i (%i/%i/%i), blocksize: %i",
1049: logical_sec,c,h,s,sec_size);
1050: File_Write(flp_buffer.data, flp_buffer.size, logical_sec*sec_size, flpdrv[drive].dsk);
1051: flp_buffer.size = 0;
1052: flp_buffer.limit = 4;
1053: }
1054: }
1055:
1056:
1057: static Uint32 old_size;
1058:
1059: void FLP_IO_Handler(void) {
1060: CycInt_AcknowledgeInterrupt();
1061:
1062: switch (flp_io_state) {
1063: case FLP_STATE_WRITE:
1064: if (flp_buffer.size==flp_buffer.limit) {
1065: floppy_write_sector();
1066: if (flp_sector_counter==0) { /* done */
1067: floppy_interrupt();
1068: flp_io_state = FLP_STATE_DONE;
1069: return;
1070: }
1071: } else if (flp_buffer.size<flp_buffer.limit) { /* loop in filling mode */
1072: old_size = flp_buffer.size;
1073: dma_esp_read_memory();
1074: if (flp_buffer.size==old_size) {
1075: floppy_rw_nodata();
1076: floppy_interrupt();
1077: flp_io_state = FLP_STATE_DONE;
1078: return;
1079: }
1080: }
1081: break;
1082:
1083: case FLP_STATE_READ:
1084: if (flp_buffer.size==0 && flp_sector_counter>0) {
1085: floppy_read_sector();
1086: }
1087: if (flp_buffer.size>0) { /* loop in draining mode */
1088: old_size = flp_buffer.size;
1089: dma_esp_write_memory();
1090: if (flp_buffer.size==old_size) {
1091: floppy_rw_nodata();
1092: floppy_interrupt();
1093: flp_io_state = FLP_STATE_DONE;
1094: return;
1095: }
1096: }
1097: if (flp_buffer.size==0 && flp_sector_counter==0) { /* done */
1098: floppy_interrupt();
1099: flp_io_state = FLP_STATE_DONE;
1100: return;
1101: }
1102: break;
1103:
1104: case FLP_STATE_FORMAT:
1105: if (flp_buffer.size<flp_buffer.limit) {
1106: old_size = flp_buffer.size;
1107: dma_esp_read_memory();
1108: if (flp_buffer.size==old_size) {
1109: floppy_format_done();
1110: floppy_interrupt();
1111: flp_io_state = FLP_STATE_DONE;
1112: return;
1113: }
1114: } else if (flp_buffer.size==flp_buffer.limit) {
1115: floppy_format_sector();
1116: }
1117: break;
1118:
1119: case FLP_STATE_INTERRUPT:
1120: floppy_interrupt();
1121: flp_io_state = FLP_STATE_DONE;
1122: /* fall through */
1123:
1124: case FLP_STATE_DONE:
1125: return;
1126:
1127: default:
1128: return;
1129: }
1130:
1131: CycInt_AddRelativeInterruptUs(get_sector_time(flp_io_drv), 250, INTERRUPT_FLP_IO);
1132: }
1133:
1134:
1135: /* Initialize/Uninitialize floppy disks */
1136:
1137: static void Floppy_Init(void) {
1138: Log_Printf(LOG_WARN, "Loading floppy disks:");
1139: int i;
1140:
1141: for (i=0; i<FLP_MAX_DRIVES; i++) {
1142: flpdrv[i].spinning=false;
1143: /* Check if files exist. */
1144: if (ConfigureParams.Floppy.drive[i].bDriveConnected) {
1145: flpdrv[i].connected=true;
1146: if (ConfigureParams.Floppy.drive[i].bDiskInserted &&
1147: File_Exists(ConfigureParams.Floppy.drive[i].szImageName)) {
1148: Floppy_Insert(i);
1149: } else {
1150: flpdrv[i].dsk = NULL;
1151: flpdrv[i].inserted=false;
1152: }
1153: } else {
1154: flpdrv[i].connected=false;
1155: }
1156: }
1157:
1158: floppy_reset(true);
1159: }
1160:
1161: static void Floppy_Uninit(void) {
1162: if (flpdrv[0].dsk)
1163: File_Close(flpdrv[0].dsk);
1164: if (flpdrv[1].dsk) {
1165: File_Close(flpdrv[1].dsk);
1166: }
1167: flpdrv[0].dsk = flpdrv[1].dsk = NULL;
1168: flpdrv[0].inserted = flpdrv[1].inserted = false;
1169: }
1170:
1171: static Uint32 Floppy_CheckSize(int drive) {
1172: Uint32 size = File_Length(ConfigureParams.Floppy.drive[drive].szImageName);
1173:
1174: switch (size) {
1175: case SIZE_720K:
1176: case SIZE_1440K:
1177: case SIZE_2880K:
1178: return size;
1179:
1180: default:
1181: Log_Printf(LOG_WARN, "Floppy Disk%i: Invalid size (%i byte)\n",drive,size);
1182: return 0;
1183: }
1184: }
1185:
1186: int Floppy_Insert(int drive) {
1187: Uint32 size;
1188:
1189: /* Check floppy size. */
1190: size = Floppy_CheckSize(drive);
1191: if (size) {
1192: flpdrv[drive].floppysize = size;
1193: flpdrv[drive].blocksize = 2; /* 512 byte */
1194: flpdrv[drive].cyl = flpdrv[drive].head = flpdrv[drive].sector = 0;
1195: flpdrv[drive].seekoffset = 0;
1196: } else {
1197: flpdrv[drive].dsk = NULL;
1198: flpdrv[drive].inserted=false;
1199: flpdrv[drive].floppysize = 0;
1200: return 1; /* bad size, do not insert */
1201: }
1202:
1203: if (ConfigureParams.Floppy.drive[drive].bWriteProtected) {
1204: flpdrv[drive].dsk = File_Open(ConfigureParams.Floppy.drive[drive].szImageName, "rb");
1205: if (flpdrv[drive].dsk == NULL) {
1206: Log_Printf(LOG_WARN, "Floppy Disk%i: Cannot open image file %s\n",
1207: drive, ConfigureParams.Floppy.drive[drive].szImageName);
1208: flpdrv[drive].inserted=false;
1209: flpdrv[drive].spinning=false;
1210: Statusbar_AddMessage("Cannot insert floppy disk", 0);
1211: return 1;
1212: }
1213: flpdrv[drive].protected=true;
1214: } else {
1215: flpdrv[drive].dsk = File_Open(ConfigureParams.Floppy.drive[drive].szImageName, "rb+");
1216: flpdrv[drive].protected=false;
1217: if (flpdrv[drive].dsk == NULL) {
1218: flpdrv[drive].dsk = File_Open(ConfigureParams.Floppy.drive[drive].szImageName, "rb");
1219: if (flpdrv[drive].dsk == NULL) {
1220: Log_Printf(LOG_WARN, "Floppy Disk%i: Cannot open image file %s\n",
1221: drive, ConfigureParams.Floppy.drive[drive].szImageName);
1222: flpdrv[drive].inserted=false;
1223: flpdrv[drive].spinning=false;
1224: Statusbar_AddMessage("Cannot insert floppy disk", 0);
1225: return 1;
1226: }
1227: flpdrv[drive].protected=true;
1228: Log_Printf(LOG_WARN, "Floppy Disk%i: Image file is not writable. Enabling write protection.\n",
1229: drive);
1230: }
1231: }
1232:
1233: flpdrv[drive].inserted=true;
1234: flpdrv[drive].spinning=false;
1235:
1236: Log_Printf(LOG_WARN, "Floppy Disk%i: %s, %iK\n",drive,
1237: ConfigureParams.Floppy.drive[drive].szImageName,flpdrv[drive].floppysize/1024);
1238:
1239: Statusbar_AddMessage("Inserting floppy disk.", 0);
1240:
1241: return 0;
1242: }
1243:
1244: void Floppy_Eject(int drive) {
1245: if (drive<0) { /* Called from emulator, else called from GUI */
1246: drive=flp.sel;
1247:
1248: Statusbar_AddMessage("Ejecting floppy disk.", 0);
1249: }
1250:
1251: Log_Printf(LOG_WARN, "Unloading floppy disk %i",drive);
1252: Log_Printf(LOG_WARN, "Floppy disk %i: Eject",drive);
1253:
1254: File_Close(flpdrv[drive].dsk);
1255: flpdrv[drive].floppysize = 0;
1256: flpdrv[drive].blocksize = 0;
1257: flpdrv[drive].dsk=NULL;
1258: flpdrv[drive].inserted=false;
1259: flpdrv[drive].spinning=false;
1260:
1261: ConfigureParams.Floppy.drive[drive].bDiskInserted=false;
1262: ConfigureParams.Floppy.drive[drive].szImageName[0]='\0';
1263: }
1264:
1265: void Floppy_Reset(void) {
1266: Floppy_Uninit();
1267: Floppy_Init();
1268: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.