hal.c

来自「ST5518机顶盒系统文件系统源代码！绝对超值！」· C语言 代码 · 共 243 行

/******************************************************************************

    File Name   : 

    Description : 

******************************************************************************/

/* Includes ---------------------------------------------------------------- */

#ifdef STAVFS_HAL_SIMULATION
#undef STAVFS_HAL_SIMULATION
#endif

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <assert.h>

#include "hal.h"
#include "internal.h"
#include "sttbx.h"

/* Private Types ----------------------------------------------------------- */

/* Private Constants ------------------------------------------------------- */

#define   ENABLE_WRITE_CACHE                      (0x02)
#define   DISABLE_REVERTING_TO_POWER_ON_DEFAULT   (0x66)

#define   BLOCK_ACCESS_SIZE  (128)

static U64 const Max28BitsValue = { 0X0FFFFFFF, 0 }; /* Maximum 28 bit value */

#define   HAL_MAGIC_NUM       ((void*)&Magic) /* Unique value to HAL */

/* Private Variables ------------------------------------------------------- */

/* Private Macros ---------------------------------------------------------- */

/* Private Function Prototypes --------------------------------------------- */

static ST_ErrorCode_t SetupTheEvents (stavfs_HAL_t * HALData_p);
static ST_ErrorCode_t IdentifyDevice (stavfs_HAL_t * HALData_p, U16 * Info, U8 StartIndex, U8 Length);

static void Callback (STEVT_CallReason_t Reason, const ST_DeviceName_t RegName, STEVT_EventConstant_t Event,
                      const void *EventData, const void *SubscriberData_p);

static int Magic; /* This variable exists soly to provide a unique adddress */

/*************************************************************************
 *
 * This code is used for crash testing only
 *
 * DO NOT COMPILE WITH "STAVFS_CRASH_TEST" DEFINED FOR A LIVE SYSTEM
 *
 *************************************************************************/

#ifdef STAVFS_CRASH_TEST

void stavfs_Crash(stavfs_HAL_t * HALData_p, U64 * FirstSector_p);
/* from crash test module */

#endif

/* Functions --------------------------------------------------------------- */




/******************************************************************************
Function Name : stavfs_HalDiskExist
  Description : Does the specified volume exist in the physical world.
   Parameters : 
******************************************************************************/
BOOL stavfs_HalDiskExist (stavfs_HAL_t * HALData_p)
{
    ST_ErrorCode_t Error;

    assert (NULL != HALData_p);

    if (HALData_p->Initialised)
    {
        return (TRUE);          /* Already up and running */
    }
    else if (HALData_p->Protocol == PROTOCOL_ATA) /* ATA protocol */
    {
        STATAPI_Handle_t AtapiHandle;
        STATAPI_OpenParams_t AtapiOpenParams;
        STATAPI_DriveType_t Type = STATAPI_UNKNOWN_DRIVE;

        switch (HALData_p->UnitNumber)
        {
            case 0:
                AtapiOpenParams.DeviceAddress = STATAPI_DEVICE_0;
                break;
            case 1:
                AtapiOpenParams.DeviceAddress = STATAPI_DEVICE_1;
                break;
            default:
                return (FALSE); /* Invalid unit number */
        }

        /* The code here can test a HDD is present, on TheBoard */

        if (ST_NO_ERROR == (Error = STATAPI_Open (HALData_p->ATAPIName, &AtapiOpenParams, &AtapiHandle)))
        {
            STATAPI_GetDriveType (AtapiHandle, &Type);
            STATAPI_Close (AtapiHandle);
        }

        return (Type == STATAPI_ATAPI_DRIVE) || (Type == STATAPI_ATA_DRIVE);
    }
    else
    {
        /* Unknown protocol */
        return (FALSE);
    }
}


/******************************************************************************
Function Name : stavfs_HalInit
  Description : Initialise the disk volume.
   Parameters : The stavfs_HAL_t structure passed will be completed by the
                initialisation and must be passed to subsequent calls.
******************************************************************************/
ST_ErrorCode_t stavfs_HalInit (stavfs_HAL_t * HALData_p)
{
    ST_ErrorCode_t Error = ST_NO_ERROR;
    BOOL GotHandles = FALSE; /* flags how failure should be dealt with */

    assert (NULL != HALData_p);

    task_lock();
    if (HALData_p->Initialised)
    {
        task_unlock();
        STTBX_Print(("Hal already initialised\n"));
        return (Error);         /* Already up and running */
    }
    else
    {
        HALData_p->a.ata.EVTHandle   = 0;
        HALData_p->a.ata.AtapiHandle = NULL;
        HALData_p->Initialised       = TRUE;
        HALData_p->MagicNumber       = HAL_MAGIC_NUM;
         
        /* Set up the semaphores */

        semaphore_init_fifo_timeout (&(HALData_p->CMDSemaphore), 0);
        task_unlock();
    }
    
    if (HALData_p->Protocol == PROTOCOL_ATA) /* ATA protocol */
    {
        STATAPI_OpenParams_t   AtapiOpenParams;
        STATAPI_DriveType_t    Type;
        
        STATAPI_Cmd_t          Cmd;
        STATAPI_CmdStatus_t    CmdStatus;
        
        U16 Word;
        

        switch (HALData_p->UnitNumber)
        {
            case 0:
                AtapiOpenParams.DeviceAddress = STATAPI_DEVICE_0;
                break;
            case 1:
                AtapiOpenParams.DeviceAddress = STATAPI_DEVICE_1;
                break;
            default:
                Error = ST_ERROR_BAD_PARAMETER; /* Invalid unit number */
        }

        /* The code here can test a HDD is present, on the board */

        if (Error != ST_NO_ERROR)
        {
            STTBX_Print (("Bad unit number\n"));
        }
        else if (ST_NO_ERROR != (Error = STATAPI_Open (HALData_p->ATAPIName, &AtapiOpenParams, &(HALData_p->a.ata.AtapiHandle))))
        {
            STTBX_Print (("Failed to open STATAPI: error 0X%08X\n", Error));
        }
        else if ((ST_NO_ERROR != STATAPI_GetDriveType (HALData_p->a.ata.AtapiHandle, &Type)) &&
                 (Type != STATAPI_ATAPI_DRIVE) && (Type != STATAPI_ATA_DRIVE))
        {
            /* Bad drive type */
            STTBX_Print (("Bad drive type\n"));
            STATAPI_Close (HALData_p->a.ata.AtapiHandle);
            Error = ST_ERROR_BAD_PARAMETER;
        }
        else if (ST_NO_ERROR != (Error = SetupTheEvents (HALData_p)))
        {
            /* Initialisation failed */
            STTBX_Print (("Failed to setup the drive events\n"));
            STATAPI_Close (HALData_p->a.ata.AtapiHandle);
        }
        else
        {
            GotHandles = TRUE; /* use stavfs_HalTerm if we go wrong from now on */
            
            if (ST_NO_ERROR != (Error = STATAPI_SetPioMode (HALData_p->a.ata.AtapiHandle, STATAPI_PIO_MODE_4)))
            {
                /* Initialisation failed */
                STTBX_Print (("Failed to setup the PIO Mode\n"));
            }
        }

        if (Error == ST_NO_ERROR)
        {
            Cmd.Features = DISABLE_REVERTING_TO_POWER_ON_DEFAULT;
            Cmd.SectorCount = 0;
            Cmd.CmdCode = STATAPI_CMD_SET_FEATURES;

            if (ST_NO_ERROR ==
                    (Error = STATAPI_CmdNoData (HALData_p->a.ata.AtapiHandle, &Cmd, &CmdStatus)))
            {
                semaphore_wait (&(HALData_p->CMDSemaphore));
                STTBX_Report ((STTBX_REPORT_LEVEL_INFO, "FEATURE DISABLE_REVERTING_TO_POWER_ON_DEFAULT ACTIVED"));
            }
        }

        if (Error == ST_NO_ERROR)
        {
            Cmd.Features = ENABLE_WRITE_CACHE;
            Cmd.SectorCount = 0;
            Cmd.CmdCode = STATAPI_CMD_SET_FEATURES;

            if (ST_NO_ERROR ==
                (Error = STATAPI_CmdNoData (HALData_p->a.ata.AtapiHandle, &Cmd, &CmdStatus)))
            {
                semaphore_wait (&(HALData_p->CMDSemaphore));
                STTBX_Report ((STTBX_REPORT_LEVEL_INFO, "FEATURE ENABLE_WRITE_CACHE ACTIVED"));
            }
        }

        if (Error == ST_NO_ERROR)
        {
            /* 1