pc_dev.c

瑞星微公司RK27XX系列芯片的SDK开发包

    }

    pCache = PCFdtCache.pCacheData;
    
    for(i=0; i<PC_SYSTEM_FDT_CACHE_COUNT; i++){
        pCache->flag     = 0; 
        pCache->pBuffer  = &PCFdtCacheBuf[i][0];
        pCache->SectorNo = 0xFFFFFFFF;
        pCache++;
    }

    pCache = PCDataCache.pCacheData;
    
    for(i=0; i<PC_SYSTEM_DATA_CACHE_COUNT; i++){
        pCache->flag     = 0; 
        pCache->pBuffer  = &PCDataCacheBuf[i][0];
        pCache->SectorNo = 0xFFFFFFFF;
        pCache++;
    }    
}
int FS_PCSysMediumInit(void)
{
    int err=0;
    
    char DevPathBuf[24];
        
    PCSysCacheInit();

    PC_SYSTEM_DEV_PATH[4] = 'C';
    gPCDevSysDiskWritable = FS_PCDevGetRemovedDisk( PC_SYSTEM_DEV_PATH ,10, 128 );
    TR("Sys Disk Writable[%d]" , gPCDevSysDiskWritable);
    if( gPCDevSysDiskWritable )
        {
        gPCDevSysDiskHandle = 
            CreateFile(PC_SYSTEM_DEV_PATH, GENERIC_READ|GENERIC_WRITE, 
            FILE_SHARE_WRITE|FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
        }
    else
        {
        gPCDevSysDiskHandle = 
            CreateFile(PC_SYSTEM_DEV_PATH, GENERIC_READ, FILE_SHARE_WRITE|FILE_SHARE_READ,
            NULL, OPEN_EXISTING, 0, NULL);
        }
    
    if(gPCDevSysDiskHandle == INVALID_HANDLE_VALUE)
    {
        err = ERROR;
    }
    else
    {
        strcpy(DevPathBuf, PC_SYSTEM_DEV_PATH);
        strcat(DevPathBuf, "\\");
        if(GetDiskFreeSpace(DevPathBuf, &dwSysSectPerClust, 
                                        &dwSysBytesPerSect, 
                                        &dwSysFreeClusters, 
                                        &dwSysTotalClusters))
        {
            err = OK;
        }
        else
        {
            err = ERROR;
        }
    }

    return(err);
}

/*********************************************************************************/
#if 0
//用户盘接口函数
#endif
/*********************************************************************************/

int FS_PCUserReadSec(uint32 LBA, uint32 SecCount, void *buf)
{
    DWORD dwCB;
    DWORD dwCB2;
    DWORD dwPtrLow;
    DWORD dwError;
    BOOL  rd;
    
    dwCB2 = 512 * LBA;
    dwCB  = (DWORD)(((INT64U)512*LBA)>>32);

    dwPtrLow = SetFilePointer(gPCDevUserDiskHandle, dwCB2, (long *)&dwCB, FILE_BEGIN);
	
    if (dwPtrLow == 0xFFFFFFFF && (dwError = GetLastError()) != NO_ERROR )
        { 
        // Deal with failure 
        TR("Read:Seek UserDisk Failed,Lba=0x%x,Err=%d" , LBA , dwError );
	    return -1;
        } // End of error handler 

    dwPtrLow = PCFS_TMPBUF_SIZE;
    while( SecCount > 0 )
    {
        if( SecCount <= (PCFS_TMPBUF_SIZE/512) )
            {
            dwPtrLow = 512 * SecCount;
            }
        rd = ReadFile(gPCDevUserDiskHandle, gPCUsrDiskTmpBuf ,
            dwPtrLow , &dwCB, NULL);
        
        if( !rd || dwCB != dwPtrLow )
        {
            dwError = GetLastError();
            TR("Read:Read UserDisk Failed,Lba=0x%x,SecCnt=%d,Err=%d,rd=%d,dwCB=%d" ,
                LBA ,SecCount, dwError , rd , dwCB);
            return -1;
        }
        memcpy( buf , gPCUsrDiskTmpBuf , dwPtrLow );
        buf =(char*)buf+ dwPtrLow;
        SecCount -= (dwPtrLow/512);
    }
    return 0;
}
int FS_PCUserWriteSec(uint32 LBA, uint32 SecCount, void *buf)
{
    DWORD dwCB;
	DWORD dwCB2;
    DWORD dwPtrLow;
    DWORD dwError;
   //系统盘不可写.
    if( !gPCDevUsrDiskWritable )
        return -1;
    
	dwCB2 = 512 * LBA;
	dwCB  = (DWORD)(((INT64U)512*LBA)>>32);
    
	dwPtrLow = SetFilePointer(gPCDevUserDiskHandle, dwCB2, (long *)&dwCB, FILE_BEGIN);
	
    if (dwPtrLow == 0xFFFFFFFF && (dwError = GetLastError()) != NO_ERROR )
        { 
        // Deal with failure 
        TR("Wirte:Seek UserDisk Failed,Lba=0x%x,Err=%d" , LBA , dwError );
	    return -1;
    
        } // End of error handler 
    
	if( WriteFile(gPCDevUserDiskHandle, buf, 512 * SecCount, &dwCB, NULL) == 0 )
	    {
	    TR("Write UserDisk Failed0,SECTOR=%d,Err=%d" , SecCount , GetLastError() );
	    return -1;
	    }
	
    if(dwCB != 512*SecCount)
    {
        TR("Write UserDisk Failed1,SECTOR=%d,Err=%d" , SecCount , GetLastError() );
        return -1;
    }
    return 0;
}


int FS_PCUserIoCtl(uint32 cmd, uint32 arg, void *buf)
{
    uint32 *rbuf;
    rbuf = (uint32 *)buf;
    switch(cmd)
    {
        case IO_CTL_GET_CAPACITY:
            //*rbuf = GetCapacity(DISK_FLASH);
            *rbuf = dwUserTotalClusters*dwUserSectPerClust;
            break;
        case IO_CTL_GET_MEDIUM_START_SEC:
            *rbuf = 0;  /* 用户盘的开始为SYSTEM盘的大小 */
            break;
        case IO_CTL_CACHE_WRITE_BACK:
            //PCCacheCloseAll();
            break;
        case IO_CTL_FLUSH_CACHE:
            PCUserCacheInit();
            break;
        default:
            break;
    } 
    return(0);
}

void PCUserCacheInit(void)
{
    uint32 i;
    FS_CACHE_DATA *pCache;

    pCache = PCUFatCache.pCacheData;
    
    for(i=0; i<PC_USER_FAT_CACHE_COUNT; i++){
        pCache->flag     = 0; 
        pCache->pBuffer  = &PCUFatCacheBuf[i][0];
        pCache->SectorNo = 0xFFFFFFFF;
        pCache++;
    }

    pCache = PCUFdtCache.pCacheData;
    
    for(i=0; i<PC_USER_FDT_CACHE_COUNT; i++){
        pCache->flag     = 0; 
        pCache->pBuffer  = &PCUFdtCacheBuf[i][0];
        pCache->SectorNo = 0xFFFFFFFF;
        pCache++;
    }

    pCache = PCUDataCache.pCacheData;
    
    for(i=0; i<PC_USER_DATA_CACHE_COUNT; i++){
        pCache->flag     = 0; 
        pCache->pBuffer  = &PCUDataCacheBuf[i][0];
        pCache->SectorNo = 0xFFFFFFFF;
        pCache++;
    }
}

int FS_PCUserMediumInit(void)
{
    int         err = OK;
    char        DevPathBuf[24];
    
    PCUserCacheInit();

    PC_USER_DEV_PATH[4] = 'D';
    gPCDevUsrDiskWritable = FS_PCDevGetRemovedDisk( PC_USER_DEV_PATH ,130 , 0X20000 );
    TR("User Disk Writable[%d]", gPCDevUsrDiskWritable);
    
    if( !gPCDevUsrDiskWritable )    //如果没有移动磁盘,默认设为 PC上的 D盘.
        PC_USER_DEV_PATH[4] = 'D';
    
    if( gPCDevUsrDiskWritable )
        {
        gPCDevUserDiskHandle = 
            CreateFile(PC_USER_DEV_PATH, GENERIC_READ|GENERIC_WRITE, 
                FILE_SHARE_WRITE|FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
        }
    else
        {
        gPCDevUserDiskHandle = 
            CreateFile(PC_USER_DEV_PATH, GENERIC_READ, 
                FILE_SHARE_WRITE|FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
        }

    if(gPCDevUserDiskHandle == INVALID_HANDLE_VALUE)
    {
        err = ERROR;
    }
    else
    {
        strcpy(DevPathBuf, PC_USER_DEV_PATH);
        strcat(DevPathBuf, "\\");
        if(GetDiskFreeSpace(DevPathBuf, &dwUserSectPerClust, 
                                        &dwUserBytesPerSect, 
                                        &dwUserFreeClusters, 
                                        &dwUserTotalClusters))
        {
            err = OK;
        }
        else
        {
            err = ERROR;
        }
    }
 
    return(err);
}

void FS_PCMediumClose( void )
{
    if (gPCDevSysDiskHandle != INVALID_HANDLE_VALUE) 
        {
        CloseHandle(gPCDevSysDiskHandle); 
        gPCDevSysDiskHandle = INVALID_HANDLE_VALUE;
        }

    if (gPCDevUserDiskHandle != INVALID_HANDLE_VALUE) 
        {
        CloseHandle(gPCDevUserDiskHandle); 
        gPCDevUserDiskHandle = INVALID_HANDLE_VALUE;
        }
}
#endif