usbsrc.c

ct952 source code use for Digital Frame Photo

#include "winav.h"
#include "ctkav.h"
#include "usbsrc.h"
#include "srcfilter.h"
#include "comutl.h"
#include "infofilter.h"
#include "cc.h"
#include "parser.h"
#include "initial.h"
#include "utl.h"
#include "media.h"
// wyc2.71-portusb,
#if (USB_SYSTEM == USB2_0_JUNGO)
#include "usbwrap.h"
#elif (USB_SYSTEM == USB1_1_CT909R)
#include "usb.h"
#endif //

#ifdef CTK_CARDREADER
#include "card.h"
#endif

#define USBSRC_DEBUG_INFO 
// wyc1.01-909, new module for USB source.
#ifdef SUPPORT_USB_SOURCE
// ============================= Definition ============================= //
#include "debug.h"
#undef PRINTF
#undef printf
#define PRINTF(x, y...)     DBG_Printf(DBG_THREAD_USB, DBG_INFO_MM_INFOFTR, x, ## y)
#define printf(x, y...)     DBG_Printf(DBG_THREAD_USB, DBG_INFO_PRINTF, x, ## y)

    // wyc2.16-909S
    void    PRINTF_USBSRC(char *fmt, ...);
    void    printf_USBSRC(char *fmt, ...);

    // #define PRINTF PRINTF_USBSRC
    // #define printf printf_USBSRC

#define USB_MONITOR_WORKING     1
#define USB_MONITOR_WORK_END    0
    // wyc1.02-909, move define to header file.
    // the reading cluster one cmd issued. Default one cluster is 4
    // sectors.
    // Seemed USB can read max. 4x2048(PARSEC is 2048 bytes) bytes per
    // CMD, current set to 2x2048 bytes.
#define USBSRC_WRITE_PARSEC_ONE_CMD     2

#define FAT12_CLUSTER_END \
    ((_dwUSBSRCWriteCluster == FAT12_TABLE_CLUS_END) && (__bFileSystem == FILE_SYSTEM_FAT12) ? TRUE : FALSE)
#define FAT16_CLUSTER_END \
    ((_dwUSBSRCWriteCluster == FAT16_TABLE_CLUS_END) && (__bFileSystem == FILE_SYSTEM_FAT16) ? TRUE : FALSE)
#define FAT32_CLUSTER_END \
    ((_dwUSBSRCWriteCluster == FAT32_TABLE_CLUS_END) && (__bFileSystem == FILE_SYSTEM_FAT32) ? TRUE : FALSE)
#define FAT_CLUSTER_END \
    (FAT12_CLUSTER_END | FAT16_CLUSTER_END | FAT32_CLUSTER_END) ? TRUE : FALSE
// wyc2.78-909P, add new commands into the list
#define USBSRC_SUPPORT_CMD \
    USBSRC_CMD_CHECK_DEVICE | USBSRC_CMD_RECOGNIZE_MEDIA | USBSRC_CMD_READDATA | USBSRC_CMD_DUMPDATA | \
    USBSRC_CMD_STOP | USBSRC_CMD_READDATA_1 | USBSRC_CMD_SWITCH_USB_STACK | USBSRC_CMD_DEVICE_MODE_CHK_CARD | USBSRC_CMD_EXIT_USB_STACK

    // ============================= Variables =============================
    DWORD   __dwUSBSRCPhyOffset;
    BYTE    __bUSBSecPerPar;
    DWORD   _dwUSBSRCDumpSecNO;
    DWORD   _dwUSBSRCDumpNum;
    DWORD   *_dwUSBSRCDumpBuff;

    volatile DWORD   __dwUSBSRCStreamId; // record the processing stream
    // ============ variables declaration ============ //
    FLAG_T  _fUSBSRCCmdd;
    FLAG_T  _fUSBSRCCmddRunning;
    FLAG_T  _fUSBSRCCmddStatus;
    BYTE    _bUSBSRCState; 
    BYTE    _bUSBSRCReadStatus;
    WORD    __wUSBSRCCluSize;

    DWORD   _dwUSBSRCWriteCluster1[MAX_STREAM_COUNT];
    DWORD   _bUSBSRCWriteClusEnd1[MAX_STREAM_COUNT];

    // elmer2.78
    BYTE __bUSBSRCReadError[MAX_STREAM_COUNT];

    BYTE    _bSource = 0;
    // wyc2.78-909P, new vairables to issue commands and record the usb otg mode.
    volatile BYTE    _bUSBOTGCmdMode = USB_MODE_NONE;
    volatile DWORD   __dwUSBOTGMode = USB_MODE_NONE;
    BYTE    _bUSBSRCInitUSBStack = FALSE;
#ifdef SUPPORT_USB_HOST_DEVICE
#ifdef CTK_CARDREADER
    BYTE    __bUSBSRCCardType = CARD_CONTROLLER_NONE;
    BYTE    __bUSBSRCCardReady = FALSE;
    BYTE    __bCardDetectStage = 0;
    DWORD   __dwCardInitChkTime;
#endif //
#endif //

    BYTE    __bTestLun = 0xFF;
    // wyc2.77-909p, the usb performance testing code.
#ifdef TEST_DEVICE_PERFORMANCE
    #define USB_TEST_TIMES          (2)
    #define USB_TEST_START_SEC      (500)
    #define USB_TEST_LOOP           (1000)
    #define USB_CHUNK_SIZE          (32)
    #define USB_TEST_DUMP_IN_BUFF   (0x40300000L)
    DWORD   __dwTestUSBSpeed = FALSE;
    DWORD   __dwTestUSBTime[USB_TEST_TIMES];
    DWORD   __dwTestUSBCnt = 0;
#endif //
    // ============================= Function Prototype =============================
    void    _USBSRC_InitialVars(void);
// wyc2.71-portusb,
#if (USB_SYSTEM == USB2_0_CHIPIDEA)
#define  USB_DEVICE_IDLE                   (0)
#define  USB_DEVICE_ATTACHED               (1)
#define  USB_DEVICE_CONFIGURED             (2)
#define  USB_DEVICE_SET_INTERFACE_STARTED  (3)
#define  USB_DEVICE_INTERFACED             (4)
#define  USB_DEVICE_DETACHED               (5)
#define  USB_DEVICE_OTHER                  (6)
void USB_Init(void);
void USB_CheckState(void);
BYTE USB_MSC_Read(DWORD dwStartSector, DWORD dwNumOfSector, DWORD* dwBuffAddr);
DWORD USB_GetUSBState(void);

#endif //

void PRINTF_USBSRC(char *fmt, ...)
{
    DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_MM_INFOFTR, fmt);
}

void printf_USBSRC(char *fmt, ...)
{
    DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, fmt);
}

void USBSRC_ConfigSource(BYTE bSRC)
{
    _bSource = bSRC;
}

BYTE USBSRC_TriggerCmdAPI(BYTE flag, DWORD dwCmd)
{
    switch (flag)
    {
        case SRCFILTER_FLAG_CMD:
            return USBSRC_TriggerCmd(&_fUSBSRCCmdd, dwCmd);
        case SRCFILTER_FLAG_STATUS:
            return USBSRC_TriggerCmd(&_fUSBSRCCmddStatus, dwCmd);
        case SRCFILTER_FLAG_RUNNING:
            return USBSRC_TriggerCmd(&_fUSBSRCCmddRunning, dwCmd);
        default:
            return FALSE;
    }
}

BYTE USBSRC_PeekCmdAPI(BYTE flag, DWORD dwCmd)
{
    switch (flag)
    {
        case SRCFILTER_FLAG_CMD:
            return USBSRC_PeekCmd(&_fUSBSRCCmdd, dwCmd);
        case SRCFILTER_FLAG_STATUS:
            return USBSRC_PeekCmd(&_fUSBSRCCmddStatus, dwCmd);
        case SRCFILTER_FLAG_RUNNING:
            return USBSRC_PeekCmd(&_fUSBSRCCmddRunning, dwCmd);
        default:
            return FALSE;
    }
}

void USBSRC_ClearCmdAPI(BYTE flag, DWORD dwCmd)
{
    switch (flag)
    {
        case SRCFILTER_FLAG_CMD:
            USBSRC_ClearCmd(&_fUSBSRCCmdd, dwCmd);
            break;
        case SRCFILTER_FLAG_STATUS:
            USBSRC_ClearCmd(&_fUSBSRCCmddStatus, dwCmd);
            break;
        case SRCFILTER_FLAG_RUNNING:
            USBSRC_ClearCmd(&_fUSBSRCCmddRunning, dwCmd);
            break;
        default:
            break;
    }
}

BYTE USBSRC_TriggerCmd(FLAG_T *flag, DWORD dwCmd)
{
    if ((OS_PeekFlag(&__fThreadInit) & INIT_SRC_THREAD_USB_DONE))
    {
        if (flag == &_fUSBSRCCmdd)
        {
            // if RECOGNIZE_MEDIA command is processing, then CHECK_DEVICE command cannot be triggered.
            if (USBSRC_PeekCmd(&_fUSBSRCCmddRunning, USBSRC_CMD_RECOGNIZE_MEDIA) && (dwCmd == USBSRC_CMD_CHECK_DEVICE))
            {
                //printf("Trigger USBSRC Command CHECK_DEVICE failed\n");

                return FALSE;
            }

            // if command is processing, then the same command cannot be triggered.
            if (!USBSRC_PeekCmd(&_fUSBSRCCmddRunning, dwCmd))
            {
                OS_SetFlag(&_fUSBSRCCmdd, dwCmd);
                OS_SetFlag(&_fUSBSRCCmddRunning, dwCmd);

                //printf("Trigger USBSRC Command: %lx\n", dwCmd);

                return TRUE;
            }
        }
        else
        {
            OS_SetFlag(flag, dwCmd);

            return TRUE;
        }
    }
    
    return FALSE;
}

void USBSRC_ClearCmd(FLAG_T *flag, DWORD dwCmd)
{
    OS_ClearFlag(flag, ~dwCmd);
}


void USBSRC_WaitCmd(FLAG_T *flag, DWORD dwCmd)
{
    OS_WaitFlag(flag, dwCmd, FLAG_WAITMODE_AND);
}

BYTE USBSRC_PeekCmd(FLAG_T *flag, DWORD dwCmd)
{
    if (OS_PeekFlag(flag) & dwCmd)
        return TRUE;

    return FALSE;
}
// ***********************************************************************
// Function : USBSRC_Thread
// Description : The entry of USB Source thread.
// Arguments : index: the thread ID
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
void USBSRC_Thread(DWORD index)
{
    DWORD wUSBSRCWaitFlag;

    // initialize relative flags to signal the running of USBSRC
    OS_SetFlag(&__fThreadInit, INIT_SRC_THREAD_USB_DONE);

    // first initialization
    _USBSRC_InitialVars();
    USBSRC_ClearUSBSRCState();

    // Because we must only initialize these flags once, so we do it here.
    OS_InitFlag(&_fUSBSRCCmdd);
    OS_InitFlag(&_fUSBSRCCmddRunning);
    OS_InitFlag(&_fUSBSRCCmddStatus);
    // removed, move to cc.c
/*
#ifdef SUPPORT_POWERON_MENU
    // wyc2.71-portusb,
    // wyc2.75-909P, don't call it here and move to media.c.
    // when used in CT95x, we initialize USB2_0 here
    USB_HCInit(0,0x40604000,0xE6000);
    //USB_HCInit(0,0);
#endif //
*/
    //wyc2.78-909P, init the usb stack when usbsrc init OK to save time when later code will use usb function.
    if (_bUSBSRCInitUSBStack == FALSE)
#ifdef SUPPORT_USB_HOST_DEVICE
    {
        CARD_InitSystem();
        OS_DelayTime(COUNT_300_MSEC);
        CARD_InitCard();
        __bUSBSRCCardType = CARD_CONTROLLER_SD;
        __bUSBSRCCardReady = TRUE;
        USB_ConfigDeviceMemPool(DS_USB_DEVICE_SCSI_POOL_ST, (DS_USB_DEVICE_SCSI_POOL_END - DS_USB_DEVICE_SCSI_POOL_ST));
        USB_HCInit(USB_MODE_DEVICE, 0,DS_USB_MEMPOOL_ST_DEVICE,(DS_USB_MEMPOOL_END_DEVICE-DS_USB_MEMPOOL_ST_DEVICE));
        // wyc2.78-909P
        //OS_DelayTime(COUNT_200_MSEC);
        //USB_HCExit();
        //__dwUSBOTGMode = USB_MODE_EXIT_MODE;
        __dwUSBOTGMode = USB_MODE_DEVICE;
        _bUSBSRCInitUSBStack = TRUE;
    }
#else
    {   
        USB_HCInit(USB_MODE_HOST, 0,DS_USB_MEMPOOL_ST_HOST,(DS_USB_MEMPOOL_END_HOST-DS_USB_MEMPOOL_ST_HOST));
        __dwUSBOTGMode = USB_MODE_HOST;
        _bUSBSRCInitUSBStack = TRUE;
    }
#endif //
    while (1)
    {
        wUSBSRCWaitFlag = OS_WaitFlag(&_fUSBSRCCmdd, USBSRC_SUPPORT_CMD, FLAG_WAITMODE_OR);

        // [Command]: USBSRC_CMD_RECOGNIZE_MEDIA
        if (wUSBSRCWaitFlag & USBSRC_CMD_RECOGNIZE_MEDIA)
        {
            //printf("USBSRC: Processing command (Recognize Media)\n");

            _bUSBSRCState = USBSRC_CheckUSBStatus(__SF_SourceGBL[__dwSFStreamID].bSourceIndex);

            // clear the command when finishing the corresponding processing operations, 
            // and trigger the status command to notify CC
            USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_RECOGNIZE_MEDIA);
            USBSRC_TriggerCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_RECOGNIZE_MEDIA);
            OS_YieldThread();
        }

        // [Command]: USBSRC_CMD_CHECK_DEVICE
        if (wUSBSRCWaitFlag & USBSRC_CMD_CHECK_DEVICE)
        {
            //printf("USBSRC: Processing command (Check Device)\n");
#ifdef TEST_DEVICE_PERFORMANCE
            {
                // wyc2.77-909p, the usb performance testing code.
                DWORD i;
                if (__dwTestUSBSpeed == TRUE)
                {
                    printf("\n======== Start the testing ========");
                    __dwTestUSBSpeed = OS_GetSysTimer();
                    for (i=USB_TEST_START_SEC; i<USB_TEST_START_SEC+USB_TEST_LOOP; i++ )
                    {
                        USB_ReadData(i, USB_CHUNK_SIZE, USB_TEST_DUMP_IN_BUFF);
                    }
                    __dwTestUSBTime[__dwTestUSBCnt]=OS_GetSysTimer()-__dwTestUSBSpeed;
                    __dwTestUSBSpeed = TRUE;
                    printf("\n======== Complete the testing ========");
                    __dwTestUSBCnt++;
                    if (__dwTestUSBCnt >= USB_TEST_TIMES)
                    {
                        __dwTestUSBSpeed = 0;
                        for (i=0; i<USB_TEST_TIMES; i++)
                        {
                            __dwTestUSBSpeed += (__dwTestUSBTime[i]*2);
                        }
                        __dwTestUSBSpeed /= USB_TEST_TIMES;