MdeModulePkg/Bus/Pci/SdMmcPciHcDxe/SdDevice.c

   1 /** @file
   2   This file provides some helper functions which are specific for SD card device.
   3
   4   Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
   5   Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
   6   SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include "SdMmcPciHcDxe.h"
  11
  12 /**
  13   Send command GO_IDLE_STATE to the device to make it go to Idle State.
  14
  15   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
  16
  17   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
  18   @param[in] Slot           The slot number of the SD card to send the command to.
  19
  20   @retval EFI_SUCCESS       The SD device is reset correctly.
  21   @retval Others            The device reset fails.
  22
  23 **/
  24 EFI_STATUS
  25 SdCardReset (
  26   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
  27   IN UINT8                              Slot
  28   )
  29 {
  30   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
  31   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
  32   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
  33   EFI_STATUS                            Status;
  34
  35   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
  36   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
  37   ZeroMem (&Packet, sizeof (Packet));
  38
  39   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
  40   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
  41   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
  42
  43   SdMmcCmdBlk.CommandIndex = SD_GO_IDLE_STATE;
  44   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBc;
  45
  46   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
  47
  48   return Status;
  49 }
  50
  51 /**
  52   Send command SEND_IF_COND to the device to inquiry the SD Memory Card interface
  53   condition.
  54
  55   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
  56
  57   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
  58   @param[in] Slot           The slot number of the SD card to send the command to.
  59   @param[in] SupplyVoltage  The supplied voltage by the host.
  60   @param[in] CheckPattern   The check pattern to be sent to the device.
  61
  62   @retval EFI_SUCCESS       The operation is done correctly.
  63   @retval Others            The operation fails.
  64
  65 **/
  66 EFI_STATUS
  67 SdCardVoltageCheck (
  68   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
  69   IN UINT8                              Slot,
  70   IN UINT8                              SupplyVoltage,
  71   IN UINT8                              CheckPattern
  72   )
  73 {
  74   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
  75   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
  76   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
  77   EFI_STATUS                            Status;
  78
  79   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
  80   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
  81   ZeroMem (&Packet, sizeof (Packet));
  82
  83   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
  84   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
  85   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
  86
  87   SdMmcCmdBlk.CommandIndex = SD_SEND_IF_COND;
  88   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBcr;
  89   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR7;
  90   SdMmcCmdBlk.CommandArgument = (SupplyVoltage << 8) | CheckPattern;
  91
  92   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
  93
  94   if (!EFI_ERROR (Status)) {
  95     if (SdMmcStatusBlk.Resp0 != SdMmcCmdBlk.CommandArgument) {
  96       return EFI_DEVICE_ERROR;
  97     }
  98   }
  99
 100   return Status;
 101 }
 102
 103 /**
 104   Send command SDIO_SEND_OP_COND to the device to see whether it is SDIO device.
 105
 106   Refer to SDIO Simplified Spec 3 Section 3.2 for details.
 107
 108   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 109   @param[in] Slot           The slot number of the SD card to send the command to.
 110   @param[in] VoltageWindow  The supply voltage window.
 111   @param[in] S18R           The boolean to show if it should switch to 1.8v.
 112
 113   @retval EFI_SUCCESS       The operation is done correctly.
 114   @retval Others            The operation fails.
 115
 116 **/
 117 EFI_STATUS
 118 SdioSendOpCond (
 119   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 120   IN UINT8                              Slot,
 121   IN UINT32                             VoltageWindow,
 122   IN BOOLEAN                            S18R
 123   )
 124 {
 125   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 126   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 127   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 128   EFI_STATUS                            Status;
 129   UINT32                                Switch;
 130
 131   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 132   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 133   ZeroMem (&Packet, sizeof (Packet));
 134
 135   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 136   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 137   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 138
 139   SdMmcCmdBlk.CommandIndex = SDIO_SEND_OP_COND;
 140   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBcr;
 141   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR4;
 142
 143   Switch = S18R ? BIT24 : 0;
 144
 145   SdMmcCmdBlk.CommandArgument = (VoltageWindow & 0xFFFFFF) | Switch;
 146
 147   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 148
 149   return Status;
 150 }
 151
 152 /**
 153   Send command SD_SEND_OP_COND to the device to see whether it is SDIO device.
 154
 155   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 156
 157   @param[in]  PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 158   @param[in]  Slot           The slot number of the SD card to send the command to.
 159   @param[in]  Rca            The relative device address of addressed device.
 160   @param[in]  VoltageWindow  The supply voltage window.
 161   @param[in]  S18R           The boolean to show if it should switch to 1.8v.
 162   @param[in]  Xpc            The boolean to show if it should provide 0.36w power control.
 163   @param[in]  Hcs            The boolean to show if it support host capacity info.
 164   @param[out] Ocr            The buffer to store returned OCR register value.
 165
 166   @retval EFI_SUCCESS        The operation is done correctly.
 167   @retval Others             The operation fails.
 168
 169 **/
 170 EFI_STATUS
 171 SdCardSendOpCond (
 172   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
 173   IN     UINT8                          Slot,
 174   IN     UINT16                         Rca,
 175   IN     UINT32                         VoltageWindow,
 176   IN     BOOLEAN                        S18R,
 177   IN     BOOLEAN                        Xpc,
 178   IN     BOOLEAN                        Hcs,
 179      OUT UINT32                         *Ocr
 180   )
 181 {
 182   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 183   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 184   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 185   EFI_STATUS                            Status;
 186   UINT32                                Switch;
 187   UINT32                                MaxPower;
 188   UINT32                                HostCapacity;
 189
 190   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 191   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 192   ZeroMem (&Packet, sizeof (Packet));
 193
 194   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 195   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 196   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 197
 198   SdMmcCmdBlk.CommandIndex = SD_APP_CMD;
 199   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 200   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 201   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 202
 203   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 204   if (EFI_ERROR (Status)) {
 205     return Status;
 206   }
 207
 208   SdMmcCmdBlk.CommandIndex = SD_SEND_OP_COND;
 209   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBcr;
 210   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR3;
 211
 212   Switch       = S18R ? BIT24 : 0;
 213   MaxPower     = Xpc ? BIT28 : 0;
 214   HostCapacity = Hcs ? BIT30 : 0;
 215
 216   SdMmcCmdBlk.CommandArgument = (VoltageWindow & 0xFFFFFF) | Switch | MaxPower | HostCapacity;
 217
 218   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 219   if (!EFI_ERROR (Status)) {
 220     //
 221     // For details, refer to SD Host Controller Simplified Spec 3.0 Table 2-12.
 222     //
 223     *Ocr = SdMmcStatusBlk.Resp0;
 224   }
 225
 226   return Status;
 227 }
 228
 229 /**
 230   Broadcast command ALL_SEND_CID to the bus to ask all the SD devices to send the
 231   data of their CID registers.
 232
 233   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 234
 235   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 236   @param[in] Slot           The slot number of the SD card to send the command to.
 237
 238   @retval EFI_SUCCESS       The operation is done correctly.
 239   @retval Others            The operation fails.
 240
 241 **/
 242 EFI_STATUS
 243 SdCardAllSendCid (
 244   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 245   IN UINT8                              Slot
 246   )
 247 {
 248   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 249   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 250   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 251   EFI_STATUS                            Status;
 252
 253   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 254   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 255   ZeroMem (&Packet, sizeof (Packet));
 256
 257   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 258   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 259   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 260
 261   SdMmcCmdBlk.CommandIndex = SD_ALL_SEND_CID;
 262   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBcr;
 263   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR2;
 264
 265   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 266
 267   return Status;
 268 }
 269
 270 /**
 271   Send command SET_RELATIVE_ADDR to the SD device to assign a Relative device
 272   Address (RCA).
 273
 274   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 275
 276   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 277   @param[in]  Slot          The slot number of the SD card to send the command to.
 278   @param[out] Rca           The relative device address to assign.
 279
 280   @retval EFI_SUCCESS       The operation is done correctly.
 281   @retval Others            The operation fails.
 282
 283 **/
 284 EFI_STATUS
 285 SdCardSetRca (
 286   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
 287   IN     UINT8                          Slot,
 288      OUT UINT16                         *Rca
 289   )
 290 {
 291   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 292   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 293   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 294   EFI_STATUS                            Status;
 295
 296   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 297   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 298   ZeroMem (&Packet, sizeof (Packet));
 299
 300   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 301   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 302   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 303
 304   SdMmcCmdBlk.CommandIndex = SD_SET_RELATIVE_ADDR;
 305   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBcr;
 306   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR6;
 307
 308   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 309   if (!EFI_ERROR (Status)) {
 310     *Rca = (UINT16)(SdMmcStatusBlk.Resp0 >> 16);
 311   }
 312
 313   return Status;
 314 }
 315
 316
 317
 318
 319
 320 /**
 321   Send command SELECT_DESELECT_CARD to the SD device to select/deselect it.
 322
 323   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 324
 325   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 326   @param[in]  Slot          The slot number of the SD card to send the command to.
 327   @param[in]  Rca           The relative device address of selected device.
 328
 329   @retval EFI_SUCCESS       The operation is done correctly.
 330   @retval Others            The operation fails.
 331
 332 **/
 333 EFI_STATUS
 334 SdCardSelect (
 335   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 336   IN UINT8                              Slot,
 337   IN UINT16                             Rca
 338   )
 339 {
 340   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 341   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 342   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 343   EFI_STATUS                            Status;
 344
 345   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 346   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 347   ZeroMem (&Packet, sizeof (Packet));
 348
 349   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 350   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 351   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 352
 353   SdMmcCmdBlk.CommandIndex = SD_SELECT_DESELECT_CARD;
 354   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 355   if (Rca != 0) {
 356     SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1b;
 357   }
 358   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 359
 360   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 361
 362   return Status;
 363 }
 364
 365 /**
 366   Send command VOLTAGE_SWITCH to the SD device to switch the voltage of the device.
 367
 368   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 369
 370   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 371   @param[in]  Slot          The slot number of the SD card to send the command to.
 372
 373   @retval EFI_SUCCESS       The operation is done correctly.
 374   @retval Others            The operation fails.
 375
 376 **/
 377 EFI_STATUS
 378 SdCardVoltageSwitch (
 379   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 380   IN UINT8                              Slot
 381   )
 382 {
 383   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 384   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 385   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 386   EFI_STATUS                            Status;
 387
 388   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 389   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 390   ZeroMem (&Packet, sizeof (Packet));
 391
 392   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 393   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 394   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 395
 396   SdMmcCmdBlk.CommandIndex = SD_VOLTAGE_SWITCH;
 397   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 398   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 399   SdMmcCmdBlk.CommandArgument = 0;
 400
 401   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 402
 403   return Status;
 404 }
 405
 406 /**
 407   Send command SET_BUS_WIDTH to the SD device to set the bus width.
 408
 409   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 410
 411   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 412   @param[in] Slot           The slot number of the SD card to send the command to.
 413   @param[in] Rca            The relative device address of addressed device.
 414   @param[in] BusWidth       The bus width to be set, it could be 1 or 4.
 415
 416   @retval EFI_SUCCESS       The operation is done correctly.
 417   @retval Others            The operation fails.
 418
 419 **/
 420 EFI_STATUS
 421 SdCardSetBusWidth (
 422   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 423   IN UINT8                              Slot,
 424   IN UINT16                             Rca,
 425   IN UINT8                              BusWidth
 426   )
 427 {
 428   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 429   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 430   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 431   EFI_STATUS                            Status;
 432   UINT8                                 Value;
 433
 434   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 435   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 436   ZeroMem (&Packet, sizeof (Packet));
 437
 438   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 439   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 440   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 441
 442   SdMmcCmdBlk.CommandIndex = SD_APP_CMD;
 443   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 444   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 445   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 446
 447   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 448   if (EFI_ERROR (Status)) {
 449     return Status;
 450   }
 451
 452   SdMmcCmdBlk.CommandIndex = SD_SET_BUS_WIDTH;
 453   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 454   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 455
 456   if (BusWidth == 1) {
 457     Value = 0;
 458   } else if (BusWidth == 4) {
 459     Value = 2;
 460   } else {
 461     return EFI_INVALID_PARAMETER;
 462   }
 463
 464   SdMmcCmdBlk.CommandArgument = Value & 0x3;
 465
 466   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 467   return Status;
 468 }
 469
 470 /**
 471   Send command SWITCH_FUNC to the SD device to check switchable function or switch card function.
 472
 473   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 474
 475   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 476   @param[in]  Slot          The slot number of the SD card to send the command to.
 477   @param[in]  AccessMode    The value for access mode group.
 478   @param[in]  CommandSystem The value for command set group.
 479   @param[in]  DriveStrength The value for drive length group.
 480   @param[in]  PowerLimit    The value for power limit group.
 481   @param[in]  Mode          Switch or check function.
 482   @param[out] SwitchResp    The return switch function status.
 483
 484   @retval EFI_SUCCESS       The operation is done correctly.
 485   @retval Others            The operation fails.
 486
 487 **/
 488 EFI_STATUS
 489 SdCardSwitch (
 490   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
 491   IN     UINT8                          Slot,
 492   IN     UINT8                          AccessMode,
 493   IN     UINT8                          CommandSystem,
 494   IN     UINT8                          DriveStrength,
 495   IN     UINT8                          PowerLimit,
 496   IN     BOOLEAN                        Mode,
 497      OUT UINT8                          *SwitchResp
 498   )
 499 {
 500   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 501   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 502   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 503   EFI_STATUS                            Status;
 504   UINT32                                ModeValue;
 505
 506   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 507   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 508   ZeroMem (&Packet, sizeof (Packet));
 509
 510   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 511   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 512   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 513
 514   SdMmcCmdBlk.CommandIndex = SD_SWITCH_FUNC;
 515   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAdtc;
 516   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 517
 518   ModeValue = Mode ? BIT31 : 0;
 519   SdMmcCmdBlk.CommandArgument = (AccessMode & 0xF) | ((PowerLimit & 0xF) << 4) | \
 520                                 ((DriveStrength & 0xF) << 8) | ((DriveStrength & 0xF) << 12) | \
 521                                 ModeValue;
 522
 523   Packet.InDataBuffer     = SwitchResp;
 524   Packet.InTransferLength = 64;
 525
 526   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 527
 528   return Status;
 529 }
 530
 531 /**
 532   Send command SEND_STATUS to the addressed SD device to get its status register.
 533
 534   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 535
 536   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 537   @param[in]  Slot          The slot number of the SD card to send the command to.
 538   @param[in]  Rca           The relative device address of addressed device.
 539   @param[out] DevStatus     The returned device status.
 540
 541   @retval EFI_SUCCESS       The operation is done correctly.
 542   @retval Others            The operation fails.
 543
 544 **/
 545 EFI_STATUS
 546 SdCardSendStatus (
 547   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
 548   IN     UINT8                          Slot,
 549   IN     UINT16                         Rca,
 550      OUT UINT32                         *DevStatus
 551   )
 552 {
 553   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 554   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 555   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 556   EFI_STATUS                            Status;
 557
 558   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 559   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 560   ZeroMem (&Packet, sizeof (Packet));
 561
 562   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 563   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 564   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 565
 566   SdMmcCmdBlk.CommandIndex = SD_SEND_STATUS;
 567   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 568   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 569   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 570
 571   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 572   if (!EFI_ERROR (Status)) {
 573     *DevStatus = SdMmcStatusBlk.Resp0;
 574   }
 575
 576   return Status;
 577 }
 578
 579 /**
 580   Send command SEND_TUNING_BLOCK to the SD device for HS200 optimal sampling point
 581   detection.
 582
 583   It may be sent up to 40 times until the host finishes the tuning procedure.
 584
 585   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 for details.
 586
 587   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 588   @param[in] Slot           The slot number of the SD card to send the command to.
 589
 590   @retval EFI_SUCCESS       The operation is done correctly.
 591   @retval Others            The operation fails.
 592
 593 **/
 594 EFI_STATUS
 595 SdCardSendTuningBlk (
 596   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 597   IN UINT8                              Slot
 598   )
 599 {
 600   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 601   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 602   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 603   EFI_STATUS                            Status;
 604   UINT8                                 TuningBlock[64];
 605
 606   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 607   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 608   ZeroMem (&Packet, sizeof (Packet));
 609
 610   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 611   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 612   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 613
 614   SdMmcCmdBlk.CommandIndex = SD_SEND_TUNING_BLOCK;
 615   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAdtc;
 616   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 617   SdMmcCmdBlk.CommandArgument = 0;
 618
 619   Packet.InDataBuffer     = TuningBlock;
 620   Packet.InTransferLength = sizeof (TuningBlock);
 621
 622   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 623
 624   return Status;
 625 }
 626
 627 /**
 628   Tunning the sampling point of SDR104 or SDR50 bus speed mode.
 629
 630   Command SD_SEND_TUNING_BLOCK may be sent up to 40 times until the host finishes the
 631   tuning procedure.
 632
 633   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 and
 634   SD Host Controller Simplified Spec 3.0 section Figure 3-7 for details.
 635
 636   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 637   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 638   @param[in] Slot           The slot number of the SD card to send the command to.
 639
 640   @retval EFI_SUCCESS       The operation is done correctly.
 641   @retval Others            The operation fails.
 642
 643 **/
 644 EFI_STATUS
 645 SdCardTuningClock (
 646   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 647   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 648   IN UINT8                              Slot
 649   )
 650 {
 651   EFI_STATUS          Status;
 652   UINT8               HostCtrl2;
 653   UINT8               Retry;
 654
 655   //
 656   // Notify the host that the sampling clock tuning procedure starts.
 657   //
 658   HostCtrl2 = BIT6;
 659   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 660   if (EFI_ERROR (Status)) {
 661     return Status;
 662   }
 663   //
 664   // Ask the device to send a sequence of tuning blocks till the tuning procedure is done.
 665   //
 666   Retry = 0;
 667   do {
 668     Status = SdCardSendTuningBlk (PassThru, Slot);
 669     if (EFI_ERROR (Status)) {
 670       DEBUG ((DEBUG_ERROR, "SdCardSendTuningBlk: Send tuning block fails with %r\n", Status));
 671       return Status;
 672     }
 673
 674     Status = SdMmcHcRwMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, TRUE, sizeof (HostCtrl2), &HostCtrl2);
 675     if (EFI_ERROR (Status)) {
 676       return Status;
 677     }
 678
 679     if ((HostCtrl2 & (BIT6 | BIT7)) == 0) {
 680       break;
 681     }
 682     if ((HostCtrl2 & (BIT6 | BIT7)) == BIT7) {
 683       return EFI_SUCCESS;
 684     }
 685   } while (++Retry < 40);
 686
 687   DEBUG ((DEBUG_ERROR, "SdCardTuningClock: Send tuning block fails at %d times with HostCtrl2 %02x\n", Retry, HostCtrl2));
 688   //
 689   // Abort the tuning procedure and reset the tuning circuit.
 690   //
 691   HostCtrl2 = (UINT8)~(BIT6 | BIT7);
 692   Status = SdMmcHcAndMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 693   if (EFI_ERROR (Status)) {
 694     return Status;
 695   }
 696   return EFI_DEVICE_ERROR;
 697 }
 698
 699 /**
 700   Switch the bus width to specified width.
 701
 702   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 and
 703   SD Host Controller Simplified Spec 3.0 section Figure 3-7 for details.
 704
 705   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 706   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 707   @param[in] Slot           The slot number of the SD card to send the command to.
 708   @param[in] Rca            The relative device address to be assigned.
 709   @param[in] BusWidth       The bus width to be set, it could be 4 or 8.
 710
 711   @retval EFI_SUCCESS       The operation is done correctly.
 712   @retval Others            The operation fails.
 713
 714 **/
 715 EFI_STATUS
 716 SdCardSwitchBusWidth (
 717   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 718   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 719   IN UINT8                              Slot,
 720   IN UINT16                             Rca,
 721   IN UINT8                              BusWidth
 722   )
 723 {
 724   EFI_STATUS          Status;
 725   UINT32              DevStatus;
 726
 727   Status = SdCardSetBusWidth (PassThru, Slot, Rca, BusWidth);
 728   if (EFI_ERROR (Status)) {
 729     DEBUG ((DEBUG_ERROR, "SdCardSwitchBusWidth: Switch to bus width %d fails with %r\n", BusWidth, Status));
 730     return Status;
 731   }
 732
 733   Status = SdCardSendStatus (PassThru, Slot, Rca, &DevStatus);
 734   if (EFI_ERROR (Status)) {
 735     DEBUG ((DEBUG_ERROR, "SdCardSwitchBusWidth: Send status fails with %r\n", Status));
 736     return Status;
 737   }
 738   //
 739   // Check the switch operation is really successful or not.
 740   //
 741   if ((DevStatus >> 16) != 0) {
 742     DEBUG ((DEBUG_ERROR, "SdCardSwitchBusWidth: The switch operation fails as DevStatus is 0x%08x\n", DevStatus));
 743     return EFI_DEVICE_ERROR;
 744   }
 745
 746   Status = SdMmcHcSetBusWidth (PciIo, Slot, BusWidth);
 747
 748   return Status;
 749 }
 750
 751 /**
 752   Switch the high speed timing according to request.
 753
 754   Refer to SD Physical Layer Simplified Spec 4.1 Section 4.7 and
 755   SD Host Controller Simplified Spec 3.0 section Figure 2-29 for details.
 756
 757   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 758   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 759   @param[in] Slot           The slot number of the SD card to send the command to.
 760   @param[in] Rca            The relative device address to be assigned.
 761   @param[in] S18A           The boolean to show if it's a UHS-I SD card.
 762
 763   @retval EFI_SUCCESS       The operation is done correctly.
 764   @retval Others            The operation fails.
 765
 766 **/
 767 EFI_STATUS
 768 SdCardSetBusMode (
 769   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 770   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 771   IN UINT8                              Slot,
 772   IN UINT16                             Rca,
 773   IN BOOLEAN                            S18A
 774   )
 775 {
 776   EFI_STATUS                   Status;
 777   SD_MMC_HC_SLOT_CAP           *Capability;
 778   UINT32                       ClockFreq;
 779   UINT8                        BusWidth;
 780   UINT8                        AccessMode;
 781   UINT8                        HostCtrl1;
 782   UINT8                        SwitchResp[64];
 783   SD_MMC_BUS_MODE              Timing;
 784   SD_MMC_HC_PRIVATE_DATA       *Private;
 785
 786   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
 787
 788   Capability = &Private->Capability[Slot];
 789
 790   Status = SdCardSelect (PassThru, Slot, Rca);
 791   if (EFI_ERROR (Status)) {
 792     return Status;
 793   }
 794
 795   BusWidth = 4;
 796
 797   Status = SdCardSwitchBusWidth (PciIo, PassThru, Slot, Rca, BusWidth);
 798   if (EFI_ERROR (Status)) {
 799     return Status;
 800   }
 801   //
 802   // Get the supported bus speed from SWITCH cmd return data group #1.
 803   //
 804   Status = SdCardSwitch (PassThru, Slot, 0xF, 0xF, 0xF, 0xF, FALSE, SwitchResp);
 805   if (EFI_ERROR (Status)) {
 806     return Status;
 807   }
 808   //
 809   // Calculate supported bus speed/bus width/clock frequency by host and device capability.
 810   //
 811   ClockFreq = 0;
 812   if (S18A && (Capability->Sdr104 != 0) && ((SwitchResp[13] & BIT3) != 0)) {
 813     ClockFreq = 208;
 814     AccessMode = 3;
 815     Timing = SdMmcUhsSdr104;
 816   } else if (S18A && (Capability->Sdr50 != 0) && ((SwitchResp[13] & BIT2) != 0)) {
 817     ClockFreq = 100;
 818     AccessMode = 2;
 819     Timing = SdMmcUhsSdr50;
 820   } else if (S18A && (Capability->Ddr50 != 0) && ((SwitchResp[13] & BIT4) != 0)) {
 821     ClockFreq = 50;
 822     AccessMode = 4;
 823     Timing = SdMmcUhsDdr50;
 824   } else if ((SwitchResp[13] & BIT1) != 0) {
 825     ClockFreq = 50;
 826     AccessMode = 1;
 827     Timing = SdMmcUhsSdr25;
 828   } else {
 829     ClockFreq = 25;
 830     AccessMode = 0;
 831     Timing = SdMmcUhsSdr12;
 832   }
 833
 834   Status = SdCardSwitch (PassThru, Slot, AccessMode, 0xF, 0xF, 0xF, TRUE, SwitchResp);
 835   if (EFI_ERROR (Status)) {
 836     return Status;
 837   }
 838
 839   if ((SwitchResp[16] & 0xF) != AccessMode) {
 840     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));
 841     return EFI_DEVICE_ERROR;
 842   }
 843
 844   DEBUG ((DEBUG_INFO, "SdCardSetBusMode: Switch to AccessMode %d ClockFreq %d BusWidth %d\n", AccessMode, ClockFreq, BusWidth));
 845
 846   //
 847   // Set to Hight Speed timing
 848   //
 849   if (AccessMode == 1) {
 850     HostCtrl1 = BIT2;
 851     Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL1, sizeof (HostCtrl1), &HostCtrl1);
 852     if (EFI_ERROR (Status)) {
 853       return Status;
 854     }
 855   }
 856
 857   Status = SdMmcHcUhsSignaling (Private->ControllerHandle, PciIo, Slot, Timing);
 858   if (EFI_ERROR (Status)) {
 859     return Status;
 860   }
 861
 862   Status = SdMmcHcClockSupply (PciIo, Slot, ClockFreq * 1000, Private->BaseClkFreq[Slot], Private->ControllerVersion[Slot]);
 863   if (EFI_ERROR (Status)) {
 864     return Status;
 865   }
 866
 867   if (mOverride != NULL && mOverride->NotifyPhase != NULL) {
 868     Status = mOverride->NotifyPhase (
 869                           Private->ControllerHandle,
 870                           Slot,
 871                           EdkiiSdMmcSwitchClockFreqPost,
 872                           &Timing
 873                           );
 874     if (EFI_ERROR (Status)) {
 875       DEBUG ((
 876         DEBUG_ERROR,
 877         "%a: SD/MMC switch clock freq post notifier callback failed - %r\n",
 878         __FUNCTION__,
 879         Status
 880         ));
 881       return Status;
 882     }
 883   }
 884
 885   if ((AccessMode == 3) || ((AccessMode == 2) && (Capability->TuningSDR50 != 0))) {
 886     Status = SdCardTuningClock (PciIo, PassThru, Slot);
 887     if (EFI_ERROR (Status)) {
 888       return Status;
 889     }
 890   }
 891
 892   return Status;
 893 }
 894
 895 /**
 896   Execute SD device identification procedure.
 897
 898   Refer to SD Physical Layer Simplified Spec 4.1 Section 3.6 for details.
 899
 900   @param[in] Private        A pointer to the SD_MMC_HC_PRIVATE_DATA instance.
 901   @param[in] Slot           The slot number of the SD card to send the command to.
 902
 903   @retval EFI_SUCCESS       There is a SD card.
 904   @retval Others            There is not a SD card.
 905
 906 **/
 907 EFI_STATUS
 908 SdCardIdentification (
 909   IN SD_MMC_HC_PRIVATE_DATA             *Private,
 910   IN UINT8                              Slot
 911   )
 912 {
 913   EFI_STATUS                     Status;
 914   EFI_PCI_IO_PROTOCOL            *PciIo;
 915   EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru;
 916   UINT32                         Ocr;
 917   UINT16                         Rca;
 918   BOOLEAN                        Xpc;
 919   BOOLEAN                        S18r;
 920   UINT64                         MaxCurrent;
 921   UINT16                         ControllerVer;
 922   UINT8                          PowerCtrl;
 923   UINT32                         PresentState;
 924   UINT8                          HostCtrl2;
 925   UINTN                          Retry;
 926
 927   PciIo    = Private->PciIo;
 928   PassThru = &Private->PassThru;
 929   //
 930   // 1. Send Cmd0 to the device
 931   //
 932   Status = SdCardReset (PassThru, Slot);
 933   if (EFI_ERROR (Status)) {
 934     DEBUG ((DEBUG_INFO, "SdCardIdentification: Executing Cmd0 fails with %r\n", Status));
 935     return Status;
 936   }
 937   //
 938   // 2. Send Cmd8 to the device
 939   //
 940   Status = SdCardVoltageCheck (PassThru, Slot, 0x1, 0xFF);
 941   if (EFI_ERROR (Status)) {
 942     DEBUG ((DEBUG_INFO, "SdCardIdentification: Executing Cmd8 fails with %r\n", Status));
 943     return Status;
 944   }
 945   //
 946   // 3. Send SDIO Cmd5 to the device to the SDIO device OCR register.
 947   //
 948   Status = SdioSendOpCond (PassThru, Slot, 0, FALSE);
 949   if (!EFI_ERROR (Status)) {
 950     DEBUG ((DEBUG_INFO, "SdCardIdentification: Found SDIO device, ignore it as we don't support\n"));
 951     return EFI_DEVICE_ERROR;
 952   }
 953   //
 954   // 4. Send Acmd41 with voltage window 0 to the device
 955   //
 956   Status = SdCardSendOpCond (PassThru, Slot, 0, 0, FALSE, FALSE, FALSE, &Ocr);
 957   if (EFI_ERROR (Status)) {
 958     DEBUG ((DEBUG_INFO, "SdCardIdentification: Executing SdCardSendOpCond fails with %r\n", Status));
 959     return EFI_DEVICE_ERROR;
 960   }
 961
 962   if (Private->Capability[Slot].Voltage33 != 0) {
 963     //
 964     // Support 3.3V
 965     //
 966     MaxCurrent = ((UINT32)Private->MaxCurrent[Slot] & 0xFF) * 4;
 967   } else if (Private->Capability[Slot].Voltage30 != 0) {
 968     //
 969     // Support 3.0V
 970     //
 971     MaxCurrent = (((UINT32)Private->MaxCurrent[Slot] >> 8) & 0xFF) * 4;
 972   } else if (Private->Capability[Slot].Voltage18 != 0) {
 973     //
 974     // Support 1.8V
 975     //
 976     MaxCurrent = (((UINT32)Private->MaxCurrent[Slot] >> 16) & 0xFF) * 4;
 977   } else {
 978     ASSERT (FALSE);
 979     return EFI_DEVICE_ERROR;
 980   }
 981
 982   if (MaxCurrent >= 150) {
 983     Xpc = TRUE;
 984   } else {
 985     Xpc = FALSE;
 986   }
 987
 988   Status = SdMmcHcRwMmio (PciIo, Slot, SD_MMC_HC_CTRL_VER, TRUE, sizeof (ControllerVer), &ControllerVer);
 989   if (EFI_ERROR (Status)) {
 990     return Status;
 991   }
 992
 993   if (((ControllerVer & 0xFF) >= SD_MMC_HC_CTRL_VER_300) &&
 994       ((ControllerVer & 0xFF) <= SD_MMC_HC_CTRL_VER_420)) {
 995     S18r = TRUE;
 996   } else if (((ControllerVer & 0xFF) == SD_MMC_HC_CTRL_VER_100) || ((ControllerVer & 0xFF) == SD_MMC_HC_CTRL_VER_200)) {
 997     S18r = FALSE;
 998   } else {
 999     ASSERT (FALSE);
1000     return EFI_UNSUPPORTED;
1001   }
1002   //
1003   // 5. Repeatly send Acmd41 with supply voltage window to the device.
1004   //    Note here we only support the cards complied with SD physical
1005   //    layer simplified spec version 2.0 and version 3.0 and above.
1006   //
1007   Ocr   = 0;
1008   Retry = 0;
1009   do {
1010     Status = SdCardSendOpCond (PassThru, Slot, 0, Ocr, S18r, Xpc, TRUE, &Ocr);
1011     if (EFI_ERROR (Status)) {
1012       DEBUG ((DEBUG_ERROR, "SdCardIdentification: SdCardSendOpCond fails with %r Ocr %x, S18r %x, Xpc %x\n", Status, Ocr, S18r, Xpc));
1013       return EFI_DEVICE_ERROR;
1014     }
1015
1016     if (Retry++ == 100) {
1017       DEBUG ((DEBUG_ERROR, "SdCardIdentification: SdCardSendOpCond fails too many times\n"));
1018       return EFI_DEVICE_ERROR;
1019     }
1020     gBS->Stall(10 * 1000);
1021   } while ((Ocr & BIT31) == 0);
1022
1023   //
1024   // 6. If the S18A bit is set and the Host Controller supports 1.8V signaling
1025   //    (One of support bits is set to 1: SDR50, SDR104 or DDR50 in the
1026   //    Capabilities register), switch its voltage to 1.8V.
1027   //
1028   if ((Private->Capability[Slot].Sdr50 != 0 ||
1029        Private->Capability[Slot].Sdr104 != 0 ||
1030        Private->Capability[Slot].Ddr50 != 0) &&
1031        ((Ocr & BIT24) != 0)) {
1032     Status = SdCardVoltageSwitch (PassThru, Slot);
1033     if (EFI_ERROR (Status)) {
1034       DEBUG ((DEBUG_ERROR, "SdCardIdentification: Executing SdCardVoltageSwitch fails with %r\n", Status));
1035       Status = EFI_DEVICE_ERROR;
1036       goto Error;
1037     } else {
1038       Status = SdMmcHcStopClock (PciIo, Slot);
1039       if (EFI_ERROR (Status)) {
1040         Status = EFI_DEVICE_ERROR;
1041         goto Error;
1042       }
1043
1044       SdMmcHcRwMmio (PciIo, Slot, SD_MMC_HC_PRESENT_STATE, TRUE, sizeof (PresentState), &PresentState);
1045       if (((PresentState >> 20) & 0xF) != 0) {
1046         DEBUG ((DEBUG_ERROR, "SdCardIdentification: SwitchVoltage fails with PresentState = 0x%x\n", PresentState));
1047         Status = EFI_DEVICE_ERROR;
1048         goto Error;
1049       }
1050       HostCtrl2  = BIT3;
1051       SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
1052
1053       gBS->Stall (5000);
1054
1055       SdMmcHcRwMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, TRUE, sizeof (HostCtrl2), &HostCtrl2);
1056       if ((HostCtrl2 & BIT3) == 0) {
1057         DEBUG ((DEBUG_ERROR, "SdCardIdentification: SwitchVoltage fails with HostCtrl2 = 0x%x\n", HostCtrl2));
1058         Status = EFI_DEVICE_ERROR;
1059         goto Error;
1060       }
1061
1062       SdMmcHcInitClockFreq (PciIo, Slot, Private->BaseClkFreq[Slot], Private->ControllerVersion[Slot]);
1063
1064       gBS->Stall (1000);
1065
1066       SdMmcHcRwMmio (PciIo, Slot, SD_MMC_HC_PRESENT_STATE, TRUE, sizeof (PresentState), &PresentState);
1067       if (((PresentState >> 20) & 0xF) != 0xF) {
1068         DEBUG ((DEBUG_ERROR, "SdCardIdentification: SwitchVoltage fails with PresentState = 0x%x, It should be 0xF\n", PresentState));
1069         Status = EFI_DEVICE_ERROR;
1070         goto Error;
1071       }
1072     }
1073     DEBUG ((DEBUG_INFO, "SdCardIdentification: Switch to 1.8v signal voltage success\n"));
1074   }
1075
1076   Status = SdCardAllSendCid (PassThru, Slot);
1077   if (EFI_ERROR (Status)) {
1078     DEBUG ((DEBUG_ERROR, "SdCardIdentification: Executing SdCardAllSendCid fails with %r\n", Status));
1079     return Status;
1080   }
1081
1082   Status = SdCardSetRca (PassThru, Slot, &Rca);
1083   if (EFI_ERROR (Status)) {
1084     DEBUG ((DEBUG_ERROR, "SdCardIdentification: Executing SdCardSetRca fails with %r\n", Status));
1085     return Status;
1086   }
1087   //
1088   // Enter Data Tranfer Mode.
1089   //
1090   DEBUG ((DEBUG_INFO, "SdCardIdentification: Found a SD device at slot [%d]\n", Slot));
1091   Private->Slot[Slot].CardType = SdCardType;
1092
1093   Status = SdCardSetBusMode (PciIo, PassThru, Slot, Rca, ((Ocr & BIT24) != 0));
1094
1095   return Status;
1096
1097 Error:
1098   //
1099   // Set SD Bus Power = 0
1100   //
1101   PowerCtrl = (UINT8)~BIT0;
1102   Status = SdMmcHcAndMmio (PciIo, Slot, SD_MMC_HC_POWER_CTRL, sizeof (PowerCtrl), &PowerCtrl);
1103   return EFI_DEVICE_ERROR;
1104 }
1105