usbsrc.c

ct952 source code use for Digital Frame Photo

// ***********************************************************************
// Function : USBSRC_ReadSectors
// Description : Read data from USB by requested start / end position.
// Arguments : dwStartPos: Start position, dwEndPos: End position.
// Return : TRUE/FALSE
// Side Effect :
// @dwStartPos: start sector(in sector unit)
// @dwEndPos: start sector + occupied how many parser sector size
// ***********************************************************************
BYTE USBSRC_ReadSectors(DWORD dwStreamID, DWORD dwStartPos, DWORD dwEndPos, BYTE bDirectRead)
{
    DWORD dwUSBSRCTemp1, dwUSBSRCTemp2, dwUSBSRCTemp3;

    __bUSBSecPerPar = PARSER_SECTOR_SIZE / FAT_GetFATInfo(FAT_INFO_BYTE_PER_USBSEC);

    // if __dwUSBStartPos == 0xFFFFFFFF, it stands for that it is through our FAT translating function
    if (__dwUSBStartPos != 0xFFFFFFFF)
    {
        __SF_SourceGBL[dwStreamID].dwStartSector = __dwUSBStartPos;
        __SF_SourceGBL[dwStreamID].dwEndSector = __dwUSBStartPos + (dwEndPos - dwStartPos);
        __dwUSBStartPos = 0xFFFFFFFF;
    }
    else
    {
        __SF_SourceGBL[dwStreamID].dwStartSector = dwStartPos;
        __SF_SourceGBL[dwStreamID].dwEndSector = dwEndPos;
        __SF_SourceGBL[dwStreamID].dwBlockOffset = 0;
    }

    _dwUSBSRCWriteCluster1[dwStreamID] = FAT_SectorToClus(dwStartPos);

    __SF_SourceGBL[dwStreamID].dwWriteSector = __SF_SourceGBL[dwStreamID].dwStartSector;
    __SF_SourceGBL[dwStreamID].dwReadSector = __SF_SourceGBL[dwStreamID].dwStartSector;

    dwUSBSRCTemp1 = __SF_SourceGBL[dwStreamID].dwUpperAddr - __SF_SourceGBL[dwStreamID].dwLowerAddr;
    dwUSBSRCTemp2 = dwUSBSRCTemp1 / PARSER_SECTOR_SIZE;
    dwUSBSRCTemp3 = dwUSBSRCTemp1 % PARSER_SECTOR_SIZE;
    _bUSBSRCWriteClusEnd1[dwStreamID] = FALSE;

    // let the size of the buffer be multiple of PARSER_SECTOR_SIZE(2048 bytes).
    if (dwUSBSRCTemp3)
    {
        __SF_SourceGBL[dwStreamID].dwUpperAddr =
            __SF_SourceGBL[dwStreamID].dwLowerAddr + dwUSBSRCTemp2 * PARSER_SECTOR_SIZE;
    }

    __SF_SourceGBL[dwStreamID].dwWriteAddr = __SF_SourceGBL[dwStreamID].dwLowerAddr;
    __SF_SourceGBL[dwStreamID].dwReadAddr = __SF_SourceGBL[dwStreamID].dwLowerAddr;

    // need to set data format for parser.
    __SF_SourceGBL[dwStreamID].dwDataFormat = PARSER_DATAFMT_LINEAR | PARSER_DATAFMT_DVD_2048;
    __SF_SourceGBL[dwStreamID].dwBuffLength = dwUSBSRCTemp2;

#ifdef USBSRC_DEBUG_INFO
    //printf("USBSRC Readsectors(%lx, %lx)", dwStartPos, dwEndPos);
#endif

    // elmer.fix
    if (bDirectRead)
    {
        USBSRC_EnableRunning(dwStreamID, TRUE);
        //USBSRC_IssueReadCmd(dwStreamID);
        //__dwUSBSRCStreamId = dwStreamID;
        
    }
    else
    {
        //__dwUSBSRCStreamId = (MAX_STREAM_COUNT - 1) - dwStreamID;
    }
    //USBSRC_EnableRunning(0, TRUE);
    //USBSRC_TriggerCmd(&_fUSBSRCCmdd, USBSRC_CMD_READDATA);

    return TRUE;
}

// ***********************************************************************
// Function : USBSRC_IssueReadCmd
// Description : Issue the read command to USB SRC
// Arguments : NO
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_IssueReadCmd(DWORD dwStreamID)
{
    __dwUSBSRCStreamId = dwStreamID;
    OS_REORDER_BARRIER();

    // trigger command to read data
    if (dwStreamID == 0)
        OS_SetFlag(&_fUSBSRCCmdd, USBSRC_CMD_READDATA);
    else
        OS_SetFlag(&_fUSBSRCCmdd, USBSRC_CMD_READDATA_1);

    return TRUE;
}

// ***********************************************************************
// Function : USBSRC_GetCurrentPos
// Description : Read current reading cluster from USB source.
// Arguments : pCurrentPos: The current reading cluster.
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************
BYTE USBSRC_GetCurrentPos(PDWORD pCurrentPos)
{
    *pCurrentPos = __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector;
    return TRUE;
}

// ***********************************************************************
// Function : USBSRC_Monitor
// Description : This function will monitor to read data from USB when
// actived and 
// : reading range is specified.
// Arguments : None
// Return : TRUE/FALSE
// Side Effect :
// ***********************************************************************

BYTE USBSRC_Monitor(void)
{
    DWORD dwSaveInt;
    DWORD dwUSBSRCTemp;
    DWORD dwRemainedSec;
    DWORD dwToWriteSecNum;
    DWORD dwTotalSecNum;
    DWORD dwWriteSecNum;
    DWORD dwWriteStartSec;
    DWORD dwWriteStartAddr;
    LONG lUSBSRCTemp;

    dwRemainedSec = 0;
    dwWriteStartAddr = __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteAddr;

    while (__SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector < (__SF_SourceGBL[__dwUSBSRCStreamId].dwEndSector + 1))
    {
        OS_DISABLE_INTERRUPTS(dwSaveInt);
        dwUSBSRCTemp = (__SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector - __SF_SourceGBL[__dwUSBSRCStreamId].dwReadSector);
        OS_RESTORE_INTERRUPTS(dwSaveInt);

        if (dwUSBSRCTemp >= __SF_SourceGBL[__dwUSBSRCStreamId].dwBuffLength)
        {
            if (dwUSBSRCTemp > __SF_SourceGBL[__dwUSBSRCStreamId].dwBuffLength)
            {
#ifdef USBSRC_DEBUG_INFO
                PRINTF("USBSRC write exceeds the length of dump-in buffer");
#endif
                return FALSE;
            }
            else
            {
#ifdef USBSRC_DEBUG_INFO
                //printf("Dump-in buffer is full of unused data");
#endif
                //continue;
                return TRUE;
            }
        }
        
        // configure the buffer length in order to get data
        // in CT909P, there are USB2_0_JUNGO & CTK_CARDREADER
#ifdef CT909P_IC_SYSTEM
        // wyc2.76-909P,
#ifdef SMALL_SOURCE_BUFFER
        if (dwUSBSRCTemp >= 1)
#else
        if (dwUSBSRCTemp >= __SF_SourceGBL[__dwUSBSRCStreamId].dwBuffLength / 3)
#endif //
        {
            OS_YieldThread();
            return TRUE;
        }
#endif

        // how many sectors we still must to read from USB
        dwTotalSecNum = ((__SF_SourceGBL[__dwUSBSRCStreamId].dwEndSector + 1) - __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector)
            * __bUSBSecPerPar - dwRemainedSec;

        // how many sectors we can fill to the dump-in buffer
        OS_DISABLE_INTERRUPTS(dwSaveInt);
        if (__SF_SourceGBL[__dwUSBSRCStreamId].dwWriteAddr >= __SF_SourceGBL[__dwUSBSRCStreamId].dwReadAddr) 
            dwToWriteSecNum = (__SF_SourceGBL[__dwUSBSRCStreamId].dwUpperAddr - __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteAddr) 
                / FAT_GetFATInfo(FAT_INFO_BYTE_PER_USBSEC);
        else
            dwToWriteSecNum = (__SF_SourceGBL[__dwUSBSRCStreamId].dwReadAddr - __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteAddr) 
                / FAT_GetFATInfo(FAT_INFO_BYTE_PER_USBSEC);
        OS_RESTORE_INTERRUPTS(dwSaveInt);

        if (dwToWriteSecNum > dwTotalSecNum)
            dwToWriteSecNum = dwTotalSecNum;

#ifdef SUPPORT_JPEG_AUDIO_PLAYING
        {
            extern BYTE __bMMJPEGAudioMode;
            BOOL PARSER_QueryESBufferReady(DWORD, DWORD);

            if ((__bMMJPEGAudioMode == 1))// && (__dwUSBSRCStreamId == 0))
            {
                if (dwToWriteSecNum > 8) // 4096 bytes
                {
                    if (!PARSER_QueryESBufferReady(__dwUSBSRCStreamId, 4096))
                        return FALSE;
                    else
                        dwToWriteSecNum = 8;
                }
                else
                {
                    if (!PARSER_QueryESBufferReady(__dwUSBSRCStreamId, dwToWriteSecNum * 512))
                        return FALSE;
                }
            }
        }
#endif

        while (dwToWriteSecNum)
        {
            dwWriteStartSec = FAT_ClusToSector(_dwUSBSRCWriteCluster1[__dwUSBSRCStreamId]) + __dwUSBSRCPhyOffset + 
                __SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset;
            
            // the limitation of CT909R
            if (_bSource)
                // For 909P card reader, it has no limitation for 8 sectors per command, and the limitation is 65536
                dwWriteSecNum = dwToWriteSecNum;
            else
// wyc2.71-portusb,
#if (USB_SYSTEM == USB2_0_JUNGO)
                dwWriteSecNum = dwToWriteSecNum;
#elif (USB_SYSTEM == USB1_1_CT909R)
                if (dwToWriteSecNum > USBSRC_WRITE_PARSEC_ONE_CMD * __bUSBSecPerPar)
                    dwWriteSecNum = USBSRC_WRITE_PARSEC_ONE_CMD * __bUSBSecPerPar;
                else
                    dwWriteSecNum = dwToWriteSecNum;
#else
                ;
#endif //
            

            lUSBSRCTemp = dwWriteSecNum - 
                (FAT_GetFATInfo(FAT_INFO_SECTOR_PER_CLUSTER) - __SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset);

            if (lUSBSRCTemp > 0)
            {
                dwWriteSecNum = FAT_GetFATInfo(FAT_INFO_SECTOR_PER_CLUSTER) - __SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset;
                __SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset = 0;

                while (lUSBSRCTemp)
                {
                    if ((FAT_GetNextClus(TRUE, _dwUSBSRCWriteCluster1[__dwUSBSRCStreamId]) - _dwUSBSRCWriteCluster1[__dwUSBSRCStreamId]) == 1)
                    {
                        _dwUSBSRCWriteCluster1[__dwUSBSRCStreamId]++;
                        //dwUSBSRCTemp = FAT_ClusToSector(_dwUSBSRCWriteCluster1) + __dwUSBSRCPhyOffset;
                        lUSBSRCTemp -= FAT_GetFATInfo(FAT_INFO_SECTOR_PER_CLUSTER);

                        if (lUSBSRCTemp >= 0)
                        {
                            dwWriteSecNum += FAT_GetFATInfo(FAT_INFO_SECTOR_PER_CLUSTER);
                            continue;
                        }
                        else
                        {
                            dwWriteSecNum += lUSBSRCTemp + FAT_GetFATInfo(FAT_INFO_SECTOR_PER_CLUSTER);
                            __SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset = 
                                lUSBSRCTemp + FAT_GetFATInfo(FAT_INFO_SECTOR_PER_CLUSTER);
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
            }
            else
            {
                __SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset += dwWriteSecNum;
            }

#ifdef CTK_CARDREADER
            if (_bSource)
                // for 909P
                _bUSBSRCReadStatus = CARD_ReadSector(dwWriteStartAddr, dwWriteStartSec, dwWriteSecNum);
            else
#endif
#if (USB_SYSTEM != USB_NONE)
                _bUSBSRCReadStatus = USB_ReadData(dwWriteStartSec, dwWriteSecNum, dwWriteStartAddr);
#else
                _bUSBSRCReadStatus = FALSE;
#endif 

            //printf("Source %d\: %lx, %lx\n", __dwUSBSRCStreamId, dwWriteStartSec, dwWriteSecNum);

            if (_bUSBSRCReadStatus == FALSE)
            {
#ifdef USBSRC_DEBUG_INFO
                PRINTF("USBSRC monitor error (WriteStartSec, WriteSecNum): (%lx, %lx)", dwWriteStartSec, dwWriteSecNum);
#endif
                __bUSBSRCReadError[__dwUSBSRCStreamId] = TRUE;
                return FALSE;
            }
#ifdef USBSRC_DEBUG_INFO
            else
                //printf("Read %lx sectors from %lx\n", dwWriteSecNum, dwWriteStartSec);
#endif
            dwToWriteSecNum -= dwWriteSecNum;

            dwWriteStartAddr += dwWriteSecNum * FAT_GetFATInfo(FAT_INFO_BYTE_PER_USBSEC);

            if (dwWriteStartAddr == __SF_SourceGBL[__dwUSBSRCStreamId].dwUpperAddr)
                dwWriteStartAddr = __SF_SourceGBL[__dwUSBSRCStreamId].dwLowerAddr;

            __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteAddr = dwWriteStartAddr;
            OS_DISABLE_INTERRUPTS(dwSaveInt);
            __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector += (dwWriteSecNum + dwRemainedSec) / __bUSBSecPerPar;
            OS_RESTORE_INTERRUPTS(dwSaveInt);
            dwRemainedSec = (dwWriteSecNum + dwRemainedSec) % __bUSBSecPerPar;

            if (!(__SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset % FAT_GetFATInfo(FAT_INFO_SECTOR_PER_CLUSTER)))
            {
                __SF_SourceGBL[__dwUSBSRCStreamId].dwBlockOffset = 0;
                _dwUSBSRCWriteCluster1[__dwUSBSRCStreamId] = FAT_GetNextClus(TRUE, _dwUSBSRCWriteCluster1[__dwUSBSRCStreamId]);

                //if (FAT_CLUSTER_END)
                if (((_dwUSBSRCWriteCluster1[__dwUSBSRCStreamId] == FAT12_TABLE_CLUS_END) && (__bFileSystem ==            FILE_SYSTEM_FAT12))
                        || ((_dwUSBSRCWriteCluster1[__dwUSBSRCStreamId] == FAT16_TABLE_CLUS_END) && (__bFileSystem ==     FILE_SYSTEM_FAT16))
                        || ((_dwUSBSRCWriteCluster1[__dwUSBSRCStreamId] == FAT32_TABLE_CLUS_END) && (__bFileSystem ==     FILE_SYSTEM_FAT32)))

                {
#ifdef USBSRC_DEBUG_INFO
                    //printf("File End(%x)", _wWriteSectorNum);
#endif
                    dwToWriteSecNum = 0;
                    // must add this statement to notify PARSER that the file has reached end
                    __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector = __SF_SourceGBL[__dwUSBSRCStreamId].dwEndSector + 1;
                    _bUSBSRCWriteClusEnd1[__dwUSBSRCStreamId] = TRUE;
                }
            }
        } // while (dwToWriteSecNum)

        if (_bUSBSRCWriteClusEnd1[__dwUSBSRCStreamId] == TRUE
                || __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector > __SF_SourceGBL[__dwUSBSRCStreamId].dwEndSector)
        {
#ifdef USBSRC_DEBUG_INFO
            //printf("End work of USBSRC_Monitor");
#endif
            __SF_SourceGBL[__dwUSBSRCStreamId].dwWriteSector = __SF_SourceGBL[__dwUSBSRCStreamId].dwEndSector + 1;
            USBSRC_EnableRunning(__dwUSBSRCStreamId, FALSE);
            //__SF_SourceGBL[__dwUSBSRCStreamId].bEnableRunning = FALSE;