![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to floppy_stx.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_stx.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 ! root 1: /* ! 2: Hatari - floppy_stx.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: STX disk image support. ! 8: ! 9: STX files are created using the program 'Pasti' made by Jorge Cwik (Ijor). ! 10: As no official documentation exists, this file is based on the reverse ! 11: engineering and docs made by the following people, mainly using Pasti 0.4b : ! 12: - Markus Fritze (Sarnau) ! 13: - P. Putnik ! 14: - Jean Louis Guerin (Dr CoolZic) ! 15: - Nicolas Pomarede ! 16: */ ! 17: const char floppy_stx_fileid[] = "Hatari floppy_stx.c : " __DATE__ " " __TIME__; ! 18: ! 19: #include "main.h" ! 20: #include "file.h" ! 21: #include "floppy.h" ! 22: #include "floppy_stx.h" ! 23: #include "fdc.h" ! 24: #include "log.h" ! 25: #include "memorySnapShot.h" ! 26: #include "screen.h" ! 27: #include "video.h" ! 28: #include "cycles.h" ! 29: #include "str.h" ! 30: #include "utils.h" ! 31: ! 32: ! 33: #define STX_DEBUG_FLAG_STRUCTURE 1 ! 34: #define STX_DEBUG_FLAG_DATA 2 ! 35: ! 36: #define STX_DEBUG_FLAG 0 ! 37: // #define STX_DEBUG_FLAG ( STX_DEBUG_FLAG_STRUCTURE ) ! 38: // #define STX_DEBUG_FLAG ( STX_DEBUG_FLAG_STRUCTURE | STX_DEBUG_FLAG_DATA ) ! 39: ! 40: ! 41: #define FDC_DELAY_CYCLE_MFM_BIT ( 4 * 8 ) /* 4 us per bit, 8 MHz clock -> 32 cycles */ ! 42: #define FDC_DELAY_CYCLE_MFM_BYTE ( 4 * 8 * 8 ) /* 4 us per bit, 8 bits per byte, 8 MHz clock -> 256 cycles */ ! 43: ! 44: #define FDC_TRACK_BYTES_STANDARD 6250 ! 45: ! 46: ! 47: #define WD1772_SAVE_FILE_EXT ".wd1772" ! 48: #define WD1772_SAVE_FILE_ID "WD1772" /* 6 bytes */ ! 49: #define WD1772_SAVE_VERSION 1 ! 50: #define WD1772_SAVE_REVISION 0 ! 51: #define WD1772_SAVE_SECTOR_ID "SECT" /* 4 bytes */ ! 52: #define WD1772_SAVE_TRACK_ID "TRCK" /* 4 bytes */ ! 53: ! 54: ! 55: typedef struct ! 56: { ! 57: STX_MAIN_STRUCT *ImageBuffer[ MAX_FLOPPYDRIVES ]; /* For the STX disk images */ ! 58: ! 59: Uint32 NextSectorStruct_Nbr; /* Sector Number in pSectorsStruct after a call to FDC_NextSectorID_FdcCycles_STX() */ ! 60: Uint8 NextSector_ID_Field_TR; /* Track value in the next ID Field after a call to FDC_NextSectorID_FdcCycles_STX() */ ! 61: Uint8 NextSector_ID_Field_SR; /* Sector value in the next ID Field after a call to FDC_NextSectorID_FdcCycles_STX() */ ! 62: Uint8 NextSector_ID_Field_LEN; /* Sector's length in the next ID Field after a call to FDC_NextSectorID_FdcCycles_STX() */ ! 63: Uint8 NextSector_ID_Field_CRC_OK; /* CRC OK or not in the next ID Field after a call to FDC_NextSectorID_FdcCycles_STX() */ ! 64: ! 65: } STX_STRUCT; ! 66: ! 67: ! 68: static STX_STRUCT STX_State; /* All variables related to the STX support */ ! 69: ! 70: static STX_SAVE_STRUCT STX_SaveStruct[ MAX_FLOPPYDRIVES ]; /* To save 'write sector' data */ ! 71: ! 72: ! 73: ! 74: /* Default timing table for Macrodos when revision=0 */ ! 75: /* 1 unit of timing means 32 FDC cycles ; + 28 cycles every 16 bytes, so a standard block of 16 bytes */ ! 76: /* should have a value of 0x7f or 0x80, which gives 4092-4124 cycles */ ! 77: Uint8 TimingDataDefault[] = { ! 78: 0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f, ! 79: 0x00,0x85,0x00,0x85,0x00,0x85,0x00,0x85,0x00,0x85,0x00,0x85,0x00,0x85,0x00,0x85, ! 80: 0x00,0x79,0x00,0x79,0x00,0x79,0x00,0x79,0x00,0x79,0x00,0x79,0x00,0x79,0x00,0x79, ! 81: 0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f,0x00,0x7f ! 82: }; ! 83: ! 84: ! 85: ! 86: /*--------------------------------------------------------------*/ ! 87: /* Local functions prototypes */ ! 88: /*--------------------------------------------------------------*/ ! 89: ! 90: static bool STX_LoadSaveFile ( int Drive , const char *FilenameSave ); ! 91: static bool STX_LoadSaveFile_SECT ( int Drive, STX_SAVE_SECTOR_STRUCT *pStxSaveSector , Uint8 *p ); ! 92: static bool STX_LoadSaveFile_TRCK ( int Drive , STX_SAVE_TRACK_STRUCT *pStxSaveTrack , Uint8 *p ); ! 93: ! 94: static bool STX_Insert_internal ( int Drive , const char *FilenameSTX , Uint8 *pImageBuffer , long ImageSize ); ! 95: ! 96: static Uint16 STX_ReadU16_LE ( Uint8 *p ); ! 97: static Uint32 STX_ReadU32_LE ( Uint8 *p ); ! 98: static Uint16 STX_ReadU16_BE ( Uint8 *p ); ! 99: static Uint32 STX_ReadU32_BE ( Uint8 *p ); ! 100: static void STX_WriteU16_BE ( Uint8 *p , Uint16 val ); ! 101: static void STX_WriteU32_BE ( Uint8 *p , Uint32 val ); ! 102: ! 103: static void STX_FreeStruct ( STX_MAIN_STRUCT *pStxMain ); ! 104: static void STX_FreeSaveStruct ( int Drive ); ! 105: static void STX_FreeSaveSectorsStructAll ( STX_SAVE_SECTOR_STRUCT *pSaveSectorsStruct , Uint32 SaveSectorsCount ); ! 106: static void STX_FreeSaveSectorsStruct ( STX_SAVE_SECTOR_STRUCT *pSaveSectorsStruct , int Nb ); ! 107: static void STX_FreeSaveTracksStructAll ( STX_SAVE_TRACK_STRUCT *pSaveTracksStruct , Uint32 SaveTracksCount ); ! 108: static void STX_FreeSaveTracksStruct ( STX_SAVE_TRACK_STRUCT *pSaveTracksStruct , int Nb ); ! 109: ! 110: static void STX_BuildSectorsSimple ( STX_TRACK_STRUCT *pStxTrack , Uint8 *p ); ! 111: static Uint16 STX_BuildSectorID_CRC ( STX_SECTOR_STRUCT *pStxSector ); ! 112: static STX_TRACK_STRUCT *STX_FindTrack ( Uint8 Drive , Uint8 Track , Uint8 Side ); ! 113: static STX_SECTOR_STRUCT *STX_FindSector ( Uint8 Drive , Uint8 Track , Uint8 Side , Uint8 SectorStruct_Nb ); ! 114: static STX_SECTOR_STRUCT *STX_FindSector_By_Position ( Uint8 Drive , Uint8 Track , Uint8 Side , Uint16 BitPosition ); ! 115: ! 116: ! 117: ! 118: /*-----------------------------------------------------------------------*/ ! 119: /** ! 120: * Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type) ! 121: */ ! 122: void STX_MemorySnapShot_Capture(bool bSave) ! 123: { ! 124: int Drive; ! 125: Uint32 i; ! 126: STX_SECTOR_STRUCT *pStxSector; ! 127: STX_TRACK_STRUCT *pStxTrack; ! 128: ! 129: if ( bSave ) /* Saving snapshot */ ! 130: { ! 131: MemorySnapShot_Store( &STX_State , sizeof (STX_State) ); ! 132: ! 133: /* Also save the 'write sector' and 'write track' buffers */ ! 134: for ( Drive=0 ; Drive < MAX_FLOPPYDRIVES ; Drive++ ) ! 135: { ! 136: /* Save the sectors' buffer */ ! 137: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].SaveSectorsCount , sizeof ( STX_SaveStruct[ Drive ].SaveSectorsCount ) ); ! 138: if ( STX_SaveStruct[ Drive ].SaveSectorsCount > 0 ) ! 139: { ! 140: /* Save all sectors in the memory state */ ! 141: /* For each sector, we save the structure, then the data */ ! 142: for ( i=0 ; i<STX_SaveStruct[ Drive ].SaveSectorsCount ; i++ ) ! 143: { ! 144: //Str_Dump_Hex_Ascii ( (char *) &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ], sizeof( STX_SAVE_SECTOR_STRUCT ), 16, "" , stderr ); ! 145: /* Save the structure */ ! 146: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ] , sizeof( STX_SAVE_SECTOR_STRUCT ) ); ! 147: /* Save the sector's data */ ! 148: MemorySnapShot_Store ( STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].pData , ! 149: STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].SectorSize ); ! 150: } ! 151: } ! 152: //fprintf ( stderr , "stx save write buffer drive=%d count=%d buf=%p\n" , Drive , STX_SaveStruct[ Drive ].SaveSectorsCount , STX_SaveStruct[ Drive ].pSaveSectorsStruct ); ! 153: ! 154: /* Save the tracks' buffer */ ! 155: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].SaveTracksCount , sizeof ( STX_SaveStruct[ Drive ].SaveTracksCount ) ); ! 156: if ( STX_SaveStruct[ Drive ].SaveTracksCount > 0 ) ! 157: { ! 158: /* Save all tracks in the memory state */ ! 159: /* For each track, we save the structure, then the data */ ! 160: for ( i=0 ; i<STX_SaveStruct[ Drive ].SaveTracksCount ; i++ ) ! 161: { ! 162: //Str_Dump_Hex_Ascii ( (char *) &STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ], sizeof( STX_SAVE_TRACK_STRUCT ), 16, "" , stderr ); ! 163: /* Save the structure */ ! 164: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ] , sizeof( STX_SAVE_TRACK_STRUCT ) ); ! 165: /* Save the track's data (as it was written, don't save the interpreted track) */ ! 166: MemorySnapShot_Store ( STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].pDataWrite , ! 167: STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].TrackSizeWrite ); ! 168: } ! 169: } ! 170: } ! 171: } ! 172: ! 173: else /* Restoring snapshot */ ! 174: { ! 175: MemorySnapShot_Store ( &STX_State , sizeof (STX_State) ); ! 176: ! 177: /* Call STX_Insert_internal to recompute STX_State */ ! 178: /* (without loading an optional ".wd1772" file) */ ! 179: for ( Drive=0 ; Drive < MAX_FLOPPYDRIVES ; Drive++ ) ! 180: if ( EmulationDrives[Drive].ImageType == FLOPPY_IMAGE_TYPE_STX ) ! 181: if ( STX_Insert_internal ( Drive , EmulationDrives[Drive].sFileName , EmulationDrives[Drive].pBuffer , ! 182: EmulationDrives[Drive].nImageBytes ) == false ) ! 183: { ! 184: Log_AlertDlg(LOG_ERROR, "Error restoring STX image %s in drive %d" , ! 185: EmulationDrives[Drive].sFileName , Drive ); ! 186: return; ! 187: } ! 188: ! 189: /* Also restore the 'write sector' and 'write track' buffers */ ! 190: for ( Drive=0 ; Drive < MAX_FLOPPYDRIVES ; Drive++ ) ! 191: { ! 192: /* Restore the sectors' buffer */ ! 193: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].SaveSectorsCount , sizeof ( STX_SaveStruct[ Drive ].SaveSectorsCount ) ); ! 194: if ( STX_SaveStruct[ Drive ].SaveSectorsCount > 0 ) ! 195: { ! 196: /* Alloc a buffer for all the sectors */ ! 197: STX_SaveStruct[ Drive ].pSaveSectorsStruct = malloc ( STX_SaveStruct[ Drive ].SaveSectorsCount * sizeof ( STX_SAVE_SECTOR_STRUCT ) ); ! 198: if ( !STX_SaveStruct[ Drive ].pSaveSectorsStruct ) ! 199: { ! 200: Log_AlertDlg(LOG_ERROR, "Error restoring STX sectors save buffer malloc size=%d in drive %d" , ! 201: STX_SaveStruct[ Drive ].SaveSectorsCount , Drive ); ! 202: return; ! 203: } ! 204: ! 205: /* Load all the sectors from the memory state */ ! 206: /* For each sector, we load the structure, then the data */ ! 207: for ( i=0 ; i<STX_SaveStruct[ Drive ].SaveSectorsCount ; i++ ) ! 208: { ! 209: /* Load the structure */ ! 210: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ] , sizeof( STX_SAVE_SECTOR_STRUCT ) ); ! 211: //Str_Dump_Hex_Ascii ( (char *) &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ], sizeof( STX_SAVE_SECTOR_STRUCT ), 16, "" , stderr ); ! 212: ! 213: /* Load the sector's data */ ! 214: STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].pData = malloc ( STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].SectorSize ); ! 215: if ( !STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].pData ) ! 216: { ! 217: Log_AlertDlg(LOG_ERROR, "Error restoring STX save buffer for sector=%d in drive %d" , ! 218: i , Drive ); ! 219: return; ! 220: } ! 221: MemorySnapShot_Store ( STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].pData , ! 222: STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].SectorSize ); ! 223: ! 224: /* Find the original sector to associate it with this saved sector */ ! 225: pStxSector = STX_FindSector_By_Position ( Drive , STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].Track , ! 226: STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].Side , ! 227: STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i ].BitPosition ); ! 228: if ( !pStxSector ) ! 229: { ! 230: Log_AlertDlg(LOG_ERROR, "Error restoring STX save buffer for sector=%d in drive %d" , ! 231: i , Drive ); ! 232: return; ! 233: } ! 234: pStxSector->SaveSectorIndex = i; ! 235: } ! 236: } ! 237: ! 238: else ! 239: STX_SaveStruct[ Drive ].pSaveSectorsStruct = NULL; ! 240: //fprintf ( stderr , "stx load write buffer drive=%d count=%d buf=%p\n" , Drive , STX_SaveStruct[ Drive ].SaveSectorsCount , STX_SaveStruct[ Drive ].pSaveSectorsStruct ); ! 241: ! 242: /* Restore the tracks' buffer */ ! 243: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].SaveTracksCount , sizeof ( STX_SaveStruct[ Drive ].SaveTracksCount ) ); ! 244: if ( STX_SaveStruct[ Drive ].SaveTracksCount > 0 ) ! 245: { ! 246: /* Alloc a buffer for all the tracks */ ! 247: STX_SaveStruct[ Drive ].pSaveTracksStruct = malloc ( STX_SaveStruct[ Drive ].SaveTracksCount * sizeof ( STX_SAVE_TRACK_STRUCT ) ); ! 248: if ( !STX_SaveStruct[ Drive ].pSaveTracksStruct ) ! 249: { ! 250: Log_AlertDlg(LOG_ERROR, "Error restoring STX tracks save buffer malloc size=%d in drive %d" , ! 251: STX_SaveStruct[ Drive ].SaveTracksCount , Drive ); ! 252: return; ! 253: } ! 254: ! 255: /* Load all the tracks from the memory state */ ! 256: /* For each track, we load the structure, then the data */ ! 257: for ( i=0 ; i<STX_SaveStruct[ Drive ].SaveTracksCount ; i++ ) ! 258: { ! 259: /* Load the structure */ ! 260: MemorySnapShot_Store ( &STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ] , sizeof( STX_SAVE_TRACK_STRUCT ) ); ! 261: //Str_Dump_Hex_Ascii ( (char *) &STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ], sizeof( STX_SAVE_TRACK_STRUCT ), 16, "" , stderr ); ! 262: ! 263: /* Load the track's data (as it was written, don't load the interpreted track) */ ! 264: STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].pDataWrite = malloc ( STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].TrackSizeWrite ); ! 265: if ( !STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].pDataWrite ) ! 266: { ! 267: Log_AlertDlg(LOG_ERROR, "Error restoring STX save buffer for track=%d in drive %d" , ! 268: i , Drive ); ! 269: return; ! 270: } ! 271: MemorySnapShot_Store ( STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].pDataWrite , ! 272: STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].TrackSizeWrite ); ! 273: ! 274: STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].pDataRead = NULL; /* TODO : compute interpreted track */ ! 275: STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].TrackSizeRead = 0; /* TODO : compute interpreted track */ ! 276: ! 277: /* Find the original track to associate it with this saved track */ ! 278: pStxTrack = STX_FindTrack ( Drive , STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].Track , ! 279: STX_SaveStruct[ Drive ].pSaveTracksStruct[ i ].Side ); ! 280: if ( !pStxTrack ) ! 281: { ! 282: Log_AlertDlg(LOG_ERROR, "Error restoring STX save buffer for track=%d in drive %d" , ! 283: i , Drive ); ! 284: return; ! 285: } ! 286: pStxTrack->SaveTrackIndex = i; ! 287: } ! 288: } ! 289: ! 290: else ! 291: STX_SaveStruct[ Drive ].pSaveTracksStruct = NULL; ! 292: } ! 293: ! 294: fprintf ( stderr , "stx load ok\n" ); ! 295: } ! 296: } ! 297: ! 298: ! 299: /*-----------------------------------------------------------------------*/ ! 300: /** ! 301: * Does filename end with a .STX extension? If so, return true. ! 302: */ ! 303: bool STX_FileNameIsSTX(const char *pszFileName, bool bAllowGZ) ! 304: { ! 305: return(File_DoesFileExtensionMatch(pszFileName,".stx") ! 306: || (bAllowGZ && File_DoesFileExtensionMatch(pszFileName,".stx.gz"))); ! 307: } ! 308: ! 309: ! 310: /*-----------------------------------------------------------------------*/ ! 311: /** ! 312: * Create a filename to save modifications made to an STX file ! 313: * We replace the ".stx" or ".stx.gz" extension with ".wd1772" ! 314: * Return true if OK ! 315: */ ! 316: bool STX_FileNameToSave ( const char *FilenameSTX , char *FilenameSave ) ! 317: { ! 318: if ( File_ChangeFileExtension ( FilenameSTX , ".stx.gz" , FilenameSave , WD1772_SAVE_FILE_EXT ) ) ! 319: return true; ! 320: ! 321: else if ( File_ChangeFileExtension ( FilenameSTX , ".stx" , FilenameSave , WD1772_SAVE_FILE_EXT ) ) ! 322: return true; ! 323: ! 324: return false; ! 325: } ! 326: ! 327: ! 328: /*-----------------------------------------------------------------------*/ ! 329: /** ! 330: * Load .STX file into memory, set number of bytes loaded and return a pointer ! 331: * to the buffer. ! 332: */ ! 333: Uint8 *STX_ReadDisk(int Drive, const char *pszFileName, long *pImageSize, int *pImageType) ! 334: { ! 335: Uint8 *pSTXFile; ! 336: ! 337: *pImageSize = 0; ! 338: ! 339: /* Just load directly a buffer, and set ImageSize accordingly */ ! 340: pSTXFile = File_Read(pszFileName, pImageSize, NULL); ! 341: if (!pSTXFile) ! 342: { ! 343: *pImageSize = 0; ! 344: return NULL; ! 345: } ! 346: ! 347: *pImageType = FLOPPY_IMAGE_TYPE_STX; ! 348: return pSTXFile; ! 349: } ! 350: ! 351: ! 352: /*-----------------------------------------------------------------------*/ ! 353: /** ! 354: * Save .STX file from memory buffer. Returns true if all OK. ! 355: * We create a file based on the initial filename by replacing the ".stx" extension ! 356: * with ".wd1172". ! 357: * We save all sectors, then all tracks. ! 358: * If there're no sector and no track to save, return true and don't create ! 359: * the save file ! 360: */ ! 361: bool STX_WriteDisk ( int Drive , const char *pszFileName , Uint8 *pBuffer , int ImageSize ) ! 362: { ! 363: FILE *FileOut; ! 364: char FilenameSave[ FILENAME_MAX ]; ! 365: Uint8 buf[ 100 ]; ! 366: Uint8 *p; ! 367: Uint32 Sector; ! 368: Uint32 Track; ! 369: Uint32 BlockLen; ! 370: Uint32 SaveSectorsCount_real; ! 371: STX_SAVE_SECTOR_STRUCT *pStxSaveSector; ! 372: STX_SAVE_TRACK_STRUCT *pStxSaveTrack; ! 373: Uint32 i; ! 374: ! 375: fprintf ( stderr , "stx write <%s>\n" , pszFileName ); ! 376: ! 377: ! 378: /* We can only save if the filename ends with ".stx" (or ".stx.gz"), not if it's a ".zip" file */ ! 379: if ( STX_FileNameIsSTX ( pszFileName , true ) == false ) ! 380: { ! 381: Log_AlertDlg ( LOG_INFO , "WARNING : can't save changes made to this STX disk, bad file extension" ); ! 382: return false; ! 383: } ! 384: ! 385: /* Count the saved sectors that are really used */ ! 386: SaveSectorsCount_real = 0; ! 387: i = 0; ! 388: while ( i < STX_SaveStruct[ Drive ].SaveSectorsCount ) ! 389: if ( STX_SaveStruct[ Drive ].pSaveSectorsStruct[ i++ ].StructIsUsed != 0 ) ! 390: SaveSectorsCount_real++; ! 391: ! 392: /* Do we have data to save ? */ ! 393: if ( ( SaveSectorsCount_real == 0 ) ! 394: && ( STX_SaveStruct[ Drive ].SaveTracksCount == 0 ) ) ! 395: return true; ! 396: ! 397: ! 398: if ( STX_FileNameToSave ( pszFileName , FilenameSave ) == false ) ! 399: { ! 400: fprintf ( stderr , "STX_WriteDisk drive=%d file=%s, error STX_FileNameToSave\n" , Drive , pszFileName ); ! 401: return false; ! 402: } ! 403: fprintf ( stderr , "stx write <%s>\n" , FilenameSave ); ! 404: ! 405: ! 406: FileOut = fopen ( FilenameSave , "wb+" ); ! 407: if ( !FileOut ) ! 408: { ! 409: fprintf ( stderr , "STX_WriteDisk drive=%d file=%s, error fopen\n" , Drive , pszFileName ); ! 410: return false; ! 411: } ! 412: ! 413: /* Write the file's header : 6 + 1 + 1 + 4 + 4 = 16 bytes */ ! 414: p = buf; ! 415: strcpy ( (char *) p , WD1772_SAVE_FILE_ID ); /* +0 .. +5 */ ! 416: p += strlen ( WD1772_SAVE_FILE_ID ); ! 417: *p++ = WD1772_SAVE_VERSION; /* +6 */ ! 418: *p++ = WD1772_SAVE_REVISION; /* +7 */ ! 419: ! 420: STX_WriteU32_BE ( p , SaveSectorsCount_real ); /* +8 ... +11 */ ! 421: p += 4; ! 422: ! 423: STX_WriteU32_BE ( p , STX_SaveStruct[ Drive ].SaveTracksCount ); /* +12 ... +15 */ ! 424: p += 4; ! 425: ! 426: if ( fwrite ( buf , p-buf , 1 , FileOut ) != 1 ) ! 427: { ! 428: fprintf ( stderr , "STX_WriteDisk drive=%d file=%s, error fwrite header\n" , Drive , pszFileName ); ! 429: return false; ! 430: } ! 431: ! 432: ! 433: /* Write the sectors' buffer */ ! 434: Sector = 0; ! 435: while ( Sector < STX_SaveStruct[ Drive ].SaveSectorsCount ) ! 436: { ! 437: pStxSaveSector = &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ Sector ]; ! 438: ! 439: if ( pStxSaveSector->StructIsUsed == 0 ) ! 440: { ! 441: Sector++; ! 442: continue; /* This structure is not used anymore, ignore it */ ! 443: } ! 444: ! 445: /* Build the sector's header : 20 bytes */ ! 446: p = buf; ! 447: strcpy ( (char *) p , WD1772_SAVE_SECTOR_ID ); /* +0 .. +3 */ ! 448: p += strlen ( WD1772_SAVE_SECTOR_ID ); ! 449: ! 450: BlockLen = 20-4 + pStxSaveSector->SectorSize; ! 451: STX_WriteU32_BE ( p , BlockLen ); /* +4 ... +7 */ ! 452: p += 4; ! 453: ! 454: *p++ = pStxSaveSector->Track; /* +8 */ ! 455: *p++ = pStxSaveSector->Side; /* +9 */ ! 456: STX_WriteU16_BE ( p , pStxSaveSector->BitPosition ); /* +10 ... +11 */ ! 457: p += 2; ! 458: *p++ = pStxSaveSector->ID_Track; /* +12 */ ! 459: *p++ = pStxSaveSector->ID_Head; /* +13 */ ! 460: *p++ = pStxSaveSector->ID_Sector; /* +14 */ ! 461: *p++ = pStxSaveSector->ID_Size; /* +15 */ ! 462: STX_WriteU16_BE ( p , pStxSaveSector->ID_CRC ); /* +16 ... +17 */ ! 463: p += 2; ! 464: ! 465: STX_WriteU16_BE ( p , pStxSaveSector->SectorSize ); /* +18 ... +19 */ ! 466: p += 2; ! 467: ! 468: /* Write the header */ ! 469: //Str_Dump_Hex_Ascii ( (char *) buf , p-buf, 16, "" , stderr ); ! 470: if ( fwrite ( buf , p-buf , 1 , FileOut ) != 1 ) ! 471: { ! 472: fprintf ( stderr , "STX_WriteDisk drive=%d file=%s, error fwrite sector header\n" , Drive , pszFileName ); ! 473: return false; ! 474: } ! 475: ! 476: /* Write the data */ ! 477: //Str_Dump_Hex_Ascii ( (char *) pStxSaveSector->pData , pStxSaveSector->SectorSize, 16, "" , stderr ); ! 478: if ( fwrite ( pStxSaveSector->pData , pStxSaveSector->SectorSize , 1 , FileOut ) != 1 ) ! 479: { ! 480: fprintf ( stderr , "STX_WriteDisk drive=%d file=%s, error fwrite sector data\n" , Drive , pszFileName ); ! 481: return false; ! 482: } ! 483: ! 484: Sector++; ! 485: } ! 486: ! 487: ! 488: /* Write the tracks' buffer */ ! 489: Track = 0; ! 490: while ( Track < STX_SaveStruct[ Drive ].SaveTracksCount ) ! 491: { ! 492: pStxSaveTrack = &STX_SaveStruct[ Drive ].pSaveTracksStruct[ Track ]; ! 493: ! 494: /* Build the track's header : 12 bytes */ ! 495: p = buf; ! 496: strcpy ( (char *) p , WD1772_SAVE_TRACK_ID ); /* +0 ... +3 */ ! 497: p += strlen ( WD1772_SAVE_TRACK_ID ); ! 498: ! 499: BlockLen = 12-4 + pStxSaveTrack->TrackSizeWrite; ! 500: STX_WriteU32_BE ( p , BlockLen ); /* +4 ... +7 */ ! 501: p += 4; ! 502: ! 503: *p++ = pStxSaveTrack->Track; /* +8 */ ! 504: *p++ = pStxSaveTrack->Side; /* +9 */ ! 505: ! 506: STX_WriteU16_BE ( p , pStxSaveTrack->TrackSizeWrite ); /* +10 ... +11 */ ! 507: p += 2; ! 508: ! 509: /* Write the header */ ! 510: //Str_Dump_Hex_Ascii ( (char *) buf , p-buf, 16, "" , stderr ); ! 511: if ( fwrite ( buf , p-buf , 1 , FileOut ) != 1 ) ! 512: { ! 513: fprintf ( stderr , "STX_WriteDisk drive=%d file=%s, error fwrite track header\n" , Drive , pszFileName ); ! 514: return false; ! 515: } ! 516: ! 517: /* Write the data at +12 */ ! 518: //Str_Dump_Hex_Ascii ( (char *) pStxSaveTrack->pDataWrite , pStxSaveTrack->TrackSizeWrite, 16, "" , stderr ); ! 519: if ( fwrite ( pStxSaveTrack->pDataWrite , pStxSaveTrack->TrackSizeWrite , 1 , FileOut ) != 1 ) ! 520: { ! 521: fprintf ( stderr , "STX_WriteDisk drive=%d file=%s, error fwrite track data\n" , Drive , pszFileName ); ! 522: return false; ! 523: } ! 524: ! 525: Track++; ! 526: } ! 527: ! 528: ! 529: fclose ( FileOut ); ! 530: ! 531: return true; ! 532: } ! 533: ! 534: ! 535: /*-----------------------------------------------------------------------*/ ! 536: /* ! 537: * Load a ".wd1772" save file and add it to the STX structures ! 538: * Return true if OK. ! 539: */ ! 540: static bool STX_LoadSaveFile ( int Drive , const char *FilenameSave ) ! 541: { ! 542: Uint8 *SaveFileBuffer; ! 543: long SaveFileSize; ! 544: Uint8 *p; ! 545: Uint8 *p_save; ! 546: Uint8 version , revision; ! 547: Uint32 SectorNb; ! 548: Uint32 TrackNb; ! 549: STX_SECTOR_STRUCT *pStxSector; ! 550: STX_TRACK_STRUCT *pStxTrack; ! 551: ! 552: ! 553: SaveFileBuffer = File_Read ( FilenameSave, &SaveFileSize, NULL ); ! 554: if (!SaveFileBuffer) ! 555: { ! 556: fprintf ( stderr , "STX_LoadSaveFile drive=%d file=%s error\n" , Drive , FilenameSave ); ! 557: return false; ! 558: } ! 559: ! 560: p = SaveFileBuffer; ! 561: ! 562: if ( strncmp ( (char *) p , WD1772_SAVE_FILE_ID , strlen ( WD1772_SAVE_FILE_ID ) ) ) /* +0 ... +5 */ ! 563: { ! 564: fprintf ( stderr , "STX_LoadSaveFile drive=%d file=%s bad header\n" , Drive , FilenameSave ); ! 565: free ( SaveFileBuffer ); ! 566: return false; ! 567: } ! 568: p += strlen ( WD1772_SAVE_FILE_ID ); ! 569: ! 570: version = *p++; /* +6 */ ! 571: revision = *p++; /* +7 */ ! 572: if ( ( version != WD1772_SAVE_VERSION ) || ( revision != WD1772_SAVE_REVISION ) ) ! 573: { ! 574: fprintf ( stderr , "STX_LoadSaveFile drive=%d file=%s bad version 0x%x revision 0x%x\n" , Drive , FilenameSave , version , revision ); ! 575: free ( SaveFileBuffer ); ! 576: return false; ! 577: } ! 578: ! 579: STX_SaveStruct[ Drive ].SaveSectorsCount = STX_ReadU32_BE ( p ); /* +8 ... +11 */ ! 580: p += 4; ! 581: ! 582: STX_SaveStruct[ Drive ].SaveTracksCount = STX_ReadU32_BE ( p ); /* +12 ... +15 */ ! 583: p += 4; ! 584: ! 585: ! 586: /* Alloc a buffer for all the sectors */ ! 587: if ( STX_SaveStruct[ Drive ].SaveSectorsCount > 0 ) ! 588: { ! 589: STX_SaveStruct[ Drive ].pSaveSectorsStruct = malloc ( STX_SaveStruct[ Drive ].SaveSectorsCount * sizeof ( STX_SAVE_SECTOR_STRUCT ) ); ! 590: if ( !STX_SaveStruct[ Drive ].pSaveSectorsStruct ) ! 591: { ! 592: Log_AlertDlg(LOG_ERROR, "Error loading STX sectors save file malloc size=%d in drive %d" , ! 593: STX_SaveStruct[ Drive ].SaveSectorsCount , Drive ); ! 594: STX_FreeSaveStruct ( Drive ); ! 595: free ( SaveFileBuffer ); ! 596: return false; ! 597: } ! 598: } ! 599: ! 600: /* Alloc a buffer for all the tracks */ ! 601: if ( STX_SaveStruct[ Drive ].SaveTracksCount > 0 ) ! 602: { ! 603: STX_SaveStruct[ Drive ].pSaveTracksStruct = malloc ( STX_SaveStruct[ Drive ].SaveTracksCount * sizeof ( STX_SAVE_TRACK_STRUCT ) ); ! 604: if ( !STX_SaveStruct[ Drive ].pSaveTracksStruct ) ! 605: { ! 606: Log_AlertDlg(LOG_ERROR, "Error loading STX tracks save file malloc size=%d in drive %d" , ! 607: STX_SaveStruct[ Drive ].SaveTracksCount , Drive ); ! 608: STX_FreeSaveStruct ( Drive ); ! 609: free ( SaveFileBuffer ); ! 610: return false; ! 611: } ! 612: } ! 613: ! 614: ! 615: SectorNb = 0; ! 616: TrackNb = 0; ! 617: while ( p < SaveFileBuffer + SaveFileSize ) ! 618: { ! 619: /* Start of a block */ ! 620: p_save = p; ! 621: //Str_Dump_Hex_Ascii ( (char *) p , 32, 16, "" , stderr ); ! 622: ! 623: /* Check the name of this block */ ! 624: if ( strncmp ( (char *) p , WD1772_SAVE_SECTOR_ID , 4 ) == 0 ) ! 625: { ! 626: //fprintf ( stderr , "STX_LoadSaveFile drive=%d SECT block %d\n" , Drive , SectorNb ); ! 627: if ( STX_LoadSaveFile_SECT ( Drive , &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ SectorNb ] , p+4+4 ) == false ) ! 628: { ! 629: Log_AlertDlg(LOG_ERROR, "Error loading STX save file SECT block %d in drive %d" , ! 630: SectorNb , Drive ); ! 631: STX_FreeSaveStruct ( Drive ); ! 632: free ( SaveFileBuffer ); ! 633: return false; ! 634: } ! 635: ! 636: //Str_Dump_Hex_Ascii ( (char *) &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ SectorNb ] , sizeof(STX_SAVE_SECTOR_STRUCT) , 16, "" , stderr ); ! 637: //Str_Dump_Hex_Ascii ( (char *) STX_SaveStruct[ Drive ].pSaveSectorsStruct[ SectorNb ].pData , 32, 16, "" , stderr ); ! 638: ! 639: /* Find the original sector to associate it with this saved sector */ ! 640: pStxSector = STX_FindSector_By_Position ( Drive , STX_SaveStruct[ Drive ].pSaveSectorsStruct[ SectorNb ].Track , ! 641: STX_SaveStruct[ Drive ].pSaveSectorsStruct[ SectorNb ].Side , ! 642: STX_SaveStruct[ Drive ].pSaveSectorsStruct[ SectorNb ].BitPosition ); ! 643: if ( !pStxSector ) ! 644: { ! 645: Log_AlertDlg(LOG_ERROR, "Error restoring STX save buffer for sector=%d in drive %d" , ! 646: SectorNb , Drive ); ! 647: STX_FreeSaveStruct ( Drive ); ! 648: free ( SaveFileBuffer ); ! 649: return false; ! 650: } ! 651: pStxSector->SaveSectorIndex = SectorNb; ! 652: ! 653: SectorNb++; ! 654: } ! 655: ! 656: else if ( strncmp ( (char *) p , WD1772_SAVE_TRACK_ID , 4 ) == 0 ) ! 657: { ! 658: //fprintf ( stderr , "STX_LoadSaveFile drive=%d TRCK block %d\n" , Drive , TrackNb ); ! 659: if ( STX_LoadSaveFile_TRCK ( Drive , &STX_SaveStruct[ Drive ].pSaveTracksStruct[ TrackNb ] , p+4+4 ) == false ) ! 660: { ! 661: Log_AlertDlg(LOG_ERROR, "Error loading STX save file TRCK block %d in drive %d" , ! 662: TrackNb , Drive ); ! 663: STX_FreeSaveStruct ( Drive ); ! 664: free ( SaveFileBuffer ); ! 665: return false; ! 666: } ! 667: ! 668: /* Find the original track to associate it with this saved track */ ! 669: pStxTrack = STX_FindTrack ( Drive , STX_SaveStruct[ Drive ].pSaveTracksStruct[ TrackNb ].Track , ! 670: STX_SaveStruct[ Drive ].pSaveTracksStruct[ TrackNb ].Side ); ! 671: if ( !pStxTrack ) ! 672: { ! 673: Log_AlertDlg(LOG_ERROR, "Error loading STX save file TRCK block %d in drive %d" , ! 674: TrackNb , Drive ); ! 675: STX_FreeSaveStruct ( Drive ); ! 676: free ( SaveFileBuffer ); ! 677: return false; ! 678: } ! 679: pStxTrack->SaveTrackIndex = TrackNb; ! 680: ! 681: TrackNb++; ! 682: } ! 683: ! 684: else ! 685: { ! 686: fprintf ( stderr , "STX_LoadSaveFile drive=%d file=%s, unknown block %4.4s, skipping\n" , Drive , FilenameSave , p ); ! 687: } ! 688: ! 689: /* Next block */ ! 690: p = p_save + 4; ! 691: p += STX_ReadU32_BE ( p ); ! 692: } ! 693: ! 694: free ( SaveFileBuffer ); ! 695: return true; ! 696: } ! 697: ! 698: ! 699: /*-----------------------------------------------------------------------*/ ! 700: /* ! 701: * Parse the "SECT" block from a ".wd1772" save file ! 702: * Return true if OK. ! 703: */ ! 704: static bool STX_LoadSaveFile_SECT ( int Drive, STX_SAVE_SECTOR_STRUCT *pStxSaveSector , Uint8 *p ) ! 705: { ! 706: pStxSaveSector->Track = *p++; ! 707: pStxSaveSector->Side = *p++; ! 708: ! 709: pStxSaveSector->BitPosition = STX_ReadU16_BE ( p ); ! 710: p += 2; ! 711: ! 712: pStxSaveSector->ID_Track = *p++; ! 713: pStxSaveSector->ID_Head = *p++; ! 714: pStxSaveSector->ID_Sector = *p++; ! 715: pStxSaveSector->ID_Size = *p++; ! 716: pStxSaveSector->ID_CRC = STX_ReadU16_BE ( p ); ! 717: p += 2; ! 718: ! 719: pStxSaveSector->SectorSize = STX_ReadU16_BE ( p ); ! 720: p += 2; ! 721: ! 722: /* Copy the sector's data */ ! 723: pStxSaveSector->pData = malloc ( pStxSaveSector->SectorSize ); ! 724: if ( !pStxSaveSector->pData ) ! 725: { ! 726: Log_AlertDlg(LOG_ERROR, "Error loading STX save buffer for track=%d side=%d bitposition=%d in drive %d" , ! 727: pStxSaveSector->Track , pStxSaveSector->Side , pStxSaveSector->BitPosition , Drive ); ! 728: return false; ! 729: } ! 730: ! 731: memcpy ( pStxSaveSector->pData , p , pStxSaveSector->SectorSize ); ! 732: ! 733: pStxSaveSector->StructIsUsed = 1; ! 734: ! 735: return true; ! 736: } ! 737: ! 738: ! 739: /*-----------------------------------------------------------------------*/ ! 740: /* ! 741: * Parse the "TRCK" block from a ".wd1772" save file ! 742: * Return true if OK. ! 743: */ ! 744: static bool STX_LoadSaveFile_TRCK ( int Drive , STX_SAVE_TRACK_STRUCT *pStxSaveTrack , Uint8 *p ) ! 745: { ! 746: pStxSaveTrack->Track = *p++; ! 747: pStxSaveTrack->Side = *p++; ! 748: ! 749: pStxSaveTrack->TrackSizeWrite = STX_ReadU16_BE ( p ); ! 750: p += 2; ! 751: ! 752: /* Copy the track's data */ ! 753: pStxSaveTrack->pDataWrite = malloc ( pStxSaveTrack->TrackSizeWrite ); ! 754: if ( !pStxSaveTrack->pDataWrite ) ! 755: { ! 756: Log_AlertDlg(LOG_ERROR, "Error loading STX save buffer for track=%d side=%d in drive %d" , ! 757: pStxSaveTrack->Track , pStxSaveTrack->Side , Drive ); ! 758: return false; ! 759: } ! 760: ! 761: memcpy ( pStxSaveTrack->pDataWrite , p , pStxSaveTrack->TrackSizeWrite ); ! 762: ! 763: pStxSaveTrack->pDataRead = NULL; /* TODO : compute interpreted track */ ! 764: pStxSaveTrack->TrackSizeRead = 0; /* TODO : compute interpreted track */ ! 765: ! 766: return true; ! 767: } ! 768: ! 769: ! 770: ! 771: /*-----------------------------------------------------------------------*/ ! 772: /* ! 773: * Init variables used to handle STX images ! 774: */ ! 775: bool STX_Init ( void ) ! 776: { ! 777: int i; ! 778: ! 779: for ( i=0 ; i<MAX_FLOPPYDRIVES ; i++ ) ! 780: { ! 781: STX_State.ImageBuffer[ i ] = NULL; ! 782: ! 783: STX_SaveStruct[ i ].SaveSectorsCount = 0; ! 784: STX_SaveStruct[ i ].pSaveSectorsStruct = NULL; ! 785: STX_SaveStruct[ i ].SaveTracksCount = 0; ! 786: STX_SaveStruct[ i ].pSaveTracksStruct = NULL; ! 787: } ! 788: ! 789: return true; ! 790: } ! 791: ! 792: ! 793: /*-----------------------------------------------------------------------*/ ! 794: /* ! 795: * Init the ressources to handle the STX image inserted into a drive (0=A: 1=B:) ! 796: * We also look for an optional save file with the ".wd1772" extension. ! 797: * If this file exists, then we load it too. ! 798: */ ! 799: bool STX_Insert ( int Drive , const char *FilenameSTX , Uint8 *pImageBuffer , long ImageSize ) ! 800: { ! 801: char FilenameSave[ FILENAME_MAX ]; ! 802: ! 803: /* Process the current STX image */ ! 804: if ( STX_Insert_internal ( Drive , FilenameSTX , pImageBuffer , ImageSize ) == false ) ! 805: return false; ! 806: ! 807: /* Try to load an optional ".wd1772" save file. In case of error, we continue anyway with the current STX image */ ! 808: if ( ( STX_FileNameToSave ( FilenameSTX , FilenameSave ) ) ! 809: && ( File_Exists ( FilenameSave ) ) ) ! 810: { ! 811: fprintf ( stderr , "STX : STX_Insert drive=%d file=%s buf=%p size=%ld load wd1172 %s\n" , Drive , FilenameSTX , pImageBuffer , ImageSize , FilenameSave ); ! 812: if ( STX_LoadSaveFile ( Drive , FilenameSave ) == false ) ! 813: { ! 814: Log_AlertDlg ( LOG_ERROR , "Can't read the STX save file '%s'. Ignore it" , FilenameSave ); ! 815: } ! 816: } ! 817: ! 818: return true; ! 819: } ! 820: ! 821: ! 822: /*-----------------------------------------------------------------------*/ ! 823: /* ! 824: * Init the ressources to handle the STX image inserted into a drive (0=A: 1=B:) ! 825: * This function is used when restoring a memory snapshot and does not load ! 826: * an optional ".wd1772" save file (the saved data are already in the memory ! 827: * snapshot) ! 828: */ ! 829: static bool STX_Insert_internal ( int Drive , const char *FilenameSTX , Uint8 *pImageBuffer , long ImageSize ) ! 830: { ! 831: fprintf ( stderr , "STX : STX_Insert_internal drive=%d file=%s buf=%p size=%ld\n" , Drive , FilenameSTX , pImageBuffer , ImageSize ); ! 832: ! 833: STX_State.ImageBuffer[ Drive ] = STX_BuildStruct ( pImageBuffer , STX_DEBUG_FLAG ); ! 834: if ( STX_State.ImageBuffer[ Drive ] == NULL ) ! 835: { ! 836: fprintf ( stderr , "STX : STX_Insert_internal drive=%d file=%s buf=%p size=%ld, error in STX_BuildStruct\n" , Drive , FilenameSTX , pImageBuffer , ImageSize ); ! 837: return false; ! 838: } ! 839: ! 840: return true; ! 841: } ! 842: ! 843: ! 844: /*-----------------------------------------------------------------------*/ ! 845: /* ! 846: * When ejecting a disk, free the ressources associated with an STX image ! 847: */ ! 848: bool STX_Eject ( int Drive ) ! 849: { ! 850: fprintf ( stderr , "STX : STX_Eject drive=%d\n" , Drive ); ! 851: ! 852: if ( STX_State.ImageBuffer[ Drive ] ) ! 853: { ! 854: STX_FreeStruct ( STX_State.ImageBuffer[ Drive ] ); ! 855: STX_State.ImageBuffer[ Drive ] = NULL; ! 856: } ! 857: ! 858: STX_FreeSaveStruct ( Drive ); ! 859: ! 860: return true; ! 861: } ! 862: ! 863: ! 864: /*-----------------------------------------------------------------------*/ ! 865: /* ! 866: * Read words and longs stored in little endian order ! 867: */ ! 868: static Uint16 STX_ReadU16_LE ( Uint8 *p ) ! 869: { ! 870: return (p[1]<<8) +p [0]; ! 871: } ! 872: ! 873: static Uint32 STX_ReadU32_LE ( Uint8 *p ) ! 874: { ! 875: return (p[3]<<24) + (p[2]<<16) + (p[1]<<8) +p[0]; ! 876: } ! 877: ! 878: ! 879: /*-----------------------------------------------------------------------*/ ! 880: /* ! 881: * Read words and longs stored in big endian order ! 882: */ ! 883: static Uint16 STX_ReadU16_BE ( Uint8 *p ) ! 884: { ! 885: return (p[0]<<8) + p[1]; ! 886: } ! 887: ! 888: static Uint32 STX_ReadU32_BE ( Uint8 *p ) ! 889: { ! 890: return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) +p[3]; ! 891: } ! 892: ! 893: ! 894: /*-----------------------------------------------------------------------*/ ! 895: /* ! 896: * Store words and longs in big endian order ! 897: */ ! 898: static void STX_WriteU16_BE ( Uint8 *p , Uint16 val ) ! 899: { ! 900: p[ 1 ] = val & 0xff; ! 901: val >>= 8; ! 902: p[ 0 ] = val & 0xff; ! 903: } ! 904: ! 905: static void STX_WriteU32_BE ( Uint8 *p , Uint32 val ) ! 906: { ! 907: p[ 3 ] = val & 0xff; ! 908: val >>= 8; ! 909: p[ 2 ] = val & 0xff; ! 910: val >>= 8; ! 911: p[ 1 ] = val & 0xff; ! 912: val >>= 8; ! 913: p[ 0 ] = val & 0xff; ! 914: } ! 915: ! 916: /*-----------------------------------------------------------------------*/ ! 917: /** ! 918: * Free all the memory allocated to store an STX file ! 919: */ ! 920: static void STX_FreeStruct ( STX_MAIN_STRUCT *pStxMain ) ! 921: { ! 922: int Track; ! 923: ! 924: if ( !pStxMain ) ! 925: return; ! 926: ! 927: for ( Track = 0 ; Track < pStxMain->TracksCount ; Track++ ) ! 928: { ! 929: free ( (pStxMain->pTracksStruct[ Track ]).pSectorsStruct ); ! 930: } ! 931: ! 932: free ( pStxMain->pTracksStruct ); ! 933: free ( pStxMain ); ! 934: } ! 935: ! 936: ! 937: /*-----------------------------------------------------------------------*/ ! 938: /** ! 939: * Free all the memory allocated to store saved sectors / tracks ! 940: */ ! 941: static void STX_FreeSaveStruct ( int Drive ) ! 942: { ! 943: if ( STX_SaveStruct[ Drive ].pSaveSectorsStruct ) ! 944: { ! 945: STX_FreeSaveSectorsStructAll ( STX_SaveStruct[ Drive ].pSaveSectorsStruct , STX_SaveStruct[ Drive ].SaveSectorsCount ); ! 946: STX_SaveStruct[ Drive ].SaveSectorsCount = 0; ! 947: STX_SaveStruct[ Drive ].pSaveSectorsStruct = NULL; ! 948: } ! 949: ! 950: if ( STX_SaveStruct[ Drive ].pSaveTracksStruct ) ! 951: { ! 952: STX_FreeSaveTracksStructAll ( STX_SaveStruct[ Drive ].pSaveTracksStruct , STX_SaveStruct[ Drive ].SaveTracksCount ); ! 953: STX_SaveStruct[ Drive ].SaveTracksCount = 0; ! 954: STX_SaveStruct[ Drive ].pSaveTracksStruct = NULL; ! 955: } ! 956: } ! 957: ! 958: ! 959: /*-----------------------------------------------------------------------*/ ! 960: /** ! 961: * Free the memory allocated to store all the STX_SAVE_SECTOR_STRUCT ! 962: */ ! 963: static void STX_FreeSaveSectorsStructAll ( STX_SAVE_SECTOR_STRUCT *pSaveSectorsStruct , Uint32 SaveSectorsCount ) ! 964: { ! 965: Uint32 i; ! 966: ! 967: if ( !pSaveSectorsStruct ) ! 968: return; ! 969: ! 970: for ( i = 0 ; i < SaveSectorsCount ; i++ ) ! 971: { ! 972: STX_FreeSaveSectorsStruct ( pSaveSectorsStruct , i ); ! 973: } ! 974: ! 975: free ( pSaveSectorsStruct ); ! 976: } ! 977: ! 978: ! 979: /*-----------------------------------------------------------------------*/ ! 980: /** ! 981: * Free the memory allocated to store one STX_SAVE_SECTOR_STRUCT ! 982: */ ! 983: static void STX_FreeSaveSectorsStruct ( STX_SAVE_SECTOR_STRUCT *pSaveSectorsStruct , int Nb ) ! 984: { ! 985: if ( pSaveSectorsStruct[ Nb ].StructIsUsed == 0 ) ! 986: return; /* This structure is already free */ ! 987: ! 988: if ( pSaveSectorsStruct[ Nb ].pData ) ! 989: free ( pSaveSectorsStruct[ Nb ].pData ); ! 990: ! 991: pSaveSectorsStruct[ Nb ].StructIsUsed = 0; ! 992: } ! 993: ! 994: ! 995: /*-----------------------------------------------------------------------*/ ! 996: /** ! 997: * Free the memory allocated to store all the STX_SAVE_TRACK_STRUCT ! 998: */ ! 999: static void STX_FreeSaveTracksStructAll ( STX_SAVE_TRACK_STRUCT *pSaveTracksStruct , Uint32 SaveTracksCount ) ! 1000: { ! 1001: Uint32 i; ! 1002: ! 1003: if ( !pSaveTracksStruct ) ! 1004: return; ! 1005: ! 1006: for ( i = 0 ; i < SaveTracksCount ; i++ ) ! 1007: { ! 1008: STX_FreeSaveTracksStruct ( pSaveTracksStruct , i ); ! 1009: } ! 1010: ! 1011: free ( pSaveTracksStruct ); ! 1012: } ! 1013: ! 1014: ! 1015: /*-----------------------------------------------------------------------*/ ! 1016: /** ! 1017: * Free the memory allocated to store one STX_SAVE_TRACK_STRUCT ! 1018: */ ! 1019: static void STX_FreeSaveTracksStruct ( STX_SAVE_TRACK_STRUCT *pSaveTracksStruct , int Nb ) ! 1020: { ! 1021: if ( pSaveTracksStruct[ Nb ].pDataWrite ) ! 1022: free ( pSaveTracksStruct[ Nb ].pDataWrite ); ! 1023: if ( pSaveTracksStruct[ Nb ].pDataRead ) ! 1024: free ( pSaveTracksStruct[ Nb ].pDataRead ); ! 1025: } ! 1026: ! 1027: ! 1028: /*-----------------------------------------------------------------------*/ ! 1029: /** ! 1030: * Parse an STX file. ! 1031: * The file is in pFileBuffer and we dynamically allocate memory to store ! 1032: * the components (main header, tracks, sectors). ! 1033: * Some internal variables/pointers are also computed, to speed up ! 1034: * data access when the FDC emulates an STX file. ! 1035: */ ! 1036: STX_MAIN_STRUCT *STX_BuildStruct ( Uint8 *pFileBuffer , int Debug ) ! 1037: { ! 1038: ! 1039: STX_MAIN_STRUCT *pStxMain; ! 1040: STX_TRACK_STRUCT *pStxTrack; ! 1041: STX_SECTOR_STRUCT *pStxSector; ! 1042: Uint8 *p; ! 1043: Uint8 *p_cur; ! 1044: int Track; ! 1045: int Sector; ! 1046: Uint8 *pFuzzyData; ! 1047: Uint8 *pTimingData; ! 1048: Uint32 MaxOffsetSectorEnd; ! 1049: int VariableTimings; ! 1050: ! 1051: pStxMain = malloc ( sizeof ( STX_MAIN_STRUCT ) ); ! 1052: if ( !pStxMain ) ! 1053: return NULL; ! 1054: memset ( pStxMain , 0 , sizeof ( STX_MAIN_STRUCT ) ); ! 1055: ! 1056: p = pFileBuffer; ! 1057: ! 1058: /* Read file's header */ ! 1059: memcpy ( pStxMain->FileID , p , 4 ); p += 4; ! 1060: pStxMain->Version = STX_ReadU16_LE ( p ); p += 2; ! 1061: pStxMain->ImagingTool = STX_ReadU16_LE ( p ); p += 2; ! 1062: pStxMain->Reserved_1 = STX_ReadU16_LE ( p ); p += 2; ! 1063: pStxMain->TracksCount = *p++;; ! 1064: pStxMain->Revision = *p++; ! 1065: pStxMain->Reserved_2 = STX_ReadU32_LE ( p ); p += 4; ! 1066: ! 1067: if ( Debug & STX_DEBUG_FLAG_STRUCTURE ) ! 1068: fprintf ( stderr , "STX header ID='%.4s' Version=%4.4x ImagingTool=%4.4x Reserved1=%4.4x" ! 1069: " TrackCount=%d Revision=%2.2x Reserved2=%x\n" , pStxMain->FileID , pStxMain->Version , ! 1070: pStxMain->ImagingTool , pStxMain->Reserved_1 , pStxMain->TracksCount , pStxMain->Revision , ! 1071: pStxMain->Reserved_2 ); ! 1072: ! 1073: pStxMain->WarnedWriteSector = false; ! 1074: pStxMain->WarnedWriteTrack = false; ! 1075: ! 1076: pStxTrack = malloc ( sizeof ( STX_TRACK_STRUCT ) * pStxMain->TracksCount ); ! 1077: if ( !pStxTrack ) ! 1078: { ! 1079: STX_FreeStruct ( pStxMain ); ! 1080: return NULL; ! 1081: } ! 1082: memset ( pStxTrack , 0 , sizeof ( STX_TRACK_STRUCT ) * pStxMain->TracksCount ); ! 1083: pStxMain->pTracksStruct = pStxTrack; ! 1084: ! 1085: /* Parse all the track blocks */ ! 1086: for ( Track = 0 ; Track < pStxMain->TracksCount ; Track++ ) ! 1087: { ! 1088: p_cur = p; ! 1089: ! 1090: pStxTrack->BlockSize = STX_ReadU32_LE ( p ); p += 4; ! 1091: pStxTrack->FuzzySize = STX_ReadU32_LE ( p ); p += 4; ! 1092: pStxTrack->SectorsCount = STX_ReadU16_LE ( p ); p += 2; ! 1093: pStxTrack->Flags = STX_ReadU16_LE ( p ); p += 2; ! 1094: pStxTrack->MFMSize = STX_ReadU16_LE ( p ); p += 2; ! 1095: pStxTrack->TrackNumber = *p++; ! 1096: pStxTrack->RecordType = *p++; ! 1097: ! 1098: pStxTrack->SaveTrackIndex = -1; ! 1099: ! 1100: if ( pStxTrack->SectorsCount == 0 ) /* No sector (track image only, or empty / non formatted track) */ ! 1101: { ! 1102: pStxTrack->pSectorsStruct = NULL; ! 1103: } ! 1104: else ! 1105: { ! 1106: /* Track contains some sectors */ ! 1107: pStxSector = malloc ( sizeof ( STX_SECTOR_STRUCT ) * pStxTrack->SectorsCount ); ! 1108: if ( !pStxSector ) ! 1109: { ! 1110: STX_FreeStruct ( pStxMain ); ! 1111: return NULL; ! 1112: } ! 1113: memset ( pStxSector , 0 , sizeof ( STX_SECTOR_STRUCT ) * pStxTrack->SectorsCount ); ! 1114: pStxTrack->pSectorsStruct = pStxSector; ! 1115: ! 1116: /* Do we have some sector infos after the track header or only sector data ? */ ! 1117: if ( ( pStxTrack->Flags & STX_TRACK_FLAG_SECTOR_BLOCK ) == 0 ) ! 1118: { ! 1119: /* The track only contains SectorsCount sectors of 512 bytes */ ! 1120: /* NOTE |NP] : in that case, pStxTrack->MFMSize seems to be in bits instead of bytes */ ! 1121: STX_BuildSectorsSimple ( pStxTrack , p ); ! 1122: goto next_track; ! 1123: } ! 1124: } ! 1125: ! 1126: /* Start of the optional fuzzy bits data */ ! 1127: pStxTrack->pFuzzyData = p + pStxTrack->SectorsCount * STX_SECTOR_BLOCK_SIZE; ! 1128: ! 1129: /* Start of the optional track data */ ! 1130: pStxTrack->pTrackData = pStxTrack->pFuzzyData + pStxTrack->FuzzySize; ! 1131: ! 1132: if ( ( pStxTrack->Flags & STX_TRACK_FLAG_TRACK_IMAGE ) == 0 ) ! 1133: { ! 1134: pStxTrack->TrackImageSyncPosition = 0; ! 1135: pStxTrack->TrackImageSize = 0; ! 1136: pStxTrack->pTrackImageData = NULL; ! 1137: pStxTrack->pSectorsImageData = pStxTrack->pTrackData; ! 1138: } ! 1139: else if ( ( pStxTrack->Flags & STX_TRACK_FLAG_TRACK_IMAGE_SYNC ) == 0 ) /* Track with size+data */ ! 1140: { ! 1141: pStxTrack->TrackImageSyncPosition = 0; ! 1142: pStxTrack->TrackImageSize = STX_ReadU16_LE ( pStxTrack->pTrackData ); ! 1143: pStxTrack->pTrackImageData = pStxTrack->pTrackData + 2; ! 1144: pStxTrack->pSectorsImageData = pStxTrack->pTrackImageData + pStxTrack->TrackImageSize; ! 1145: } ! 1146: else /* Track with sync offset + size + data */ ! 1147: { ! 1148: pStxTrack->TrackImageSyncPosition = STX_ReadU16_LE ( pStxTrack->pTrackData ); ! 1149: pStxTrack->TrackImageSize = STX_ReadU16_LE ( pStxTrack->pTrackData + 2 ); ! 1150: pStxTrack->pTrackImageData = pStxTrack->pTrackData + 4; ! 1151: pStxTrack->pSectorsImageData = pStxTrack->pTrackImageData + pStxTrack->TrackImageSize; ! 1152: } ! 1153: ! 1154: if ( pStxTrack->SectorsCount == 0 ) /* No sector (track image only, or empty / non formatted track) */ ! 1155: goto next_track; ! 1156: ! 1157: /* Parse all the sectors in this track */ ! 1158: pFuzzyData = pStxTrack->pFuzzyData; ! 1159: VariableTimings = 0; ! 1160: MaxOffsetSectorEnd = 0; ! 1161: for ( Sector = 0 ; Sector < pStxTrack->SectorsCount ; Sector++ ) ! 1162: { ! 1163: pStxSector = &(pStxTrack->pSectorsStruct[ Sector ]); ! 1164: ! 1165: pStxSector->DataOffset = STX_ReadU32_LE ( p ); p += 4; ! 1166: pStxSector->BitPosition = STX_ReadU16_LE ( p ); p += 2; ! 1167: pStxSector->ReadTime = STX_ReadU16_LE ( p ); p += 2; ! 1168: pStxSector->ID_Track = *p++; ! 1169: pStxSector->ID_Head = *p++; ! 1170: pStxSector->ID_Sector = *p++; ! 1171: pStxSector->ID_Size = *p++; ! 1172: pStxSector->ID_CRC = ( p[0] << 8 ) | p[1] ; p +=2; ! 1173: pStxSector->FDC_Status = *p++; ! 1174: pStxSector->Reserved = *p++; ! 1175: ! 1176: /* Check if sector has data */ ! 1177: if ( ( pStxSector->FDC_Status & STX_SECTOR_FLAG_RNF ) == 0 ) ! 1178: { ! 1179: /* Check if SectorSize is valid (this is just a warning, we keep only bits 0-1 anyway) */ ! 1180: if ( pStxSector->ID_Size & ~FDC_SECTOR_SIZE_MASK ) ! 1181: { ! 1182: // fprintf ( stderr , "STX : invalid ID_Size=%d on track %d sector %d\n" , ! 1183: // pStxSector->ID_Size , Track , Sector ); ! 1184: } ! 1185: ! 1186: pStxSector->SectorSize = 128 << ( pStxSector->ID_Size & FDC_SECTOR_SIZE_MASK ); ! 1187: ! 1188: pStxSector->pData = pStxTrack->pTrackData + pStxSector->DataOffset; ! 1189: if ( pStxSector->FDC_Status & STX_SECTOR_FLAG_FUZZY ) ! 1190: { ! 1191: pStxSector->pFuzzyData = pFuzzyData; ! 1192: pFuzzyData += pStxSector->SectorSize; ! 1193: } ! 1194: ! 1195: /* Max offset of the end of all sectors image in the track */ ! 1196: if ( MaxOffsetSectorEnd < pStxSector->DataOffset + pStxSector->SectorSize ) ! 1197: MaxOffsetSectorEnd = pStxSector->DataOffset + pStxSector->SectorSize; ! 1198: ! 1199: if ( pStxSector->FDC_Status & STX_SECTOR_FLAG_VARIABLE_TIME ) ! 1200: VariableTimings = 1; ! 1201: } ! 1202: ! 1203: pStxSector->SaveSectorIndex = -1; ! 1204: } ! 1205: ! 1206: /* Start of the optional timings data, after the optional sectors image data */ ! 1207: pStxTrack->pTiming = pStxTrack->pTrackData + MaxOffsetSectorEnd; ! 1208: if ( pStxTrack->pTiming < pStxTrack->pSectorsImageData ) /* If all sectors image were inside the track image */ ! 1209: pStxTrack->pTiming = pStxTrack->pSectorsImageData; /* then timings data are just after the track image */ ! 1210: ! 1211: if ( VariableTimings == 1 ) /* Track has at least one variable sector */ ! 1212: { ! 1213: if ( pStxMain->Revision == 2 ) /* Specific timing table */ ! 1214: { ! 1215: pStxTrack->TimingFlags = STX_ReadU16_LE ( pStxTrack->pTiming ); /* always '5' ? */ ! 1216: pStxTrack->TimingSize = STX_ReadU16_LE ( pStxTrack->pTiming + 2 ); ! 1217: pStxTrack->pTimingData = pStxTrack->pTiming + 4; /* 2 bytes of timing for each block of 16 bytes */ ! 1218: } ! 1219: ! 1220: /* Compute the address of the timings data for each sector with variable timings */ ! 1221: pTimingData = pStxTrack->pTimingData; ! 1222: for ( Sector = 0 ; Sector < pStxTrack->SectorsCount ; Sector++ ) ! 1223: { ! 1224: pStxSector = &(pStxTrack->pSectorsStruct[ Sector ]); ! 1225: pStxSector->pTimingData = NULL; /* No timings by default */ ! 1226: ! 1227: /* Check if sector has data + variable timings */ ! 1228: if ( ( ( pStxSector->FDC_Status & STX_SECTOR_FLAG_RNF ) == 0 ) ! 1229: && ( pStxSector->FDC_Status & STX_SECTOR_FLAG_VARIABLE_TIME ) ) ! 1230: { ! 1231: if ( pStxMain->Revision == 2 ) /* Specific table for revision 2 */ ! 1232: { ! 1233: pStxSector->pTimingData = pTimingData; ! 1234: pTimingData += ( pStxSector->SectorSize / 16 ) * 2; ! 1235: } ! 1236: else ! 1237: pStxSector->pTimingData = TimingDataDefault; /* Fixed table for revision 0 */ ! 1238: } ! 1239: } ! 1240: } ! 1241: ! 1242: next_track: ! 1243: if ( Debug & STX_DEBUG_FLAG_STRUCTURE ) ! 1244: { ! 1245: fprintf ( stderr , " track %3d BlockSize=%d FuzzySize=%d Sectors=%4.4x Flags=%4.4x" ! 1246: " MFMSize=%d TrackNb=%2.2x Side=%d RecordType=%x" ! 1247: " TrackImage=%s (%d bytes, sync=%4.4x) Timings=%d,%d\n" , ! 1248: Track , pStxTrack->BlockSize , ! 1249: pStxTrack->FuzzySize , pStxTrack->SectorsCount , pStxTrack->Flags , pStxTrack->MFMSize , ! 1250: pStxTrack->TrackNumber & 0x7f , ( pStxTrack->TrackNumber >> 7 ) & 0x01 , pStxTrack->RecordType , ! 1251: pStxTrack->pTrackImageData ? "yes" : "no" , pStxTrack->TrackImageSize , pStxTrack->TrackImageSyncPosition , ! 1252: pStxTrack->TimingFlags , pStxTrack->TimingSize ); ! 1253: ! 1254: if ( ( Debug & STX_DEBUG_FLAG_DATA ) && pStxTrack->pTrackImageData ) ! 1255: { ! 1256: fprintf ( stderr , " track image data :\n" ); ! 1257: Str_Dump_Hex_Ascii ( (char *)pStxTrack->pTrackImageData , pStxTrack->TrackImageSize , ! 1258: 16 , " " , stderr ); ! 1259: } ! 1260: ! 1261: if ( pStxTrack->SectorsCount == 0 ) ! 1262: fprintf ( stderr , " no sector in this track, %s\n" , ! 1263: pStxTrack->pTrackImageData ? "only track image" : "track empty / not formatted" ); ! 1264: else ! 1265: for ( Sector = 0 ; Sector < pStxTrack->SectorsCount ; Sector++ ) ! 1266: { ! 1267: /* If the sector use the internal timing table, we print TimingsOffset=-1 */ ! 1268: pStxSector = &(pStxTrack->pSectorsStruct[ Sector ]); ! 1269: fprintf ( stderr , " sector %2d DataOffset=%d BitPosition=%d ReadTime=%d" ! 1270: " [track=%2.2x head=%2.2x sector=%2.2x size=%2.2x crc=%4.4x]" ! 1271: " FdcStatus=%2.2x Reserved=%2.2x TimingsOffset=%d\n" , ! 1272: Sector , pStxSector->DataOffset , pStxSector->BitPosition , ! 1273: pStxSector->ReadTime , pStxSector->ID_Track , pStxSector->ID_Head , ! 1274: pStxSector->ID_Sector , pStxSector->ID_Size , pStxSector->ID_CRC , ! 1275: pStxSector->FDC_Status , pStxSector->Reserved , ! 1276: pStxSector->pTimingData ? ! 1277: ( pStxTrack->TimingSize > 0 ? (int)(pStxSector->pTimingData - pStxTrack->pTrackData) : -1 ) ! 1278: : 0 ); ! 1279: ! 1280: if ( ( Debug & STX_DEBUG_FLAG_DATA ) && pStxSector->pData ) ! 1281: { ! 1282: fprintf ( stderr , " sector data :\n" ); ! 1283: Str_Dump_Hex_Ascii ( (char *)pStxSector->pData , pStxSector->SectorSize , ! 1284: 16 , " " , stderr ); ! 1285: } ! 1286: if ( ( Debug & STX_DEBUG_FLAG_DATA ) && pStxSector->pFuzzyData ) ! 1287: { ! 1288: fprintf ( stderr , " fuzzy data :\n" ); ! 1289: Str_Dump_Hex_Ascii ( (char *)pStxSector->pFuzzyData , pStxSector->SectorSize , ! 1290: 16 , " " , stderr ); ! 1291: } ! 1292: if ( ( Debug & STX_DEBUG_FLAG_DATA ) && pStxSector->pTimingData ) ! 1293: { ! 1294: fprintf ( stderr , " timing data :\n" ); ! 1295: Str_Dump_Hex_Ascii ( (char *)pStxSector->pTimingData , ( pStxSector->SectorSize / 16 ) * 2 , ! 1296: 16 , " " , stderr ); ! 1297: } ! 1298: } ! 1299: } ! 1300: ! 1301: p = p_cur + pStxTrack->BlockSize; /* Next Track block */ ! 1302: pStxTrack++; ! 1303: } ! 1304: ! 1305: ! 1306: return pStxMain; ! 1307: } ! 1308: ! 1309: ! 1310: /*-----------------------------------------------------------------------*/ ! 1311: /** ! 1312: * When a track only consists of the content of each 512 bytes sector and ! 1313: * no timings informations, we must compute some default values for each ! 1314: * sector, as well as the position of the corresponding 512 bytes of data. ! 1315: * This is only used when storing unprotected tracks. ! 1316: */ ! 1317: static void STX_BuildSectorsSimple ( STX_TRACK_STRUCT *pStxTrack , Uint8 *p ) ! 1318: { ! 1319: int Sector; ! 1320: int BytePosition; ! 1321: Uint16 CRC; ! 1322: ! 1323: BytePosition = FDC_TRACK_LAYOUT_STANDARD_GAP1 + FDC_TRACK_LAYOUT_STANDARD_GAP2; /* Points to the 3x$A1 before the 1st IDAM $FE */ ! 1324: BytePosition += 4; /* Pasti seems to point after the 3x$A1 and the IDAM $FE */ ! 1325: ! 1326: for ( Sector = 0 ; Sector < pStxTrack->SectorsCount ; Sector++ ) ! 1327: { ! 1328: pStxTrack->pSectorsStruct[ Sector ].SaveSectorIndex = -1; ! 1329: pStxTrack->pSectorsStruct[ Sector ].DataOffset = 0; ! 1330: pStxTrack->pSectorsStruct[ Sector ].BitPosition = BytePosition * 8; ! 1331: pStxTrack->pSectorsStruct[ Sector ].ReadTime = 0; ! 1332: ! 1333: /* Build the ID Field */ ! 1334: pStxTrack->pSectorsStruct[ Sector ].ID_Track = pStxTrack->TrackNumber & 0x7f; ! 1335: pStxTrack->pSectorsStruct[ Sector ].ID_Head = ( pStxTrack->TrackNumber >> 7 ) & 0x01; ! 1336: pStxTrack->pSectorsStruct[ Sector ].ID_Sector = Sector + 1; ! 1337: pStxTrack->pSectorsStruct[ Sector ].ID_Size = FDC_SECTOR_SIZE_512; ! 1338: CRC = STX_BuildSectorID_CRC ( &(pStxTrack->pSectorsStruct[ Sector ]) ); ! 1339: pStxTrack->pSectorsStruct[ Sector ].ID_CRC = CRC; ! 1340: ! 1341: pStxTrack->pSectorsStruct[ Sector ].FDC_Status = 0; ! 1342: pStxTrack->pSectorsStruct[ Sector ].Reserved = 0; ! 1343: pStxTrack->pSectorsStruct[ Sector ].pData = p + Sector * 512; ! 1344: pStxTrack->pSectorsStruct[ Sector ].SectorSize = 128 << pStxTrack->pSectorsStruct[ Sector ].ID_Size; ! 1345: ! 1346: BytePosition += FDC_TRACK_LAYOUT_STANDARD_RAW_SECTOR_512; ! 1347: } ! 1348: } ! 1349: ! 1350: ! 1351: ! 1352: /*-----------------------------------------------------------------------*/ ! 1353: /** ! 1354: * Compute the CRC of the Address Field for a given sector. ! 1355: */ ! 1356: static Uint16 STX_BuildSectorID_CRC ( STX_SECTOR_STRUCT *pStxSector ) ! 1357: { ! 1358: Uint16 CRC; ! 1359: ! 1360: crc16_reset ( &CRC ); ! 1361: crc16_add_byte ( &CRC , 0xa1 ); ! 1362: crc16_add_byte ( &CRC , 0xa1 ); ! 1363: crc16_add_byte ( &CRC , 0xa1 ); ! 1364: crc16_add_byte ( &CRC , 0xfe ); ! 1365: crc16_add_byte ( &CRC , pStxSector->ID_Track ); ! 1366: crc16_add_byte ( &CRC , pStxSector->ID_Head ); ! 1367: crc16_add_byte ( &CRC , pStxSector->ID_Sector ); ! 1368: crc16_add_byte ( &CRC , pStxSector->ID_Size ); ! 1369: ! 1370: return CRC; ! 1371: } ! 1372: ! 1373: ! 1374: ! 1375: /*-----------------------------------------------------------------------*/ ! 1376: /** ! 1377: * Find a track in the floppy image inserted into a drive. ! 1378: */ ! 1379: static STX_TRACK_STRUCT *STX_FindTrack ( Uint8 Drive , Uint8 Track , Uint8 Side ) ! 1380: { ! 1381: int i; ! 1382: ! 1383: if ( STX_State.ImageBuffer[ Drive ] == NULL ) ! 1384: return NULL; ! 1385: ! 1386: for ( i=0 ; i<STX_State.ImageBuffer[ Drive ]->TracksCount ; i++ ) ! 1387: if ( STX_State.ImageBuffer[ Drive ]->pTracksStruct[ i ].TrackNumber == ( ( Track & 0x7f ) | ( Side << 7 ) ) ) ! 1388: return &(STX_State.ImageBuffer[ Drive ]->pTracksStruct[ i ]); ! 1389: ! 1390: return NULL; ! 1391: } ! 1392: ! 1393: ! 1394: ! 1395: /*-----------------------------------------------------------------------*/ ! 1396: /** ! 1397: * Find a sector in the floppy image inserted into a drive. ! 1398: * SectorStruct_Nb is a value set by a previous call to FDC_NextSectorID_FdcCycles_STX() ! 1399: */ ! 1400: static STX_SECTOR_STRUCT *STX_FindSector ( Uint8 Drive , Uint8 Track , Uint8 Side , Uint8 SectorStruct_Nb ) ! 1401: { ! 1402: STX_TRACK_STRUCT *pStxTrack; ! 1403: ! 1404: if ( STX_State.ImageBuffer[ Drive ] == NULL ) ! 1405: return NULL; ! 1406: ! 1407: pStxTrack = STX_FindTrack ( Drive , Track , Side ); ! 1408: if ( pStxTrack == NULL ) ! 1409: return NULL; ! 1410: ! 1411: if ( pStxTrack->pSectorsStruct == NULL ) ! 1412: return NULL; ! 1413: ! 1414: return &(pStxTrack->pSectorsStruct[ SectorStruct_Nb ]); ! 1415: } ! 1416: ! 1417: ! 1418: ! 1419: /*-----------------------------------------------------------------------*/ ! 1420: /** ! 1421: * Find a sector in the floppy image inserted into a drive. ! 1422: * The sector is identified by its BitPosition which is unique per track/side ! 1423: */ ! 1424: static STX_SECTOR_STRUCT *STX_FindSector_By_Position ( Uint8 Drive , Uint8 Track , Uint8 Side , Uint16 BitPosition ) ! 1425: { ! 1426: STX_TRACK_STRUCT *pStxTrack; ! 1427: int Sector; ! 1428: ! 1429: if ( STX_State.ImageBuffer[ Drive ] == NULL ) ! 1430: return NULL; ! 1431: ! 1432: pStxTrack = STX_FindTrack ( Drive , Track , Side ); ! 1433: if ( pStxTrack == NULL ) ! 1434: return NULL; ! 1435: ! 1436: if ( pStxTrack->pSectorsStruct == NULL ) ! 1437: return NULL; ! 1438: ! 1439: for ( Sector=0 ; Sector<pStxTrack->SectorsCount ; Sector++ ) ! 1440: if ( pStxTrack->pSectorsStruct[ Sector ].BitPosition == BitPosition ) ! 1441: return &(pStxTrack->pSectorsStruct[ Sector ]); ! 1442: ! 1443: return NULL; ! 1444: } ! 1445: ! 1446: ! 1447: ! 1448: /*-----------------------------------------------------------------------*/ ! 1449: /** ! 1450: * Return the number of FDC cycles to go from one index pulse to the next ! 1451: * one on a given drive/track/side. ! 1452: * We take the TrackSize into account to return this delay. ! 1453: */ ! 1454: extern Uint32 FDC_GetCyclesPerRev_FdcCycles_STX ( Uint8 Drive , Uint8 Track , Uint8 Side ) ! 1455: { ! 1456: STX_TRACK_STRUCT *pStxTrack; ! 1457: int TrackSize; ! 1458: ! 1459: pStxTrack = STX_FindTrack ( Drive , Track , Side ); ! 1460: if ( pStxTrack == NULL ) ! 1461: TrackSize = FDC_TRACK_BYTES_STANDARD; /* Use a standard track length is track is not available */ ! 1462: ! 1463: else if ( pStxTrack->pTrackImageData ) ! 1464: TrackSize = pStxTrack->TrackImageSize; ! 1465: else if ( ( pStxTrack->Flags & STX_TRACK_FLAG_SECTOR_BLOCK ) == 0 ) ! 1466: TrackSize = pStxTrack->MFMSize / 8; /* When the track contains only sector data, MFMSize is in bits */ ! 1467: else ! 1468: TrackSize = pStxTrack->MFMSize; ! 1469: ! 1470: //fprintf ( stderr , "fdc stx drive=%d track=0x%x side=%d size=%d\n" , Drive , Track, Side , TrackSize ); ! 1471: return TrackSize * FDC_DELAY_CYCLE_MFM_BYTE; ! 1472: } ! 1473: ! 1474: ! 1475: ! 1476: /*-----------------------------------------------------------------------*/ ! 1477: /** ! 1478: * Return the number of FDC cycles to wait before reaching the next ! 1479: * sector's ID Field in the track ($A1 $A1 $A1 $FE TR SIDE SR LEN CRC1 CRC2) ! 1480: * If no ID Field is found before the end of the track, we use the 1st ! 1481: * ID Field of the track (which simulates a full spin of the floppy). ! 1482: * We also store the next sector's number into NextSectorStruct_Nbr, ! 1483: * the next sector's number into NextSector_ID_Field_SR, the next track's number ! 1484: * into NextSector_ID_Field_TR, the next sector's lenght into ! 1485: * NextSector_ID_Field_LEN and if the CRC is correct or not into NextSector_ID_Field_CRC_OK. ! 1486: * This function assumes the sectors of each track are sorted in ascending order ! 1487: * using BitPosition. ! 1488: * If there's no available drive/floppy or no ID field in the track, we return -1 ! 1489: */ ! 1490: extern int FDC_NextSectorID_FdcCycles_STX ( Uint8 Drive , Uint8 NumberOfHeads , Uint8 Track , Uint8 Side ) ! 1491: { ! 1492: STX_TRACK_STRUCT *pStxTrack; ! 1493: int CurrentPos_FdcCycles; ! 1494: int i; ! 1495: int Delay_FdcCycles; ! 1496: int TrackSize; ! 1497: ! 1498: CurrentPos_FdcCycles = FDC_IndexPulse_GetCurrentPos_FdcCycles ( NULL ); ! 1499: if ( CurrentPos_FdcCycles < 0 ) /* No drive/floppy available at the moment */ ! 1500: return -1; ! 1501: ! 1502: if ( ( Side == 1 ) && ( NumberOfHeads == 1 ) ) /* Can't read side 1 on a single sided drive */ ! 1503: return -1; ! 1504: ! 1505: pStxTrack = STX_FindTrack ( Drive , Track , Side ); ! 1506: if ( pStxTrack == NULL ) /* Track/Side don't exist in this STX image */ ! 1507: return -1; ! 1508: ! 1509: if ( pStxTrack->SectorsCount == 0 ) /* No sector (track image only, or empty / non formatted track) */ ! 1510: return -1; ! 1511: ! 1512: /* Compare CurrentPos_FdcCycles with each sector's position in ascending order */ ! 1513: for ( i=0 ; i<pStxTrack->SectorsCount ; i++ ) ! 1514: { ! 1515: if ( CurrentPos_FdcCycles < (int)pStxTrack->pSectorsStruct[ i ].BitPosition*FDC_DELAY_CYCLE_MFM_BIT ) /* 1 bit = 32 cycles at 8 MHz */ ! 1516: break; /* We found the next sector */ ! 1517: } ! 1518: ! 1519: if ( i == pStxTrack->SectorsCount ) /* CurrentPos_FdcCycles is after the last ID Field of this track */ ! 1520: { ! 1521: /* Reach end of track (new index pulse), then go to 1st sector from current position */ ! 1522: if ( pStxTrack->pTrackImageData ) ! 1523: TrackSize = pStxTrack->TrackImageSize; ! 1524: else if ( ( pStxTrack->Flags & STX_TRACK_FLAG_SECTOR_BLOCK ) == 0 ) ! 1525: TrackSize = pStxTrack->MFMSize / 8; /* When the track contains only sector data, MFMSize is in bits */ ! 1526: else ! 1527: TrackSize = pStxTrack->MFMSize; ! 1528: ! 1529: Delay_FdcCycles = TrackSize * FDC_DELAY_CYCLE_MFM_BYTE - CurrentPos_FdcCycles ! 1530: + pStxTrack->pSectorsStruct[ 0 ].BitPosition*FDC_DELAY_CYCLE_MFM_BIT; ! 1531: STX_State.NextSectorStruct_Nbr = 0; ! 1532: //fprintf ( stderr , "size=%d pos=%d pos0=%d delay=%d\n" , TrackSize, CurrentPos_FdcCycles, pStxTrack->pSectorsStruct[ 0 ].BitPosition , Delay_FdcCycles ); ! 1533: } ! 1534: else /* There's an ID Field before end of track */ ! 1535: { ! 1536: Delay_FdcCycles = (int)pStxTrack->pSectorsStruct[ i ].BitPosition*FDC_DELAY_CYCLE_MFM_BIT - CurrentPos_FdcCycles; ! 1537: STX_State.NextSectorStruct_Nbr = i; ! 1538: //fprintf ( stderr , "i=%d pos=%d posi=%d delay=%d\n" , i, CurrentPos_FdcCycles, pStxTrack->pSectorsStruct[ i ].BitPosition*FDC_DELAY_CYCLE_MFM_BIT , Delay_FdcCycles ); ! 1539: } ! 1540: ! 1541: /* Store the value of the track/sector numbers in the next ID field */ ! 1542: STX_State.NextSector_ID_Field_TR = pStxTrack->pSectorsStruct[ STX_State.NextSectorStruct_Nbr ].ID_Track; ! 1543: STX_State.NextSector_ID_Field_SR = pStxTrack->pSectorsStruct[ STX_State.NextSectorStruct_Nbr ].ID_Sector; ! 1544: STX_State.NextSector_ID_Field_LEN = pStxTrack->pSectorsStruct[ STX_State.NextSectorStruct_Nbr ].ID_Size; ! 1545: ! 1546: /* If RNF is set and CRC error is set, then this ID field has a CRC error */ ! 1547: if ( ( pStxTrack->pSectorsStruct[ STX_State.NextSectorStruct_Nbr ].FDC_Status & STX_SECTOR_FLAG_RNF ) ! 1548: && ( pStxTrack->pSectorsStruct[ STX_State.NextSectorStruct_Nbr ].FDC_Status & STX_SECTOR_FLAG_CRC ) ) ! 1549: STX_State.NextSector_ID_Field_CRC_OK = 0; /* CRC bad */ ! 1550: else ! 1551: STX_State.NextSector_ID_Field_CRC_OK = 1; /* CRC correct */ ! 1552: ! 1553: /* BitPosition in STX seems to point just after the IDAM $FE ; we need to point 4 bytes earlier at the 1st $A1 */ ! 1554: Delay_FdcCycles -= 4 * FDC_DELAY_CYCLE_MFM_BYTE; /* Correct delay to point to $A1 $A1 $A1 $FE */ ! 1555: ! 1556: //fprintf ( stderr , "fdc bytes next sector pos=%d delay=%d maxsr=%d nextsr=%d\n" , CurrentPos_FdcCycles, Delay_FdcCycles, pStxTrack->SectorsCount, STX_State.NextSectorStruct_Nbr ); ! 1557: return Delay_FdcCycles; ! 1558: } ! 1559: ! 1560: ! 1561: ! 1562: /*-----------------------------------------------------------------------*/ ! 1563: /** ! 1564: * Return the value of the track number in the next ID field set by ! 1565: * FDC_NextSectorID_FdcCycles_STX. ! 1566: */ ! 1567: extern Uint8 FDC_NextSectorID_TR_STX ( void ) ! 1568: { ! 1569: return STX_State.NextSector_ID_Field_TR; ! 1570: } ! 1571: ! 1572: ! 1573: /*-----------------------------------------------------------------------*/ ! 1574: /** ! 1575: * Return the value of the sector number in the next ID field set by ! 1576: * FDC_NextSectorID_FdcCycles_STX. ! 1577: */ ! 1578: extern Uint8 FDC_NextSectorID_SR_STX ( void ) ! 1579: { ! 1580: return STX_State.NextSector_ID_Field_SR; ! 1581: } ! 1582: ! 1583: ! 1584: /*-----------------------------------------------------------------------*/ ! 1585: /** ! 1586: * Return the value of the sector's length in the next ID field set by ! 1587: * FDC_NextSectorID_FdcCycles_STX. ! 1588: */ ! 1589: extern Uint8 FDC_NextSectorID_LEN_STX ( void ) ! 1590: { ! 1591: return STX_State.NextSector_ID_Field_LEN; ! 1592: } ! 1593: ! 1594: ! 1595: /*-----------------------------------------------------------------------*/ ! 1596: /** ! 1597: * Return the status of the CRC in the next ID field set by ! 1598: * FDC_NextSectorID_FdcCycles_STX. ! 1599: * If '0', CRC is bad, else CRC is OK ! 1600: */ ! 1601: extern Uint8 FDC_NextSectorID_CRC_OK_STX ( void ) ! 1602: { ! 1603: return STX_State.NextSector_ID_Field_CRC_OK; ! 1604: } ! 1605: ! 1606: ! 1607: /*-----------------------------------------------------------------------*/ ! 1608: /** ! 1609: * Read a sector from a floppy image in STX format (used in type II command) ! 1610: * We return the sector NextSectorStruct_Nbr, whose value was set ! 1611: * by the latest call to FDC_NextSectorID_FdcCycles_STX ! 1612: * Each byte of the sector is added to the FDC buffer with a default timing ! 1613: * (32 microsec) or a variable timing, depending on the sector's flags. ! 1614: * Some sectors can also contains "fuzzy" bits. ! 1615: * Special care must be taken to compute the timing of each byte, which can ! 1616: * be a decimal value and must be rounded to the best possible integer. ! 1617: * ! 1618: * If the sector's data were changed by a 'write sector' command, then we assume ! 1619: * a sector with no fuzzy byte and standard timings. ! 1620: * ! 1621: * Return RNF if sector was not found, else return CRC and RECORD_TYPE values ! 1622: * for the status register. ! 1623: */ ! 1624: extern Uint8 FDC_ReadSector_STX ( Uint8 Drive , Uint8 Track , Uint8 Sector , Uint8 Side , int *pSectorSize ) ! 1625: { ! 1626: STX_SECTOR_STRUCT *pStxSector; ! 1627: int i; ! 1628: Uint8 Byte; ! 1629: Uint16 Timing; ! 1630: Uint32 Sector_ReadTime; ! 1631: double Total_cur; /* To compute closest integer timings for each byte */ ! 1632: double Total_prev; ! 1633: Uint8 *pSector_WriteData; ! 1634: ! 1635: pStxSector = STX_FindSector ( Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1636: if ( pStxSector == NULL ) ! 1637: { ! 1638: fprintf ( stderr , "FDC_ReadSector_STX drive=%d track=%d side=%d sector=%d returns null !\n" , ! 1639: Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1640: return STX_SECTOR_FLAG_RNF; /* Should not happen if FDC_NextSectorID_FdcCycles_STX succeeded before */ ! 1641: } ! 1642: ! 1643: /* If RNF is set, return FDC_STR_BIT_RNF */ ! 1644: if ( pStxSector->FDC_Status & STX_SECTOR_FLAG_RNF ) ! 1645: return STX_SECTOR_FLAG_RNF; /* RNF in FDC's status register */ ! 1646: ! 1647: *pSectorSize = pStxSector->SectorSize; ! 1648: Sector_ReadTime = pStxSector->ReadTime; ! 1649: ! 1650: /* Check if this sector was changed by a 'write sector' command */ ! 1651: /* If so, we use this recent buffer instead of the original STX content */ ! 1652: if (STX_SaveStruct[Drive].SaveSectorsCount > 0 && pStxSector->SaveSectorIndex >= 0) ! 1653: { ! 1654: pSector_WriteData = STX_SaveStruct[ Drive ].pSaveSectorsStruct[ pStxSector->SaveSectorIndex ].pData; ! 1655: Sector_ReadTime = 0; /* Standard timings */ ! 1656: ! 1657: LOG_TRACE(TRACE_FDC, "fdc stx read sector drive=%d track=%d sect=%d side=%d using saved sector=%d\n" , ! 1658: Drive, Track, Sector, Side , pStxSector->SaveSectorIndex ); ! 1659: } ! 1660: else ! 1661: pSector_WriteData = NULL; ! 1662: ! 1663: if ( Sector_ReadTime == 0 ) /* Sector has a standard delay (32 us per byte) */ ! 1664: Sector_ReadTime = 32 * pStxSector->SectorSize; /* Use the real standard value instead of 0 */ ! 1665: Sector_ReadTime *= 8; /* Convert delay in us to a number of FDC cycles at 8 MHz */ ! 1666: ! 1667: Total_prev = 0; ! 1668: for ( i=0 ; i<pStxSector->SectorSize ; i++ ) ! 1669: { ! 1670: /* Get the value of each byte, with possible fuzzy bits */ ! 1671: if ( pSector_WriteData == NULL ) /* Use original STX content */ ! 1672: { ! 1673: Byte = pStxSector->pData[ i ]; ! 1674: if ( pStxSector->pFuzzyData ) ! 1675: Byte = ( Byte & pStxSector->pFuzzyData[ i ] ) | ( rand() & ~pStxSector->pFuzzyData[ i ] ); ! 1676: } ! 1677: ! 1678: else /* Use data from 'write sector' */ ! 1679: Byte = pSector_WriteData[ i ]; ! 1680: ! 1681: /* Compute the timing in FDC cycles to transfer this byte */ ! 1682: if ( ( pStxSector->pTimingData ) /* Specific timing for each block of 16 bytes */ ! 1683: && ( pSector_WriteData == NULL ) ) ! 1684: { ! 1685: Timing = ( pStxSector->pTimingData[ ( i>>4 ) * 2 ] << 8 ) ! 1686: + pStxSector->pTimingData[ ( i>>4 ) * 2 + 1 ]; /* Get big endian timing for this block of 16 bytes */ ! 1687: ! 1688: /* [NP] Formula to convert timing data comes from Pasti.prg 0.4b : */ ! 1689: /* 1 unit of timing = 32 FDC cycles at 8 MHz + 28 cycles to complete each block of 16 bytes */ ! 1690: Timing = Timing * 32 + 28; ! 1691: ! 1692: if ( i % 16 == 0 ) Total_prev = 0; /* New block of 16 bytes */ ! 1693: Total_cur = ( (double)Timing * ( ( i % 16 ) + 1 ) ) / 16; ! 1694: Timing = rint ( Total_cur - Total_prev ); ! 1695: Total_prev += Timing; ! 1696: } ! 1697: else /* Specific timing in us for the whole sector */ ! 1698: { ! 1699: Total_cur = ( (double)Sector_ReadTime * ( i+1 ) ) / pStxSector->SectorSize; ! 1700: Timing = rint ( Total_cur - Total_prev ); ! 1701: Total_prev += Timing; ! 1702: } ! 1703: ! 1704: /* Add the Byte to the buffer, Timing should be a number of FDC cycles at 8 MHz */ ! 1705: FDC_Buffer_Add_Timing ( Byte , Timing ); ! 1706: } ! 1707: ! 1708: /* Return only bits 3 and 5 of the FDC_Status */ ! 1709: return pStxSector->FDC_Status & ( STX_SECTOR_FLAG_CRC | STX_SECTOR_FLAG_RECORD_TYPE ); ! 1710: } ! 1711: ! 1712: ! 1713: /*-----------------------------------------------------------------------*/ ! 1714: /** ! 1715: * Write a sector to a floppy image in STX format (used in type II command) ! 1716: * ! 1717: * STX format doesn't support write command. For each 'write sector' we ! 1718: * store the sector data in a dedicated buffer STX_SaveStruct[].pSaveSectorsStruct. ! 1719: * When the sector is read later, we return the data from STX_SaveStruct[].pSaveSectorsStruct ! 1720: * instead of returning the data from the original STX file. ! 1721: * ! 1722: * We only allow writing for sectors whose ID field has a correct CRC and ! 1723: * where RNF is not set. ! 1724: * Any valid size can be written : 128, 256, 512 or 1024 bytes ! 1725: * ! 1726: * NOTE : data will saved in memory snapshot, as well as in an additional ! 1727: * file with the extension .wd1772. ! 1728: * ! 1729: * Return RNF if sector was not found or CRC if ID field has a CRC error. ! 1730: * Return 0 if OK. ! 1731: */ ! 1732: extern Uint8 FDC_WriteSector_STX ( Uint8 Drive , Uint8 Track , Uint8 Sector , Uint8 Side , int SectorSize ) ! 1733: { ! 1734: STX_SECTOR_STRUCT *pStxSector; ! 1735: int i; ! 1736: Uint8 *pSector_WriteData; ! 1737: void *pNewBuf; ! 1738: STX_SAVE_SECTOR_STRUCT *pStxSaveSector; ! 1739: ! 1740: pStxSector = STX_FindSector ( Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1741: if ( pStxSector == NULL ) ! 1742: { ! 1743: fprintf ( stderr , "FDC_WriteSector_STX drive=%d track=%d side=%d sector=%d returns null !\n" , ! 1744: Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1745: return STX_SECTOR_FLAG_RNF; /* Should not happen if FDC_NextSectorID_FdcCycles_STX succeeded before */ ! 1746: } ! 1747: ! 1748: /* If RNF is set, return FDC_STR_BIT_RNF */ ! 1749: if ( pStxSector->FDC_Status & STX_SECTOR_FLAG_RNF ) ! 1750: return STX_SECTOR_FLAG_RNF; /* RNF in FDC's status register */ ! 1751: ! 1752: /* If CRC is set, return FDC_STR_BIT_RNF */ ! 1753: if ( pStxSector->FDC_Status & STX_SECTOR_FLAG_CRC ) ! 1754: return STX_SECTOR_FLAG_CRC; /* CRC in FDC's status register */ ! 1755: ! 1756: ! 1757: /* Check if this sector was already changed by a 'write sector' command */ ! 1758: /* If so, we use the same buffer. Else we alloc a new buffer for this sector */ ! 1759: if ( pStxSector->SaveSectorIndex < 0 ) ! 1760: { ! 1761: //fprintf ( stderr , "realloc\n" ); ! 1762: /* Increase save buffer by 1 */ ! 1763: pNewBuf = realloc ( STX_SaveStruct[ Drive ].pSaveSectorsStruct , ! 1764: ( STX_SaveStruct[ Drive ].SaveSectorsCount + 1 ) * sizeof ( STX_SAVE_SECTOR_STRUCT ) ); ! 1765: if ( pNewBuf == NULL ) ! 1766: { ! 1767: fprintf ( stderr , "FDC_WriteSector_STX drive=%d track=%d side=%d sector=%d realloc error !\n" , ! 1768: Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1769: return STX_SECTOR_FLAG_RNF; ! 1770: } ! 1771: ! 1772: /* Save the new buffer values */ ! 1773: STX_SaveStruct[ Drive ].pSaveSectorsStruct = (STX_SAVE_SECTOR_STRUCT *) pNewBuf;; ! 1774: STX_SaveStruct[ Drive ].SaveSectorsCount++; ! 1775: ! 1776: /* Create the new entry in pSaveSectorsStruct */ ! 1777: pNewBuf = malloc ( SectorSize ); ! 1778: if ( pNewBuf == NULL ) ! 1779: { ! 1780: fprintf ( stderr , "FDC_WriteSector_STX drive=%d track=%d side=%d sector=%d malloc error !\n" , ! 1781: Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1782: return STX_SECTOR_FLAG_RNF; ! 1783: } ! 1784: ! 1785: pStxSector->SaveSectorIndex = STX_SaveStruct[ Drive ].SaveSectorsCount - 1; ! 1786: ! 1787: /* Fill the new SaveSectorStruct. We copy some of the original sector's values */ ! 1788: /* in the saved sector */ ! 1789: pStxSaveSector = &STX_SaveStruct[ Drive ].pSaveSectorsStruct[ pStxSector->SaveSectorIndex ]; ! 1790: ! 1791: pStxSaveSector->Track = Track; ! 1792: pStxSaveSector->Side = Side; ! 1793: pStxSaveSector->BitPosition = pStxSector->BitPosition; ! 1794: pStxSaveSector->ID_Track = pStxSector->ID_Track; ! 1795: pStxSaveSector->ID_Head = pStxSector->ID_Head; ! 1796: pStxSaveSector->ID_Sector = pStxSector->ID_Sector; ! 1797: pStxSaveSector->ID_Size = pStxSector->ID_Size; ! 1798: pStxSaveSector->ID_CRC = pStxSector->ID_CRC; ! 1799: ! 1800: pStxSaveSector->SectorSize = SectorSize; ! 1801: pStxSaveSector->pData = (Uint8 *) pNewBuf; ! 1802: ! 1803: pStxSaveSector->StructIsUsed = 1; ! 1804: } ! 1805: ! 1806: pSector_WriteData = STX_SaveStruct[ Drive ].pSaveSectorsStruct[ pStxSector->SaveSectorIndex ].pData; ! 1807: ! 1808: /* Get the sector's data (ignore timings) */ ! 1809: for ( i=0 ; i<SectorSize ; i++ ) ! 1810: pSector_WriteData[ i ] = FDC_Buffer_Read_Byte_pos ( i ); ! 1811: ! 1812: //fprintf ( stderr , "write drive=%d track=%d side=%d sector=%d size=%d index=%d\n", Drive, Track, Side, Sector, SectorSize , pStxSector->SaveSectorIndex ); ! 1813: //Str_Dump_Hex_Ascii ( (char *) pSector_WriteData, SectorSize, 16, "" , stderr ); ! 1814: ! 1815: /* Warn that 'write sector' data will be lost or saved (if zipped or not) */ ! 1816: if ( STX_State.ImageBuffer[ Drive ]->WarnedWriteSector == false ) ! 1817: { ! 1818: if ( File_DoesFileExtensionMatch ( EmulationDrives[ Drive ].sFileName , ".zip" ) ) ! 1819: Log_AlertDlg ( LOG_INFO , "WARNING : can't save changes made with 'write sector' to an STX disk inside a zip file" ); ! 1820: else ! 1821: Log_AlertDlg ( LOG_INFO , "Changes made with 'write sector' to an STX disk will be saved into an additional .wd1772 file" ); ! 1822: STX_State.ImageBuffer[ Drive ]->WarnedWriteSector = true; ! 1823: } ! 1824: ! 1825: ! 1826: /* No error */ ! 1827: EmulationDrives[Drive].bContentsChanged = true; ! 1828: return 0; ! 1829: } ! 1830: ! 1831: ! 1832: /*-----------------------------------------------------------------------*/ ! 1833: /** ! 1834: * Read an address field from a floppy image in STX format (used in type III command) ! 1835: * We return the address field NextSectorStruct_Nbr, whose value was set ! 1836: * by the latest call to FDC_NextSectorID_FdcCycles_STX ! 1837: * Each byte of the ID field is added to the FDC buffer with a default timing ! 1838: * (32 microsec) ! 1839: * Return 0 if OK, or a CRC error ! 1840: */ ! 1841: extern Uint8 FDC_ReadAddress_STX ( Uint8 Drive , Uint8 Track , Uint8 Sector , Uint8 Side ) ! 1842: { ! 1843: STX_SECTOR_STRUCT *pStxSector; ! 1844: ! 1845: pStxSector = STX_FindSector ( Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1846: if ( pStxSector == NULL ) ! 1847: { ! 1848: fprintf ( stderr , "FDC_ReadAddress_STX drive=%d track=%d side=%d sector=%d returns null !\n" , ! 1849: Drive , Track , Side , STX_State.NextSectorStruct_Nbr ); ! 1850: return STX_SECTOR_FLAG_RNF; /* Should not happen if FDC_NextSectorID_FdcCycles_STX succeeded before */ ! 1851: } ! 1852: ! 1853: FDC_Buffer_Add ( pStxSector->ID_Track ); ! 1854: FDC_Buffer_Add ( pStxSector->ID_Head ); ! 1855: FDC_Buffer_Add ( pStxSector->ID_Sector ); ! 1856: FDC_Buffer_Add ( pStxSector->ID_Size ); ! 1857: FDC_Buffer_Add ( pStxSector->ID_CRC >> 8 ); ! 1858: FDC_Buffer_Add ( pStxSector->ID_CRC & 0xff ); ! 1859: ! 1860: /* If RNF is set and CRC error is set, then this ID field has a CRC error */ ! 1861: if ( ( pStxSector->FDC_Status & STX_SECTOR_FLAG_RNF ) && ( pStxSector->FDC_Status & STX_SECTOR_FLAG_CRC ) ) ! 1862: return STX_SECTOR_FLAG_CRC; ! 1863: ! 1864: return 0; /* No error */ ! 1865: } ! 1866: ! 1867: ! 1868: /*-----------------------------------------------------------------------*/ ! 1869: /** ! 1870: * Read a track from a floppy image in STX format (used in type III command) ! 1871: * This function is called after an index pulse was encountered, and it will ! 1872: * always succeeds and fill the track buffer. ! 1873: * If the Track/Side infos exist in the STX image, then the corresponding ! 1874: * bytes from the track's image are returned. ! 1875: * If these Track/Side infos don't exist, we return some random bytes ! 1876: * (empty / not formatted track). ! 1877: * If the Track/Side infos exist but there's no track's image, then we build ! 1878: * a standard track by using the available sectors and standard GAP values. ! 1879: * Return 0 if OK ! 1880: */ ! 1881: extern Uint8 FDC_ReadTrack_STX ( Uint8 Drive , Uint8 Track , Uint8 Side ) ! 1882: { ! 1883: STX_TRACK_STRUCT *pStxTrack; ! 1884: STX_SECTOR_STRUCT *pStxSector; ! 1885: int i; ! 1886: Uint16 Timing; ! 1887: Uint32 Track_ReadTime; ! 1888: double Total_cur; /* To compute closest integer timings for each byte */ ! 1889: double Total_prev; ! 1890: int TrackSize; ! 1891: int Sector; ! 1892: int SectorSize; ! 1893: Uint16 CRC; ! 1894: Uint8 *pData; ! 1895: Uint8 Byte; ! 1896: ! 1897: if ( STX_State.ImageBuffer[ Drive ] == NULL ) ! 1898: { ! 1899: fprintf ( stderr , "FDC_ReadTrack_STX drive=%d track=%d side=%d, no image buffer !\n" , Drive , Track , Side ); ! 1900: return STX_SECTOR_FLAG_RNF; /* Should not happen, just in case of a bug */ ! 1901: } ! 1902: ! 1903: pStxTrack = STX_FindTrack ( Drive , Track , Side ); ! 1904: if ( pStxTrack == NULL ) /* Track/Side don't exist in this STX image */ ! 1905: { ! 1906: fprintf ( stderr , "fdc stx : track info not found for read track drive=%d track=%d side=%d, returning random bytes\n" , Drive , Track , Side ); ! 1907: for ( i=0 ; i<FDC_GetBytesPerTrack ( Drive ) ; i++ ) ! 1908: FDC_Buffer_Add ( rand() & 0xff ); /* Fill the track buffer with random bytes */ ! 1909: return 0; ! 1910: } ! 1911: ! 1912: /* If the Track block contains a complete dump of the track image, use it directly */ ! 1913: /* The timing for each byte is the average timing based on TrackImageSize */ ! 1914: if ( pStxTrack->pTrackImageData ) ! 1915: { ! 1916: Track_ReadTime = 8000000 / 5; /* 300 RPM, gives 5 RPS and 1600000 cycles per revolution at 8 MHz */ ! 1917: Total_prev = 0; ! 1918: for ( i=0 ; i<pStxTrack->TrackImageSize ; i++ ) ! 1919: { ! 1920: Total_cur = ( (double)Track_ReadTime * ( i+1 ) ) / pStxTrack->TrackImageSize; ! 1921: Timing = rint ( Total_cur - Total_prev ); ! 1922: Total_prev += Timing; ! 1923: /* Add each byte to the buffer, Timing should be a number of FDC cycles at 8 MHz */ ! 1924: FDC_Buffer_Add_Timing ( pStxTrack->pTrackImageData[ i ] , Timing ); ! 1925: } ! 1926: } ! 1927: ! 1928: /* If the track block doesn't contain a dump of the track image, we must build a track */ ! 1929: /* using the sector blocks and some standard GAP values */ ! 1930: /* [NP] NOTE : we build a track of pStxTrack->MFMSize bytes, as this seems to always be != 0 */ ! 1931: /* even for empty / not formatted track */ ! 1932: /* [NP] NOTE : instead of using standard GAP values, we could compute GAP based on pStxSector->BitPosition */ ! 1933: /* but this seems unnecessary, as a track image would certainly be present if precise GAP values */ ! 1934: /* were required */ ! 1935: else ! 1936: { ! 1937: TrackSize = pStxTrack->MFMSize; ! 1938: if ( ( pStxTrack->Flags & STX_TRACK_FLAG_SECTOR_BLOCK ) == 0 ) ! 1939: TrackSize /= 8; /* When the track contains only sector data, MFMSize is in bits */ ! 1940: ! 1941: /* If there's no image for this track, and no sector as well, then track is empty / not formatted */ ! 1942: if ( pStxTrack->SectorsCount == 0 ) ! 1943: { ! 1944: fprintf ( stderr , "fdc stx : no track image and no sector for read track drive=%d track=%d side=%d, building an unformatted track\n" , Drive , Track , Side ); ! 1945: for ( i=0 ; i<TrackSize ; i++ ) ! 1946: FDC_Buffer_Add ( rand() & 0xff ); /* Fill the track buffer with random bytes */ ! 1947: return 0; ! 1948: } ! 1949: ! 1950: /* Use the available sectors and add some default GAPs to build the track */ ! 1951: fprintf ( stderr , "fdc stx : no track image for read track drive=%d track=%d side=%d, building a standard track\n" , Drive , Track , Side ); ! 1952: ! 1953: for ( i=0 ; i<FDC_TRACK_LAYOUT_STANDARD_GAP1 ; i++ ) /* GAP1 */ ! 1954: FDC_Buffer_Add ( 0x4e ); ! 1955: ! 1956: for ( Sector=0 ; Sector < pStxTrack->SectorsCount ; Sector++ ) ! 1957: { ! 1958: pStxSector = &(pStxTrack->pSectorsStruct[ Sector ]); ! 1959: SectorSize = pStxSector->SectorSize; ! 1960: ! 1961: /* Check that the data+GAPs for this sector will not be above track's length */ ! 1962: /* (in case we build a track with a high / non standard number of sectors) */ ! 1963: if ( FDC_Buffer_Get_Size () + SectorSize + FDC_TRACK_LAYOUT_STANDARD_GAP2 + 10 + FDC_TRACK_LAYOUT_STANDARD_GAP3a ! 1964: + FDC_TRACK_LAYOUT_STANDARD_GAP3b + 4 + 2 + FDC_TRACK_LAYOUT_STANDARD_GAP4 >= TrackSize ) ! 1965: { ! 1966: fprintf ( stderr , "fdc stx : no track image for read track drive=%d track=%d side=%d, too many data sector=%d\n" , Drive , Track , Side , Sector ); ! 1967: break; /* Exit the loop and fill the rest of the track */ ! 1968: } ! 1969: ! 1970: for ( i=0 ; i<FDC_TRACK_LAYOUT_STANDARD_GAP2 ; i++ ) /* GAP2 */ ! 1971: FDC_Buffer_Add ( 0x00 ); ! 1972: ! 1973: /* Add the ID field for the sector */ ! 1974: for ( i=0 ; i<3 ; i++ ) ! 1975: FDC_Buffer_Add ( 0xa1 ); /* SYNC (write $F5) */ ! 1976: FDC_Buffer_Add ( 0xfe ); /* Index Address Mark */ ! 1977: FDC_Buffer_Add ( pStxSector->ID_Track ); ! 1978: FDC_Buffer_Add ( pStxSector->ID_Head ); ! 1979: FDC_Buffer_Add ( pStxSector->ID_Sector ); ! 1980: FDC_Buffer_Add ( pStxSector->ID_Size ); ! 1981: FDC_Buffer_Add ( pStxSector->ID_CRC >> 8 ); ! 1982: FDC_Buffer_Add ( pStxSector->ID_CRC & 0xff ); ! 1983: ! 1984: for ( i=0 ; i<FDC_TRACK_LAYOUT_STANDARD_GAP3a ; i++ ) /* GAP3a */ ! 1985: FDC_Buffer_Add ( 0x4e ); ! 1986: for ( i=0 ; i<FDC_TRACK_LAYOUT_STANDARD_GAP3b ; i++ ) /* GAP3b */ ! 1987: FDC_Buffer_Add ( 0x00 ); ! 1988: ! 1989: /* Add the data for the sector + build the CRC */ ! 1990: crc16_reset ( &CRC ); ! 1991: for ( i=0 ; i<3 ; i++ ) ! 1992: { ! 1993: FDC_Buffer_Add ( 0xa1 ); /* SYNC (write $F5) */ ! 1994: crc16_add_byte ( &CRC , 0xa1 ); ! 1995: } ! 1996: ! 1997: FDC_Buffer_Add ( 0xfb ); /* Data Address Mark */ ! 1998: crc16_add_byte ( &CRC , 0xfb ); ! 1999: ! 2000: /* [NP] NOTE : when building the sector, we assume there's no specific timing or fuzzy bytes */ ! 2001: /* If it was not the case, there would certainly be a real track image (and STX format doesn't */ ! 2002: /* support fuzzy bytes or specific timing for a track image anyway) */ ! 2003: /* If the sector was changed by a 'write sector' command, we use the data from pSaveSectorsStruct */ ! 2004: if ( pStxSector->SaveSectorIndex < 0 ) /* Use original data from the STX */ ! 2005: pData = pStxSector->pData; ! 2006: else /* Use data from the 'write sector' */ ! 2007: pData = STX_SaveStruct[ Drive ].pSaveSectorsStruct[ pStxSector->SaveSectorIndex ].pData; ! 2008: ! 2009: for ( i=0 ; i<SectorSize ; i++ ) ! 2010: { ! 2011: Byte = pData[ i ]; ! 2012: FDC_Buffer_Add ( Byte ); ! 2013: crc16_add_byte ( &CRC , Byte ); ! 2014: } ! 2015: ! 2016: FDC_Buffer_Add ( CRC >> 8 ); /* CRC1 (write $F7) */ ! 2017: FDC_Buffer_Add ( CRC & 0xff ); /* CRC2 */ ! 2018: ! 2019: for ( i=0 ; i<FDC_TRACK_LAYOUT_STANDARD_GAP4 ; i++ ) /* GAP4 */ ! 2020: FDC_Buffer_Add ( 0x4e ); ! 2021: } ! 2022: ! 2023: while ( FDC_Buffer_Get_Size () < TrackSize ) /* Complete the track buffer */ ! 2024: FDC_Buffer_Add ( 0x4e ); /* GAP5 */ ! 2025: } ! 2026: ! 2027: return 0; /* No error */ ! 2028: } ! 2029: ! 2030: ! 2031: /*-----------------------------------------------------------------------*/ ! 2032: /** ! 2033: * Write a track to a floppy image in STX format (used in type III command) ! 2034: * ! 2035: * STX format doesn't support write command. For each 'write track' we ! 2036: * store the track data in a dedicated buffer STX_SaveStruct[].pSaveTracksStruct. ! 2037: * When the track is read later, we return the data from STX_SaveStruct[].pSaveTracksStruct ! 2038: * instead of returning the data from the original STX file. ! 2039: * ! 2040: * NOTE : data will saved in memory snapshot, as well as in an additional ! 2041: * file with the extension .wd1772. ! 2042: * ! 2043: * Return 0 if track was written without error, or LOST_DATA if an error occurred ! 2044: */ ! 2045: extern Uint8 FDC_WriteTrack_STX ( Uint8 Drive , Uint8 Track , Uint8 Side , int TrackSize ) ! 2046: { ! 2047: STX_TRACK_STRUCT *pStxTrack; ! 2048: int i; ! 2049: Uint8 *pTrack_DataWrite; ! 2050: void *pNewBuf; ! 2051: STX_SAVE_TRACK_STRUCT *pStxSaveTrack; ! 2052: int Sector; ! 2053: ! 2054: pStxTrack = STX_FindTrack ( Drive , Track , Side ); ! 2055: if ( pStxTrack == NULL ) ! 2056: { ! 2057: fprintf ( stderr , "FDC_WriteTrack_STX drive=%d track=%d side=%d returns null !\n" , ! 2058: Drive , Track , Side ); ! 2059: return STX_SECTOR_FLAG_LOST_DATA; ! 2060: } ! 2061: ! 2062: /* Check if this track was already changed by a 'write track' command */ ! 2063: /* If so, we use the same structure. Else we alloc a new structure for this track */ ! 2064: if ( pStxTrack->SaveTrackIndex < 0 ) ! 2065: { ! 2066: //fprintf ( stderr , "realloc\n" ); ! 2067: /* Increase save buffer by 1 */ ! 2068: pNewBuf = realloc ( STX_SaveStruct[ Drive ].pSaveTracksStruct , ! 2069: ( STX_SaveStruct[ Drive ].SaveTracksCount + 1 ) * sizeof ( STX_SAVE_TRACK_STRUCT ) ); ! 2070: if ( pNewBuf == NULL ) ! 2071: { ! 2072: fprintf ( stderr , "FDC_WriteTrack_STX drive=%d track=%d side=%d realloc error !\n" , ! 2073: Drive , Track , Side ); ! 2074: return STX_SECTOR_FLAG_LOST_DATA; ! 2075: } ! 2076: ! 2077: /* Save the new buffer values */ ! 2078: STX_SaveStruct[ Drive ].pSaveTracksStruct = (STX_SAVE_TRACK_STRUCT *) pNewBuf;; ! 2079: STX_SaveStruct[ Drive ].SaveTracksCount++; ! 2080: ! 2081: pStxTrack->SaveTrackIndex = STX_SaveStruct[ Drive ].SaveTracksCount - 1; ! 2082: } ! 2083: ! 2084: /* Use the same structure : free previous DataWrite buffer */ ! 2085: else ! 2086: { ! 2087: free ( STX_SaveStruct[ Drive ].pSaveTracksStruct[ pStxTrack->SaveTrackIndex ].pDataWrite ); ! 2088: STX_SaveStruct[ Drive ].pSaveTracksStruct[ pStxTrack->SaveTrackIndex ].pDataWrite = NULL; ! 2089: /* TODO : also free pDataRead */ ! 2090: } ! 2091: ! 2092: /* Create the new DataWrite buffer in pSaveTracksStruct */ ! 2093: pNewBuf = malloc ( TrackSize ); ! 2094: if ( pNewBuf == NULL ) ! 2095: { ! 2096: fprintf ( stderr , "FDC_WriteTrack_STX drive=%d track=%d side=%d malloc error !\n" , ! 2097: Drive , Track , Side ); ! 2098: return STX_SECTOR_FLAG_LOST_DATA; ! 2099: } ! 2100: ! 2101: /* Fill the new SaveTrackStruct */ ! 2102: pStxSaveTrack = &STX_SaveStruct[ Drive ].pSaveTracksStruct[ pStxTrack->SaveTrackIndex ]; ! 2103: ! 2104: pStxSaveTrack->Track = Track; ! 2105: pStxSaveTrack->Side = Side; ! 2106: ! 2107: pStxSaveTrack->TrackSizeWrite = TrackSize; ! 2108: pStxSaveTrack->pDataWrite = (Uint8 *) pNewBuf; ! 2109: ! 2110: ! 2111: /* Get the track's data (ignore timings) */ ! 2112: pTrack_DataWrite = STX_SaveStruct[ Drive ].pSaveTracksStruct[ pStxTrack->SaveTrackIndex ].pDataWrite; ! 2113: ! 2114: for ( i=0 ; i<pStxSaveTrack->TrackSizeWrite ; i++ ) ! 2115: pTrack_DataWrite[ i ] = FDC_Buffer_Read_Byte_pos ( i ); ! 2116: ! 2117: //fprintf ( stderr , "write drive=%d track=%d side=%d size=%d index=%d\n", Drive, Track, Side, pStxSaveTrack->TrackSizeWrite , pStxTrack->SaveTrackIndex ); ! 2118: //Str_Dump_Hex_Ascii ( (char *) pTrack_DataWrite, pStxSaveTrack->TrackSizeWrite, 16, "" , stderr ); ! 2119: ! 2120: // TODO : convert pDataWrite into pDataRead ! 2121: pStxSaveTrack->TrackSizeRead = 0; /* TODO : compute interpreted track */ ! 2122: pStxSaveTrack->pDataRead = NULL; /* TODO : compute interpreted track */ ! 2123: ! 2124: ! 2125: /* If some sectors were already saved for that track, we must remove them */ ! 2126: /* as the 'write track' takes precedence over the previous 'write sector' */ ! 2127: for ( Sector=0 ; Sector < pStxTrack->SectorsCount ; Sector++ ) ! 2128: { ! 2129: if ( pStxTrack->pSectorsStruct[ Sector ].SaveSectorIndex >= 0 ) ! 2130: { ! 2131: STX_FreeSaveSectorsStruct ( STX_SaveStruct[ Drive ].pSaveSectorsStruct , ! 2132: pStxTrack->pSectorsStruct[ Sector ].SaveSectorIndex ); ! 2133: pStxTrack->pSectorsStruct[ Sector ].SaveSectorIndex = -1; ! 2134: } ! 2135: } ! 2136: ! 2137: ! 2138: /* Warn that 'write track' data will be lost or saved (if zipped or not) */ ! 2139: if ( STX_State.ImageBuffer[ Drive ]->WarnedWriteTrack == false ) ! 2140: { ! 2141: if ( File_DoesFileExtensionMatch ( EmulationDrives[ Drive ].sFileName , ".zip" ) ) ! 2142: Log_AlertDlg ( LOG_INFO , "WARNING : can't save changes made with 'write track' to an STX disk inside a zip file" ); ! 2143: else ! 2144: Log_AlertDlg ( LOG_INFO , "Changes made with 'write track' to an STX disk will be saved into an additional .wd1772 file" ); ! 2145: STX_State.ImageBuffer[ Drive ]->WarnedWriteTrack = true; ! 2146: } ! 2147: ! 2148: ! 2149: /* No error */ ! 2150: EmulationDrives[Drive].bContentsChanged = true; ! 2151: return 0; ! 2152: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.