📄 sdbusrequest.cpp
字号:
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)));
// 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);
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
// is calculated from 2 5bit fields. Erase block enable does not exist for MMC cards.
if( pDevice->DeviceType == Device_MMC ) {
UCHAR eraseGroupSize, eraseGroupMult;
// Set EraseBlockEnable to FALSE
pParsedCSD->EraseBlockEnable = FALSE;
// Calculate Erase Sector Size from the Erase Group Size and
// Erase Group Mult fields
eraseGroupSize = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,MMC_CSD_ER_GRP_SIZE_BIT_SLICE,
MMC_CSD_ER_GRP_SIZE_SLICE_SIZE);
eraseGroupMult = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,MMC_CSD_ER_GRP_MULT_BIT_SLICE,
MMC_CSD_ER_GRP_MULT_SLICE_SIZE);
pParsedCSD->EraseSectorSize = (eraseGroupSize+1)*(eraseGroupMult+1);
pParsedCSD->WPGroupSize = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,MMC_CSD_WP_GROUP_SIZE_BIT_SLICE,
MMC_CSD_WP_GROUP_SIZE_SLICE_SIZE);
pParsedCSD->WPGroupSize++;
} else {
// Erase by block size enabled
pParsedCSD->EraseBlockEnable = GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_ERASE_BL_ENABLE_BIT_SLICE,
SD_CSD_ERASE_BL_ENABLE_SLICE_SIZE)
? TRUE:FALSE;
// Erase Sector Size
pParsedCSD->EraseSectorSize = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_ERASE_SECT_SIZE_BIT_SLICE,
SD_CSD_ERASE_SECT_SIZE_SLICE_SIZE);
pParsedCSD->EraseSectorSize++;
// Write Protect Group Size
pParsedCSD->WPGroupSize = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_WP_GROUP_SIZE_BIT_SLICE,
SD_CSD_WP_GROUP_SIZE_SLICE_SIZE);
pParsedCSD->WPGroupSize++;
}
memcpy(pParsedCSD->RawCSDRegister, pDevice->CachedRegisters.CSD, SD_CSD_REGISTER_SIZE );
DumpParsedCSDRegisters(pParsedCSD);
return SD_API_STATUS_SUCCESS;
}
static
SD_API_STATUS InfoQueryRCA(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
DEBUGCHK(pDevice);
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_CARD_RCA));
memcpy(pCardInfo, &pDevice->RelativeAddress, sizeof(SD_CARD_RCA));
return SD_API_STATUS_SUCCESS;
}
static
SD_API_STATUS InfoQueryCardInterface(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
DEBUGCHK(pDevice);
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_CARD_INTERFACE));
memcpy(pCardInfo, &pDevice->CardInterface, sizeof(SD_CARD_INTERFACE));
return SD_API_STATUS_SUCCESS;
}
static
SD_API_STATUS InfoQueryStatus(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
DEBUGCHK(pDevice);
DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_CARD_STATUS));
// get the card status
return GetCardStatus((SD_DEVICE_HANDLE) pDevice,
(SD_CARD_STATUS *)pCardInfo);
}
static
SD_API_STATUS InfoQuerySDIOInfo(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
PREFAST_DEBUGCHK(pDevice);
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SDIO_CARD_INFO));
if (Device_SD_IO != pDevice->DeviceType) {
return SD_API_STATUS_INVALID_PARAMETER;
}
((PSDIO_CARD_INFO)pCardInfo)->FunctionNumber = pDevice->SDCardInfo.SDIOInformation.Function;
((PSDIO_CARD_INFO)pCardInfo)->DeviceCode = pDevice->SDCardInfo.SDIOInformation.DeviceCode;
((PSDIO_CARD_INFO)pCardInfo)->CISPointer = pDevice->SDCardInfo.SDIOInformation.CISPointer;
((PSDIO_CARD_INFO)pCardInfo)->CSAPointer = pDevice->SDCardInfo.SDIOInformation.CSAPointer;
DEBUGCHK(pDevice->pParentDevice != NULL);
DEBUGCHK(pDevice->pParentDevice->SDCardInfo.SDIOInformation.pCommonInformation != NULL);
((PSDIO_CARD_INFO)pCardInfo)->CardCapability =
pDevice->pParentDevice->SDCardInfo.SDIOInformation.pCommonInformation->CardCapability;
return SD_API_STATUS_SUCCESS;
}
static
SD_API_STATUS InfoQueryHostInterface(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
PREFAST_DEBUGCHK(pDevice);
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_CARD_INTERFACE));
PSD_CARD_INTERFACE pCardCapabilities = (PSD_CARD_INTERFACE)pCardInfo;
// fetch the max clock rate
pCardCapabilities->ClockRate = pDevice->pSlot->MaxClockRate;
// work out the best interface the HC can provide
if( pDevice->pSlot->Capabilities & SD_SLOT_SD_4BIT_CAPABLE ) {
pCardCapabilities->InterfaceMode = SD_INTERFACE_SD_4BIT;
} else {
pCardCapabilities->InterfaceMode = SD_INTERFACE_SD_MMC_1BIT;
}
// write protect is meaningless for a capability query, set to FALSE
pCardCapabilities->WriteProtected = FALSE;
return SD_API_STATUS_SUCCESS;
}
static
SD_API_STATUS InfoQueryBlockCaps(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
DEBUGCHK(pDevice);
DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_HOST_BLOCK_CAPABILITY));
// send the requested block transfer size to the HC, if the HC is
// unable to support the requested block size it will return the
// next supported block size smaller than that requested
return pDevice->pSlot->pHostController->pSlotOptionHandler(
pDevice->pSlot->pHostController,
pDevice->pSlot->SlotIndex,
SDHCDQueryBlockCapability,
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -