advioreg.c

pc机上经由pci连接的ata和atapi设备驱动

      }
   }

   // read the output registers and trace the command.

   sub_trace_command();

   // BMCR/BMIDE Error=1?

   if ( sub_readBusMstrStatus() & BM_SR_MASK_ERR )
   {
      ADP->ec = 78;                  // yes
      trc_llt( 0, ADP->ec, TRC_LLT_ERROR );
   }

   // NON_DATA_DONE:

   // mark end of ND cmd in low level trace

   trc_llt( 0, 0, TRC_LLT_E_ND );

   // All done.  The return values of this function are described in
   // ADVIO.H.

   if ( ADP->ec )
      return 1;
   return 0;
}

//*************************************************************
//
// reg_non_data_chs() - Execute a non-data command.
//
// Note special handling for Execute Device Diagnostics
// command when there is no device 0.
//
// See ATA-2 Section 9.5, ATA-3 Section 9.5,
// ATA-4 Section 8.8 Figure 12.  Also see Section 8.5.
//
//*************************************************************

int reg_non_data_chs( int cmd,
                      unsigned int fr, unsigned int sc,
                      unsigned int cyl, unsigned int head, unsigned int sect )

{

   // Setup command parameters.

   sub_zero_return_data();
   ADP->flg = TRC_FLAG_ATA;
   ADP->ct  = TRC_TYPE_AND;
   ADP->cmd = cmd;
   ADP->fr1 = fr;
   ADP->sc1 = sc;
   ADP->sn1 = sect;
   ADP->cl1 = cyl & 0x00ff;
   ADP->ch1 = ( cyl & 0xff00 ) >> 8;
   ADP->dh1 = ADP->devBit | ( head & 0x0f );
   // ADP->dc1 = 0x00;     // see sub_setup_command()
   ADP->ns  = sc;
   ADP->lbaSize = LBACHS;

   // Execute the command.

   return exec_non_data_cmd();
}

//*************************************************************
//
// reg_non_data_lba28() - Easy way to execute a non-data command
//                        using an LBA sector address.
//
//*************************************************************

int reg_non_data_lba28( int cmd,
                        unsigned int fr, unsigned int sc,
                        unsigned long lba )

{

   // Setup current command information.

   sub_zero_return_data();
   ADP->flg = TRC_FLAG_ATA;
   ADP->ct  = TRC_TYPE_AND;
   ADP->cmd = cmd;
   ADP->fr1 = fr;
   ADP->sc1 = sc;
   ADP->dh1 = CB_DH_LBA | ADP->devBit;
   // ADP->dc1 = 0x00;     // see sub_setup_command()
   ADP->ns  = sc;
   ADP->lbaSize = LBA28;
   ADP->lbaHigh1 = 0L;
   ADP->lbaLow1 = lba;

   // Execute the command.

   return exec_non_data_cmd();
}

//*************************************************************
//
// reg_non_data_lba48() - Easy way to execute a non-data command
//                        using an LBA sector address.
//
//*************************************************************

int reg_non_data_lba48( int cmd,
                        unsigned int fr, unsigned int sc,
                        unsigned long lbahi, unsigned long lbalo )

{

   // Setup current command infomation.

   sub_zero_return_data();
   ADP->flg = TRC_FLAG_ATA;
   ADP->ct  = TRC_TYPE_AND;
   ADP->cmd = cmd;
   ADP->fr1 = fr;
   ADP->sc1 = sc;
   ADP->dh1 = CB_DH_LBA | ADP->devBit;
   // ADP->dc1 = 0x00;     // see sub_setup_command()
   ADP->ns  = sc;
   ADP->lbaSize = LBA48;
   ADP->lbaHigh1 = lbahi;
   ADP->lbaLow1 = lbalo;

   // Execute the command.

   return exec_non_data_cmd();
}

//*************************************************************
//
// exec_pio_data_in_cmd() - Execute a PIO Data In command.
//
// See ATA-2 Section 9.3, ATA-3 Section 9.3,
// ATA-4 Section 8.6 Figure 10.
//
//*************************************************************

static int exec_pio_data_in_cmd(
                            unsigned int seg, unsigned int off,
                            long numSect, int multiCnt );


static int exec_pio_data_in_cmd(
                            unsigned int seg, unsigned int off,
                            long numSect, int multiCnt )

{
   unsigned char status;
   long wordCnt;
   unsigned int saveSeg = seg;
   unsigned int saveOff = off;

   // mark start of PDI cmd in low level trace

   trc_llt( 0, 0, TRC_LLT_S_PDI );

   // reset Bus Master Error bit

   sub_writeBusMstrStatus( BM_SR_MASK_ERR );

   // Set command time out.

   tmr_set_timeout();

   // Select the drive - call the sub_select function.
   // Quit now if this fails.

   if ( sub_select() )
   {
      sub_trace_command();
      trc_llt( 0, 0, TRC_LLT_E_PDI );
      ADP->reg_drq_block_call_back = 0;
      return 1;
   }

   // Set up all the registers except the command register.

   sub_setup_command();

   // Start the command by setting the Command register.  The drive
   // should immediately set BUSY status.

   pio_outbyte( CB_CMD, ADP->cmd );

   // Waste some time by reading the alternate status a few times.
   // This gives the drive time to set BUSY in the status register on
   // really fast systems.  If we don't do this, a slow drive on a fast
   // system may not set BUSY fast enough and we would think it had
   // completed the command when it really had not even started the
   // command yet.

   DELAY400NS;

   // Loop to read each sector.

   while ( 1 )
   {
      // READ_LOOP:
      //
      // NOTE NOTE NOTE ...  The primary status register (1f7) MUST NOT be
      // read more than ONCE for each sector transferred!  When the
      // primary status register is read, the drive resets IRQ 14.  The
      // alternate status register (3f6) can be read any number of times.
      // After BSY=0 read the the primary status register ONCE
      // and transfer the 256 words (REP INSW).  AS SOON as BOTH the
      // primary status register has been read AND the last of the 256
      // words has been read, the drive is allowed to generate the next
      // IRQ 14 (newer and faster drives could generate the next IRQ 14 in
      // 50 microseconds or less).  If the primary status register is read
      // more than once, there is the possibility of a race between the
      // drive and the software and the next IRQ 14 could be reset before
      // the system interrupt controller sees it.

      // Poll for not BUSY -or- wait for time out.

      reg_poll_not_busy( 35 );

      // Read the primary status register.  In keeping with the rules
      // stated above the primary status register is read only
      // ONCE.

      status = pio_inbyte( CB_STAT );

      // If there was a time out error, go to READ_DONE.

      if ( ADP->ec )
         break;   // go to READ_DONE

      // If BSY=0 and DRQ=1, transfer the data,
      // even if we find out there is an error later.

      if ( ( status & ( CB_STAT_BSY | CB_STAT_DRQ ) ) == CB_STAT_DRQ )
      {

         // increment number of DRQ packets

         ADP->drqPackets ++ ;

         // determine the number of sectors to transfer

         wordCnt = multiCnt ? multiCnt : 1;
         if ( wordCnt > numSect )
            wordCnt = numSect;
         wordCnt = wordCnt * 256;

         // Quit if buffer overrun.
         // Adjust buffer address when DRQ block call back in use.

         if ( ADP->reg_drq_block_call_back )
         {
            if ( ( wordCnt << 1 ) > ADP->reg_buffer_size )
            {
               ADP->ec = 61;
               trc_llt( 0, ADP->ec, TRC_LLT_ERROR );
               break;   // go to READ_DONE
            }
            seg = saveSeg;
            off = saveOff;
         }
         else
         {
            if ( ( ADP->totalBytesXfer + ( wordCnt << 1 ) )
                 > ADP->reg_buffer_size )
            {
               ADP->ec = 61;
               trc_llt( 0, ADP->ec, TRC_LLT_ERROR );
               break;   // go to READ_DONE
            }
         }

         // Do the REP INSW to read the data for one DRQ block.

         ADP->totalBytesXfer += ( wordCnt << 1 );
         pio_drq_block_in( CB_DATA, seg, off, wordCnt );

         DELAY400NS;    // delay so device can get the status updated

         // Note: The drive should have dropped DATA REQUEST by now.  If there
         // are more sectors to transfer, BUSY should be active now (unless
         // there is an error).

         // Call DRQ block call back function.
         if ( ADP->reg_drq_block_call_back )
         {
            ADP->drqPacketSize = ( wordCnt << 1 );
            (* ADP->reg_drq_block_call_back) ( ADP );
         }

         // Decrement the count of sectors to be transferred
         // and increment buffer address.

         numSect = numSect - ( multiCnt ? multiCnt : 1 );
         seg = seg + ( 32 * ( multiCnt ? multiCnt : 1 ) );
      }

      // So was there any error condition?

      if ( status & ( CB_STAT_BSY | CB_STAT_DF | CB_STAT_ERR ) )
      {
         ADP->ec = 31;
         trc_llt( 0, ADP->ec, TRC_LLT_ERROR );
         break;   // go to READ_DONE
      }

      // DRQ should have been set -- was it?

      if ( ( status & CB_STAT_DRQ ) == 0 )
      {
         ADP->ec = 32;
         trc_llt( 0, ADP->ec, TRC_LLT_ERROR );
         break;   // go to READ_DONE
      }

      // If all of the requested sectors have been transferred, make a
      // few more checks before we exit.

      if ( numSect < 1 )
      {
         // Since the drive has transferred all of the requested sectors
         // without error, the drive should not have BUSY, DEVICE FAULT,
         // DATA REQUEST or ERROR active now.

         status = pio_inbyte( CB_STAT );
         if ( status & ( CB_STAT_BSY | CB_STAT_DF | CB_STAT_DRQ | CB_STAT_ERR ) )
         {
            ADP->ec = 33;
            trc_llt( 0, ADP->ec, TRC_LLT_ERROR );
            break;   // go to READ_DONE
         }

         // All sectors have been read without error, go to READ_DONE.

         break;   // go to READ_DONE

      }

      // This is the end of the read loop.  If we get here, the loop is
      // repeated to read the next sector.  Go back to READ_LOOP.

   }

   // read the output registers and trace the command.

   sub_trace_command();

   // BMCR/BMIDE Error=1?

   if ( sub_readBusMstrStatus() & BM_SR_MASK_ERR )
   {
      ADP->ec = 78;                  // yes
      trc_llt( 0, ADP->ec, TRC_LLT_ERROR );
   }

   // READ_DONE:

   // mark end of PDI cmd in low level trace

   trc_llt( 0, 0, TRC_LLT_E_PDI );

   // reset reg_drq_block_call_back to NULL (0)

   ADP->reg_drq_block_call_back = 0;

   // All done.  The return values of this function are described in
   // ADVIO.H.

   if ( ADP->ec )
      return 1;
   return 0;
}

//*************************************************************
//
// reg_pio_data_in_chs() - Execute a PIO Data In command.
//
// See ATA-2 Section 9.3, ATA-3 Section 9.3,
// ATA-4 Section 8.6 Figure 10.
//
//*************************************************************

int reg_pio_data_in_chs( int cmd,
                         unsigned int fr, unsigned int sc,
                         unsigned int cyl, unsigned int head, unsigned int sect,
                         unsigned int seg, unsigned int off,
                         long numSect, int multiCnt )

{

   // Reset error return data.

   sub_zero_return_data();
   ADP->flg = TRC_FLAG_ATA;
   ADP->ct  = TRC_TYPE_APDI;
   ADP->cmd = cmd;
   ADP->fr1 = fr;
   ADP->sc1 = sc;
   ADP->sn1 = sect;
   ADP->cl1 = cyl & 0x00ff;
   ADP->ch1 = ( cyl & 0xff00 ) >> 8;
   ADP->dh1 = ADP->devBit | ( head & 0x0f );
   // ADP->dc1 = 0x00;     // see sub_setup_command()
   ADP->lbaSize = LBACHS;

   // these commands transfer only 1 sector
   if (    ( cmd == CMD_IDENTIFY_DEVICE )
        || ( cmd == CMD_IDENTIFY_DEVICE_PACKET )
        || ( cmd == CMD_READ_BUFFER )
      )
      numSect = 1;

   // only Read Multiple uses multiCnt
   if ( cmd != CMD_READ_MULTIPLE )
      multiCnt = 1;

   ADP->ns  = numSect;
   ADP->mc  = multiCnt;

   return exec_pio_data_in_cmd( seg, off, numSect, multiCnt );
}

//*************************************************************
//
// reg_pio_data_in_lba28() - Easy way to execute a PIO Data In command
//                           using an LBA sector address.
//
//*************************************************************

int reg_pio_data_in_lba28( int cmd,