📄 sddevinf.cpp
字号:
/****** Date : 07.05.14 ******/
/****** Developer : HS.JANG ******/
/****** Description : Get CSD Spec version Info to know card type ******/
/*************************************************************************/
pParsedCSD->SpecVersion= (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_SPEC_VERSION_BIT_SLICE,
SD_CSD_SPEC_VERSION_SLICE_SIZE);
/*************************************************************************/
#endif
// check the CSD version code
if (Device_SD_Memory == m_DeviceType) {
if (pParsedCSD->CSDVersion > (SD_CSD_VERSION_CODE_SUPPORTED)) {
DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDCardInfoQuery: SD CSD version : %d currently not supported \n"),pParsedCSD->CSDVersion));
DEBUGCHK(FALSE);
return SD_API_STATUS_DEVICE_UNSUPPORTED;
}
} else if (Device_MMC == m_DeviceType) {
// remove MMC CSD version check. To do this, we would allow MMC v4.x card to be able
// to operate as V3.1 card in 1 bit mode.
// if (pParsedCSD->CSDVersion > MMC_CSD_VERSION_CODE_SUPPORTED) {
// DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDCardInfoQuery: MMC CSD version : %d currently not supported \n"),pParsedCSD->CSDVersion));
// DEBUGCHK(FALSE);
// return SD_API_STATUS_DEVICE_UNSUPPORTED;
// }
#ifdef _MMC_SPEC_42_
/*************************************************************************/
/****** Date : 07.05.14 ******/
/****** Developer : HS.JANG ******/
/****** Description : If MMC card is HSMMC, should check whether it ******/
/****** is bigger than Spec 4.2 or not ******/
/*************************************************************************/
if (pParsedCSD->SpecVersion >= HSMMC_CSD_SPEC_VERSION_CODE_SUPPORTED)
{
MMC_PARSED_REGISTER_EXTCSD temp;
m_dwMMCSpecVer = Device_HSMMC40;
memcpy(&temp,m_ucEXTCSD,MMC_EXTCSD_REGISTER_SIZE);
if ( temp.Sec_Count > 0 )
{
SD_COMMAND_RESPONSE response; // response
SD_API_STATUS status = SD_API_STATUS_SUCCESS;
pParsedCSD->SectorCount = temp.Sec_Count;
// if the MMC card is on SPEC42, Block Length must be 512Byte.
status = SendSDCommand( SD_CMD_SET_BLOCKLEN ,
((DWORD)512),
ResponseR1,
&response);
if (!SD_API_SUCCESS(status))
{
RETAILMSG(1,(TEXT("[SDBUS] SD_CMD_SET_BLOCKLEN is FAILED!\n")));
}
}
}
/*************************************************************************/
#endif
} else {
DEBUGCHK(FALSE);
return SD_API_STATUS_INVALID_PARAMETER;
}
// get the value
value = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_TAAC_BIT_SLICE,
SD_CSD_TAAC_SLICE_SIZE);
// extract the time units
unit = value & SD_CSD_TAAC_UNIT_MASK;
// get the timee value into position
value = (value & SD_CSD_TAAC_VALUE_MASK) >> SD_CSD_TAAC_VALUE_SHIFT;
switch( value ) {
case 1: pParsedCSD->DataAccessTime.TAAC = 1.0; break;
case 2: pParsedCSD->DataAccessTime.TAAC = 1.2; break;
case 3: pParsedCSD->DataAccessTime.TAAC = 1.3; break;
case 4: pParsedCSD->DataAccessTime.TAAC = 1.5; break;
case 5: pParsedCSD->DataAccessTime.TAAC = 2.0; break;
case 6: pParsedCSD->DataAccessTime.TAAC = 2.5; break;
case 7: pParsedCSD->DataAccessTime.TAAC = 3.0; break;
case 8: pParsedCSD->DataAccessTime.TAAC = 3.5; break;
case 9: pParsedCSD->DataAccessTime.TAAC = 4.0; break;
case 10: pParsedCSD->DataAccessTime.TAAC = 4.5; break;
case 11: pParsedCSD->DataAccessTime.TAAC = 5.0; break;
case 12: pParsedCSD->DataAccessTime.TAAC = 5.5; break;
case 13: pParsedCSD->DataAccessTime.TAAC = 6.0; break;
case 14: pParsedCSD->DataAccessTime.TAAC = 7.0; break;
case 15: pParsedCSD->DataAccessTime.TAAC = 8.0; break;
default: pParsedCSD->DataAccessTime.TAAC = 0.0; break;
};
for( ; unit; unit-- ) {
pParsedCSD->DataAccessTime.TAAC *= 10;
}
pParsedCSD->DataAccessTime.NSAC = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_NSAC_BIT_SLICE,
SD_CSD_NSAC_SLICE_SIZE);
// Calculate transfer rate in kbit/s
value = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_TRANS_SPEED_BIT_SLICE,
SD_CSD_TRANS_SPEED_SLICE_SIZE);
unit = value & SD_CSD_TRANS_SPEED_UNIT_MASK;
// get value bits into position
value = (value & SD_CSD_TRANS_SPEED_VALUE_MASK) >> SD_CSD_TRANS_SPEED_VALUE_SHIFT;
switch( value ) {
case 1: pParsedCSD->MaxDataTransferRate = 100; break;
case 2: pParsedCSD->MaxDataTransferRate = 120; break;
case 3: pParsedCSD->MaxDataTransferRate = 130; break;
case 4: pParsedCSD->MaxDataTransferRate = 150; break;
case 5: pParsedCSD->MaxDataTransferRate = 200; break;
case 6: pParsedCSD->MaxDataTransferRate = 250; break;
case 7: pParsedCSD->MaxDataTransferRate = 300; break;
case 8: pParsedCSD->MaxDataTransferRate = 350; break;
case 9: pParsedCSD->MaxDataTransferRate = 400; break;
case 10: pParsedCSD->MaxDataTransferRate = 450; break;
case 11: pParsedCSD->MaxDataTransferRate = 500; break;
case 12: pParsedCSD->MaxDataTransferRate = 550; break;
case 13: pParsedCSD->MaxDataTransferRate = 600; break;
case 14: pParsedCSD->MaxDataTransferRate = 700; break;
case 15: pParsedCSD->MaxDataTransferRate = 800; break;
default: pParsedCSD->MaxDataTransferRate = 0; break;
};
for( ; unit; unit-- )
pParsedCSD->MaxDataTransferRate *= 10;
pParsedCSD->CardCommandClasses = (USHORT)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_CCC_BIT_SLICE,
SD_CSD_CCC_SLICE_SIZE);
rblLength = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD, SD_CSD_READ_BL_LEN_BIT_SLICE,
SD_CSD_READ_BL_LEN_SLICE_SIZE);
DEBUG_CHECK((rblLength < 12), (TEXT("SDCardInfoQuery - Read Block Length %d is invalid \n"),rblLength));
// Read Block Length
pParsedCSD->MaxReadBlockLength = 1 << rblLength;
// Write Block Length
pParsedCSD->MaxWriteBlockLength = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_WRITE_BL_LEN_BIT_SLICE,
SD_CSD_WRITE_BL_LEN_SLICE_SIZE);
DEBUG_CHECK((pParsedCSD->MaxWriteBlockLength < 12), (TEXT("SDCardInfoQuery - Write Block Length Length %d is invalid \n"),
pParsedCSD->MaxWriteBlockLength));
pParsedCSD->MaxWriteBlockLength = 1 << pParsedCSD->MaxWriteBlockLength;
pParsedCSD->ReadBlockPartial = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_READ_BL_PARTIAL_BIT_SLICE,
SD_CSD_READ_BL_PARTIAL_SLICE_SIZE)
? TRUE:FALSE;
pParsedCSD->WriteBlockPartial = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_WRITE_BL_PARTIAL_BIT_SLICE,
SD_CSD_WRITE_BL_PARTIAL_SLICE_SIZE)
? TRUE:FALSE;
// Read/Write Block Misalign
pParsedCSD->WriteBlockMisalign = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_WRITE_BL_MISALIGN_BIT_SLICE,
SD_CSD_WRITE_BL_MISALIGN_SLICE_SIZE)
? TRUE:FALSE;
pParsedCSD->ReadBlockMisalign = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_READ_BL_MISALIGN_BIT_SLICE,
SD_CSD_READ_BL_MISALIGN_SLICE_SIZE)
? TRUE:FALSE;
// DSR Implemented
pParsedCSD->DSRImplemented = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_DSR_IMP_BIT_SLICE,
SD_CSD_DSR_IMP_SLICE_SIZE)
? TRUE:FALSE;
// Write Protect Group Enabled
pParsedCSD->WPGroupEnable = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_WP_GRP_ENABLE_BIT_SLICE,
SD_CSD_WP_GRP_ENABLE_SLICE_SIZE)
? TRUE:FALSE;
// Copy Flag
pParsedCSD->CopyFlag = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_COPY_FLAG_BIT_SLICE,
SD_CSD_COPY_FLAG_SLICE_SIZE)
? TRUE:FALSE;
// Permanent Write Protect
pParsedCSD->PermanentWP = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_PERM_WR_PROT_BIT_SLICE,
SD_CSD_PERM_WR_PROT_SLICE_SIZE)
? TRUE:FALSE;
// Temporary Write Protect
pParsedCSD->TemporaryWP = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_TEMP_WR_PROT_BIT_SLICE,
SD_CSD_TEMP_WR_PROT_SLICE_SIZE)
? TRUE:FALSE;
// Calculate the device size as per SD Spec
cSize = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_CSIZE_BIT_SLICE,
SD_CSD_CSIZE_SLICE_SIZE);
cSizeMult = GET_BIT_SLICE_FROM_CSD(pCSD,
SD_CSD_CSIZE_MULT_BIT_SLICE,
SD_CSD_CSIZE_MULT_SLICE_SIZE);
DEBUG_CHECK((cSizeMult < 8), (TEXT("SDCardInfoQuery - C_SIZE %d is invalid \n"),cSizeMult));
// Perform actual device size calculation
pParsedCSD->DeviceSize = pParsedCSD->MaxReadBlockLength * ((cSize+1) * (1<<(cSizeMult+2)));
m_SDCardInfo.SDMMCInformation.ullDeviceSize = pParsedCSD->DeviceSize;
// VDD Read Current Minimum
pParsedCSD->VDDReadCurrentMin = (USHORT)GET_BIT_SLICE_FROM_CSD(pCSD, SD_CSD_R_CURR_MIN_BIT_SLICE,
SD_CSD_R_CURR_MIN_SLICE_SIZE);
switch( pParsedCSD->VDDReadCurrentMin ) {
case 0: pParsedCSD->VDDReadCurrentMin = 1; break;
case 1: pParsedCSD->VDDReadCurrentMin = 1; break;
case 2: pParsedCSD->VDDReadCurrentMin = 5; break;
case 3: pParsedCSD->VDDReadCurrentMin = 10; break;
case 4: pParsedCSD->VDDReadCurrentMin = 25; break;
case 5: pParsedCSD->VDDReadCurrentMin = 35; break;
case 6: pParsedCSD->VDDReadCurrentMin = 60; break;
case 7: pParsedCSD->VDDReadCurrentMin = 100; break;
default: pParsedCSD->VDDReadCurrentMin = 0; break;
}
// VDD Write Current Minimum
pParsedCSD->VDDWriteCurrentMin = (USHORT)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_W_CURR_MIN_BIT_SLICE,
SD_CSD_W_CURR_MIN_SLICE_SIZE);
switch( pParsedCSD->VDDWriteCurrentMin ) {
case 0: pParsedCSD->VDDWriteCurrentMin = 1; break;
case 1: pParsedCSD->VDDWriteCurrentMin = 1; break;
case 2: pParsedCSD->VDDWriteCurrentMin = 5; break;
case 3: pParsedCSD->VDDWriteCurrentMin = 10; break;
case 4: pParsedCSD->VDDWriteCurrentMin = 25; break;
case 5: pParsedCSD->VDDWriteCurrentMin = 35; break;
case 6: pParsedCSD->VDDWriteCurrentMin = 60; break;
case 7: pParsedCSD->VDDWriteCurrentMin = 100; break;
default: pParsedCSD->VDDWriteCurrentMin = 0; break;
}
// VDD Read Current Maximum
pParsedCSD->VDDReadCurrentMax = (USHORT)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_R_CURR_MAX_BIT_SLICE,
SD_CSD_R_CURR_MAX_SLICE_SIZE);
switch( pParsedCSD->VDDReadCurrentMax ) {
case 0: pParsedCSD->VDDReadCurrentMax = 1; break;
case 1: pParsedCSD->VDDReadCurrentMax = 5; break;
case 2: pParsedCSD->VDDReadCurrentMax = 10; break;
case 3: pParsedCSD->VDDReadCurrentMax = 25; break;
case 4: pParsedCSD->VDDReadCurrentMax = 35; break;
case 5: pParsedCSD->VDDReadCurrentMax = 45; break;
case 6: pParsedCSD->VDDReadCurrentMax = 80; break;
case 7: pParsedCSD->VDDReadCurrentMax = 200; break;
default: pParsedCSD->VDDReadCurrentMax = 0; break;
}
// VDD Write Current Maximum
pParsedCSD->VDDWriteCurrentMax = (USHORT)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_W_CURR_MAX_BIT_SLICE,
SD_CSD_W_CURR_MAX_SLICE_SIZE);
switch( pParsedCSD->VDDWriteCurrentMax ) {
case 0: pParsedCSD->VDDWriteCurrentMax = 1; break;
case 1: pParsedCSD->VDDWriteCurrentMax = 5; break;
case 2: pParsedCSD->VDDWriteCurrentMax = 10; break;
case 3: pParsedCSD->VDDWriteCurrentMax = 25; break;
case 4: pParsedCSD->VDDWriteCurrentMax = 35; break;
case 5: pParsedCSD->VDDWriteCurrentMax = 45; break;
case 6: pParsedCSD->VDDWriteCurrentMax = 80; break;
case 7: pParsedCSD->VDDWriteCurrentMax = 200; break;
default: pParsedCSD->VDDWriteCurrentMax = 0; break;
}
pParsedCSD->WriteSpeedFactor = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_R2W_FACTOR_BIT_SLICE,
SD_CSD_R2W_FACTOR_SLICE_SIZE);
// For CSD Version 2.0 above is wrong the following code correct them.
if (Device_SD_Memory == m_DeviceType && pParsedCSD->CSDVersion == SD_CSD_VERSION_CODE_2_0 ) {
// SD Physical Layer Spec(2.0) 5.3.3
ASSERT(pParsedCSD->MaxReadBlockLength==0x200);
ASSERT(pParsedCSD->MaxWriteBlockLength==0x200);
// THis field no long exist in SD Memory 2.0 So we made them up.
pParsedCSD->VDDReadCurrentMin = 0;
pParsedCSD->VDDWriteCurrentMin = 0;
pParsedCSD->VDDReadCurrentMax = 200;
pParsedCSD->VDDWriteCurrentMax = 200 ;
// C_SIZE is different from 1.0.
m_SDCardInfo.SDMMCInformation.ullDeviceSize = (ULONGLONG)GET_BIT_SLICE_FROM_CSD(pCSD, SD_CSD20_CSIZE_BIT_SLICE, SD_CSD20_CSIZE_SLICE_SIZE)
*0x200*0x400;
// We had no choic but provide low portion of value for BC. The Full value can get from Card Extention function.
pParsedCSD->DeviceSize = (ULONG)(m_SDCardInfo.SDMMCInformation.ullDeviceSize/0x200); // return as block size.
}
pParsedCSD->WriteSpeedFactor = 1 << pParsedCSD->WriteSpeedFactor;
fileFormatGroup = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_FILE_GROUP_BIT_SLICE,
SD_CSD_FILE_GROUP_SLICE_SIZE);
fileFormat = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_FILE_FORMAT_BIT_SLICE,
SD_CSD_FILE_FORMAT_SLICE_SIZE);
if( fileFormatGroup == 0 ) {
switch( fileFormat ) {
case 0: pParsedCSD->FileSystem = SD_FS_FAT_PARTITION_TABLE; break;
case 1: pParsedCSD->FileSystem = SD_FS_FAT_NO_PARTITION_TABLE; break;
case 2: pParsedCSD->FileSystem = SD_FS_UNIVERSAL; break;
default: pParsedCSD->FileSystem = SD_FS_OTHER; break;
}
} else {
pParsedCSD->FileSystem = SD_FS_OTHER;
}
// For MMC cards the WP Group Size is now 5 bits rather than 7, Erase sector size
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -