usbsrc.c

ct952 source code use for Digital Frame Photo

                        __dwTestUSBCnt = ((USB_TEST_LOOP*USB_CHUNK_SIZE*512*8)/__dwTestUSBSpeed);
                        printf("\nAverage bitrate: %lx K - bps",__dwTestUSBCnt);
                        __dwTestUSBCnt = 0;
                        __dwTestUSBSpeed = FALSE;
                        
                    }
                }
            }
#endif //

            if (USBSRC_CheckConnect())
            {
                switch (_bUSBSRCState)
                {
                    case USBSRC_STATE_NO_MEDIA:
                        _bUSBSRCState = USBSRC_STATE_CONN_MEDIA;
                        break;
                    case USBSRC_STATE_NO_CARD:
#if (USB_SYSTEM != USB_NONE)
                        if (USB_CheckCard(__bTestLun))
                            _bUSBSRCState = USBSRC_STATE_READY_MEDIA;
                        else
                            _bUSBSRCState = USBSRC_STATE_NO_CARD;
#endif //
                        break;
                    case USBSRC_STATE_WRONG_MEDIA:
                        _bUSBSRCState = USBSRC_STATE_WRONG_MEDIA;
                        break;
                    case USBSRC_STATE_READY_MEDIA:
                        // it must check card in 909R, and it need not check in 909P because it use 
                        // USBSRC_CheckConnect() to check it
#if (USB_SYSTEM != USB_NONE)
                        if (!_bSource)
                            if (!USB_CheckCard(__bTestLun))
                                _bUSBSRCState = USBSRC_STATE_NO_CARD;
#endif //
                        break;
                    default:
                        break;
                }
            }
            else
            {
#ifdef SUPPORT_USB_HOST_DEVICE
                if (_bSource)
                    __bUSBSRCCardType = CARD_CONTROLLER_NONE;
#endif //
                _bUSBSRCState = USBSRC_STATE_NO_MEDIA;
            }

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

        // Elmer070216, it could maybe be removed
        /*
        if (_bUSBSRCState == USBSRC_STATE_NO_CARD || _bUSBSRCState ==  USBSRC_STATE_NO_MEDIA || 
                _bUSBSRCState ==  USBSRC_STATE_WRONG_MEDIA)
        {
            wUSBSRCWaitFlag &= ~(USBSRC_CMD_READDATA | USBSRC_CMD_DUMPDATA | USBSRC_CMD_READDATA_1);

            {
                BYTE bTemp;

                for (bTemp = 0; bTemp < MAX_STREAM_COUNT; bTemp++)
                    USBSRC_EnableRunning(bTemp, FALSE);
            }
        }
        */

        // [Command]: USBSRC_CMD_STOP
        if (wUSBSRCWaitFlag & USBSRC_CMD_STOP)
        {
            //printf("USBSRC: Processing command (STOP)\n");
//            {
//                BYTE bTemp;
//
//                for (bTemp = 0; bTemp < MAX_STREAM_COUNT; bTemp++)
//                    USBSRC_EnableRunning(bTemp, FALSE);
//            }
            // clear the command when finishing the corresponding processing operations, 
            // and trigger the status command to notify CC
            USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_STOP);
            USBSRC_TriggerCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_STOP);
            OS_YieldThread();
        }

        // [Command]: USBSRC_CMD_READDATA
        if (wUSBSRCWaitFlag & (USBSRC_CMD_READDATA | USBSRC_CMD_READDATA_1))
        {
            //printf("USBSRC: Processing command (READ DATA)\n");

            _bUSBSRCReadStatus = TRUE;

            if (__SF_SourceGBL[__dwUSBSRCStreamId].bEnableRunning == TRUE)
            {
                USBSRC_Monitor();
                OS_YieldThread();
            }
            /*
            else
            {
                USBSRC_EnableRunning(__dwUSBSRCStreamId, FALSE);
            }
            */

            if (_bUSBSRCReadStatus == FALSE)
            {
                //_bUSBSRCState = USBSRC_STATE_NO_CARD;

                PRINTF("MONITOR Data Error ...\n");
                USBSRC_EnableRunning(__dwUSBSRCStreamId, FALSE);
                OS_YieldThread();
            }
        }

        // [Command]: USBSRC_CMD_DUMPDATA
        if (wUSBSRCWaitFlag & USBSRC_CMD_DUMPDATA)
        {
            //printf("USBSRC: Processing command (READ DATA)\n");

            _bUSBSRCReadStatus = TRUE;

            //if (__SF_SourceGBL[__dwUSBSRCStreamId].bEnableRunning == TRUE)
            {
#ifdef CTK_CARDREADER
                if (_bSource)
                    // for 909P
                    _bUSBSRCReadStatus = CARD_ReadSector((DWORD)(_dwUSBSRCDumpBuff), _dwUSBSRCDumpSecNO, _dwUSBSRCDumpNum);
                else
#endif
#if (USB_SYSTEM != USB_NONE)
                    _bUSBSRCReadStatus = USB_ReadData(_dwUSBSRCDumpSecNO, _dwUSBSRCDumpNum, (DWORD)_dwUSBSRCDumpBuff);
#else
                    _bUSBSRCReadStatus = FALSE;
#endif
            }

            if (_bUSBSRCReadStatus == FALSE)
            {
                //_bUSBSRCState = USBSRC_STATE_NO_CARD;

                PRINTF("DUMPDATA Error ...\n");
            }

            //USBSRC_EnableRunning(__dwUSBSRCStreamId, FALSE);
            USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_DUMPDATA);
            USBSRC_TriggerCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_DUMPDATA);
            OS_YieldThread();
        }

        // wyc2.78-909P, new commands to switch the usb hsot/device stack.
        if (wUSBSRCWaitFlag & USBSRC_CMD_SWITCH_USB_STACK)
        {
            if (_bUSBOTGCmdMode == USB_MODE_HOST)
            {
#ifdef USBSRC_DEBUG_INFO
                PRINTF("\nEnter HOST mode: CMD:%lx, USB mode:%lx",_bUSBOTGCmdMode,__dwUSBOTGMode);
#endif //
                if (__dwUSBOTGMode != USB_MODE_EXIT_MODE)
                    USB_HCExit();
                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;
            }
#ifdef SUPPORT_USB_HOST_DEVICE
            else if (_bUSBOTGCmdMode == USB_MODE_DEVICE)
            {
#ifdef USBSRC_DEBUG_INFO
                PRINTF("\nEnter DEVICE mode: CMD:%lx, USB mode:%lx",_bUSBOTGCmdMode,__dwUSBOTGMode);
#endif //
                USB_ConfigDeviceMemPool(DS_USB_DEVICE_SCSI_POOL_ST, DS_USB_DEVICE_SCSI_POOL_END - DS_USB_DEVICE_SCSI_POOL_ST);
                if (__dwUSBOTGMode != USB_MODE_EXIT_MODE)
                    USB_HCExit();
                USB_HCInit(USB_MODE_DEVICE, 0,DS_USB_MEMPOOL_ST_DEVICE,(DS_USB_MEMPOOL_END_DEVICE-DS_USB_MEMPOOL_ST_DEVICE));
                __dwUSBOTGMode = USB_MODE_DEVICE;
            }
#endif //
            _bUSBOTGCmdMode = USB_MODE_NONE;

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

        // wyc2.78-909P, the commands to check if card is changed.
        if (wUSBSRCWaitFlag & USBSRC_CMD_DEVICE_MODE_CHK_CARD)
        {
#ifdef SUPPORT_USB_HOST_DEVICE
#ifdef CTK_CARDREADER

            BYTE    bType;
            bType = CARD_CardStatus_Inserted();
            if ((bType != CARD_CONTROLLER_NONE) && (__bUSBSRCCardType != bType))
            {
                __bUSBSRCCardType = bType;
                if (CARD_InitCard() != FALSE)
                {
                    __bUSBSRCCardReady = TRUE;
                    if ((USB_ConnectToPC() == TRUE) && (__dwUSBOTGMode == USB_MODE_DEVICE))
                    {
                        USB_ConfigDeviceMemPool(DS_USB_DEVICE_SCSI_POOL_ST, DS_USB_DEVICE_SCSI_POOL_END - DS_USB_DEVICE_SCSI_POOL_ST);
                        USB_HCExit();
                        USB_HCInit(USB_MODE_DEVICE, 0,DS_USB_MEMPOOL_ST_DEVICE,(DS_USB_MEMPOOL_END_DEVICE-DS_USB_MEMPOOL_ST_DEVICE));
                    }
                }
                else
                {
                    __bUSBSRCCardReady = FALSE;
                }
            }
            if (bType == CARD_CONTROLLER_NONE)
            {
                __bUSBSRCCardReady = FALSE;
                __bUSBSRCCardType = CARD_CONTROLLER_NONE;
            }
            __bCardDetectStage = 0;
            USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_DEVICE_MODE_CHK_CARD);
            USBSRC_TriggerCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_DEVICE_MODE_CHK_CARD);
            OS_YieldThread();
#endif
#endif //
        }
        // wyc2.78-909P, the commands to re-init the usb device stack.
#ifdef SUPPORT_USB_HOST_DEVICE
        if (wUSBSRCWaitFlag & USBSRC_CMD_EXIT_USB_STACK)
        {
            if (__dwUSBOTGMode != USB_MODE_EXIT_MODE)
            {
#ifdef USBSRC_DEBUG_INFO
                PRINTF("\nExit USB Stack: %hx",__dwUSBOTGMode);
#endif //               
                USB_HCExit();
            }
            __dwUSBOTGMode = USB_MODE_EXIT_MODE;
            USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_EXIT_USB_STACK);
            USBSRC_TriggerCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_EXIT_USB_STACK);
            OS_YieldThread();
        }
#endif //
        
    }
}

// ***********************************************************************
// Function : USBSRC_ThreadDelete
// Description : The delete function of USBSRC thread.
// Arguments : None
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
void USBSRC_ThreadDelete(void)
{
    if ((OS_PeekFlag(&__fThreadInit) & INIT_SRC_THREAD_USB_DONE))
    {
        // [1] suspend the thread
        OS_SuspendThread(ThreadUSBSRC.handle);

        // [2] kill the desired thread
        OS_KillThread(ThreadUSBSRC.handle);

        // [3] clear the thread initial done flag
        OS_ClearFlag(&__fThreadInit, ~INIT_SRC_THREAD_USB_DONE);
    }
}

void USBSRC_ThreadSuspend(void)
{
    if ((OS_PeekFlag(&__fThreadInit) & INIT_SRC_THREAD_USB_DONE))
    {
        // [1] clear all the commands triggered
        USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_ALL);
        // [2] disable triggering any command anymore
        USBSRC_TriggerCmd(&_fUSBSRCCmddRunning, USBSRC_CMD_ALL);

        // [3] force USBSRC to sleep state
        // 1 for SLEEPING state
        while (ThreadUSBSRC.space.state != 1)
            OS_YieldThread();

        OS_SuspendThread(ThreadUSBSRC.handle);

        // [4] clear the relative flags
        USBSRC_ClearCmd(&_fUSBSRCCmddRunning, USBSRC_CMD_ALL);
        USBSRC_ClearCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_ALL);
        //USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_ALL);

        // elmer070208, when suspended, clear this bit
        OS_ClearFlag(&__fThreadInit, ~INIT_SRC_THREAD_USB_DONE);
    }
}

void USBSRC_ThreadResume(void)
{
    if (!(OS_PeekFlag(&__fThreadInit) & INIT_SRC_THREAD_USB_DONE))
    {
        OS_SetFlag(&__fThreadInit, INIT_SRC_THREAD_USB_DONE);
        //_USBSRC_InitialVars();
        USBSRC_ClearUSBSRCState();
        OS_ResumeThread(ThreadUSBSRC.handle);
    }
}

// ***********************************************************************
// Function : USBSRC_Stop
// Description : Stop the USB Source running after calling this function.
// Arguments : None
// Return : TRUE (have stop monitor)
// FALSE(stop monitor fail)
// Side Effect :
// ***********************************************************************
// wyc2.53-909P,
BYTE USBSRC_Stop(DWORD dwStreamID, BYTE bRealStop)
{
    //DBG_Printf(DBG_THREAD_INFO_FILTER, DBG_INFO_PRINTF,"\nUSBSRC trigger command ( STOP... )");

    if ((OS_PeekFlag(&__fThreadInit) & INIT_SRC_THREAD_USB_DONE))
    {
        USBSRC_EnableRunning(dwStreamID, FALSE);
        OS_REORDER_BARRIER();
        USBSRC_TriggerCmd(&_fUSBSRCCmdd, USBSRC_CMD_STOP);
        OS_YieldThread();
        USBSRC_WaitCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_STOP);
        USBSRC_ClearCmd(&_fUSBSRCCmddRunning, USBSRC_CMD_STOP);
        USBSRC_ClearCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_STOP);

        if (bRealStop)
        {
            // set WriteSector to (EndSector + 1) to indicate the end of the undergoing file
            __SF_SourceGBL[dwStreamID].dwWriteSector = __SF_SourceGBL[dwStreamID].dwEndSector + 1;
            __SF_SourceGBL[dwStreamID].dwBlockOffset = 0;
        }
    }
    else
    {
        //
    }

    //__dwUSBSRCStreamId = dwStreamID;

    return TRUE;
}