static int MS_MountDevice(int DeviceType)
{
kal_uint8 *sector = (kal_uint8*)MSDC_Sector;
FS_MasterBootRecord *MBR;
FS_BootRecord *PBR;
int status;
kal_bool IsMBRExist;
kal_uint8 type = 0;
kal_uint8 c = gMS.Capacity;
// get index for MS_MBR => (type) is the index
while((c >>= 1) != 2)
type++;
IsMBRExist = KAL_FALSE;
// read MBR at sector 0
status = ReadSectors(NULL,0,1,(void*)sector);
MBR = (FS_MasterBootRecord*)sector;
PBR = (FS_BootRecord*)sector;
if( MBR->Signature == 0xAA55 &&
MBR->PTable[0].BootIndicator == 0x80)
{
IsMBRExist = KAL_TRUE;
}
if(!IsMBRExist)
{
// create MBR
kal_mem_set((void*)MBR,0,sizeof(MBR));
kal_mem_cpy((void*)&(MBR->PTable[0]),MS_MBR[type],MS_MBR_SIZE);
MBR->Signature = 0xAA55;
status = WriteSectors(NULL,0,1,(void*)sector);
if(status < NO_ERROR)
return FS_MSDC_MOUNT_ERROR;
// create PBR
FS_CreateBootSector((void*)sector, (FS_PartitionRecord*)MS_MBR[type], (BYTE)MSDC_MEDIA_DESCRIPTOR,
(UINT)gMS.PagesPerBlk, (gMS.Capacity < 128)?FS_FMT_FAT_12:FS_FMT_FAT_16);
PBR->NearJump[0] = 0xE9;
PBR->NearJump[1] = 0x00;
PBR->NearJump[2] = 0x00;
kal_mem_set((void*)PBR->BP.OEMName,0x20,8);
PBR->BP.SectorsPerCluster = gMS.PagesPerBlk;
PBR->BP.DirEntries = 0x200;
PBR->BP.E._16.BPB.PhysicalDiskNumber = 0;
PBR->BP.E._16.BPB.CurrentHead = 0;
PBR->BP.E._16.BPB.SerialNumber = 0;
kal_mem_set((void*)PBR->BP.E._16.BPB.Label,0x20,11);
status = WriteSectors(NULL, PBR->BP.NumberOfHiddenSectors,1,(void*)sector);
if(status < NO_ERROR)
return FS_MSDC_MOUNT_ERROR;
}
return FS_NO_ERROR;
}
BOOL BackupBoot(RDWRHandle handle)
{
int fatlabelsize = GetFatLabelSize(handle);
SECTOR BackupSector;
struct BootSectorStruct* boot;
BOOL retVal = TRUE;
if (fatlabelsize == FAT32)
{
BackupSector = GetFAT32BackupBootSector(handle);
if (!BackupSector)
{
RETURN_FTEERR(FALSE);
}
boot = AllocateBootSector();
if (!boot) RETURN_FTEERR(FALSE);
if (!ReadBootSector(handle, boot) ||
(WriteSectors(handle, 1, BackupSector, (void*) boot, WR_UNKNOWN)
== -1))
{
RETURN_FTEERR(FALSE);
}
FreeBootSector(boot);
}
RETURN_FTEERR(retVal);
}
RETVAL PlaceDescriptorInFat(RDWRHandle handle)
{
struct BootSectorStruct boot;
SECTOR fatstart;
char buffer[BYTESPERSECTOR], *p;
if (!ReadBootSector(handle, &boot))
return ERROR;
fatstart = GetFatStart(handle);
if (!fatstart) return ERROR;
if (ReadSectors(handle, 1, fatstart, buffer) == -1)
return ERROR;
if (buffer[0] != boot.descriptor)
{
ReportFileSysError("Wrong descriptor value in FAT",
0,
&p,
0,
FALSE);
buffer[0] = boot.descriptor;
if (WriteSectors(handle, 1, fatstart, buffer, WR_FAT) == -1)
return ERROR;
if (!BackupFat(handle))
return ERROR;
}
return SUCCESS;
}
SD_SelfFormat()
{
FS_PartitionRecord Par, Par1;
//static kal_uint8 p[512];
kal_mem_set((void*)&Par, 0, sizeof Par);
Par.Sectors = gSD->mCSD.capacity/512;
FS_CreateMasterBootRecord(MSDC_Sector, &Par);
WriteSectors(gMSDC_Handle, 0, 1, MSDC_Sector);
Par = ((FS_MasterBootRecord *)MSDC_Sector)->PTable[0];
FS_CreateBootSector((void*)MSDC_Sector, &Par, 0xF8, 0, FS_FMT_SINGLE_FAT );
WriteSectors(gMSDC_Handle, Par.RelativeSector, 1, MSDC_Sector);
/* End of SelfFormat */
}
BOOL WriteDiskFromFile( HANDLE hDevice,HANDLE hFile,ULONGLONG ullStartSector, ULONGLONG ullSectors )
{
ULONGLONG ullRealStartSector = ullStartSector;
ULONGLONG ullReadSectors = 0;
ULONGLONG ullRemainSectors = ullSectors;
DWORD dwSectors = 0;
BOOL bOK = TRUE;
ULONGLONG ullOffset = 0;
PBYTE lpBuf = new BYTE[BUF_LENGTH];
memset(lpBuf,0,BUF_LENGTH);
while (ullReadSectors < ullSectors)
{
if (ullRemainSectors < PER_SECTORS)
{
dwSectors = (DWORD)ullRemainSectors;
}
else
{
dwSectors = PER_SECTORS;
}
DWORD dwLastError = 0;
memset(lpBuf,0,BUF_LENGTH);
DWORD dwSize = dwSectors * BYTES_PER_SECTOR;
BOOL bRec = ReadFileAsyn(hFile,ullOffset,dwSize,lpBuf,&g_OverlapedFile,&dwLastError);
if (!bRec)
{
bOK = FALSE;
std::cout << red << "Read File Error---" << dwLastError << white << std::endl;
break;
}
bRec = WriteSectors(hDevice,ullRealStartSector,dwSectors,BYTES_PER_SECTOR,lpBuf,&g_OverlapedDisk,&dwLastError);
if (!bRec)
{
bOK = FALSE;
std::cout << red << "Write Sectors Error---" << dwLastError << white << std::endl;
break;
}
ullRealStartSector += dwSectors;
ullReadSectors += dwSectors;
ullRemainSectors -= dwSectors;
ullOffset += dwSize;
}
delete[] lpBuf;
return bOK;
}
//! under construction [Samuel, 2010/10/01]
DRV_STATUS_CODE DRV_SD_WriteSectors(
mcdev_enum id,
unsigned int sector,
unsigned int sectors,
void * buffer,
unsigned int flags
)
{
SDC_CMD_STATUS status = NO_ERROR;
emmc_addr addr;
//#if !defined(__UBL__) && !defined(__FUE__)
// ASSERT(0); // so far this function can only be used in bootloader
//#endif
get_MSDC_lock(&gSD->mSDdrv_lock);
status = DRV_SD_AddrLookupTbl(sector, &addr);
if (NO_ERROR != status)
{
free_MSDC_lock(&gSD->mSDdrv_lock);
return DRV_WRITE_FAILURE;
}
if (KAL_TRUE != SD_eMMC_ECSD_setCurrentPart(addr.partition))
{
free_MSDC_lock(&gSD->mSDdrv_lock);
return DRV_WRITE_FAILURE;
}
status = WriteSectors(GetMsdcHandle(id), addr.offset, sectors, buffer);
if (NO_ERROR != status)
{
free_MSDC_lock(&gSD->mSDdrv_lock);
return DRV_WRITE_FAILURE;
}
//! TODO: check why it fails
if (KAL_TRUE != SD_eMMC_ECSD_setCurrentPart(eMMC_user_Area))
{
free_MSDC_lock(&gSD->mSDdrv_lock);
return DRV_WRITE_FAILURE;
}
free_MSDC_lock(&gSD->mSDdrv_lock);
return DRV_SUCCESS;
}
BiosResult WriteEncryptedSectors (uint16 sourceSegment, uint16 sourceOffset, byte drive, uint64 sector, uint16 sectorCount)
{
BiosResult result;
AcquireSectorBuffer();
uint64 dataUnitNo;
uint64 writeOffset;
dataUnitNo = sector;
writeOffset.HighPart = 0;
writeOffset.LowPart = 0;
if (BootCryptoInfo->hiddenVolume)
{
if (ReadWritePartiallyCoversEncryptedArea (sector, sectorCount))
return BiosResultInvalidFunction;
// Remap the request to the hidden volume
writeOffset = HiddenVolumeStartSector;
writeOffset -= EncryptedVirtualPartition.StartSector;
dataUnitNo -= EncryptedVirtualPartition.StartSector;
dataUnitNo += HiddenVolumeStartUnitNo;
}
while (sectorCount-- > 0)
{
CopyMemory (sourceSegment, sourceOffset, SectorBuffer, TC_LB_SIZE);
if (drive == EncryptedVirtualPartition.Drive && sector >= EncryptedVirtualPartition.StartSector && sector <= EncryptedVirtualPartition.EndSector)
{
EncryptDataUnits (SectorBuffer, &dataUnitNo, 1, BootCryptoInfo);
}
result = WriteSectors (SectorBuffer, drive, sector + writeOffset, 1);
if (result != BiosResultSuccess)
break;
++sector;
++dataUnitNo;
sourceOffset += TC_LB_SIZE;
}
ReleaseSectorBuffer();
return result;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Installs BK to load the specified driver.
//
BOOL BkInstallVbr(
PCHSS PayloadAddress
)
{
BOOL Ret = FALSE;
PCHAR Vbs = NULL, Loader = NULL, Packed = NULL;
PVBR Vbr = NULL;
ULONG i, CodeSize, bSize = BIOS_DEFAULT_SECTOR_SIZE;
PPARTITION_TABLE PTable;
ULONG StartSector = 0, SectorSize = 0, PackedSize = 0;
WCHAR TargetDrive[cstrlenW(wszPartition) + 1] = {0};
wsprintfW(TargetDrive, wszPartition, 0);
do // not a loop
{
if (!(Vbs = Alloc(BIOS_DEFAULT_SECTOR_SIZE)))
// Not enough memory
break;
// Reading MBR sector
if (!ReadSectors(TargetDrive, Vbs, bSize, 0, 1))
// Reading failed
break;
// Check out we read a right one
if (*(PUSHORT)(Vbs + BIOS_DEFAULT_SECTOR_SIZE - sizeof(USHORT)) != BIOS_MBR_MAGIC)
// Wrong or corrupt sector loaded
break;
// Here we read the Driver Boot sector and searching for the Volume boot sector within it
PTable = (PPARTITION_TABLE)(Vbs + BIOS_PARTITION_TABLE_OFFSET);
i = 0;
while(
(i < BIOS_MAX_PARTITION_COUNT) &&
(!(PTable->Entry[i].ActiveFlag & BIOS_PARTITION_ACTIVE_FLAG) ||
(PTable->Entry[i].Descriptor != BIOS_PARTITION_TYPE_INSTALLABLE)))
i += 1;
if (i == BIOS_MAX_PARTITION_COUNT)
// No bootable NTFS partition found
break;
bSize = BIOS_DEFAULT_SECTOR_SIZE;
#ifdef _PHYSICAL_DRIVE
StartSector = PTable->Entry[i].LBAStartSector;
#else
wsprintfW(TargetDrive, wszPartition, (i + 1));
StartSector = 0;
#endif
if (!ReadSectors(TargetDrive, Vbs, bSize, StartSector, 1))
// Reading failed
break;
Vbr = (PVBR)Vbs;
if (memcmp(&Vbr->VolumeOemId, NTFS_OEM_ID, sizeof(NTFS_OEM_ID)))
// Not a NTFS partition
break;
SectorSize = Vbr->Bpb.SectorSize;
ASSERT(SectorSize == BIOS_DEFAULT_SECTOR_SIZE);
bSize = (NTFS_LOADER_SIZE * SectorSize);
if (!(Loader = Alloc(bSize)))
// Not enough memory
break;
if (!ReadSectors(TargetDrive, Loader, bSize, (StartSector + 1), (NTFS_LOADER_SIZE - 1)))
// Reading failed
break;
if (!(i = GetCodeOffset(Loader)))
// Wrong or corrupt OS loader
break;
CodeSize = (NTFS_LOADER_SIZE - 1) * SectorSize - i;
PackedSize = ApPack((Loader + i), CodeSize, &Packed);
if (!PackedSize)
// Packing failed
break;
if (!BkCreateLoader(Loader + i, CodeSize, Packed, PackedSize, PayloadAddress))
// Failed to create loader
break;
if (WriteSectors(TargetDrive, Loader, bSize, (StartSector + 1), (NTFS_LOADER_SIZE - 1)))
Ret = TRUE;
} while(FALSE);
if (Vbs)
Free(Vbs);
if (Loader)
Free(Loader);
if (Packed)
Free(Packed);
return(Ret);
}
static BOOL BkInstallPayloadFromBuffer(
PCHAR Payload,
ULONG PayloadSize,
PCHSS PayloadAddress
)
{
BOOL Ret = FALSE;
PCHAR Vbs = NULL, Loader = NULL, Packed = NULL;
PVBR Vbr = NULL;
ULONG i, bSize = BIOS_DEFAULT_SECTOR_SIZE;
PPARTITION_TABLE PTable;
ULONG StartSector = 0, EndSector = 0, SectorSize = 0, PackedSize = 0;
PWCHAR TargetDrive = wszPhysicalDrive0;
PCHAR PayloadSectors = NULL;
ULONG PayloadSecSize;
ULONG RndSeed = GetTickCount();
DISK_GEOMETRY Dg = {0};
do // not a loop
{
if (!Payload || !PayloadAddress || !PayloadSize)
break;
if (!GetDriveGeometry(TargetDrive, &Dg))
break;
if (!(Vbs = Alloc(BIOS_DEFAULT_SECTOR_SIZE)))
// Not enough memory
break;
// Reading MBR sector
if (!ReadSectors(TargetDrive, Vbs, bSize, 0, 1))
// Reading failed
break;
// Check out we read a right one
if (*(PUSHORT)(Vbs + BIOS_DEFAULT_SECTOR_SIZE - sizeof(USHORT)) != BIOS_MBR_MAGIC)
// Wrong or corrupt sector loaded
break;
// Here we read the Driver Boot sector and searching for the Volume boot sector within it
PTable = (PPARTITION_TABLE)(Vbs + BIOS_PARTITION_TABLE_OFFSET);
// Calculating drive unpartitioned space
for (i=0; i<BIOS_MAX_PARTITION_COUNT; i++)
{
if (PTable->Entry[i].ActiveFlag & BIOS_PARTITION_ACTIVE_FLAG)
{
if (StartSector == 0 || StartSector > PTable->Entry[i].LBAStartSector)
StartSector = PTable->Entry[i].LBAStartSector;
if (EndSector < (PTable->Entry[i].LBAStartSector + PTable->Entry[i].PartitionSize))
EndSector = (PTable->Entry[i].LBAStartSector + PTable->Entry[i].PartitionSize);
}
} // for (i=0; i<BIOS_MAX_PARTITION_COUNT; i++)
PayloadSecSize = (PayloadSize + (Dg.BytesPerSector -1))/Dg.BytesPerSector;
if (((StartSector - 1)) > PayloadSecSize)
StartSector = 1 + RtlRandom(&RndSeed)%((StartSector - 1) - PayloadSecSize);
else
{
ULONG DriveLastSector = Dg.Cylinders.LowPart * Dg.TracksPerCylinder * Dg.SectorsPerTrack;
StartSector = DriveLastSector - PayloadSecSize - 2;
}
if (!(PayloadSectors = Alloc(PayloadSecSize * Dg.BytesPerSector)))
// Not enough memory
break;
memcpy(PayloadSectors, Payload, PayloadSize);
if (StartSector)
{
// Calculating Start sector CHSS address
PayloadAddress->StartSector.QuadPart = (ULONGLONG)StartSector;
PayloadAddress->NumberSectors = (USHORT)PayloadSecSize;
// Writing payload to the disk
Ret = WriteSectors(TargetDrive, PayloadSectors, (PayloadSecSize * Dg.BytesPerSector), StartSector, PayloadSecSize);
}
} while(FALSE);
if (Vbs)
Free(Vbs);
if (PayloadSectors)
Free(PayloadSectors);
return(Ret);
}
int MMCWriteSectors(BYTE bDevice, void *pData,
DWORD dwStartSector, WORD wSectorCount)
{
int nError;
WORD wWriteCount;
DRIVE *pDrive = 0;
BYTE *pByte;
nError = MMC_OK;
MMCLock();
if (bDevice >= MMC_MAX_SUPPORTED_DEVICE)
{
nError = MMC_DRIVE_NOT_FOUND;
}
else
{
pDrive = &sDrive[bDevice];
if ((dwStartSector + wSectorCount) > pDrive->dTotalSectors)
{
nError = MMC_PARAM_ERROR;
}
if ((pDrive->wFlags & MMC_READY) == 0)
{
nError = MMC_DRIVE_NOT_FOUND;
}
if (pDrive->wFlags & MMC_READ_ONLY)
{
nError = MMC_NOT_SUPPORTED;
}
}
if (nError == MMC_OK)
{
pByte = (BYTE *) pData;
while (wSectorCount > 0)
{
if (wSectorCount < 256)
{
wWriteCount = wSectorCount;
}
else
{
wWriteCount = 256;
}
nError = WriteSectors(pDrive, pByte, dwStartSector, wWriteCount);
if (nError != MMC_OK)
{
break;
}
dwStartSector += wWriteCount;
wSectorCount -= wWriteCount;
pByte += (wWriteCount * MMC_SECTOR_SIZE);
}
}
MMCFree();
return(nError);
} /* MMCWriteSectors */
void USB_Mode(void)
{
gb_cmd_timeout=0;
set_clock_mode(CLOCK_MODE_USB);
PowerOn_Init_USB();
Fill_EndpointDataTable_Into_ExRamBase();
USBInitialize();
Init_Flash_Reg();
Init_Flash_Variable();
gc_WriteProof = 0x00;
InitFlash();
USB_REG[0x27] = 0x00; // 080304 jay change for new fpga
GLOBAL_REG[0x17] = 0x01; // UDC O/P
IE = 0x83;
gdw_USB_CountDown = USB_DETECT_TIMEOUT;
EA=1;
while(!gc_USBRST_ISR_Detected) // Bulk_In_Out 將跳出while 迴圈 //20090630 chiayen modify
{
USB_PlugDetect();
if((--gdw_USB_CountDown==0)) //080925chiayen add
{
gb_cmd_timeout=1;
break;
}
if(!gbt_USB_Detected)
{
break;
}
}
EA=0;
if(gb_cmd_timeout==1) //080925chiayen modify
{
USB_DisConnect();
set_clock_mode(CLOCK_MODE_MP3);
InitFlash();
return;
}
if(!gb_cmd_timeout)
{
LCM_clear();
LCM_Disp_PC();
LCM_Disp_PCConnect();
LCM_Disp_MyMP3Logo();
}
for(;;)
{
USB_PlugDetect();
if(!gbt_USB_Detected)
{//usb connected
USB_DisConnect();
set_clock_mode(CLOCK_MODE_MP3);
InitFlash();
break;
}
else
{
if (gc_USBStage == CBWStage)
{
if(gbt_USB_Connect_Flag)
{
//tdw_CMD_In_Count =0x02FFFFF;
}
else
{
gdw_USB_CountDown =0x01FFFF; //081208 detect charge first
}
EA=1;
while (!gbt_USB_CMD_IN) // Bulk_In_Out 將跳出while 迴圈
{
USB_PlugDetect();
if(!gbt_USB_Detected)
{
break;
}
if(gbt_USB_Connect_Flag)
{
if(gbt_USER_Remove_Flag)
{
gb_cmd_timeout=1;
break;
}
}
else
{
if((--gdw_USB_CountDown==0)&&(!gb_USB_ISR_Detected))
{
gb_cmd_timeout=1;
break;
}
}
}
EA=0; // 表示有 SCSI CMD 進入 關閉中斷避免常常進入
if((!gbt_USB_Detected)||(gb_cmd_timeout==1)) //080925chiayen modify
{
USB_DisConnect();
set_clock_mode(CLOCK_MODE_MP3);
InitFlash();
break;
}
gbt_USB_CMD_IN = 0;
SD_Card_Detect();
gbt_USB_Connect_Flag =1; // 081208 jay add
Save_CBW_Packet();
Decode_CBW_Command(); // 解CBW和記錄相關手續
}
if(gw_USBDisplayTime==0)
{
USB_Mode_Disp();
}
if (gc_USBStage == BulkInReadSectorsStage)
{
USB_REG[0xD2] &= 0xDD; //Disable Bulk-Out中斷
ReadSectors();
USB_REG[0xE9] = 0x11;
if (gc_ErrorCode == SET_ABRT)
{
gc_RequestSenseCode = 0x06; //ECC Error
gdw_dCBW_DataXferLength.LW = ((LWORD)TotalXferPageNum.WD) << 9;
gc_bCSWStatus = 0x01;
}
else if (gc_ErrorCode == ID_NOT_FND)
{
gc_RequestSenseCode = 0x07; //over range
gdw_dCBW_DataXferLength.LW = ((LWORD)TotalXferPageNum.WD) << 9;
gc_bCSWStatus = 0x01;
}
else
{
gdw_dCBW_DataXferLength.LW = 0;
}
gc_USBStage = CSWStage; // 進入Comand Status Wrapper
}
if (gc_USBStage == BulkOutWriteSectorsStage)
{
USB_REG[0xD2] &= 0xDD; //Disable Bulk-Out中斷
USB_REG[0x11] = 0x01; //HW auto ACK
WriteSectors();
USB_REG[0x11] = 0x00;
USB_REG[0xE9] = 0x22;
if (gc_ErrorCode == SET_ABRT)
{
gc_bCSWStatus = 0x01;
gc_RequestSenseCode = 0x08; // write error
}
else if (gc_ErrorCode == ID_NOT_FND)
{
gc_RequestSenseCode = 0x07; //over range
gc_bCSWStatus = 0x01;
}
else
{
gc_bCSWStatus = 0x00;
gc_RequestSenseCode = 0xFF; // normal
}
gdw_dCBW_DataXferLength.LW = 0;
gc_USBStage = CSWStage;
}
if (gc_USBStage == BulkInResponseStage)
{ // '4' BulkInProcess
USB_REG[0xD2] &= 0xDD; //Disable Bulk-Out中斷
if (gbt_XferNormalResponseData_or_ModeSense)
{ // '1':Normal
if (COMD_IN[0] == 0x23)
{
gdw_dCBW_DataXferLength.WD[1] = 0x00;
USB_REG[0x16] = 0x00;
USB_REG[0x15] = 0x0C;
USB_REG[0xA1] |= 0x01;
while (USB_REG[0xA1] & 0x01)
{
USB_PlugDetect(); // 081014 Jay add for usb plug out
if(!gbt_USB_Detected) break;
}
USB_REG[0xE9] = 0x01;
}
else
{
while (gdw_dCBW_DataXferLength.WD[1])
{
if (gdw_dCBW_DataXferLength.WD[1] > 64)
{
gdw_dCBW_DataXferLength.WD[1] = gdw_dCBW_DataXferLength.WD[1] - 64;
USB_REG[0x16] = 0x00;
USB_REG[0x15] = 0x40;
}
else
{
USB_REG[0x16] = gdw_dCBW_DataXferLength.BY[2] & 0x0F;
USB_REG[0x15] = gdw_dCBW_DataXferLength.BY[3];
gdw_dCBW_DataXferLength.WD[1] = 0x00;
}
USB_REG[0xA1] |= 0x01;
while (USB_REG[0xA1] & 0x01)
{ //081014 Jay add for usb plug out
USB_PlugDetect();
if(!gbt_USB_Detected) break;
}
USB_REG[0xE9] = 0x01;
}
}
}
else
{
if (COMD_IN[0] == 0x1A)
{
gdw_dCBW_DataXferLength.WD[1] = 0x00;
USB_REG[0x15] = 0x04;
USB_REG[0x16] = 0x00;
USB_REG[0xA1] |= 0x01;
while (USB_REG[0xA1] & 0x01)
{ //081014 Jay add for usb plug out
USB_PlugDetect();
if(!gbt_USB_Detected) break;
}
USB_REG[0xE9] = 0x01;
}
else
{
gdw_dCBW_DataXferLength.WD[1] = 0x00;
USB_REG[0x15] = 0x08;
USB_REG[0x16] = 0x00;
USB_REG[0xA1] |= 0x01;
while (USB_REG[0xA1] & 0x01)
{ //081014 Jay add for usb plug out
USB_PlugDetect();
if(!gbt_USB_Detected) break;
}
USB_REG[0xE9] = 0x01;
}
gbt_XferNormalResponseData_or_ModeSense = NormalResponseData;// 將預設設為一般型
}
gc_USBStage = CSWStage;
}
if (gc_USBStage == BulkStallStage)
{
StallBulkRW();
gc_USBStage = CSWStage;
}
if (gc_USBStage == BulkInReadBufferStage)
{
USB_REG[0xD2] &= 0xDD; //Disable Bulk-Out中斷
NoCard_ReadSectors();
USB_REG[0xE9] = 0x11;
gdw_dCBW_DataXferLength.LW = 0;
gc_USBStage = CSWStage; // 進入Comand Status Wrapper
}
if (gc_USBStage == BulkOutWriteBufferStage)
{
USB_REG[0xD2] &= 0xDD; //Disable Bulk-Out中斷
USB_REG[0x11] = 0x01; //HW auto ACK
NoCard_WriteSectors();
USB_REG[0x11] = 0x00;
USB_REG[0xE9] = 0x22;
gdw_dCBW_DataXferLength.LW = 0;
gc_USBStage = CSWStage;
}
if (gc_USBStage == CSWStage)
{
gc_USBStage = CBWStage; // 重新準備收下一筆command
USB_BUF_Bank0[ 0] = 'U'; // 以下由SetCSWData expand
USB_BUF_Bank0[ 1] = 'S';
USB_BUF_Bank0[ 2] = 'B';
USB_BUF_Bank0[ 3] = 'S';
USB_BUF_Bank0[ 4] = dCBW_Tag[0];
USB_BUF_Bank0[ 5] = dCBW_Tag[1];
USB_BUF_Bank0[ 6] = dCBW_Tag[2];
USB_BUF_Bank0[ 7] = dCBW_Tag[3];
USB_BUF_Bank0[ 8] = gdw_dCBW_DataXferLength.BY[3]; // LSB 記錄剩下未被傳輸的資料
USB_BUF_Bank0[ 9] = gdw_dCBW_DataXferLength.BY[2]; // 記錄剩下未被傳輸的資料
USB_BUF_Bank0[10] = gdw_dCBW_DataXferLength.BY[1]; // 記錄剩下未被傳輸的資料
USB_BUF_Bank0[11] = gdw_dCBW_DataXferLength.BY[0]; // MSB 記錄剩下未被傳輸的資料
USB_BUF_Bank0[12] = gc_bCSWStatus; // Command Status 見BulkOnly P.15說明各種碼的情形
USB_REG[0x2B] = 0x00;
USB_REG[0x16] = 0x00;
USB_REG[0x15] = 0x0D;
USB_REG[0xA1] |= 0x01;
while (USB_REG[0xA1] & 0x01)
{ //081014 Jay add for usb plug out
USB_PlugDetect();
if(!gbt_USB_Detected) break;
}
}
USB_REG[0xE9] = 0x01;
USB_REG[0xD2] |= 0x02; //Enable Bulk-Out中斷
USB_REG[0xA1] |= 0x02; //下一筆31Byte Bulk-Out
}
}
}
int highlevelformat(void * DriveData, UINT BaseSectorNumber)
{
int FATType;
int SystemSectors,
RootDirSectors,
FATSectors,
Written;
int FatCount,
StartOfFAT,
InfoSector;
int i, y;
FS_BootRecord *PBR;
kal_uint8 MediaDescriptor;
int Result = RTF_NO_ERROR;
/* HLF - 1 - Read the PBR sector */
///* FIXME */ DrvDirect.ReadSector(SectorBuffer /* Buffer */ ,
// BaseSectorNumber /* Sector Number */);
ReadSectors(DriveData, BaseSectorNumber, 1, MSDC_Sector);
PBR = (FS_BootRecord*)&MSDC_Sector;
/* HLF - 2 - Setup PBR sector content and attributes */
{
if (PBR->BP.SectorsOnDisk != 0)
PBR->BP.TotalSectors = PBR->BP.SectorsOnDisk;
if (PBR->Signature != 0xAA55 ||
//PBR->BP.TotalSectors > Par.Partition.Sectors ||
PBR->BP.TotalSectors > (gSD->mCSD.capacity/512) ||
PBR->BP.BytesPerSector != 512 ||
PBR->BP.SectorsPerCluster == 0 ||
PBR->BP.ReservedSectors == 0 ||
PBR->BP.NumberOfFATs == 0)
{
return FS_INVALID_FILE_SYSTEM;
}
FATSectors = (PBR->BP.SectorsPerFAT) ? PBR->BP.SectorsPerFAT : PBR->BP.E._32.SectorsPerFAT;
RootDirSectors = (PBR->BP.DirEntries * 32 + (PBR->BP.BytesPerSector - 1)) / PBR->BP.BytesPerSector;
Written = PBR->BP.TotalSectors
- PBR->BP.ReservedSectors
- PBR->BP.NumberOfFATs * FATSectors
- RootDirSectors;
Written = Written / PBR->BP.SectorsPerCluster;
if (Written <= 0xFF4L) FATType = 12;
else if (Written <= 0xFFF4l) FATType = 16;
else if (Written <= 0xFFFFFF4l) FATType = 32;
else return FS_INVALID_FILE_SYSTEM;
Written = 0;
if (FATType == 32)
{
RootDirSectors = PBR->BP.SectorsPerCluster;
if (PBR->BP.E._32.RootDirCluster != 2)
{
PBR->BP.E._32.RootDirCluster = 2;
/*
Result = RTFSeek(Drive, 0, RTF_FILE_BEGIN);
if (Result < RTF_NO_ERROR) return Result;
Result = RTFWrite(Drive, (void*)PBR, SECTOR_SIZE, NULL);
if (Result < RTF_NO_ERROR) return Result;
*/
//above seek and write seems mean write to specific sector
WriteSectors(DriveData, BaseSectorNumber , 1, (void *)PBR);
/*
Result = RTFSeek(Drive, PBR->BP.E._32.BackupBootSector * SECTOR_SIZE, RTF_FILE_BEGIN);
if (Result < RTF_NO_ERROR) return Result;
Result = RTFWrite(Drive, (void*)PBR, SECTOR_SIZE, NULL);
if (Result < RTF_NO_ERROR) return Result;
*/
WriteSectors(DriveData, BaseSectorNumber + PBR->BP.E._32.BackupBootSector , 1, (void *)PBR);
}
}
SystemSectors = PBR->BP.ReservedSectors
+ PBR->BP.NumberOfFATs * FATSectors
+ RootDirSectors;
FatCount = PBR->BP.NumberOfFATs;
StartOfFAT = PBR->BP.ReservedSectors;
InfoSector = PBR->BP.E._32.FSInfoSector;
}
/*we get MediaDescriptor for step 6 usage, since we will clear MSDC_Sector*/
MediaDescriptor = PBR->BP.MediaDescriptor;
/*we need MSDC_Sector to be 512-byte-0 now*/
kal_mem_set(MSDC_Sector, 0, 512);
/* HLF - 3 - Formating cont, FAT32 reserved sector write down */
{
if ((FATType == 32) && (InfoSector > 0) && (InfoSector < StartOfFAT))
{
/* FIXME */
//DrvDirect.ZeroSector( BaseSectorNumber + InfoSector /* Start Sector Number */ ,
// 1 /* Zero Sector Count */ );
WriteSectors(DriveData, BaseSectorNumber + InfoSector, 1, MSDC_Sector);
}
}
SD_startFastFormat();
/* HLF - 4 - Formating cont, start, FAT Table write down , remember FAT begin sector */
{
/* FIXME */
//DrvDirect.ZeroSector( BaseSectorNumber + StartOfFAT /* Start Sector Number */ ,
// FATSectors * FatCount /* Zero Sector Count */ );
#ifdef DRV_LSD
WriteSectors(DriveData, BaseSectorNumber + StartOfFAT, FATSectors * FatCount , MSDC_Sector);
#else
for(i = 0; i < FATSectors * FatCount; i++) {
WriteSectors(DriveData, BaseSectorNumber + StartOfFAT + i, 1 , MSDC_Sector);
}
#endif
}
/* HLF - 5 - Formating cont, Root directory write down */
{
int x;
x = StartOfFAT + FATSectors * FatCount;
/* FIXME */
//DrvDirect.ZeroSector( BaseSectorNumber + x /* Start Sector Number */ ,
// RootDirSectors /* Zero Sector Count */ );
#ifdef DRV_LSD
WriteSectors(DriveData, BaseSectorNumber + x, RootDirSectors , MSDC_Sector);
#else
for(i = 0; i < RootDirSectors; i++) {
WriteSectors(DriveData, BaseSectorNumber + x + i, 1 , MSDC_Sector);
}
#endif
}
SD_closeFastFormat();
/* HLF - 6 - Formating final, 1st FAT sector must be rewritten */
{
switch (FATType)
{
case 32:
{
//kal_uint32 * FPtr = (void*) ScratchSector;
MSDC_Sector[2] = 0x0FFFFFFF; // this is for the root dir
MSDC_Sector[1] = 0x0FFFFFFF;
break;
}
case 16:
{
kal_uint16 * FPtr = (void*) MSDC_Sector;
FPtr[1] = 0xFFFF;
break;
}
case 12:
{
kal_uint8 *FPtr = (void *)MSDC_Sector;
/* FIXME */ FPtr[2] = 0xFF;
/* FIXME */ FPtr[1] = 0xFF;
/* FIXME */ FPtr[0] = MediaDescriptor;
break;
}
}
for (i = 0, y = StartOfFAT;
i < FatCount;
i++ , y+= FATSectors)
{
///* FIXME */ DrvDirect.WriteSector(SectorBuffer /* Buffer */ ,
// BaseSectorNumber + y /* Sector Number */);
WriteSectors(DriveData, BaseSectorNumber + y, 1 , MSDC_Sector);
}
}
/* HLF - 7 - The END */
return FS_NO_ERROR;
}