sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MdeModulePkg/SdMmcHcDxe: Implement revision 3 of SdMmcOverrideProtocol

Browse Source 
https://bugzilla.tianocore.org/show_bug.cgi?id=1882

Implement support for GetOperatingParamters notify phase
in SdMmcHcDxe driver. GetOperatingParameters notify phase
is signaled before we start card detection and initialization.
Code has been updated for both eMMC and SD card controllers to
take into consideration those new parameters. Initialization process
has been divided into 2 steps. In the first step we bring the link
up to the point where we can get card identification data(Extended
CSD in eMMC case and SWITCH command response in SD card case). This
data is later used along with controller capabilities and operating
parameters passed in GetOperatingParameters phase to choose preferred
bus settings in GetTargetBusSettings function. Those settings are later
on to start bus training to high speeds. If user passes incompatible
setting with selected bus timing driver will assume it's standard behavior
with respect to that setting. For instance if HS400 has been selected as a
target bus timing due to card and controller support bus width setting of
4 and 1 bit won't be respected and 8 bit setting will be chosen instead.

Tests on Marvell boards were also performed by Marcin Wojtas
<mw@semihalf.com>:

https://edk2.groups.io/g/devel/message/42999

Board 1 (out of tree): SD - OK, MMC - OK
Board 2: (Armada80x0McBin): SD - OK, MMC - OK
Board 3: (Armada70x0Db): SD - problems, MMC - OK

Please note that the problem on Armada70x0Db SD devices are introduced by
adding new types of SD bus modes, a subsequent patch within edk2-platforms
repository will be proposed to address it.
(More details can be referred from the above link.)

Signed-off-by: Mateusz Albecki <mateusz.albecki@intel.com>
Reviewed-by: Hao A Wu <hao.a.wu@intel.com>
Regression-tested-by: Sumit Garg <sumit.garg@linaro.org>
This commit is contained in:
Albecki, Mateusz
2019-06-26 21:10:03 +08:00
committed by Hao A Wu
parent f56cc67f62
commit adec1f5deb
6 changed files with 827 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

418
MdeModulePkg/Bus/Pci/SdMmcPciHcDxe/SdDevice.c
View File

@@ -313,10 +313,6 @@ SdCardSetRca (
return Status;
}
/**
Send command SELECT_DESELECT_CARD to the SD device to select/deselect it.
@@ -472,14 +468,14 @@ SdCardSetBusWidth (
Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
@param[in] PassThru A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
@param[in] Slot The slot number of the SD card to send the command to.
@param[in] AccessMode The value for access mode group.
@param[in] CommandSystem The value for command set group.
@param[in] DriveStrength The value for drive length group.
@param[in] PowerLimit The value for power limit group.
@param[in] Mode Switch or check function.
@param[out] SwitchResp The return switch function status.
@param[in] PassThru A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
@param[in] Slot The slot number of the SD card to send the command to.
@param[in] BusTiming Target bus timing based on which access group value will be set.
@param[in] CommandSystem The value for command set group.
@param[in] DriverStrength The value for driver strength group.
@param[in] PowerLimit The value for power limit group.
@param[in] Mode Switch or check function.
@param[out] SwitchResp The return switch function status.
@retval EFI_SUCCESS The operation is done correctly.
@retval Others The operation fails.
@@ -489,9 +485,9 @@ EFI_STATUS
SdCardSwitch (
IN EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru,
IN UINT8 Slot,
IN UINT8 AccessMode,
IN SD_MMC_BUS_MODE BusTiming,
IN UINT8 CommandSystem,
IN UINT8 DriveStrength,
IN SD_DRIVER_STRENGTH_TYPE DriverStrength,
IN UINT8 PowerLimit,
IN BOOLEAN Mode,
OUT UINT8 *SwitchResp
@@ -502,6 +498,7 @@ SdCardSwitch (
EFI_SD_MMC_PASS_THRU_COMMAND_PACKET Packet;
EFI_STATUS Status;
UINT32 ModeValue;
UINT8 AccessMode;
ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
@@ -516,14 +513,49 @@ SdCardSwitch (
SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
ModeValue = Mode ? BIT31 : 0;
SdMmcCmdBlk.CommandArgument = (AccessMode & 0xF) | ((PowerLimit & 0xF) << 4) | \
((DriveStrength & 0xF) << 8) | ((DriveStrength & 0xF) << 12) | \
switch (BusTiming) {
case SdMmcUhsDdr50:
AccessMode = 0x4;
break;
case SdMmcUhsSdr104:
AccessMode = 0x3;
break;
case SdMmcUhsSdr50:
AccessMode = 0x2;
break;
case SdMmcUhsSdr25:
case SdMmcSdHs:
AccessMode = 0x1;
break;
case SdMmcUhsSdr12:
case SdMmcSdDs:
AccessMode = 0;
break;
default:
AccessMode = 0xF;
}
SdMmcCmdBlk.CommandArgument = (AccessMode & 0xF) | ((CommandSystem & 0xF) << 4) | \
((DriverStrength & 0xF) << 8) | ((PowerLimit & 0xF) << 12) | \
ModeValue;
Packet.InDataBuffer = SwitchResp;
Packet.InTransferLength = 64;
Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
if (EFI_ERROR (Status)) {
return Status;
}
if (Mode) {
if ((((AccessMode & 0xF) != 0xF) && ((SwitchResp[16] & 0xF) != AccessMode)) ||
(((CommandSystem & 0xF) != 0xF) && (((SwitchResp[16] >> 4) & 0xF) != CommandSystem)) ||
(((DriverStrength & 0xF) != 0xF) && ((SwitchResp[15] & 0xF) != DriverStrength)) ||
(((PowerLimit & 0xF) != 0xF) && (((SwitchResp[15] >> 4) & 0xF) != PowerLimit))) {
return EFI_DEVICE_ERROR;
}
}
return Status;
}
@@ -748,6 +780,273 @@ SdCardSwitchBusWidth (
return Status;
}
/**
Check if passed BusTiming is supported in both controller and card.
@param[in] Private Pointer to controller private data
@param[in] SlotIndex Index of the slot in the controller
@param[in] CardSupportedBusTimings Bitmask indicating which bus timings are supported by card
@param[in] IsInUhsI Flag indicating if link is in UHS-I
@retval TRUE Both card and controller support given BusTiming
@retval FALSE Card or controller doesn't support given BusTiming
**/
BOOLEAN
SdIsBusTimingSupported (
IN SD_MMC_HC_PRIVATE_DATA *Private,
IN UINT8 SlotIndex,
IN UINT8 CardSupportedBusTimings,
IN BOOLEAN IsInUhsI,
IN SD_MMC_BUS_MODE BusTiming
)
{
SD_MMC_HC_SLOT_CAP *Capability;
Capability = &Private->Capability[SlotIndex];
if (IsInUhsI) {
switch (BusTiming) {
case SdMmcUhsSdr104:
if ((Capability->Sdr104 != 0) && ((CardSupportedBusTimings & BIT3) != 0)) {
return TRUE;
}
break;
case SdMmcUhsDdr50:
if ((Capability->Ddr50 != 0) && ((CardSupportedBusTimings & BIT4) != 0)) {
return TRUE;
}
break;
case SdMmcUhsSdr50:
if ((Capability->Sdr50 != 0) && ((CardSupportedBusTimings & BIT2) != 0)) {
return TRUE;
}
break;
case SdMmcUhsSdr25:
if ((CardSupportedBusTimings & BIT1) != 0) {
return TRUE;
}
break;
case SdMmcUhsSdr12:
if ((CardSupportedBusTimings & BIT0) != 0) {
return TRUE;
}
break;
default:
break;
}
} else {
switch (BusTiming) {
case SdMmcSdHs:
if ((Capability->HighSpeed != 0) && (CardSupportedBusTimings & BIT1) != 0) {
return TRUE;
}
break;
case SdMmcSdDs:
if ((CardSupportedBusTimings & BIT0) != 0) {
return TRUE;
}
break;
default:
break;
}
}
return FALSE;
}
/**
Get the target bus timing to set on the link. This function
will try to select highest bus timing supported by card, controller
and the driver.
@param[in] Private Pointer to controller private data
@param[in] SlotIndex Index of the slot in the controller
@param[in] CardSupportedBusTimings Bitmask indicating which bus timings are supported by card
@param[in] IsInUhsI Flag indicating if link is in UHS-I
@return Bus timing value that should be set on link
**/
SD_MMC_BUS_MODE
SdGetTargetBusTiming (
IN SD_MMC_HC_PRIVATE_DATA *Private,
IN UINT8 SlotIndex,
IN UINT8 CardSupportedBusTimings,
IN BOOLEAN IsInUhsI
)
{
SD_MMC_BUS_MODE BusTiming;
if (IsInUhsI) {
BusTiming = SdMmcUhsSdr104;
} else {
BusTiming = SdMmcSdHs;
}
while (BusTiming > SdMmcSdDs) {
if (SdIsBusTimingSupported (Private, SlotIndex, CardSupportedBusTimings, IsInUhsI, BusTiming)) {
break;
}
BusTiming--;
}
return BusTiming;
}
/**
Get the target bus width to be set on the bus.
@param[in] Private Pointer to controller private data
@param[in] SlotIndex Index of the slot in the controller
@param[in] BusTiming Bus timing set on the bus
@return Bus width to be set on the bus
**/
UINT8
SdGetTargetBusWidth (
IN SD_MMC_HC_PRIVATE_DATA *Private,
IN UINT8 SlotIndex,
IN SD_MMC_BUS_MODE BusTiming
)
{
UINT8 BusWidth;
UINT8 PreferredBusWidth;
PreferredBusWidth = Private->Slot[SlotIndex].OperatingParameters.BusWidth;
if (BusTiming == SdMmcSdDs || BusTiming == SdMmcSdHs) {
if (PreferredBusWidth != EDKII_SD_MMC_BUS_WIDTH_IGNORE &&
(PreferredBusWidth == 1 || PreferredBusWidth == 4)) {
BusWidth = PreferredBusWidth;
} else {
BusWidth = 4;
}
} else {
//
// UHS-I modes support only 4-bit width.
// Switch to 4-bit has been done before calling this function anyway so
// this is purely informational.
//
BusWidth = 4;
}
return BusWidth;
}
/**
Get the target clock frequency to be set on the bus.
@param[in] Private Pointer to controller private data
@param[in] SlotIndex Index of the slot in the controller
@param[in] BusTiming Bus timing to be set on the bus
@return Value of the clock frequency to be set on bus in MHz
**/
UINT32
SdGetTargetBusClockFreq (
IN SD_MMC_HC_PRIVATE_DATA *Private,
IN UINT8 SlotIndex,
IN SD_MMC_BUS_MODE BusTiming
)
{
UINT32 PreferredClockFreq;
UINT32 MaxClockFreq;
PreferredClockFreq = Private->Slot[SlotIndex].OperatingParameters.ClockFreq;
switch (BusTiming) {
case SdMmcUhsSdr104:
MaxClockFreq = 208;
break;
case SdMmcUhsSdr50:
MaxClockFreq = 100;
break;
case SdMmcUhsDdr50:
case SdMmcUhsSdr25:
case SdMmcSdHs:
MaxClockFreq = 50;
break;
case SdMmcUhsSdr12:
case SdMmcSdDs:
default:
MaxClockFreq = 25;
}
if (PreferredClockFreq != EDKII_SD_MMC_CLOCK_FREQ_IGNORE && PreferredClockFreq < MaxClockFreq) {
return PreferredClockFreq;
} else {
return MaxClockFreq;
}
}
/**
Get the driver strength to be set on bus.
@param[in] Private Pointer to controller private data
@param[in] SlotIndex Index of the slot in the controller
@param[in] CardSupportedDriverStrengths Bitmask indicating which driver strengths are supported on the card
@param[in] BusTiming Bus timing set on the bus
@return Value of the driver strength to be set on the bus
**/
EDKII_SD_MMC_DRIVER_STRENGTH
SdGetTargetDriverStrength (
IN SD_MMC_HC_PRIVATE_DATA *Private,
IN UINT8 SlotIndex,
IN UINT8 CardSupportedDriverStrengths,
IN SD_MMC_BUS_MODE BusTiming
)
{
EDKII_SD_MMC_DRIVER_STRENGTH PreferredDriverStrength;
EDKII_SD_MMC_DRIVER_STRENGTH DriverStrength;
if (BusTiming == SdMmcSdDs || BusTiming == SdMmcSdHs) {
DriverStrength.Sd = SdDriverStrengthIgnore;
return DriverStrength;
}
PreferredDriverStrength = Private->Slot[SlotIndex].OperatingParameters.DriverStrength;
DriverStrength.Sd = SdDriverStrengthTypeB;
if (PreferredDriverStrength.Sd != EDKII_SD_MMC_DRIVER_STRENGTH_IGNORE &&
(CardSupportedDriverStrengths & (BIT0 << PreferredDriverStrength.Sd))) {
if ((PreferredDriverStrength.Sd == SdDriverStrengthTypeA &&
(Private->Capability[SlotIndex].DriverTypeA != 0)) ||
(PreferredDriverStrength.Sd == SdDriverStrengthTypeC &&
(Private->Capability[SlotIndex].DriverTypeC != 0)) ||
(PreferredDriverStrength.Sd == SdDriverStrengthTypeD &&
(Private->Capability[SlotIndex].DriverTypeD != 0))) {
DriverStrength.Sd = PreferredDriverStrength.Sd;
}
}
return DriverStrength;
}
/**
Get the target settings for the bus mode.
@param[in] Private Pointer to controller private data
@param[in] SlotIndex Index of the slot in the controller
@param[in] SwitchQueryResp Pointer to switch query response
@param[in] IsInUhsI Flag indicating if link is in UHS-I mode
@param[out] BusMode Target configuration of the bus
**/
VOID
SdGetTargetBusMode (
IN SD_MMC_HC_PRIVATE_DATA *Private,
IN UINT8 SlotIndex,
IN UINT8 *SwitchQueryResp,
IN BOOLEAN IsInUhsI,
OUT SD_MMC_BUS_SETTINGS *BusMode
)
{
BusMode->BusTiming = SdGetTargetBusTiming (Private, SlotIndex, SwitchQueryResp[13], IsInUhsI);
BusMode->BusWidth = SdGetTargetBusWidth (Private, SlotIndex, BusMode->BusTiming);
BusMode->ClockFreq = SdGetTargetBusClockFreq (Private, SlotIndex, BusMode->BusTiming);
BusMode->DriverStrength = SdGetTargetDriverStrength (Private, SlotIndex, SwitchQueryResp[9], BusMode->BusTiming);
}
/**
Switch the high speed timing according to request.
@@ -775,13 +1074,10 @@ SdCardSetBusMode (
{
EFI_STATUS Status;
SD_MMC_HC_SLOT_CAP *Capability;
UINT32 ClockFreq;
UINT8 BusWidth;
UINT8 AccessMode;
UINT8 HostCtrl1;
UINT8 SwitchResp[64];
SD_MMC_BUS_MODE Timing;
SD_MMC_HC_PRIVATE_DATA *Private;
SD_MMC_BUS_SETTINGS BusMode;
Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
@@ -792,61 +1088,51 @@ SdCardSetBusMode (
return Status;
}
BusWidth = 4;
Status = SdCardSwitchBusWidth (PciIo, PassThru, Slot, Rca, BusWidth);
if (EFI_ERROR (Status)) {
return Status;
if (S18A) {
//
// For UHS-I speed modes 4-bit data bus is requiered so we
// switch here irrespective of platform preference.
//
Status = SdCardSwitchBusWidth (PciIo, PassThru, Slot, Rca, 4);
if (EFI_ERROR (Status)) {
return Status;
}
}
//
// Get the supported bus speed from SWITCH cmd return data group #1.
//
Status = SdCardSwitch (PassThru, Slot, 0xF, 0xF, 0xF, 0xF, FALSE, SwitchResp);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Calculate supported bus speed/bus width/clock frequency by host and device capability.
//
ClockFreq = 0;
if (S18A && (Capability->Sdr104 != 0) && ((SwitchResp[13] & BIT3) != 0)) {
ClockFreq = 208;
AccessMode = 3;
Timing = SdMmcUhsSdr104;
} else if (S18A && (Capability->Sdr50 != 0) && ((SwitchResp[13] & BIT2) != 0)) {
ClockFreq = 100;
AccessMode = 2;
Timing = SdMmcUhsSdr50;
} else if (S18A && (Capability->Ddr50 != 0) && ((SwitchResp[13] & BIT4) != 0)) {
ClockFreq = 50;
AccessMode = 4;
Timing = SdMmcUhsDdr50;
} else if ((SwitchResp[13] & BIT1) != 0) {
ClockFreq = 50;
AccessMode = 1;
Timing = SdMmcUhsSdr25;
} else {
ClockFreq = 25;
AccessMode = 0;
Timing = SdMmcUhsSdr12;
}
Status = SdCardSwitch (PassThru, Slot, AccessMode, 0xF, 0xF, 0xF, TRUE, SwitchResp);
Status = SdCardSwitch (PassThru, Slot, 0xFF, 0xF, SdDriverStrengthIgnore, 0xF, FALSE, SwitchResp);
if (EFI_ERROR (Status)) {
return Status;
}
if ((SwitchResp[16] & 0xF) != AccessMode) {
DEBUG ((DEBUG_ERROR, "SdCardSetBusMode: Switch to AccessMode %d ClockFreq %d BusWidth %d fails! The Switch response is 0x%1x\n", AccessMode, ClockFreq, BusWidth, SwitchResp[16] & 0xF));
return EFI_DEVICE_ERROR;
SdGetTargetBusMode (Private, Slot, SwitchResp, S18A, &BusMode);
DEBUG ((DEBUG_INFO, "SdCardSetBusMode: Target bus mode: bus timing = %d, bus width = %d, clock freq[MHz] = %d, driver strength = %d\n",
BusMode.BusTiming, BusMode.BusWidth, BusMode.ClockFreq, BusMode.DriverStrength.Sd));
if (!S18A) {
Status = SdCardSwitchBusWidth (PciIo, PassThru, Slot, Rca, BusMode.BusWidth);
if (EFI_ERROR (Status)) {
return Status;
}
}
DEBUG ((DEBUG_INFO, "SdCardSetBusMode: Switch to AccessMode %d ClockFreq %d BusWidth %d\n", AccessMode, ClockFreq, BusWidth));
Status = SdCardSwitch (PassThru, Slot, BusMode.BusTiming, 0xF, BusMode.DriverStrength.Sd, 0xF, TRUE, SwitchResp);
if (EFI_ERROR (Status)) {
return Status;
}
Status = SdMmcSetDriverStrength (Private->PciIo, Slot, BusMode.DriverStrength.Sd);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Set to Hight Speed timing
// Set to High Speed timing
//
if (AccessMode == 1) {
if (BusMode.BusTiming == SdMmcSdHs) {
HostCtrl1 = BIT2;
Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL1, sizeof (HostCtrl1), &HostCtrl1);
if (EFI_ERROR (Status)) {
@@ -854,12 +1140,12 @@ SdCardSetBusMode (
}
}
Status = SdMmcHcUhsSignaling (Private->ControllerHandle, PciIo, Slot, Timing);
Status = SdMmcHcUhsSignaling (Private->ControllerHandle, PciIo, Slot, BusMode.BusTiming);
if (EFI_ERROR (Status)) {
return Status;
}
Status = SdMmcHcClockSupply (PciIo, Slot, ClockFreq * 1000, Private->BaseClkFreq[Slot], Private->ControllerVersion[Slot]);
Status = SdMmcHcClockSupply (PciIo, Slot, BusMode.ClockFreq * 1000, Private->BaseClkFreq[Slot], Private->ControllerVersion[Slot]);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -869,7 +1155,7 @@ SdCardSetBusMode (
Private->ControllerHandle,
Slot,
EdkiiSdMmcSwitchClockFreqPost,
&Timing
&BusMode.BusTiming
);
if (EFI_ERROR (Status)) {
DEBUG ((
@@ -882,7 +1168,7 @@ SdCardSetBusMode (
}
}
if ((AccessMode == 3) || ((AccessMode == 2) && (Capability->TuningSDR50 != 0))) {
if ((BusMode.BusTiming == SdMmcUhsSdr104) || ((BusMode.BusTiming == SdMmcUhsSdr50) && (Capability->TuningSDR50 != 0))) {
Status = SdCardTuningClock (PciIo, PassThru, Slot);
if (EFI_ERROR (Status)) {
return Status;