Работа с флоппи-диском через порты.

The first thing that the driver needs to do is reset the controller. This
will put it in a known state. To reset the primary floppy controller,(in C)

1.write 0x00 to the DIGITAL_OUTPUT_REG of the desired controller
2.write 0x0C to the DIGITAL_OUTPUT_REG of the desired controller
3.wait for an interrupt from the controller
4.check interrupt status (this is function 0x08 of controllers)
5.write 0x00 to the CONFIG_CONTROL_REG
6.configure the drive desired on the controller (function 0x03 of controller)
7.calibrate the drive (function 0x07 of controller)

*Note: The code below is taken from my OS floppy driver
base is the address of the controller, either PRIMARY of SECONDARY
drive is the drive on the controller to be reset - 0 is drive A (fd0),1 is drive B (fd1)

void reset_floppy_controller(int base,char drive){
  outportb((base+DIGITAL_OUTPUT_REG),0x00); /*disable controller*/
  outportb((base+DIGITAL_OUTPUT_REG),0x0c); /*enable controller*/
    kreceive_message(floppy_mailbox,&fmess); /*this suspends the driver until
                                             the controller issues an
                                             interrupt*/
  check_interrupt_status(base,&st0,&cylinder);
   outportb(base+CONFIG_CONTROL_REG,0);
  configure_drive(base,drive);
    calibrate_drive(base,drive);
  return;
}

void calibrate_drive(int base,char drive){
  motor_control(drive,START); /*turns the motor of drive ON*/
  write_floppy_command(base,CALIBRATE_DRIVE); /*Calibrate drive*/
  write_floppy_command(base,drive);
  kreceive_message(floppy_mailbox,&fmess);  /*wait for interrupt from
                                              controller*/
  check_interrupt_status(base,&st0,&cylinder); /*check interrupt status and
                                                store results in global variables
                                                st0 and cylinder*/
 return;
}

void check_interrupt_status(int base,unsigned char *st0,unsigned char *cylinder){
             write_floppy_command(base,CHECK_INTERRUPT_STATUS);
             wait_floppy_data(base);
             *st0=inportb(base+DATA_REGISTER);
             wait_floppy_data(base);
              *cylinder=inportb(base+DATA_REGISTER);
  return;
}

void wait_floppy_data(int base){
/*     read main status register of controller and wait until it signals that
     data is ready in the data register*/

  while(((inportb(base+MAIN_STATUS_REG))&0xd0)!=0xd0);
 return;
}

void configure_drive(int base,char drive){
  write_floppy_command(base,FIX_DRIVE_DATA);/*config/specify command*/
  write_floppy_command(base,floppy_disk.steprate_headunload);
  write_floppy_command(base,floppy_disk.headload_ndma);
  return;
}

void write_floppy_command(int base,char command){
   wait_floppy_ready(base);
   outportb(base+DATA_REGISTER,command);
   return;
}

Once the controller and drive have been reset, you can now issue commands.
To read a sector from the drive, you need to

1. issue a seek track command (function 0x0F of controller)
2. initialize the DMA chip. (Not covered in this tutorial. but the floppy
   controller used channel 2.)
3. wait (delay the driver for) head_settle_time specified in the floppy
   parameter table described above.
4. write read sector command (function 0x66) to the controller
5. write the value of ((head*4)|drive) to the controller
6. write the value of the desired cylinder to be read to the controller
7. write the value of the desired head to be read to the controller
8. write the value of the desired sector to be read to the controller
9. write value of bytes_per_sector specified in the floppy parameter table to the controller
10.write value of sectors_per_track specified in the floppy parameter table to the controller
11.write value of gap_length specified in the floppy parameter table to the controller
12.write value of data_length specified in the floppy parameter table to the controller
   At this point the controller will start to read the sector,so you have to wait
   for it to finish, which is will signal by an interrupt.
13.wait for interrupt from controller
14.check interrupt status
15.read the result bytes sent by the controller

This is also the way to perform a WRITE SECTOR COMMAND.

*Note: The code below is taken from my OS floppy driver
sector,head and cylinder are the CHS value for the data
 requireddrive is the drive on the controller to be reset - 0 is drive A (fd0),1 is drive B (fd1)


void read_sector(unsigned char sector,unsigned char head,unsigned char cylinder,unsigned char drive,unsigned long buffer)
{
   seek_track(head,cylinder,drive);

   start_dma(0x02,0x44,buffer,511);

   k_delay(floppy_disk.head_settle_time);

   write_floppy_command(FLOPPY_PRIMARY_BASE,READ_SECTOR);
   write_floppy_command(FLOPPY_PRIMARY_BASE,head<<2|drive);
   write_floppy_command(FLOPPY_PRIMARY_BASE,cylinder);
   write_floppy_command(FLOPPY_PRIMARY_BASE,head);
   write_floppy_command(FLOPPY_PRIMARY_BASE,sector);
   write_floppy_command(FLOPPY_PRIMARY_BASE,floppy_disk.bytes_per_sector);  /*sector size = 128*2^size*/
   write_floppy_command(FLOPPY_PRIMARY_BASE,floppy_disk.sectors_per_track); /*last sector*/
   write_floppy_command(FLOPPY_PRIMARY_BASE,floppy_disk.gap_length);        /*27 default gap3 value*/
   write_floppy_command(FLOPPY_PRIMARY_BASE,floppy_disk.data_length);       /*default value for data length*/

   kreceive_message(floppy_mailbox,&fmess); /*wait for interrupt to signal
                                              completion of read sector command*/

   check_interrupt_status(FLOPPY_PRIMARY_BASE,&st0,&cylinder);
      read_result_phase();
   return;
}

void read_result_phase()
{

  unsigned char status;
  int timeout=16;

  while(timeout--)
  {
         wait_floppy_ready(FLOPPY_PRIMARY_BASE);
         status=inportb(FLOPPY_PRIMARY_BASE+MAIN_STATUS_REG);
         if((status&0xd0) != 0xd0)
            break;

         status=inportb(FLOPPY_PRIMARY_BASE+DATA_REGISTER);
  }
  return;
}

The floppy uses interrupt line 6 (IRQ 6) for its interrupts. If you have reprogrammed the
PIC say to handle the master interrupts from 0x20 and the slave interrupts
from 0x28, the the floppy's interrupts should be installed at interrupt service routine 0x26.
An example floppy ISR could be
(NASM format)
Code:

extern _floppy_int_count
_floppy_int:
          inc word [_floppy_int_count]
          mov al,0x20 ;acknowledge interrupt to PIC
          out 0x20,al
          iret


then in the C code,
Code:

unsigned short floppy_int_count=0;
void wait_floppy_interrupt()
{
    while(floppy_int_count <= 0);
    floppy_int_count--;
    return;
}


This is one method. Another is to use interprocess communication code such as
send and receive to send messages to a floppy server that will handle the interrupts.
this is the method i used, as it saves cpu cycles due to the suspension of the server
until an interrupt occurs. during that time, another task is allocated the cpu ie running

Well, I hope this helps you with your own code. I'm new to writing Tutorials
so if there is anything you don't understand you can mail me and i'll explain
it. Also if there are suggestions and corrections you'll like to make, please
email them to me too.