/* Copyright 2015 by Joseph Forgione This file is part of VCC (Virtual Color Computer). VCC (Virtual Color Computer) is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. VCC (Virtual Color Computer) is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with VCC (Virtual Color Computer). If not, see . */ /******************************************************************************** * File name: wd1793.c * * Copyright 2005 by Joseph Forgione * * This will Emulate the Western Digital wd1793 Floppy Disk Controller chip * * and support circuts as implemented in the Tandy Color Computer 1,2 and 3. * * Last change date 03/16/2005 * * Last change date 07/14/2005 Changes NMI assert fucntion * * Last change date 07/26/2005 Complete rewrite to get F**king nitros09 to boot * * Last change date 02/04/2006 rewritten again for DMK and writetrack support * * Last change date 06/27/2006 seek time more closely emulated * * Last change date 05/16/2007 Better DMK support. Diecom protection works now * * Last change date 05/21/2007 Added fdrawcmd support for real disk access/ * * Last change date 02/07/2026 EJJ Sanitize variable names * * * ********************************************************************************/ //#define USE_LOGGING #include #include #include #include #include "defines.h" #include "../../../src/core/Interrupts.h" #include #include "wd1793.h" #include "fd502.h" #include "fdrawcmd.h" // http://simonowen.com/fdrawcmd/ /****************Fuction Protos for this Module************/ unsigned char GetBytefromSector (); unsigned char GetBytefromAddress(); unsigned char GetBytefromTrack (); unsigned char (*GetBytefromDisk)()=&GetBytefromSector; unsigned char WriteBytetoSector (unsigned char); unsigned char WriteBytetoTrack (unsigned char); unsigned char (*WriteBytetoDisk)(unsigned char)=&WriteBytetoSector; unsigned char MountDisk(const char *filename,unsigned char); void DispatchCommand(unsigned char); void DecodeControlReg(unsigned char); void SetType1Flags(unsigned char); void SetType2Flags(unsigned char); void SetType3Flags(unsigned char); long ReadSector (unsigned char,unsigned char,unsigned char,unsigned char *); long WriteSector(unsigned char,unsigned char,unsigned char,const unsigned char *,long); long ReadTrack (unsigned char,unsigned char,unsigned char,unsigned char *); long WriteTrack (unsigned char,unsigned char,unsigned char,const unsigned char *); unsigned short ccitt_crc16(unsigned short crc, const unsigned char *, unsigned short ); long GetSectorInfo (SectorInfo *,const unsigned char *); void CommandDone(); extern unsigned char PhysicalDriveA,PhysicalDriveB; bool FormatTrack (HANDLE , BYTE , BYTE,BYTE ); bool CmdFormat (HANDLE , PFD_FORMAT_PARAMS , ULONG ); /**********************************************************/ static unsigned char StepTimesMS[4]={6,12,20,30}; static unsigned short BytesperSector[4]={128,256,512,1024}; static unsigned char TransferBuffer[16384]=""; DiskInfo gVirtualDrive[5]; static unsigned char StatusReg=READY; static unsigned char DataReg=0; static unsigned char TrackReg=0; static unsigned char SectorReg=0; static unsigned char ControlReg=0; static unsigned char Side=0; static unsigned char CurrentCommand=IDLE,CurrentDisk=NONE,LastDisk=NONE; static unsigned char MotorOn=0; static unsigned char KBLeds=0; static unsigned char InteruptEnable=0; static unsigned char HaltEnable=0; static unsigned char HeadLoad=0; static unsigned char TrackVerify=0; static unsigned char StepTimeMS= 0; static unsigned char SideCompare=0; static unsigned char SideCompareEnable=0; static unsigned char Delay15ms=0; static unsigned char StepDirection=1; static unsigned char IndexPulse; static unsigned char TurboMode=0; static unsigned char CyclestoSettle=SETTLETIME; static unsigned char CyclesperStep=STEPTIME; static unsigned char MSectorFlag=0; static unsigned char LostDataFlag=0; static int ExecTimeWaiter=0; static long TransferBufferIndex=0; static long TransferBufferSize=0; static unsigned int IOWaiter=0; static unsigned int IndexCounter=0; //static unsigned char UseLeds=0; DWORD dwRet; HANDLE OpenFloppy (int ); static PVOID RawReadBuf=nullptr; bool SetDataRate (HANDLE , BYTE ); static FD_READ_WRITE_PARAMS rwp; static bool DirtyDisk=true; char ImageFormat[5][4]={"JVC","VDK","DMK","OS9","RAW"}; /*************************************************************/ unsigned char disk_io_read(unsigned char port) { unsigned char temp; switch (port) { case 0x48: temp=StatusReg; break; case 0x49: temp=TrackReg; break; case 0x4A: temp=SectorReg; break; case 0x4B: //Reading data from disk if (CurrentCommand==IDLE) temp=DataReg; else temp=GetBytefromDisk(); break; case 0x40: //Control Register can't be read temp=0; break; default: return 0; } //END Switch port return temp; } void disk_io_write(unsigned char data,unsigned char port) { switch (port) { case 0x48: //Command Register DispatchCommand(data); break; case 0x49: TrackReg=data; break; case 0x4A: SectorReg=data; break; case 0x4B: //Writing Data to disk if (CurrentCommand==IDLE) DataReg=data; else WriteBytetoDisk(data); break; case 0x40: ControlReg=data; DecodeControlReg(ControlReg); break; } //END Switch port return; } /**************************************************************** * 7 halt enable flag * * 6 drive select #3 or SideSelect * * 5 density (0=single, 1=double) and NMI enable flag * * 4 write precompensation * * 3 drive motor activation * * 2 drive select #2 * * 1 drive select #1 * * 0 drive select #0 * * * * Reading from $ff48-$ff4f clears bit 7 of DSKREG ($ff40) * * * ****************************************************************/ void DecodeControlReg(unsigned char Tmp) { KBLeds=0; MotorOn=0; CurrentDisk=NONE; Side=0; InteruptEnable=0; HaltEnable=0; if (Tmp & CTRL_DRIVE0) { CurrentDisk=0; } if (Tmp & CTRL_DRIVE1) { CurrentDisk=1; } if (Tmp & CTRL_DRIVE2) { CurrentDisk=2; } if (Tmp & SIDESELECT) //DRIVE3 Select in "all single sided" systems Side=1; if (Tmp & CTRL_MOTOR_EN) { MotorOn=1; if ( gVirtualDrive[CurrentDisk].ImageType == RAW) DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle, IOCTL_FD_MOTOR_ON, nullptr, 0, nullptr, 0, &dwRet, nullptr); } if ( (Side==1) & (CurrentDisk==NONE) ) { CurrentDisk=3; Side=0; } if ( !(Tmp & CTRL_MOTOR_EN)) //Turning off the drive makes the disk dirty DirtyDisk=true; if (LastDisk != CurrentDisk) //If we switch from reading one Physical disk to another we need to invalidate the cache DirtyDisk=true; LastDisk=CurrentDisk; if (Tmp & CTRL_DENSITY) //Strange, Density and Interupt enable flag InteruptEnable=1; if (Tmp & CTRL_HALT_FLAG) HaltEnable=1; return; } int mount_disk_image(const char *filename,unsigned char drive) { unsigned int Temp=0; Temp=MountDisk(filename,drive); return(!Temp); } void unmount_disk_image(unsigned char drive) { if (gVirtualDrive[drive].FileHandle !=nullptr) CloseHandle(gVirtualDrive[drive].FileHandle); gVirtualDrive[drive].FileHandle=nullptr; gVirtualDrive[drive].ImageType=0; strcpy(gVirtualDrive[drive].ImageName,""); DirtyDisk=true; if (drive==(PhysicalDriveA-1)) PhysicalDriveA=0; if (drive==(PhysicalDriveB-1)) PhysicalDriveB=0; return; } void DiskStatus(char* text_buffer, size_t buffer_size) { if (MotorOn==1) sprintf(text_buffer,"FD-502:Drv:%1.1i %s Trk:%2.2i Sec:%2.2i Hd:%1.1i",CurrentDisk,ImageFormat[gVirtualDrive[CurrentDisk].ImageType],gVirtualDrive[CurrentDisk].HeadPosition,SectorReg,Side); else sprintf(text_buffer,"FD-502:Idle"); } unsigned char MountDisk(const char *FileName,unsigned char disk) { unsigned long BytesRead=0; unsigned char HeaderBlock[HEADERBUFFERSIZE]=""; long TotalSectors=0; unsigned char TmpSides=0,TmpSectors=0,TmpMod=0; if (gVirtualDrive[disk].FileHandle !=nullptr) unmount_disk_image(disk); //Image Geometry Defaults gVirtualDrive[disk].FirstSector=1; gVirtualDrive[disk].Sides=1; gVirtualDrive[disk].Sectors=18; gVirtualDrive[disk].SectorSize=1; gVirtualDrive[disk].WriteProtect=0; gVirtualDrive[disk].RawDrive=0; if (!strcmp(FileName,"*Floppy A:")) gVirtualDrive[disk].RawDrive=1; if (!strcmp(FileName,"*Floppy B:")) gVirtualDrive[disk].RawDrive=2; if (gVirtualDrive[disk].RawDrive==0) { gVirtualDrive[disk].FileHandle = CreateFile( FileName,GENERIC_READ | GENERIC_WRITE,0,nullptr,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,nullptr); if (gVirtualDrive[disk].FileHandle==INVALID_HANDLE_VALUE) { //Can't open read/write might be read only gVirtualDrive[disk].FileHandle = CreateFile(FileName,GENERIC_READ,0,nullptr,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,nullptr); gVirtualDrive[disk].WriteProtect=0xFF; } if (gVirtualDrive[disk].FileHandle==INVALID_HANDLE_VALUE) return 1; //Give up cant mount it strcpy(gVirtualDrive[disk].ImageName,FileName); gVirtualDrive[disk].FileSize= GetFileSize(gVirtualDrive[disk].FileHandle,nullptr); gVirtualDrive[disk].HeaderSize = gVirtualDrive[disk].FileSize % 256; SetFilePointer(gVirtualDrive[disk].FileHandle,0,nullptr,FILE_BEGIN); ReadFile(gVirtualDrive[disk].FileHandle,HeaderBlock,HEADERBUFFERSIZE,&BytesRead,nullptr); } else gVirtualDrive[disk].HeaderSize=0xFF; switch (gVirtualDrive[disk].HeaderSize) { case 4: gVirtualDrive[disk].FirstSector=HeaderBlock[3]; case 3: gVirtualDrive[disk].SectorSize=HeaderBlock[2]; case 2: gVirtualDrive[disk].Sectors = HeaderBlock[0]; gVirtualDrive[disk].Sides = HeaderBlock[1]; case 0: //OS9 Image checks TotalSectors = (HeaderBlock[0]<<16) + (HeaderBlock[1]<<8) + (HeaderBlock[2]); TmpSides = (HeaderBlock[16] & 1)+1; TmpSectors = HeaderBlock[3]; TmpMod=1; if ( (TmpSides*TmpSectors)!=0) TmpMod = TotalSectors%(TmpSides*TmpSectors); if ((TmpSectors ==18) & (TmpMod==0) & (gVirtualDrive[disk].HeaderSize ==0)) //Sanity Check { gVirtualDrive[disk].ImageType=OS9; gVirtualDrive[disk].Sides = TmpSides; gVirtualDrive[disk].Sectors = TmpSectors; } else gVirtualDrive[disk].ImageType=JVC; gVirtualDrive[disk].TrackSize = gVirtualDrive[disk].Sectors * BytesperSector[gVirtualDrive[disk].SectorSize]; break; case 12: gVirtualDrive[disk].ImageType=VDK; //VDK gVirtualDrive[disk].Sides = HeaderBlock[9]; gVirtualDrive[disk].TrackSize = gVirtualDrive[disk].Sectors * BytesperSector[gVirtualDrive[disk].SectorSize]; break; case 16: gVirtualDrive[disk].ImageType=DMK; //DMK if (gVirtualDrive[disk].WriteProtect != 0xFF) gVirtualDrive[disk].WriteProtect = HeaderBlock[0]; gVirtualDrive[disk].TrackSize = (HeaderBlock[3]<<8 | HeaderBlock[2]); gVirtualDrive[disk].Sides = 2-((HeaderBlock[4] & 16 )>>4); break; case 0xFF: if (gVirtualDrive[disk].RawDrive) { if (gVirtualDrive[disk].FileHandle !=nullptr) unmount_disk_image(disk); gVirtualDrive[disk].ImageType=RAW; gVirtualDrive[disk].Sides=2; gVirtualDrive[disk].FileHandle = OpenFloppy(gVirtualDrive[disk].RawDrive-1); if (gVirtualDrive[disk].FileHandle == nullptr) return 1; strcpy(gVirtualDrive[disk].ImageName,FileName); if (gVirtualDrive[disk].RawDrive==1) PhysicalDriveA=disk+1; if (gVirtualDrive[disk].RawDrive==2) PhysicalDriveB=disk+1; } break; default: return 1; } strncpy(gVirtualDrive[disk].ImageTypeName,ImageFormat[gVirtualDrive[disk].ImageType],4); return 0; //Return 0 on success } /******************************************************************************************** * ReadSector returns only the valid sector data with out the low level housekeeping info * * * Should work for all formats * ********************************************************************************************/ long ReadSector (unsigned char Side, //0 or 1 unsigned char Track, //0 to 255 "REAL" values are 1 to 80 unsigned char Sector, //1 to 18 could be 0 to 17 unsigned char *ReturnBuffer) { unsigned long BytesRead=0,Result=0; long FileOffset=0; unsigned char TempBuffer[16384]; SectorInfo CurrentSector; //Needed for RAW access DWORD dwRet; FD_SEEK_PARAMS sp; unsigned char Ret=0; const unsigned char *pva=nullptr; //************************ if (gVirtualDrive[CurrentDisk].FileHandle==nullptr) return 0; switch (gVirtualDrive[CurrentDisk].ImageType) { case JVC: case VDK: case OS9: if (((Side+1) > gVirtualDrive[CurrentDisk].Sides) | (TrackReg != gVirtualDrive[CurrentDisk].HeadPosition)) return 0; FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (Track * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize) + (BytesperSector[gVirtualDrive[CurrentDisk].SectorSize] * (Sector - gVirtualDrive[CurrentDisk].FirstSector) ) ) ; DLOG_C("FDC S%d trk:%d side:%d sect:%d hsiz:%d nside:%d tsiz:%d ssiz:%d fsec:%d\n", FileOffset, Track, Side, Sector, gVirtualDrive[CurrentDisk].HeaderSize, gVirtualDrive[CurrentDisk].Sides, gVirtualDrive[CurrentDisk].TrackSize, BytesperSector[gVirtualDrive[CurrentDisk].SectorSize], gVirtualDrive[CurrentDisk].FirstSector); SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); ReadFile(gVirtualDrive[CurrentDisk].FileHandle,ReturnBuffer,BytesperSector[gVirtualDrive[CurrentDisk].SectorSize],&BytesRead,nullptr); if (BytesRead != BytesperSector[gVirtualDrive[CurrentDisk].SectorSize]) //Fake the read for short images { memset(ReturnBuffer,0xFF,BytesperSector[gVirtualDrive[CurrentDisk].SectorSize]); BytesRead=BytesperSector[gVirtualDrive[CurrentDisk].SectorSize]; } return(BytesperSector[gVirtualDrive[CurrentDisk].SectorSize]); case DMK: FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (Track * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize)); Result=SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); //Need to read the entire track due to the emulation of interleave on these images ReadFile(gVirtualDrive[CurrentDisk].FileHandle,TempBuffer,gVirtualDrive[CurrentDisk].TrackSize,&BytesRead,nullptr); if (BytesRead!=gVirtualDrive[CurrentDisk].TrackSize) //DMK can't be short the image is corupt return 0; CurrentSector.Sector=Sector; if (GetSectorInfo (&CurrentSector,TempBuffer)==0) return 0; memcpy(ReturnBuffer,&TempBuffer[CurrentSector.DAM],CurrentSector.Lenth); return(CurrentSector.Lenth); case RAW: pva=(unsigned char *)RawReadBuf; if (TrackReg != gVirtualDrive[CurrentDisk].HeadPosition) return 0; //Read the entire track and cache it. Speeds up disk reads if (DirtyDisk | (rwp.phead != Side) | (rwp.cyl != gVirtualDrive[CurrentDisk].HeadPosition ) ) { rwp.flags = FD_OPTION_MFM; rwp.phead = Side; rwp.cyl = gVirtualDrive[CurrentDisk].HeadPosition; rwp.head = Side; rwp.sector = 1; rwp.size = 1; //256 Byte Secotors rwp.eot = 1+18; rwp.gap = 0x0a; rwp.datalen = 0xff; // details of seek location sp.cyl = Track; sp.head = Side; // seek to cyl DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle , IOCTL_FDCMD_SEEK, &sp, sizeof(sp), nullptr, 0, &dwRet, nullptr); Ret=DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle , IOCTL_FDCMD_READ_DATA, &rwp, sizeof(rwp), RawReadBuf,4608, &dwRet, nullptr); if (dwRet != 4608) return 0; DirtyDisk=false; } memcpy(ReturnBuffer,&pva[(Sector-1)*256],256); return 256; } return 0; } long WriteSector ( unsigned char Side, //0 or 1 unsigned char Track, //0 to 255 "REAL" values are 1 to 80 unsigned char Sector, //1 to 18 could be 0 to 17 const unsigned char *WriteBuffer, //) long BytestoWrite) { unsigned long BytesWritten=0,Result=0,BytesRead=0; unsigned int FileOffset=0; unsigned char TempBuffer[16384]; unsigned short Crc=0xABCD; //Needed for RAW access DWORD dwRet; FD_SEEK_PARAMS sp; unsigned char Ret=0; const unsigned char *pva=nullptr; SectorInfo CurrentSector; if ( (gVirtualDrive[CurrentDisk].FileHandle==nullptr) | ((Side+1) > gVirtualDrive[CurrentDisk].Sides) ) return 0; switch (gVirtualDrive[CurrentDisk].ImageType) { case JVC: case VDK: case OS9: FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (Track * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize) + (BytesperSector[gVirtualDrive[CurrentDisk].SectorSize] * (Sector - gVirtualDrive[CurrentDisk].FirstSector) ) ) ; Result=SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); WriteFile(gVirtualDrive[CurrentDisk].FileHandle,WriteBuffer,BytesperSector[gVirtualDrive[CurrentDisk].SectorSize],&BytesWritten,nullptr); return BytesWritten; case DMK: //DMK FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (Track * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize)); Result=SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); //Need to read the entire track due to the emulation of interleave on these images ReadFile(gVirtualDrive[CurrentDisk].FileHandle,TempBuffer,gVirtualDrive[CurrentDisk].TrackSize,&BytesRead,nullptr); if (BytesRead!=gVirtualDrive[CurrentDisk].TrackSize) return 0; CurrentSector.Sector=Sector; if (GetSectorInfo(&CurrentSector,TempBuffer)==0) return 0; memcpy(&TempBuffer[CurrentSector.DAM],WriteBuffer,BytestoWrite); Crc=ccitt_crc16(0xE295,&TempBuffer[CurrentSector.DAM] , CurrentSector.Lenth); //0xcdb4 TempBuffer[CurrentSector.DAM + CurrentSector.Lenth ] =Crc>>8; TempBuffer[CurrentSector.DAM + CurrentSector.Lenth +1 ] =(Crc & 0xFF); FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (Track * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize)); Result=SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); WriteFile(gVirtualDrive[CurrentDisk].FileHandle,TempBuffer,gVirtualDrive[CurrentDisk].TrackSize,&BytesWritten,nullptr); return(CurrentSector.Lenth); case RAW: DirtyDisk=true; pva=(unsigned char *) RawReadBuf; rwp.flags = FD_OPTION_MFM; rwp.phead = Side; rwp.cyl = gVirtualDrive[CurrentDisk].HeadPosition; rwp.head = Side; rwp.sector = Sector; rwp.size = 1; //256 Byte Secotors rwp.eot = 1+Sector; rwp.gap = 0x0a; rwp.datalen = 0xff; // details of seek location sp.cyl = Track; sp.head = Side; // seek to cyl DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle , IOCTL_FDCMD_SEEK, &Track, sizeof(Track), nullptr, 0, &dwRet, nullptr); memcpy(RawReadBuf,WriteBuffer,256); Ret=DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle , IOCTL_FDCMD_WRITE_DATA, &rwp, sizeof(rwp), RawReadBuf,18*(128<>8); TempBuffer[BufferIndex++]= (Crc & 0xFF); } else { TempBuffer[BufferIndex]=TempChar; if (TempChar == 0xFE) //ID Address mark Build Track Header Pointers { TempBuffer[IdamIndex++]= (BufferIndex & 0xFF); TempBuffer[IdamIndex++]= 0x80 |(BufferIndex>>8); } if (TempChar == 0xFB) //data Address Marker { DataBlockPointer = BufferIndex+1; Seed = 0xE295; } if (TempChar == 0xFE) //ID address marker { DataBlockPointer = BufferIndex; Seed = 0xCDB4; } if (TempChar == 0xF5) TempBuffer[BufferIndex]=0xA1; if (TempChar == 0xF6) TempBuffer[BufferIndex]=0xC2; BufferIndex++; } } FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (Track * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize) ) ; Result=SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); WriteFile(gVirtualDrive[CurrentDisk].FileHandle,TempBuffer,gVirtualDrive[CurrentDisk].TrackSize,&BytesWritten,nullptr); free(TempBuffer); break; case RAW: DirtyDisk=true; DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle , IOCTL_FDCMD_SEEK, &Track, sizeof(Track), nullptr, 0, &dwRet, nullptr); return(FormatTrack (gVirtualDrive[CurrentDisk].FileHandle , Track , Side, WriteBuffer[100] )); //KLUDGE! } return BytesWritten; } long ReadTrack ( unsigned char Side, //0 or 1 unsigned char Track, //0 to 255 "REAL" values are 1 to 80 unsigned char /*Dummy*/, //Sector Value unused unsigned char *WriteBuffer) { unsigned long BytesRead=0,Result=0; long FileOffset=0; if (gVirtualDrive[CurrentDisk].FileHandle==nullptr) return 0; switch (gVirtualDrive[CurrentDisk].ImageType) { case JVC: case VDK: case OS9: if ((Side+1) > gVirtualDrive[CurrentDisk].Sides) return 0; //STUB Write Me return 0; case DMK: FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (Track * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize)+128); Result=SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); ReadFile(gVirtualDrive[CurrentDisk].FileHandle,WriteBuffer,(gVirtualDrive[CurrentDisk].TrackSize-128),&BytesRead,nullptr); if (BytesRead != ((unsigned)gVirtualDrive[CurrentDisk].TrackSize-128) ) return 0; break; } return BytesRead; } //This gets called at the end of every scan line so the controller has acurate timing. void PingFdc() { static char wobble=0; if (MotorOn==0) return; IndexCounter++; if (IndexCounter> ((INDEXTIME-30)+wobble)) IndexPulse=1; if (IndexCounter > (INDEXTIME+wobble)) { IndexPulse=0; IndexCounter=0; wobble=rand(); wobble/=4; } if ( ((CurrentCommand<=7) | (CurrentCommand==IDLE)) & (gVirtualDrive[CurrentDisk].FileHandle!=nullptr) ) { if (IndexPulse ) StatusReg|=INDEXPULSE; else StatusReg &=(~INDEXPULSE); } if (CurrentCommand==IDLE) return; ExecTimeWaiter--; if (ExecTimeWaiter >0) //Click Click Click return; ExecTimeWaiter=1; IOWaiter++; switch (CurrentCommand) { case RESTORE: if (gVirtualDrive[CurrentDisk].HeadPosition!=0) { gVirtualDrive[CurrentDisk].HeadPosition-=1; ExecTimeWaiter=(CyclesperStep * StepTimeMS); if (gVirtualDrive[CurrentDisk].ImageType==RAW) DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle , IOCTL_FDCMD_SEEK, nullptr, 1, nullptr, 0, &dwRet, nullptr); } else { TrackReg=0; StatusReg=READY; StatusReg|=TRACK_ZERO; gVirtualDrive[CurrentDisk].HeadPosition=0; if (gVirtualDrive[CurrentDisk].WriteProtect) StatusReg|=WRITEPROTECT; CommandDone(); } break; case SEEK: if (gVirtualDrive[CurrentDisk].HeadPosition!=DataReg) { if (StepDirection==1) gVirtualDrive[CurrentDisk].HeadPosition+=1; else gVirtualDrive[CurrentDisk].HeadPosition-=1; ExecTimeWaiter=(CyclesperStep * StepTimeMS); } else { gVirtualDrive[CurrentDisk].HeadPosition=TrackReg; StatusReg=READY; if (gVirtualDrive[CurrentDisk].HeadPosition==0) StatusReg|=TRACK_ZERO; if (gVirtualDrive[CurrentDisk].WriteProtect) StatusReg|=WRITEPROTECT; CommandDone(); } if (gVirtualDrive[CurrentDisk].ImageType==RAW) DeviceIoControl(gVirtualDrive[CurrentDisk].FileHandle , IOCTL_FDCMD_SEEK, &TrackReg, sizeof(TrackReg), nullptr, 0, &dwRet, nullptr); break; case STEP: case STEPUPD: if (StepDirection==1) gVirtualDrive[CurrentDisk].HeadPosition+=1; else { if (gVirtualDrive[CurrentDisk].HeadPosition >0) gVirtualDrive[CurrentDisk].HeadPosition-=1; } if (CurrentCommand & 1) { if (StepDirection==1) TrackReg+=1; else TrackReg-=1; } if ( gVirtualDrive[CurrentDisk].HeadPosition == 0) StatusReg=TRACK_ZERO; if (gVirtualDrive[CurrentDisk].WriteProtect) StatusReg|=WRITEPROTECT; StatusReg=READY; CommandDone(); break; case STEPIN: case STEPINUPD: StepDirection=1; gVirtualDrive[CurrentDisk].HeadPosition+=1; if (CurrentCommand & 1) TrackReg+=1; if (gVirtualDrive[CurrentDisk].WriteProtect) StatusReg|=WRITEPROTECT; StatusReg=READY; CommandDone(); break; case STEPOUT: case STEPOUTUPD: StepDirection=0; if ( gVirtualDrive[CurrentDisk].HeadPosition > 0 ) gVirtualDrive[CurrentDisk].HeadPosition-=1; if (CurrentCommand & 1) TrackReg-=1; if ( gVirtualDrive[CurrentDisk].HeadPosition == 0) StatusReg=TRACK_ZERO; if (gVirtualDrive[CurrentDisk].WriteProtect) StatusReg|=WRITEPROTECT; StatusReg=READY; CommandDone(); break; case READSECTOR: case READSECTORM: if (IOWaiter>WAITTIME) { LostDataFlag=1; GetBytefromSector(); } break; case WRITESECTOR: case WRITESECTORM: StatusReg |=DRQ; //IRON if (IOWaiter>WAITTIME) { LostDataFlag=1; // WriteLog("WRITESECTOR TIMEOUT",0); WriteBytetoSector(0); } break; case READADDRESS: if (IOWaiter>WAITTIME) { LostDataFlag=1; GetBytefromAddress (); } break; case FORCEINTERUPT: break; case READTRACK: if (IOWaiter>WAITTIME) { LostDataFlag=1; GetBytefromTrack(); } break; case WRITETRACK: StatusReg|=DRQ; //IRON if (IOWaiter>WAITTIME) { LostDataFlag=1; WriteBytetoTrack(0); } break; case IDLE: break; } return; } void DispatchCommand(unsigned char Tmp) { unsigned char Command= (Tmp >>4); if ( (CurrentCommand !=IDLE) & (Command != 13) ) return; CurrentCommand=Command; switch (Command) { case RESTORE: SetType1Flags(Tmp); ExecTimeWaiter= CyclestoSettle + (CyclesperStep * StepTimeMS); StatusReg= BUSY; // WriteLog("RESTORE",0); break; case SEEK: SetType1Flags(Tmp); ExecTimeWaiter= CyclestoSettle + (CyclesperStep * StepTimeMS); TrackReg=DataReg; StatusReg= BUSY; if ( gVirtualDrive[CurrentDisk].HeadPosition > DataReg) StepDirection=0; else StepDirection=1; // WriteLog("SEEK",0); break; case STEP: case STEPUPD: SetType1Flags(Tmp); ExecTimeWaiter= CyclestoSettle + (CyclesperStep * StepTimeMS); StatusReg= BUSY; // WriteLog("STEP",0); break; case STEPIN: case STEPINUPD: SetType1Flags(Tmp); ExecTimeWaiter= CyclestoSettle + (CyclesperStep * StepTimeMS); StatusReg= BUSY; // WriteLog("STEPIN",0); break; case STEPOUT: case STEPOUTUPD: SetType1Flags(Tmp); ExecTimeWaiter= CyclestoSettle + (CyclesperStep * StepTimeMS); StatusReg= BUSY; // WriteLog("STEPOUT",0); break; case READSECTOR: case READSECTORM: SetType2Flags(Tmp); TransferBufferIndex=0; StatusReg= BUSY | DRQ; GetBytefromDisk=&GetBytefromSector; ExecTimeWaiter= 1; IOWaiter=0; MSectorFlag=Command & 1; // WriteLog("READSECTOR",0); break; case WRITESECTOR: case WRITESECTORM: // WriteLog("Getting WriteSector Command",0); SetType2Flags(Tmp); TransferBufferIndex=0; StatusReg= BUSY; //IRON WriteBytetoDisk=&WriteBytetoSector; ExecTimeWaiter=5; IOWaiter=0; MSectorFlag=Command & 1; // WriteLog("WRITESECTOR",0); break; case READADDRESS: // MessageBox(0,"Hitting Get Address","Ok",0); SetType3Flags(Tmp); TransferBufferIndex=0; StatusReg= BUSY | DRQ; GetBytefromDisk=&GetBytefromAddress; ExecTimeWaiter=1; IOWaiter=0; break; case FORCEINTERUPT: CurrentCommand=IDLE; TransferBufferSize=0; StatusReg=READY; ExecTimeWaiter=1; if ((Tmp & 15) != 0) AssertInt(gSlotId, INT_NMI,IS_NMI); // WriteLog("FORCEINTERUPT",0); break; case READTRACK: // WriteLog("Hitting ReadTrack",0); SetType3Flags(Tmp); TransferBufferIndex=0; StatusReg= BUSY | DRQ; GetBytefromDisk=&GetBytefromTrack; ExecTimeWaiter=1; IOWaiter=0; break; case WRITETRACK: // WriteLog("Getting WriteTrack Command",0); SetType3Flags(Tmp); TransferBufferIndex=0; StatusReg= BUSY ; //IRON WriteBytetoDisk=&WriteBytetoTrack; ExecTimeWaiter=1; ExecTimeWaiter=5; //IRON IOWaiter=0; break; } return; } unsigned char GetBytefromSector () { unsigned char RetVal=0; if (TransferBufferSize == 0) { TransferBufferSize = ReadSector(Side,gVirtualDrive[CurrentDisk].HeadPosition,SectorReg,TransferBuffer); // WriteLog("BEGIN Readsector",0); } if (TransferBufferSize==0)// IRON| (TrackReg != gVirtualDrive[CurrentDrive].HeadPosition) ) //| (SectorReg > gVirtualDrive[CurrentDrive].Sectors) { CommandDone(); StatusReg=RECNOTFOUND; return 0; } if (TransferBufferIndex < TransferBufferSize) { RetVal=TransferBuffer[TransferBufferIndex++]; StatusReg= BUSY | DRQ; IOWaiter=0; // WriteLog("Transfering 1 Byte",0); } else { // WriteLog("READSECTOR DONE",0); StatusReg=READY; CommandDone(); if (LostDataFlag==1) { StatusReg=LOSTDATA; LostDataFlag=0; } SectorReg++; } return RetVal; } unsigned char GetBytefromAddress () { unsigned char RetVal=0; unsigned short Crc=0; if (TransferBufferSize == 0) { switch (gVirtualDrive[CurrentDisk].ImageType) { case JVC: case VDK: case OS9: TransferBuffer[0]= gVirtualDrive[CurrentDisk].HeadPosition; TransferBuffer[1]= gVirtualDrive[CurrentDisk].Sides; TransferBuffer[2]= IndexCounter/176; TransferBuffer[3]= gVirtualDrive[CurrentDisk].SectorSize; TransferBuffer[4]= (Crc >> 8); TransferBuffer[5]= (Crc & 0xFF); TransferBufferSize=6; break; case DMK: TransferBuffer[0]= gVirtualDrive[CurrentDisk].HeadPosition; //CurrentSector.Track; not right need to get from image TransferBuffer[1]= gVirtualDrive[CurrentDisk].Sides; TransferBuffer[2]= IndexCounter/176; TransferBuffer[3]= IndexCounter/176; //gVirtualDrive[CurrentDrive].SectorSize; Crc = 0;//CurrentSector.CRC; TransferBuffer[4]= (Crc >> 8); TransferBuffer[5]= (Crc & 0xFF); TransferBufferSize=6; break; } //END Switch } if ( gVirtualDrive[CurrentDisk].FileHandle==nullptr ) { StatusReg=RECNOTFOUND; CommandDone(); return 0; } if (TransferBufferIndex < TransferBufferSize) { RetVal=TransferBuffer[TransferBufferIndex++]; StatusReg= BUSY | DRQ; IOWaiter=0; } else { StatusReg=READY; CommandDone(); if (LostDataFlag==1) { StatusReg=LOSTDATA; LostDataFlag=0; } } return RetVal; } unsigned char GetBytefromTrack () { unsigned char RetVal=0; if (TransferBufferSize == 0) { TransferBufferSize = ReadTrack(Side,gVirtualDrive[CurrentDisk].HeadPosition,SectorReg,TransferBuffer); // WriteLog("BEGIN READTRACK",0); } if (TransferBufferSize==0)//iron | (TrackReg != gVirtualDrive[CurrentDrive].HeadPosition) ) //| (SectorReg > gVirtualDrive[CurrentDrive].Sectors) { CommandDone(); StatusReg=RECNOTFOUND; return 0; } if (TransferBufferIndex < TransferBufferSize) { RetVal=TransferBuffer[TransferBufferIndex++]; StatusReg= BUSY | DRQ; IOWaiter=0; } else { // WriteLog("READTRACK DONE",0); StatusReg=READY; CommandDone(); if (LostDataFlag==1) { StatusReg=LOSTDATA; LostDataFlag=0; } SectorReg++; } return RetVal; } unsigned char WriteBytetoSector (unsigned char Tmp) { unsigned long BytesRead=0,Result=0; long FileOffset=0,RetVal=0; unsigned char TempBuffer[16384]; SectorInfo CurrentSector; if (TransferBufferSize==0) { // WriteLog("Begining WriteSector data collection Command",0); switch (gVirtualDrive[CurrentDisk].ImageType) { case JVC: case VDK: case OS9: TransferBufferSize=BytesperSector[gVirtualDrive[CurrentDisk].SectorSize]; if ((TransferBufferSize==0) | (TrackReg != gVirtualDrive[CurrentDisk].HeadPosition) | (SectorReg > gVirtualDrive[CurrentDisk].Sectors) ) { StatusReg=RECNOTFOUND; CommandDone(); return 0; } break; case DMK: FileOffset= gVirtualDrive[CurrentDisk].HeaderSize + ( (gVirtualDrive[CurrentDisk].HeadPosition * gVirtualDrive[CurrentDisk].Sides * gVirtualDrive[CurrentDisk].TrackSize)+ (Side * gVirtualDrive[CurrentDisk].TrackSize)); Result=SetFilePointer(gVirtualDrive[CurrentDisk].FileHandle,FileOffset,nullptr,FILE_BEGIN); ReadFile(gVirtualDrive[CurrentDisk].FileHandle,TempBuffer,gVirtualDrive[CurrentDisk].TrackSize,&BytesRead,nullptr); CurrentSector.Sector=SectorReg; GetSectorInfo(&CurrentSector,TempBuffer); if ( (CurrentSector.DAM == 0) | (BytesRead != gVirtualDrive[CurrentDisk].TrackSize) ) { StatusReg=RECNOTFOUND; CommandDone(); return 0; } TransferBufferSize = CurrentSector.Lenth; break; case RAW: TransferBufferSize = 256; break; } //END Switch } //END if if (TransferBufferIndex>=TransferBufferSize) { RetVal=WriteSector(Side,gVirtualDrive[CurrentDisk].HeadPosition,SectorReg,TransferBuffer,TransferBufferSize); StatusReg=READY; if (( RetVal==0) | (LostDataFlag==1) ) StatusReg=LOSTDATA; if (gVirtualDrive[CurrentDisk].WriteProtect != 0) StatusReg=WRITEPROTECT | RECNOTFOUND; CommandDone(); LostDataFlag=0; SectorReg++; } else { TransferBuffer[TransferBufferIndex++]=Tmp; StatusReg= BUSY | DRQ; IOWaiter=0; } return 0; } unsigned char WriteBytetoTrack (unsigned char Tmp) { long RetVal=0; if (TransferBufferSize==0) TransferBufferSize=6272 ; if (TransferBufferIndex>=TransferBufferSize) { RetVal=WriteTrack(Side,gVirtualDrive[CurrentDisk].HeadPosition,SectorReg,TransferBuffer); StatusReg=READY; if (( RetVal==0) | (LostDataFlag==1) ) StatusReg=LOSTDATA; if (gVirtualDrive[CurrentDisk].WriteProtect != 0) StatusReg=WRITEPROTECT | RECNOTFOUND; CommandDone(); LostDataFlag=0; } else { TransferBuffer[TransferBufferIndex++]=Tmp; StatusReg= BUSY | DRQ; IOWaiter=0; } return 0; } void SetType1Flags(unsigned char Tmp) { Tmp&=15; HeadLoad= (Tmp>>3)&1; TrackVerify= (Tmp>>2)&1; StepTimeMS = StepTimesMS[Tmp & 3]; return; } void SetType2Flags(unsigned char Tmp) { Tmp&=15; SideCompare= (Tmp>>3)&1; SideCompareEnable=(Tmp>>1)&1; Delay15ms=(Tmp>>2)&1; return; } void SetType3Flags(unsigned char Tmp) { Delay15ms=(Tmp>>2)&1; return; } unsigned char SetTurboDisk( unsigned char Tmp) { if (Tmp!=QUERY) { TurboMode=Tmp&1; switch (TurboMode) { case 0: CyclestoSettle=SETTLETIME; CyclesperStep=STEPTIME; break; case 1: CyclestoSettle=1; CyclesperStep=0; break; } } return TurboMode; } long GetSectorInfo (SectorInfo *Sector,const unsigned char *TempBuffer) { unsigned short Temp1=0,Temp2=0; unsigned char Density=0; long IdamIndex=0; do //Scan IDAM table for correct sector { Temp1= (TempBuffer[IdamIndex+1]<<8) | TempBuffer[IdamIndex]; //Reverse Bytes and Get the pointer Density= Temp1>>15; //Density flag Temp1= (0x3FFF & Temp1) % gVirtualDrive[CurrentDisk].TrackSize; //Mask and keep from overflowing IdamIndex+=2; } while ( (IdamIndex<128) & (Temp1 !=0) & (Sector->Sector != TempBuffer[Temp1+3]) ); if ((Temp1 ==0) | (IdamIndex>128) ) return 0; //Can't Find the Specified Sector on this track //At this point Temp1 should be pointing to the IDAM $FE for the track in question Sector->Track = TempBuffer[Temp1+1]; Sector->Side = TempBuffer[Temp1+2]; Sector->Sector = TempBuffer[Temp1+3]; Sector->Lenth = BytesperSector[ TempBuffer[Temp1+4] & 3]; //128 256 512 1024 Sector->CRC = (TempBuffer[Temp1+5]<<8) | TempBuffer[Temp1+6] ; Sector->Density = Density; if ( (Sector->Track != TrackReg) | (Sector->Sector != SectorReg) ) return 0; Temp1+=7; //Ignore the CRC Temp2=Temp1+43; //Scan for D.A.M. while ( (TempBuffer[Temp1] !=0xFB) & (Temp1DAM = Temp1+1; Sector->CRC = ccitt_crc16(0xE295, &TempBuffer[Sector->DAM], Sector->Lenth); return(Sector->DAM); //Return Pointer to Start of sector data } void CommandDone() { if (InteruptEnable) AssertInt(gSlotId, INT_NMI,IS_NMI); TransferBufferSize=0; CurrentCommand=IDLE; } //Stolen from MESS /* Compute CCITT CRC-16 using the correct bit order for floppy disks. CRC code courtesy of Tim Mann. */ /* Accelerator table to compute the CRC eight bits at a time */ static const unsigned short ccitt_crc16_table[256] = { 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 }; unsigned short ccitt_crc16(unsigned short crc, const unsigned char *buffer, unsigned short buffer_len) { unsigned short i; for (i = 0; i < buffer_len; i++) crc = (crc << 8) ^ ccitt_crc16_table[(crc >> 8) ^ buffer[i]]; return crc; } //Stolen from fdrawcmd.sys Demo Disk Utility by Simon Owen DWORD GetDriverVersion () { DWORD dwVersion = 0; HANDLE h = CreateFile("\\\\.\\fdrawcmd", GENERIC_READ|GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr); if (h != INVALID_HANDLE_VALUE) { DeviceIoControl(h, IOCTL_FDRAWCMD_GET_VERSION, nullptr, 0, &dwVersion, sizeof(dwVersion), &dwRet, nullptr); CloseHandle(h); } return dwVersion; } HANDLE OpenFloppy (int nDrive_) { char szDevice[32],szTemp[128]=""; HANDLE h=nullptr; wsprintf(szDevice, "\\\\.\\fdraw%u", nDrive_); h = CreateFile(szDevice, GENERIC_READ|GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr); if (h == INVALID_HANDLE_VALUE) { sprintf(szTemp,"Unable to open RAW device %s",szDevice); MessageBox(nullptr,szTemp,"Ok",0); } return (h != INVALID_HANDLE_VALUE && SetDataRate(h, DISK_DATARATE)) ? h : nullptr; } bool SetDataRate (HANDLE h_, BYTE bDataRate_) { return !!DeviceIoControl(h_,IOCTL_FD_SET_DATA_RATE,&bDataRate_,sizeof(bDataRate_),nullptr,0,&dwRet,nullptr); } bool FormatTrack (HANDLE h_, BYTE cyl_, BYTE head_, BYTE Fill) { BYTE abFormat[sizeof(FD_FORMAT_PARAMS) + sizeof(FD_ID_HEADER)*DISK_SECTORS]; PFD_FORMAT_PARAMS pfp = (PFD_FORMAT_PARAMS)abFormat; pfp->flags = FD_OPTION_MFM; pfp->phead = head_; pfp->size = SECTOR_SIZE_CODE; pfp->sectors = DISK_SECTORS; pfp->gap = SECTOR_GAP3; pfp->fill = Fill;//SECTOR_FILL; PFD_ID_HEADER ph = pfp->Header; for (BYTE s = 0 ; s < pfp->sectors ; s++, ph++) { ph->cyl = cyl_; ph->head = head_; ph->sector = SECTOR_BASE + ((s + cyl_*(pfp->sectors - TRACK_SKEW)) % pfp->sectors); ph->size = pfp->size; } return CmdFormat(h_, pfp, (PBYTE)ph - abFormat); } bool CmdFormat (HANDLE h_, PFD_FORMAT_PARAMS pfp_, ULONG ulSize_) { return !!DeviceIoControl(h_, IOCTL_FDCMD_FORMAT_TRACK, pfp_, ulSize_, nullptr, 0, &dwRet, nullptr); } unsigned short InitController () { long RawDriverVersion=0; RawDriverVersion=GetDriverVersion (); if (RawReadBuf==nullptr) RawReadBuf = VirtualAlloc(nullptr, 4608, MEM_COMMIT, PAGE_READWRITE); if (RawReadBuf==nullptr) return 0; return 1; }