OSDev.org

Code: Select all

#define base_address        0x03f0
#define DOR_register        0x03f2
#define status_register     0x03f4
#define data_register       0x03f5
#define CCR_register        0x03f7

/* -- DOR Register Bits -- */
#define DR0     0x01
#define DR1     0x02
#define REST    0x04
#define DMA     0x08
#define MOTA    0x10
#define MOTB    0x20
#define MOTC    0x40
#define MATD    0x80

/* -- Main Status Register Bits -- */
#define ACTA    0x01
#define ACTB    0x02
#define ACTC    0x04
#define ACTD    0x08
#define BUSY    0x10
#define NDMA    0x20
#define DIO     0x40
#define MRQ     0x80

void wait_for_data()
{
    int timeout = 1000;
    while((inportb(status_register) & BUSY) != 0)
    {if(timeout){timeout--;wait(5);}else{break;}}
    if(!timeout){printf("fdc - wait_for_data timeout! \n");}
}

unsigned short floppy_check_interrupt_status()
{
    unsigned short ret_val = 0;
    while(1)
    {
        floppy_write_cmd(0x08);
        wait_for_data();
        ret_val = ((read_controller() << 8) & 0xFF00);
        if((ret_val & 0xFF00) != 0x8000)
        {
            wait_for_data();
            ret_val |= (read_controller() & 0xFF);
            break;
        }
    }
    printf("fdc - interrupt_status: %x \n", ret_val);
    return ret_val;
}

void floppy_recalibrate()
{
    int timeout = 4;
    turn_floppy_motor_on();
    
    while(timeout--)
    {
        floppy_write_cmd(0x07); // recalibrate cmd
        floppy_write_cmd(0x00);
        if((floppy_check_interrupt_status() & 0x1000) == 0){break;} // check the UC bit in ST0
    }
    turn_floppy_motor_off();
}

void floppy_fix_drive_data()
{
    turn_floppy_motor_on();
    floppy_write_cmd(0x03); // fix drive data cmd
    floppy_write_cmd(0x8f); /* steprate = 8ms, unload time = 240ms */
    floppy_write_cmd(0x0B); /* load time = 10ms, no-DMA = 1 */
    
    int timeout = 1000;
    while((inportb(status_register) & BUSY) != 0 || (inportb(DOR_register) & REST) == 0)
    {if(timeout){timeout--;wait(1);}else{break;}}
    if(!timeout){printf("fdc - fix_drive_data timeout! \n");}
    turn_floppy_motor_off();
}

void floppy_reset()
{ 
    outportb(DOR_register, 0x00);
    outportb(DOR_register, REST);
    
    int timeout = 1000;
    while((inportb(status_register) & BUSY) != 0 || (inportb(DOR_register) & REST) == 0)
    {if(timeout){timeout--;wait(5);}else{break;}}
    if(!timeout){printf("fdc - reset timeout! \n");}
    
    outportb(CCR_register, 0x00);   // 500kbits/s transfer rate
    
    floppy_fix_drive_data();
    floppy_recalibrate();
    floppy_check_drive_status();
}

Code: Select all

outportb(DOR_register, 0x00);
outportb(DOR_register, REST | DMA);//set bits 2 and 3

Code: Select all

void wait_for_controller_to_send_byte()
{
    unsigned int timeout = 1000;
    while(timeout--)
    {
        if((inportb(status_register) & 0xC0) == 0x80){return;}
        else{wait(240);}
    }
    printf("fdc - wait_for_controller_to_send_byte timeout! \n");
}

void wait_for_controller_to_get_byte()
{
    unsigned int timeout = 1000;
    while(timeout--)
    {
        if((inportb(status_register) & 0xC0) == 0xC0){return;}
        else{wait(240);}
    }
    printf("fdc - wait_for_controller_to_get_byte timeout! \n");
}

void floppy_send_byte(unsigned char data)
{
    wait_for_controller_to_send_byte();
    outportb(data_register, data);
}

unsigned char floppy_get_byte()
{
    wait_for_controller_to_get_byte();
    return inportb(data_register);
}

void wait_for_interrupt()
{
    unsigned int timeout = 100;
    while(timeout--)
    {
        floppy_send_byte(0x08);
        st0 = floppy_get_byte();
        cyl = floppy_get_byte();
        if(!(st0 & 0x80))
        {
            printf("fdc - interrupt: %x | %x \n", st0, cyl);
            return;
        }
        wait(5);
    }
    printf("fdc - interrupt timeout! \n");
}

void floppy_reset()
{
    floppy_motor_status = 0;
    st0 = st3 = cyl = 0;
    
    printf("fdc - resetting. \n");
    outportb(DOR_register, 0x00);       // Start Reset, DMA
    wait(250);
    outportb(DOR_register, 0x0C);       // Finish Reset, DMA
    wait(250);
    wait_for_interrupt();
    
    outportb(CCR_register, 0x00);       // 500Kb/s mode
    wait(250);
    
    printf("fdc - specify cmd. \n");
    floppy_send_byte(0x03);             // specify cmd
    floppy_send_byte(0xDF);             // SRT = 8ms, HUT = 240ms
    floppy_send_byte(0x02);             // HLT = 10ms, ND = 0
}

Code: Select all

for(i = 0; i < 4; i++)
{
    fdc_send_command(fd, FDC_SENSE_INTERRUPT);
    fdc_get_data(fd, &st0);
    fdc_get_data(fd, &cyl);
}

Code: Select all

//configure the drive
fdc_send_command(fd,FDC_CONFIGURE);
fdc_send_data(fd, 0x00);//this parameter is defined as all zeros for some reason
unsigned char config_bits = 
//                    7      6         5                 4          3   2   1   0
//the bits here are:| 0 |   EIS   |  EFIFO          |   POLL     | FIFO threshold |
                         (0 << 6) | (0 << 5)        | (1 << 4)   | 15;
//               No Implied Seeks | Enable the FIFO | No Polling | Large FIFO buffer |
fdc_send_data(fd, config_bits);
fdc_send_data(fd, 0);//pretrk