?? sddevinf.cpp
字號:
pPowerDrawData->HpAvePower33 = pV11FunctionTupleExt->HpAvePwr33V;
pPowerDrawData->HpMaxPower33 = pV11FunctionTupleExt->HpMaxPwr33V;
pPowerDrawData->LpAvePower33 = pV11FunctionTupleExt->LpAvePwr33V;
pPowerDrawData->LpMaxPower33 = pV11FunctionTupleExt->LpMaxPwr33V;
}
}
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT("SDBusDriver: Function %d Power Draw:\r\n"),m_SDCardInfo.SDIOInformation.Function));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" OpMinPower %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.OpMinPower));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" OpAvePower %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.OpAvePower));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" OpMaxPower %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.OpMaxPower));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" SpAvePower33 %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.SpAvePower33));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" SpAvePower33 %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.SpMaxPower33));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" HpAvePower33 %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.HpAvePower33));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" HpMaxPower33 %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.HpMaxPower33));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" LpAvePower33 %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.LpAvePower33));
DbgPrintZo(SDBUS_ZONE_DEVICE, (TEXT(" LpMaxPower33 %d mA\r\n"), m_SDCardInfo.SDIOInformation.PowerDrawData.LpMaxPower33));
return SD_API_STATUS_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
// GetFunctionPowerState - Get the power state of a SDIO function
// Input: pDevice - the device
//
// Output: pPowerState - structure describing the power state of the device
// Return: SD_API_STATUS code
//
// Notes:
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS CSDDevice::GetFunctionPowerState( PFUNCTION_POWER_STATE pPowerState)
{
SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; // intermediate status
DWORD FBROffset; // calculated FBR offset
UCHAR regValue; // register value
if (m_FuncionIndex == 0 || pPowerState == NULL) {
return SD_API_STATUS_INVALID_PARAMETER;
}
CSDDevice *pDevice0 = m_sdSlot.GetFunctionDevice(0);
if (pDevice0 == NULL) {
return SD_API_STATUS_INVALID_PARAMETER;
}
pPowerState->fPowerControlSupport = pDevice0->GetCardInfo().SDIOInformation.pCommonInformation->fCardSupportsPowerControl;
pPowerState->fPowerControlEnabled = pDevice0->GetCardInfo().SDIOInformation.pCommonInformation->fPowerControlEnabled;
pPowerState->fFunctionEnabled = (pDevice0->GetCardInfo().SDIOInformation.pCommonInformation->CCCRShadowIOEnable
& (1 << m_FuncionIndex)) ? TRUE : FALSE;
FBROffset = SD_IO_FBR_1_OFFSET + (m_FuncionIndex - 1) * SD_IO_FBR_LENGTH;
status = pDevice0->SDReadWriteRegistersDirect_I( SD_IO_READ, FBROffset + SD_IO_FBR_POWER_SELECT, FALSE, ®Value, 1);
if (!SD_API_SUCCESS(status)) {
return status;
}
pPowerState->fSupportsPowerSelect = (regValue & SD_IO_FUNCTION_POWER_SELECT_SUPPORT) ? TRUE : FALSE;
if(pPowerState->fSupportsPowerSelect) {
pPowerState->fLowPower = regValue & SD_IO_FUNCTION_POWER_SELECT_STATE ? TRUE : FALSE;
}
else {
pPowerState->fLowPower = 0;
}
pPowerState->OperatingVoltage = m_OperatingVoltage;
//calculate the current draw
if(pPowerState->fPowerControlSupport) {
if(pPowerState->fFunctionEnabled) {
//
// in future when more power tuples are added select the proper tuple here
// currently only the 3.3V tuple is supported
//
if((pPowerState->fPowerControlEnabled) && (pPowerState->fSupportsPowerSelect)) {
if(pPowerState->fLowPower){
//function enabled at low power
pPowerState->CurrentDrawNow = m_SDCardInfo.SDIOInformation.PowerDrawData.LpMaxPower33;
pPowerState->EnableDelta = ((INT)m_SDCardInfo.SDIOInformation.PowerDrawData.LpMaxPower33) * -1;
pPowerState->SelectDelta = ((INT)m_SDCardInfo.SDIOInformation.PowerDrawData.HpMaxPower33)
- ((INT)m_SDCardInfo.SDIOInformation.PowerDrawData.LpMaxPower33);
}
else {
//function enabled at high power
pPowerState->CurrentDrawNow = m_SDCardInfo.SDIOInformation.PowerDrawData.HpMaxPower33;
pPowerState->EnableDelta = ((INT)m_SDCardInfo.SDIOInformation.PowerDrawData.HpMaxPower33) * -1;
pPowerState->SelectDelta = ((INT)m_SDCardInfo.SDIOInformation.PowerDrawData.LpMaxPower33)
- ((INT)m_SDCardInfo.SDIOInformation.PowerDrawData.HpMaxPower33);
}
}
else {
//function enabled at no power select
pPowerState->CurrentDrawNow = m_SDCardInfo.SDIOInformation.PowerDrawData.SpMaxPower33;
pPowerState->EnableDelta = ((INT)m_SDCardInfo.SDIOInformation.PowerDrawData.SpMaxPower33) * -1;
pPowerState->SelectDelta = 0;
}
}
else {
if((pPowerState->fPowerControlEnabled) && (pPowerState->fSupportsPowerSelect)) {
if(pPowerState->fLowPower) {
//function disabled power select set to low
pPowerState->CurrentDrawNow = 0;
pPowerState->EnableDelta = m_SDCardInfo.SDIOInformation.PowerDrawData.LpMaxPower33;
pPowerState->SelectDelta = 0;
}
else {
//function disabled power select set to low
pPowerState->CurrentDrawNow = 0;
pPowerState->EnableDelta = m_SDCardInfo.SDIOInformation.PowerDrawData.HpMaxPower33;
pPowerState->SelectDelta = 0;
}
}
else {
//function disabled, no power select
pPowerState->CurrentDrawNow = 0;
pPowerState->EnableDelta = m_SDCardInfo.SDIOInformation.PowerDrawData.SpMaxPower33;
}
}
}
else
{
USHORT TempMaxPower;
//the current draw must never be greater than 200mA for a non Power Control enabled card
if((0 == m_SDCardInfo.SDIOInformation.PowerDrawData.OpMaxPower) || (200 < m_SDCardInfo.SDIOInformation.PowerDrawData.OpMaxPower)){
TempMaxPower = 200;
}
else {
TempMaxPower = m_SDCardInfo.SDIOInformation.PowerDrawData.OpMaxPower;
}
if(pPowerState->fFunctionEnabled) {
//function enabled, no power control
pPowerState->CurrentDrawNow = TempMaxPower;
pPowerState->EnableDelta = ((INT)TempMaxPower) * -1;
pPowerState->SelectDelta = 0;
}
else {
//function disabled, no power control
pPowerState->CurrentDrawNow = 0;
pPowerState->EnableDelta = (INT)TempMaxPower;
pPowerState->SelectDelta = 0;
}
}
return SD_API_STATUS_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
// GetCardStatus - retrieve the card status
// Input: hDevice - SD Device Handle
// Output: pCardStatus - the card status
// Return: SD_API_STATUS
// Notes:
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS CSDDevice::GetCardStatus(SD_CARD_STATUS *pCardStatus)
{
SD_API_STATUS status; // status
SD_COMMAND_RESPONSE cardResponse; // response buffer
// Initiate the bus transaction
status = SDSynchronousBusRequest_I(
SD_CMD_SEND_STATUS,
((DWORD)(m_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;
}
SD_API_STATUS CSDDevice::InfoQueryCID(PVOID pCardInfo, ULONG cbCardInfo)
{
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_PARSED_REGISTER_CID));
PSD_PARSED_REGISTER_CID pParsedCID = (PSD_PARSED_REGISTER_CID)pCardInfo;
PUCHAR pCid = m_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( m_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, m_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)
///////////////////////////////////////////////////////////////////////////////
// DumpParsedCSDRegisters- dump parsed register data to the debugger
// Input: pParsedCSD - the Parsed CSD structure
// Output:
//
// Notes:
///////////////////////////////////////////////////////////////////////////////
inline 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")));
}
SD_API_STATUS CSDDevice::InfoQueryCSD(PVOID pCardInfo, ULONG cbCardInfo)
{
PREFAST_DEBUGCHK(pCardInfo);
DEBUGCHK(cbCardInfo == sizeof(SD_PARSED_REGISTER_CSD));
PSD_PARSED_REGISTER_CSD pParsedCSD = (PSD_PARSED_REGISTER_CSD)pCardInfo;
PUCHAR pCSD = m_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);
#ifdef _MMC_SPEC_42_
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -