atapitest.c

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

    Error = STATAPI_CmdNoData(Handle, &Cmd, &CmdStatus);
    if (Error == ST_NO_ERROR)
    {
        semaphore_wait(&StepSemaphore);
        if ((CmdStatus.Error != ST_NO_ERROR) || 
            (EvtError != ST_NO_ERROR))
        {
            STTBX_Print(("Error while setting features: "));
            DisplayErrorNew(CmdStatus.Error);
            DisplayErrorNew(EvtError);
        }
    }
    else
    {
        STTBX_Print(("Couldn't set features: "));
        DisplayErrorNew(Error);
    }
    
    return Error;
}
#endif

static ST_ErrorCode_t SetTransferModePio(STATAPI_Handle_t Handle, 
                                         STATAPI_PioMode_t PioMode)
{
    STATAPI_Cmd_t Cmd;
    STATAPI_CmdStatus_t CmdStatus;
    ST_ErrorCode_t Error;

    return 0;
    
    Cmd.Features = 3;
    Cmd.UseLBA = FALSE;
    Cmd.Sector = 0;
    Cmd.CylinderLow =  0;
    Cmd.CylinderHigh = 0;
    Cmd.Head = 0;
    Cmd.CmdCode = STATAPI_CMD_SET_FEATURES;

    /* PIO flow control mode */
    Cmd.SectorCount = 0x8 + (PioMode - STATAPI_PIO_MODE_0);

    STTBX_Print(("Setting transfer mode\n"));
    Error = STATAPI_CmdNoData(Handle, &Cmd, &CmdStatus);
    if (Error == ST_NO_ERROR)
    {
        semaphore_wait(&StepSemaphore);
        if ((CmdStatus.Error != ST_NO_ERROR) || 
            (EvtError != ST_NO_ERROR))
        {
            STTBX_Print(("Error while setting features: "));
            DisplayErrorNew(CmdStatus.Error);
            DisplayErrorNew(EvtError);
        }
    }
    else
    {
        STTBX_Print(("Couldn't set features: "));
        DisplayErrorNew(Error);
    }
    
    return Error;
}

#ifdef RW_INFO
static void ShowStatus(STATAPI_CmdStatus_t * Stat)
{

  STTBX_Print(("Command Status info:  \n"));
  STTBX_Print(("    Error %x \n",Stat->Error));
  STTBX_Print(("    Status %x \n",Stat->Status));
  STTBX_Print(("    LBA %x \n",Stat->LBA));

  STTBX_Print(("    Sector %x \n",Stat->Sector));
  STTBX_Print(("    CylinderLow %x \n",Stat->CylinderLow));
  STTBX_Print(("    CylinderHigh %x \n",Stat->CylinderHigh));
  STTBX_Print(("    Head %x \n",Stat->Head));
  STTBX_Print(("    SectorCount %x \n",Stat->SectorCount));
  
  STTBX_Print(("--------------------------------------\n"));
}
#endif

/**************************************************************************
       THIS FUNCTION WILL CALL ALL THE TEST ROUTINES...
**************************************************************************/

#if defined(MEDIAREF)

/*-------------------------------------------------------------------------
 * Function : ATAPI_UndoClkGen
 * Notes    : On Mediaref board, turns off clkgen workaround that uses 
 *            ATA data lines
 * Input    : None
 * Output   :
 * Return   : Error Code
 * ----------------------------------------------------------------------*/
static ST_ErrorCode_t ATAPI_UndoClkGen(void)
{
    STPIO_InitParams_t PIO_InitParams;
    STPIO_OpenParams_t PIO_OpenParams;
    STPIO_TermParams_t PIO_TermParams;
    STPIO_Handle_t     PIO_Handle;
    ST_ErrorCode_t     ErrCode;

    PIO_InitParams.BaseAddress = (U32 *)PIO_3_BASE_ADDRESS;
    PIO_InitParams.InterruptNumber = PIO_3_INTERRUPT;
    PIO_InitParams.InterruptLevel = PIO_3_INTERRUPT_LEVEL;
    PIO_InitParams.DriverPartition = TEST_PARTITION_1;
    ErrCode = STPIO_Init("PIO3", &PIO_InitParams);
    if (ErrCode != ST_NO_ERROR)
    {
        STTBX_Print(("Init PIO driver (port 3) failed  "));
        DisplayErrorNew(ErrCode);
        return ErrCode;
    }
    
    PIO_OpenParams.ReservedBits    = PIO_BIT_5;
    PIO_OpenParams.BitConfigure[5] = STPIO_BIT_OUTPUT;
    PIO_OpenParams.IntHandler      = NULL;

    ErrCode = STPIO_Open("PIO3", &PIO_OpenParams, &PIO_Handle);
    if (ErrCode != ST_NO_ERROR)
    {
        STTBX_Print(("Open PIO driver (port 3) failed: "));
        DisplayErrorNew(ErrCode);
        return(ErrCode);
    }

    /* switch off clkgen workaround that used ATA data lines */
    STPIO_Set(PIO_Handle, PIO_BIT_5);
    STPIO_Close(PIO_Handle);

    PIO_TermParams.ForceTerminate = FALSE;
    ErrCode = STPIO_Term("PIO3", &PIO_TermParams);
    if (ErrCode != ST_NO_ERROR)
    {
        STTBX_Print(("Term PIO driver (port 3) failed: "));
        DisplayErrorNew(ErrCode);
    }    

    return ErrCode;
}
#endif

static void DoTheTests(void)
{
    ST_ErrorCode_t Error;
#if defined(ST_5518) || defined(ST_5508)
    STPIO_InitParams_t  PIO_Init;
    STPIO_OpenParams_t  PIO_Open;
    STPIO_Handle_t  PIO_Handle;
#endif
#if defined(ATAPI_GPDMA)
    STGPDMA_InitParams_t GPDMA_Init;
    STGPDMA_TermParams_t GPDMA_Term;
#endif
    ATAPI_TestEntry_t *Test_p;
    U32 Section = 1;
    ATAPI_TestParams_t TestParams;
    ATAPI_TestResult_t Total = TEST_RESULT_ZERO, Result;

    /* Init the EVT driver */
    EVTInitParams.EventMaxNum= 10;
    EVTInitParams.ConnectMaxNum=4;
    EVTInitParams.SubscrMaxNum=2;
    EVTInitParams.MemoryPartition=TEST_PARTITION_1;

    EVTTermParams.ForceTerminate=FALSE; 
    
    Error= STEVT_Init(EVTDevName,&EVTInitParams);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Event Device initialization failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }

    Error= STEVT_Open(EVTDevName,&EVTOpenParams,&EVTHandle);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Event Device open failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }
    
    Error= STEVT_SubscribeDeviceEvent( EVTHandle, AtapiDevName, 
                                STATAPI_HARD_RESET_EVT, &SubsParams);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Subscribe STATAPI_HARD_RESET_EVT failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }

    Error= STEVT_SubscribeDeviceEvent( EVTHandle, AtapiDevName, 
                                STATAPI_SOFT_RESET_EVT, &SubsParams);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Subscribe STATAPI_SOFT_RESET_EVT failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }
    Error= STEVT_SubscribeDeviceEvent( EVTHandle, AtapiDevName, 
                                STATAPI_CMD_COMPLETE_EVT, &SubsParams);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Subscribe STATAPI_CMD_COMPLETE_EVT failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }
    Error= STEVT_SubscribeDeviceEvent( EVTHandle, AtapiDevName, 
                                STATAPI_PKT_COMPLETE_EVT, &SubsParams);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Subscribe STATAPI_PKT_COMPLETE_EVT failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }
    
    semaphore_init_fifo_timeout(&StepSemaphore,0);

#if defined(ATAPI_GPDMA)
    /* Initialise and open GPDMA */
    GPDMA_Init.DriverPartition = TINY_PARTITION_1;
    GPDMA_Init.DeviceType = STGPDMA_DEVICE_GPDMAC;
    GPDMA_Init.BaseAddress = (U32 *)GPDMA_BASE_ADDRESS;
    GPDMA_Init.InterruptNumber = GPDMA_BASE_INTERRUPT + 4;
    GPDMA_Init.InterruptLevel = 5;
    GPDMA_Init.ChannelNumber = 4;
    GPDMA_Init.FreeListSize = 2;
    GPDMA_Init.MaxHandles = 1;
    GPDMA_Init.MaxTransfers = 2;
    strcpy(GPDMA_Init.EVTDeviceName, EVTDevName);
    /* Initialize GPDMA channel 0 */

    Error = STGPDMA_Init(GPDMADevName, &GPDMA_Init);
    if (Error != ST_NO_ERROR)
    {
        STTBX_Print(("Initializing STGPDMA... failed: "));
        DisplayErrorNew(Error);
        return;
    }
#endif
    
#if defined(ST_5512)
       /*---- Let's load the FPGA code ---*/    
    Error=STFPGA_Init();
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("FPGA Init failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }

    /* Now change the EMI configuration (bank 3) to set PIO mode 4 */
#if defined(STATAPI_OLD_FPGA)
    *(volatile U32*) 0x2020 = 0x16D1;
    *(volatile U32*) 0x2024 = 0x50F0;
    *(volatile U32*) 0x2028 = 0x400F;
    *(volatile U32*) 0x202C = 0x0002;
#else
    /* "New" (supported) FPGA */
    *(volatile U32*) 0x00002030 = 0x1791; 
    *(volatile U32*) 0x00002034 = 0x50f0; 
    *(volatile U32*) 0x00002038 = 0x50f0; 
    *(volatile U32*) 0x0000203C = 0x0002;
#endif

#elif defined(ST_5518) | defined(ST_5508)              
    /* Set FEI_ATAPI_CFG register */
    STSYS_WriteRegDev8((void*)0x200387A0, 0x01);
    /* Configure PIO0-1 and PIO0-2  as  output */

    PIO_Init.BaseAddress=(U32*)PIO_0_BASE_ADDRESS;
    PIO_Init.InterruptNumber=PIO_0_INTERRUPT;
    PIO_Init.InterruptLevel=PIO_0_INTERRUPT_LEVEL;
    PIO_Init.DriverPartition=TEST_PARTITION_1;
    Error=STPIO_Init(PIODevName,&PIO_Init);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Init PIO driver (port 0) failed  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }

    PIO_Open.ReservedBits=(PIO_BIT_1| PIO_BIT_2);
    PIO_Open.BitConfigure[1]=STPIO_BIT_OUTPUT;
    PIO_Open.BitConfigure[2]=STPIO_BIT_OUTPUT;
    PIO_Open.IntHandler=NULL;
    Error=STPIO_Open(PIODevName,&PIO_Open,&PIO_Handle);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("Open PIO driver failed  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }
      
#endif

#if defined(MEDIAREF)
    ATAPI_UndoClkGen();
#endif    
        
   
    STTBX_Print(("*******************************************************  \n")); 
    STTBX_Print(("*******************************************************  \n")); 
    STTBX_Print(("                 ATAPI TEST HARNESS  \n")); 
    STTBX_Print(("Test Harness Revision: %s\n", Revision)); 
    STTBX_Print(("Driver Revision: %s\n", STATAPI_GetRevision() )); 
    
    STTBX_Print(("*******************************************************  \n")); 
    STTBX_Print(("*******************************************************  \n")); 
    STTBX_Print(("\n")); 
    
                                                          
    Test_p = ATAPITestTable;
    
    while (Test_p->TestFunction != NULL)
    {
        TestParams.DevAddress=STATAPI_DEVICE_0;
        while (Test_p->RepeatCount > 0)
        {
            STTBX_Print(("**************************************************\n"));
            STTBX_Print(("SECTION %d - %s\n", Section,
                              Test_p->TestInfo));
            STTBX_Print(("**************************************************\n"));

            /* Set up parameters for test function */
            TestParams.Ref = Section;

            /* Call test */
            Result = Test_p->TestFunction(&TestParams);
            
            /* Update counters */
            Total.NumberPassed += Result.NumberPassed;
            Total.NumberFailed += Result.NumberFailed;
            Test_p->RepeatCount--;
            TestParams.DevAddress=STATAPI_DEVICE_1;
        }

        Test_p++;
        Section++;
    }

    /* Output running analysis */
    STTBX_Print(("**************************************************\n"));
    STTBX_Print(("PASSED: %d\n", Total.NumberPassed));
    STTBX_Print(("FAILED: %d\n", Total.NumberFailed));
    STTBX_Print(("**************************************************\n"));

    Error= STEVT_Close(EVTHandle);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("STEVT Close failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }

#if defined(ATAPI_GPDMA)
    GPDMA_Term.ForceTerminate = TRUE;    
    Error = STGPDMA_Term(GPDMADevName, &GPDMA_Term);
    if (Error != ST_NO_ERROR)
    {
        STTBX_Print(("STGPDMA term failed: "));
        DisplayErrorNew(Error);
    }
#endif
    
    Error= STEVT_Term(EVTDevName,&EVTTermParams);
    if(Error!= ST_NO_ERROR)
    {
        STTBX_Print(("STEVT Close failed:  "));
        DisplayError(Error);
        STTBX_Print(("\n"));
    }
} 

#ifdef ATAPI_MEMTEST

void test_overhead(void *dummy) { }

void test_init(void *dummy) 
{
    ST_ErrorCode_t error;

    /* Parameters, buffers, and structures */
    STATAPI_InitParams_t    InitParams;

    InitParams.DeviceType = STATAPI_EMI_PIO4;
    InitParams.DriverPartition = TEST_PARTITION_1;