📄 sdbusrequest.cpp
字号:
if (NULL == pRequest->ListEntry.Flink) {
DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDCancelBusRequest: Request 0x%08X on slot:%d is not in a queue! \n"),
pRequest, pSlot->SlotIndex ));
SDHCDReleaseHCLock(pSlot->pHostController);
goto EXIT;
}
// remove the entry
SDRemoveEntryFromQueue(&pSlot->RequestQueue, pRequest);
// release the lock
SDHCDReleaseHCLock(pSlot->pHostController);
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT("SDCard: Request 0x%08X on slot:%d is in the queue, removing request, completing.... \n"),
pRequest, pSlot->SlotIndex));
// set the status
pRequest->Status = SD_API_STATUS_CANCELED;
// complete the request
SDCompleteBusRequest(pRequest);
fRet = TRUE;
EXIT:
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT("SDCard: -SDCancelBusRequest\n")));
return fRet;
}
#if DEBUG
///////////////////////////////////////////////////////////////////////////////
// DumpParsedCSDRegisters- dump parsed register data to the debugger
// Input: pParsedCSD - the Parsed CSD structure
// Output:
//
// Notes:
///////////////////////////////////////////////////////////////////////////////
VOID DumpParsedCSDRegisters(PSD_PARSED_REGISTER_CSD pParsedCSD)
{
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT("\n\n\nSDCard: Dumping parsed Registers : \n")));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Version:%d \n"),pParsedCSD->CSDVersion));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" TAAC: %f ns \n"),pParsedCSD->DataAccessTime.TAAC));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" NSAC: %d clocks \n"),pParsedCSD->DataAccessTime.NSAC));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" MaxDataTransferRate: %d kb/s \n"),pParsedCSD->MaxDataTransferRate));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Card Command Classes: 0x%04X \n"),pParsedCSD->CardCommandClasses));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Max Read Block Length: %d bytes \n"),pParsedCSD->MaxReadBlockLength));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Read Block Partial? : %d \n"),pParsedCSD->ReadBlockPartial));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Max Write Block Length: %d bytes \n"),pParsedCSD->MaxWriteBlockLength));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Write Block Partial? : %d \n"),pParsedCSD->WriteBlockPartial));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Write Block Misaligned? : %d \n"),pParsedCSD->WriteBlockMisalign));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Read Block Misaligned? : %d \n"),pParsedCSD->ReadBlockMisalign));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" DSR Implemented? : %d \n"),pParsedCSD->DSRImplemented));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Device Size : %d bytes \n"),pParsedCSD->DeviceSize));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" VDD Read Current Min : %d mA \n"),pParsedCSD->VDDReadCurrentMin));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" VDD Read Current Max : %d mA \n"),pParsedCSD->VDDReadCurrentMax));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" VDD Write Current Min : %d mA \n"),pParsedCSD->VDDWriteCurrentMin));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" VDD Write Current Max : %d mA \n"),pParsedCSD->VDDWriteCurrentMax));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Erase Block Enabled?: %d \n"),pParsedCSD->EraseBlockEnable));
DEBUGMSG(SDBUS_ZONE_REQUEST, (TEXT(" Erase Sector Size: %d blocks \n"),pParsedCSD->EraseSectorSize));
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;
#ifdef SD_SPEC_20
/*************************************************************************/
/****** Date : 07.05.04 ******/
/****** Developer : HS.JANG ******/
/****** Description : g_bIsSupportSDHC flag must be clear before ******/
/****** executing InfoQueryCSD function ******/
/*************************************************************************/
g_bIsSupportSDHC = FALSE;
/*************************************************************************/
#endif
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)) {
DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDCardInfoQuery: SD CSD version : %d currently not supported \n"),pParsedCSD->CSDVersion));
DEBUGCHK(FALSE);
return SD_API_STATUS_DEVICE_UNSUPPORTED;
}
#ifdef SD_SPEC_20
/*************************************************************************/
/****** Date : 07.05.04 ******/
/****** Developer : HS.JANG ******/
/****** Description : Check that this card support SD high capacity ******/
/****** or not ******/
/*************************************************************************/
if (pParsedCSD->CSDVersion == (SD_CSD_VERSION_CODE_SUPPORTED)) {
g_bIsSupportSDHC = TRUE;
pDevice->dwWhatIsCardType = 2;
}
/*************************************************************************/
#endif
} else if (Device_MMC == pDevice->DeviceType) {
#ifdef __MMC_SPEC_4_2_SUPPORT__ // read spec. version value from CSD
pParsedCSD->SpecVersion =
(UCHAR)GET_BIT_SLICE_FROM_CSD(pCSD, SD_CSD_SPEC_VERSION_BIT_SLICE,
SD_CSD_SPEC_VERSION_SLICE_SIZE);
#endif
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,
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -