![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to floppy_ipf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to floppy_ipf.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 ! root 1: /* ! 2: Hatari - floppy_ipf.c ! 3: ! 4: This file is distributed under the GNU General Public License, version 2 or at ! 5: your option any later version. Read the file gpl.txt for details. ! 6: ! 7: IPF disk image support. ! 8: ! 9: IPF files are handled using the capsimage library, which emulates the FDC ! 10: at low level and allows to read complex protections. ! 11: ! 12: RAW files made with KryoFlux board or CT RAW dumped with an Amiga are also handled ! 13: by the capsimage library. ! 14: */ ! 15: const char floppy_ipf_fileid[] = "Hatari floppy_ipf.c : " __DATE__ " " __TIME__; ! 16: ! 17: #include "main.h" ! 18: #include "file.h" ! 19: #include "floppy.h" ! 20: #include "floppy_ipf.h" ! 21: #include "fdc.h" ! 22: #include "log.h" ! 23: #include "memorySnapShot.h" ! 24: #include "screen.h" ! 25: #include "video.h" ! 26: #include "cycles.h" ! 27: ! 28: #ifdef HAVE_CAPSIMAGE ! 29: #if CAPSIMAGE_VERSION == 5 ! 30: #include <caps5/CapsLibAll.h> ! 31: #else ! 32: #include <caps/fdc.h> ! 33: #define CAPS_LIB_RELEASE 4 ! 34: #define CAPS_LIB_REVISION 2 ! 35: #endif ! 36: /* Macro to check release and revision */ ! 37: #define CAPS_LIB_REL_REV ( CAPS_LIB_RELEASE * 100 + CAPS_LIB_REVISION ) ! 38: #endif ! 39: ! 40: ! 41: typedef struct ! 42: { ! 43: #ifdef HAVE_CAPSIMAGE ! 44: Uint32 CapsLibRelease; ! 45: Uint32 CapsLibRevision; ! 46: ! 47: struct CapsFdc Fdc; /* Fdc state */ ! 48: struct CapsDrive Drive[ MAX_FLOPPYDRIVES ]; /* Physical drives */ ! 49: CapsLong CapsImage[ MAX_FLOPPYDRIVES ]; /* For the IPF disk images */ ! 50: ! 51: int Rev_Track[ MAX_FLOPPYDRIVES ]; /* Needed to handle CAPSSetRevolution for type II/III commands */ ! 52: int Rev_Side[ MAX_FLOPPYDRIVES ]; ! 53: ! 54: bool DriveEnabled[ MAX_FLOPPYDRIVES ];/* Is drive ON or OFF */ ! 55: bool DoubleSided[ MAX_FLOPPYDRIVES ];/* Is drive double sided or not */ ! 56: ! 57: Sint64 FdcClock; /* Current value of CyclesGlobalClockCounter */ ! 58: #endif ! 59: } IPF_STRUCT; ! 60: ! 61: ! 62: static IPF_STRUCT IPF_State; /* All variables related to the IPF support */ ! 63: ! 64: ! 65: #ifdef HAVE_CAPSIMAGE ! 66: static void IPF_CallBack_Trk ( struct CapsFdc *pc , CapsULong State ); ! 67: static void IPF_CallBack_Irq ( struct CapsFdc *pc , CapsULong State ); ! 68: static void IPF_CallBack_Drq ( struct CapsFdc *pc , CapsULong State ); ! 69: static void IPF_Drive_Update_Enable_Side ( void ); ! 70: #endif ! 71: ! 72: ! 73: ! 74: ! 75: /*-----------------------------------------------------------------------*/ ! 76: /** ! 77: * Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type) ! 78: * We must take care of whether Hatari was compiled with IPF support of not ! 79: * when saving/restoring snapshots to avoid incompatibilies. ! 80: */ ! 81: void IPF_MemorySnapShot_Capture(bool bSave) ! 82: { ! 83: int StructSize; ! 84: int Drive; ! 85: ! 86: if ( bSave ) /* Saving snapshot */ ! 87: { ! 88: StructSize = sizeof ( IPF_State ); /* 0 if HAVE_CAPSIMAGE is not defined */ ! 89: MemorySnapShot_Store(&StructSize, sizeof(StructSize)); ! 90: fprintf ( stderr , "ipf save %d\n" , StructSize ); ! 91: if ( StructSize > 0 ) ! 92: MemorySnapShot_Store(&IPF_State, sizeof(IPF_State)); ! 93: } ! 94: ! 95: else /* Restoring snapshot */ ! 96: { ! 97: MemorySnapShot_Store(&StructSize, sizeof(StructSize)); ! 98: fprintf ( stderr , "ipf load %d\n" , StructSize ); ! 99: if ( ( StructSize == 0 ) && ( sizeof ( IPF_State ) > 0 ) ) ! 100: { ! 101: Log_AlertDlg(LOG_ERROR, "This memory snapshot doesn't include IPF data but this version of Hatari was built with IPF support"); ! 102: return; /* Continue restoring the rest of the memory snapshot */ ! 103: } ! 104: else if ( ( StructSize > 0 ) && ( sizeof ( IPF_State ) == 0 ) ) ! 105: { ! 106: Log_AlertDlg(LOG_ERROR, "This memory snapshot includes IPF data but this version of Hatari was not built with IPF support"); ! 107: MemorySnapShot_Skip( StructSize ); /* Ignore the IPF data */ ! 108: return; /* Continue restoring the rest of the memory snapshot */ ! 109: } ! 110: else if ( ( StructSize > 0 ) && ( StructSize != sizeof ( IPF_State ) ) ) ! 111: { ! 112: Log_AlertDlg(LOG_ERROR, "This memory snapshot includes IPF data different from the ones handled in this version of Hatari"); ! 113: MemorySnapShot_Skip( StructSize ); /* Ignore the IPF data */ ! 114: return; /* Continue restoring the rest of the memory snapshot */ ! 115: } ! 116: ! 117: if ( StructSize > 0 ) ! 118: { ! 119: MemorySnapShot_Store(&IPF_State, sizeof(IPF_State)); ! 120: ! 121: #ifdef HAVE_CAPSIMAGE ! 122: /* For IPF structures, we need to update some pointers in Fdc/Drive/CapsImage */ ! 123: /* drive : PUBYTE trackbuf, PUDWORD timebuf */ ! 124: /* fdc : PCAPSDRIVE driveprc, PCAPSDRIVE drive, CAPSFDCHOOK callback functions */ ! 125: CAPSFdcInvalidateTrack ( &IPF_State.Fdc , 0 ); /* Invalidate buffered track data for drive 0 */ ! 126: CAPSFdcInvalidateTrack ( &IPF_State.Fdc , 1 ); /* Invalidate buffered track data for drive 1 */ ! 127: ! 128: IPF_State.Fdc.drive = IPF_State.Drive; /* Connect drives array to the FDC */ ! 129: if ( IPF_State.Fdc.driveprc != NULL ) /* Recompute active drive's pointer */ ! 130: IPF_State.Fdc.driveprc = IPF_State.Fdc.drive + IPF_State.Fdc.driveact; ! 131: ! 132: /* Set callback functions */ ! 133: IPF_State.Fdc.cbirq = IPF_CallBack_Irq; ! 134: IPF_State.Fdc.cbdrq = IPF_CallBack_Drq; ! 135: IPF_State.Fdc.cbtrk = IPF_CallBack_Trk; ! 136: #endif ! 137: ! 138: /* Call IPF_Insert to recompute IPF_State.CapsImage[ Drive ] */ ! 139: for ( Drive=0 ; Drive < MAX_FLOPPYDRIVES ; Drive++ ) ! 140: if ( EmulationDrives[Drive].ImageType == FLOPPY_IMAGE_TYPE_IPF ) ! 141: if ( IPF_Insert ( Drive , EmulationDrives[Drive].pBuffer , EmulationDrives[Drive].nImageBytes ) == false ) ! 142: { ! 143: Log_AlertDlg(LOG_ERROR, "Error restoring IPF image %s in drive %d" , ! 144: EmulationDrives[Drive].sFileName , Drive ); ! 145: return; ! 146: } ! 147: ! 148: fprintf ( stderr , "ipf load ok\n" ); ! 149: } ! 150: } ! 151: } ! 152: ! 153: ! 154: ! 155: ! 156: /*-----------------------------------------------------------------------*/ ! 157: /** ! 158: * Does filename end with a .IPF or .RAW or .CTR extension ? If so, return true. ! 159: * .RAW and .CTR support requires caps lib >= 5.1 ! 160: */ ! 161: bool IPF_FileNameIsIPF(const char *pszFileName, bool bAllowGZ) ! 162: { ! 163: return ( File_DoesFileExtensionMatch(pszFileName,".ipf" ) ! 164: || ( bAllowGZ && File_DoesFileExtensionMatch(pszFileName,".ipf.gz") ) ! 165: #if CAPS_LIB_REL_REV >= 501 ! 166: || File_DoesFileExtensionMatch(pszFileName,".raw" ) ! 167: || ( bAllowGZ && File_DoesFileExtensionMatch(pszFileName,".raw.gz") ) ! 168: || File_DoesFileExtensionMatch(pszFileName,".ctr" ) ! 169: || ( bAllowGZ && File_DoesFileExtensionMatch(pszFileName,".ctr.gz") ) ! 170: #endif ! 171: ); ! 172: } ! 173: ! 174: ! 175: /*-----------------------------------------------------------------------*/ ! 176: /** ! 177: * Load .IPF file into memory, set number of bytes loaded and return a pointer ! 178: * to the buffer. ! 179: */ ! 180: Uint8 *IPF_ReadDisk(int Drive, const char *pszFileName, long *pImageSize, int *pImageType) ! 181: { ! 182: #ifndef HAVE_CAPSIMAGE ! 183: Log_AlertDlg(LOG_ERROR, "This version of Hatari was not built with IPF support, this disk image can't be handled."); ! 184: return NULL; ! 185: ! 186: #else ! 187: Uint8 *pIPFFile; ! 188: ! 189: *pImageSize = 0; ! 190: ! 191: /* Just load directly a buffer, and set ImageSize accordingly */ ! 192: pIPFFile = File_Read(pszFileName, pImageSize, NULL); ! 193: if (!pIPFFile) ! 194: { ! 195: *pImageSize = 0; ! 196: return NULL; ! 197: } ! 198: ! 199: *pImageType = FLOPPY_IMAGE_TYPE_IPF; ! 200: return pIPFFile; ! 201: #endif ! 202: } ! 203: ! 204: ! 205: /*-----------------------------------------------------------------------*/ ! 206: /** ! 207: * Save .IPF file from memory buffer. Returns true is all OK. ! 208: */ ! 209: bool IPF_WriteDisk(int Drive, const char *pszFileName, Uint8 *pBuffer, int ImageSize) ! 210: { ! 211: /* saving is not supported for IPF files */ ! 212: return false; ! 213: } ! 214: ! 215: ! 216: ! 217: ! 218: /* ! 219: * Init the FDC and the drives used to handle IPF images ! 220: */ ! 221: bool IPF_Init ( void ) ! 222: { ! 223: #ifndef HAVE_CAPSIMAGE ! 224: return true; ! 225: ! 226: #else ! 227: int i; ! 228: struct CapsVersionInfo caps_vi; ! 229: ! 230: fprintf ( stderr , "IPF : IPF_Init\n" ); ! 231: ! 232: if ( CAPSInit() != imgeOk ) ! 233: { ! 234: fprintf ( stderr , "IPF : Could not initialize the capsimage library\n" ); ! 235: return false; ! 236: } ! 237: ! 238: if ( CAPSGetVersionInfo ( &caps_vi , 0 ) != imgeOk ) ! 239: { ! 240: fprintf ( stderr , "IPF : CAPSVersionInfo failed\n" ); ! 241: return false; ! 242: } ! 243: fprintf ( stderr , "IPF : capsimage library version release=%d revision=%d\n" , (int)caps_vi.release , (int)caps_vi.revision ); ! 244: IPF_State.CapsLibRelease = caps_vi.release; ! 245: IPF_State.CapsLibRevision = caps_vi.revision; ! 246: ! 247: /* Default values for each physical drive */ ! 248: memset ( IPF_State.Drive , 0 , sizeof ( IPF_State.Drive ) ); ! 249: for ( i=0 ; i < MAX_FLOPPYDRIVES ; i++ ) ! 250: { ! 251: IPF_State.Drive[ i ].type = sizeof ( struct CapsDrive ); ! 252: IPF_State.Drive[ i ].rpm = CAPSDRIVE_35DD_RPM; ! 253: IPF_State.Drive[ i ].maxtrack = CAPSDRIVE_35DD_HST; ! 254: ! 255: IPF_State.Rev_Track[ i ] = -1; ! 256: IPF_State.Rev_Side[ i ] = -1; ! 257: ! 258: IPF_State.DriveEnabled[ i ] = true; ! 259: IPF_State.DoubleSided[ i ] = true; ! 260: } ! 261: ! 262: /* Init FDC with 2 physical drives */ ! 263: memset ( &IPF_State.Fdc , 0 , sizeof ( IPF_State.Fdc ) ); ! 264: IPF_State.Fdc.type = sizeof( struct CapsFdc ); ! 265: IPF_State.Fdc.model = cfdcmWD1772; ! 266: IPF_State.Fdc.drive = IPF_State.Drive; ! 267: IPF_State.Fdc.drivecnt = MAX_FLOPPYDRIVES; ! 268: ! 269: if ( CAPSFdcInit ( &IPF_State.Fdc ) != imgeOk) ! 270: { ! 271: fprintf ( stderr , "IPF : CAPSFdcInit failed\n" ); ! 272: return false; ! 273: } ! 274: ! 275: /* 2 drives by default */ ! 276: IPF_State.Fdc.drivemax = MAX_FLOPPYDRIVES; ! 277: /* Update drives' state in case we have some drives ON or OFF in config or parameters */ ! 278: IPF_Drive_Update_Enable_Side (); ! 279: ! 280: /* FDC clock */ ! 281: IPF_State.Fdc.clockfrq = 8000000; ! 282: ! 283: /* Set callback functions */ ! 284: IPF_State.Fdc.cbirq = IPF_CallBack_Irq; ! 285: IPF_State.Fdc.cbdrq = IPF_CallBack_Drq; ! 286: IPF_State.Fdc.cbtrk = IPF_CallBack_Trk; ! 287: ! 288: CAPSFdcReset ( &IPF_State.Fdc ); ! 289: ! 290: return true; ! 291: #endif ! 292: } ! 293: ! 294: ! 295: ! 296: ! 297: /* ! 298: * Exit ! 299: */ ! 300: void IPF_Exit ( void ) ! 301: { ! 302: #ifndef HAVE_CAPSIMAGE ! 303: #else ! 304: CAPSExit(); ! 305: #endif ! 306: } ! 307: ! 308: ! 309: ! 310: ! 311: /* ! 312: * Init the ressources to handle the IPF image inserted into a drive (0=A: 1=B:) ! 313: */ ! 314: bool IPF_Insert ( int Drive , Uint8 *pImageBuffer , long ImageSize ) ! 315: { ! 316: #ifndef HAVE_CAPSIMAGE ! 317: return false; ! 318: ! 319: #else ! 320: CapsLong ImageId; ! 321: CapsLong ImageType; ! 322: ! 323: ImageId = CAPSAddImage(); ! 324: if ( ImageId < 0 ) ! 325: { ! 326: fprintf ( stderr , "IPF : error CAPSAddImage\n" ); ! 327: return false; ! 328: } ! 329: ! 330: #if CAPS_LIB_REL_REV >= 501 ! 331: ImageType = CAPSGetImageTypeMemory ( pImageBuffer , ImageSize ); ! 332: if ( ImageType == citError ) ! 333: { ! 334: fprintf ( stderr , "IPF : error CAPSGetImageTypeMemory\n" ); ! 335: return false; ! 336: } ! 337: else if ( ImageType == citUnknown ) ! 338: { ! 339: fprintf ( stderr , "IPF : unknown image type\n" ); ! 340: return false; ! 341: } ! 342: ! 343: fprintf ( stderr , "IPF : IPF_Insert drive=%d buf=%p size=%ld imageid=%d type=" , Drive , pImageBuffer , ImageSize , ImageId ); ! 344: switch ( ImageType ) { ! 345: case citIPF: fprintf ( stderr , "IPF\n" ); break; ! 346: case citCTRaw: fprintf ( stderr , "CT RAW\n" ); break; ! 347: case citKFStream: fprintf ( stderr , "KF STREAM\n" ) ; break; ! 348: case citDraft: fprintf ( stderr , "DRAFT\n" ) ; break; ! 349: default : fprintf ( stderr , "NOT SUPPORTED\n" ); ! 350: return false; ! 351: } ! 352: #endif ! 353: ! 354: if ( CAPSLockImageMemory ( ImageId , pImageBuffer , (CapsULong)ImageSize , DI_LOCK_MEMREF ) == imgeOk ) ! 355: { ! 356: struct CapsImageInfo cii; ! 357: int i; ! 358: ! 359: /* Print some debug infos */ ! 360: if ( CAPSGetImageInfo ( &cii , ImageId ) == imgeOk ) ! 361: { ! 362: printf("Type: %d\n", (int)cii.type); ! 363: printf("Release: %d\n", (int)cii.release); ! 364: printf("Revision: %d\n", (int)cii.revision); ! 365: printf("Min Cylinder: %d\n", (int)cii.mincylinder); ! 366: printf("Max Cylinder: %d\n", (int)cii.maxcylinder); ! 367: printf("Min Head: %d\n", (int)cii.minhead); ! 368: printf("Max Head: %d\n", (int)cii.maxhead); ! 369: printf("Creation Date: %04d/%02d/%02d %02d:%02d:%02d.%03d\n", (int)cii.crdt.year, (int)cii.crdt.month, (int)cii.crdt.day, (int)cii.crdt.hour, (int)cii.crdt.min, (int)cii.crdt.sec, (int)cii.crdt.tick); ! 370: printf("Platforms:"); ! 371: for (i = 0; i < CAPS_MAXPLATFORM; i++) ! 372: if (cii.platform[i] != ciipNA) ! 373: printf ( " %s" , CAPSGetPlatformName(cii.platform[i]) ); ! 374: printf("\n"); ! 375: ! 376: /* Some IPF disks are not correctly supported yet : display a warning */ ! 377: if ( (int)cii.release == 3222 ) /* Sundog */ ! 378: Log_AlertDlg ( LOG_INFO , "'Sundog' is not correctly supported yet, it requires write access." ); ! 379: else if ( (int)cii.release == 3058 ) /* Lethal Xcess */ ! 380: Log_AlertDlg ( LOG_INFO , "'Lethal Xcess' is not correctly supported yet, protection will fail" ); ! 381: } ! 382: } ! 383: else ! 384: { ! 385: CAPSRemImage ( ImageId ) ; ! 386: return false; ! 387: } ! 388: ! 389: if ( CAPSLoadImage ( ImageId , DI_LOCK_DENALT | DI_LOCK_DENVAR | DI_LOCK_UPDATEFD ) != imgeOk ) ! 390: { ! 391: fprintf ( stderr , "IPF : error CAPSLoadImage\n" ); ! 392: CAPSUnlockImage ( ImageId ); ! 393: CAPSRemImage ( ImageId ) ; ! 394: return false; ! 395: } ! 396: ! 397: ! 398: IPF_State.CapsImage[ Drive ] = ImageId; ! 399: ! 400: IPF_State.Drive[ Drive ].diskattr |= CAPSDRIVE_DA_IN; /* Disk inserted, keep the value for "write protect" */ ! 401: ! 402: CAPSFdcInvalidateTrack ( &IPF_State.Fdc , Drive ); /* Invalidate previous buffered track data for drive, if any */ ! 403: ! 404: IPF_State.Rev_Track[ Drive ] = -1; /* Invalidate previous track/side to handle revolution's count */ ! 405: IPF_State.Rev_Side[ Drive ] = -1; ! 406: ! 407: return true; ! 408: #endif ! 409: } ! 410: ! 411: ! 412: ! 413: ! 414: /* ! 415: * When ejecting a disk, free the ressources associated with an IPF image ! 416: */ ! 417: bool IPF_Eject ( int Drive ) ! 418: { ! 419: #ifndef HAVE_CAPSIMAGE ! 420: return false; ! 421: ! 422: #else ! 423: fprintf ( stderr , "IPF : IPF_Eject drive=%d imageid=%d\n" , Drive , IPF_State.CapsImage[ Drive ] ); ! 424: ! 425: CAPSFdcInvalidateTrack ( &IPF_State.Fdc , Drive ); /* Invalidate previous buffered track data for drive, if any */ ! 426: ! 427: if ( CAPSUnlockImage ( IPF_State.CapsImage[ Drive ] ) < 0 ) ! 428: { ! 429: fprintf ( stderr , "IPF : error CAPSUnlockImage\n" ); ! 430: return false; ! 431: } ! 432: ! 433: if ( CAPSRemImage ( IPF_State.CapsImage[ Drive ] ) < 0 ) ! 434: { ! 435: fprintf ( stderr , "IPF : error CAPSRemImage\n" ); ! 436: return false; ! 437: } ! 438: ! 439: IPF_State.CapsImage[ Drive ] = -1; ! 440: ! 441: IPF_State.Drive[ Drive ].diskattr &= ~CAPSDRIVE_DA_IN; ! 442: ! 443: return true; ! 444: #endif ! 445: } ! 446: ! 447: ! 448: ! 449: ! 450: /* ! 451: * Reset FDC state when a reset signal was received ! 452: */ ! 453: void IPF_Reset ( void ) ! 454: { ! 455: #ifdef HAVE_CAPSIMAGE ! 456: CAPSFdcReset ( &IPF_State.Fdc ); ! 457: ! 458: IPF_State.FdcClock = CyclesGlobalClockCounter; ! 459: #endif ! 460: } ! 461: ! 462: ! 463: ! 464: ! 465: /* ! 466: * Callback function used when track is changed. ! 467: * We need to update the track data by calling CAPSLockTrack ! 468: */ ! 469: #ifdef HAVE_CAPSIMAGE ! 470: static void IPF_CallBack_Trk ( struct CapsFdc *pc , CapsULong State ) ! 471: { ! 472: int Drive = State; /* State is the drive number in that case */ ! 473: struct CapsDrive *pd = pc->drive+Drive; /* Current drive where the track change occurred */ ! 474: struct CapsTrackInfoT1 cti; ! 475: ! 476: cti.type=1; ! 477: if ( CAPSLockTrack ( &cti , IPF_State.CapsImage[ Drive ] , pd->buftrack , pd->bufside , ! 478: DI_LOCK_DENALT|DI_LOCK_DENVAR|DI_LOCK_UPDATEFD|DI_LOCK_TYPE ) != imgeOk ) ! 479: return; ! 480: ! 481: LOG_TRACE(TRACE_FDC, "fdc ipf callback trk drive=%d buftrack=%d bufside=%d VBL=%d HBL=%d\n" , Drive , ! 482: (int)pd->buftrack , (int)pd->bufside , nVBLs , nHBL ); ! 483: ! 484: pd->ttype = cti.type; ! 485: pd->trackbuf = cti.trackbuf; ! 486: pd->timebuf = cti.timebuf; ! 487: pd->tracklen = cti.tracklen; ! 488: pd->overlap = cti.overlap; ! 489: } ! 490: #endif ! 491: ! 492: ! 493: ! 494: ! 495: /* ! 496: * Callback function used when the FDC change the IRQ signal ! 497: */ ! 498: #ifdef HAVE_CAPSIMAGE ! 499: static void IPF_CallBack_Irq ( struct CapsFdc *pc , CapsULong State ) ! 500: { ! 501: LOG_TRACE(TRACE_FDC, "fdc ipf callback irq state=0x%x VBL=%d HBL=%d\n" , (int)State , nVBLs , nHBL ); ! 502: ! 503: if ( State ) ! 504: FDC_SetIRQ ( FDC_IRQ_SOURCE_OTHER ); /* IRQ bit was set */ ! 505: else ! 506: FDC_ClearIRQ (); /* IRQ bit was reset */ ! 507: } ! 508: #endif ! 509: ! 510: ! 511: ! 512: ! 513: /* ! 514: * Callback function used when the FDC change the DRQ signal ! 515: * -> copy the byte to/from the DMA's FIFO if it's a read or a write to the disk ! 516: */ ! 517: #ifdef HAVE_CAPSIMAGE ! 518: static void IPF_CallBack_Drq ( struct CapsFdc *pc , CapsULong State ) ! 519: { ! 520: Uint8 Byte; ! 521: ! 522: if ( State == 0 ) ! 523: return; /* DRQ bit was reset, do nothing */ ! 524: ! 525: if ( FDC_DMA_GetModeControl_R_WR () != 0 ) /* DMA write mode */ ! 526: { ! 527: Byte = FDC_DMA_FIFO_Pull (); /* Get a byte from the DMA FIFO */ ! 528: CAPSFdcWrite ( &IPF_State.Fdc , 3 , Byte ); /* Write to FDC's reg 3 */ ! 529: ! 530: LOG_TRACE(TRACE_FDC, "fdc ipf callback drq state=0x%x write byte 0x%02x VBL=%d HBL=%d\n" , (int)State , Byte , nVBLs , nHBL ); ! 531: } ! 532: ! 533: else /* DMA read mode */ ! 534: { ! 535: Byte = CAPSFdcRead ( &IPF_State.Fdc , 3 ); /* Read from FDC's reg 3 */ ! 536: FDC_DMA_FIFO_Push ( Byte ); /* Add byte to the DMA FIFO */ ! 537: ! 538: LOG_TRACE(TRACE_FDC, "fdc ipf callback drq state=0x%x read byte 0x%02x VBL=%d HBL=%d\n" , (int)State , Byte , nVBLs , nHBL ); ! 539: } ! 540: } ! 541: #endif ! 542: ! 543: ! 544: ! 545: /* ! 546: * This function is used to enable/disable a drive when ! 547: * using the UI or command line parameters ! 548: * ! 549: * NOTE : for now, IPF only supports changing drive 1, drive 0 ! 550: * is always ON. ! 551: */ ! 552: void IPF_Drive_Set_Enable ( int Drive , bool value ) ! 553: { ! 554: #ifndef HAVE_CAPSIMAGE ! 555: return; ! 556: ! 557: #else ! 558: IPF_State.DriveEnabled[ Drive ] = value; /* Store the new state */ ! 559: ! 560: IPF_Drive_Update_Enable_Side (); /* Update IPF's internal state */ ! 561: #endif ! 562: } ! 563: ! 564: ! 565: /* ! 566: * This function is used to configure a drive as single sided ! 567: * or double sided when using the UI or command line parameters ! 568: */ ! 569: void IPF_Drive_Set_DoubleSided ( int Drive , bool value ) ! 570: { ! 571: #ifndef HAVE_CAPSIMAGE ! 572: return; ! 573: ! 574: #else ! 575: IPF_State.DoubleSided[ Drive ] = value; /* Store the new state */ ! 576: ! 577: IPF_Drive_Update_Enable_Side (); /* Update IPF's internal state */ ! 578: #endif ! 579: } ! 580: ! 581: ! 582: /* ! 583: * Update IPF's internal state depending on which drives are ON or OFF ! 584: * and if the drive is single or double sided (for capslib >= 5.1) ! 585: */ ! 586: #ifdef HAVE_CAPSIMAGE ! 587: static void IPF_Drive_Update_Enable_Side ( void ) ! 588: { ! 589: int i; ! 590: ! 591: if ( IPF_State.DriveEnabled[ 1 ] ) ! 592: IPF_State.Fdc.drivemax = MAX_FLOPPYDRIVES; /* Should be 2 */ ! 593: else ! 594: IPF_State.Fdc.drivemax = MAX_FLOPPYDRIVES - 1; /* Should be 1 */ ! 595: ! 596: #if CAPS_LIB_REL_REV >= 501 ! 597: for ( i=0 ; i < MAX_FLOPPYDRIVES ; i++ ) ! 598: { ! 599: if ( IPF_State.DoubleSided[ i ] ) ! 600: IPF_State.Drive[ i ].diskattr &= ~CAPSDRIVE_DA_SS; /* Double sided */ ! 601: else ! 602: IPF_State.Drive[ i ].diskattr |= CAPSDRIVE_DA_SS; /* Single sided */ ! 603: } ! 604: #endif ! 605: } ! 606: #endif ! 607: ! 608: ! 609: /* ! 610: * Set the drive and the side to be used for the next FDC commands ! 611: * io_porta_old is the previous value, io_porta_new is the new value ! 612: * to take into account. ! 613: * We report a side change only when a drive is selected. ! 614: */ ! 615: void IPF_SetDriveSide ( Uint8 io_porta_old , Uint8 io_porta_new ) ! 616: { ! 617: #ifndef HAVE_CAPSIMAGE ! 618: return; ! 619: ! 620: #else ! 621: int Side; ! 622: ! 623: LOG_TRACE(TRACE_FDC, "fdc ipf change drive/side io_porta_old=0x%x io_porta_new=0x%x VBL=%d HBL=%d\n" , io_porta_old , io_porta_new , nVBLs , nHBL ); ! 624: ! 625: Side = ( (~io_porta_new) & 0x01 ); /* Side 0 or 1 */ ! 626: ! 627: IPF_State.Fdc.drivenew = -1; /* By default, don't select any drive */ ! 628: ! 629: /* Check drive 1 first */ ! 630: if ( ( io_porta_new & 0x04 ) == 0 ) ! 631: { ! 632: IPF_State.Drive[ 1 ].newside = Side; ! 633: IPF_State.Fdc.drivenew = 1; /* Select drive 1 */ ! 634: } ! 635: ! 636: /* If both drive 0 and drive 1 are enabled, we keep only drive 0 as newdrive */ ! 637: if ( ( io_porta_new & 0x02 ) == 0 ) ! 638: { ! 639: IPF_State.Drive[ 0 ].newside = Side; ! 640: IPF_State.Fdc.drivenew = 0; /* Select drive 0 (and un-select drive 1 if set above) */ ! 641: } ! 642: ! 643: IPF_Emulate(); /* Update emulation's state up to this point, then set new drive/side */ ! 644: #endif ! 645: } ! 646: ! 647: ! 648: ! 649: ! 650: /* ! 651: * Write a byte into one of the FDC registers ! 652: * 0=command 1=track 2=sector 3=data ! 653: */ ! 654: void IPF_FDC_WriteReg ( Uint8 Reg , Uint8 Byte ) ! 655: { ! 656: #ifndef HAVE_CAPSIMAGE ! 657: return; /* This should not be reached (an IPF image can't be inserted without capsimage) */ ! 658: ! 659: #else ! 660: LOG_TRACE(TRACE_FDC, "fdc ipf write reg=%d data=0x%x VBL=%d HBL=%d\n" , Reg , Byte , nVBLs , nHBL ); ! 661: ! 662: ! 663: #if CAPS_LIB_REL_REV >= 501 ! 664: /* In the case of CTR images, we must reset the revolution counter */ ! 665: /* when a command access data on disk and track/side changed since last access */ ! 666: if ( Reg == 0 ) ! 667: { ! 668: int Type; ! 669: int Drive; ! 670: ! 671: Type = FDC_GetCmdType ( Byte ); ! 672: if ( ( Type == 2 ) || ( Type == 3 ) ) ! 673: { ! 674: Drive = IPF_State.Fdc.driveact; ! 675: if ( ( Drive >= 0 ) ! 676: && ( ( IPF_State.Drive[ Drive ].side != IPF_State.Rev_Side[ Drive ] ) || ( IPF_State.Drive[ Drive ].track != IPF_State.Rev_Track[ Drive ] ) ) ) ! 677: { ! 678: IPF_State.Rev_Side[ Drive ] = IPF_State.Drive[ Drive ].side; ! 679: IPF_State.Rev_Track[ Drive ] = IPF_State.Drive[ Drive ].track; ! 680: CAPSSetRevolution ( IPF_State.CapsImage[ Drive ] , 0 ); ! 681: } ! 682: } ! 683: } ! 684: #endif ! 685: ! 686: IPF_Emulate(); /* Update emulation's state up to this point */ ! 687: ! 688: CAPSFdcWrite ( &IPF_State.Fdc , Reg , Byte ); ! 689: #endif ! 690: } ! 691: ! 692: ! 693: ! 694: ! 695: /* ! 696: * Read the content of one of the FDC registers ! 697: * 0=status 1=track 2=sector 3=data ! 698: */ ! 699: Uint8 IPF_FDC_ReadReg ( Uint8 Reg ) ! 700: { ! 701: #ifndef HAVE_CAPSIMAGE ! 702: return 0; /* This should not be reached (an IPF image can't be inserted without capsimage) */ ! 703: #else ! 704: Uint8 Byte; ! 705: ! 706: IPF_Emulate(); /* Update emulation's state up to this point */ ! 707: ! 708: Byte = CAPSFdcRead ( &IPF_State.Fdc , Reg ); ! 709: LOG_TRACE(TRACE_FDC, "fdc ipf read reg=%d data=0x%x VBL=%d HBL=%d\n" , Reg , Byte , nVBLs , nHBL ); ! 710: ! 711: return Byte; ! 712: #endif ! 713: } ! 714: ! 715: ! 716: ! 717: ! 718: /* ! 719: * Return the content of some registers to display them in the statusbar ! 720: * We should not call IPF_Emulate() or similar, reading should not change emulation's state ! 721: */ ! 722: void IPF_FDC_StatusBar ( Uint8 *pCommand , Uint8 *pHead , Uint8 *pTrack , Uint8 *pSector , Uint8 *pSide ) ! 723: { ! 724: #ifndef HAVE_CAPSIMAGE ! 725: return; /* This should not be reached (an IPF image can't be inserted without capsimage) */ ! 726: #else ! 727: int Drive; ! 728: ! 729: Drive = IPF_State.Fdc.driveact; ! 730: if ( Drive < 0 ) /* If no drive enabled, use drive O for Head/Side */ ! 731: Drive = 0; ! 732: ! 733: /* We read directly in the structures, to be sure we don't change emulation's state */ ! 734: *pCommand = IPF_State.Fdc.r_command; ! 735: *pHead = IPF_State.Drive[ Drive ].track; ! 736: *pTrack = IPF_State.Fdc.r_track; ! 737: *pSector = IPF_State.Fdc.r_sector; ! 738: *pSide = IPF_State.Drive[ Drive ].side; ! 739: #endif ! 740: } ! 741: ! 742: ! 743: ! 744: ! 745: /* ! 746: * Run the FDC emulation during NbCycles cycles (relative to the 8MHz FDC's clock) ! 747: */ ! 748: void IPF_Emulate ( void ) ! 749: { ! 750: #ifndef HAVE_CAPSIMAGE ! 751: return; ! 752: ! 753: #else ! 754: int NbCycles; ! 755: int Drive; ! 756: ! 757: NbCycles = CyclesGlobalClockCounter - IPF_State.FdcClock; /* Number of cycles since last emulation */ ! 758: if ( NbCycles < 0 ) ! 759: NbCycles = 0; /* We should call CAPSFdcEmulate even when NbCycles=0 */ ! 760: ! 761: // LOG_TRACE(TRACE_FDC, "fdc ipf emulate cycles=%d VBL=%d HBL=%d clock=%lld\n" , NbCycles , nVBLs , nHBL , CyclesGlobalClockCounter ); ! 762: ! 763: /* Update Write Protect status for each drive */ ! 764: for ( Drive=0 ; Drive < MAX_FLOPPYDRIVES ; Drive++ ) ! 765: if ( Floppy_IsWriteProtected ( Drive ) ) ! 766: IPF_State.Drive[ Drive ].diskattr |= CAPSDRIVE_DA_WP; /* Disk write protected */ ! 767: else ! 768: IPF_State.Drive[ Drive ].diskattr &= ~CAPSDRIVE_DA_WP; /* Disk is not write protected */ ! 769: ! 770: ! 771: CAPSFdcEmulate ( &IPF_State.Fdc , NbCycles ); /* Process at max NbCycles */ ! 772: IPF_State.FdcClock += IPF_State.Fdc.clockact; /* clockact can be < NbCycle in some cases */ ! 773: ! 774: /* Update UI's LEDs depending on Status Register */ ! 775: FDC_Drive_Set_BusyLed ( (IPF_State.Fdc.r_st0 & ~IPF_State.Fdc.r_stm) | (IPF_State.Fdc.r_st1 & IPF_State.Fdc.r_stm) ); ! 776: #endif ! 777: } ! 778: ! 779: ! 780:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.