statapi.c

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

    if (TermParams->ForceTerminate == TRUE)
    {      
        if (ATAHandle->UsedHandles !=0 )   
        {
            /* Close existing handles */
            if (ATAHandle->Handles[0].Opened == TRUE)
            {
                rVal = STATAPI_Close((STATAPI_Handle_t)&ATAHandle->Handles[0]);
            }
            
            if (rVal != ST_NO_ERROR)
                return rVal;
            
            if (ATAHandle->Handles[1].Opened == TRUE)
            {
                rVal = STATAPI_Close((STATAPI_Handle_t)&ATAHandle->Handles[1]);
            }
            
            if (rVal != ST_NO_ERROR)
                return rVal;
        }
    }
    else if (ATAHandle->UsedHandles != 0 )
    {
        return ST_ERROR_OPEN_HANDLE;
    }
       
    /* Unregister events */  
    rVal = UnregisterATAEvents(ATAHandle->EvtHndl);
    if(rVal != ST_NO_ERROR)
    {
        return rVal;   
    }
    
    /* After closing all the handles we are sure that the BAT is waiting and
     * that the bus is idle.. so we have to set terminate
     * to make the task to exit from the main loop before signal
     */
    ATAHandle->Terminate = TRUE;
    TaskList[0] = &ATAHandle->BAT;
    semaphore_signal(&ATAHandle->BATSemaphore);
    TO = time_plus(time_now(), ATA_TIMEOUT);
    
    if(task_wait(TaskList, 1, &TO))
    {         
        return STATAPI_ERROR_TERMINATE_BAT;
    }
      
    /* Deallocate all resources */   
    semaphore_delete(&ATAHandle->BusMutexSemaphore);
    semaphore_delete(&ATAHandle->BATSemaphore);
    semaphore_delete(&ATAHandle->Handles[STATAPI_DEVICE_0].EndCmdSem);
    semaphore_delete(&ATAHandle->Handles[STATAPI_DEVICE_1].EndCmdSem);
    
    hal_Term(ATAHandle->HalHndl);
    
    task_delete(&ATAHandle->BAT);
    
    /* Clean and deallocate */
    Clean_p = ATAHandle;
    
    memory_deallocate(ATAHandle->DriverPartition, ATAHandle);
    memory_deallocate(ATAHandle->DriverPartition, BusTaskStack); 
    memset(Clean_p, 0, sizeof(ata_ControlBlock_t));
    ATAHandle = NULL;
    
    return ST_NO_ERROR;
}

/****************************************************************************
Name         : STATAPI Open()

Description  : Open a connection to the ATAPI driver and allocate a structure
                to control that connection

Parameters   : ST_DeviceName_t      DeviceName      ATAPI driver name
               STATAPI_OpenParams_t OpenParams      Params structure
               STATAPI_Handle_t     Handle          Stored handle identifier for
                                                    communicating with the
                                                    ATA/ATAPI driver  
                   
Return Value :  
  ST_NO_ERROR                       No error.
  ST_ERROR_BAD_PARAMETER            The device address parameter is invalid.
  ST_ERROR_NO_FREE_HANDLES          The ATA/ATAPI device is already open.
  ST_ERROR_UNKNOWN_DEVICE           Invalid device name or unable to identify the
                                    device when issuing a IDENTIFY DEVICE command.
  STATAPI_ERROR_DEVICE_NOT_PRESENT  The ATA/ATAPI device at the nominated address is
                                        not present.
 ****************************************************************************/
 
ST_ErrorCode_t STATAPI_Open(const ST_DeviceName_t          DeviceName,
                             const  STATAPI_OpenParams_t   *OpenParams,
                             STATAPI_Handle_t              *Handle)
 {
    ST_ErrorCode_t rVal=ST_NO_ERROR;
    
    /* Parameter check */
    
    if (strcmp(DeviceName,ATAHandle->DeviceName))
    {
        return ST_ERROR_UNKNOWN_DEVICE;
    }
    
    if(IsOutsideRange(
                OpenParams->DeviceAddress,
                STATAPI_DEVICE_0,
                STATAPI_DEVICE_1))              
     {           
       return( ST_ERROR_BAD_PARAMETER );
     } 
    if ((OpenParams==NULL) | (Handle==NULL))
    {
        return ST_ERROR_BAD_PARAMETER;
    }
    
    
    if(ATAHandle->Handles[OpenParams->DeviceAddress].Opened)
    {
        return ST_ERROR_NO_FREE_HANDLES;
    }
    
    if((ATAHandle->DevInBus[OpenParams->DeviceAddress]==NONE_DEVICE)|
       (ATAHandle->DevInBus[OpenParams->DeviceAddress]==UNKNOWN_DEVICE))   
    {
        return STATAPI_ERROR_DEVICE_NOT_PRESENT;
    }     
    
    /* Identify device and set the common capabilities (host and device) */  
    rVal= GetDeviceCapabilities(OpenParams->DeviceAddress);
    if(rVal!= ST_NO_ERROR) 
    {
      return rVal;
    }
    /*Set up the other fields*/
    ATAHandle->Handles[OpenParams->DeviceAddress].Abort= FALSE;
    ATAHandle->Handles[OpenParams->DeviceAddress].Notify= FALSE; 
    ATAHandle->Handles[OpenParams->DeviceAddress].MultiCnt= 1;
    ATAHandle->Handles[OpenParams->DeviceAddress].IsModeSet= FALSE;
    ATAHandle->Handles[OpenParams->DeviceAddress].DeviceParams.CurrentDmaMode = STATAPI_DMA_NOT_SUPPORTED;

    *Handle= (STATAPI_Handle_t) &ATAHandle->Handles[OpenParams->DeviceAddress];
    ATAHandle->Handles[OpenParams->DeviceAddress].Opened= TRUE; 
    ATAHandle->UsedHandles++;

    return ST_NO_ERROR;
}
 
/****************************************************************************
Name         : STATAPI Close()

Description  : Closes the connection to the ATA/ATAPI device associated with the 
               device handle.

Parameters   : STATAPI_Handle_t     Handle        Handle to ATA/ATAPI device on 
                                                  host bus.
                   
Return Value :  
          ST_NO_ERROR                   No error
          ST_ERROR_INVALID_HANDLE       Handle invalid or not open.
 ****************************************************************************/
ST_ErrorCode_t STATAPI_Close(STATAPI_Handle_t Handle)
 {
    
    ata_DevCtrlBlock_t  *Dev;
    U8                  DevNo;
    clock_t             TO;
    
    Dev=(ata_DevCtrlBlock_t *)Handle;
    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;
    }
    
    /* Try to acquire the bus */
    if(ata_bus_Acquire(ATAHandle))
    {
        /*We fail: someone is using the bus*/
        if(ATAHandle->DeviceSelected==DevNo)
        { /* It's me ... I have to abort */
            Dev->Abort=TRUE;
            TO = time_plus(time_now(), CLOSING_TIMEOUT);
            if(semaphore_wait_timeout(&Dev->EndCmdSem,&TO))
            {
                return ST_ERROR_INVALID_HANDLE;
            }
        }
         /* It's not me... nothing to do */
        
    }
    
    Dev->Opened= FALSE;
    Dev->IsModeSet= FALSE;
    Dev->Notify= FALSE;
    Dev->Abort= FALSE;
    ATAHandle->UsedHandles--;
    ata_bus_Release(ATAHandle);
    
    return ST_NO_ERROR;
 }

 /****************************************************************************
Name         : STATAPI SetPioMode()

Description  : Sets the current PIO mode on the device handle.

Parameters   : STATAPI_Handle_t     Handle        Handle to ATA/ATAPI device on 
                                                  host bus.
               STATAPI_PIOMode_t    Mode          PIO mode to invoke.   
               
                   
Return Value :  
    ST_NO_ERROR                      The PIO mode was set without error.
    ST_ERROR_BAD_PARAMETER           Invalid mode parameter.
    ST_ERROR_DEVICE_BUSY             The ATA/ATAPI device or host controller 
                                     is busy.
    ST_ERROR_INVALID_HANDLE          The handle is invalid.
    ST_ERROR_FEATURE_NOT_SUPPORTED   The host controller or ATA/ATAPI device does 
                                     not  supported the PIO mode.
 ****************************************************************************/
ST_ErrorCode_t STATAPI_SetPioMode(STATAPI_Handle_t Handle,
                                  STATAPI_PioMode_t Mode)
{
    BOOL error = FALSE;
    ata_DevCtrlBlock_t  *Dev;
    U32 Dummy= 0;
    
    Dev=(ata_DevCtrlBlock_t*) Handle;
    
    /*  Check Parameters  */
    if((Dev!= &ATAHandle->Handles[0]) &  (Dev!= &ATAHandle->Handles[1])) 
    {
        return ST_ERROR_INVALID_HANDLE;
    }
    if(IsOutsideRange( Mode,STATAPI_PIO_MODE_0, STATAPI_PIO_MODE_4))
    {
        return ST_ERROR_BAD_PARAMETER;
    }
    
    if(Dev->Opened==FALSE) 
    {
        return ST_ERROR_INVALID_HANDLE;
    }
    
    /*  Check if the mode is suported  */
    Dummy= 1<< Mode;

    /* Note! This *will* need to be changed if the driver gets 
     * extended to support more PIO modes.
     */
    if (Dev->DeviceParams.SupportedPioModes & Dummy)
    { 
        /* Ok! the device support the mode*/
        if(ata_bus_Acquire(ATAHandle))
        {
            return ST_ERROR_DEVICE_BUSY;
        }

        /* Set the mode */
        if(Dev->DeviceParams.CurrentPioMode!= Mode)
        {
            error = hal_SetPioMode(ATAHandle->HalHndl,Mode);
            Dev->DeviceParams.CurrentPioMode= Mode;
        }

#if defined(ST_5514)
        /* Set the timing, based on the stored value */
        if (error == FALSE)
        {
            if (Dev->PioTimingOverridden[PIOMODE_TO_INDEX(Mode)])
            {
                hal_SetPioTiming(ATAHandle->HalHndl,
                                 &Dev->PioTimingOverrides[PIOMODE_TO_INDEX(Mode)]);
            }
            else
            {
                hal_SetPioTiming(ATAHandle->HalHndl, 
                                 &PioTimingDefaults[PIOMODE_TO_INDEX(Mode)]);
            }
        }
#endif

        ata_bus_Release(ATAHandle);
    }
    else
    {
        return  ST_ERROR_FEATURE_NOT_SUPPORTED;
    }
    
    Dev->IsModeSet= TRUE;
    return ST_NO_ERROR;
}
    
 /****************************************************************************
Name         : STATAPI SetDmaMode()

Description  : Sets the current Dma mode on the device handle.

Parameters   : STATAPI_Handle_t     Handle        Handle to ATA/ATAPI device on 
                                                  host bus.
               STATAPI_DmaMode_t    Mode          DMA mode to invoke.   
               
                   
Return Value :  
    ST_NO_ERROR                      The DMA mode was set without error.
    ST_ERROR_BAD_PARAMETER           Invalid mode parameter.
    ST_ERROR_DEVICE_BUSY             The ATA/ATAPI device or host controller 
                                     is busy.
    ST_ERROR_INVALID_HANDLE          The handle is invalid.
    ST_ERROR_FEATURE_NOT_SUPPORTED   The host controller or ATA/ATAPI device does 
                                     not  supported the DMA mode.
 ****************************************************************************/
ST_ErrorCode_t STATAPI_SetDmaMode(STATAPI_Handle_t Handle,STATAPI_DmaMode_t Mode)
{
    ata_DevCtrlBlock_t  *Dev;
#if defined(ST_5514)
    BOOL error = FALSE;
    U32 Dummy= 0;
#endif
    
    Dev=(ata_DevCtrlBlock_t*) Handle;
    
    /*  Check Parameters  */
    if((Dev!= &ATAHandle->Handles[0]) &  (Dev!= &ATAHandle->Handles[1])) 
    {
        return ST_ERROR_INVALID_HANDLE;
    }
    if (Dev->Opened == FALSE)
    {
        return ST_ERROR_INVALID_HANDLE;
    }
    if(IsOutsideRange( Mode,STATAPI_DMA_MWDMA_MODE_0, STATAPI_DMA_NOT_SUPPORTED))
    {
        return ST_ERROR_BAD_PARAMETER;
    }

    /* This would be a stupid thing to try and set. */
    if (Mode == STATAPI_DMA_NOT_SUPPORTED)
        return ST_ERROR_BAD_PARAMETER;

#if defined(ST_5514)
    /*  Check if the mode is suported  */
    Dummy= 1<< Mode;
    if(Dev->DeviceParams.SupportedDmaModes & Dummy)
    { /* Ok! the device support the mode*/
        if(ata_bus_Acquire(ATAHandle))
        {
            return ST_ERROR_DEVICE_BUSY;
        }

        /* Set the mode */
        if(Dev->DeviceParams.CurrentDmaMode != Mode)
        {
            error = hal_SetDmaMode(ATAHandle->HalHndl,Mode);
            if (error == FALSE)
            {
                /* Set DMA mode okay, so restore last known timing
                 * parameters for this mode 
                 */
                U32 index;

                Dev->DeviceParams.CurrentDmaMode= Mode;
                if (IsOutsideRange(Mode, STATAPI_DMA_MWDMA_MODE_0, 
                                   STATAPI_DMA_MWDMA_MODE_2))
                {
                    /* UDMA */
                    index = UDMAMODE_TO_INDEX(Mode);
                    if (Dev->UDMATimingOverridden[index])
                        hal_SetUDMATiming(ATAHandle->HalHndl, 
                                          &Dev->UltraDmaTimingOverrides[index]);
                    else
                        hal_SetUDMATiming(ATAHandle->HalHndl,
                                          &UltraDmaTimingDefaults[index]);
                }
                else
                {
                    index = MWDMAMODE_TO_INDEX(Mode);
                    if (Dev->MWDMATimingOverridden[index])
                        hal_SetMWDMATiming(ATAHandle->HalHndl, 
                                           &Dev->MwDmaTimingOverrides[index]);
                    else
                        hal_SetMWDMATiming(ATAHandle->HalHndl,
                                           &MwDmaTimingDefaults[index]);
                }
            }
        }