494 lines
13 KiB
C
494 lines
13 KiB
C
/***** floppy.c ******************************************************
|
|
* (c) 2010 CTA Systems Inc. All rights reserved. Glory To God *
|
|
* *
|
|
* Floppy Drive I/O Routines *
|
|
* ========================= *
|
|
* *
|
|
************************************************************ cta os */
|
|
#include <system.h>
|
|
#include <conio.h>
|
|
#include <time.h>
|
|
#include "dma.h"
|
|
#include "storage.h"
|
|
|
|
unsigned char CmosReadFloppyData ()
|
|
{
|
|
outportb (0x70, 0x10);
|
|
return inportb(0x71);
|
|
}
|
|
|
|
unsigned char FloppyDrivesInstalled;
|
|
volatile unsigned char FloppyNewInterrupt;
|
|
|
|
|
|
typedef struct {
|
|
unsigned char Type;
|
|
unsigned Size;
|
|
unsigned char SectorsPerTrack;
|
|
unsigned char Heads;
|
|
unsigned char Tracks;
|
|
unsigned char DataRate;
|
|
unsigned char StepRateTime;
|
|
unsigned char HeadLoadTime;
|
|
unsigned char HeadUnloadTime;
|
|
unsigned char Gap3;
|
|
unsigned char Gap3Format;
|
|
} FloppyType;
|
|
|
|
FloppyType fd[2];
|
|
|
|
void FloppyReset();
|
|
enum FloppyRegisters {
|
|
FloppyRegDOR = 0x3f2,
|
|
FloppyRegMSR = 0x3f4,
|
|
FloppyRegFIFO = 0x3f5,
|
|
FloppyRegCTRL = 0x3f7
|
|
};
|
|
|
|
enum FloppyCommands {
|
|
FloppyCommandReadTrack = 2,
|
|
FloppyCommandSpecify = 3,
|
|
FloppyCommandCheckStatus = 4,
|
|
FloppyCommandWriteSector = 5,
|
|
FloppyCommandReadSector = 6,
|
|
FloppyCommandCalibrate = 7,
|
|
FloppyCommandCheckInt = 8,
|
|
FloppyCommandFormatTrack = 0xd,
|
|
FloppyCommandSeek = 0xf,
|
|
|
|
FloppyCommandExtSkip = 0x20,
|
|
FloppyCommandExtDensity = 0x40,
|
|
FloppyCommandExtMultiTrack = 0x80
|
|
};
|
|
|
|
// Initialize DMA
|
|
unsigned char FloppyInitializeDMA(unsigned char* buffer, unsigned length)
|
|
{
|
|
union { unsigned char byt[4]; // Low[0], Mid[1], Hi[2]
|
|
unsigned long l;
|
|
} a, c;
|
|
|
|
a.l = (unsigned) buffer;
|
|
c.l = (unsigned) length-1;
|
|
|
|
// Check for buffer issues
|
|
if ((a.l >> 24) || (c.l >> 16) || (((a.l & 0xffff)+c.l) >> 16)) return 0;
|
|
|
|
DMAReset();
|
|
DMAMaskChannel(2); // Mask channel 2
|
|
DMAResetFlipFlop(1); // FlipFlop reset on DMA1
|
|
|
|
DMASetAddress(2, a.byt[0], a.byt[1]); // Buffer address
|
|
DMAResetFlipFlop(1); // FlipFlop reset on DMA2
|
|
|
|
DMASetCount(2, c.byt[0], c.byt[1]); // Set count
|
|
DMASetRead(2);
|
|
DMAUnmaskAll();
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
inline void FloppyDisableController() {
|
|
outportb (FloppyRegDOR, 0);
|
|
}
|
|
|
|
inline void FloppyEnableController() {
|
|
outportb (FloppyRegDOR, 4 | 8);
|
|
}
|
|
|
|
|
|
inline unsigned char FloppySendCommand (unsigned char command)
|
|
{
|
|
int i;
|
|
for (i = 0; i < 750; i++)
|
|
if (inportb(FloppyRegMSR) & 128) {
|
|
outportb(FloppyRegFIFO, command); return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
inline unsigned char FloppyReadData ()
|
|
{
|
|
int i;
|
|
for (i = 0; i < 750; i++)
|
|
if (inportb(FloppyRegMSR) & 0x80)
|
|
return inportb(FloppyRegFIFO);
|
|
return 0;
|
|
}
|
|
|
|
|
|
inline void FloppyCheckInt(unsigned* st0, unsigned* cyl)
|
|
{
|
|
int t;
|
|
for (t=3; t>=0; t--) {
|
|
if (!FloppySendCommand(0x8)) FloppyReset();
|
|
else break;
|
|
}
|
|
for (t=50; !(inportb(FloppyRegMSR) & 0x80) && t>0; --t);
|
|
|
|
*st0 = FloppyReadData();
|
|
*cyl = FloppyReadData();
|
|
}
|
|
|
|
|
|
inline unsigned char FloppyWaitIRQ()
|
|
{
|
|
unsigned tick = ClockGetTickCount();
|
|
unsigned freq = PitGetFrequency();
|
|
tick = tick + (freq * 3); // Wait 3 seconds
|
|
|
|
while (FloppyNewInterrupt==0)
|
|
if (tick <= ClockGetTickCount()) return 0; // timeout
|
|
|
|
FloppyNewInterrupt = 0;
|
|
return 1;
|
|
}
|
|
|
|
|
|
void FloppyMotor (unsigned char drive, unsigned char on)
|
|
{
|
|
if (drive >= FloppyDrivesInstalled) return;
|
|
|
|
// Read DOR register
|
|
unsigned char dor = inportb(FloppyRegDOR);
|
|
|
|
// Un/set selected drive motor
|
|
if (on) dor |= 1 << (4+drive);
|
|
else dor &= ~(1 << (4+drive));
|
|
|
|
// Write DOR
|
|
outportb (FloppyRegDOR, dor);
|
|
|
|
// Wait a fifth of a second for motor to turn on
|
|
unsigned temp = ClockGetTickCount();
|
|
unsigned freq = PitGetFrequency();
|
|
while (temp + (freq/5) > ClockGetTickCount());
|
|
}
|
|
|
|
|
|
void i86_FloppyHandler(ISR_stack_regs *r)
|
|
{
|
|
FloppyNewInterrupt = 1;
|
|
}
|
|
|
|
|
|
void FloppyDriveData (unsigned char drv, unsigned char dma)
|
|
{
|
|
unsigned data = 0;
|
|
if (drv >= FloppyDrivesInstalled) return;
|
|
|
|
outportb(FloppyRegCTRL, fd[drv].DataRate);
|
|
|
|
FloppySendCommand (0x3);
|
|
|
|
data = ((fd[drv].StepRateTime & 0xf) << 4) | (fd[drv].HeadUnloadTime & 0xf);
|
|
FloppySendCommand (data);
|
|
|
|
data = (fd[drv].HeadLoadTime <<1 ) | (dma) ? 1 : 0;
|
|
FloppySendCommand (data);
|
|
}
|
|
|
|
|
|
inline void FloppySelect(unsigned char drive)
|
|
{
|
|
if (drive >= FloppyDrivesInstalled) return;
|
|
|
|
unsigned char dor = inportb(FloppyRegDOR) & 0xf0;
|
|
|
|
// Send mechanical drive data
|
|
FloppyDriveData(drive, 1);
|
|
|
|
// Select drive in DOR register
|
|
outportb (FloppyRegDOR, dor | 4 | 8 | drive);
|
|
|
|
}
|
|
|
|
|
|
unsigned char FloppyCalibrate(unsigned drive)
|
|
{
|
|
unsigned st0, cyl;
|
|
|
|
if (drive >= FloppyDrivesInstalled) return 0;
|
|
|
|
FloppyMotor (drive, 1);
|
|
|
|
int i;
|
|
for (i = 0; i < 15; i++) {
|
|
FloppyNewInterrupt = 0;
|
|
FloppySendCommand(FloppyCommandCalibrate);
|
|
FloppySendCommand(drive);
|
|
FloppyWaitIRQ();
|
|
FloppyCheckInt(&st0, &cyl);
|
|
|
|
if (!cyl) {
|
|
FloppyMotor(drive, 0);
|
|
return 1;
|
|
}
|
|
}
|
|
FloppyMotor(drive, 0);
|
|
return 0;
|
|
}
|
|
|
|
|
|
void FloppyReset()
|
|
{
|
|
unsigned st0, cyl;
|
|
|
|
FloppyNewInterrupt = 0;
|
|
FloppyDisableController();
|
|
FloppyEnableController();
|
|
FloppyWaitIRQ();
|
|
|
|
int i;
|
|
for (i = 0; i < 4; i++)
|
|
FloppyCheckInt(&st0, &cyl);
|
|
|
|
unsigned char drive;
|
|
for (drive = 0; drive < FloppyDrivesInstalled; drive++) {
|
|
FloppyDriveData(drive, 1);
|
|
FloppyCalibrate(drive);
|
|
}
|
|
}
|
|
|
|
|
|
unsigned FloppyReadSectorImp (unsigned* where, unsigned char drive, unsigned char head, unsigned char track, unsigned char sector)
|
|
{
|
|
int t, fail;
|
|
for (t=3; t>=0; t--) {
|
|
fail = 0;
|
|
FloppySelect (drive);
|
|
FloppyInitializeDMA((unsigned char*) where, 512);
|
|
DMASetRead(2);
|
|
|
|
FloppyNewInterrupt = 0;
|
|
|
|
fail += 1-FloppySendCommand(0x06 | 0x80 | 0x40 );
|
|
fail += 1-FloppySendCommand(head<<2 | drive);
|
|
fail += 1-FloppySendCommand(track);
|
|
fail += 1-FloppySendCommand(head);
|
|
fail += 1-FloppySendCommand(sector);
|
|
fail += 1-FloppySendCommand(2);
|
|
fail += 1-FloppySendCommand( ((sector+1) >= fd[drive].SectorsPerTrack) ? fd[drive].SectorsPerTrack : sector+1);
|
|
fail += 1-FloppySendCommand(fd[drive].Gap3);
|
|
fail += 1-FloppySendCommand(0xff);
|
|
|
|
if (fail) {
|
|
FloppyReset(); continue;
|
|
}
|
|
|
|
FloppyWaitIRQ();
|
|
while (!(inportb(FloppyRegMSR) & 0x80));
|
|
|
|
int i; unsigned ccc=0;
|
|
|
|
for (i = 0; i < 7; i++) {
|
|
if (i<3) ccc |= FloppyReadData() << (i*4);
|
|
else FloppyReadData();
|
|
}
|
|
|
|
return ccc;
|
|
}
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
|
|
unsigned FloppyWriteSectorImp (unsigned* where, unsigned char drive, unsigned char head, unsigned char track, unsigned char sector)
|
|
{
|
|
int t, fail;
|
|
for (t=3; t>=0; t--) {
|
|
fail = 0;
|
|
FloppySelect (drive);
|
|
FloppyInitializeDMA((unsigned char*) where, 512);
|
|
DMASetWrite(2);
|
|
|
|
FloppyNewInterrupt = 0;
|
|
|
|
fail += 1-FloppySendCommand(0x05 | 0x80 | 0x40 );
|
|
fail += 1-FloppySendCommand(head<<2 | drive);
|
|
fail += 1-FloppySendCommand(track);
|
|
fail += 1-FloppySendCommand(head);
|
|
fail += 1-FloppySendCommand(sector);
|
|
fail += 1-FloppySendCommand(2);
|
|
fail += 1-FloppySendCommand( ((sector+1) >= fd[drive].SectorsPerTrack) ? fd[drive].SectorsPerTrack : sector+1);
|
|
fail += 1-FloppySendCommand(fd[drive].Gap3);
|
|
fail += 1-FloppySendCommand(0xff);
|
|
|
|
if (fail) {
|
|
FloppyReset(); continue;
|
|
}
|
|
|
|
FloppyWaitIRQ();
|
|
|
|
int i; unsigned ccc=0;
|
|
for (i = 0; i < 7; i++)
|
|
if (i<3) ccc |= FloppyReadData() << (i*4);
|
|
else FloppyReadData();
|
|
|
|
return ccc;
|
|
}
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
unsigned char FloppySeek (unsigned drive, unsigned cyl, unsigned head)
|
|
{
|
|
unsigned st0, cyl0;
|
|
|
|
if (drive >= FloppyDrivesInstalled) return 0;
|
|
|
|
FloppySelect (drive);
|
|
|
|
int i;
|
|
for (i = 0; i < 20; i++) {
|
|
FloppyNewInterrupt = 0;
|
|
FloppySendCommand (0xF);
|
|
FloppySendCommand ( (head) << 2 | drive);
|
|
FloppySendCommand (cyl);
|
|
|
|
FloppyWaitIRQ();
|
|
FloppyCheckInt(&st0, &cyl0);
|
|
|
|
if (cyl0 == cyl) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
inline void FloppyLBAtoCHS (int lba, unsigned char drive, unsigned char *head, unsigned char *track, unsigned char *sectors)
|
|
{
|
|
*head = (lba % (fd[drive].SectorsPerTrack * 2)) / fd[drive].SectorsPerTrack;
|
|
*track = lba / (fd[drive].SectorsPerTrack * 2);
|
|
*sectors = lba % fd[drive].SectorsPerTrack + 1;
|
|
}
|
|
|
|
|
|
/*const char* types[] = {
|
|
"Nonexistant", "5.25\", unsupported.", "5.25\", unsupported.",
|
|
"3.5\", 720kb", "3.5\", 1.44mb", "3.5\", 2.88 mb"};*/
|
|
|
|
void FloppyInstall()
|
|
{
|
|
unsigned char temp = CmosReadFloppyData();
|
|
int i;
|
|
|
|
// Set fd0 and fd1 types
|
|
fd[1].Type = temp & 0xf;
|
|
fd[0].Type = temp >> 4;
|
|
|
|
// SRT = 16 - (ms * datarate / 500000);
|
|
// HLT = ms * datarate / 1000000
|
|
// HUT = ms * datarate / 8000000
|
|
|
|
// Set up
|
|
for (i = 0; i < 2; i++) {
|
|
if (fd[i].Type >= 3) FloppyDrivesInstalled++; // 5.25" drives unsupported
|
|
if (fd[i].Type == 3) { // 720 kb, DD
|
|
fd[i].DataRate = 2; // speed = 250 kbps
|
|
fd[i].StepRateTime = 12; // 16 - (ms * 250000 / 500000), ms = 8
|
|
fd[i].HeadLoadTime = 7;
|
|
fd[i].HeadUnloadTime = 7;
|
|
fd[i].SectorsPerTrack = 9;
|
|
fd[i].Size = 1440;
|
|
fd[i].Gap3 = 0x2A;
|
|
fd[i].Gap3Format = 0x50;
|
|
fd[i].Heads = 2;
|
|
fd[i].Tracks = 80;
|
|
}
|
|
else if (fd[i].Type == 4) { // 1.44 MB, HD
|
|
fd[i].DataRate = 0; // speed = 500 kbps
|
|
fd[i].StepRateTime = 8;
|
|
fd[i].HeadLoadTime = 15;
|
|
fd[i].HeadUnloadTime = 15;
|
|
fd[i].SectorsPerTrack = 18;
|
|
fd[i].Size = 2880;
|
|
fd[i].Gap3 = 0x1B;
|
|
fd[i].Gap3Format = 0x6C;
|
|
fd[i].Heads = 2;
|
|
fd[i].Tracks = 80;
|
|
}
|
|
else if (fd[i].Type == 5) { // 2.88 MB, ED
|
|
fd[i].DataRate = 3; // speed = 1000 kbps;
|
|
fd[i].StepRateTime = 0;
|
|
fd[i].HeadLoadTime = 30;
|
|
fd[i].HeadUnloadTime = 30;
|
|
fd[i].SectorsPerTrack = 36;
|
|
fd[i].Size = 5760;
|
|
fd[i].Gap3 = 0x1B;
|
|
fd[i].Gap3Format = 0x54;
|
|
fd[i].Heads = 2;
|
|
fd[i].Tracks = 80;
|
|
}
|
|
}
|
|
if (FloppyDrivesInstalled == 0) return; // No drives to set
|
|
|
|
|
|
FloppyReset();
|
|
}
|
|
|
|
|
|
unsigned char FloppyIsDriverEnabled()
|
|
{
|
|
return FloppyDrivesInstalled;
|
|
}
|
|
|
|
unsigned* FloppyReadSectors (unsigned* where, unsigned char drive, int sectorLBA, unsigned count)
|
|
{
|
|
if (drive >= FloppyDrivesInstalled || !where) return 0;
|
|
|
|
unsigned head=0, track=0, sector=1, i, addr = (unsigned)where;
|
|
|
|
// start motor, seek to track
|
|
FloppyMotor(drive, 1);
|
|
|
|
// read count sectors
|
|
for (i=0; i<count; i++) {
|
|
|
|
// Convert lba to chs
|
|
head=0, track=0, sector=1;
|
|
FloppyLBAtoCHS(sectorLBA+i, drive, (unsigned char*)&head, (unsigned char*)&track, (unsigned char*) §or);
|
|
|
|
// Seek
|
|
if (!FloppySeek(drive, track, head)) return 0;
|
|
|
|
// Read the sector
|
|
FloppyReadSectorImp((unsigned*)0x7e00, drive, head, track, sector);
|
|
|
|
memcpy((void*)(addr+(0x200*i)), (void*)0x7e00, 0x200);
|
|
}
|
|
|
|
FloppyMotor(drive, 0);
|
|
|
|
return (unsigned*)where;
|
|
}
|
|
|
|
unsigned* FloppyWriteSectors (unsigned* where, unsigned char drive, int sectorLBA, unsigned count)
|
|
{
|
|
if (drive >= FloppyDrivesInstalled || !where) return 0;
|
|
|
|
unsigned head=0, track=0, sector=1, i, addr = (unsigned)where;
|
|
|
|
// start motor, seek to track
|
|
FloppyMotor(drive, 1);
|
|
|
|
// read count sectors
|
|
for (i=0; i<count; i++) {
|
|
memcpy((void*)0x7e00, (void*)(addr+(0x200*i)), 0x200);
|
|
where = where+0x200;
|
|
// Convert lba to chs
|
|
head=0, track=0, sector=1;
|
|
FloppyLBAtoCHS(sectorLBA+i, drive, (unsigned char*)&head, (unsigned char*)&track, (unsigned char*) §or);
|
|
|
|
// Seek
|
|
if (!FloppySeek(drive, track, head)) return 0;
|
|
|
|
// Read the sector
|
|
FloppyWriteSectorImp((unsigned*)0x7e00, drive, head, track, sector);
|
|
}
|
|
|
|
FloppyMotor(drive, 0);
|
|
|
|
return (unsigned*)where;
|
|
} |