statapi.c

STi5518机顶盒ATAPI源代码！绝对超值！

    if (Dev->IsModeSet==FALSE)    
    {
        return STATAPI_ERROR_MODE_NOT_SET;
    }   

    if ((Mode == NULL) || (TimingParams == NULL))
    {
        return ST_ERROR_BAD_PARAMETER;
    }
    if(hal_GetDmaTiming(ATAHandle->HalHndl,TimingParams))
    {
        return  ST_ERROR_BAD_PARAMETER;
    }
    
    *Mode=Dev->DeviceParams.CurrentDmaMode;
    
    return ST_NO_ERROR;
}  
/*************************************************************************
Name         : STATAPI Abort()

Description  : Aborts any pending command or packet transfer in progress with 
                an ATA/ATAPI device.
Parameters   : 
    STATAPI_Handle_t    Handle          Handle allowing access to host device.    
    
                   
Return Value :  
  ST_NO_ERROR               No error.
  ST_ERROR_INVALID_HANDLE   Device handle is invalid.
  
 
 ************************************************************************/
ST_ErrorCode_t  STATAPI_Abort(STATAPI_Handle_t     Handle)
{
    ata_DevCtrlBlock_t  *Dev;
    U8 DevNo;
    
    
    Dev=(ata_DevCtrlBlock_t*) Handle;
    
    /*  Parameter checking  */
     if((Dev!= &ATAHandle->Handles[0]) &  (Dev!= &ATAHandle->Handles[1])) 
    {
        return ST_ERROR_INVALID_HANDLE;
    }
    
    if (Dev->Opened==FALSE)    
    {
        return ST_ERROR_INVALID_HANDLE;
    }
    
    if(Dev== &ATAHandle->Handles[0])
    {
        DevNo= DEVICE_0;
    }else
    {
        DevNo= DEVICE_1; 
    }
    if (ATAHandle->DeviceSelected != DevNo)
    {
        return ST_NO_ERROR;    /* Nothing to abort */
    }
    if (ATAHandle->BusBusy==FALSE)
    {
        return ST_NO_ERROR;    /* Nothing to abort */
    }
    
    Dev->Abort=TRUE;
    
    return ST_NO_ERROR;
}  
 
/*************************************************************************
Name         : STATAPI HardReset()

Description  : Performs a hardware reset.
Parameters   : 
    STATAPI_Handle_t    Handle          Handle allowing access to host device.    
    
                   
Return Value :  
  ST_NO_ERROR               No error.
  ST_ERROR_INVALID_HANDLE   Device handle is invalid.
  STATAPI_ERROR_DEVICE_NOT_PRESENT  The ATA/ATAPI device at the nominated address is
                                        not present.
 
 ************************************************************************/
ST_ErrorCode_t  STATAPI_HardReset(const ST_DeviceName_t DeviceName)
{
     ST_ErrorCode_t  Error;  
     #if !(defined(ST_5508)| defined(ST_5518)) 
     STATAPI_EvtParams_t   EvtData;    
     #endif
   /*  Parameter checking  */
    
    if (strcmp(ATAHandle->DeviceName,DeviceName))
    {
        return ST_ERROR_UNKNOWN_DEVICE;
    }
     
    #if defined(ST_5508)| defined(ST_5518)
       Error=ST_ERROR_FEATURE_NOT_SUPPORTED;
    #else
      /* Abort any possible command */  
      ATAHandle->Handles[0].Abort= TRUE;
      ATAHandle->Handles[1].Abort= TRUE;
      
     ata_ctrl_HardReset(ATAHandle);
    
      /* Notify the user that a Hard reset has been perfomed */    
      
      EvtData.Error=ST_NO_ERROR;
      STEVT_Notify(ATAHandle->EvtHndl,
                    ATAHandle->EvtIds[STATAPI_HARD_RESET_ID],
                    &EvtData);  

    /* Now let's see what we have in the bus */
       ata_ctrl_Probe(ATAHandle);
       
       ata_ctrl_HardReset(ATAHandle);
       
       ATAHandle->Handles[0].Abort= FALSE;
       ATAHandle->Handles[1].Abort= FALSE;
       
      /* Refresh the device parameter */
      
      if(ATAHandle->Handles[0].Opened== TRUE)
      {
        Error= GetDeviceCapabilities(STATAPI_DEVICE_0);
        ATAHandle->Handles[0].IsModeSet= FALSE;
        ATAHandle->Handles[0].MultiCnt= 1;
        /* Ensure these don't match anything, so when the user sets the
         * next mode everything gets reprogrammed.
         */
        ATAHandle->Handles[0].DeviceParams.CurrentPioMode = STATAPI_PIO_MODE_4 + 1;
        ATAHandle->Handles[0].DeviceParams.CurrentDmaMode = STATAPI_DMA_NOT_SUPPORTED + 1;
      }
    
      if(ATAHandle->Handles[1].Opened== TRUE)
      {
        Error= GetDeviceCapabilities(STATAPI_DEVICE_1);
        ATAHandle->Handles[1].IsModeSet= FALSE;
        ATAHandle->Handles[1].MultiCnt= 1;
        /* Ensure these don't match anything, so when the user sets the
         * next mode everything gets reprogrammed.
         */
        ATAHandle->Handles[1].DeviceParams.CurrentPioMode = STATAPI_PIO_MODE_4 + 1;
        ATAHandle->Handles[1].DeviceParams.CurrentDmaMode = STATAPI_DMA_NOT_SUPPORTED + 1;
      }
         
    #endif
    return Error;
    
}  

/*************************************************************************
Name         : STATAPI SoftReset()


Description  : Performs a software reset.
Parameters   : 
    ST_DeviceName_t  DeviceName          NAme of the device to reset.    
    
                   
Return Value :  
  ST_NO_ERROR               No error.
  ST_ERROR_INVALID_HANDLE   Device handle is invalid.
  STATAPI_ERROR_DEVICE_NOT_PRESENT  The ATA/ATAPI device at the nominated address is
                                        not present.
 
 ************************************************************************/
ST_ErrorCode_t  STATAPI_SoftReset(const ST_DeviceName_t DeviceName)
{
    ST_ErrorCode_t  Error;   
    STATAPI_EvtParams_t   EvtData;    
    
    /*  Parameter checking  */
    if (strcmp(ATAHandle->DeviceName,DeviceName) != 0)
    {
        return ST_ERROR_UNKNOWN_DEVICE;
    }
    
    /* Abort any possible command */  
    ATAHandle->Handles[0].Abort= TRUE;
    ATAHandle->Handles[1].Abort= TRUE;
    
    ata_ctrl_SoftReset(ATAHandle);
    
    /* Notify the user that a Soft reset has been perfomed */    
    EvtData.Error = ST_NO_ERROR;
    STEVT_Notify(ATAHandle->EvtHndl,
                 ATAHandle->EvtIds[STATAPI_SOFT_RESET_ID],
                 &EvtData);  
    
    ATAHandle->Handles[0].Abort= FALSE;
    ATAHandle->Handles[1].Abort= FALSE;

    /* Don't know what the devices *now* support, so find out and
     * get back in sync 
     */
    GetDeviceCapabilities(ATAHandle->DeviceSelected);
    
    /* Refresh the device parameter */
    
    if(ATAHandle->Handles[0].Opened== TRUE)
    {
        Error= GetDeviceCapabilities(STATAPI_DEVICE_0);
        ATAHandle->Handles[0].IsModeSet= FALSE;
    }
    
    if(ATAHandle->Handles[1].Opened== TRUE)
    {
        Error= GetDeviceCapabilities(STATAPI_DEVICE_1);
        ATAHandle->Handles[1].IsModeSet= FALSE;
    }
    
    return Error;
}  

/****************************************************************************
Name         : ChooseProtocolCmd

Description  : Selects the transfer protocol (PIO/DMA) based on the command;
               see return value below.

Parameters   : 
    CommandCode         The command to be executed
    Dev                 Pointer to a device control block, for accessing 
                        required capability details
Return Value :  
    ATA_CMD_NODATA ...  Which transfer protocol is required by the command
                        and supported by both the host and device
    0                   The command requires a protocol that isn't supported
                        by both device and host
****************************************************************************/
static U8 ChooseProtocolCmd(U16 CommandCode, ata_DevCtrlBlock_t *Dev)
{
    U8 Type;
    BOOL Supported = TRUE;
    
    /* Figure out what type the command implies */
    switch (CommandCode)
    {
        case STATAPI_CMD_READ_SECTORS:
        case STATAPI_CMD_CFA_TRANSLATE_SECTOR:
        case STATAPI_CMD_READ_MULTIPLE:
        case STATAPI_CMD_IDENTIFY_DEVICE:
        case STATAPI_CMD_READ_BUFFER:
            Type = ATA_CMD_PIOIN;
            break;

        case STATAPI_CMD_READ_SECTORS_EXT:
        case STATAPI_CMD_READ_MULTIPLE_EXT:
            Type = ATA_CMD_PIOIN_EXT;
            break;

        case STATAPI_CMD_WRITE_SECTORS:
        case STATAPI_CMD_CFA_WRITE_SECTORS_WO_ERASE:
        case STATAPI_CMD_WRITE_MULTIPLE:
        case STATAPI_CMD_CFA_WRITE_MULTIPLE_WO_ERASE:
        case STATAPI_CMD_WRITE_BUFFER:
        case STATAPI_CMD_SECURITY_SET_PASSWORD:
        case STATAPI_CMD_SECURITY_UNLOCK:
        case STATAPI_CMD_SECURITY_DISABLE_PASSWORD:
            Type = ATA_CMD_PIOOUT;
            break;

        case STATAPI_CMD_WRITE_SECTORS_EXT:
        case STATAPI_CMD_WRITE_MULTIPLE_EXT:
            Type = ATA_CMD_PIOOUT_EXT;
            break;

        case STATAPI_CMD_IDENTIFY_PACKET_DEVICE:
            Type = ATA_PKT_PIOIN;
            break;
            
        case STATAPI_CMD_READ_DMA:
        case STATAPI_CMD_READ_DMA_QUEUED:
            Type = ATA_CMD_DMAIN;
            break;
            
        case STATAPI_CMD_WRITE_DMA:
        case STATAPI_CMD_WRITE_DMA_QUEUED:
            Type = ATA_CMD_DMAOUT;
            break;
            
        case STATAPI_CMD_READ_DMA_EXT:
        case STATAPI_CMD_READ_DMA_QUEUED_EXT:
            Type = ATA_CMD_DMAIN_EXT;
            break;

        case STATAPI_CMD_WRITE_DMA_EXT:
        case STATAPI_CMD_WRITE_DMA_QUEUED_EXT:
            Type = ATA_CMD_DMAOUT_EXT;
            break;
            
        case STATAPI_CMD_READ_VERIFY_SECTORS:
        case STATAPI_CMD_SEEK:
        case STATAPI_CMD_SET_MULTIPLE_MODE:
        case STATAPI_CMD_IDLE:
        case STATAPI_CMD_IDLE_IMMEDIATE:
        case STATAPI_CMD_STANDBY:
        case STATAPI_CMD_STANDBY_IMMEDIATE:
        case STATAPI_CMD_CHECK_POWER_MODE:
        case STATAPI_CMD_SLEEP:
        case STATAPI_CMD_FLUSH_CACHE:
        case STATAPI_CMD_MEDIA_EJECT:
        case STATAPI_CMD_SET_FEATURES:
        case STATAPI_CMD_CFA_REQUEST_EXT_ERR_CODE:
        case STATAPI_CMD_CFA_ERASE_SECTORS:
            Type = ATA_CMD_NODATA;
            break;

        case STATAPI_CMD_FLUSH_CACHE_EXT:
        case STATAPI_CMD_SET_MAX_ADDRESS_EXT:
        case STATAPI_CMD_READ_NATIVE_MAX_ADDRESS_EXT:
        case STATAPI_CMD_READ_VERIFY_SECTORS_EXT:
            Type = ATA_CMD_NODATA_EXT;
            break;
    }
    
    /* Now see if both the host and the device can support that. These checks
     * are only for capability, *not* to see if host/device are in the correct
     * modes. That's an application problem.
     */
    if ((Type == ATA_CMD_DMAIN)     || (Type == ATA_CMD_DMAOUT) || 
        (Type == ATA_CMD_DMAIN_EXT) || (Type == ATA_CMD_DMAOUT_EXT))
    {
        /* If DMA disabled, or no DMA modes in common for host and device. */
        if ((Dev->DmaEnabled == FALSE) || 
            (Dev->DeviceParams.SupportedDmaModes == 0))
            Supported = FALSE;
    }

    /* This check is almost certainly pointless; maybe it should be removed. */
    if ((Type == ATA_CMD_PIOIN)     || (Type == ATA_CMD_PIOOUT) ||
        (Type == ATA_CMD_PIOIN_EXT) || (Type == ATA_CMD_PIOOUT_EXT))
    {
        if (Dev->DeviceParams.SupportedPioModes == 0)
            Supported = FALSE;
    }

    /* Exit point */
    if (Supported == TRUE)
        return Type;
    else
        return 0;
}
      
 /****************************************************************************
Name         : STATAPI CmdNoData()

Description  : Issues a command with no data transfer associated

Parameters   : STATAPI_Handle_t     Handle        Handle to ATA/ATAPI device on 
                                                  host bus.
               STATAPI_Cmd_t       Cmd            Pointer to the command
                                                  information   
               STATAPI_CmdStatus_t  CmdStat       Pointer that will be updated
                                                  when the command is completed 
               
                   
Return Value :  
  ST_NO_ERROR               No error.
  ST_ERROR_INVALID_HANDLE   Device handle is invalid.
  ST_ERROR_DEVICE_BUSY      The command can not be executed as the BSY bit
                            is set in the status register, indicating the device is
                            busy.
  STATAPI_ERROR_CMD_ABORT   The ABRT bit is set in the error register indicating
                            that the command failed to complete e.g., a bad
                            parameter or unsupported command.
  STATAPI_ERROR_CMD_ERROR   A command-specific error has occured and the
                            user should interrogate the error.
  STATAPI_ERROR_USER_ABORT  The command or operation has been explicitly
                            aborted by the user.
STATAPI_ERROR_MODE_NOT_SET   Mode not set yet                             
 ****************************************************************************/
ST_ErrorCode_t STATAPI_CmdNoData(STATAPI_Handle_t Handle,
                                 const STATAPI_Cmd_t *Cmd,
                                 STATAPI_CmdStatus_t *CmdStatus)
 {
    ata_DevCtrlBlock_t  *Dev;
    U32 Dummy32= 0;
    U8  Dummy8=0;
    U8  DevNo;
    
    Dev=(ata_DevCtrlBlock_t*) Handle;
    
    /*  Check Parameters  */
    if((Dev!= &ATAHandle->Handles[0]) &  (Dev!= &ATAHandle->Handles[1])) 
    {
        return ST_ERROR_INVALID_HANDLE;
    }
    if((Cmd==NULL)|(CmdStatus==NULL))
    {
        return ST_ERROR_BAD_PARAMETER;
    }
    
    /* Internal protocol checkings */