atapitest.c

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

    String[j] = 0;
}
#endif

int main (int argc, char *argv[])
{
    ST_ErrorCode_t        Code;
    ST_DeviceName_t       Name = "DEV0";
    STBOOT_InitParams_t   InitParams;
    STBOOT_TermParams_t   TermParams;
    /* 5514 UM - 3meg avmem, 0.5meg n/c, up to 4.5meg rest */
#if defined(ST_5514) && defined(UNIFIED_MEMORY)
    STBOOT_DCache_Area_t  Cache[] = { {(U32*)0xC0380000, (U32*)0xc03fffff},
                                      { NULL, NULL} };
#elif defined(ST_5514)
    /* 5514 emi - 2meg n/c */
    STBOOT_DCache_Area_t  Cache[] = { {(U32*)0x40200000, (U32*)0x5FFFFFFF},
                                      { NULL, NULL} };
#else
    /* anything else, 0.5meg n/c */
    STBOOT_DCache_Area_t  Cache[] = { {(U32*)0x40080000, (U32*)0x4FFFFFFF},
                                      { NULL, NULL} };
#endif

    STTBX_InitParams_t    TBX_InitParams;
#if defined(ST_5514)
    ST_ClockInfo_t      ClockInfo;
#endif

    partition_init_heap (&the_internal_partition, internal_block,
                         sizeof(internal_block));
    partition_init_heap (&the_system_partition,   system_block,
                         sizeof(system_block));
    partition_init_heap (&the_tiny_partition,   tiny_block,
                         sizeof(tiny_block));

#if defined(HDDI_5514_CUT_2)
    printf("Programming ticktimer\n");
    {
        U32 n;
        volatile int *ticktimer = (volatile int*)0x20013208;
        *ticktimer = 0x7f0f;
        for (n=0;n<1000;n++) { }
        *ticktimer = 0x7f07;
        for (n=0;n<1000;n++) { }
        *ticktimer = 0x7f03;
        for (n=0;n<1000;n++) { }
        *ticktimer = 0x7f01;
        for (n=0;n<1000;n++) { }
    }
    printf("Done\n");
#endif
    
    InitParams.ICacheEnabled             = TRUE;
    InitParams.BackendType.DeviceType    = STBOOT_DEVICE_UNKNOWN;
    InitParams.BackendType.MajorRevision = STBOOT_REVISION_UNKNOWN;
    InitParams.BackendType.MinorRevision = STBOOT_REVISION_UNKNOWN;
    InitParams.CacheBaseAddress          = (U32*) CACHE_BASE_ADDRESS;
    InitParams.DCacheMap                 = Cache;
    InitParams.MemorySize                = SDRAM_SIZE;
    InitParams.SDRAMFrequency            = SDRAM_FREQUENCY;
    
    if ((Code = STBOOT_Init (Name, &InitParams)) != ST_NO_ERROR)
        printf ("ERROR: STBOOT_Init returned code %d\n", Code);
    else
    {
        TBX_InitParams.CPUPartition_p    = TEST_PARTITION_1;;
        TBX_InitParams.SupportedDevices    = STTBX_DEVICE_DCU;
        TBX_InitParams.DefaultOutputDevice = STTBX_DEVICE_DCU;
        TBX_InitParams.DefaultInputDevice  = STTBX_DEVICE_DCU;
        if ((Code = STTBX_Init( "TBX0", &TBX_InitParams )) != ST_NO_ERROR )
        {
            printf ("Error: STTBX_Init = 0x%08X\n", Code );
        }
        else
        {
            ClocksPerSec = ST_GetClocksPerSecond();
            ClockSpeed   = ST_GetClockSpeed();

#if defined(ST_5514)            
            ST_GetClockInfo(&ClockInfo);
            ClockFrequency = ClockInfo.HDDI;
            STTBX_Print(("ClockFrequency: %u\n", ClockFrequency));
            
            /* Need this to Reset HDDI */
            if (DoCfg() != ST_NO_ERROR)
            {
                return 1;
            }
#endif

            DoTheTests();

        }
        STBOOT_Term (Name, &TermParams);
    }
    return 0;
}

#if defined(ST_5514)
static ST_ErrorCode_t DoCfg(void)
{
    STCFG_InitParams_t  CfgInitParams;
    STCFG_TermParams_t  CfgTermParams;
    STCFG_Handle_t      CfgHandle;
    ST_DeviceName_t     Name = "DEV0";
    ST_ErrorCode_t      error = ST_NO_ERROR;
                
    CfgInitParams.DeviceType = STCFG_DEVICE_5514;
    CfgInitParams.BaseAddress_p = (U32 *)ST5514_CFG_BASE_ADDRESS;
    CfgInitParams.Partition_p = TEST_PARTITION_1;
    error = STCFG_Init(Name, &CfgInitParams);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("Error initialising STCFG\n"));
        return error;
    }
            
    error = STCFG_Open(Name, NULL, &CfgHandle);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("Error opening STCFG\n"));
        return error;
    }
            
    error = STCFG_CallCmd(CfgHandle, STCFG_CMD_HDDI_ENABLE, STCFG_HDDI_RESET);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("Error resetting HDDI\n"));
        return error;
    }
    /* Wait 1ms */
    task_delay(ClocksPerSec / 1000);
    error = STCFG_CallCmd(CfgHandle, STCFG_CMD_HDDI_DISABLE, STCFG_HDDI_RESET);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("Error resetting HDDI\n"));
        return error;
    }

    STCFG_Close(CfgHandle);

    CfgTermParams.ForceTerminate = TRUE;
    error = STCFG_Term(Name, &CfgTermParams);
    if (error != ST_NO_ERROR)
    {
        STTBX_Print(("Error terminating STCFG driver\n"));
        return error;
    }
    
    return error;
}
#endif

/*---------------------------------------------------------------------------
   Other utility function for displaying error codes
 ---------------------------------------------------------------------------*/
static void DisplayError( ST_ErrorCode_t ErrorCode )
{
    switch( ErrorCode )
    {
        case ST_NO_ERROR:
          STTBX_Print(("ST_NO_ERROR "));
          break;
        case ST_ERROR_BAD_PARAMETER:
          STTBX_Print(("ST_ERROR_BAD_PARAMETER "));
          break;
        case ST_ERROR_ALREADY_INITIALIZED:
            STTBX_Print(("ST_ERROR_ALREADY_INITIALIZED "));
            break;
        case ST_ERROR_UNKNOWN_DEVICE:
            STTBX_Print(("ST_ERROR_UNKNOWN_DEVICE "));
            break;
        case ST_ERROR_INVALID_HANDLE:
            STTBX_Print(("ST_ERROR_INVALID_HANDLE "));
            break;
        case ST_ERROR_OPEN_HANDLE:
            STTBX_Print(("ST_ERROR_OPEN_HANDLE "));
            break;
        case ST_ERROR_FEATURE_NOT_SUPPORTED:
            STTBX_Print(("ST_ERROR_FEATURE_NOT_SUPPORTED "));
            break;
        case ST_ERROR_NO_MEMORY:
            STTBX_Print(("ST_ERROR_NO_MEMORY "));
            break;
        case ST_ERROR_NO_FREE_HANDLES:
            STTBX_Print(("ST_ERROR_NO_FREE_HANDLES "));
            break;
        case ST_ERROR_TIMEOUT:
            STTBX_Print(("ST_ERROR_TIMEOUT "));
            break;
        case ST_ERROR_DEVICE_BUSY:
            STTBX_Print(("ST_ERROR_DEVICE_BUSY "));
            break;
        case STATAPI_ERROR_CMD_ABORT:
          STTBX_Print(("STATAPI_ERROR_CMD_ABORT "));
          break;
        case STATAPI_ERROR_CMD_ERROR:
          STTBX_Print(("STATAPI_ERROR_CMD_ERROR "));
          break;
        case STATAPI_ERROR_DEVICE_NOT_PRESENT:
          STTBX_Print(("STATAPI_ERROR_DEVICE_NOT_PRESENT "));
          break;
        case STATAPI_ERROR_PKT_CHECK:
          STTBX_Print(("STATAPI_ERROR_PKT_CHECK "));
          break;
        case STATAPI_ERROR_PKT_NOT_SUPPORTED:
          STTBX_Print(("STATAPI_ERROR_PKT_NOT_SUPPORTED "));
          break;
        case STATAPI_ERROR_USER_ABORT:
          STTBX_Print(("STATAPI_ERROR_USER_ABORT "));
          break;
        case STATAPI_ERROR_TERMINATE_BAT:
          STTBX_Print(("STATAPI_ERROR_TERMINATE_BAT "));
          break;
        case STATAPI_ERROR_DIAGNOSTICS_FAIL:
          STTBX_Print(("STATAPI_ERROR_DIAGNOSTICS_FAIL "));
          break; 
        case STATAPI_ERROR_MODE_NOT_SET:
          STTBX_Print(("STATAPI_ERROR_MODE_NOT_SET "));
          break;     
        case STATAPI_ERROR_PROTOCOL_NOT_SUPPORTED:
          STTBX_Print(("STATAPI_ERROR_PROTOCOL_NOT_SUPPORTED "));
          break;
        case STATAPI_ERROR_CRC_ERROR:
          STTBX_Print(("STATAPI_ERROR_CRC_ERROR "));
          break;
#if defined(ATAPI_GPDMA)
        case STGPDMA_ERROR_BUS:
            STTBX_Print(("STGPDMA_ERROR_BUS "));
            break;
        case STGPDMA_ERROR_DATA_ALIGNMENT:
            STTBX_Print(("STGPDMA_ERROR_DATA_ALIGNMENT "));
            break;
        case STGPDMA_ERROR_DATA_UNIT_SIZE:
            STTBX_Print(("STGPDMA_ERROR_DATA_UNIT_SIZE "));
            break;
        case STGPDMA_ERROR_INVALID_CHANNEL:
            STTBX_Print(("STGPDMA_ERROR_INVALID_CHANNEL "));
            break;
        case STGPDMA_ERROR_INVALID_EVENT:
            STTBX_Print(("STGPDMA_ERROR_INVALID_EVENT "));
            break;
        case STGPDMA_ERROR_INVALID_PROTOCOL:
            STTBX_Print(("STGPDMA_ERROR_INVALID_PROTOCOL "));
            break;
        case STGPDMA_ERROR_INVALID_SUBCHANNEL:
            STTBX_Print(("STGPDMA_ERROR_INVALID_SUBCHANNEL "));
            break;
        case STGPDMA_ERROR_INVALID_TRANSFERID:
            STTBX_Print(("STGPDMA_ERROR_INVALID_TRANSFERID "));
            break;
        case STGPDMA_ERROR_QUEUE_FULL:
            STTBX_Print(("STGPDMA_ERROR_QUEUE_FULL "));
            break;
        case STGPDMA_ERROR_SUBCHANNEL_BUSY:
            STTBX_Print(("STGPDMA_ERROR_SUBCHANNEL_BUSY "));
            break;
        case STGPDMA_ERROR_TIMING_MODEL:
            STTBX_Print(("STGPDMA_ERROR_TIMING_MODEL "));
            break;
        case STGPDMA_ERROR_TRANSFER_ABORTED:
            STTBX_Print(("STGPDMA_ERROR_TRANSFER_ABORTED "));
            break;
        case STGPDMA_ERROR_TRANSFER_TYPE:
            STTBX_Print(("STGPDMA_ERROR_TRANSFER_TYPE "));
            break;
        case STGPDMA_ERROR_EVENT_REGISTER:
            STTBX_Print(("STGPDMA_ERROR_EVENT_REGISTER "));
            break;
        case STGPDMA_ERROR_EVENT_UNREGISTER:
            STTBX_Print(("STGPDMA_ERROR_EVENT_UNREGISTER "));
            break;
#endif
        default:
          STTBX_Print(("unknown error code %u ", ErrorCode ));
          break;
      }
}

static void DisplayErrorNew(ST_ErrorCode_t error)
{
    DisplayError(error);
    STTBX_Print(("\n"));
}

/*---------------------------------------------------------------------------*/
/* Other utility functions for checking various things.                      */
/*---------------------------------------------------------------------------*/

static BOOL CompareData (const U8 *b1, const U8 *b2, U32 size)
{
    if (memcmp (b1, b2, size) == 0)
    {
        STTBX_Print(("Data read matches data written!\n"));
        return TRUE;
    }
    else
    {
        STTBX_Print(("ERROR: data read does NOT match data written\n"));
        {
            U32 i, x, y;
            
            /* Find out first different character */
            for (i = 0; i < size; i++)
                if (b1[i] != b2[i])
                    break;
            
            /* then go back to nearest 16-byte boundary */
            i = i / 16;
            for (x = i; x < (i + 4); x++)
            {
                y = 0;
                STTBX_Print(("%04x   ", (x * 16) + y));
                for (y = 0; y < 16; y++)
                {
                    STTBX_Print(("%02x ", b1[(x * 16) + y]));
                }
                STTBX_Print(("\n"));
            }
            STTBX_Print(("\n\n"));
            for (x = i; x < (i + 4); x++)
            {
                y = 0;
                STTBX_Print(("%04x   ", (x * 16) + y));
                for (y = 0; y < 16; y++)
                {
                    STTBX_Print(("%02x ", b2[(x * 16) + y]));
                }
                STTBX_Print(("\n"));
            }
        }
        return FALSE;
    }
}


static BOOL CheckCode (ST_ErrorCode_t actualCode, ST_ErrorCode_t expectedCode)
{
    if (actualCode == expectedCode)
    {
        STTBX_Print((" Got expected code:  "));
        DisplayError( expectedCode );
        STTBX_Print(( "\n" ));
        return FALSE;
    }
    else
    {
        STTBX_Print(("ERROR: got code "));
        DisplayError( actualCode );
        STTBX_Print(("expected code "));
        DisplayError( expectedCode );
        STTBX_Print(( "\n" ));
        return TRUE;
    }
}


static BOOL CheckCodeOk (ST_ErrorCode_t actualCode)
{
    return CheckCode (actualCode, ST_NO_ERROR);
}

#if defined(ST_5514)
static ST_ErrorCode_t SetTransferModeDma(STATAPI_Handle_t Handle, 
                                         STATAPI_DmaMode_t DmaMode)
{
    STATAPI_Cmd_t Cmd;
    STATAPI_CmdStatus_t CmdStatus;
    ST_ErrorCode_t Error;
    
    Cmd.Features = 3;
    Cmd.UseLBA = FALSE;
    Cmd.Sector = 0;
    Cmd.CylinderLow =  0;
    Cmd.CylinderHigh = 0;
    Cmd.Head = 0;
    Cmd.CmdCode = STATAPI_CMD_SET_FEATURES;

    if (DmaMode <= STATAPI_DMA_MWDMA_MODE_2)
    {
        IsUDMA = FALSE;
        Cmd.SectorCount = 0x20 + (DmaMode - STATAPI_DMA_MWDMA_MODE_2);
    }
    else
    {
        IsUDMA = TRUE;
        Cmd.SectorCount = 0x40 + (DmaMode - STATAPI_DMA_UDMA_MODE_0);
    }

    STTBX_Print(("Setting transfer mode\n"));