Apple-2-Tools/AppleWin
1
0
Fork 0
mirror of https://github.com/AppleWin/AppleWin.git synced 2024-06-27 22:29:48 +00:00
Code Issues Projects Releases Wiki Activity

Rename Drive_t to FloppyDrive; and prefix members

Browse Source
This commit is contained in:
tomcw 2019-04-14 16:47:41 +01:00
parent 971eff7875
commit cd62b82af4
2 changed files with 122 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

218
source/Disk.cpp
View File

@ -82,26 +82,26 @@ bool DiskIIInterfaceCard::GetEnhanceDisk(void) { return m_enhanceDisk; }
void DiskIIInterfaceCard::SetEnhanceDisk(bool bEnhanceDisk) { m_enhanceDisk = bEnhanceDisk; } void DiskIIInterfaceCard::SetEnhanceDisk(bool bEnhanceDisk) { m_enhanceDisk = bEnhanceDisk; }
int DiskIIInterfaceCard::GetCurrentDrive(void) { return m_currDrive; } int DiskIIInterfaceCard::GetCurrentDrive(void) { return m_currDrive; }
int DiskIIInterfaceCard::GetCurrentTrack(void) { return m_floppyDrive[m_currDrive].track; } int DiskIIInterfaceCard::GetCurrentTrack(void) { return m_floppyDrive[m_currDrive].m_track; }
int DiskIIInterfaceCard::GetCurrentPhase(void) { return m_floppyDrive[m_currDrive].phase; } int DiskIIInterfaceCard::GetCurrentPhase(void) { return m_floppyDrive[m_currDrive].m_phase; }
int DiskIIInterfaceCard::GetCurrentOffset(void) { return m_floppyDrive[m_currDrive].disk.byte; } int DiskIIInterfaceCard::GetCurrentOffset(void) { return m_floppyDrive[m_currDrive].m_disk.byte; }
int DiskIIInterfaceCard::GetTrack(const int drive) { return m_floppyDrive[drive].track; } int DiskIIInterfaceCard::GetTrack(const int drive) { return m_floppyDrive[drive].m_track; }
LPCTSTR DiskIIInterfaceCard::GetCurrentState(void) LPCTSTR DiskIIInterfaceCard::GetCurrentState(void)
{ {
if (m_floppyDrive[m_currDrive].disk.imagehandle == NULL) if (m_floppyDrive[m_currDrive].m_disk.imagehandle == NULL)
return "Empty"; return "Empty";
if (!m_floppyMotorOn) if (!m_floppyMotorOn)
{ {
if (m_floppyDrive[m_currDrive].spinning > 0) if (m_floppyDrive[m_currDrive].m_spinning > 0)
return "Off (spinning)"; return "Off (spinning)";
else else
return "Off"; return "Off";
} }
else if (m_floppyWriteMode) else if (m_floppyWriteMode)
{ {
if (m_floppyDrive[m_currDrive].disk.bWriteProtected) if (m_floppyDrive[m_currDrive].m_disk.bWriteProtected)
return "Writing (write protected)"; return "Writing (write protected)";
else else
return "Writing"; return "Writing";
@ -153,7 +153,7 @@ void DiskIIInterfaceCard::SaveLastDiskImage(const int drive)
if (!m_saveDiskImage) if (!m_saveDiskImage)
return; return;
const char *pFileName = m_floppyDrive[drive].disk.fullname; const char *pFileName = m_floppyDrive[drive].m_disk.fullname;
if (drive == DRIVE_1) if (drive == DRIVE_1)
RegSaveString(TEXT(REG_PREFS), REGVALUE_PREF_LAST_DISK_1, TRUE, pFileName); RegSaveString(TEXT(REG_PREFS), REGVALUE_PREF_LAST_DISK_1, TRUE, pFileName);
@ -177,10 +177,10 @@ void DiskIIInterfaceCard::SaveLastDiskImage(const int drive)
// Called by DiskControlMotor() & DiskEnable() // Called by DiskControlMotor() & DiskEnable()
void DiskIIInterfaceCard::CheckSpinning(const ULONG nExecutedCycles) void DiskIIInterfaceCard::CheckSpinning(const ULONG nExecutedCycles)
{ {
DWORD modechange = (m_floppyMotorOn && !m_floppyDrive[m_currDrive].spinning); DWORD modechange = (m_floppyMotorOn && !m_floppyDrive[m_currDrive].m_spinning);
if (m_floppyMotorOn) if (m_floppyMotorOn)
m_floppyDrive[m_currDrive].spinning = SPINNING_CYCLES; m_floppyDrive[m_currDrive].m_spinning = SPINNING_CYCLES;
if (modechange) if (modechange)
FrameDrawDiskLEDS( (HDC)0 ); FrameDrawDiskLEDS( (HDC)0 );
@ -199,14 +199,14 @@ Disk_Status_e DiskIIInterfaceCard::GetDriveLightStatus(const int drive)
{ {
if (IsDriveValid( drive )) if (IsDriveValid( drive ))
{ {
Drive_t* pDrive = &m_floppyDrive[ drive ]; FloppyDrive* pDrive = &m_floppyDrive[ drive ];
if (pDrive->spinning) if (pDrive->m_spinning)
{ {
if (pDrive->disk.bWriteProtected) if (pDrive->m_disk.bWriteProtected)
return DISK_STATUS_PROT; return DISK_STATUS_PROT;
if (pDrive->writelight) if (pDrive->m_writelight)
return DISK_STATUS_WRITE; return DISK_STATUS_WRITE;
else else
return DISK_STATUS_READ; return DISK_STATUS_READ;
@ -231,7 +231,7 @@ bool DiskIIInterfaceCard::IsDriveValid(const int drive)
void DiskIIInterfaceCard::AllocTrack(const int drive) void DiskIIInterfaceCard::AllocTrack(const int drive)
{ {
Disk_t* pFloppy = &m_floppyDrive[drive].disk; Disk_t* pFloppy = &m_floppyDrive[drive].m_disk;
pFloppy->trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE); pFloppy->trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE);
} }
@ -242,10 +242,10 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
if (! IsDriveValid( drive )) if (! IsDriveValid( drive ))
return; return;
Drive_t* pDrive = &m_floppyDrive[ drive ]; FloppyDrive* pDrive = &m_floppyDrive[ drive ];
Disk_t* pFloppy = &pDrive->disk; Disk_t* pFloppy = &pDrive->m_disk;
if (pDrive->track >= ImageGetNumTracks(pFloppy->imagehandle)) if (pDrive->m_track >= ImageGetNumTracks(pFloppy->imagehandle))
{ {
pFloppy->trackimagedata = false; pFloppy->trackimagedata = false;
return; return;
@ -261,8 +261,8 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
#endif #endif
ImageReadTrack( ImageReadTrack(
pFloppy->imagehandle, pFloppy->imagehandle,
pDrive->track, pDrive->m_track,
pDrive->phase, pDrive->m_phase,
pFloppy->trackimage, pFloppy->trackimage,
&pFloppy->nibbles, &pFloppy->nibbles,
m_enhanceDisk); m_enhanceDisk);
@ -276,7 +276,7 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
void DiskIIInterfaceCard::RemoveDisk(const int drive) void DiskIIInterfaceCard::RemoveDisk(const int drive)
{ {
Disk_t* pFloppy = &m_floppyDrive[drive].disk; Disk_t* pFloppy = &m_floppyDrive[drive].m_disk;
if (pFloppy->imagehandle) if (pFloppy->imagehandle)
{ {
@ -305,10 +305,10 @@ void DiskIIInterfaceCard::RemoveDisk(const int drive)
void DiskIIInterfaceCard::WriteTrack(const int drive) void DiskIIInterfaceCard::WriteTrack(const int drive)
{ {
Drive_t* pDrive = &m_floppyDrive[ drive ]; FloppyDrive* pDrive = &m_floppyDrive[ drive ];
Disk_t* pFloppy = &pDrive->disk; Disk_t* pFloppy = &pDrive->m_disk;
if (pDrive->track >= ImageGetNumTracks(pFloppy->imagehandle)) if (pDrive->m_track >= ImageGetNumTracks(pFloppy->imagehandle))
return; return;
if (pFloppy->bWriteProtected) if (pFloppy->bWriteProtected)
@ -321,8 +321,8 @@ void DiskIIInterfaceCard::WriteTrack(const int drive)
#endif #endif
ImageWriteTrack( ImageWriteTrack(
pFloppy->imagehandle, pFloppy->imagehandle,
pDrive->track, pDrive->m_track,
pDrive->phase, // TODO: this should never be used; it's the current phase (half-track), not that of the track to be written (nickw) pDrive->m_phase, // TODO: this should never be used; it's the current phase (half-track), not that of the track to be written (nickw)
pFloppy->trackimage, pFloppy->trackimage,
pFloppy->nibbles); pFloppy->nibbles);
} }
@ -332,7 +332,7 @@ void DiskIIInterfaceCard::WriteTrack(const int drive)
void DiskIIInterfaceCard::FlushCurrentTrack(const int drive) void DiskIIInterfaceCard::FlushCurrentTrack(const int drive)
{ {
Disk_t* pFloppy = &m_floppyDrive[drive].disk; Disk_t* pFloppy = &m_floppyDrive[drive].m_disk;
if (pFloppy->trackimage && pFloppy->trackimagedirty) if (pFloppy->trackimage && pFloppy->trackimagedirty)
WriteTrack(drive); WriteTrack(drive);
@ -344,7 +344,7 @@ void DiskIIInterfaceCard::Boot(void)
{ {
// THIS FUNCTION RELOADS A PROGRAM IMAGE IF ONE IS LOADED IN DRIVE ONE. // THIS FUNCTION RELOADS A PROGRAM IMAGE IF ONE IS LOADED IN DRIVE ONE.
// IF A DISK IMAGE OR NO IMAGE IS LOADED IN DRIVE ONE, IT DOES NOTHING. // IF A DISK IMAGE OR NO IMAGE IS LOADED IN DRIVE ONE, IT DOES NOTHING.
if (m_floppyDrive[0].disk.imagehandle && ImageBoot(m_floppyDrive[0].disk.imagehandle)) if (m_floppyDrive[0].m_disk.imagehandle && ImageBoot(m_floppyDrive[0].m_disk.imagehandle))
m_floppyMotorOn = 0; m_floppyMotorOn = 0;
} }
@ -370,12 +370,12 @@ void __stdcall DiskIIInterfaceCard::ControlMotor(WORD, WORD address, BYTE, BYTE,
void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles) void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles)
{ {
Drive_t* pDrive = &m_floppyDrive[m_currDrive]; FloppyDrive* pDrive = &m_floppyDrive[m_currDrive];
Disk_t* pFloppy = &pDrive->disk; Disk_t* pFloppy = &pDrive->m_disk;
if (!m_floppyMotorOn) // GH#525 if (!m_floppyMotorOn) // GH#525
{ {
if (!pDrive->spinning) if (!pDrive->m_spinning)
{ {
#if LOG_DISK_PHASES #if LOG_DISK_PHASES
LOG_DISK("stepper accessed whilst motor is off and not spinning\r\n"); LOG_DISK("stepper accessed whilst motor is off and not spinning\r\n");
@ -410,22 +410,22 @@ void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYT
// - do not move if both adjacent magnets are on // - do not move if both adjacent magnets are on
// momentum and timing are not accounted for ... maybe one day! // momentum and timing are not accounted for ... maybe one day!
int direction = 0; int direction = 0;
if (m_phases & (1 << ((pDrive->phase + 1) & 3))) if (m_phases & (1 << ((pDrive->m_phase + 1) & 3)))
direction += 1; direction += 1;
if (m_phases & (1 << ((pDrive->phase + 3) & 3))) if (m_phases & (1 << ((pDrive->m_phase + 3) & 3)))
direction -= 1; direction -= 1;
// apply magnet step, if any // apply magnet step, if any
if (direction) if (direction)
{ {
pDrive->phase = MAX(0, MIN(79, pDrive->phase + direction)); pDrive->m_phase = MAX(0, MIN(79, pDrive->m_phase + direction));
const int nNumTracksInImage = ImageGetNumTracks(pFloppy->imagehandle); const int nNumTracksInImage = ImageGetNumTracks(pFloppy->imagehandle);
const int newtrack = (nNumTracksInImage == 0) ? 0 const int newtrack = (nNumTracksInImage == 0) ? 0
: MIN(nNumTracksInImage-1, pDrive->phase >> 1); // (round half tracks down) : MIN(nNumTracksInImage-1, pDrive->m_phase >> 1); // (round half tracks down)
if (newtrack != pDrive->track) if (newtrack != pDrive->m_track)
{ {
FlushCurrentTrack(m_currDrive); FlushCurrentTrack(m_currDrive);
pDrive->track = newtrack; pDrive->m_track = newtrack;
pFloppy->trackimagedata = false; pFloppy->trackimagedata = false;
m_formatTrack.DriveNotWritingTrack(); m_formatTrack.DriveNotWritingTrack();
@ -474,8 +474,8 @@ void __stdcall DiskIIInterfaceCard::Enable(WORD, WORD address, BYTE, BYTE, ULONG
#if LOG_DISK_ENABLE_DRIVE #if LOG_DISK_ENABLE_DRIVE
LOG_DISK("enable drive: %d\r\n", m_currDrive); LOG_DISK("enable drive: %d\r\n", m_currDrive);
#endif #endif
m_floppyDrive[!m_currDrive].spinning = 0; m_floppyDrive[!m_currDrive].m_spinning = 0;
m_floppyDrive[!m_currDrive].writelight = 0; m_floppyDrive[!m_currDrive].m_writelight = 0;
CheckSpinning(uExecutedCycles); CheckSpinning(uExecutedCycles);
} }
@ -495,8 +495,8 @@ void DiskIIInterfaceCard::EjectDisk(const int drive)
// . Used by Drive Buttons' tooltips // . Used by Drive Buttons' tooltips
LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive) LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive)
{ {
if (!m_floppyDrive[drive].disk.strFilenameInZip.empty()) if (!m_floppyDrive[drive].m_disk.strFilenameInZip.empty())
return m_floppyDrive[drive].disk.strFilenameInZip.c_str(); return m_floppyDrive[drive].m_disk.strFilenameInZip.c_str();
return GetFullName(drive); return GetFullName(drive);
} }
@ -505,19 +505,19 @@ LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive)
// . Used by Property Sheet Page (Disk) // . Used by Property Sheet Page (Disk)
LPCTSTR DiskIIInterfaceCard::GetFullName(const int drive) LPCTSTR DiskIIInterfaceCard::GetFullName(const int drive)
{ {
return m_floppyDrive[drive].disk.fullname; return m_floppyDrive[drive].m_disk.fullname;
} }
// Return the imagename // Return the imagename
// . Used by Drive Button's icons & Property Sheet Page (Save snapshot) // . Used by Drive Button's icons & Property Sheet Page (Save snapshot)
LPCTSTR DiskIIInterfaceCard::GetBaseName(const int drive) LPCTSTR DiskIIInterfaceCard::GetBaseName(const int drive)
{ {
return m_floppyDrive[drive].disk.imagename; return m_floppyDrive[drive].m_disk.imagename;
} }
LPCTSTR DiskIIInterfaceCard::DiskGetFullPathName(const int drive) LPCTSTR DiskIIInterfaceCard::DiskGetFullPathName(const int drive)
{ {
return ImageGetPathname(m_floppyDrive[drive].disk.imagehandle); return ImageGetPathname(m_floppyDrive[drive].m_disk.imagehandle);
} }
//=========================================================================== //===========================================================================
@ -535,8 +535,8 @@ void DiskIIInterfaceCard::GetLightStatus(Disk_Status_e *pDisk1Status, Disk_Statu
ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary) ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary)
{ {
Drive_t* pDrive = &m_floppyDrive[drive]; FloppyDrive* pDrive = &m_floppyDrive[drive];
Disk_t* pFloppy = &pDrive->disk; Disk_t* pFloppy = &pDrive->m_disk;
if (pFloppy->imagehandle) if (pFloppy->imagehandle)
RemoveDisk(drive); RemoveDisk(drive);
@ -544,11 +544,11 @@ ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFi
// Reset the drive's struct, but preserve the physical attributes (bug#18242: Platoon) // Reset the drive's struct, but preserve the physical attributes (bug#18242: Platoon)
// . Changing the disk (in the drive) doesn't affect the drive's head etc. // . Changing the disk (in the drive) doesn't affect the drive's head etc.
{ {
int track = pDrive->track; int track = pDrive->m_track;
int phase = pDrive->phase; int phase = pDrive->m_phase;
pDrive->clear(); pDrive->clear();
pDrive->track = track; pDrive->m_track = track;
pDrive->phase = phase; pDrive->m_phase = phase;
} }
const DWORD dwAttributes = GetFileAttributes(pszImageFilename); const DWORD dwAttributes = GetFileAttributes(pszImageFilename);
@ -683,7 +683,7 @@ void DiskIIInterfaceCard::NotifyInvalidImage(const int drive, LPCTSTR pszImageFi
TEXT("first file (%s) in this multi-zip archive is not recognized.\n") TEXT("first file (%s) in this multi-zip archive is not recognized.\n")
TEXT("Try unzipping and using the disk images directly.\n"), TEXT("Try unzipping and using the disk images directly.\n"),
pszImageFilename, pszImageFilename,
m_floppyDrive[drive].disk.strFilenameInZip.c_str()); m_floppyDrive[drive].m_disk.strFilenameInZip.c_str());
break; break;
case eIMAGE_ERROR_GZ: case eIMAGE_ERROR_GZ:
@ -738,7 +738,7 @@ bool DiskIIInterfaceCard::GetProtect(const int drive)
{ {
if (IsDriveValid(drive)) if (IsDriveValid(drive))
{ {
if (m_floppyDrive[drive].disk.bWriteProtected) if (m_floppyDrive[drive].m_disk.bWriteProtected)
return true; return true;
} }
@ -751,7 +751,7 @@ void DiskIIInterfaceCard::SetProtect(const int drive, const bool bWriteProtect)
{ {
if (IsDriveValid( drive )) if (IsDriveValid( drive ))
{ {
m_floppyDrive[drive].disk.bWriteProtected = bWriteProtect; m_floppyDrive[drive].m_disk.bWriteProtected = bWriteProtect;
} }
} }
@ -762,7 +762,7 @@ bool DiskIIInterfaceCard::IsDiskImageWriteProtected(const int drive)
if (!IsDriveValid(drive)) if (!IsDriveValid(drive))
return true; return true;
return ImageIsWriteProtected(m_floppyDrive[drive].disk.imagehandle); return ImageIsWriteProtected(m_floppyDrive[drive].m_disk.imagehandle);
} }
//=========================================================================== //===========================================================================
@ -772,7 +772,7 @@ bool DiskIIInterfaceCard::IsDriveEmpty(const int drive)
if (!IsDriveValid(drive)) if (!IsDriveValid(drive))
return true; return true;
return m_floppyDrive[drive].disk.imagehandle == NULL; return m_floppyDrive[drive].m_disk.imagehandle == NULL;
} }
//=========================================================================== //===========================================================================
@ -811,8 +811,8 @@ bool DiskIIInterfaceCard::LogWriteCheckSyncFF(ULONG& uCycleDelta)
void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles) void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
{ {
/* m_floppyLoadMode = 0; */ /* m_floppyLoadMode = 0; */
Drive_t* pDrive = &m_floppyDrive[m_currDrive]; FloppyDrive* pDrive = &m_floppyDrive[m_currDrive];
Disk_t* pFloppy = &pDrive->disk; Disk_t* pFloppy = &pDrive->m_disk;
if (!pFloppy->trackimagedata && pFloppy->imagehandle) if (!pFloppy->trackimagedata && pFloppy->imagehandle)
ReadTrack(m_currDrive); ReadTrack(m_currDrive);
@ -827,7 +827,7 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
UINT uSpinNibbleCount = 0; UINT uSpinNibbleCount = 0;
CpuCalcCycles(nExecutedCycles); // g_nCumulativeCycles required for uSpinNibbleCount & LogWriteCheckSyncFF() CpuCalcCycles(nExecutedCycles); // g_nCumulativeCycles required for uSpinNibbleCount & LogWriteCheckSyncFF()
if (!m_enhanceDisk && pDrive->spinning) if (!m_enhanceDisk && pDrive->m_spinning)
{ {
const ULONG nCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastCycle); const ULONG nCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastCycle);
m_diskLastCycle = g_nCumulativeCycles; m_diskLastCycle = g_nCumulativeCycles;
@ -854,7 +854,7 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
// Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13) // Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13)
// "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12) // "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12)
// Note: Sherwood Forest sets shift mode and reads with the drive off. // Note: Sherwood Forest sets shift mode and reads with the drive off.
if (!pDrive->spinning) // GH#599 if (!pDrive->m_spinning) // GH#599
return; return;
const ULONG nReadCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastReadLatchCycle); const ULONG nReadCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastReadLatchCycle);
@ -939,10 +939,10 @@ void DiskIIInterfaceCard::Reset(const bool bIsPowerCycle/*=false*/)
// . The initial machine start-up state is track=0, but after a power-cycle the track could be any value. // . The initial machine start-up state is track=0, but after a power-cycle the track could be any value.
// . (For DiskII firmware, this results in a subtle extra latch read in this latter case, for the track!=0 case) // . (For DiskII firmware, this results in a subtle extra latch read in this latter case, for the track!=0 case)
m_floppyDrive[DRIVE_1].spinning = 0; m_floppyDrive[DRIVE_1].m_spinning = 0;
m_floppyDrive[DRIVE_1].writelight = 0; m_floppyDrive[DRIVE_1].m_writelight = 0;
m_floppyDrive[DRIVE_2].spinning = 0; m_floppyDrive[DRIVE_2].m_spinning = 0;
m_floppyDrive[DRIVE_2].writelight = 0; m_floppyDrive[DRIVE_2].m_writelight = 0;
FrameRefreshStatus(DRAW_LEDS, false); FrameRefreshStatus(DRAW_LEDS, false);
} }
@ -1008,7 +1008,7 @@ void __stdcall DiskIIInterfaceCard::LoadWriteProtect(WORD, WORD, BYTE write, BYT
// Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13) // Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13)
// "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12) // "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12)
// Note: Gemstone Warrior sets load mode with the drive off. // Note: Gemstone Warrior sets load mode with the drive off.
if (!m_floppyDrive[m_currDrive].spinning) // GH#599 if (!m_floppyDrive[m_currDrive].m_spinning) // GH#599
return; return;
if (!write) if (!write)
@ -1018,7 +1018,7 @@ void __stdcall DiskIIInterfaceCard::LoadWriteProtect(WORD, WORD, BYTE write, BYT
// . write mode doesn't prevent reading write protect (GH#537): // . write mode doesn't prevent reading write protect (GH#537):
// "If for some reason the above write protect check were entered with the READ/WRITE switch in WRITE, // "If for some reason the above write protect check were entered with the READ/WRITE switch in WRITE,
// the write protect switch would still be read correctly" (UTAIIe page 9-21) // the write protect switch would still be read correctly" (UTAIIe page 9-21)
if (m_floppyDrive[m_currDrive].disk.bWriteProtected) if (m_floppyDrive[m_currDrive].m_disk.bWriteProtected)
m_floppyLatch |= 0x80; m_floppyLatch |= 0x80;
else else
m_floppyLatch &= 0x7F; m_floppyLatch &= 0x7F;
@ -1031,7 +1031,7 @@ void __stdcall DiskIIInterfaceCard::SetReadMode(WORD, WORD, BYTE, BYTE, ULONG)
{ {
m_floppyWriteMode = 0; m_floppyWriteMode = 0;
m_formatTrack.DriveSwitchedToReadMode(&m_floppyDrive[m_currDrive].disk); m_formatTrack.DriveSwitchedToReadMode(&m_floppyDrive[m_currDrive].m_disk);
#if LOG_DISK_RW_MODE #if LOG_DISK_RW_MODE
LOG_DISK("rw mode: read\r\n"); LOG_DISK("rw mode: read\r\n");
@ -1044,9 +1044,9 @@ void __stdcall DiskIIInterfaceCard::SetWriteMode(WORD, WORD, BYTE, BYTE, ULONG u
{ {
m_floppyWriteMode = 1; m_floppyWriteMode = 1;
m_formatTrack.DriveSwitchedToWriteMode(m_floppyDrive[m_currDrive].disk.byte); m_formatTrack.DriveSwitchedToWriteMode(m_floppyDrive[m_currDrive].m_disk.byte);
BOOL modechange = !m_floppyDrive[m_currDrive].writelight; BOOL modechange = !m_floppyDrive[m_currDrive].m_writelight;
#if LOG_DISK_RW_MODE #if LOG_DISK_RW_MODE
LOG_DISK("rw mode: write (mode changed=%d)\r\n", modechange ? 1 : 0); LOG_DISK("rw mode: write (mode changed=%d)\r\n", modechange ? 1 : 0);
#endif #endif
@ -1054,7 +1054,7 @@ void __stdcall DiskIIInterfaceCard::SetWriteMode(WORD, WORD, BYTE, BYTE, ULONG u
m_uWriteLastCycle = 0; m_uWriteLastCycle = 0;
#endif #endif
m_floppyDrive[m_currDrive].writelight = WRITELIGHT_CYCLES; m_floppyDrive[m_currDrive].m_writelight = WRITELIGHT_CYCLES;
if (modechange) if (modechange)
FrameDrawDiskLEDS( (HDC)0 ); FrameDrawDiskLEDS( (HDC)0 );
@ -1067,24 +1067,24 @@ void DiskIIInterfaceCard::UpdateDriveState(DWORD cycles)
int loop = NUM_DRIVES; int loop = NUM_DRIVES;
while (loop--) while (loop--)
{ {
Drive_t* pDrive = &m_floppyDrive[loop]; FloppyDrive* pDrive = &m_floppyDrive[loop];
if (pDrive->spinning && !m_floppyMotorOn) if (pDrive->m_spinning && !m_floppyMotorOn)
{ {
if (!(pDrive->spinning -= MIN(pDrive->spinning, cycles))) if (!(pDrive->m_spinning -= MIN(pDrive->m_spinning, cycles)))
{ {
FrameDrawDiskLEDS( (HDC)0 ); FrameDrawDiskLEDS( (HDC)0 );
FrameDrawDiskStatus( (HDC)0 ); FrameDrawDiskStatus( (HDC)0 );
} }
} }
if (m_floppyWriteMode && (m_currDrive == loop) && pDrive->spinning) if (m_floppyWriteMode && (m_currDrive == loop) && pDrive->m_spinning)
{ {
pDrive->writelight = WRITELIGHT_CYCLES; pDrive->m_writelight = WRITELIGHT_CYCLES;
} }
else if (pDrive->writelight) else if (pDrive->m_writelight)
{ {
if (!(pDrive->writelight -= MIN(pDrive->writelight, cycles))) if (!(pDrive->m_writelight -= MIN(pDrive->m_writelight, cycles)))
{ {
FrameDrawDiskLEDS( (HDC)0 ); FrameDrawDiskLEDS( (HDC)0 );
FrameDrawDiskStatus( (HDC)0 ); FrameDrawDiskStatus( (HDC)0 );
@ -1099,7 +1099,7 @@ bool DiskIIInterfaceCard::DriveSwap(void)
{ {
// Refuse to swap if either Disk][ is active // Refuse to swap if either Disk][ is active
// TODO: if Shift-Click then FORCE drive swap to bypass message // TODO: if Shift-Click then FORCE drive swap to bypass message
if (m_floppyDrive[DRIVE_1].spinning || m_floppyDrive[DRIVE_2].spinning) if (m_floppyDrive[DRIVE_1].m_spinning || m_floppyDrive[DRIVE_2].m_spinning)
{ {
// 1.26.2.4 Prompt when trying to swap disks while drive is on instead of silently failing // 1.26.2.4 Prompt when trying to swap disks while drive is on instead of silently failing
int status = MessageBox( int status = MessageBox(
@ -1134,11 +1134,11 @@ bool DiskIIInterfaceCard::DriveSwap(void)
// Swap disks between drives // Swap disks between drives
// . NB. We swap trackimage ptrs (so don't need to swap the buffers' data) // . NB. We swap trackimage ptrs (so don't need to swap the buffers' data)
std::swap(m_floppyDrive[DRIVE_1].disk, m_floppyDrive[DRIVE_2].disk); std::swap(m_floppyDrive[DRIVE_1].m_disk, m_floppyDrive[DRIVE_2].m_disk);
// Invalidate the trackimage so that a read latch will re-read the track for the new floppy (GH#543) // Invalidate the trackimage so that a read latch will re-read the track for the new floppy (GH#543)
m_floppyDrive[DRIVE_1].disk.trackimagedata = false; m_floppyDrive[DRIVE_1].m_disk.trackimagedata = false;
m_floppyDrive[DRIVE_2].disk.trackimagedata = false; m_floppyDrive[DRIVE_2].m_disk.trackimagedata = false;
SaveLastDiskImage(DRIVE_1); SaveLastDiskImage(DRIVE_1);
SaveLastDiskImage(DRIVE_2); SaveLastDiskImage(DRIVE_2);
@ -1293,21 +1293,21 @@ std::string DiskIIInterfaceCard::GetSnapshotCardName(void)
void DiskIIInterfaceCard::SaveSnapshotDisk2Unit(YamlSaveHelper& yamlSaveHelper, UINT unit) void DiskIIInterfaceCard::SaveSnapshotDisk2Unit(YamlSaveHelper& yamlSaveHelper, UINT unit)
{ {
YamlSaveHelper::Label label(yamlSaveHelper, "%s%d:\n", SS_YAML_KEY_DISK2UNIT, unit); YamlSaveHelper::Label label(yamlSaveHelper, "%s%d:\n", SS_YAML_KEY_DISK2UNIT, unit);
yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, m_floppyDrive[unit].disk.fullname); yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, m_floppyDrive[unit].m_disk.fullname);
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, m_floppyDrive[unit].track); yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, m_floppyDrive[unit].m_track);
yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, m_floppyDrive[unit].phase); yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, m_floppyDrive[unit].m_phase);
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, m_floppyDrive[unit].disk.byte); yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, m_floppyDrive[unit].m_disk.byte);
yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, m_floppyDrive[unit].disk.bWriteProtected); yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, m_floppyDrive[unit].m_disk.bWriteProtected);
yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, m_floppyDrive[unit].spinning); yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, m_floppyDrive[unit].m_spinning);
yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, m_floppyDrive[unit].writelight); yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, m_floppyDrive[unit].m_writelight);
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, m_floppyDrive[unit].disk.nibbles); yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, m_floppyDrive[unit].m_disk.nibbles);
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, m_floppyDrive[unit].disk.trackimagedata); yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, m_floppyDrive[unit].m_disk.trackimagedata);
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, m_floppyDrive[unit].disk.trackimagedirty); yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, m_floppyDrive[unit].m_disk.trackimagedirty);
if (m_floppyDrive[unit].disk.trackimage) if (m_floppyDrive[unit].m_disk.trackimage)
{ {
YamlSaveHelper::Label image(yamlSaveHelper, "%s:\n", SS_YAML_KEY_TRACK_IMAGE); YamlSaveHelper::Label image(yamlSaveHelper, "%s:\n", SS_YAML_KEY_TRACK_IMAGE);
yamlSaveHelper.SaveMemory(m_floppyDrive[unit].disk.trackimage, NIBBLES_PER_TRACK); yamlSaveHelper.SaveMemory(m_floppyDrive[unit].m_disk.trackimage, NIBBLES_PER_TRACK);
} }
} }
@ -1339,9 +1339,9 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
bool bImageError = false; bool bImageError = false;
m_floppyDrive[unit].disk.fullname[0] = 0; m_floppyDrive[unit].m_disk.fullname[0] = 0;
m_floppyDrive[unit].disk.imagename[0] = 0; m_floppyDrive[unit].m_disk.imagename[0] = 0;
m_floppyDrive[unit].disk.bWriteProtected = false; // Default to false (until image is successfully loaded below) m_floppyDrive[unit].m_disk.bWriteProtected = false; // Default to false (until image is successfully loaded below)
std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME); std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME);
if (!filename.empty()) if (!filename.empty())
@ -1368,15 +1368,15 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
} }
} }
m_floppyDrive[unit].track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK); m_floppyDrive[unit].m_track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK);
m_floppyDrive[unit].phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE); m_floppyDrive[unit].m_phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE);
m_floppyDrive[unit].disk.byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE); m_floppyDrive[unit].m_disk.byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE);
yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITE_PROTECTED); // Consume yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITE_PROTECTED); // Consume
m_floppyDrive[unit].spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING); m_floppyDrive[unit].m_spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING);
m_floppyDrive[unit].writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT); m_floppyDrive[unit].m_writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT);
m_floppyDrive[unit].disk.nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES); m_floppyDrive[unit].m_disk.nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES);
m_floppyDrive[unit].disk.trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA) ? true : false; m_floppyDrive[unit].m_disk.trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA) ? true : false;
m_floppyDrive[unit].disk.trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY) ? true : false; m_floppyDrive[unit].m_disk.trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY) ? true : false;
std::vector<BYTE> track(NIBBLES_PER_TRACK); std::vector<BYTE> track(NIBBLES_PER_TRACK);
if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE)) if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE))
@ -1391,20 +1391,20 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
if (!filename.empty() && !bImageError) if (!filename.empty() && !bImageError)
{ {
if ((m_floppyDrive[unit].disk.trackimage == NULL) && m_floppyDrive[unit].disk.nibbles) if ((m_floppyDrive[unit].m_disk.trackimage == NULL) && m_floppyDrive[unit].m_disk.nibbles)
AllocTrack(unit); AllocTrack(unit);
if (m_floppyDrive[unit].disk.trackimage == NULL) if (m_floppyDrive[unit].m_disk.trackimage == NULL)
bImageError = true; bImageError = true;
else else
memcpy(m_floppyDrive[unit].disk.trackimage, &track[0], NIBBLES_PER_TRACK); memcpy(m_floppyDrive[unit].m_disk.trackimage, &track[0], NIBBLES_PER_TRACK);
} }
if (bImageError) if (bImageError)
{ {
m_floppyDrive[unit].disk.trackimagedata = false; m_floppyDrive[unit].m_disk.trackimagedata = false;
m_floppyDrive[unit].disk.trackimagedirty = false; m_floppyDrive[unit].m_disk.trackimagedirty = false;
m_floppyDrive[unit].disk.nibbles = 0; m_floppyDrive[unit].m_disk.nibbles = 0;
} }
} }

26
source/Disk.h
View File

@ -78,26 +78,26 @@ struct Disk_t
} }
}; };
struct Drive_t struct FloppyDrive
{ {
int phase; int m_phase;
int track; int m_track;
DWORD spinning; DWORD m_spinning;
DWORD writelight; DWORD m_writelight;
Disk_t disk; Disk_t m_disk;
Drive_t() FloppyDrive()
{ {
clear(); clear();
} }
void clear() void clear()
{ {
phase = 0; m_phase = 0;
track = 0; m_track = 0;
spinning = 0; m_spinning = 0;
writelight = 0; m_writelight = 0;
disk.clear(); m_disk.clear();
} }
}; };
@ -180,7 +180,7 @@ private:
// //
WORD m_currDrive; WORD m_currDrive;
Drive_t m_floppyDrive[NUM_DRIVES]; FloppyDrive m_floppyDrive[NUM_DRIVES];
BYTE m_floppyLatch; BYTE m_floppyLatch;
BOOL m_floppyMotorOn; BOOL m_floppyMotorOn;
BOOL m_floppyLoadMode; // for efficiency this is not used; it's extremely unlikely to affect emulation (nickw) BOOL m_floppyLoadMode; // for efficiency this is not used; it's extremely unlikely to affect emulation (nickw)