FDC.java
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13: package xeij;
14:
15: import java.awt.event.*;
16: import java.io.*;
17: import java.lang.*;
18: import java.util.*;
19: import javax.swing.*;
20: import javax.swing.filechooser.*;
21:
22: public class FDC {
23:
24: public static final boolean FDC_DEBUG_TRACE = false;
25: public static final boolean FDC_DEBUG_DEFAULT = true;
26: public static boolean fdcDebugLogOn;
27:
28:
29: public static final int FDC_STATUS_PORT = 0x00e94001;
30: public static final int FDC_DATA_PORT = 0x00e94003;
31: public static final int FDC_DRIVE_STATUS = 0x00e94005;
32: public static final int FDC_DRIVE_SELECT = 0x00e94007;
33:
34:
35: public static final int FDC_MIN_UNITS = 2;
36: public static final int FDC_MAX_UNITS = 4;
37:
38: public static FDUnit[] fdcUnitArray;
39:
40:
41: public static JMenu fdcMenu;
42:
43:
44: public static javax.swing.filechooser.FileFilter fdcFileFilter;
45:
46:
47: public static OpenDialog fdcOpenDialog;
48: public static int fdcOpenUnit;
49: public static ArrayList<File[]> fdcOpenHistory;
50:
51:
52: public static JDialog fdcFormatDialog;
53: public static JCheckBox fdcFormatX86SafeCheckBox;
54: public static JFileChooser2 fdcFormatFileChooser;
55: public static FDMedia fdcFormatMedia;
56:
57: public static boolean fdcFormatX86SafeOn;
58: public static JCheckBox fdcFormatCopyHumanSysCheckBox;
59: public static JCheckBox fdcFormatCopyCommandXCheckBox;
60: public static boolean fdcFormatCopyHumanSysOn;
61: public static boolean fdcFormatCopyCommandXOn;
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108: public static final int FDC_RQM = 0x80;
109: public static final int FDC_MPU_TO_FDC = 0x00;
110: public static final int FDC_FDC_TO_MPU = 0x40;
111: public static final int FDC_NDM = 0x20;
112: public static final int FDC_CB = 0x10;
113: public static final int FDC_D3B = 0x08;
114: public static final int FDC_D2B = 0x04;
115: public static final int FDC_D1B = 0x02;
116: public static final int FDC_D0B = 0x01;
117: public static int fdcStatus;
118: public static int fdcLastStatus;
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151: public static final int FDC_ST0_NT = 0x00 << 24;
152: public static final int FDC_ST0_AT = 0x40 << 24;
153: public static final int FDC_ST0_IC = 0x80 << 24;
154: public static final int FDC_ST0_AI = 0xc0 << 24;
155: public static final int FDC_ST0_SE = 0x20 << 24;
156: public static final int FDC_ST0_EC = 0x10 << 24;
157: public static final int FDC_ST0_NR = 0x08 << 24;
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184: public static final int FDC_ST1_EN = 0x80 << 16;
185: public static final int FDC_ST1_DE = 0x20 << 16;
186: public static final int FDC_ST1_OR = 0x10 << 16;
187: public static final int FDC_ST1_ND = 0x04 << 16;
188: public static final int FDC_ST1_NW = 0x02 << 16;
189: public static final int FDC_ST1_MA = 0x01 << 16;
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215: public static final int FDC_ST2_CM = 0x40 << 8;
216: public static final int FDC_ST2_DD = 0x20 << 8;
217: public static final int FDC_ST2_NC = 0x10 << 8;
218: public static final int FDC_ST2_SH = 0x08 << 8;
219: public static final int FDC_ST2_SN = 0x04 << 8;
220: public static final int FDC_ST2_BC = 0x02 << 8;
221: public static final int FDC_ST2_MD = 0x01 << 8;
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242: public static final int FDC_ST3_FT = 0x80;
243: public static final int FDC_ST3_WP = 0x40;
244: public static final int FDC_ST3_RY = 0x20;
245: public static final int FDC_ST3_T0 = 0x10;
246: public static final int FDC_ST3_TS = 0x08;
247:
248:
249:
250: public static final String[] FDC_COMMAND_NAME = {
251: "INVALID",
252: "INVALID",
253: "READ DIAGNOSTIC",
254: "SPECIFY",
255: "SENSE DEVICE STATUS",
256: "WRITE DATA",
257: "READ DATA",
258: "RECALIBRATE",
259: "SENSE INTERRUPT STATUS",
260: "WRITE DELETED DATA",
261: "READ ID",
262: "INVALID",
263: "READ DELETED DATA",
264: "WRITE ID",
265: "INVALID",
266: "SEEK",
267: "INVALID",
268: "SCAN EQUAL",
269: "INVALID",
270: "INVALID",
271: "RESET STANDBY",
272: "SET STANDBY",
273: "SOFTWARE RESET",
274: "INVALID",
275: "INVALID",
276: "SCAN LOW OR EQUAL",
277: "INVALID",
278: "INVALID",
279: "INVALID",
280: "SCAN HIGH OR EQUAL",
281: "INVALID",
282: "INVALID",
283: };
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321: public static final byte[] FDC_COMMAND_LENGTH = "\1\1\t\3\2\t\t\2\1\t\2\1\t\6\1\3\1\t\1\1\1\1\1\1\1\t\1\1\1\t\1\1".getBytes (XEiJ.ISO_8859_1);
322: public static int fdcCommandNumber;
323:
324:
325: public static final byte[] fdcCommandBuffer = new byte[256];
326: public static final byte[] fdcResultBuffer = new byte[256];
327: public static final byte[] fdcTempBuffer = new byte[16384];
328: public static byte[] fdcReadHandle;
329: public static byte[] fdcWriteHandle;
330: public static int fdcIndex;
331: public static int fdcStart;
332: public static int fdcLimit;
333:
334:
335: public static boolean fdcEnforcedReady;
336:
337:
338:
339:
340: public static FDUnit fdcDriveLastSelected;
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548: public static int fdcSRT;
549:
550:
551:
552: public static void fdcInit () {
553: if (FDC_DEBUG_TRACE) {
554: System.out.printf ("%08x fdcInit()\n", XEiJ.regPC0);
555: fdcDebugLogOn = FDC_DEBUG_DEFAULT;
556: }
557:
558:
559:
560:
561: fdcFileFilter = new javax.swing.filechooser.FileFilter () {
562: @Override public boolean accept (File file) {
563: if (file.isDirectory ()) {
564: return true;
565: }
566: if (!file.isFile ()) {
567: return false;
568: }
569: String path = file.getPath ();
570: if (fdcIsInsertedPath (path)) {
571: return false;
572: }
573: int dotIndex = path.lastIndexOf ('.');
574: String upperExt = dotIndex < 0 ? "" : path.substring (dotIndex + 1).toUpperCase ();
575: if (upperExt.equals ("DIM")) {
576: return true;
577: }
578: long longLength = file.length ();
579: if (1024 * 1024 * 16 <= longLength) {
580: return false;
581: }
582: int length = (int) longLength;
583: for (FDMedia media : FDMedia.FDM_ARRAY) {
584: if (media.fdmBytesPerDisk == length) {
585: return true;
586: }
587: }
588: return false;
589: }
590: @Override public String getDescription () {
591: return (Multilingual.mlnJapanese ?
592: "フロッピーディスクのイメージファイル (*.XDF,*.2HD,*.2HC,*.DIM,etc.)" :
593: "Floppy disk image files (*.XDF,*.2HD,*.2HC,*.DIM,etc.)");
594: }
595: };
596:
597:
598: fdcOpenDialog = null;
599: fdcOpenUnit = 0;
600: fdcOpenHistory = new ArrayList<File[]> ();
601: for (int i = JFileChooser2.MAXIMUM_HISTORY_COUNT - 1; 0 <= i; i--) {
602: fdcAddHistory (JFileChooser2.pathsToFiles (Settings.sgsGetString ("fdhistory" + i)));
603: }
604:
605:
606: fdcFormatDialog = null;
607: fdcFormatX86SafeCheckBox = null;
608: fdcFormatFileChooser = null;
609: fdcFormatMedia = FDMedia.FDM_2HD;
610:
611: fdcFormatX86SafeOn = true;
612: fdcFormatCopyHumanSysCheckBox = null;
613: fdcFormatCopyCommandXCheckBox = null;
614: fdcFormatCopyHumanSysOn = true;
615: fdcFormatCopyCommandXOn = true;
616:
617:
618:
619: fdcUnitArray = new FDUnit[FDC_MAX_UNITS];
620: for (int u = 0; u < FDC_MAX_UNITS; u++) {
621: FDUnit unit = fdcUnitArray[u] = new FDUnit (u);
622: if (u < FDC_MIN_UNITS) {
623: unit.connect (false);
624: }
625: String path = Settings.sgsGetString ("fd" + u);
626: boolean userWriteProtect = false;
627: if (path.toUpperCase ().endsWith (":R")) {
628: path = path.substring (0, path.length () - 2);
629: userWriteProtect = true;
630: }
631: boolean hostWriteProtect = !new File (path).canWrite ();
632: if (path.length () != 0) {
633: unit.connect (true);
634: if (unit.insert (path,
635: userWriteProtect || hostWriteProtect)) {
636: fdcAddHistory (new File (path).getAbsoluteFile ());
637: }
638: }
639: }
640:
641:
642:
643:
644: fdcCPhase ();
645: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
646: fdcLastStatus = -1;
647: }
648: fdcEnforcedReady = false;
649: fdcDriveLastSelected = null;
650: fdcSRT = 3;
651: }
652:
653:
654: public static void fdcReset () {
655: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
656: System.out.printf ("%08x fdcReset()\n", XEiJ.regPC0);
657: }
658:
659:
660:
661:
662:
663:
664:
665: fdcCPhase ();
666: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
667: fdcLastStatus = -1;
668: }
669: fdcEnforcedReady = false;
670: fdcDriveLastSelected = null;
671: fdcSRT = 3;
672:
673:
674: for (int u = 0; u <= 3; u++) {
675: FDUnit unit = fdcUnitArray[u];
676: if (unit.fduIsInserted ()) {
677: IOInterrupt.ioiFddFall ();
678: IOInterrupt.ioiFddRise ();
679: break;
680: }
681: }
682:
683: }
684:
685:
686:
687:
688: public static void fdcTini () {
689: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
690: System.out.printf ("%08x fdcTini()\n", XEiJ.regPC0);
691: }
692: for (FDUnit unit : fdcUnitArray) {
693: unit.fduTini ();
694: }
695:
696:
697:
698: if (fdcOpenDialog != null) {
699: Settings.sgsPutOnOff ("fdreadonly", fdcOpenDialog.getReadOnly ());
700: Settings.sgsPutOnOff ("fdappreboot", fdcOpenDialog.getReboot ());
701: ArrayList<String> pathsList = fdcOpenDialog.getHistory ();
702: int n = pathsList.size ();
703: for (int i = 0; i < n; i++) {
704: Settings.sgsPutString ("fdhistory" + i, pathsList.get (i));
705: }
706: for (int i = n; i < FDC_MAX_UNITS; i++) {
707: Settings.sgsPutString ("fdhistory" + i, "");
708: }
709: }
710:
711:
712: for (int u = 0; u < FDC_MAX_UNITS; u++) {
713: AbstractUnit unit = fdcUnitArray[u];
714: Settings.sgsPutString (
715: "fd" + u,
716: unit.abuConnected && unit.abuInserted ?
717: unit.abuWriteProtected ? unit.abuPath + ":R" : unit.abuPath :
718: "");
719: }
720:
721: }
722:
723: public static void fdcMakeMenu () {
724:
725:
726: ActionListener listener = new ActionListener () {
727: @Override public void actionPerformed (ActionEvent ae) {
728: Object source = ae.getSource ();
729: String command = ae.getActionCommand ();
730: switch (command) {
731: case "Create new floppy disk image files":
732: fdcOpenFormatDialog ();
733: break;
734: case "FDC debug log":
735: if (FDC_DEBUG_TRACE) {
736: fdcDebugLogOn = ((JCheckBoxMenuItem) source).isSelected ();
737: }
738: break;
739: }
740: }
741: };
742:
743:
744: fdcMenu = ComponentFactory.createMenu ("FD");
745: ComponentFactory.addComponents (
746: fdcMenu,
747: ComponentFactory.createHorizontalBox (
748: Multilingual.mlnText (ComponentFactory.createLabel ("Floppy disk"),
749: "ja", "フロッピーディスク")),
750: ComponentFactory.createHorizontalSeparator ()
751: );
752: for (FDUnit unit : fdcUnitArray) {
753: fdcMenu.add (unit.getMenuBox ());
754: }
755: ComponentFactory.addComponents (
756: fdcMenu,
757: ComponentFactory.createHorizontalSeparator (),
758: Multilingual.mlnText (ComponentFactory.createMenuItem ("Create new floppy disk image files", listener),
759: "ja", "フロッピーディスクのイメージファイルの新規作成"),
760: !FDC_DEBUG_TRACE ? null :
761: Multilingual.mlnText (ComponentFactory.createCheckBoxMenuItem (fdcDebugLogOn, "FDC debug log", listener), "ja", "FDC デバッグログ")
762: );
763:
764: }
765:
766:
767:
768: public static boolean fdcIsInsertedPath (String path) {
769: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
770: System.out.printf ("%08x fdcIsInsertedPath(\"%s\")\n", XEiJ.regPC0, path);
771: }
772: boolean inserted = false;
773: for (FDUnit unit : fdcUnitArray) {
774: if (unit != null &&
775: unit.abuConnected &&
776: unit.fduIsInserted () &&
777: unit.abuPath.equals (path)) {
778: inserted = true;
779: break;
780: }
781: }
782: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
783: System.out.printf ("\tinserted=%b\n", inserted);
784: }
785: return inserted;
786: }
787:
788: static class OpenDialog extends AbstractOpenDialog {
789: public OpenDialog () {
790: super (XEiJ.frmFrame,
791: "Open floppy disk image files",
792: "フロッピーディスクのイメージファイルを開く",
793: false,
794: fdcFileFilter);
795: }
796: @Override public void openFiles (File[] files, boolean reboot) {
797: fdcOpenFiles (files, reboot);
798: }
799: }
800:
801:
802:
803: public static void fdcOpenFiles (File[] list, boolean reset) {
804: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
805: System.out.printf ("%08x fdcOpenFiles({", XEiJ.regPC0);
806: for (int i = 0; i < list.length; i++) {
807: if (0 < i) {
808: System.out.print (',');
809: }
810: System.out.printf ("\"%s\"", list[i].getPath ());
811: }
812: System.out.printf ("},%b)\n", reset);
813: }
814: boolean success = true;
815: for (int u = fdcOpenUnit, k = 0; k < list.length; ) {
816: if (FDC_MAX_UNITS <= u) {
817: success = false;
818: break;
819: }
820: FDUnit unit = fdcUnitArray[u];
821: if (!unit.abuConnected) {
822: u++;
823: continue;
824: }
825: File file = list[k++];
826: if (!file.isFile ()) {
827: success = false;
828: continue;
829: }
830: if (!unit.insert (file.getPath (),
831: fdcOpenDialog.getReadOnly () || !file.canWrite ())) {
832: success = false;
833: continue;
834: }
835: u++;
836: }
837: if (success) {
838: fdcAddHistory (list);
839: if (reset) {
840: XEiJ.mpuReset (0x9070 | fdcOpenUnit << 8, -1);
841: }
842: }
843: }
844:
845:
846:
847:
848: public static void fdcMakeFormatDialog () {
849:
850: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
851: System.out.printf ("%08x fdcMakeFormatDialog()\n", XEiJ.regPC0);
852: }
853:
854:
855: ActionListener listener = new ActionListener () {
856: @Override public void actionPerformed (ActionEvent ae) {
857: switch (ae.getActionCommand ()) {
858: case JFileChooser.APPROVE_SELECTION:
859: case "Start formatting":
860: {
861: File[] list = fdcFormatFileChooser.getSelectedFiles ();
862: if (list.length > 0) {
863: fdcFormatDialog.setVisible (false);
864: if (!fdcFormatFiles (list)) {
865:
866: }
867: }
868: }
869: break;
870: case JFileChooser.CANCEL_SELECTION:
871: case "Cancel":
872: fdcFormatDialog.setVisible (false);
873: break;
874: case "2HD (1232KB)":
875: fdcFormatMedia = FDMedia.FDM_2HD;
876: fdcFormatX86SafeCheckBox.setSelected (false);
877: fdcFormatX86SafeCheckBox.setEnabled (false);
878: break;
879: case "2HC (1200KB)":
880: fdcFormatMedia = FDMedia.FDM_2HC;
881: fdcFormatX86SafeCheckBox.setSelected (false);
882: fdcFormatX86SafeCheckBox.setEnabled (false);
883: break;
884: case "2DD (640KB)":
885: fdcFormatMedia = FDMedia.FDM_2DD8;
886: fdcFormatX86SafeCheckBox.setSelected (false);
887: fdcFormatX86SafeCheckBox.setEnabled (false);
888: break;
889: case "2DD (720KB)":
890: fdcFormatMedia = FDMedia.FDM_2DD9;
891: fdcFormatX86SafeCheckBox.setSelected (false);
892: fdcFormatX86SafeCheckBox.setEnabled (false);
893: break;
894: case "2HQ (1440KB)":
895: fdcFormatMedia = FDMedia.FDM_2HQ;
896: fdcFormatX86SafeCheckBox.setEnabled (true);
897: fdcFormatX86SafeCheckBox.setSelected (fdcFormatX86SafeOn);
898: break;
899: case "2DD (800KB)":
900: fdcFormatMedia = FDMedia.FDM_2DD10;
901: fdcFormatX86SafeCheckBox.setSelected (false);
902: fdcFormatX86SafeCheckBox.setEnabled (false);
903: break;
904: case "2HDE(1440KB)":
905: fdcFormatMedia = FDMedia.FDM_2HDE;
906: fdcFormatX86SafeCheckBox.setSelected (false);
907: fdcFormatX86SafeCheckBox.setEnabled (false);
908: break;
909: case "2HS (1440KB)":
910: fdcFormatMedia = FDMedia.FDM_2HS;
911: fdcFormatX86SafeCheckBox.setSelected (false);
912: fdcFormatX86SafeCheckBox.setEnabled (false);
913: break;
914:
915:
916:
917: case "HUMAN.SYS":
918: fdcFormatCopyHumanSysOn = fdcFormatCopyHumanSysCheckBox.isSelected ();
919: if (fdcFormatCopyHumanSysOn) {
920: fdcFormatCopyCommandXCheckBox.setEnabled (true);
921: fdcFormatCopyCommandXCheckBox.setSelected (fdcFormatCopyCommandXOn);
922: } else {
923: fdcFormatCopyCommandXCheckBox.setEnabled (false);
924: fdcFormatCopyCommandXCheckBox.setSelected (false);
925: }
926: break;
927: case "COMMAND.X":
928: fdcFormatCopyCommandXOn = fdcFormatCopyCommandXCheckBox.isSelected ();
929: break;
930: case "x86-safe":
931: fdcFormatX86SafeOn = ((JCheckBox) ae.getSource ()).isSelected ();
932: break;
933: }
934: }
935: };
936:
937:
938: fdcMakeFormatFileChooser ();
939: fdcFormatFileChooser.setFileFilter (fdcFileFilter);
940: fdcFormatFileChooser.addActionListener (listener);
941:
942:
943: ButtonGroup mediaGroup = new ButtonGroup ();
944: fdcFormatDialog = Multilingual.mlnTitle (
945: ComponentFactory.createModalDialog (
946: XEiJ.frmFrame,
947: "Create new floppy disk image files",
948: ComponentFactory.createBorderPanel (
949: 0, 0,
950: ComponentFactory.createVerticalBox (
951: fdcFormatFileChooser,
952: ComponentFactory.createHorizontalBox (
953: Box.createHorizontalStrut (12),
954: Box.createHorizontalGlue (),
955: ComponentFactory.createVerticalBox (
956: ComponentFactory.createHorizontalBox (
957: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2HD, "2HD (1232KB)", listener),
958: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2HC, "2HC (1200KB)", listener),
959: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2DD8, "2DD (640KB)", listener),
960: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2DD9, "2DD (720KB)", listener),
961: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2HQ, "2HQ (1440KB)", listener)
962: ),
963: ComponentFactory.createHorizontalBox (
964: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2DD10, "2DD (800KB)", listener),
965: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2HDE, "2HDE(1440KB)", listener),
966: ComponentFactory.createRadioButtonMenuItem (mediaGroup, fdcFormatMedia == FDMedia.FDM_2HS, "2HS (1440KB)", listener),
967: Box.createHorizontalGlue (),
968: fdcFormatX86SafeCheckBox = ComponentFactory.setEnabled (
969: Multilingual.mlnText (ComponentFactory.createCheckBox (fdcFormatMedia == FDMedia.FDM_2HQ && fdcFormatX86SafeOn, "x86-safe", listener), "ja", "x86 セーフ"),
970: fdcFormatMedia == FDMedia.FDM_2HQ),
971: Box.createHorizontalStrut (12)
972: )
973: ),
974: Box.createHorizontalGlue (),
975: Box.createHorizontalStrut (12)
976: ),
977: Box.createVerticalStrut (12),
978: ComponentFactory.createHorizontalBox (
979: Box.createHorizontalStrut (12),
980: Box.createHorizontalGlue (),
981:
982: fdcFormatCopyHumanSysCheckBox = ComponentFactory.createCheckBox (fdcFormatCopyHumanSysOn, "HUMAN.SYS", listener),
983: Box.createHorizontalStrut (12),
984: fdcFormatCopyCommandXCheckBox = ComponentFactory.setEnabled (
985: ComponentFactory.createCheckBox (fdcFormatCopyHumanSysOn && fdcFormatCopyCommandXOn, "COMMAND.X", listener),
986: fdcFormatCopyHumanSysOn),
987: Box.createHorizontalGlue (),
988: Box.createHorizontalStrut (12),
989: Multilingual.mlnText (ComponentFactory.createButton ("Start formatting", KeyEvent.VK_F, listener), "ja", "フォーマットを開始する"),
990: Box.createHorizontalStrut (12),
991: Multilingual.mlnText (ComponentFactory.createButton ("Cancel", KeyEvent.VK_C, listener), "ja", "キャンセル"),
992: Box.createHorizontalStrut (12)
993: ),
994: Box.createVerticalStrut (12)
995: )
996: )
997: ),
998: "ja", "フロッピーディスクのイメージファイルの新規作成");
999:
1000: }
1001:
1002:
1003:
1004: public static void fdcMakeFormatFileChooser () {
1005: if (fdcFormatFileChooser == null) {
1006: fdcFormatFileChooser = new JFileChooser2 ();
1007:
1008: fdcFormatFileChooser.setControlButtonsAreShown (false);
1009: }
1010: }
1011:
1012:
1013:
1014:
1015: public static void fdcOpenFormatDialog () {
1016: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1017: System.out.printf ("%08x fdcOpenFormatDialog()\n", XEiJ.regPC0);
1018: }
1019: if (fdcFormatDialog == null) {
1020: fdcMakeFormatDialog ();
1021: }
1022: fdcFormatFileChooser.rescanCurrentDirectory ();
1023: fdcFormatDialog.setVisible (true);
1024: }
1025:
1026:
1027:
1028:
1029: public static boolean fdcFormatFiles (File[] list) {
1030: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1031: System.out.printf ("%08x fdcFormatFiles({", XEiJ.regPC0);
1032: for (int i = 0; i < list.length; i++) {
1033: if (0 < i) {
1034: System.out.print (',');
1035: }
1036: System.out.printf ("\"%s\"", list[i].getPath ());
1037: }
1038: System.out.println ('}');
1039: }
1040: boolean success = true;
1041: format:
1042: {
1043:
1044: byte[] diskImage = new byte[fdcFormatMedia.fdmBytesPerDisk];
1045: if (!fdcFormatMedia.fdmMakeFormatData (diskImage, fdcFormatCopyHumanSysOn, fdcFormatCopyCommandXOn, fdcFormatX86SafeOn)) {
1046: success = false;
1047: break format;
1048: }
1049: byte[] dimImage = null;
1050: int dimSize = 0;
1051:
1052: int u = 0;
1053: for (File file : list) {
1054: String path = file.getPath ();
1055: String upperPath = path.toUpperCase ();
1056: if (upperPath.endsWith (".DIM")) {
1057: if (fdcIsInsertedPath (path)) {
1058: success = false;
1059: break format;
1060: }
1061: if (dimImage == null) {
1062: dimImage = new byte[256 + fdcFormatMedia.fdmBytesPerDisk];
1063: dimSize = fdcFormatMedia.fdmMakeDimImage (dimImage, diskImage);
1064: if (dimSize < 0) {
1065: success = false;
1066: break format;
1067: }
1068: }
1069: if (!XEiJ.rscPutFile (path, dimImage, 0, dimSize)) {
1070: success = false;
1071: break format;
1072: }
1073: } else {
1074: boolean extNotSpecified = true;
1075: for (String mediaExt : fdcFormatMedia.fdmExtensionArray) {
1076: if (upperPath.endsWith (mediaExt)) {
1077: extNotSpecified = false;
1078: break;
1079: }
1080: }
1081: if (extNotSpecified) {
1082: if (!path.endsWith (".")) {
1083: path += ".";
1084: }
1085: path += fdcFormatMedia.fdmExtensionArray[0].toLowerCase ();
1086: upperPath = path.toUpperCase ();
1087: }
1088: if (fdcIsInsertedPath (path)) {
1089: success = false;
1090: break format;
1091: }
1092: if (!XEiJ.rscPutFile (path, diskImage, 0, fdcFormatMedia.fdmBytesPerDisk)) {
1093: success = false;
1094: break format;
1095: }
1096: }
1097:
1098: while (u < FDC_MAX_UNITS) {
1099: FDUnit unit = fdcUnitArray[u++];
1100: if (unit.abuConnected &&
1101: !unit.fduIsInserted () &&
1102: unit.insert (path,
1103: false)) {
1104:
1105: break;
1106: }
1107: }
1108: }
1109: }
1110: if (success) {
1111: fdcAddHistory (list);
1112: }
1113: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1114: System.out.printf ("\tsuccess=%b\n", success);
1115: }
1116: return success;
1117: }
1118:
1119:
1120:
1121:
1122: public static void fdcAddHistory (File file) {
1123: fdcAddHistory (new File[] { file });
1124: }
1125:
1126:
1127:
1128: public static void fdcAddHistory (File[] files) {
1129: if (fdcOpenDialog == null) {
1130: fdcOpenHistory.add (files);
1131: } else {
1132: fdcOpenDialog.addHistory (files);
1133: }
1134: fdcMakeFormatFileChooser ();
1135: fdcFormatFileChooser.addHistory (files);
1136: fdcFormatFileChooser.selectLastFiles ();
1137: }
1138:
1139:
1140:
1141:
1142:
1143: public static int fdcPeekStatus () {
1144: return fdcStatus;
1145: }
1146:
1147:
1148:
1149:
1150: public static int fdcReadStatus () {
1151: int d = fdcStatus;
1152: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1153: if (fdcLastStatus == d) {
1154: System.out.print ('=');
1155: } else {
1156: fdcLastStatus = d;
1157: System.out.printf ("%08x fdcReadStatus(0x00e94001)=%s\n", XEiJ.regPC0, fdcStatusToString (d));
1158: }
1159: }
1160: return d;
1161: }
1162:
1163:
1164:
1165:
1166: public static int fdcPeekData () {
1167: return (fdcReadHandle == null ? 0 :
1168: fdcReadHandle[fdcIndex] & 255);
1169: }
1170:
1171:
1172:
1173:
1174: public static int fdcReadData () {
1175: if (fdcReadHandle == null) {
1176: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1177: System.out.printf ("%08x fdcReadData(0x00e94003=???)=0x00\n", XEiJ.regPC0);
1178: }
1179: return 0;
1180: }
1181: int d = fdcReadHandle[fdcIndex] & 255;
1182: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1183: if (fdcIndex < fdcStart + 8 || fdcLimit - 8 <= fdcIndex) {
1184: System.out.printf ("%08x fdcReadData(0x00e94003=%s[0x%08x])=0x%02x\n",
1185: XEiJ.regPC0,
1186: fdcReadHandle == fdcResultBuffer ? "fdcResultBuffer" :
1187: fdcReadHandle == fdcTempBuffer ? "fdcTempBuffer" :
1188: "fduImage",
1189: fdcIndex,
1190: d);
1191: }
1192: }
1193: fdcIndex++;
1194: if (fdcIndex < fdcLimit) {
1195: if (fdcReadHandle != fdcResultBuffer) {
1196: HD63450.dmaFallPCL (0);
1197: } else {
1198: if (fdcIndex == 1) {
1199: fdcStatus &= ~(1 << (d & 3));
1200: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1201: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
1202: }
1203: }
1204: }
1205: } else {
1206: if (fdcReadHandle != fdcResultBuffer) {
1207: fdcEPhaseEnd ();
1208: } else {
1209: fdcRPhaseEnd ();
1210: }
1211: }
1212: return d;
1213: }
1214:
1215:
1216:
1217:
1218: public static int fdcPeekDriveStatus () {
1219: return (fdcDriveLastSelected == null ? 0 :
1220: fdcDriveLastSelected.fduDriveStatus ());
1221: }
1222:
1223:
1224:
1225:
1226: public static int fdcReadDriveStatus () {
1227: int d = (fdcDriveLastSelected == null ? 0 :
1228: fdcDriveLastSelected.fduDriveStatus ());
1229: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1230: System.out.printf ("%08x fdcReadDriveStatus(0x00e94005)=0x%02x(挿入=%d 誤挿入=%d)\n",
1231: XEiJ.regPC0,
1232: d,
1233: d >> 7,
1234: d >> 6 & 1);
1235: }
1236: return d;
1237: }
1238:
1239:
1240:
1241:
1242: public static void fdcWriteCommand (int d) {
1243: if (fdcWriteHandle != fdcCommandBuffer) {
1244: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1245: System.out.printf ("%08x fdcWriteCommand(0x00e94001=???,0x%02x)\n",
1246: XEiJ.regPC0,
1247: d & 255);
1248: }
1249: return;
1250: }
1251: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1252: if (fdcIndex < fdcStart + 8 || fdcLimit - 8 <= fdcIndex) {
1253: System.out.printf ("%08x fdcWriteCommand(0x00e94001=%s[0x%08x],0x%02x)\n",
1254: XEiJ.regPC0,
1255: "fdcCommandBuffer",
1256: fdcIndex,
1257: d & 255);
1258: }
1259: }
1260: fdcWriteHandle[fdcIndex++] = (byte) d;
1261: if (fdcLimit <= fdcIndex) {
1262: fdcCPhaseEnd ();
1263: }
1264: }
1265:
1266:
1267:
1268:
1269: public static void fdcWriteData (int d) {
1270: if (fdcWriteHandle == null) {
1271: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1272: System.out.printf ("%08x fdcWriteData(0x00e94003=???,0x%02x)\n",
1273: XEiJ.regPC0,
1274: d & 255);
1275: }
1276: return;
1277: }
1278: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1279: if (fdcIndex < fdcStart + 8 || fdcLimit - 8 <= fdcIndex) {
1280: System.out.printf ("%08x fdcWriteData(0x00e94003=%s[0x%08x],0x%02x)\n",
1281: XEiJ.regPC0,
1282: fdcWriteHandle == fdcCommandBuffer ? "fdcCommandBuffer" :
1283: fdcWriteHandle == fdcTempBuffer ? "fdcTempBuffer" :
1284: "fduImage",
1285: fdcIndex,
1286: d & 255);
1287: }
1288: }
1289: fdcWriteHandle[fdcIndex++] = (byte) d;
1290: if (fdcIndex < fdcLimit) {
1291: if (fdcWriteHandle != fdcCommandBuffer) {
1292: HD63450.dmaFallPCL (0);
1293: }
1294: } else if (fdcWriteHandle == fdcCommandBuffer) {
1295: fdcCPhaseEnd ();
1296: } else {
1297: fdcEPhaseEnd ();
1298: }
1299: }
1300:
1301:
1302:
1303:
1304: public static void fdcCPhase () {
1305: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1306: System.out.printf ("%08x fdcCPhase()\n", XEiJ.regPC0);
1307: }
1308:
1309: fdcStatus = (FDC_RQM | FDC_MPU_TO_FDC |
1310: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
1311: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1312: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
1313: }
1314:
1315: fdcReadHandle = null;
1316: fdcWriteHandle = fdcCommandBuffer;
1317: fdcIndex = fdcStart = 0;
1318: fdcLimit = 1;
1319: fdcCommandNumber = -1;
1320: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1321: System.out.printf ("\tfdcCommandNumber=%d\n", fdcCommandNumber);
1322: }
1323: for (int u = 0; u <= 3; u++) {
1324: FDUnit unit = fdcUnitArray[u];
1325: if (unit.fduSeekStepWaiting) {
1326: unit.fduSeekStepWaiting = false;
1327: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1328: System.out.printf ("\tfduSeekStepWaiting%d=%b\n", u, unit.fduSeekStepWaiting);
1329: }
1330: unit.fduSeekStep ();
1331: }
1332: if ((fdcStatus & 1 << u) != 0) {
1333: if (unit.fduSeekEndInterruptWaiting) {
1334: unit.fduSeekEndInterruptWaiting = false;
1335: unit.fduSeekEndInterruptRequest = true;
1336: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1337: System.out.printf ("\tfduSeekEndInterruptWaiting%d=%b\n", u, unit.fduSeekEndInterruptWaiting);
1338: System.out.printf ("\tfduSeekEndInterruptRequest%d=%b\n", u, unit.fduSeekEndInterruptRequest);
1339: }
1340: IOInterrupt.ioiFdcRise ();
1341: }
1342: } else {
1343: if (unit.fduAttentionCheckWaiting) {
1344: unit.fduAttentionCheckWaiting = false;
1345: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1346: System.out.printf ("\tfduAttentionCheckWaiting%d=%b\n", u, unit.fduAttentionCheckWaiting);
1347: }
1348: boolean ready = unit.fduIsReady ();
1349: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1350: System.out.printf ("\tready%d=%b\n", u, ready);
1351: }
1352: if (ready != unit.fduSavedReady) {
1353: unit.fduSavedReady = ready;
1354: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1355: System.out.printf ("\tfduSavedReady%d=%b\n", u, unit.fduSavedReady);
1356: }
1357: if (!unit.fduAttentionInterruptRequest) {
1358: unit.fduAttentionInterruptRequest = true;
1359: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1360: System.out.printf ("\tfduAttentionInterruptRequest%d=%b\n", u, unit.fduAttentionInterruptRequest);
1361: }
1362: IOInterrupt.ioiFdcRise ();
1363: }
1364: }
1365: }
1366: }
1367: }
1368: }
1369:
1370:
1371:
1372: public static void fdcCPhaseEnd () {
1373: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1374: System.out.printf ("%08x fdcCPhaseEnd()\n", XEiJ.regPC0);
1375: }
1376: if (fdcCommandNumber < 0) {
1377: fdcCommandNumber = fdcCommandBuffer[0] & 31;
1378: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1379: System.out.printf ("\tfdcCommandNumber=%d\n", fdcCommandNumber);
1380: }
1381: fdcLimit = FDC_COMMAND_LENGTH[fdcCommandNumber];
1382: if (1 < fdcLimit) {
1383: fdcStatus |= FDC_CB;
1384: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1385: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
1386: }
1387:
1388:
1389:
1390: return;
1391: }
1392:
1393: }
1394:
1395: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1396: System.out.printf ("********* %s {",
1397: FDC_COMMAND_NAME[fdcCommandNumber]);
1398: for (int i = 0; i < fdcLimit; i++) {
1399: if (i > 0) {
1400: System.out.print (',');
1401: }
1402: System.out.printf ("0x%02x", fdcCommandBuffer[i] & 255);
1403: }
1404: System.out.println ("} ********");
1405: }
1406: FDUnit unit = fdcUnitArray[fdcCommandBuffer[1] & 3];
1407: switch (fdcCommandNumber) {
1408:
1409:
1410:
1411: case 0x03:
1412: fdcCommandSpecify ();
1413: break;
1414: case 0x04:
1415: unit.fduCommandSenseDeviceStatus ();
1416: break;
1417: case 0x05:
1418: unit.fduCommandWriteData ();
1419: break;
1420: case 0x06:
1421: unit.fduCommandReadData ();
1422: break;
1423: case 0x07:
1424: unit.fduCommandRecalibrate ();
1425: break;
1426: case 0x08:
1427: fdcCommandSenseInterruptStatus ();
1428: break;
1429:
1430:
1431:
1432: case 0x0a:
1433: unit.fduCommandReadId ();
1434: break;
1435:
1436:
1437:
1438: case 0x0d:
1439: unit.fduCommandWriteId ();
1440: break;
1441: case 0x0f:
1442: unit.fduCommandSeek ();
1443: break;
1444: case 0x11:
1445: unit.fduCommandScan ();
1446: break;
1447:
1448:
1449:
1450:
1451:
1452:
1453: case 0x16:
1454: fdcCommandSoftwareReset ();
1455: break;
1456: case 0x19:
1457: unit.fduCommandScan ();
1458: break;
1459: case 0x1d:
1460: unit.fduCommandScan ();
1461: break;
1462:
1463:
1464:
1465:
1466:
1467:
1468:
1469:
1470:
1471:
1472:
1473:
1474:
1475:
1476: default:
1477: fdcCommandInvalid ();
1478: }
1479: }
1480:
1481:
1482:
1483: public static void fdcEPhaseEnd () {
1484: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1485: System.out.printf ("%08x fdcEPhaseEnd()\n", XEiJ.regPC0);
1486: }
1487: FDUnit unit = fdcUnitArray[fdcCommandBuffer[1] & 3];
1488: switch (unit.fduCommandNumber) {
1489: case 0x05:
1490: unit.fduWriteDataEPhaseEnd ();
1491: break;
1492: case 0x06:
1493: unit.fduReadDataEPhaseEnd ();
1494: break;
1495: case 0x0d:
1496: unit.fduWriteIdEPhaseEnd ();
1497: break;
1498: case 0x11:
1499: unit.fduScanEqualEPhaseEnd ();
1500: break;
1501: case 0x19:
1502: unit.fduScanLowOrEqualEPhaseEnd ();
1503: break;
1504: case 0x1d:
1505: unit.fduScanHighOrEqualEPhaseEnd ();
1506: break;
1507: }
1508: }
1509:
1510:
1511:
1512: public static void fdcRPhase (int limit) {
1513: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1514: System.out.printf ("%08x fdcRPhase({", XEiJ.regPC0);
1515: for (int i = 0; i < limit; i++) {
1516: if (0 < i) {
1517: System.out.print (',');
1518: }
1519: System.out.printf ("0x%02x", fdcResultBuffer[i] & 255);
1520: }
1521: System.out.println ("})");
1522: }
1523: fdcStatus = (FDC_RQM | FDC_FDC_TO_MPU | FDC_CB |
1524: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
1525: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1526: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
1527: }
1528: fdcReadHandle = fdcResultBuffer;
1529: fdcWriteHandle = null;
1530: fdcIndex = fdcStart = 0;
1531: fdcLimit = limit;
1532: }
1533:
1534:
1535:
1536: public static void fdcRPhaseEnd () {
1537: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1538: System.out.printf ("%08x fdcRPhaseEnd()\n", XEiJ.regPC0);
1539: }
1540: fdcCPhase ();
1541:
1542: for (int u = 0; u <= 3; u++) {
1543: FDUnit unit = fdcUnitArray[u];
1544: if (unit.fduSeekEndInterruptRequest) {
1545: IOInterrupt.ioiFdcRise ();
1546: break;
1547: }
1548: }
1549: }
1550:
1551:
1552:
1553:
1554:
1555: public static void fdcWriteDriveControl (int d) {
1556:
1557: IOInterrupt.ioiFddFall ();
1558: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1559: System.out.printf ("%08x fdcWriteDriveControl(0x00e94005,0x%02x(BLK=%d PRV=%d EJT=%d US3=%d US2=%d US1=%d US0=%d))\n",
1560: XEiJ.regPC0,
1561: d & 255,
1562: d >> 7,
1563: d >> 6 & 1,
1564: d >> 5 & 1,
1565: d >> 3 & 1,
1566: d >> 2 & 1,
1567: d >> 1 & 1,
1568: d & 1);
1569: }
1570:
1571: int u = Integer.numberOfTrailingZeros (d & 15);
1572: if (u < 4) {
1573: FDUnit unit = fdcUnitArray[u];
1574: if (unit.abuConnected) {
1575: unit.fduDriveControl (d);
1576: }
1577: fdcDriveLastSelected = unit;
1578: } else {
1579: fdcDriveLastSelected = null;
1580: }
1581: }
1582:
1583:
1584:
1585:
1586: public static void fdcWriteDriveSelect (int d) {
1587: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1588: System.out.printf ("%08x fdcWriteDriveSelect(0x00e94007,0x%02x(MT=%d 2DD=%d US=%d))\n",
1589: XEiJ.regPC0,
1590: d & 255,
1591: d >> 7,
1592: d >> 4 & 1,
1593: d & 3);
1594: }
1595: IOInterrupt.ioiFddFall ();
1596: FDUnit unit = fdcUnitArray[d & 3];
1597: if (unit.abuConnected &&
1598: unit.fduIsInserted ()) {
1599: unit.fduDoubleDensity = d << 31 - 4 < 0;
1600: if ((byte) d < 0) {
1601: unit.fduMotorOn ();
1602: } else {
1603: unit.fduMotorOff ();
1604: }
1605: }
1606: }
1607:
1608:
1609:
1610: public static void fdcSetEnforcedReady (boolean enforcedReady) {
1611: fdcEnforcedReady = enforcedReady;
1612: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1613: System.out.printf ("%08x fdcSetEnforcedReady(%b)\n", XEiJ.regPC0, enforcedReady);
1614: }
1615: }
1616:
1617:
1618:
1619:
1620:
1621:
1622:
1623:
1624:
1625:
1626:
1627: public static void fdcCommandSpecify () {
1628: int srt = fdcCommandBuffer[1] >> 4 & 15;
1629: int hut = fdcCommandBuffer[1] & 15;
1630: int hlt = fdcCommandBuffer[2] >> 1 & 127;
1631: int nd = fdcCommandBuffer[2] & 1;
1632: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1633: System.out.printf ("%08x fdcCommandSpecify(SRT=%d HUT=%d HLT=%d ND=%d)\n", XEiJ.regPC0, srt, hut, hlt, nd);
1634: }
1635: fdcSRT = srt;
1636: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1637: System.out.printf ("\tfdcSRT=%d\n", fdcSRT);
1638: }
1639: fdcCPhase ();
1640: }
1641:
1642:
1643:
1644:
1645:
1646:
1647:
1648:
1649:
1650:
1651:
1652: public static void fdcCommandSenseInterruptStatus () {
1653: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1654: System.out.printf ("%08x fdcCommandSenseInterruptStatus()\n", XEiJ.regPC0);
1655: }
1656:
1657: IOInterrupt.ioiFdcFall ();
1658: for (int u = 0; u <= 3; u++) {
1659: FDUnit unit = fdcUnitArray[u];
1660: if ((fdcStatus & 1 << u) != 0) {
1661: if (unit.fduSeekEndInterruptWaiting) {
1662: unit.fduSeekEndInterruptWaiting = false;
1663: unit.fduSeekEndInterruptRequest = true;
1664: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1665: System.out.printf ("\tfduSeekEndInterruptWaiting%d=%b\n", u, unit.fduSeekEndInterruptWaiting);
1666: System.out.printf ("\tfduSeekEndInterruptRequest%d=%b\n", u, unit.fduSeekEndInterruptRequest);
1667: }
1668: } else {
1669: if (unit.fduAttentionCheckWaiting) {
1670: unit.fduAttentionCheckWaiting = false;
1671: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1672: System.out.printf ("\tfduAttentionCheckWaiting%d=%b\n", u, unit.fduAttentionCheckWaiting);
1673: }
1674: boolean ready = unit.fduIsReady ();
1675: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1676: System.out.printf ("\tready%d=%b\n", u, ready);
1677: }
1678: if (ready != unit.fduSavedReady) {
1679: unit.fduSavedReady = ready;
1680: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1681: System.out.printf ("\tfduSavedReady%d=%b\n", u, unit.fduSavedReady);
1682: }
1683: if (!unit.fduAttentionInterruptRequest) {
1684: unit.fduAttentionInterruptRequest = true;
1685: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1686: System.out.printf ("\tfduAttentionInterruptRequest%d=%b\n", u, unit.fduAttentionInterruptRequest);
1687: }
1688: }
1689: }
1690: }
1691: }
1692: }
1693: }
1694: int status = FDC_ST0_IC;
1695: for (int u = 0; u <= 3; u++) {
1696: FDUnit unit = fdcUnitArray[u];
1697: if (unit.fduSeekEndInterruptRequest) {
1698: unit.fduSeekEndInterruptRequest = false;
1699: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1700: System.out.printf ("\tfduSeekEndInterruptRequest%d=%b\n", u, unit.fduSeekEndInterruptRequest);
1701: }
1702: status = unit.fduSeekResultStatus | u << 24 | (unit.fduPCN & 255) << 16;
1703: break;
1704: }
1705: if (unit.fduAttentionInterruptRequest) {
1706: unit.fduAttentionInterruptRequest = false;
1707: status = FDC_ST0_AI | u << 24 | (unit.fduPCN & 255) << 16;
1708: break;
1709: }
1710: }
1711: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1712: System.out.printf ("\tstatus=%s\n", fdcResultStatusToString (status & 0xff000000));
1713: }
1714: fdcResultBuffer[0] = (byte) (status >> 24);
1715: if (status == FDC_ST0_IC) {
1716: fdcRPhase (1);
1717: } else {
1718: fdcResultBuffer[1] = (byte) (status >> 16);
1719: fdcRPhase (2);
1720: }
1721: }
1722:
1723:
1724:
1725:
1726: public static void fdcCommandResetStandby () {
1727: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1728: System.out.printf ("%08x fdcCommandResetStandby()\n", XEiJ.regPC0);
1729: }
1730:
1731: fdcCPhase ();
1732: }
1733:
1734:
1735:
1736:
1737: public static void fdcCommandSetStandby () {
1738: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1739: System.out.printf ("%08x fdcCommandSetStandby()\n", XEiJ.regPC0);
1740: }
1741:
1742: fdcCPhase ();
1743: }
1744:
1745:
1746:
1747:
1748: public static void fdcCommandSoftwareReset () {
1749: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1750: System.out.printf ("%08x fdcCommandSoftwareReset()\n", XEiJ.regPC0);
1751: }
1752:
1753: fdcCPhase ();
1754: }
1755:
1756:
1757:
1758:
1759:
1760:
1761:
1762:
1763:
1764:
1765:
1766:
1767:
1768:
1769:
1770:
1771:
1772: public static void fdcCommandInvalid () {
1773: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1774: System.out.printf ("%08x fdcCommandInvalid()\n", XEiJ.regPC0);
1775: }
1776: int status = FDC_ST0_IC;
1777: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1778: System.out.printf ("\tstatus=%s\n", fdcResultStatusToString (status));
1779: }
1780: fdcResultBuffer[0] = (byte) (status >> 24);
1781: fdcRPhase (1);
1782: }
1783:
1784:
1785: public static String fdcResultStatusToString (int status) {
1786: int ic = status >> 24 + 6 & 3;
1787: return String.format ("0x%08x\n" +
1788: "\t\tST0=0x%02x(IC=%d(%s) SE=%d EC=%d NR=%d HD=%d US=%d)\n" +
1789: "\t\tST1=0x%02x(EN=%d DE=%d OR=%d ND=%d NW=%d MA=%d)\n" +
1790: "\t\tST2=0x%02x(CM=%d DD=%d NC=%d SH=%d SN=%d BC=%d MD=%d)",
1791: status,
1792: status >> 24 & 255,
1793: ic, ic == 0 ? "NT" : ic == 1 ? "AT" : ic == 2 ? "IC" : "AI",
1794: status >> 24 + 5 & 1,
1795: status >> 24 + 4 & 1,
1796: status >> 24 + 3 & 1,
1797: status >> 24 + 2 & 1,
1798: status >> 24 + 0 & 3,
1799: status >> 16 & 255,
1800: status >> 16 + 7 & 1,
1801: status >> 16 + 5 & 1,
1802: status >> 16 + 4 & 1,
1803: status >> 16 + 2 & 1,
1804: status >> 16 + 1 & 1,
1805: status >> 16 + 0 & 1,
1806: status >> 8 & 255,
1807: status >> 8 + 6 & 1,
1808: status >> 8 + 5 & 1,
1809: status >> 8 + 4 & 1,
1810: status >> 8 + 3 & 1,
1811: status >> 8 + 2 & 1,
1812: status >> 8 + 1 & 1,
1813: status >> 8 + 0 & 1);
1814: }
1815:
1816:
1817: public static String fdcStatusToString (int status) {
1818: return String.format ("0x%02x(RQM=%d DIO=%d(%s) NDM=%d CB=%d D3B=%d D2B=%d D1B=%d D0B=%d)",
1819: status,
1820: status >> 7,
1821: status >> 6 & 1,
1822: (status >> 6 & 1) == 0 ? "MPU->FDC" : "FDC->MPU",
1823: status >> 5 & 1,
1824: status >> 4 & 1,
1825: status >> 3 & 1,
1826: status >> 2 & 1,
1827: status >> 1 & 1,
1828: status & 1);
1829: }
1830:
1831:
1832:
1833:
1834:
1835:
1836:
1837: public static class FDUnit extends AbstractUnit {
1838:
1839: public FDMedia fduMedia;
1840: public byte[] fduImage;
1841: public boolean fduWritten;
1842:
1843: public int fduCommandNumber;
1844:
1845:
1846:
1847:
1848:
1849:
1850:
1851:
1852:
1853:
1854:
1855:
1856: public boolean fduIsInserted () {
1857: return abuConnected && abuInserted && fduMedia != null;
1858: }
1859:
1860:
1861:
1862:
1863:
1864:
1865:
1866: public boolean fduBlinking;
1867:
1868:
1869:
1870: public boolean fduPrevented;
1871:
1872:
1873:
1874:
1875:
1876:
1877:
1878:
1879:
1880: public boolean fduDoubleDensity;
1881:
1882:
1883:
1884: public boolean fduIsWriteProtected () {
1885: return abuWriteProtected;
1886: }
1887:
1888:
1889:
1890:
1891:
1892:
1893: public boolean fduIsReady () {
1894: return (fdcEnforcedReady ||
1895: (abuConnected &&
1896: fduIsInserted () &&
1897: (fduMotorStatus == FDU_MOTOR_RUN_SOON ||
1898: fduMotorStatus == FDU_MOTOR_DECELERATING ||
1899: fduMotorStatus == FDU_MOTOR_RUNNING)));
1900: }
1901:
1902:
1903:
1904:
1905:
1906:
1907: public static final int FDU_ACCESS_OFF = 0;
1908: public static final int FDU_ACCESS_GREEN_BLINKING = 1;
1909: public static final int FDU_ACCESS_GREEN_ON = 2;
1910: public static final int FDU_ACCESS_RED_ON = 3;
1911:
1912:
1913:
1914:
1915:
1916: public static final int FDU_EJECT_OFF = 0;
1917: public static final int FDU_EJECT_GREEN_ON = 1;
1918:
1919:
1920:
1921: public static final long FDU_SEEK_INTERVAL = XEiJ.TMR_FREQ * 1 / 1000;
1922: public int fduNCN;
1923: public int fduPCN;
1924: public int fduPHN;
1925: public int fduPRN;
1926: public int fduPNN;
1927: public int fduEOT;
1928: public int fduSTP;
1929: public int fduSRC;
1930: public boolean fduSeekStepWaiting;
1931: public boolean fduSeekEndInterruptWaiting;
1932: public boolean fduSeekEndInterruptRequest;
1933: public int fduSeekResultStatus;
1934:
1935:
1936:
1937: public final TickerQueue.Ticker fduSeekTicker = new TickerQueue.Ticker () {
1938: @Override protected void tick () {
1939: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1940: System.out.printf ("%08x fduSeekTicker%d.tick()\n", XEiJ.regPC0, abuNumber);
1941: }
1942: if ((fdcStatus & 1 << abuNumber) != 0) {
1943: if ((fdcStatus & FDC_CB) != 0) {
1944: fduSeekStepWaiting = true;
1945: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1946: System.out.printf ("\tfduSeekStepWaiting%d=%b\n", abuNumber, fduSeekStepWaiting);
1947: }
1948: } else {
1949: fduSeekStep ();
1950: }
1951: } else {
1952: fduSeekStep ();
1953: }
1954: }
1955: };
1956:
1957:
1958:
1959: public void fduSeekStep () {
1960: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1961: System.out.printf ("%08x fduSeekStep%d()\n", XEiJ.regPC0, abuNumber);
1962: }
1963: if (fduPCN != fduNCN) {
1964: fduSRC--;
1965: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1966: System.out.printf ("\tfduSRC%d=%d\n", abuNumber, fduSRC);
1967: }
1968: if (fduSRC == 0) {
1969: fduSRC = 16 - fdcSRT;
1970: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1971: System.out.printf ("\tfduSRC%d=%d\n", abuNumber, fduSRC);
1972: }
1973: if (fduPCN < fduNCN) {
1974: fduPCN++;
1975: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1976: System.out.printf ("\tfduPCN%d=%d\n", abuNumber, fduPCN);
1977: }
1978: } else {
1979: fduPCN--;
1980: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
1981: System.out.printf ("\tfduPCN%d=%d\n", abuNumber, fduPCN);
1982: }
1983: }
1984: }
1985: TickerQueue.tkqAdd (fduSeekTicker, XEiJ.mpuClockTime + FDU_SEEK_INTERVAL);
1986: return;
1987: }
1988:
1989:
1990: switch (fduCommandNumber) {
1991:
1992:
1993:
1994: case 0x05:
1995: fduWriteDataEPhase ();
1996: break;
1997: case 0x06:
1998: fduReadDataEPhase ();
1999: break;
2000: case 0x07:
2001: case 0x0f:
2002:
2003: fduSeekEnd ();
2004: break;
2005:
2006:
2007:
2008:
2009:
2010:
2011: case 0x11:
2012: case 0x19:
2013: case 0x1d:
2014: fduScanEPhase ();
2015: break;
2016: }
2017: }
2018:
2019:
2020:
2021: public void fduSeekEnd () {
2022: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2023: System.out.printf ("%08x fduSeekEnd%d()\n", XEiJ.regPC0, abuNumber);
2024: }
2025: if ((fdcStatus & FDC_CB) != 0) {
2026: fduSeekEndInterruptWaiting = true;
2027: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2028: System.out.printf ("\tfduSeekEndInterruptWaiting%d=%b\n", abuNumber, fduSeekEndInterruptWaiting);
2029: }
2030: } else {
2031: if (!fduSeekEndInterruptRequest) {
2032: fduSeekEndInterruptRequest = true;
2033: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2034: System.out.printf ("\tfduSeekEndInterruptRequest%d=%b\n", abuNumber, fduSeekEndInterruptRequest);
2035: }
2036: IOInterrupt.ioiFdcRise ();
2037: }
2038: }
2039: }
2040:
2041:
2042:
2043:
2044:
2045:
2046:
2047:
2048:
2049:
2050:
2051:
2052:
2053:
2054:
2055:
2056:
2057:
2058:
2059:
2060:
2061:
2062:
2063:
2064:
2065:
2066:
2067:
2068:
2069:
2070:
2071:
2072:
2073:
2074:
2075:
2076:
2077:
2078:
2079:
2080:
2081:
2082:
2083:
2084:
2085:
2086:
2087:
2088:
2089:
2090:
2091:
2092:
2093:
2094:
2095:
2096:
2097:
2098:
2099:
2100:
2101:
2102:
2103:
2104:
2105:
2106:
2107:
2108:
2109:
2110:
2111:
2112:
2113:
2114:
2115:
2116:
2117:
2118:
2119:
2120:
2121:
2122:
2123:
2124:
2125:
2126:
2127:
2128:
2129:
2130:
2131:
2132:
2133:
2134:
2135: public static final int FDU_MOTOR_SLEEPING = 0;
2136: public static final int FDU_MOTOR_ACCELERATING = 1;
2137: public static final int FDU_MOTOR_SLEEP_SOON = 2;
2138: public static final int FDU_MOTOR_RUN_SOON = 3;
2139: public static final int FDU_MOTOR_DECELERATING = 4;
2140: public static final int FDU_MOTOR_RUNNING = 5;
2141: public int fduMotorStatus;
2142: public static final long FDU_MOTOR_ON_DELAY = XEiJ.TMR_FREQ * 100 / 1000000;
2143: public static final long FDU_MOTOR_OFF_DELAY = XEiJ.TMR_FREQ * 3;
2144: public static final long FDU_MOTOR_INTERRUPT_DELAY = XEiJ.TMR_FREQ * 100 / 1000000;
2145: public boolean fduSavedReady;
2146: public boolean fduAttentionCheckWaiting;
2147: public boolean fduAttentionInterruptRequest;
2148:
2149:
2150:
2151: public void fduMotorOn () {
2152: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2153: System.out.printf ("%08x fduMotorOn%d()\n", XEiJ.regPC0, abuNumber);
2154: }
2155: if (!fduIsInserted ()) {
2156: return;
2157: }
2158: switch (fduMotorStatus) {
2159: case FDU_MOTOR_SLEEPING:
2160: fduMotorStatus = FDU_MOTOR_ACCELERATING;
2161: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2162: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2163: }
2164: if (!fduPrevented) {
2165: prevent ();
2166: }
2167: TickerQueue.tkqAdd (fduMotorAcceleratingTicker, XEiJ.mpuClockTime + FDU_MOTOR_ON_DELAY);
2168: break;
2169: case FDU_MOTOR_SLEEP_SOON:
2170: TickerQueue.tkqRemove (fduMotorSleepSoonTicker);
2171: fduMotorStatus = FDU_MOTOR_ACCELERATING;
2172: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2173: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2174: }
2175: TickerQueue.tkqAdd (fduMotorAcceleratingTicker, XEiJ.mpuClockTime + FDU_MOTOR_ON_DELAY);
2176: break;
2177: case FDU_MOTOR_DECELERATING:
2178: TickerQueue.tkqRemove (fduMotorDeceleratingTicker);
2179: fduMotorStatus = FDU_MOTOR_RUN_SOON;
2180: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2181: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2182: }
2183: TickerQueue.tkqAdd (fduMotorRunSoonTicker, XEiJ.mpuClockTime + FDU_MOTOR_INTERRUPT_DELAY);
2184: break;
2185: }
2186: }
2187:
2188:
2189:
2190: public final TickerQueue.Ticker fduMotorAcceleratingTicker = new TickerQueue.Ticker () {
2191: @Override protected void tick () {
2192: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2193: System.out.printf ("%08x fduMotorAcceleratingTicker%d.tick()\n", XEiJ.regPC0, abuNumber);
2194: }
2195: fduMotorStatus = FDU_MOTOR_RUN_SOON;
2196: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2197: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2198: }
2199:
2200: TickerQueue.tkqAdd (fduMotorRunSoonTicker, XEiJ.mpuClockTime + FDU_MOTOR_INTERRUPT_DELAY);
2201: }
2202: };
2203:
2204:
2205:
2206: public final TickerQueue.Ticker fduMotorRunSoonTicker = new TickerQueue.Ticker () {
2207: @Override protected void tick () {
2208: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2209: System.out.printf ("%08x fduMotorRunSoonTicker%d.tick()\n", XEiJ.regPC0, abuNumber);
2210: }
2211: fduMotorStatus = FDU_MOTOR_RUNNING;
2212: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2213: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2214: }
2215: fduMotorInterrupt ();
2216: }
2217: };
2218:
2219:
2220:
2221: @SuppressWarnings ("fallthrough") public void fduMotorOff () {
2222: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2223: System.out.printf ("%08x fduMotorOff%d()\n", XEiJ.regPC0, abuNumber);
2224: }
2225: if (!fduIsInserted ()) {
2226: return;
2227: }
2228: switch (fduMotorStatus) {
2229: case FDU_MOTOR_ACCELERATING:
2230: TickerQueue.tkqRemove (fduMotorAcceleratingTicker);
2231: fduMotorStatus = FDU_MOTOR_SLEEP_SOON;
2232: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2233: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2234: }
2235: TickerQueue.tkqAdd (fduMotorSleepSoonTicker, XEiJ.mpuClockTime + FDU_MOTOR_INTERRUPT_DELAY);
2236: break;
2237: case FDU_MOTOR_RUN_SOON:
2238: TickerQueue.tkqRemove (fduMotorRunSoonTicker);
2239:
2240: case FDU_MOTOR_RUNNING:
2241: fduMotorStatus = FDU_MOTOR_DECELERATING;
2242: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2243: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2244: }
2245: TickerQueue.tkqAdd (fduMotorDeceleratingTicker, XEiJ.mpuClockTime + FDU_MOTOR_OFF_DELAY);
2246: break;
2247: }
2248: }
2249:
2250:
2251:
2252: public final TickerQueue.Ticker fduMotorDeceleratingTicker = new TickerQueue.Ticker () {
2253: @Override protected void tick () {
2254: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2255: System.out.printf ("%08x fduMotorDeceleratingTicker%d.tick()\n", XEiJ.regPC0, abuNumber);
2256: }
2257: fduMotorStatus = FDU_MOTOR_SLEEP_SOON;
2258: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2259: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2260: }
2261:
2262: TickerQueue.tkqAdd (fduMotorSleepSoonTicker, XEiJ.mpuClockTime + FDU_MOTOR_INTERRUPT_DELAY);
2263: }
2264: };
2265:
2266:
2267:
2268: public final TickerQueue.Ticker fduMotorSleepSoonTicker = new TickerQueue.Ticker () {
2269: @Override protected void tick () {
2270: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2271: System.out.printf ("%08x fduMotorSleepSoonTicker%d.tick()\n", XEiJ.regPC0, abuNumber);
2272: }
2273: fduMotorStatus = FDU_MOTOR_SLEEPING;
2274: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2275: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2276: }
2277: if (!fduPrevented) {
2278: allow ();
2279: }
2280: fduMotorInterrupt ();
2281: }
2282: };
2283:
2284:
2285:
2286: public void fduMotorInterrupt () {
2287: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2288: System.out.printf ("%08x fduMotorInterrupt%d()\n", XEiJ.regPC0, abuNumber);
2289: }
2290: if ((fdcStatus & 1 << abuNumber) != 0) {
2291: fduAttentionCheckWaiting = true;
2292: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2293: System.out.printf ("\tfduAttentionCheckWaiting%d=%b\n", abuNumber, fduAttentionCheckWaiting);
2294: }
2295: } else {
2296: if ((fdcStatus & FDC_CB) != 0) {
2297: fduAttentionCheckWaiting = true;
2298: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2299: System.out.printf ("\tfduAttentionCheckWaiting%d=%b\n", abuNumber, fduAttentionCheckWaiting);
2300: }
2301: } else {
2302: boolean ready = fduIsReady ();
2303: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2304: System.out.printf ("\tready%d=%b\n", abuNumber, ready);
2305: }
2306: if (ready != fduSavedReady) {
2307: fduSavedReady = ready;
2308: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2309: System.out.printf ("\tfduSavedReady%d=%b\n", abuNumber, fduSavedReady);
2310: }
2311: if (!fduAttentionInterruptRequest) {
2312: fduAttentionInterruptRequest = true;
2313: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2314: System.out.printf ("\tfduAttentionInterruptRequest%d=%b\n", abuNumber, fduAttentionInterruptRequest);
2315: }
2316: IOInterrupt.ioiFdcRise ();
2317: }
2318: }
2319: }
2320: }
2321: }
2322:
2323:
2324:
2325:
2326:
2327:
2328: public FDUnit (int number) {
2329: super (number);
2330:
2331: fduMedia = null;
2332: fduImage = null;
2333: fduWritten = false;
2334:
2335: fduBlinking = false;
2336: fduPrevented = false;
2337: fduDoubleDensity = false;
2338:
2339: fduNCN = 0;
2340: fduPCN = 0;
2341: fduPHN = 0;
2342: fduPRN = 1;
2343: fduPNN = 3;
2344: fduEOT = 1;
2345: fduSTP = 1;
2346: fduSeekStepWaiting = false;
2347: fduSeekEndInterruptWaiting = false;
2348: fduSeekEndInterruptRequest = false;
2349: fduSeekResultStatus = FDC_ST0_IC;
2350:
2351: fduMotorStatus = FDU_MOTOR_SLEEPING;
2352: fduSavedReady = false;
2353: fduAttentionCheckWaiting = false;
2354: fduAttentionInterruptRequest = false;
2355: }
2356:
2357:
2358:
2359:
2360: public void fduTini () {
2361: if (fduIsInserted ()) {
2362: fduFlush ();
2363: }
2364: }
2365:
2366:
2367:
2368: public boolean fduFlush () {
2369: if (!abuConnected ||
2370: !fduIsInserted () ||
2371: !fduWritten) {
2372: return true;
2373: }
2374: if (fduIsWriteProtected ()) {
2375: return false;
2376: }
2377: int dotIndex = abuPath.lastIndexOf ('.');
2378: String upperExt = dotIndex < 0 ? "" : abuPath.substring (dotIndex + 1).toUpperCase ();
2379: if (upperExt.equals ("DIM")) {
2380: byte[] dimImage = new byte[256 + fduMedia.fdmBytesPerDisk];
2381: int dimSize = fduMedia.fdmMakeDimImage (dimImage, fduImage);
2382: if (dimSize < 0) {
2383:
2384: JOptionPane.showMessageDialog (null,
2385: Multilingual.mlnJapanese ?
2386: fduMedia.fdmName + " を *.DIM に変換できません" :
2387: fduMedia.fdmName + " cannot be converted to *.DIM");
2388: return false;
2389: }
2390: if (!XEiJ.rscPutFile (abuPath, dimImage, 0, dimSize)) {
2391: return false;
2392: }
2393: } else {
2394: if (!XEiJ.rscPutFile (abuPath, fduImage, 0, fduMedia.fdmBytesPerDisk)) {
2395: return false;
2396: }
2397: }
2398: fduWritten = false;
2399: return true;
2400: }
2401:
2402:
2403:
2404: @Override protected void connect (boolean disconnectable) {
2405: super.connect (disconnectable);
2406: fduImage = new byte[FDMedia.FDM_BUFFER_SIZE];
2407: }
2408:
2409:
2410:
2411: @Override protected void disconnect () {
2412: super.disconnect ();
2413: fduImage = null;
2414: }
2415:
2416:
2417:
2418: public void blink () {
2419: if (!abuConnected ||
2420: fduBlinking) {
2421: return;
2422: }
2423: fduBlinking = true;
2424:
2425: }
2426:
2427:
2428:
2429: public void darken () {
2430: if (!abuConnected ||
2431: !fduBlinking) {
2432: return;
2433: }
2434: fduBlinking = false;
2435:
2436: }
2437:
2438:
2439:
2440: @Override protected boolean eject () {
2441: if (!fduFlush ()) {
2442: return false;
2443: }
2444: fduMotorStatus = FDU_MOTOR_SLEEPING;
2445: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2446: System.out.printf ("\tfduMotorStatus%d=%d\n", abuNumber, fduMotorStatus);
2447: }
2448: boolean inserted = fduIsInserted ();
2449: String path = abuPath;
2450: if (!super.eject ()) {
2451: return false;
2452: }
2453: if (fduMedia != null) {
2454: fdcAddHistory (new File (path).getAbsoluteFile ());
2455: System.out.println (Multilingual.mlnJapanese ?
2456: path + " を fd" + abuNumber + " から取り出しました" :
2457: path + " was ejected from fd" + abuNumber);
2458: }
2459: fduMedia = null;
2460: fduPCN = 0;
2461: fduPHN = 0;
2462: fduPRN = 1;
2463: fduPNN = 3;
2464:
2465: if (inserted) {
2466: IOInterrupt.ioiFddFall ();
2467: IOInterrupt.ioiFddRise ();
2468: }
2469: return true;
2470: }
2471:
2472:
2473:
2474: @Override protected boolean open () {
2475: if (!super.open ()) {
2476: return false;
2477: }
2478: fdcOpenUnit = abuNumber;
2479: if (fdcOpenDialog == null) {
2480: fdcOpenDialog = new OpenDialog ();
2481: fdcOpenDialog.setReadOnly (Settings.sgsGetOnOff ("fdreadonly"));
2482: fdcOpenDialog.setReboot (Settings.sgsGetOnOff ("fdappreboot"));
2483: for (File[] files : fdcOpenHistory) {
2484: fdcOpenDialog.addHistory (files);
2485: }
2486: fdcOpenHistory.clear ();
2487: }
2488: fdcOpenDialog.rescanCurrentDirectory ();
2489: fdcOpenDialog.setVisible (true);
2490: return true;
2491: }
2492:
2493:
2494:
2495: public boolean insert (String path, boolean writeProtected) {
2496: if (fdcIsInsertedPath (path)) {
2497: return false;
2498: }
2499: if (!super.insert (path, writeProtected)) {
2500: return false;
2501: }
2502: if (fduMedia != null) {
2503: IOInterrupt.ioiFddFall ();
2504: IOInterrupt.ioiFddRise ();
2505: }
2506: return true;
2507: }
2508:
2509:
2510:
2511:
2512: @Override protected boolean load (String path) {
2513: fduMedia = FDMedia.fdmPathToMedia (path, fduImage);
2514: if (fduMedia == null) {
2515: return false;
2516: }
2517: if (abuWriteProtected && !abuUnprotectable) {
2518: fduMedia.fdmReviveFiles (fduImage);
2519: }
2520: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2521: System.out.println ("media = " + fduMedia.fdmName);
2522: System.out.println ("------------------------------------------------------------------------");
2523: fduMedia.fdmPrintInfo ();
2524: System.out.println ("------------------------------------------------------------------------");
2525: }
2526: fduWritten = false;
2527: fdcAddHistory (new File (path).getAbsoluteFile ());
2528: System.out.println (Multilingual.mlnJapanese ?
2529: path + " を fd" + abuNumber + " に挿入しました" :
2530: path + " was inserted in fd" + abuNumber);
2531: return true;
2532: }
2533:
2534:
2535:
2536:
2537: public String getName () {
2538: return abuPath.substring (abuPath.lastIndexOf (File.separatorChar) + 1);
2539: }
2540:
2541:
2542:
2543:
2544: public int fduDriveStatus () {
2545: return fduIsInserted () ? 0x80 : 0;
2546: }
2547:
2548:
2549:
2550:
2551:
2552: public void fduDriveControl (int d) {
2553: if (d << 31 - 5 < 0) {
2554: eject ();
2555: }
2556: if (d << 31 - 6 < 0) {
2557: fduPrevented = true;
2558: prevent ();
2559: } else {
2560: fduPrevented = false;
2561: allow ();
2562: }
2563: if ((byte) d < 0) {
2564: fduBlinking = true;
2565: blink ();
2566: } else {
2567: fduBlinking = false;
2568: darken ();
2569: }
2570: }
2571:
2572:
2573:
2574:
2575:
2576:
2577:
2578:
2579:
2580:
2581:
2582:
2583:
2584:
2585:
2586:
2587:
2588:
2589:
2590:
2591:
2592:
2593:
2594:
2595:
2596:
2597:
2598:
2599:
2600:
2601:
2602:
2603:
2604:
2605:
2606:
2607:
2608:
2609:
2610:
2611:
2612:
2613:
2614:
2615:
2616:
2617: public void fduCommandReadDiagnostic () {
2618:
2619: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2620: System.out.printf ("%08x READ DIAGNOSTIC is not implemented\n", XEiJ.regPC0);
2621: }
2622: fdcCommandInvalid ();
2623: }
2624:
2625:
2626:
2627:
2628:
2629:
2630:
2631:
2632:
2633:
2634: public void fduCommandSenseDeviceStatus () {
2635:
2636: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2637: System.out.printf ("%08x fduCommandSenseDeviceStatus%d()\n", XEiJ.regPC0, abuNumber);
2638: }
2639: int st3 = ((fduIsWriteProtected () ? FDC_ST3_WP : 0) |
2640: (fduIsReady () ? FDC_ST3_RY : 0) |
2641: (fduIsInserted () && fduIsReady () && fduPCN == 0 ? FDC_ST3_T0 : 0) |
2642:
2643: (fduPHN & 1) << 2 |
2644: abuNumber);
2645: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2646: System.out.printf ("\t\tST3=0x%02x(FT=%d WP=%d RY=%d T0=%d TS=%d HD=%d US=%d)\n",
2647: st3,
2648: st3 >> 7,
2649: st3 >> 6 & 1,
2650: st3 >> 5 & 1,
2651: st3 >> 4 & 1,
2652: st3 >> 3 & 1,
2653: st3 >> 2 & 1,
2654: st3 & 3);
2655: }
2656: fdcResultBuffer[0] = (byte) st3;
2657: fdcRPhase (1);
2658: }
2659:
2660:
2661:
2662:
2663:
2664:
2665:
2666:
2667:
2668:
2669:
2670:
2671:
2672:
2673:
2674:
2675:
2676:
2677:
2678:
2679:
2680:
2681:
2682:
2683:
2684:
2685:
2686:
2687:
2688:
2689:
2690:
2691:
2692:
2693:
2694:
2695:
2696:
2697:
2698:
2699:
2700:
2701:
2702:
2703:
2704:
2705: public void fduCommandWriteData () {
2706:
2707: int ncn = fdcCommandBuffer[2] & 255;
2708: int phn = fdcCommandBuffer[3] & 255;
2709: int prn = fdcCommandBuffer[4] & 255;
2710: int pnn = fdcCommandBuffer[5] & 255;
2711: int eot = fdcCommandBuffer[6] & 255;
2712: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2713: System.out.printf ("%08x fduCommandWriteData%d(NCN=%d H=%d R=%d N=%d EOT=%d)\n",
2714: XEiJ.regPC0, abuNumber, ncn, phn, prn, pnn, eot);
2715: }
2716: fduCommandNumber = fdcCommandNumber;
2717: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2718: System.out.printf ("\tfduCommandNumber%d=0x%02x\n", abuNumber, fduCommandNumber);
2719: }
2720: if (!fduIsReady ()) {
2721: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_NR | ((fduPHN & 1) << 2 | abuNumber) << 24);
2722: return;
2723: }
2724: if (fduIsWriteProtected ()) {
2725: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_NW | ((fduPHN & 1) << 2 | abuNumber) << 24);
2726: return;
2727: }
2728: fduNCN = ncn;
2729: fduPHN = phn;
2730: fduPRN = prn;
2731: fduPNN = pnn;
2732: fduEOT = eot;
2733: fduSRC = 16 - fdcSRT;
2734: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2735: System.out.printf ("\tfduNCN%d=%d\n", abuNumber, fduNCN);
2736: System.out.printf ("\tfduPHN%d=%d\n", abuNumber, fduPHN);
2737: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
2738: System.out.printf ("\tfduPNN%d=%d\n", abuNumber, fduPNN);
2739: System.out.printf ("\tfduEOT%d=%d\n", abuNumber, fduEOT);
2740: System.out.printf ("\tfduSRC%d=%d\n", abuNumber, fduSRC);
2741: }
2742: fdcStatus = (FDC_MPU_TO_FDC | FDC_CB |
2743: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
2744: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2745: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
2746: }
2747: TickerQueue.tkqAdd (fduSeekTicker, XEiJ.mpuClockTime + FDU_SEEK_INTERVAL);
2748: }
2749:
2750: public void fduWriteDataEPhase () {
2751: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2752: System.out.printf ("%08x fduWriteDataEPhase%d()\n", XEiJ.regPC0, abuNumber);
2753: }
2754: if (fduPCN != fduNCN) {
2755: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_NR | ((fduPHN & 1) << 2 | abuNumber) << 24);
2756: return;
2757: }
2758:
2759: fduWritten = true;
2760: fdcStatus = (FDC_RQM | FDC_MPU_TO_FDC | FDC_CB |
2761: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
2762: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2763: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
2764: }
2765:
2766: int o = fduCalcOffset ();
2767: if (o < 0) {
2768: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | ((fduPHN & 1) << 2 | abuNumber) << 24);
2769: return;
2770: }
2771: fdcReadHandle = null;
2772: fdcWriteHandle = fduImage;
2773: fdcIndex = fdcStart = o;
2774: fdcLimit = o + (128 << fduPNN);
2775: HD63450.dmaFallPCL (0);
2776: }
2777:
2778:
2779: public void fduWriteDataEPhaseEnd () {
2780: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2781: System.out.printf ("%08x fduWriteDataEPhaseEnd%d()\n", XEiJ.regPC0, abuNumber);
2782: }
2783: if (fduPRN == fduEOT) {
2784: HD63450.dmaRisePCL (0);
2785: fduEPhaseEnd (FDC_ST0_NT | ((fduPHN & 1) << 2 | abuNumber) << 24);
2786: return;
2787: }
2788:
2789: if (fduMedia == FDMedia.FDM_2HS && fduPCN == 0 && fduPHN == 0 && fduPRN == 1) {
2790: fduPRN = 11;
2791: } else {
2792: fduPRN++;
2793: }
2794: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2795: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
2796: }
2797: int o = fduCalcOffset ();
2798: if (o < 0) {
2799: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | (fduPHN << 2 | abuNumber << 24));
2800: return;
2801: }
2802: fdcIndex = fdcStart = o;
2803: fdcLimit = o + (128 << fduPNN);
2804: }
2805:
2806:
2807:
2808:
2809:
2810:
2811:
2812:
2813:
2814:
2815:
2816:
2817:
2818:
2819:
2820:
2821:
2822:
2823:
2824:
2825:
2826:
2827:
2828:
2829:
2830:
2831:
2832:
2833:
2834:
2835:
2836:
2837:
2838:
2839:
2840:
2841:
2842:
2843:
2844:
2845:
2846:
2847:
2848:
2849:
2850:
2851:
2852:
2853: public void fduCommandReadData () {
2854:
2855: int ncn = fdcCommandBuffer[2] & 255;
2856: int phn = fdcCommandBuffer[3] & 255;
2857: int prn = fdcCommandBuffer[4] & 255;
2858: int pnn = fdcCommandBuffer[5] & 255;
2859: int eot = fdcCommandBuffer[6] & 255;
2860: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2861: System.out.printf ("%08x fduCommandReadData%d(NCN=%d H=%d R=%d N=%d EOT=%d)\n",
2862: XEiJ.regPC0, abuNumber, ncn, phn, prn, pnn, eot);
2863: }
2864: fduCommandNumber = fdcCommandNumber;
2865: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2866: System.out.printf ("\tfduCommandNumber%d=0x%02x\n", abuNumber, fduCommandNumber);
2867: }
2868: if (!fduIsReady ()) {
2869: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_NR | ((fduPHN & 1) << 2 | abuNumber) << 24);
2870: return;
2871: }
2872: fduNCN = ncn;
2873: fduPHN = phn;
2874: fduPRN = prn;
2875: fduPNN = pnn;
2876: fduEOT = eot;
2877: fduSRC = 16 - fdcSRT;
2878: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2879: System.out.printf ("\tfduNCN%d=%d\n", abuNumber, fduNCN);
2880: System.out.printf ("\tfduPHN%d=%d\n", abuNumber, fduPHN);
2881: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
2882: System.out.printf ("\tfduPNN%d=%d\n", abuNumber, fduPNN);
2883: System.out.printf ("\tfduEOT%d=%d\n", abuNumber, fduEOT);
2884: System.out.printf ("\tfduSRC%d=%d\n", abuNumber, fduSRC);
2885: }
2886: fdcStatus = (FDC_MPU_TO_FDC | FDC_CB |
2887: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
2888: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2889: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
2890: }
2891: fdcReadHandle = null;
2892: fdcWriteHandle = null;
2893: TickerQueue.tkqAdd (fduSeekTicker, XEiJ.mpuClockTime + FDU_SEEK_INTERVAL);
2894: }
2895:
2896: public void fduReadDataEPhase () {
2897: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2898: System.out.printf ("%08x fduReadDataEPhase%d()\n", XEiJ.regPC0, abuNumber);
2899: }
2900: if (fduPCN != fduNCN) {
2901: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_NR | ((fduPHN & 1) << 2 | abuNumber) << 24);
2902: return;
2903: }
2904:
2905: fdcStatus = (FDC_RQM | FDC_FDC_TO_MPU | FDC_CB |
2906: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
2907: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2908: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
2909: }
2910:
2911: int o = fduCalcOffset ();
2912: if (o < 0) {
2913: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | ((fduPHN & 1) << 2 | abuNumber) << 24);
2914: return;
2915: }
2916: fdcReadHandle = fduImage;
2917: fdcWriteHandle = null;
2918: fdcIndex = fdcStart = o;
2919: fdcLimit = o + (128 << fduPNN);
2920: HD63450.dmaFallPCL (0);
2921: }
2922:
2923:
2924: public void fduReadDataEPhaseEnd () {
2925: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2926: System.out.printf ("%08x fduReadDataEPhaseEnd%d()\n", XEiJ.regPC0, abuNumber);
2927: }
2928: if (fduPRN == fduEOT) {
2929: HD63450.dmaRisePCL (0);
2930: fduEPhaseEnd (FDC_ST0_NT | ((fduPHN & 1) << 2 | abuNumber) << 24);
2931: return;
2932: }
2933:
2934: if (fduMedia == FDMedia.FDM_2HS && fduPCN == 0 && fduPHN == 0 && fduPRN == 1) {
2935: fduPRN = 11;
2936: } else {
2937: fduPRN++;
2938: }
2939: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2940: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
2941: }
2942: int o = fduCalcOffset ();
2943: if (o < 0) {
2944: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | ((fduPHN & 1) << 2 | abuNumber) << 24);
2945: return;
2946: }
2947: fdcIndex = fdcStart = o;
2948: fdcLimit = o + (128 << fduPNN);
2949: }
2950:
2951:
2952:
2953:
2954:
2955:
2956:
2957:
2958:
2959:
2960:
2961: public void fduCommandRecalibrate () {
2962: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2963: System.out.printf ("%08x fduCommandRecalibrate%d()\n", XEiJ.regPC0, abuNumber);
2964: }
2965: fduCommandNumber = fdcCommandNumber;
2966: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2967: System.out.printf ("\tfduCommandNumber%d=0x%02x\n", abuNumber, fduCommandNumber);
2968: }
2969: fdcStatus |= 1 << abuNumber;
2970: fduNCN = 0;
2971: fduSRC = 16 - fdcSRT;
2972: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2973: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
2974: System.out.printf ("\tfduNCN%d=%d\n", abuNumber, fduNCN);
2975: System.out.printf ("\tfduSRC%d=%d\n", abuNumber, fduSRC);
2976: }
2977: if (fdcEnforcedReady && !abuConnected) {
2978: fduSeekResultStatus = FDC_ST0_AT | FDC_ST0_SE | FDC_ST0_EC;
2979: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2980: System.out.printf ("\tfduSeekResultStatus=%s\n", fdcResultStatusToString (fduSeekResultStatus));
2981: }
2982: fdcCPhase ();
2983: fduSeekEnd ();
2984: } else if (!fduIsReady ()) {
2985: fduSeekResultStatus = FDC_ST0_AT | FDC_ST0_SE | FDC_ST0_NR;
2986: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2987: System.out.printf ("\tfduSeekResultStatus=%s\n", fdcResultStatusToString (fduSeekResultStatus));
2988: }
2989: fdcCPhase ();
2990: fduSeekEnd ();
2991: } else {
2992: fduSeekResultStatus = FDC_ST0_NT | FDC_ST0_SE;
2993: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
2994: System.out.printf ("\tfduSeekResultStatus=%s\n", fdcResultStatusToString (fduSeekResultStatus));
2995: }
2996: TickerQueue.tkqAdd (fduSeekTicker, XEiJ.mpuClockTime + FDU_SEEK_INTERVAL);
2997: fdcCPhase ();
2998: }
2999: }
3000:
3001:
3002:
3003:
3004:
3005:
3006:
3007:
3008:
3009:
3010:
3011:
3012:
3013:
3014:
3015:
3016:
3017:
3018:
3019:
3020:
3021:
3022:
3023:
3024:
3025:
3026:
3027:
3028:
3029:
3030:
3031:
3032:
3033:
3034:
3035:
3036:
3037:
3038:
3039:
3040:
3041:
3042:
3043:
3044:
3045:
3046: public void fduCommandWriteDeletedData () {
3047:
3048: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3049: System.out.printf ("%08x WRITE DELETED DATA is not implemented\n", XEiJ.regPC0);
3050: }
3051: fdcCommandInvalid ();
3052: }
3053:
3054:
3055:
3056:
3057:
3058:
3059:
3060:
3061:
3062:
3063:
3064:
3065:
3066:
3067:
3068:
3069:
3070:
3071:
3072:
3073:
3074:
3075:
3076:
3077: public void fduCommandReadId () {
3078: int hd = fdcCommandBuffer[1] >> 2 & 1;
3079: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3080: System.out.printf ("%08x fduCommandReadId%d(HD=%d)\n", XEiJ.regPC0, abuNumber, hd);
3081: }
3082: fduCommandNumber = fdcCommandNumber;
3083: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3084: System.out.printf ("\tfduCommandNumber%d=0x%02x\n", abuNumber, fduCommandNumber);
3085: }
3086: fduPHN = hd;
3087: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3088: System.out.printf ("\tfduPHN%d=%d\n", abuNumber, fduPHN);
3089: }
3090: if (!fduIsReady ()) {
3091: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_NR | ((fduPHN & 1) << 2 | abuNumber) << 24);
3092: return;
3093: }
3094:
3095:
3096: if (fduMedia == FDMedia.FDM_2HS) {
3097: if (fduPCN == 0 && fduPHN == 0) {
3098: if (fduPRN == 1) {
3099: fduPRN = 11;
3100: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3101: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3102: }
3103: } else if (fduPRN == 18) {
3104: fduPRN = 1;
3105: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3106: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3107: }
3108: } else {
3109: fduPRN++;
3110: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3111: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3112: }
3113: }
3114: } else {
3115: if (fduPRN == 18) {
3116: fduPRN = 10;
3117: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3118: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3119: }
3120: } else {
3121: fduPRN++;
3122: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3123: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3124: }
3125: }
3126: }
3127: } else {
3128: if (fduPRN == fduMedia.fdmSectorsPerTrack) {
3129: fduPRN = 1;
3130: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3131: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3132: }
3133: } else {
3134: fduPRN++;
3135: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3136: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3137: }
3138: }
3139: }
3140:
3141: if (fduMedia == FDMedia.FDM_2HDE) {
3142: if (!(fduPCN == 0 && fduPHN == 0 && fduPRN == 1)) {
3143: fduPHN |= 128;
3144: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3145: System.out.printf ("\tfduPHN%d=%d\n", abuNumber, fduPHN);
3146: }
3147: }
3148: }
3149:
3150: fduPNN = fduMedia.fdmSectorScale;
3151: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3152: System.out.printf ("\tfduPNN%d=%d\n", abuNumber, fduPNN);
3153: }
3154: int o = fduCalcOffset ();
3155: if (o < 0) {
3156: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | ((fduPHN & 1) << 2 | abuNumber) << 24);
3157: return;
3158: }
3159: fduEPhaseEnd (FDC_ST0_NT | ((fduPHN & 1) << 2 | abuNumber) << 24);
3160: }
3161:
3162:
3163:
3164:
3165:
3166:
3167:
3168:
3169:
3170:
3171:
3172:
3173:
3174:
3175:
3176:
3177:
3178:
3179:
3180:
3181:
3182:
3183:
3184:
3185:
3186:
3187:
3188:
3189:
3190:
3191:
3192:
3193:
3194:
3195:
3196:
3197:
3198:
3199:
3200:
3201:
3202:
3203:
3204:
3205:
3206:
3207:
3208:
3209: public void fduCommandReadDeletedData () {
3210:
3211: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3212: System.out.printf ("%08x READ DELETED DATA is not implemented\n", XEiJ.regPC0);
3213: }
3214: fdcCommandInvalid ();
3215: }
3216:
3217:
3218:
3219:
3220:
3221:
3222:
3223:
3224:
3225:
3226:
3227:
3228:
3229:
3230:
3231:
3232:
3233:
3234:
3235:
3236:
3237:
3238:
3239:
3240:
3241:
3242:
3243:
3244:
3245:
3246:
3247:
3248:
3249:
3250: public void fduCommandWriteId () {
3251:
3252: fduCommandNumber = fdcCommandNumber;
3253: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3254: System.out.printf ("\tfduCommandNumber%d=0x%02x\n", abuNumber, fduCommandNumber);
3255: }
3256: if (!fduIsReady ()) {
3257: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3258: System.out.printf ("%08x unit=%d,is not ready\n", XEiJ.regPC0, abuNumber);
3259: }
3260: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_NR | ((fduPHN & 1) << 2 | abuNumber) << 24);
3261: return;
3262: }
3263: if (fduIsWriteProtected ()) {
3264: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3265: System.out.printf ("%08x unit=%d,is read-only\n", XEiJ.regPC0, abuNumber);
3266: }
3267: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_NW | ((fduPHN & 1) << 2 | abuNumber) << 24);
3268: return;
3269: }
3270:
3271: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3272: System.out.printf ("%08x FDC E-Phase\n", XEiJ.regPC0);
3273: }
3274: fdcStatus = (FDC_RQM | FDC_MPU_TO_FDC | FDC_CB |
3275: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
3276: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3277: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
3278: }
3279: fdcReadHandle = null;
3280: fdcWriteHandle = fdcTempBuffer;
3281: fdcIndex = fdcStart = 0;
3282: fdcLimit = (fdcCommandBuffer[3] & 255) << 2;
3283: HD63450.dmaFallPCL (0);
3284: }
3285:
3286:
3287: public void fduWriteIdEPhaseEnd () {
3288: HD63450.dmaRisePCL (0);
3289:
3290: if (fdcTempBuffer[0] == 0 && fdcTempBuffer[1] == 0) {
3291: int prn1 = fdcTempBuffer[2] & 255;
3292: int pnn1 = fdcTempBuffer[3] & 255;
3293: int pcn2 = fdcTempBuffer[4] & 255;
3294: int phn2 = fdcTempBuffer[5] & 255;
3295: int prn2 = fdcTempBuffer[6] & 255;
3296: int pnn2 = fdcTempBuffer[7] & 255;
3297: int sectors = fdcLimit >> 2;
3298: FDMedia media = null;
3299: if (phn2 == 0 && prn1 == 1 && prn2 == 2) {
3300: if (!fduDoubleDensity) {
3301: if (pnn1 == 3 && pnn2 == 3) {
3302: if (sectors == 8) {
3303: media = FDMedia.FDM_2HD;
3304: }
3305: } else if (pnn1 == 2 && pnn2 == 2) {
3306: if (sectors == 15) {
3307: media = FDMedia.FDM_2HC;
3308: } else if (sectors == 18) {
3309: media = FDMedia.FDM_2HQ;
3310: }
3311: }
3312: } else {
3313: if (pnn1 == 2 && pnn2 == 2) {
3314: if (sectors == 8) {
3315: media = FDMedia.FDM_2DD8;
3316: } else if (sectors == 9) {
3317: media = FDMedia.FDM_2DD9;
3318: } else if (sectors == 10) {
3319: media = FDMedia.FDM_2DD10;
3320: }
3321: }
3322: }
3323: } else if (phn2 == 128 && prn1 == 1 && prn2 == 2) {
3324: if (!fduDoubleDensity) {
3325: if (pnn1 == 3 && pnn2 == 3) {
3326: if (sectors == 9) {
3327: media = FDMedia.FDM_2HDE;
3328: }
3329: }
3330: }
3331: } else if (phn2 == 0 && prn1 == 1 && prn2 == 11) {
3332: if (!fduDoubleDensity) {
3333: if (pnn1 == 3 && pnn2 == 3) {
3334: if (sectors == 9) {
3335: media = FDMedia.FDM_2HS;
3336: }
3337: }
3338: }
3339: }
3340: if (media != null) {
3341: fduMedia = media;
3342: } else {
3343: fduMedia = FDMedia.FDM_2HD;
3344: }
3345: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3346: System.out.println ("media = " + fduMedia.fdmName);
3347: System.out.println ("------------------------------------------------------------------------");
3348: fduMedia.fdmPrintInfo ();
3349: System.out.println ("------------------------------------------------------------------------");
3350: }
3351: }
3352: for (int i = 0; i < fdcLimit; i += 4) {
3353: fduPCN = fdcTempBuffer[i ] & 255;
3354: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3355: System.out.printf ("%08x unit=%d,fduPCN=%d\n", XEiJ.regPC0, abuNumber, fduPCN);
3356: }
3357: fduPHN = fdcTempBuffer[i + 1] & 255;
3358: fduPRN = fdcTempBuffer[i + 2] & 255;
3359: fduPNN = fdcTempBuffer[i + 3] & 255;
3360: int o = fduCalcOffset ();
3361: if (o < 0) {
3362:
3363: if (0 < fduPCN) {
3364: fduPCN--;
3365: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3366: System.out.printf ("%08x unit=%d,fduPCN=%d\n", XEiJ.regPC0, abuNumber, fduPCN);
3367: }
3368: o = fduCalcOffset ();
3369: fduPCN++;
3370: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3371: System.out.printf ("%08x unit=%d,fduPCN=%d\n", XEiJ.regPC0, abuNumber, fduPCN);
3372: }
3373: }
3374: if (o < 0) {
3375: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_EC | ((fduPHN & 1) << 2 | abuNumber) << 24);
3376: return;
3377: }
3378: } else {
3379: Arrays.fill (fduImage, o, o + (128 << fduPNN), fdcCommandBuffer[5]);
3380: fduWritten = true;
3381: }
3382: }
3383: fduEPhaseEnd (FDC_ST0_NT | ((fduPHN & 1) << 2 | abuNumber) << 24);
3384: }
3385:
3386:
3387:
3388:
3389:
3390:
3391:
3392:
3393:
3394:
3395:
3396:
3397:
3398:
3399: public void fduCommandSeek () {
3400: int ncn = fdcCommandBuffer[2] & 255;
3401: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3402: System.out.printf ("%08x fduCommandSeek%d(NCN=%d)\n", XEiJ.regPC0, abuNumber, ncn);
3403: }
3404: fduCommandNumber = fdcCommandNumber;
3405: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3406: System.out.printf ("\tfduCommandNumber%d=0x%02x\n", abuNumber, fduCommandNumber);
3407: }
3408: fdcStatus |= 1 << abuNumber;
3409: fduNCN = ncn;
3410: fduSRC = 16 - fdcSRT;
3411: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3412: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
3413: System.out.printf ("\tfduNCN%d=%d\n", abuNumber, fduNCN);
3414: System.out.printf ("\tfduSRC%d=%d\n", abuNumber, fduSRC);
3415: }
3416: if (fdcEnforcedReady && !abuConnected) {
3417: fduSeekResultStatus = FDC_ST0_AT | FDC_ST0_SE | FDC_ST0_EC;
3418: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3419: System.out.printf ("\tfduSeekResultStatus=%s\n", fdcResultStatusToString (fduSeekResultStatus));
3420: }
3421: fdcCPhase ();
3422: fduSeekEnd ();
3423: } else if (!fduIsReady ()) {
3424: fduSeekResultStatus = FDC_ST0_AT | FDC_ST0_SE | FDC_ST0_NR;
3425: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3426: System.out.printf ("\tfduSeekResultStatus=%s\n", fdcResultStatusToString (fduSeekResultStatus));
3427: }
3428: fdcCPhase ();
3429: fduSeekEnd ();
3430: } else {
3431: fduSeekResultStatus = FDC_ST0_NT | FDC_ST0_SE;
3432: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3433: System.out.printf ("\tfduSeekResultStatus=%s\n", fdcResultStatusToString (fduSeekResultStatus));
3434: }
3435: TickerQueue.tkqAdd (fduSeekTicker, XEiJ.mpuClockTime + FDU_SEEK_INTERVAL);
3436: fdcCPhase ();
3437: }
3438: }
3439:
3440:
3441:
3442:
3443:
3444:
3445:
3446:
3447:
3448:
3449:
3450:
3451:
3452:
3453:
3454:
3455:
3456:
3457:
3458:
3459:
3460:
3461:
3462:
3463:
3464:
3465:
3466:
3467:
3468:
3469:
3470:
3471:
3472:
3473:
3474:
3475:
3476:
3477:
3478:
3479:
3480:
3481:
3482:
3483:
3484:
3485:
3486:
3487:
3488:
3489:
3490:
3491:
3492:
3493:
3494:
3495:
3496:
3497:
3498:
3499: public void fduCommandScan () {
3500:
3501: int ncn = fdcCommandBuffer[2] & 255;
3502: int phn = fdcCommandBuffer[3] & 255;
3503: int prn = fdcCommandBuffer[4] & 255;
3504: int pnn = fdcCommandBuffer[5] & 255;
3505: int eot = fdcCommandBuffer[6] & 255;
3506: int stp = fdcCommandBuffer[8] & 3;
3507: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3508: System.out.printf ("%08x fduCommandScan%d(NCN=%d H=%d R=%d N=%d EOT=%d STP=%d)\n",
3509: XEiJ.regPC0, abuNumber, ncn, phn, prn, pnn, eot, stp);
3510: }
3511: fduCommandNumber = fdcCommandNumber;
3512: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3513: System.out.printf ("\tfduCommandNumber%d=0x%02x\n", abuNumber, fduCommandNumber);
3514: }
3515: if (!fduIsReady ()) {
3516: fduEPhaseEnd (FDC_ST0_AT | FDC_ST0_NR | ((fduPHN & 1) << 2 | abuNumber) << 24);
3517: return;
3518: }
3519: fduNCN = ncn;
3520: fduPHN = phn;
3521: fduPRN = prn;
3522: fduPNN = pnn;
3523: fduEOT = eot;
3524: fduSTP = stp;
3525: fduSRC = 16 - fdcSRT;
3526: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3527: System.out.printf ("\tfduNCN%d=%d\n", abuNumber, fduNCN);
3528: System.out.printf ("\tfduPHN%d=%d\n", abuNumber, fduPHN);
3529: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3530: System.out.printf ("\tfduPNN%d=%d\n", abuNumber, fduPNN);
3531: System.out.printf ("\tfduEOT%d=%d\n", abuNumber, fduEOT);
3532: System.out.printf ("\tfduSTP%d=%d\n", abuNumber, fduSTP);
3533: System.out.printf ("\tfduSRC%d=%d\n", abuNumber, fduSRC);
3534: }
3535: fdcStatus = (FDC_MPU_TO_FDC | FDC_CB |
3536: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
3537: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3538: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
3539: }
3540: fdcReadHandle = null;
3541: fdcWriteHandle = null;
3542: TickerQueue.tkqAdd (fduSeekTicker, XEiJ.mpuClockTime + FDU_SEEK_INTERVAL);
3543: }
3544:
3545: public void fduScanEPhase () {
3546: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3547: System.out.printf ("%08x fduScanEPhase%d()\n", XEiJ.regPC0, abuNumber);
3548: }
3549:
3550: fdcStatus = (FDC_RQM | FDC_MPU_TO_FDC | FDC_CB |
3551: (fdcStatus & (FDC_D3B | FDC_D2B | FDC_D1B | FDC_D0B)));
3552: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3553: System.out.printf ("\tfdcStatus=%s\n", fdcStatusToString (fdcStatus));
3554: }
3555:
3556: fdcReadHandle = null;
3557: fdcWriteHandle = fdcTempBuffer;
3558: fdcIndex = fdcStart = 0;
3559: fdcLimit = 128 << fduPNN;
3560: HD63450.dmaFallPCL (0);
3561: }
3562:
3563:
3564: public void fduScanEqualEPhaseEnd () {
3565: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3566: System.out.printf ("%08x fduScanEqualEPhaseEnd%d()\n", XEiJ.regPC0, abuNumber);
3567: }
3568: int o = fduCalcOffset ();
3569: if (o < 0) {
3570: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | ((fduPHN & 1) << 2 | abuNumber) << 24);
3571: return;
3572: }
3573:
3574: scan:
3575: {
3576: int l = 128 << fduPNN;
3577: for (int i = 0; i < l; i++) {
3578: int d = fdcTempBuffer[i] & 255;
3579: if (d != 0xff && (fduImage[o + i] & 255) != d) {
3580: break scan;
3581: }
3582: }
3583:
3584: HD63450.dmaRisePCL (0);
3585: fduEPhaseEnd (FDC_ST0_NT | FDC_ST2_SH | ((fduPHN & 1) << 2 | abuNumber) << 24);
3586: return;
3587: }
3588: if (fduPRN == fduEOT) {
3589: HD63450.dmaRisePCL (0);
3590: fduEPhaseEnd (FDC_ST0_NT | FDC_ST2_SN | ((fduPHN & 1) << 2 | abuNumber) << 24);
3591: return;
3592: }
3593:
3594: fduPRN += fduSTP;
3595: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3596: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3597: }
3598: fdcIndex = fdcStart = 0;
3599:
3600: }
3601:
3602:
3603: public void fduScanLowOrEqualEPhaseEnd () {
3604: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3605: System.out.printf ("%08x fduScanLowOrEqualEPhaseEnd%d()\n", XEiJ.regPC0, abuNumber);
3606: }
3607: int o = fduCalcOffset ();
3608: if (o < 0) {
3609: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | ((fduPHN & 1) << 2 | abuNumber) << 24);
3610: return;
3611: }
3612: scan:
3613: {
3614: int l = 128 << fduPNN;
3615: for (int i = 0; i < l; i++) {
3616: int d = fdcTempBuffer[i] & 255;
3617: if (d != 0xff && (fduImage[o + i] & 255) > d) {
3618: break scan;
3619: }
3620: }
3621:
3622: HD63450.dmaRisePCL (0);
3623: fduEPhaseEnd (FDC_ST0_NT | ((fduPHN & 1) << 2 | abuNumber) << 24);
3624: return;
3625: }
3626: if (fduPRN == fduEOT) {
3627: HD63450.dmaRisePCL (0);
3628: fduEPhaseEnd (FDC_ST0_NT | FDC_ST2_SN | ((fduPHN & 1) << 2 | abuNumber) << 24);
3629: return;
3630: }
3631:
3632: fduPRN += fduSTP;
3633: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3634: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3635: }
3636: fdcIndex = fdcStart = 0;
3637: fdcLimit = 128 << fduPNN;
3638: }
3639:
3640:
3641: public void fduScanHighOrEqualEPhaseEnd () {
3642: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3643: System.out.printf ("%08x fduScanHighOrEqualEPhaseEnd%d()\n", XEiJ.regPC0, abuNumber);
3644: }
3645: int o = fduCalcOffset ();
3646: if (o < 0) {
3647: fduEPhaseEnd (FDC_ST0_AT | FDC_ST1_MA | ((fduPHN & 1) << 2 | abuNumber) << 24);
3648: return;
3649: }
3650: scan:
3651: {
3652: int l = 128 << fduPNN;
3653: for (int i = 0; i < l; i++) {
3654: int d = fdcTempBuffer[i] & 255;
3655: if (d != 0xff && (fduImage[o + i] & 255) < d) {
3656: break scan;
3657: }
3658: }
3659:
3660: HD63450.dmaRisePCL (0);
3661: fduEPhaseEnd (FDC_ST0_NT | ((fduPHN & 1) << 2 | abuNumber) << 24);
3662: return;
3663: }
3664: if (fduPRN == fduEOT) {
3665: HD63450.dmaRisePCL (0);
3666: fduEPhaseEnd (FDC_ST0_NT | FDC_ST2_SN | ((fduPHN & 1) << 2 | abuNumber) << 24);
3667: return;
3668: }
3669:
3670: fduPRN += fduSTP;
3671: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3672: System.out.printf ("\tfduPRN%d=%d\n", abuNumber, fduPRN);
3673: }
3674: fdcIndex = fdcStart = 0;
3675: fdcLimit = 128 << fduPNN;
3676: }
3677:
3678:
3679:
3680: public int fduCalcOffset () {
3681: int o = (fduMedia == null ? -1 :
3682: fduDoubleDensity == fduMedia.fdmDoubleDensity &&
3683: fduPNN == fduMedia.fdmSectorScale &&
3684: fduPCN < fduMedia.fdmCylindersPerDisk &&
3685: (fduMedia == FDMedia.FDM_2HDE ?
3686: fduPHN == (fduPCN == 0 && fduPRN == 1 ? 0 : 128) || fduPHN == 129 :
3687: fduPHN < fduMedia.fdmTracksPerCylinder) &&
3688: (fduMedia == FDMedia.FDM_2HS ?
3689: fduPCN == 0 && fduPHN == 0 ? fduPRN == 1 || (11 <= fduPRN && fduPRN <= 18) : 10 <= fduPRN && fduPRN <= 18 :
3690: 1 <= fduPRN && fduPRN <= fduMedia.fdmSectorsPerTrack) ?
3691: fduMedia.fdmBytesPerSector * (
3692: (fduPRN <= fduMedia.fdmSectorsPerTrack ? fduPRN : fduPRN - fduMedia.fdmSectorsPerTrack) - 1 +
3693: fduMedia.fdmSectorsPerTrack * (
3694: ((fduPHN & 1) + fduMedia.fdmTracksPerCylinder * fduPCN))) :
3695: -1);
3696: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3697: System.out.printf ("\tfduCalcOffset(C=%d H=%d R=%d N=%d)=%d\n", fduPCN, fduPHN, fduPRN, fduPNN, o);
3698: }
3699: return o;
3700: }
3701:
3702:
3703:
3704: public void fduEPhaseEnd (int status) {
3705: if (FDC_DEBUG_TRACE && fdcDebugLogOn) {
3706: System.out.printf ("%08x fduEPhaseEnd%d(%s)\n", XEiJ.regPC0, abuNumber, fdcResultStatusToString (status));
3707: }
3708:
3709:
3710: fdcResultBuffer[0] = (byte) (status >> 24);
3711: fdcResultBuffer[1] = (byte) (status >> 16);
3712: fdcResultBuffer[2] = (byte) (status >> 8);
3713: fdcResultBuffer[3] = (byte) fduPCN;
3714: fdcResultBuffer[4] = (byte) fduPHN;
3715: fdcResultBuffer[5] = (byte) fduPRN;
3716: fdcResultBuffer[6] = (byte) fduPNN;
3717:
3718: fdcRPhase (7);
3719:
3720: IOInterrupt.ioiFdcRise ();
3721: }
3722:
3723:
3724: }
3725:
3726:
3727:
3728: }
3729:
3730:
3731: