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