![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to floppy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to floppy.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari
3:
4: This where we read/write sectors to/from the disc image buffers. NOTE these buffers are in
5: memory so we only need to write routines for the .ST format. When the buffer is to be
6: saved(ie eject disc) we save it back to the original file in the correct format(.ST or .MSA)
7:
8: There are some important notes about image accessing - as we use TOS and the FDC to access
9: the disc the boot-sector MUST be valid. Sometimes this is NOT the case! In these
10: situations we must guess at the disc format. Eg, some disc images have a a boot sector which
11: states single-sided, but the images have been created as double-sided. As sides are interleaved
12: we need to read the image as if it was double-sided. Also note that 'NumBytesPerSector' is
13: ALWAYS 512 bytes, even if the boot-sector states otherwise.
14: Also note that the (current)MAKEDISK utility does not set the correct boot sector structure
15: for a real ST(and also Hatari) to read it correctly. (PaCifiST will, however, read/write to
16: these images as it does not perform FDC access as on a real ST)
17: */
18:
19: #include "main.h"
20: #include "debug.h"
21: #include "dialog.h"
22: #include "errlog.h"
23: #include "file.h"
24: #include "floppy.h"
25: #include "memAlloc.h"
26: #include "memorySnapShot.h"
27: #include "misc.h"
28: #include "msa.h"
29: #include "st.h"
30: #include "statusBar.h"
31: #include "view.h"
32:
33:
34: EMULATION_DRIVE EmulationDrives[NUM_EMULATION_DRIVES]; /* Emulation drive details, eg FileName, Inserted, Changed etc... */
35: int nBootDrive=0; /* Drive A, default */
36:
37: /* Possible disc image file extensions to scan for */
38: char *pszDiscImageNameExts[] = {
39: ".msa",
40: ".st",
41: NULL
42: };
43:
44:
45: //-----------------------------------------------------------------------
46: /*
47: Initialize emulation floppy drives
48: */
49: void Floppy_Init(void)
50: {
51: int i;
52:
53: /* Clear drive structures */
54: for(i=0; i<NUM_EMULATION_DRIVES; i++) {
55: /* Clear */
56: Memory_Clear(&EmulationDrives[i],sizeof(EMULATION_DRIVE));
57: /* And allocate buffer */
58: EmulationDrives[i].pBuffer = (unsigned char *)Memory_Alloc(DRIVE_BUFFER_BYTES);
59: }
60: }
61:
62: //-----------------------------------------------------------------------
63: /*
64: UnInitialize drives
65: */
66: void Floppy_UnInit(void)
67: {
68: int i;
69:
70: // Free buffers used for emulation drives
71: for(i=0; i<NUM_EMULATION_DRIVES; i++) {
72: Memory_Free(EmulationDrives[i].pBuffer);
73: }
74: }
75:
76: //-----------------------------------------------------------------------
77: /*
78: Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
79: */
80: void Floppy_MemorySnapShot_Capture(BOOL bSave)
81: {
82: int i;
83:
84: // Save/Restore details
85: for(i=0; i<NUM_EMULATION_DRIVES; i++) {
86: MemorySnapShot_Store(EmulationDrives[i].pBuffer,DRIVE_BUFFER_BYTES);
87: MemorySnapShot_Store(EmulationDrives[i].szFileName,sizeof(EmulationDrives[i].szFileName));
88: MemorySnapShot_Store(&EmulationDrives[i].nImageBytes,sizeof(EmulationDrives[i].nImageBytes));
89: MemorySnapShot_Store(&EmulationDrives[i].bDiscInserted,sizeof(EmulationDrives[i].bDiscInserted));
90: MemorySnapShot_Store(&EmulationDrives[i].bMediaChanged,sizeof(EmulationDrives[i].bMediaChanged));
91: MemorySnapShot_Store(&EmulationDrives[i].bContentsChanged,sizeof(EmulationDrives[i].bContentsChanged));
92: MemorySnapShot_Store(&EmulationDrives[i].bOKToSave,sizeof(EmulationDrives[i].bOKToSave));
93: }
94: }
95:
96: //-----------------------------------------------------------------------
97: /*
98: Find which device to boot from
99: */
100: void Floppy_GetBootDrive(void)
101: {
102: /* FIXME */
103: /*
104: // If we've inserted a disc or not enabled boot from hard-drive, boot from the floppy drive
105: if ( (!ConfigureParams.HardDisc.bBootFromHardDisc) || (EmulationDrives[0].bDiscInserted) )
106: nBootDrive = 0; //Drive A
107: else
108: nBootDrive = 2; //Drive C
109: */
110: }
111:
112: //-----------------------------------------------------------------------
113: /*
114: Test disc image for valid boot-sector
115:
116: It has been noticed that some discs, eg blank images made by the (current)MakeDisk utility
117: fill in the boot-sector with incorrect information. Such images cannot be read correctly using
118: a real ST, and also Hatari. To try and prevent data loss, we check for this error and flag
119: the drive so the image will not be saved back to the file.
120: */
121: BOOL Floppy_IsBootSectorOK(int Drive)
122: {
123: unsigned char *pDiscBuffer;
124:
125: /* Does our drive have a disc in? */
126: if (EmulationDrives[Drive].bDiscInserted) {
127: pDiscBuffer = EmulationDrives[Drive].pBuffer;
128: /* Check SPC(byte 13) for !=0 value. If is '0', invalid image and Hatari won't be-able to read(nor will a real ST)! */
129: if (pDiscBuffer[13]!=0)
130: return(TRUE); /* Disc sector is OK! */
131: }
132:
133: return(FALSE); /* Bad sector */
134: }
135:
136: //-----------------------------------------------------------------------
137: /*
138: Try to create disc B filename, eg 'auto_100a' becomes 'auto_100b'
139: Return TRUE if think we should try!
140: */
141: BOOL Floppy_CreateDiscBFileName(char *pSrcFileName, char *pDestFileName)
142: {
143: /* FIXME */
144: /*
145: char szDrive[_MAX_DRIVE],szDir[_MAX_DIR],szName[_MAX_FNAME],szExt[_MAX_EXT];
146:
147: // So, first split name into parts
148: _splitpath(pSrcFileName,szDrive,szDir,szName,szExt);
149: // All OK?
150: if (strlen(szName)>0) {
151: // Now, did filename end with an 'A' or 'a'?
152: if ( (szName[strlen(szName)-1]=='A') || (szName[strlen(szName)-1]=='a') ) {
153: // Change 'A' to a 'B'
154: szName[strlen(szName)-1] = 'b';
155: // And re-build name into destination
156: _makepath(pDestFileName,szDrive,szDir,szName,szExt);
157: // Does file exist?
158: if (File_Exists(pDestFileName))
159: return(TRUE); // Try this
160: }
161: }
162: */
163: return(FALSE); // No, doesn't have disc B
164: }
165:
166: //-----------------------------------------------------------------------
167: /*
168: Insert disc into floppy drive
169: The WHOLE image is copied into our drive buffers, and uncompressed if necessary
170: */
171: BOOL Floppy_InsertDiscIntoDrive(int Drive, char *pszFileName)
172: {
173: char szDiscBFileName[MAX_FILENAME_LENGTH];
174: int nImageBytes=0;
175:
176: /* Eject disc, if one is inserted(don't inform user) */
177: Floppy_EjectDiscFromDrive(Drive,FALSE);
178:
179: /* See if file exists, and if not get correct extension */
180: File_FindPossibleExtFileName(pszFileName,pszDiscImageNameExts);
181:
182: /* Is .MSA or .ST image? */
183: if (File_FileNameIsMSA(pszFileName))
184: nImageBytes = MSA_ReadDisc(pszFileName,EmulationDrives[Drive].pBuffer);
185: else if (File_FileNameIsST(pszFileName))
186: nImageBytes = ST_ReadDisc(pszFileName,EmulationDrives[Drive].pBuffer);
187: /* Did load OK? */
188: if (nImageBytes!=0) {
189: /* Store filename and size */
190: strcpy(EmulationDrives[Drive].szFileName,pszFileName);
191: EmulationDrives[Drive].nImageBytes = nImageBytes;
192: /* And set drive states */
193: EmulationDrives[Drive].bDiscInserted = TRUE;
194: EmulationDrives[Drive].bContentsChanged = FALSE;
195: EmulationDrives[Drive].bMediaChanged = TRUE;
196: EmulationDrives[Drive].bOKToSave = Floppy_IsBootSectorOK(Drive);
197: }
198:
199: /* If we insert a disc into Drive A, should be try to put disc 2 into drive B? */
200: /* FIXME */
201: /*
202: if ( (Drive==0) && (ConfigureParams.DiscImage.bAutoInsertDiscB) ) {
203: strcpy(EmulationDrives[1].szFileName,"");
204: // Attempt to make up second filename, eg was 'auto_100a' to 'auto_100b'
205: if (Floppy_CreateDiscBFileName(pszFileName,szDiscBFileName)) {
206: // Put image into Drive B, clear out if fails
207: if (!Floppy_InsertDiscIntoDrive(1,szDiscBFileName))
208: strcpy(EmulationDrives[1].szFileName,"");
209: }
210: }
211: */
212: /* Return TRUE if loaded OK */
213: if (nImageBytes)
214: return(TRUE);
215: else
216: return(FALSE);
217: }
218:
219: //-----------------------------------------------------------------------
220: /*
221: Eject disc from floppy drive, save contents back to PCs hard-drive is has changed
222: */
223: void Floppy_EjectDiscFromDrive(int Drive,BOOL bInformUser)
224: {
225: char szString[256];
226:
227: /* Does our drive have a disc in? */
228: if (EmulationDrives[Drive].bDiscInserted) {
229: /* OK, has contents changed? If so, need to save */
230: if (EmulationDrives[Drive].bContentsChanged) {
231: /* Is OK to save image(if boot-sector is bad, don't allow a save) */
232: if (EmulationDrives[Drive].bOKToSave) {
233: /* Save as .MSA or .ST image? */
234: if (File_FileNameIsMSA(EmulationDrives[Drive].szFileName))
235: MSA_WriteDisc(EmulationDrives[Drive].szFileName,EmulationDrives[Drive].pBuffer,EmulationDrives[Drive].nImageBytes);
236: else if (File_FileNameIsST(EmulationDrives[Drive].szFileName))
237: ST_WriteDisc(EmulationDrives[Drive].szFileName,EmulationDrives[Drive].pBuffer,EmulationDrives[Drive].nImageBytes);
238: }
239: }
240:
241: /* Inform user that disc has been ejected! */
242: if (bInformUser) {
243: sprintf(szString,"Disc has been removed from Drive '%c'.",'A'+Drive);
244: /* FIXME */ // MessageBox(hWnd,szString,PROG_NAME,MB_OK | MB_ICONINFORMATION);
245: }
246: }
247:
248: /* Drive is now empty */
249: strcpy(EmulationDrives[Drive].szFileName,"");
250: EmulationDrives[Drive].nImageBytes = 0;
251: EmulationDrives[Drive].bDiscInserted = FALSE;
252: EmulationDrives[Drive].bContentsChanged = FALSE;
253: EmulationDrives[Drive].bOKToSave = FALSE;
254: }
255:
256: //-----------------------------------------------------------------------
257: /*
258: Eject all disc image from floppy drives - call when quit
259: */
260: void Floppy_EjectBothDrives(void)
261: {
262: /* Eject disc images from drives 'A' and 'B' */
263: Floppy_EjectDiscFromDrive(0,FALSE);
264: Floppy_EjectDiscFromDrive(1,FALSE);
265: }
266:
267: //-----------------------------------------------------------------------
268: /*
269: Double-check information read from boot-sector as this is sometimes found to be incorrect
270: The .ST image file should be divisible by the sector size & sectors per track
271: NOTE - Pass information from boot-sector to this function(if we can't decide we leave it alone)
272: */
273: void Floppy_DoubleCheckFormat(long DiscSize,unsigned short int *pnSides,unsigned short int *pnSectorsPerTrack)
274: {
275: int nSectorsPerTrack;
276: long TotalSectors;
277:
278: /* Now guess at number of sides */
279: if (DiscSize<(500*1024)) /* Is size is >500k assume 2 sides to disc! */
280: *pnSides = 1;
281: else
282: *pnSides = 2;
283:
284: /* And Sectors Per Track(always 512 bytes per sector) */
285: TotalSectors = DiscSize/512; /* # Sectors on disc image */
286: // Does this match up with what we've read from boot-sector?
287: nSectorsPerTrack = *pnSectorsPerTrack;
288: if (nSectorsPerTrack==0) /* Check valid, default to 9 */
289: nSectorsPerTrack = 9;
290: if ((TotalSectors%nSectorsPerTrack)!=0) {
291: /* No, we have an invalid boot-sector - re-calculate from disc size */
292: if ((TotalSectors%9)==0) /* Work in this order.... */
293: *pnSectorsPerTrack = 9;
294: else if ((TotalSectors%10)==0)
295: *pnSectorsPerTrack = 10;
296: else if ((TotalSectors%11)==0)
297: *pnSectorsPerTrack = 11;
298: else if ((TotalSectors%12)==0)
299: *pnSectorsPerTrack = 12;
300: }
301: /* else unknown, assume boot-sector is correct!!! */
302: }
303:
304: //-----------------------------------------------------------------------
305: /*
306: Find details of disc image. We need to do this via a function as sometimes the boot-block
307: is not actually correct with the image - some demos/game discs have incorrect bytes in the
308: boot sector and this attempts to find the correct values.
309: */
310: void Floppy_FindDiscDetails(unsigned char *pBuffer,int nImageBytes,unsigned short int *pnSectorsPerTrack,unsigned short int *pnSides)
311: {
312: unsigned char *pDiscBuffer;
313: unsigned short int nSectorsPerTrack=9,nSides=2;
314:
315: pDiscBuffer = pBuffer;
316: /* First do check to find number of sectors and bytes per sector */
317: nSectorsPerTrack = *(unsigned short int *)(pDiscBuffer+24); /* SPT */
318: nSides = *(unsigned short int *)(pDiscBuffer+26); /* SIDE */
319: /* Now double-check info as boot-sector may contain incorrect information, eg 'Eat.st' demo, or single/double sides */
320: Floppy_DoubleCheckFormat(nImageBytes,&nSides,&nSectorsPerTrack);
321:
322: /* And set values */
323: if (pnSectorsPerTrack)
324: *pnSectorsPerTrack = nSectorsPerTrack;
325: if (pnSides)
326: *pnSides = nSides;
327: }
328:
329: //-----------------------------------------------------------------------
330: /*
331: Read sectors from floppy disc image, return TRUE if all OK
332: NOTE Pass -ve as Count to read whole track
333: */
334: BOOL Floppy_ReadSectors(int Drive,char *pBuffer,unsigned short int Sector,unsigned short int Track,unsigned short int Side, short int Count, int *pnSectorsPerTrack)
335: {
336: unsigned char *pDiscBuffer;
337: unsigned short int nSectorsPerTrack,nSides,nBytesPerTrack;
338: long Offset;
339:
340: // Do we have a disc in our drive?
341: if (EmulationDrives[Drive].bDiscInserted) {
342: // Looks good
343: StatusBar_SetIcon(STATUS_ICON_FLOPPY,ICONSTATE_UPDATE);
344: pDiscBuffer = EmulationDrives[Drive].pBuffer;
345:
346: // Find #sides and #sectors per track
347: Floppy_FindDiscDetails(EmulationDrives[Drive].pBuffer,EmulationDrives[Drive].nImageBytes,&nSectorsPerTrack,&nSides);
348:
349: // Need to read whole track?
350: if (Count<0)
351: Count = nSectorsPerTrack;
352: // Write back number of sector per track
353: if (pnSectorsPerTrack)
354: *pnSectorsPerTrack = nSectorsPerTrack;
355:
356: // Debug check as if we read over the end of a track we read into side 2!
357: if (Count>nSectorsPerTrack) {
358: ErrLog_File("ERROR Floppy_ReadSectors reading over single track\n");
359: }
360:
361: // Seek to sector
362: nBytesPerTrack = NUMBYTESPERSECTOR*nSectorsPerTrack;
363: Offset = nBytesPerTrack*Side; // First seek to side
364: Offset += (nBytesPerTrack*nSides)*Track; // Then seek to track
365: Offset += (NUMBYTESPERSECTOR*(Sector-1)); // And finally to sector
366: // Read sectors (usually 512 bytes per sector)
367: memcpy(pBuffer,pDiscBuffer+Offset,(int)Count*NUMBYTESPERSECTOR);
368:
369: return(TRUE);
370: }
371:
372: return(FALSE);
373: }
374:
375: //-----------------------------------------------------------------------
376: /*
377: Write sectors from floppy disc image, return TRUE if all OK
378: NOTE Pass -ve as Count to write whole track
379: */
380: BOOL Floppy_WriteSectors(int Drive,char *pBuffer,unsigned short int Sector,unsigned short int Track,unsigned short int Side, short int Count, int *pnSectorsPerTrack)
381: {
382: unsigned char *pDiscBuffer;
383: unsigned short int nSectorsPerTrack,nSides,nBytesPerTrack;
384: long Offset;
385:
386: // Do we have a disc in our drive?
387: if (EmulationDrives[Drive].bDiscInserted) {
388: // Looks good
389: StatusBar_SetIcon(STATUS_ICON_FLOPPY,ICONSTATE_UPDATE);
390: pDiscBuffer = EmulationDrives[Drive].pBuffer;
391:
392: // Find #sides and #sectors per track
393: Floppy_FindDiscDetails(EmulationDrives[Drive].pBuffer,EmulationDrives[Drive].nImageBytes,&nSectorsPerTrack,&nSides);
394:
395: // Need to write whole track?
396: if (Count<0)
397: Count = nSectorsPerTrack;
398: // Write back number of sector per track
399: if (pnSectorsPerTrack)
400: *pnSectorsPerTrack = nSectorsPerTrack;
401:
402: // Debug check as if we write over the end of a track we write into side 2!
403: if (Count>nSectorsPerTrack) {
404: ErrLog_File("ERROR Floppy_WriteSectors reading over single track\n");
405: }
406:
407: // Seek to sector
408: nBytesPerTrack = NUMBYTESPERSECTOR*nSectorsPerTrack;
409: Offset = nBytesPerTrack*Side; // First seek to side
410: Offset += (nBytesPerTrack*nSides)*Track; // Then seek to track
411: Offset += (NUMBYTESPERSECTOR*(Sector-1)); // And finally to sector
412: // Write sectors (usually 512 bytes per sector)
413: memcpy(pDiscBuffer+Offset,pBuffer,(int)Count*NUMBYTESPERSECTOR);
414: // And set 'changed' flag
415: EmulationDrives[Drive].bContentsChanged = TRUE;
416:
417: return(TRUE);
418: }
419:
420: return(FALSE);
421: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.