usbsrc.c

ct952 source code use for Digital Frame Photo

            return FALSE;
        }

        // elmer.test 909P
        // it needs not be setup here, when it returns, it will issue OS_YieldThread()
        //OS_YieldThread();

        return TRUE;
    } // while (__SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector < (__SF_SourceGBL[__dwUSBSRCStreamId].dwEndSector + 1))

    return TRUE;
}

// ***********************************************************************
// Function : USBSRC_DumpDatabySource
// Description : Dump the data to specific pointer address from source by
// wait source to read data.
// Arguments : dwSecNO: The dump location(logical location). dwNum: The
// dump sector num(Parser sector unit, 2048 bytes).
// : pFATTable: The dumped pointer.
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_DumpDatabySource(DWORD dwSecNO, DWORD dwNum, DWORD * pFATBuff)
{
    _dwUSBSRCDumpSecNO = dwSecNO + __dwUSBSRCPhyOffset;
    _dwUSBSRCDumpNum = dwNum * __bUSBSecPerPar;
    _dwUSBSRCDumpBuff = pFATBuff;

    //USBSRC_EnableRunning(__dwUSBSRCStreamId, TRUE);
    USBSRC_TriggerCmd(&_fUSBSRCCmdd, USBSRC_CMD_DUMPDATA);
    OS_YieldThread();
    USBSRC_WaitCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_DUMPDATA);
    USBSRC_ClearCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_DUMPDATA);
    USBSRC_ClearCmd(&_fUSBSRCCmddRunning, USBSRC_CMD_DUMPDATA);
#ifdef USBSRC_DEBUG_INFO
    PRINTF("USBSRC dump %lx sectors from %lx ...", _dwUSBSRCDumpNum, _dwUSBSRCDumpSecNO);

    if (_bUSBSRCReadStatus == FALSE)
        PRINTF("Error\n");
    else
        PRINTF("Success\n");
#endif

    return _bUSBSRCReadStatus;
}

// ***********************************************************************
// Function : USBSRC_DumpData
// Description : Dump the data to specific pointer address from source 
// Arguments : dwSecNO: The dump location(logical location). dwNum: The
// dump sector num(Parser sector unit, 2048 bytes).
// : pFATTable: The dumped pointer.
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_DumpData(DWORD dwSecNO, DWORD dwNum, DWORD * pFATBuff)
{
    dwSecNO += __dwUSBSRCPhyOffset;

#ifdef CTK_CARDREADER
    if  (_bSource)
        // for 909P
        _bUSBSRCReadStatus = CARD_ReadSector((DWORD)(pFATBuff), dwSecNO, dwNum * __bUSBSecPerPar);
    else
#endif
#if (USB_SYSTEM != USB_NONE)
        _bUSBSRCReadStatus = USB_ReadData(dwSecNO, dwNum * __bUSBSecPerPar, (DWORD)(pFATBuff));
#else
        _bUSBSRCReadStatus = FALSE;
#endif //


    if (_bUSBSRCReadStatus == FALSE)
    {
        __bUSBSRCReadError[__dwUSBSRCStreamId] = TRUE;
#ifdef USBSRC_DEBUG_INFO
        PRINTF("Dump Data ERROR[%lx, %lx, %lx, %lx]", dwSecNO, dwNum, __bUSBSecPerPar, (DWORD)(pFATBuff));
#endif
    }

    return _bUSBSRCReadStatus;
}

// ***********************************************************************
// Function : USBSRC_CheckUSBStatus
// Description : Check the status from USB S/W stack, status 
// Arguments : bUSBSRCID: The source ID to check status.
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_CheckUSBStatus(BYTE bUSBSRCID)
{
#ifdef CTK_CARDREADER
    if (_bSource)
        // for 909P
        if (CARD_InitCard())
            return USBSRC_STATE_READY_MEDIA;
        else
            return USBSRC_STATE_WRONG_MEDIA;
    else
#endif
#if (USB_SYSTEM != USB_NONE)
        switch (USB_CheckStatus())
        {
            case USB_STATUS_NOT_SUPPORTED_DEVICE:
                return USBSRC_STATE_WRONG_MEDIA;
                break;

            case USB_STATUS_MASS_STORAGE_DEVICE:
                return USBSRC_STATE_READY_MEDIA;
                break;

            case USB_STATUS_NO_DEVICE:
                return USBSRC_STATE_NO_MEDIA;
                break;

            case USB_STATUS_NO_DISC:
                return USBSRC_STATE_NO_CARD;
                break;

            default:
                return USBSRC_STATE_NO_MEDIA;
                break;
        }
#else
        return FALSE;
#endif 
}

// wyc1.05-909, rename function name.
// ***********************************************************************
// Function : USBSRC_GetUSBSRCStatus
// Description : This function will check the status of media that insert
// in USB source
// : and return status to Srcfilter.
// Arguments : None
// Return : USBSRC_STATE_NO_MEDIA: No media. USBSRC_STATE_READY_MEDIA:
// Media ready. 
// : SBSRC_STATE_WRONG_MEDIA: Media wrong.
// Side Effect :
// ***********************************************************************
BYTE USBSRC_GetUSBSRCStatus(BYTE bSourceID)
{
    return _bUSBSRCState;
}
// ***********************************************************************
// Function : USBSRC_ClearUSBSRCStatus
// Description : This function clear USBSRC state to NO media to re-get
// USB status from devide.
// Arguments : None
// Return : NONE
// Side Effect :
// ***********************************************************************
void USBSRC_ClearUSBSRCState(void)
{
    BYTE bTemp;

    _bUSBSRCState = USBSRC_STATE_NO_MEDIA;

    for (bTemp = 0; bTemp < MAX_STREAM_COUNT; bTemp++)
    {
        __SF_SourceGBL[bTemp].dwBlockOffset = 0;
        __SF_SourceGBL[bTemp].bEnableRunning = FALSE;
    }

    // clear flags
    OS_ClearFlag(&_fUSBSRCCmdd, 0);
    OS_ClearFlag(&_fUSBSRCCmddStatus, 0);
    OS_ClearFlag(&_fUSBSRCCmddRunning, 0);

    __bUSBSRCReadError[0] = FALSE;
    __bUSBSRCReadError[1] = FALSE;

#if (USB_SYSTEM != USB_NONE)
    USB_ClearStatus();
#endif //
}

// ***********************************************************************
// Function : USB_EnableRunning
// Description : Control the USB Src running or not.
// Arguments : TRUE : Enable
// FALSE : Disable
// Return : TRUE : OK, FALSE: Fail
// Side Effect :
// ***********************************************************************
BOOL USBSRC_EnableRunning(DWORD dwStreamID, BYTE bRun)
{
    __SF_SourceGBL[dwStreamID].bEnableRunning = bRun;

    // if setting to FALSE, it should clear the READDATA command so that
    // it will not continue reading data
    if (bRun == FALSE)
    {
        if (dwStreamID == 0)
        {
            USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_READDATA);
            USBSRC_ClearCmd(&_fUSBSRCCmddRunning, USBSRC_CMD_READDATA);
            //USBSRC_ClearCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_READDATA);
        }
        else
        {
            USBSRC_ClearCmd(&_fUSBSRCCmdd, USBSRC_CMD_READDATA_1);
            USBSRC_ClearCmd(&_fUSBSRCCmddRunning, USBSRC_CMD_READDATA_1);
            //USBSRC_ClearCmd(&_fUSBSRCCmddStatus, USBSRC_CMD_READDATA_1);
        }
    }
    else
    {
        if (dwStreamID == 0)
            OS_SetFlag(&_fUSBSRCCmdd, USBSRC_CMD_READDATA);
        else
            OS_SetFlag(&_fUSBSRCCmdd, USBSRC_CMD_READDATA_1);

        OS_REORDER_BARRIER();
        __dwUSBSRCStreamId = dwStreamID;
    }

    return TRUE;
}

// ***********************************************************************
// Function : USBSRC_Abort
// Description : Abort the action of USB source.
// Arguments : None
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_Abort(void)
{
    return TRUE;
}

// ***********************************************************************
// Function : _USBSRC_InitialVars
// Description : Inititl variables / flags / mutex that used by USB
// source.
// Arguments : None
// Return : None
// Side Effect :
// ***********************************************************************
void _USBSRC_InitialVars(void)
{
    // wyc1.01-909, cluster need to reference FAT, now temp assign here.
    __wUSBSRCCluSize = 2048;
    __dwUSBSRCPhyOffset = 0;
    _bUSBSRCReadStatus = TRUE;
    __bUSBSecPerPar = PARSER_SECTOR_SIZE / USB_DEFAULT_SECTOR_SIZE;

    FAT_InitVars();
}

// wyc2.05-909S, function to call USB_HCExit.
// ***********************************************************************
// Function : USBSRC_HCExit
// Description : Exit the USB mode and stop the USB HW mode.
// Arguments : None
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_HCExit(void)
{
#if (USB_SYSTEM != USB_NONE)
    USB_HCExit();
#endif //
    return TRUE;
}

// wyc2.37-909s, function to force exiting H/W relative functions.
// ***********************************************************************
// Function : USBSRC_SRCExit
// Description : Exit the USB source mode and make it entering no media mode.
// Arguments : None
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_SRCExit(void)
{
#if (USB_SYSTEM == USB1_1_CT909R)
    USB_ClearPort();
#endif //
    return TRUE;
}

#ifdef SUPPORT_JPEG_AUDIO_PLAYING
BYTE USBSRC_ExitMonitor(void)
{
    return TRUE;
}
#endif // SUPPORT_JPEG_AUDIO_PLAYING

// 1:card-reader, 0: USB
BYTE USBSRC_CheckConnect()
{
    // for 909P
#ifdef CTK_CARDREADER
    if (_bSource)
    {
        return CARD_CardStatus_Inserted();
    }
    else
#endif
    {
#if (USB_SYSTEM != USB_NONE)
        return USB_CheckConnect();
#else
        return FALSE;
#endif
    }
}

// wyc2.78-909P, function to trigger the switch host/device mode functions.
void USBSRC_SetOTGMode(BYTE bUSBOTGMode)
{
#ifdef SUPPORT_USB_HOST_DEVICE
#if (USB_SYSTEM == USB2_0_JUNGO)
    _bUSBOTGCmdMode = bUSBOTGMode;
#endif //
#endif //
}

BYTE USBSRC_GetOTGMode(void)
{
#ifdef SUPPORT_USB_HOST_DEVICE
#if (USB_SYSTEM == USB2_0_JUNGO)
    return __dwUSBOTGMode;
#endif //
#endif //
    return FALSE;
}

BYTE USBSRC_CTKCardReady(void)
{    
#ifdef SUPPORT_USB_HOST_DEVICE
    if ((__bUSBSRCCardReady == TRUE) && (__bUSBSRCCardType != CARD_CONTROLLER_NONE))
        return TRUE;
    else
        return FALSE;
#else
    return FALSE;
#endif //
}
#endif // SUPPORT_USB_SOURCE