atapitest.c

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

    InitParams.BaseAddress = ATA_BASE_ADDRESS;
    InitParams.HW_ResetAddress = ATA_HRD_RST;
    InitParams.InterruptNumber = ATA_INTERRUPT_NUMBER;
    InitParams.InterruptLevel = ATA_INTERRUPT_LEVEL;
#if defined(ST_5514)
    InitParams.ClockFrequency = ClockFrequency;
    strcpy(AtapiInitParams.GPDMADeviceName, GPDMADevName);
#endif
    strcpy(InitParams.EVTDeviceName, EVTDevName);

    error = STATAPI_Init(AtapiDevName, &InitParams);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_Init()\n"));
        DisplayError(error);
    }
}

void test_typical(void *dummy)
{
    ST_ErrorCode_t          error;
    STATAPI_Handle_t        Handle;
    STATAPI_OpenParams_t    OpenParams;

    STATAPI_PioMode_t       PioMode;
    STATAPI_PioTiming_t     PioTimingParams;
    STATAPI_Capability_t    Capability;
    STATAPI_Cmd_t           Cmd;
    STATAPI_CmdStatus_t     CmdStatus;

    U32                     BytesTransferred;

    OpenParams.DeviceAddress = STATAPI_DEVICE_0;

    memset(&Cmd, 0, sizeof(STATAPI_Cmd_t));

    error = STATAPI_Open(AtapiDevName, &OpenParams, &Handle);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_Open() - "));
        DisplayErrorNew(error);
    }
    
    error = STATAPI_SoftReset(AtapiDevName);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_SoftReset() - "));
        DisplayErrorNew(error);
    }

    semaphore_wait(&StepSemaphore);
    if (EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("Event carried result: "));
        DisplayErrorNew(EvtError);
    }

    error = STATAPI_Abort(Handle);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_Abort() - "));
        DisplayErrorNew(error);
    }

    error = STATAPI_GetCapability(AtapiDevName, &Capability);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_GetCapability() - "));
        DisplayErrorNew(error);
    }

#if !defined(ST_5508) && !defined(ST_5518)
    error = STATAPI_HardReset(AtapiDevName);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_HardReset() - "));
        DisplayErrorNew(error);
    }

    semaphore_wait(&StepSemaphore);
    if (EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("Event from STATAPI_HardReset: "));
        DisplayErrorNew(EvtError);
    }
#endif

    /* Consider adding DMA mode as well? */
    error = STATAPI_SetPioMode(Handle, STATAPI_PIO_MODE_4);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_SetPioMode() - "));
        DisplayErrorNew(error);
    }

    error = STATAPI_GetPioMode(Handle, &PioMode, 
                               &PioTimingParams);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_GetPioMode() - "));
        DisplayErrorNew(error);
    }

    Cmd.SectorCount = 1;
    Cmd.CmdCode = STATAPI_CMD_IDENTIFY_DEVICE;
    Cmd.UseLBA = FALSE;
    error = STATAPI_CmdIn(Handle, &Cmd, MemTestDataBuffer,
                          10240, &BytesTransferred, &CmdStatus);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_CmdIn()\n"));
        DisplayErrorNew(error);
    }

    semaphore_wait(&StepSemaphore);
    if (EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("Event from STATAPI_CmdIn: "));
        DisplayErrorNew(EvtError);
        STTBX_Print(("Bytes transferred: %i\n", BytesTransferred));
    }

    Cmd.CmdCode = STATAPI_CMD_FLUSH_CACHE;
    Cmd.UseLBA = FALSE;
    error = STATAPI_CmdNoData(Handle, &Cmd, &CmdStatus);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_CmdNoData() - "));
        DisplayErrorNew(error);
    }
    
    semaphore_wait(&StepSemaphore);
    if (EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("Event from STATAPI_CmdOut: "));
        DisplayErrorNew(EvtError);
        STTBX_Print(("Bytes transferred: %i\n", BytesTransferred));
    }

    Cmd.CmdCode = STATAPI_CMD_WRITE_SECTORS;
    Cmd.SectorCount = 1;
    Cmd.UseLBA = FALSE;
    Cmd.Sector = 1;
    Cmd.CylinderLow =  1;
    Cmd.CylinderHigh = 0;
    Cmd.Head = 0;
    error = STATAPI_CmdOut(Handle, &Cmd, MemTestDataBuffer,
                           10240, &BytesTransferred, &CmdStatus);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_CmdOut() - "));
        DisplayErrorNew(error);
    }

    semaphore_wait(&StepSemaphore);
    if (EvtError != ST_NO_ERROR)
    {
        STTBX_Print(("Event from STATAPI_CmdOut: "));
        DisplayErrorNew(EvtError);
    }
    
    error = STATAPI_Close(Handle);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_Close() - "));
        DisplayErrorNew(error);
    }
}

void test_term(void *dummy)
{
    ST_ErrorCode_t error;
    STATAPI_TermParams_t TermParams;
    
    TermParams.ForceTerminate = TRUE;
    error = STATAPI_Term(AtapiDevName, &TermParams);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("STATAPI_Term()\n"));
        DisplayError(error);
    }
}

static ATAPI_TestResult_t ATAPI_MemoryTest(ATAPI_TestParams_t *TestParams)
{
    ATAPI_TestResult_t result = TEST_RESULT_ZERO;
    task_t task;
    tdesc_t tdesc;
    task_t *task_p;
    task_status_t status;
    char stack[4 * 1024];
    void (*func_table[])(void *) = { test_overhead,
                                     test_init,
                                     test_typical,
                                     test_term,
                                     NULL };
    U8 i;
    void (*func)(void *);
    
    task_p = &task;
    for (i = 0; func_table[i] != NULL; i++)
    {
        func = func_table[i];
        task_init(func, NULL, stack, 4 * 1024, task_p, &tdesc,
                  MAX_USER_PRIORITY, "stack test", 0);
        task_wait(&task_p, 1, TIMEOUT_INFINITY);

        task_status(task_p, &status, task_status_flags_stack_used);
        printf("Function %i, stack used %i\n", i, status.task_stack_used);

        task_delete(task_p);
    }
    
    return result;
}

#endif /* ATAPI_MEMTEST */

/*****************************************************************
    ATAPI_TestSimpleAPI
    
  This test is aimed to show how the basic functionalities of the driver 
  work correctly.
  If This test is ran twice it test first the DEVICE 0 and then the DEVICE 1. 
   
******************************************************************/

static ATAPI_TestResult_t ATAPI_TestSimpleAPI(ATAPI_TestParams_t * TestParams)
{
    
    ST_ErrorCode_t  Error;  
    ATAPI_TestResult_t Result = TEST_RESULT_ZERO;
    U32 i;
    /* ATAPI driver parameters */  
    STATAPI_InitParams_t    AtapiInitParams;
    STATAPI_TermParams_t    AtapiTermParams;
    STATAPI_OpenParams_t    AtapiOpenParams;

    
    AtapiInitParams.DeviceType= STATAPI_EMI_PIO4;
    AtapiInitParams.DriverPartition= TEST_PARTITION_1;
    AtapiInitParams.BaseAddress= ATA_BASE_ADDRESS;
    AtapiInitParams.HW_ResetAddress= ATA_HRD_RST;
    AtapiInitParams.InterruptNumber = ATA_INTERRUPT_NUMBER;
    AtapiInitParams.InterruptLevel = ATA_INTERRUPT_LEVEL;
#if defined(ST_5514)
    AtapiInitParams.ClockFrequency = ClockFrequency;
#endif
#if defined(ATAPI_GPDMA)
    strcpy(AtapiInitParams.GPDMADeviceName, GPDMADevName);
#endif
    strcpy(AtapiInitParams.EVTDeviceName,EVTDevName);
    
    /* STATAPI_Init() */
    STTBX_Print(("%d.0 STATAPI_Init() \n",TestParams->Ref));
    STTBX_Print(("Purpose: to ensure a ATAPI device can be initialized\n"));
    {
        Error = STATAPI_Init(AtapiDevName, &AtapiInitParams);
        if(CheckCodeOk(Error))
        {
            ATAPI_TestFailed(Result,"Unable to initialize ATAPI device");
            goto api_end;
        }
        ATAPI_TestPassed(Result);
        
    } 
    
  for(i=0;i<1;i++)    
  {  
    if(Drives[i].Present)
    {
    /* STATAPI_Open() */
    if(i==0)  AtapiOpenParams.DeviceAddress=STATAPI_DEVICE_0;
    else  AtapiOpenParams.DeviceAddress=STATAPI_DEVICE_1;
    STTBX_Print(("%d.1 STATAPI_Open() \n",TestParams->Ref));
    STTBX_Print(("Purpose: to ensure a ATAPI device connection can be opened\n"));
    {
        Error = STATAPI_Open(AtapiDevName, &AtapiOpenParams,&Drives[i].Handle);
        if(CheckCodeOk(Error))
        {
            ATAPI_TestFailed(Result,"Unable to open ATAPI device");
            goto api_end;
        }
        ATAPI_TestPassed(Result);
        
    } 

     /* STATAPI_SetPioMode */
    
    STTBX_Print(("%d.2 Set Pio mode 4 \n",TestParams->Ref));
    STTBX_Print(("Purpose: to ensure we can set the Pio mode 4\n "));
    {
        Error = STATAPI_SetPioMode(Drives[i].Handle,STATAPI_PIO_MODE_4);
        if(CheckCodeOk(Error))
        {
            ATAPI_TestFailed(Result,"Unable to set Pio mode 4");
            goto api_end;
        }
        ATAPI_TestPassed(Result);
        
    }          
   /* Simple Read/Write Test */
    if(Drives[i].Type==STATAPI_ATA_DRIVE)
    {        
   /* Simple Read/Write Test */
    
      STTBX_Print(("%d.3 Simple R/W Test \n",TestParams->Ref));
      STTBX_Print(("Purpose: to ensure we can write data and then read it back \n"));
      {
        Error = SimpleRWTest(Drives[i].Handle,&AddressTable[0],3); 
        if(CheckCodeOk(Error))
        {
            ATAPI_TestFailed(Result,"Unable to Read/Write ATAPI device");
            goto api_end;
        }
        ATAPI_TestPassed(Result);        
      } 
    }else if(Drives[i].Type==STATAPI_ATAPI_DRIVE)
    {
      STTBX_Print(("%d.3  Read TOC Test \n",TestParams->Ref));
      STTBX_Print(("Purpose: to ensure we can read data from the device \n"));
      {
       
        Error = ReadTOCTest(Drives[i].Handle); 
        if(CheckCodeOk(Error))
        {
            ATAPI_TestFailed(Result,"Unable to Read TOC from ATAPI device");
            goto api_end;
        }
       
        ATAPI_TestPassed(Result);        
      }   
    }
    
api_end: 
    
    /* STATAPI_Close() */
    
    STTBX_Print(("%d.4 STATAPI_Close \n",TestParams->Ref));
    STTBX_Print(("Purpose: to ensure we can close a connection\n"));
    {
        Error = STATAPI_Close(Drives[i].Handle);
        if(CheckCodeOk(Error))
        {
            ATAPI_TestFailed(Result,"Unable to close a connection");
        }
        ATAPI_TestPassed(Result);
        
    }          
    
   } /* end if (drive present)*/ 
  } /* end for */
    
    AtapiTermParams.ForceTerminate= FALSE;
    
    /* STATAPI_Term() */
    
    STTBX_Print(("%d.5 STATAPI_Term \n",TestParams->Ref));
    STTBX_Print(("Purpose: to ensure we can terminate the driver\n"));
    {
        Error= STATAPI_Term(AtapiDevName,&AtapiTermParams);
        if(CheckCodeOk(Error))
        {
            ATAPI_TestFailed(Result,"Unable to terminate the driver");
        }else
        {
            ATAPI_TestPassed(Result);
        }
        
        
    }          
    
    return Result;

}
/*****************************************************************
    ATAPI_TestAPINormal
    
  This test is aimed to show how almost all the functionalities of 
  the driver work correctly. These are:
    - Init / Term
    - Open/ Close
    - Re-open
    - GetParams
    - GetCapability
    - GetPioMode
    - HardReset
    - SoftReset
    - CmdIn (READ_SECTOR and READ_MULTIPLE)
    - CmdOut (WRITE_SECTOR and WRITE_MULTIPLE)
    - CmdNoData (SET_MULIPLE_MODE)