---

floppy.c

Go to the documentation of this file.

/*!     \file drivers/floppy/floppy.c
 *      \brief Floppy disk driver.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2003-11-08
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

#include <const.h>

#include <arch/i386.h>
#include <arch/interrupt.h>
#include <arch/mem.h>
#include <arch/paging.h>

#include <kernel/clock.h>
#include <kernel/console.h>
#include <kernel/dma.h>
#include <kernel/task.h>

#include <kernel/floppy.h>

/** \ingroup Drivers
 *  \defgroup FloppyDriver Floppy Disk
 *  The floppy disk driver.
 *  @{
 */

//! Motor on flag.
volatile bool fdc_motor = FALSE;

//! FDC timeout.
volatile int fdc_timeout = 0;

//! Floppy motor kill countdown.
volatile int fdc_motor_countdown=0;

//! FDC operation finish.
volatile bool fdc_done = FALSE;

//! Disk change flag.
volatile bool fdc_change = FALSE;

//! FDC status (result output).
volatile byte fdc_status[7] = { 0 };

//! Current head position.
volatile byte fdc_track = 0xFF;

//! Status register 0.
volatile byte ST0 = 0;

//! Floppy types known from the system.
static floppy_struct floppy_type[] = {
{ 2880, 18, 2, 80, 0x54, 0x1B, 0x00, "H1440" }, // 1.44MB
{ 3360, 21, 2, 80, 0x0C, 0x1C, 0x00, "H1680" }  // 1.68MB
};

//! Current floppy geometry.
byte fdc_geometry = 0;

//! Floppy r/w buffer.
byte *fdc_buffer;

// --- Floppy Generic Functions --------------------------------------- //

//! \brief Send a byte to the FDC controller.
//! \param b The byte to send.
void fdc_sendbyte(byte b)
{
        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 //
        }
}

//! \brief Get a byte from the FDC controller.
//! \return The byte read from the controller.
//! \exception NULL If timeout is elapsed.
int fdc_getbyte()
{
        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 //
}

//! \brief Turn the floppy motor on.
void fdc_motor_on()
{
        if (!fdc_motor)
        {
                outportb(FDC_DOR, 0x1C);
                delay(FDC_TIME_MOTOR_SPINUP);
                fdc_motor = TRUE;
        }
        fdc_motor_countdown = -1;
}

//! \brief Starts the FDC motor kill countdown.
void fdc_motor_off()
{
        if (fdc_motor && (fdc_motor_countdown==-1))
                fdc_motor_countdown = FDC_TIME_MOTOR_OFF/1000*HZ;
}

//! \brief Wait for a FDC operation.
//! \param sensei
//!     \li #TRUE if a "sense interrupt status" command is required;
//!     \li #FALSE for a simple timeout wait.
//! \return
//!     \li #TRUE if the operation has successfully done;
//!     \li #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.
 */
bool fdc_wait(bool sensei)
{
        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);
        }
}

//! \brief Recalibrate the floppy drive.
void fdc_recalibrate()
{
        // 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();
}

//! \brief Seek a track.
//! \param track The track to seek.
//! \return
//!     \li #TRUE on success;
//!     \li #FALSE if an error occurs.
bool fdc_seek(int track)
{
        // 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);
}

//! \brief Reset the floppy disk controller.
void fdc_reset()
{
        // 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;
}

//! \brief
//!     Convert from a LBA (Linear Block Address) address to a
//!     CHS (Cylinder, Head, Sector) coordinates.
//! \param lba The LBA address.
//! \param track A pointer to the track coordinate.
//! \param head A pointer to the head coordinate.
//! \param sector A pointer to the sector coordinate.
void lba2chs(int lba, int *track, int *head, int *sector)
{
        *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;
}

//! \brief
//!     Perform a read/write operation with the floppy drive using
//!     the DMA (Direct Memory Access).
//! \param block The LBA address of the block on the floppy.
//! \param buffer
//!     The address of the buffer in memory for the transfer
//!     operation. It must have a size of at least #FDC_SECTOR_SIZE
//!     bytes.
//! \param do_read
//!     \li #TRUE to perform a read operation (from disk to memory);
//!     \li #FALSE to perform a write operation (from memory to disk).
//! \return
//!     \li #TRUE on success;
//!     \li #FALSE if an error occurs.
bool fdc_rw(int block, byte *buffer, bool do_read)
{
        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);
}

//! \brief Read some contiguous blocks from the floppy disk.
//! \param block The starting block to read.
//! \param buffer
//!     The destination buffer in memory where the
//!     blocks will be copied.
//! \param count
//!     How many blocks to read.
//! \return
//!     \li #TRUE on success;
//!     \li #FALSE if an error occurs.
bool fdc_read(int block, byte *buffer, uint32_t count)
{
        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);
}

//! \brief Write some contiguous blocks to the floppy disk.
//! \param block The starting block to write.
//! \param buffer
//!     The address in memory from which the data will be copied.
//! \param count
//!     How many blocks to write.
//! \return
//!     \li #TRUE on success;
//!     \li #FALSE if an error occurs.
bool fdc_write(int block, byte *buffer, uint32_t count)
{
        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);
}

//! \brief Check if the floppy disk was changed.
//! \return
//!     \li #TRUE if the disk was changed;
//!     \li #FALSE otherwise.
bool fdc_is_changed()
{
        return(fdc_change);
}

// --- Interrupt routines --------------------------------------------- //

//! \brief
//!     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.
void floppy_thread()
{
        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;
        }
}

/** \ingroup Handlers */
//! \brief
//!     This is the floppy interrupt handler routine. It is invoked
//!     every time that a floppy operation successfully completes.
void floppy_handler()
{
        fdc_done = TRUE;
}

// --- Initialization --------------------------------------------------//

//! \brief Initialize the floppy driver.
//! \return
//!     \li #TRUE on success;
//!     \li #FALSE if an error occurs.
bool init_floppy()
{
        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;
        }
}

/** @} */ // end of FloppyDriver

---