---

Floppy Disk
[Device Drivers]

Functions
void	fdc_sendbyte (byte b)
	Send a byte to the FDC controller. Parameters: b  The byte to send.
int	fdc_getbyte ()
	Get a byte from the FDC controller. Returns: The byte read from the controller. Exceptions: NULL  If timeout is elapsed.
void	fdc_motor_on ()
	Turn the floppy motor on.
void	fdc_motor_off ()
	Starts the FDC motor kill countdown.
bool	fdc_wait (bool sensei)
	Wait for a FDC operation. Parameters: sensei  TRUE if a "sense interrupt status" command is required; FALSE for a simple timeout wait. Returns: TRUE if the operation has successfully done; FALSE if the timeout has been elapsed.
void	fdc_recalibrate ()
	Recalibrate the floppy drive.
bool	fdc_seek (int track)
	Seek a track. Parameters: track  The track to seek. Returns: TRUE on success; FALSE if an error occurs.
void	fdc_reset ()
	Reset the floppy disk controller.
void	lba2chs (int lba, int *track, int *head, int *sector)
	Convert from a LBA (Linear Block Address) address to a CHS (Cylinder, Head, Sector) coordinates. Parameters: lba  The LBA address. track  A pointer to the track coordinate. head  A pointer to the head coordinate. sector  A pointer to the sector coordinate.
bool	fdc_rw (int block, byte *buffer, bool do_read)
	Perform a read/write operation with the floppy drive using the DMA (Direct Memory Access). Parameters: block  The LBA address of the block on the floppy. buffer  The address of the buffer in memory for the transfer operation. It must have a size of at least FDC_SECTOR_SIZE bytes. do_read  TRUE to perform a read operation (from disk to memory); FALSE to perform a write operation (from memory to disk). Returns: TRUE on success; FALSE if an error occurs.
bool	fdc_read (int block, byte *buffer, uint32_t count)
	Read some contiguous blocks from the floppy disk. Parameters: block  The starting block to read. buffer  The destination buffer in memory where the blocks will be copied. count  How many blocks to read. Returns: TRUE on success; FALSE if an error occurs.
bool	fdc_write (int block, byte *buffer, uint32_t count)
	Write some contiguous blocks to the floppy disk. Parameters: block  The starting block to write. buffer  The address in memory from which the data will be copied. count  How many blocks to write. Returns: TRUE on success; FALSE if an error occurs.
bool	fdc_is_changed ()
	Check if the floppy disk was changed. Returns: TRUE if the disk was changed; FALSE otherwise.
void	floppy_thread ()
	This is a routine called from clock_thread() at every clock tick to perform the floppy motor kill countdown and to control the floppy timeouts.
bool	init_floppy ()
	Initialize the floppy driver. Returns: TRUE on success; FALSE if an error occurs.
Variables
volatile bool	fdc_motor = FALSE
	Motor on flag.
volatile int	fdc_timeout = 0
	FDC timeout.
volatile int	fdc_motor_countdown = 0
	Floppy motor kill countdown.
volatile bool	fdc_done = FALSE
	FDC operation finish.
volatile bool	fdc_change = FALSE
	Disk change flag.
volatile byte	fdc_status [7] = { 0 }
	FDC status (result output).
volatile byte	fdc_track = 0xFF
	Current head position.
volatile byte	ST0 = 0
	Status register 0.
floppy_struct	floppy_type []
	Floppy types known from the system.
byte	fdc_geometry = 0
	Current floppy geometry.
byte *	fdc_buffer
	Floppy r/w buffer.

---

Detailed Description

The floppy disk driver.

---

Function Documentation

int fdc_getbyte (    )

Get a byte from the FDC controller. Returns: The byte read from the controller. Exceptions: NULL  If timeout is elapsed. Definition at line 88 of file floppy.c. { int msr; int tmo; for (tmo=0; tmo<128; tmo++) { msr = inportb(FDC_MSR); if ((msr & 0xD0) == 0xD0) return(inportb(FDC_DATA)); inportb(0x80); //delay // } return(-1); // timeout // }

bool fdc_is_changed (    )

Check if the floppy disk was changed. Returns: TRUE if the disk was changed; FALSE otherwise. Definition at line 411 of file floppy.c. { return(fdc_change); }

void fdc_motor_off (    )

Starts the FDC motor kill countdown. Definition at line 116 of file floppy.c. { if (fdc_motor && (fdc_motor_countdown==-1)) fdc_motor_countdown = FDC_TIME_MOTOR_OFF/1000*HZ; }

void fdc_motor_on (    )

Turn the floppy motor on. Definition at line 104 of file floppy.c. { if (!fdc_motor) { outportb(FDC_DOR, 0x1C); delay(FDC_TIME_MOTOR_SPINUP); fdc_motor = TRUE; } fdc_motor_countdown = -1; }

bool fdc_read (  int    block, byte *    buffer, uint32_t    count )

Read some contiguous blocks from the floppy disk. Parameters: block  The starting block to read. buffer  The destination buffer in memory where the blocks will be copied. count  How many blocks to read. Returns: TRUE on success; FALSE if an error occurs. Definition at line 376 of file floppy.c. { register int i; for(i=0; i<count; i++) if (!(fdc_rw(block+i, buffer+(FDC_SECTOR_SIZE*i), TRUE))) return(FALSE); // Read operation OK! // return(TRUE); }

void fdc_recalibrate (    )

Recalibrate the floppy drive. Definition at line 178 of file floppy.c. { // Turn the motor on // fdc_motor_on(); // Send recalibrate command // fdc_sendbyte(CMD_RECAL); fdc_sendbyte(0); // Wait until recalibrate command is finished // fdc_wait(TRUE); // Turn the motor off // fdc_motor_off(); }

void fdc_reset (    )

Reset the floppy disk controller. Definition at line 235 of file floppy.c. { // Stop the motor and disable IRQ // outportb(FDC_DOR, 0x00); // Program data rate (500K/s) // outportb(FDC_DSR, 0x00); // re-enable floppy IRQ // outportb(FDC_DOR, 0x0C); // Wait for fdc // fdc_done = TRUE; fdc_wait(TRUE); // Specify drive timings // fdc_sendbyte(CMD_SPECIFY); fdc_sendbyte(0xDF); // SRT = 3ms, HUT = 240ms fdc_sendbyte(0x02); // HLT = 4ms, ND = 0 (DMA mode selected) // Clear disk change flag // fdc_seek(1); fdc_recalibrate(); fdc_change = FALSE; }

bool fdc_rw (  int    block, byte *    buffer, bool    do_read )

Perform a read/write operation with the floppy drive using the DMA (Direct Memory Access). Parameters: block  The LBA address of the block on the floppy. buffer  The address of the buffer in memory for the transfer operation. It must have a size of at least FDC_SECTOR_SIZE bytes. do_read  TRUE to perform a read operation (from disk to memory); FALSE to perform a write operation (from memory to disk). Returns: TRUE on success; FALSE if an error occurs. Definition at line 289 of file floppy.c. { int track, head, sector, tries; // Translate the logical address into CHS address // lba2chs(block, &track, &head, &sector); // Spin up the motor // fdc_motor_on(); if (!do_read) // Write operation => copy data from buffer into fdc_buffer // memcpy(fdc_buffer, buffer, FDC_SECTOR_SIZE); for(tries=0; tries<3; tries++) { // Check for disk changed // if (inportb(FDC_DIR) & 0x80) { fdc_change = TRUE; fdc_seek(1); fdc_recalibrate(); fdc_motor_off(); return(FALSE); } // Move the head to the right track // if (!fdc_seek(track)) { fdc_motor_off(); return(FALSE); } // Program data rate // outportb(FDC_CCR, floppy_type[fdc_geometry].rate); // Send command // if (do_read) { // Read operation // dma_xfer(2, (dword)fdc_buffer, FDC_SECTOR_SIZE, FALSE); fdc_sendbyte(CMD_READ); } else { // Write operation // dma_xfer(2, (dword)fdc_buffer, FDC_SECTOR_SIZE, TRUE); fdc_sendbyte(CMD_WRITE); } fdc_sendbyte(head << 2); fdc_sendbyte(track); fdc_sendbyte(head); fdc_sendbyte(sector); fdc_sendbyte(2); // 512 bytes/sector // fdc_sendbyte(floppy_type[fdc_geometry].spt); fdc_sendbyte(floppy_type[fdc_geometry].rwgap); fdc_sendbyte(0xFF); // DTL = unused // // Wait for command completion // if (!fdc_wait(FALSE)) return(FALSE); // Timed out! // if ((fdc_status[0] & 0xC0) == 0) break; // Worked! :) // // Try again... // fdc_recalibrate(); } // Stop the motor // fdc_motor_off(); if (do_read) // Read operation => copy data from fdc_buffer into buffer // memcpy(buffer, fdc_buffer, FDC_SECTOR_SIZE); // Return if the R/W operation terminates successfully // return(tries != 3); }

bool fdc_seek (  int    track )

Seek a track. Parameters: track  The track to seek. Returns: TRUE on success; FALSE if an error occurs. Definition at line 199 of file floppy.c. { // If already threre return // if (fdc_track == track) return(TRUE); // Turn the motor on // fdc_motor_on(); // Send seek command // fdc_sendbyte(CMD_SEEK); fdc_sendbyte(0); fdc_sendbyte(track); // Wait until seek is finished // if (!fdc_wait(TRUE)) { // Timeout! // fdc_motor_off(); return(FALSE); } // Let the head settle for 15msec // delay(15); // Turn off the motor // fdc_motor_off(); // Check if seek worked // if ((ST0 != 0x20) || (fdc_track != track)) return(FALSE); else return(TRUE); }

void fdc_sendbyte (  byte    b )

Send a byte to the FDC controller. Parameters: b  The byte to send. Definition at line 68 of file floppy.c. { int msr; int tmo; for (tmo=0; tmo<128; tmo++) { msr = inportb(FDC_MSR); if ((msr & 0xC0) == 0x80) { outportb(FDC_DATA, b); return; } inportb(0x80); //delay // } }

bool fdc_wait (  bool    sensei )

Wait for a FDC operation. Parameters: sensei  TRUE if a "sense interrupt status" command is required; FALSE for a simple timeout wait. Returns: TRUE if the operation has successfully done; FALSE if the timeout has been elapsed. This routine must be invoked every time that we have to verify the correct completion of an operation. If a "sense interrupt status" command is issued, the status of the controller is reported into the ST0 variable and the current track is stored into the fdc_track variable. Definition at line 136 of file floppy.c. { byte i; fdc_timeout = HZ; // timeout = 2 sec // // Wait for IRQ or timeout // while((!fdc_done) && (fdc_timeout)) { enable(); idle(); } // Read command result bytes // i = 0; while ((i < 7) && (inportb(FDC_MSR) & MSR_BUSY)) fdc_status[i++] = fdc_getbyte(); // Send a "sense interrupt status" command // if (sensei) { fdc_sendbyte(CMD_SENSEI); ST0 = fdc_getbyte(); fdc_track = fdc_getbyte(); } // Timed out? // if (!fdc_done) { // Check for disk change // if (inportb(FDC_DIR) & 0x80) fdc_change = TRUE; return(FALSE); } else { fdc_done = FALSE; return(TRUE); } }

bool fdc_write (  int    block, byte *    buffer, uint32_t    count )

Write some contiguous blocks to the floppy disk. Parameters: block  The starting block to write. buffer  The address in memory from which the data will be copied. count  How many blocks to write. Returns: TRUE on success; FALSE if an error occurs. Definition at line 396 of file floppy.c. { register int i; for(i=0; i<count; i++) if (!(fdc_rw(block+i, buffer+(FDC_SECTOR_SIZE*i), FALSE))) return(FALSE); // Write operation OK! // return(TRUE); }

void floppy_thread (    )

This is a routine called from clock_thread() at every clock tick to perform the floppy motor kill countdown and to control the floppy timeouts. Definition at line 422 of file floppy.c. { if (fdc_timeout > 0) fdc_timeout--; if (fdc_motor_countdown > 0) fdc_motor_countdown--; else if (fdc_motor && !fdc_motor_countdown) { outportb(FDC_DOR, 0x0C); fdc_motor = FALSE; } }

bool init_floppy (    )

Initialize the floppy driver. Returns: TRUE on success; FALSE if an error occurs. Definition at line 451 of file floppy.c. { int v; // Install the interrupt handler routine // install_irq_handler( FLOPPY_IRQ, (void *)floppy_handler ); // Create the FDC buffer // fdc_buffer = PHYSICAL( dma_phys_alloc(PAGE_SIZE) ); // Reset the controller // fdc_reset(); // Get floppy controller version // fdc_sendbyte(CMD_VERSION); v = fdc_getbyte(); switch ( v ) { case 0xFF: return( FALSE ); break; case 0x90: kprintf("\n\rEnhanced controller found!"); return( TRUE ); break; default: kprintf("\n\r8272A/765A controller found! (cmd_version=%02X)", v); return( TRUE ); break; } }

void lba2chs (  int    lba, int *    track, int *    head, int *    sector )

Convert from a LBA (Linear Block Address) address to a CHS (Cylinder, Head, Sector) coordinates. Parameters: lba  The LBA address. track  A pointer to the track coordinate. head  A pointer to the head coordinate. sector  A pointer to the sector coordinate. Definition at line 268 of file floppy.c. { *track = lba / (floppy_type[fdc_geometry].spt * floppy_type[fdc_geometry].heads); *head = (lba / floppy_type[fdc_geometry].spt) % floppy_type[fdc_geometry].heads; *sector = (lba % floppy_type[fdc_geometry].spt) + 1; }

---

Variable Documentation

byte* fdc_buffer

Floppy r/w buffer. Definition at line 62 of file floppy.c.

volatile bool fdc_change = FALSE

Disk change flag. Definition at line 41 of file floppy.c.

volatile bool fdc_done = FALSE

FDC operation finish. Definition at line 38 of file floppy.c.

byte fdc_geometry = 0

Current floppy geometry. Definition at line 59 of file floppy.c.

volatile bool fdc_motor = FALSE

Motor on flag. Definition at line 29 of file floppy.c.

volatile int fdc_motor_countdown = 0

Floppy motor kill countdown. Definition at line 35 of file floppy.c.

volatile byte fdc_status[7] = { 0 }

FDC status (result output). Definition at line 44 of file floppy.c.

volatile int fdc_timeout = 0

FDC timeout. Definition at line 32 of file floppy.c.

volatile byte fdc_track = 0xFF

Current head position. Definition at line 47 of file floppy.c.

floppy_struct floppy_type[] [static]

Initial value: { { 2880, 18, 2, 80, 0x54, 0x1B, 0x00, "H1440" }, { 3360, 21, 2, 80, 0x0C, 0x1C, 0x00, "H1680" } } Floppy types known from the system. Definition at line 53 of file floppy.c.

volatile byte ST0 = 0

Status register 0. Definition at line 50 of file floppy.c.

---