📄 sdbusrequest.cpp
字号:
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Write Protect Group Enabled? %d \n"),pParsedCSD->WPGroupEnable));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Write Group Protect Size: %d blocks \n"),pParsedCSD->WPGroupSize));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Write Speed Factor: %d blocks \n"),pParsedCSD->WriteSpeedFactor));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Copy Flag?: %d \n"),pParsedCSD->CopyFlag));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Permanent Write Protect?: %d \n"),pParsedCSD->PermanentWP));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Temporary Write Protect?: %d \n"),pParsedCSD->TemporaryWP));
switch (pParsedCSD->FileSystem ) {
case SD_FS_FAT_PARTITION_TABLE:
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" FileSystem = FAT with Partition Table \n")));
break;
case SD_FS_FAT_NO_PARTITION_TABLE:
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" FileSystem = FAT with No Partition Table \n")));
break;
case SD_FS_UNIVERSAL:
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" FileSystem = Universal \n")));
break;
default:
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" FileSystem = Other/Unknown \n")));
}
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT("---------------------------------------------- \n\n\n")));
}
#else
#define DumpParsedCSDRegisters(p)
#endif
///////////////////////////////////////////////////////////////////////////////
// GetCardStatus - retrieve the card status
// Input: hDevice - SD Device Handle
// Output: pCardStatus - the card status
// Return: SD_API_STATUS
// Notes:
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS GetCardStatus(SD_DEVICE_HANDLE hDevice,
SD_CARD_STATUS *pCardStatus)
{
SD_API_STATUS status; // status
SD_COMMAND_RESPONSE cardResponse; // response buffer
// Initiate the bus transaction
status = SDSynchronousBusRequest__X(hDevice,
SD_CMD_SEND_STATUS,
(((DWORD)(((PSDCARD_DEVICE_CONTEXT)hDevice)->RelativeAddress)) << 16),
SD_COMMAND,
ResponseR1,
&cardResponse,
0,
0,
NULL,
0);
// Get the status and convert if necessary
if (!SD_API_SUCCESS(status) ) {
DEBUGMSG( SDCARD_ZONE_ERROR, (TEXT("SDGetCardStatus Failed: status 0x%X\r\n"),status));
return status;
}
SDGetCardStatusFromResponse(&cardResponse, pCardStatus);
DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("Status: 0x%08X, current state: %d \r\n"),
*pCardStatus, SD_STATUS_CURRENT_STATE(*pCardStatus)));
return status;
}
static
SD_API_STATUS InfoQueryCID(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
PREFAST_DEBUGCHK(pDevice);
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_PARSED_REGISTER_CID));
PSD_PARSED_REGISTER_CID pParsedCID = (PSD_PARSED_REGISTER_CID)pCardInfo;
PUCHAR pCid = pDevice->CachedRegisters.CID;
UCHAR Prv;
pParsedCID->ManufacturerID = pCid[SD_CID_MID_OFFSET];
// get the application ID string
pParsedCID->OEMApplicationID[0] = pCid[SD_CID_OID_OFFSET];
pParsedCID->OEMApplicationID[1] = pCid[SD_CID_OID_OFFSET+1];
pParsedCID->OEMApplicationID[2] = '\0';
// MMC cards have a 1 char larger Product Name
// and it starts 1 byte earlier in the CID data.
// PSN and PRV are offset by 1 byte and the date
// field has just a 4 bit year code starting at 1997.
if( pDevice->DeviceType == Device_MMC ) {
pParsedCID->ProductName[0] = pCid[MMC_CID_PNM_OFFSET];
pParsedCID->ProductName[1] = pCid[MMC_CID_PNM_OFFSET+1];
pParsedCID->ProductName[2] = pCid[MMC_CID_PNM_OFFSET+2];
pParsedCID->ProductName[3] = pCid[MMC_CID_PNM_OFFSET+3];
pParsedCID->ProductName[4] = pCid[MMC_CID_PNM_OFFSET+4];
pParsedCID->ProductName[5] = pCid[MMC_CID_PNM_OFFSET+5];
pParsedCID->ProductName[6] = '\0';
// get major and minor revs
Prv = pCid[MMC_CID_PRV_OFFSET];
pParsedCID->MajorProductRevision = (Prv & 0xF0) >> 4;
pParsedCID->MinorProductRevision = Prv & 0x0F;
// serial number
pParsedCID->ProductSerialNumber = pCid[MMC_CID_PSN_OFFSET] |
(pCid[MMC_CID_PSN_OFFSET + 1] << 8)|
(pCid[MMC_CID_PSN_OFFSET + 2] << 16) |
(pCid[MMC_CID_PSN_OFFSET + 3] << 24);
// Manufacturing month
pParsedCID->ManufacturingMonth = (pCid[MMC_CID_MDT_OFFSET] & MMC_CID_MONTH_MASK) >> MMC_CID_MONTH_SHIFT;
// Manufacturing year
pParsedCID->ManufacturingYear = pCid[MMC_CID_MDT_OFFSET] & MMC_CID_YEAR_MASK;
// Year starts at 1997
pParsedCID->ManufacturingYear += 1997;
} else {
pParsedCID->ProductName[0] = pCid[SD_CID_PNM_OFFSET];
pParsedCID->ProductName[1] = pCid[SD_CID_PNM_OFFSET+1];
pParsedCID->ProductName[2] = pCid[SD_CID_PNM_OFFSET+2];
pParsedCID->ProductName[3] = pCid[SD_CID_PNM_OFFSET+3];
pParsedCID->ProductName[4] = pCid[SD_CID_PNM_OFFSET+4];
pParsedCID->ProductName[5] = '\0';
pParsedCID->ProductName[6] = '\0';
// get major and minor revs
Prv = pCid[SD_CID_PRV_OFFSET];
pParsedCID->MajorProductRevision = (Prv & 0xF0) >> 4;
pParsedCID->MinorProductRevision = Prv & 0x0F;
// serial number
pParsedCID->ProductSerialNumber = pCid[SD_CID_PSN_OFFSET] |
(pCid[SD_CID_PSN_OFFSET + 1] << 8)|
(pCid[SD_CID_PSN_OFFSET + 2] << 16) |
(pCid[SD_CID_PSN_OFFSET + 3] << 24);
pParsedCID->ManufacturingMonth = pCid[SD_CID_MDT_OFFSET] & SD_CID_MONTH_MASK;
// get lower 4 bits
pParsedCID->ManufacturingYear = (pCid[SD_CID_MDT_OFFSET] & SD_CID_YEAR0_MASK) >> SD_CID_YEAR_SHIFT ;
// get upper 4 bits
pParsedCID->ManufacturingYear |= pCid[SD_CID_MDT_OFFSET+1] << SD_CID_YEAR_SHIFT;
// starts at year 2000
pParsedCID->ManufacturingYear += 2000;
}
memcpy(pParsedCID->RawCIDRegister, pDevice->CachedRegisters.CID, SD_CID_REGISTER_SIZE);
return SD_API_STATUS_SUCCESS;
}
#define GET_BIT_SLICE_FROM_CSD(pCSD, Slice, Size) \
GetBitSlice(pCSD, SD_CSD_REGISTER_SIZE, Slice, Size)
static
SD_API_STATUS InfoQueryCSD(
PSDCARD_DEVICE_CONTEXT pDevice,
PVOID pCardInfo,
ULONG cbCardInfo
)
{
PREFAST_DEBUGCHK(pDevice);
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_PARSED_REGISTER_CSD));
PSD_PARSED_REGISTER_CSD pParsedCSD = (PSD_PARSED_REGISTER_CSD)pCardInfo;
PUCHAR pCSD = pDevice->CachedRegisters.CSD;
UCHAR value, unit; // Used for access time/transfer rate calculations
DWORD cSize, cSizeMult; // Used for device size calculation
UCHAR fileFormatGroup, fileFormat;
UCHAR rblLength;
pParsedCSD->CSDVersion = (UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD,SD_CSD_VERSION_BIT_SLICE,
SD_CSD_VERSION_SLICE_SIZE);
// check the CSD version code
if (Device_SD_Memory == pDevice->DeviceType) {
// SanDisk 128M SD memory card has wrong CSDVersion=1. We would like to work around
// this issue by add one into SD_CSD_VERSION_CODE_SUPPORTED. This will not have impact
// on any SD Memory card which has correct CSDVersion(should be 0). But in the future,
// when SD card CSD version is updated by SDA, we should check the code here again.
if (pParsedCSD->CSDVersion > (SD_CSD_VERSION_CODE_SUPPORTED + 1)) {
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 == pDevice->DeviceType) {
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;
}
} 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,
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -