MdeModulePkg/Bus/Pci/SdMmcPciHcDxe/EmmcDevice.c

   1 /** @file
   2   This file provides some helper functions which are specific for EMMC device.
   3
   4   Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "SdMmcPciHcDxe.h"
  16
  17 /**
  18   Send command GO_IDLE_STATE (CMD0 with argument of 0x00000000) to the device to
  19   make it go to Idle State.
  20
  21   Refer to EMMC Electrical Standard Spec 5.1 Section 6.4 for details.
  22
  23   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
  24   @param[in] Slot           The slot number of the SD card to send the command to.
  25
  26   @retval EFI_SUCCESS       The EMMC device is reset correctly.
  27   @retval Others            The device reset fails.
  28
  29 **/
  30 EFI_STATUS
  31 EmmcReset (
  32   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
  33   IN UINT8                              Slot
  34   )
  35 {
  36   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
  37   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
  38   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
  39   EFI_STATUS                            Status;
  40
  41   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
  42   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
  43   ZeroMem (&Packet, sizeof (Packet));
  44
  45   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
  46   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
  47   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
  48
  49   SdMmcCmdBlk.CommandIndex = EMMC_GO_IDLE_STATE;
  50   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBc;
  51   SdMmcCmdBlk.ResponseType = 0;
  52   SdMmcCmdBlk.CommandArgument = 0;
  53
  54   gBS->Stall (1000);
  55
  56   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
  57
  58   return Status;
  59 }
  60
  61 /**
  62   Send command SEND_OP_COND to the EMMC device to get the data of the OCR register.
  63
  64   Refer to EMMC Electrical Standard Spec 5.1 Section 6.4 for details.
  65
  66   @param[in]      PassThru  A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
  67   @param[in]      Slot      The slot number of the SD card to send the command to.
  68   @param[in, out] Argument  On input, the argument of SEND_OP_COND is to send to the device.
  69                             On output, the argument is the value of OCR register.
  70
  71   @retval EFI_SUCCESS       The operation is done correctly.
  72   @retval Others            The operation fails.
  73
  74 **/
  75 EFI_STATUS
  76 EmmcGetOcr (
  77   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
  78   IN     UINT8                          Slot,
  79   IN OUT UINT32                         *Argument
  80   )
  81 {
  82   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
  83   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
  84   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
  85   EFI_STATUS                            Status;
  86
  87   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
  88   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
  89   ZeroMem (&Packet, sizeof (Packet));
  90
  91   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
  92   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
  93   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
  94
  95   SdMmcCmdBlk.CommandIndex = EMMC_SEND_OP_COND;
  96   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBcr;
  97   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR3;
  98   SdMmcCmdBlk.CommandArgument = *Argument;
  99
 100   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 101   if (!EFI_ERROR (Status)) {
 102     //
 103     // For details, refer to SD Host Controller Simplified Spec 3.0 Table 2-12.
 104     //
 105     *Argument = SdMmcStatusBlk.Resp0;
 106   }
 107
 108   return Status;
 109 }
 110
 111 /**
 112   Broadcast command ALL_SEND_CID to the bus to ask all the EMMC devices to send the
 113   data of their CID registers.
 114
 115   Refer to EMMC Electrical Standard Spec 5.1 Section 6.4 for details.
 116
 117   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 118   @param[in] Slot           The slot number of the SD card to send the command to.
 119
 120   @retval EFI_SUCCESS       The operation is done correctly.
 121   @retval Others            The operation fails.
 122
 123 **/
 124 EFI_STATUS
 125 EmmcGetAllCid (
 126   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 127   IN UINT8                              Slot
 128   )
 129 {
 130   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 131   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 132   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 133   EFI_STATUS                            Status;
 134
 135   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 136   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 137   ZeroMem (&Packet, sizeof (Packet));
 138
 139   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 140   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 141   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 142
 143   SdMmcCmdBlk.CommandIndex = EMMC_ALL_SEND_CID;
 144   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeBcr;
 145   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR2;
 146   SdMmcCmdBlk.CommandArgument = 0;
 147
 148   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 149
 150   return Status;
 151 }
 152
 153 /**
 154   Send command SET_RELATIVE_ADDR to the EMMC device to assign a Relative device
 155   Address (RCA).
 156
 157   Refer to EMMC Electrical Standard Spec 5.1 Section 6.4 for details.
 158
 159   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 160   @param[in] Slot           The slot number of the SD card to send the command to.
 161   @param[in] Rca            The relative device address to be assigned.
 162
 163   @retval EFI_SUCCESS       The operation is done correctly.
 164   @retval Others            The operation fails.
 165
 166 **/
 167 EFI_STATUS
 168 EmmcSetRca (
 169   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 170   IN UINT8                              Slot,
 171   IN UINT16                             Rca
 172   )
 173 {
 174   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 175   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 176   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 177   EFI_STATUS                            Status;
 178
 179   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 180   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 181   ZeroMem (&Packet, sizeof (Packet));
 182
 183   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 184   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 185   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 186
 187   SdMmcCmdBlk.CommandIndex = EMMC_SET_RELATIVE_ADDR;
 188   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 189   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 190   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 191
 192   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 193
 194   return Status;
 195 }
 196
 197 /**
 198   Send command SEND_CSD to the EMMC device to get the data of the CSD register.
 199
 200   Refer to EMMC Electrical Standard Spec 5.1 Section 6.10.4 for details.
 201
 202   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 203   @param[in]  Slot          The slot number of the SD card to send the command to.
 204   @param[in]  Rca           The relative device address of selected device.
 205   @param[out] Csd           The buffer to store the content of the CSD register.
 206                             Note the caller should ignore the lowest byte of this
 207                             buffer as the content of this byte is meaningless even
 208                             if the operation succeeds.
 209
 210   @retval EFI_SUCCESS       The operation is done correctly.
 211   @retval Others            The operation fails.
 212
 213 **/
 214 EFI_STATUS
 215 EmmcGetCsd (
 216   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
 217   IN     UINT8                          Slot,
 218   IN     UINT16                         Rca,
 219      OUT EMMC_CSD                       *Csd
 220   )
 221 {
 222   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 223   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 224   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 225   EFI_STATUS                            Status;
 226
 227   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 228   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 229   ZeroMem (&Packet, sizeof (Packet));
 230
 231   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 232   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 233   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 234
 235   SdMmcCmdBlk.CommandIndex = EMMC_SEND_CSD;
 236   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 237   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR2;
 238   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 239
 240   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 241   if (!EFI_ERROR (Status)) {
 242     //
 243     // For details, refer to SD Host Controller Simplified Spec 3.0 Table 2-12.
 244     //
 245     CopyMem (((UINT8*)Csd) + 1, &SdMmcStatusBlk.Resp0, sizeof (EMMC_CSD) - 1);
 246   }
 247
 248   return Status;
 249 }
 250
 251 /**
 252   Send command SELECT_DESELECT_CARD to the EMMC device to select/deselect it.
 253
 254   Refer to EMMC Electrical Standard Spec 5.1 Section 6.10.4 for details.
 255
 256   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 257   @param[in]  Slot          The slot number of the SD card to send the command to.
 258   @param[in]  Rca           The relative device address of selected device.
 259
 260   @retval EFI_SUCCESS       The operation is done correctly.
 261   @retval Others            The operation fails.
 262
 263 **/
 264 EFI_STATUS
 265 EmmcSelect (
 266   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 267   IN UINT8                              Slot,
 268   IN UINT16                             Rca
 269   )
 270 {
 271   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 272   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 273   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 274   EFI_STATUS                            Status;
 275
 276   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 277   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 278   ZeroMem (&Packet, sizeof (Packet));
 279
 280   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 281   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 282   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 283
 284   SdMmcCmdBlk.CommandIndex = EMMC_SELECT_DESELECT_CARD;
 285   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 286   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 287   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 288
 289   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 290
 291   return Status;
 292 }
 293
 294 /**
 295   Send command SEND_EXT_CSD to the EMMC device to get the data of the EXT_CSD register.
 296
 297   Refer to EMMC Electrical Standard Spec 5.1 Section 6.10.4 for details.
 298
 299   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 300   @param[in]  Slot          The slot number of the SD card to send the command to.
 301   @param[out] ExtCsd        The buffer to store the content of the EXT_CSD register.
 302
 303   @retval EFI_SUCCESS       The operation is done correctly.
 304   @retval Others            The operation fails.
 305
 306 **/
 307 EFI_STATUS
 308 EmmcGetExtCsd (
 309   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
 310   IN     UINT8                          Slot,
 311      OUT EMMC_EXT_CSD                   *ExtCsd
 312   )
 313 {
 314   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 315   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 316   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 317   EFI_STATUS                            Status;
 318
 319   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 320   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 321   ZeroMem (&Packet, sizeof (Packet));
 322
 323   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 324   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 325   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 326
 327   SdMmcCmdBlk.CommandIndex = EMMC_SEND_EXT_CSD;
 328   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAdtc;
 329   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 330   SdMmcCmdBlk.CommandArgument = 0x00000000;
 331
 332   Packet.InDataBuffer     = ExtCsd;
 333   Packet.InTransferLength = sizeof (EMMC_EXT_CSD);
 334
 335   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 336   return Status;
 337 }
 338
 339 /**
 340   Send command SWITCH to the EMMC device to switch the mode of operation of the
 341   selected Device or modifies the EXT_CSD registers.
 342
 343   Refer to EMMC Electrical Standard Spec 5.1 Section 6.10.4 for details.
 344
 345   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 346   @param[in]  Slot          The slot number of the SD card to send the command to.
 347   @param[in]  Access        The access mode of SWTICH command.
 348   @param[in]  Index         The offset of the field to be access.
 349   @param[in]  Value         The value to be set to the specified field of EXT_CSD register.
 350   @param[in]  CmdSet        The value of CmdSet field of EXT_CSD register.
 351
 352   @retval EFI_SUCCESS       The operation is done correctly.
 353   @retval Others            The operation fails.
 354
 355 **/
 356 EFI_STATUS
 357 EmmcSwitch (
 358   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 359   IN UINT8                              Slot,
 360   IN UINT8                              Access,
 361   IN UINT8                              Index,
 362   IN UINT8                              Value,
 363   IN UINT8                              CmdSet
 364   )
 365 {
 366   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 367   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 368   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 369   EFI_STATUS                            Status;
 370
 371   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 372   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 373   ZeroMem (&Packet, sizeof (Packet));
 374
 375   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 376   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 377   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 378
 379   SdMmcCmdBlk.CommandIndex = EMMC_SWITCH;
 380   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 381   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1b;
 382   SdMmcCmdBlk.CommandArgument = (Access << 24) | (Index << 16) | (Value << 8) | CmdSet;
 383
 384   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 385
 386   return Status;
 387 }
 388
 389 /**
 390   Send command SEND_STATUS to the addressed EMMC device to get its status register.
 391
 392   Refer to EMMC Electrical Standard Spec 5.1 Section 6.10.4 for details.
 393
 394   @param[in]  PassThru      A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 395   @param[in]  Slot          The slot number of the SD card to send the command to.
 396   @param[in]  Rca           The relative device address of addressed device.
 397   @param[out] DevStatus     The returned device status.
 398
 399   @retval EFI_SUCCESS       The operation is done correctly.
 400   @retval Others            The operation fails.
 401
 402 **/
 403 EFI_STATUS
 404 EmmcSendStatus (
 405   IN     EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru,
 406   IN     UINT8                          Slot,
 407   IN     UINT16                         Rca,
 408      OUT UINT32                         *DevStatus
 409   )
 410 {
 411   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 412   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 413   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 414   EFI_STATUS                            Status;
 415
 416   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 417   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 418   ZeroMem (&Packet, sizeof (Packet));
 419
 420   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 421   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 422   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 423
 424   SdMmcCmdBlk.CommandIndex = EMMC_SEND_STATUS;
 425   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAc;
 426   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 427   SdMmcCmdBlk.CommandArgument = (UINT32)Rca << 16;
 428
 429   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 430   if (!EFI_ERROR (Status)) {
 431     *DevStatus = SdMmcStatusBlk.Resp0;
 432   }
 433
 434   return Status;
 435 }
 436
 437 /**
 438   Send command SEND_TUNING_BLOCK to the EMMC device for HS200 optimal sampling point
 439   detection.
 440
 441   It may be sent up to 40 times until the host finishes the tuning procedure.
 442
 443   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 for details.
 444
 445   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 446   @param[in] Slot           The slot number of the SD card to send the command to.
 447   @param[in] BusWidth       The bus width to work.
 448
 449   @retval EFI_SUCCESS       The operation is done correctly.
 450   @retval Others            The operation fails.
 451
 452 **/
 453 EFI_STATUS
 454 EmmcSendTuningBlk (
 455   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 456   IN UINT8                              Slot,
 457   IN UINT8                              BusWidth
 458   )
 459 {
 460   EFI_SD_MMC_COMMAND_BLOCK              SdMmcCmdBlk;
 461   EFI_SD_MMC_STATUS_BLOCK               SdMmcStatusBlk;
 462   EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   Packet;
 463   EFI_STATUS                            Status;
 464   UINT8                                 TuningBlock[128];
 465
 466   ZeroMem (&SdMmcCmdBlk, sizeof (SdMmcCmdBlk));
 467   ZeroMem (&SdMmcStatusBlk, sizeof (SdMmcStatusBlk));
 468   ZeroMem (&Packet, sizeof (Packet));
 469
 470   Packet.SdMmcCmdBlk    = &SdMmcCmdBlk;
 471   Packet.SdMmcStatusBlk = &SdMmcStatusBlk;
 472   Packet.Timeout        = SD_MMC_HC_GENERIC_TIMEOUT;
 473
 474   SdMmcCmdBlk.CommandIndex = EMMC_SEND_TUNING_BLOCK;
 475   SdMmcCmdBlk.CommandType  = SdMmcCommandTypeAdtc;
 476   SdMmcCmdBlk.ResponseType = SdMmcResponseTypeR1;
 477   SdMmcCmdBlk.CommandArgument = 0;
 478
 479   Packet.InDataBuffer = TuningBlock;
 480   if (BusWidth == 8) {
 481     Packet.InTransferLength = sizeof (TuningBlock);
 482   } else {
 483     Packet.InTransferLength = 64;
 484   }
 485
 486   Status = SdMmcPassThruPassThru (PassThru, Slot, &Packet, NULL);
 487
 488   return Status;
 489 }
 490
 491 /**
 492   Tunning the clock to get HS200 optimal sampling point.
 493
 494   Command SEND_TUNING_BLOCK may be sent up to 40 times until the host finishes the
 495   tuning procedure.
 496
 497   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 498   Simplified Spec 3.0 Figure 2-29 for details.
 499
 500   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 501   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 502   @param[in] Slot           The slot number of the SD card to send the command to.
 503   @param[in] BusWidth       The bus width to work.
 504
 505   @retval EFI_SUCCESS       The operation is done correctly.
 506   @retval Others            The operation fails.
 507
 508 **/
 509 EFI_STATUS
 510 EmmcTuningClkForHs200 (
 511   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 512   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 513   IN UINT8                              Slot,
 514   IN UINT8                              BusWidth
 515   )
 516 {
 517   EFI_STATUS          Status;
 518   UINT8               HostCtrl2;
 519   UINT8               Retry;
 520
 521   //
 522   // Notify the host that the sampling clock tuning procedure starts.
 523   //
 524   HostCtrl2 = BIT6;
 525   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 526   if (EFI_ERROR (Status)) {
 527     return Status;
 528   }
 529   //
 530   // Ask the device to send a sequence of tuning blocks till the tuning procedure is done.
 531   //
 532   Retry = 0;
 533   do {
 534     Status = EmmcSendTuningBlk (PassThru, Slot, BusWidth);
 535     if (EFI_ERROR (Status)) {
 536       DEBUG ((DEBUG_ERROR, "EmmcTuningClkForHs200: Send tuning block fails with %r\n", Status));
 537       return Status;
 538     }
 539
 540     Status = SdMmcHcRwMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, TRUE, sizeof (HostCtrl2), &HostCtrl2);
 541     if (EFI_ERROR (Status)) {
 542       return Status;
 543     }
 544
 545     if ((HostCtrl2 & (BIT6 | BIT7)) == 0) {
 546       break;
 547     }
 548
 549     if ((HostCtrl2 & (BIT6 | BIT7)) == BIT7) {
 550       return EFI_SUCCESS;
 551     }
 552   } while (++Retry < 40);
 553
 554   DEBUG ((DEBUG_ERROR, "EmmcTuningClkForHs200: Send tuning block fails at %d times with HostCtrl2 %02x\n", Retry, HostCtrl2));
 555   //
 556   // Abort the tuning procedure and reset the tuning circuit.
 557   //
 558   HostCtrl2 = (UINT8)~(BIT6 | BIT7);
 559   Status = SdMmcHcAndMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 560   if (EFI_ERROR (Status)) {
 561     return Status;
 562   }
 563   return EFI_DEVICE_ERROR;
 564 }
 565
 566 /**
 567   Switch the bus width to specified width.
 568
 569   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.9 and SD Host Controller
 570   Simplified Spec 3.0 Figure 3-7 for details.
 571
 572   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 573   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 574   @param[in] Slot           The slot number of the SD card to send the command to.
 575   @param[in] Rca            The relative device address to be assigned.
 576   @param[in] IsDdr          If TRUE, use dual data rate data simpling method. Otherwise
 577                             use single data rate data simpling method.
 578   @param[in] BusWidth       The bus width to be set, it could be 4 or 8.
 579
 580   @retval EFI_SUCCESS       The operation is done correctly.
 581   @retval Others            The operation fails.
 582
 583 **/
 584 EFI_STATUS
 585 EmmcSwitchBusWidth (
 586   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 587   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 588   IN UINT8                              Slot,
 589   IN UINT16                             Rca,
 590   IN BOOLEAN                            IsDdr,
 591   IN UINT8                              BusWidth
 592   )
 593 {
 594   EFI_STATUS          Status;
 595   UINT8               Access;
 596   UINT8               Index;
 597   UINT8               Value;
 598   UINT8               CmdSet;
 599   UINT32              DevStatus;
 600
 601   //
 602   // Write Byte, the Value field is written into the byte pointed by Index.
 603   //
 604   Access = 0x03;
 605   Index  = OFFSET_OF (EMMC_EXT_CSD, BusWidth);
 606   if (BusWidth == 4) {
 607     Value = 1;
 608   } else if (BusWidth == 8) {
 609     Value = 2;
 610   } else {
 611     return EFI_INVALID_PARAMETER;
 612   }
 613
 614   if (IsDdr) {
 615     Value += 4;
 616   }
 617
 618   CmdSet = 0;
 619   Status = EmmcSwitch (PassThru, Slot, Access, Index, Value, CmdSet);
 620   if (EFI_ERROR (Status)) {
 621     DEBUG ((DEBUG_ERROR, "EmmcSwitchBusWidth: Switch to bus width %d fails with %r\n", BusWidth, Status));
 622     return Status;
 623   }
 624
 625   Status = EmmcSendStatus (PassThru, Slot, Rca, &DevStatus);
 626   if (EFI_ERROR (Status)) {
 627     DEBUG ((DEBUG_ERROR, "EmmcSwitchBusWidth: Send status fails with %r\n", Status));
 628     return Status;
 629   }
 630   //
 631   // Check the switch operation is really successful or not.
 632   //
 633   if ((DevStatus & BIT7) != 0) {
 634     DEBUG ((DEBUG_ERROR, "EmmcSwitchBusWidth: The switch operation fails as DevStatus is 0x%08x\n", DevStatus));
 635     return EFI_DEVICE_ERROR;
 636   }
 637
 638   Status = SdMmcHcSetBusWidth (PciIo, Slot, BusWidth);
 639
 640   return Status;
 641 }
 642
 643 /**
 644   Switch the clock frequency to the specified value.
 645
 646   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6 and SD Host Controller
 647   Simplified Spec 3.0 Figure 3-3 for details.
 648
 649   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 650   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 651   @param[in] Slot           The slot number of the SD card to send the command to.
 652   @param[in] Rca            The relative device address to be assigned.
 653   @param[in] HsTiming       The value to be written to HS_TIMING field of EXT_CSD register.
 654   @param[in] ClockFreq      The max clock frequency to be set, the unit is MHz.
 655
 656   @retval EFI_SUCCESS       The operation is done correctly.
 657   @retval Others            The operation fails.
 658
 659 **/
 660 EFI_STATUS
 661 EmmcSwitchClockFreq (
 662   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 663   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 664   IN UINT8                              Slot,
 665   IN UINT16                             Rca,
 666   IN UINT8                              HsTiming,
 667   IN UINT32                             ClockFreq
 668   )
 669 {
 670   EFI_STATUS                Status;
 671   UINT8                     Access;
 672   UINT8                     Index;
 673   UINT8                     Value;
 674   UINT8                     CmdSet;
 675   UINT32                    DevStatus;
 676   SD_MMC_HC_PRIVATE_DATA    *Private;
 677
 678   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
 679   //
 680   // Write Byte, the Value field is written into the byte pointed by Index.
 681   //
 682   Access = 0x03;
 683   Index  = OFFSET_OF (EMMC_EXT_CSD, HsTiming);
 684   Value  = HsTiming;
 685   CmdSet = 0;
 686
 687   Status = EmmcSwitch (PassThru, Slot, Access, Index, Value, CmdSet);
 688   if (EFI_ERROR (Status)) {
 689     DEBUG ((DEBUG_ERROR, "EmmcSwitchClockFreq: Switch to hstiming %d fails with %r\n", HsTiming, Status));
 690     return Status;
 691   }
 692
 693   Status = EmmcSendStatus (PassThru, Slot, Rca, &DevStatus);
 694   if (EFI_ERROR (Status)) {
 695     DEBUG ((DEBUG_ERROR, "EmmcSwitchClockFreq: Send status fails with %r\n", Status));
 696     return Status;
 697   }
 698   //
 699   // Check the switch operation is really successful or not.
 700   //
 701   if ((DevStatus & BIT7) != 0) {
 702     DEBUG ((DEBUG_ERROR, "EmmcSwitchClockFreq: The switch operation fails as DevStatus is 0x%08x\n", DevStatus));
 703     return EFI_DEVICE_ERROR;
 704   }
 705   //
 706   // Convert the clock freq unit from MHz to KHz.
 707   //
 708   Status = SdMmcHcClockSupply (PciIo, Slot, ClockFreq * 1000, Private->Capability[Slot]);
 709
 710   return Status;
 711 }
 712
 713 /**
 714   Switch to the High Speed timing according to request.
 715
 716   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 717   Simplified Spec 3.0 Figure 2-29 for details.
 718
 719   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 720   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 721   @param[in] Slot           The slot number of the SD card to send the command to.
 722   @param[in] Rca            The relative device address to be assigned.
 723   @param[in] ClockFreq      The max clock frequency to be set.
 724   @param[in] IsDdr          If TRUE, use dual data rate data simpling method. Otherwise
 725                             use single data rate data simpling method.
 726   @param[in] BusWidth       The bus width to be set, it could be 4 or 8.
 727
 728   @retval EFI_SUCCESS       The operation is done correctly.
 729   @retval Others            The operation fails.
 730
 731 **/
 732 EFI_STATUS
 733 EmmcSwitchToHighSpeed (
 734   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 735   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 736   IN UINT8                              Slot,
 737   IN UINT16                             Rca,
 738   IN UINT32                             ClockFreq,
 739   IN BOOLEAN                            IsDdr,
 740   IN UINT8                              BusWidth
 741   )
 742 {
 743   EFI_STATUS          Status;
 744   UINT8               HsTiming;
 745   UINT8               HostCtrl1;
 746   UINT8               HostCtrl2;
 747
 748   Status = EmmcSwitchBusWidth (PciIo, PassThru, Slot, Rca, IsDdr, BusWidth);
 749   if (EFI_ERROR (Status)) {
 750     return Status;
 751   }
 752   //
 753   // Set to Hight Speed timing
 754   //
 755   HostCtrl1 = BIT2;
 756   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL1, sizeof (HostCtrl1), &HostCtrl1);
 757   if (EFI_ERROR (Status)) {
 758     return Status;
 759   }
 760
 761   //
 762   // Clean UHS Mode Select field of Host Control 2 reigster before update
 763   //
 764   HostCtrl2 = (UINT8)~0x7;
 765   Status = SdMmcHcAndMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 766   if (EFI_ERROR (Status)) {
 767     return Status;
 768   }
 769   //
 770   // Set UHS Mode Select field of Host Control 2 reigster to SDR12/25/50
 771   //
 772   if (IsDdr) {
 773     HostCtrl2 = BIT2;
 774   } else if (ClockFreq == 52) {
 775     HostCtrl2 = BIT0;
 776   } else {
 777     HostCtrl2 = 0;
 778   }
 779   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 780   if (EFI_ERROR (Status)) {
 781     return Status;
 782   }
 783
 784   HsTiming = 1;
 785   Status = EmmcSwitchClockFreq (PciIo, PassThru, Slot, Rca, HsTiming, ClockFreq);
 786
 787   return Status;
 788 }
 789
 790 /**
 791   Switch to the HS200 timing according to request.
 792
 793   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 794   Simplified Spec 3.0 Figure 2-29 for details.
 795
 796   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 797   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 798   @param[in] Slot           The slot number of the SD card to send the command to.
 799   @param[in] Rca            The relative device address to be assigned.
 800   @param[in] ClockFreq      The max clock frequency to be set.
 801   @param[in] BusWidth       The bus width to be set, it could be 4 or 8.
 802
 803   @retval EFI_SUCCESS       The operation is done correctly.
 804   @retval Others            The operation fails.
 805
 806 **/
 807 EFI_STATUS
 808 EmmcSwitchToHS200 (
 809   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 810   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 811   IN UINT8                              Slot,
 812   IN UINT16                             Rca,
 813   IN UINT32                             ClockFreq,
 814   IN UINT8                              BusWidth
 815   )
 816 {
 817   EFI_STATUS          Status;
 818   UINT8               HsTiming;
 819   UINT8               HostCtrl2;
 820   UINT16              ClockCtrl;
 821
 822   if ((BusWidth != 4) && (BusWidth != 8)) {
 823     return EFI_INVALID_PARAMETER;
 824   }
 825
 826   Status = EmmcSwitchBusWidth (PciIo, PassThru, Slot, Rca, FALSE, BusWidth);
 827   if (EFI_ERROR (Status)) {
 828     return Status;
 829   }
 830   //
 831   // Set to HS200/SDR104 timing
 832   //
 833   //
 834   // Stop bus clock at first
 835   //
 836   Status = SdMmcHcStopClock (PciIo, Slot);
 837   if (EFI_ERROR (Status)) {
 838     return Status;
 839   }
 840   //
 841   // Clean UHS Mode Select field of Host Control 2 reigster before update
 842   //
 843   HostCtrl2 = (UINT8)~0x7;
 844   Status = SdMmcHcAndMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 845   if (EFI_ERROR (Status)) {
 846     return Status;
 847   }
 848   //
 849   // Set UHS Mode Select field of Host Control 2 reigster to SDR104
 850   //
 851   HostCtrl2 = BIT0 | BIT1;
 852   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 853   if (EFI_ERROR (Status)) {
 854     return Status;
 855   }
 856   //
 857   // Wait Internal Clock Stable in the Clock Control register to be 1 before set SD Clock Enable bit
 858   //
 859   Status = SdMmcHcWaitMmioSet (
 860              PciIo,
 861              Slot,
 862              SD_MMC_HC_CLOCK_CTRL,
 863              sizeof (ClockCtrl),
 864              BIT1,
 865              BIT1,
 866              SD_MMC_HC_GENERIC_TIMEOUT
 867              );
 868   if (EFI_ERROR (Status)) {
 869     return Status;
 870   }
 871   //
 872   // Set SD Clock Enable in the Clock Control register to 1
 873   //
 874   ClockCtrl = BIT2;
 875   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_CLOCK_CTRL, sizeof (ClockCtrl), &ClockCtrl);
 876
 877   HsTiming = 2;
 878   Status = EmmcSwitchClockFreq (PciIo, PassThru, Slot, Rca, HsTiming, ClockFreq);
 879   if (EFI_ERROR (Status)) {
 880     return Status;
 881   }
 882
 883   Status = EmmcTuningClkForHs200 (PciIo, PassThru, Slot, BusWidth);
 884
 885   return Status;
 886 }
 887
 888 /**
 889   Switch to the HS400 timing according to request.
 890
 891   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 892   Simplified Spec 3.0 Figure 2-29 for details.
 893
 894   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 895   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 896   @param[in] Slot           The slot number of the SD card to send the command to.
 897   @param[in] Rca            The relative device address to be assigned.
 898   @param[in] ClockFreq      The max clock frequency to be set.
 899
 900   @retval EFI_SUCCESS       The operation is done correctly.
 901   @retval Others            The operation fails.
 902
 903 **/
 904 EFI_STATUS
 905 EmmcSwitchToHS400 (
 906   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 907   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 908   IN UINT8                              Slot,
 909   IN UINT16                             Rca,
 910   IN UINT32                             ClockFreq
 911   )
 912 {
 913   EFI_STATUS          Status;
 914   UINT8               HsTiming;
 915   UINT8               HostCtrl2;
 916
 917   Status = EmmcSwitchToHS200 (PciIo, PassThru, Slot, Rca, ClockFreq, 8);
 918   if (EFI_ERROR (Status)) {
 919     return Status;
 920   }
 921   //
 922   // Set to Hight Speed timing and set the clock frequency to a value less than 52MHz.
 923   //
 924   HsTiming = 1;
 925   Status = EmmcSwitchClockFreq (PciIo, PassThru, Slot, Rca, HsTiming, 52);
 926   if (EFI_ERROR (Status)) {
 927     return Status;
 928   }
 929   //
 930   // HS400 mode must use 8 data lines.
 931   //
 932   Status = EmmcSwitchBusWidth (PciIo, PassThru, Slot, Rca, TRUE, 8);
 933   if (EFI_ERROR (Status)) {
 934     return Status;
 935   }
 936   //
 937   // Clean UHS Mode Select field of Host Control 2 reigster before update
 938   //
 939   HostCtrl2 = (UINT8)~0x7;
 940   Status = SdMmcHcAndMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 941   if (EFI_ERROR (Status)) {
 942     return Status;
 943   }
 944   //
 945   // Set UHS Mode Select field of Host Control 2 reigster to HS400
 946   //
 947   HostCtrl2 = BIT0 | BIT2;
 948   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL2, sizeof (HostCtrl2), &HostCtrl2);
 949   if (EFI_ERROR (Status)) {
 950     return Status;
 951   }
 952
 953   HsTiming = 3;
 954   Status = EmmcSwitchClockFreq (PciIo, PassThru, Slot, Rca, HsTiming, ClockFreq);
 955
 956   return Status;
 957 }
 958
 959 /**
 960   Switch the high speed timing according to request.
 961
 962   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 963   Simplified Spec 3.0 Figure 2-29 for details.
 964
 965   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 966   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 967   @param[in] Slot           The slot number of the SD card to send the command to.
 968   @param[in] Rca            The relative device address to be assigned.
 969
 970   @retval EFI_SUCCESS       The operation is done correctly.
 971   @retval Others            The operation fails.
 972
 973 **/
 974 EFI_STATUS
 975 EmmcSetBusMode (
 976   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 977   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 978   IN UINT8                              Slot,
 979   IN UINT16                             Rca
 980   )
 981 {
 982   EFI_STATUS                    Status;
 983   EMMC_CSD                      Csd;
 984   EMMC_EXT_CSD                  ExtCsd;
 985   UINT8                         HsTiming;
 986   BOOLEAN                       IsDdr;
 987   UINT32                        ClockFreq;
 988   UINT8                         BusWidth;
 989   SD_MMC_HC_PRIVATE_DATA        *Private;
 990
 991   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
 992
 993   Status = EmmcGetCsd (PassThru, Slot, Rca, &Csd);
 994   if (EFI_ERROR (Status)) {
 995     DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: GetCsd fails with %r\n", Status));
 996     return Status;
 997   }
 998
 999   Status = EmmcSelect (PassThru, Slot, Rca);
1000   if (EFI_ERROR (Status)) {
1001     DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: Select fails with %r\n", Status));
1002     return Status;
1003   }
1004
1005   ASSERT (Private->Capability[Slot].BaseClkFreq != 0);
1006   //
1007   // Check if the Host Controller support 8bits bus width.
1008   //
1009   if (Private->Capability[Slot].BusWidth8 != 0) {
1010     BusWidth = 8;
1011   } else {
1012     BusWidth = 4;
1013   }
1014   //
1015   // Get Deivce_Type from EXT_CSD register.
1016   //
1017   Status = EmmcGetExtCsd (PassThru, Slot, &ExtCsd);
1018   if (EFI_ERROR (Status)) {
1019     DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: GetExtCsd fails with %r\n", Status));
1020     return Status;
1021   }
1022   //
1023   // Calculate supported bus speed/bus width/clock frequency.
1024   //
1025   HsTiming  = 0;
1026   IsDdr     = FALSE;
1027   ClockFreq = 0;
1028   if (((ExtCsd.DeviceType & (BIT4 | BIT5))  != 0) && (Private->Capability[Slot].Sdr104 != 0)) {
1029     HsTiming  = 2;
1030     IsDdr     = FALSE;
1031     ClockFreq = 200;
1032   } else if (((ExtCsd.DeviceType & (BIT2 | BIT3))  != 0) && (Private->Capability[Slot].Ddr50 != 0)) {
1033     HsTiming  = 1;
1034     IsDdr     = TRUE;
1035     ClockFreq = 52;
1036   } else if (((ExtCsd.DeviceType & BIT1)  != 0) && (Private->Capability[Slot].HighSpeed != 0)) {
1037     HsTiming  = 1;
1038     IsDdr     = FALSE;
1039     ClockFreq = 52;
1040   } else if (((ExtCsd.DeviceType & BIT0)  != 0) && (Private->Capability[Slot].HighSpeed != 0)) {
1041     HsTiming  = 1;
1042     IsDdr     = FALSE;
1043     ClockFreq = 26;
1044   }
1045   //
1046   // Check if both of the device and the host controller support HS400 DDR mode.
1047   //
1048   if (((ExtCsd.DeviceType & (BIT6 | BIT7))  != 0) && (Private->Capability[Slot].Hs400 != 0)) {
1049     //
1050     // The host controller supports 8bits bus.
1051     //
1052     ASSERT (BusWidth == 8);
1053     HsTiming  = 3;
1054     IsDdr     = TRUE;
1055     ClockFreq = 200;
1056   }
1057
1058   if ((ClockFreq == 0) || (HsTiming == 0)) {
1059     //
1060     // Continue using default setting.
1061     //
1062     return EFI_SUCCESS;
1063   }
1064
1065   DEBUG ((DEBUG_INFO, "EmmcSetBusMode: HsTiming %d ClockFreq %d BusWidth %d Ddr %a\n", HsTiming, ClockFreq, BusWidth, IsDdr ? "TRUE":"FALSE"));
1066
1067   if (HsTiming == 3) {
1068     //
1069     // Execute HS400 timing switch procedure
1070     //
1071     Status = EmmcSwitchToHS400 (PciIo, PassThru, Slot, Rca, ClockFreq);
1072   } else if (HsTiming == 2) {
1073     //
1074     // Execute HS200 timing switch procedure
1075     //
1076     Status = EmmcSwitchToHS200 (PciIo, PassThru, Slot, Rca, ClockFreq, BusWidth);
1077   } else {
1078     //
1079     // Execute High Speed timing switch procedure
1080     //
1081     Status = EmmcSwitchToHighSpeed (PciIo, PassThru, Slot, Rca, ClockFreq, IsDdr, BusWidth);
1082   }
1083
1084   DEBUG ((DEBUG_INFO, "EmmcSetBusMode: Switch to %a %r\n", (HsTiming == 3) ? "HS400" : ((HsTiming == 2) ? "HS200" : "HighSpeed"), Status));
1085
1086   return Status;
1087 }
1088
1089 /**
1090   Execute EMMC device identification procedure.
1091
1092   Refer to EMMC Electrical Standard Spec 5.1 Section 6.4 for details.
1093
1094   @param[in] Private        A pointer to the SD_MMC_HC_PRIVATE_DATA instance.
1095   @param[in] Slot           The slot number of the SD card to send the command to.
1096
1097   @retval EFI_SUCCESS       There is a EMMC card.
1098   @retval Others            There is not a EMMC card.
1099
1100 **/
1101 EFI_STATUS
1102 EmmcIdentification (
1103   IN SD_MMC_HC_PRIVATE_DATA             *Private,
1104   IN UINT8                              Slot
1105   )
1106 {
1107   EFI_STATUS                     Status;
1108   EFI_PCI_IO_PROTOCOL            *PciIo;
1109   EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru;
1110   UINT32                         Ocr;
1111   UINT16                         Rca;
1112
1113   PciIo    = Private->PciIo;
1114   PassThru = &Private->PassThru;
1115
1116   Status = EmmcReset (PassThru, Slot);
1117   if (EFI_ERROR (Status)) {
1118     DEBUG ((DEBUG_VERBOSE, "EmmcIdentification: Executing Cmd0 fails with %r\n", Status));
1119     return Status;
1120   }
1121
1122   Ocr = 0;
1123   do {
1124     Status = EmmcGetOcr (PassThru, Slot, &Ocr);
1125     if (EFI_ERROR (Status)) {
1126       DEBUG ((DEBUG_VERBOSE, "EmmcIdentification: Executing Cmd1 fails with %r\n", Status));
1127       return Status;
1128     }
1129     Ocr |= BIT30;
1130   } while ((Ocr & BIT31) == 0);
1131
1132   Status = EmmcGetAllCid (PassThru, Slot);
1133   if (EFI_ERROR (Status)) {
1134     DEBUG ((DEBUG_VERBOSE, "EmmcIdentification: Executing Cmd2 fails with %r\n", Status));
1135     return Status;
1136   }
1137   //
1138   // Slot starts from 0 and valid RCA starts from 1.
1139   // Here we takes a simple formula to calculate the RCA.
1140   // Don't support multiple devices on the slot, that is
1141   // shared bus slot feature.
1142   //
1143   Rca    = Slot + 1;
1144   Status = EmmcSetRca (PassThru, Slot, Rca);
1145   if (EFI_ERROR (Status)) {
1146     DEBUG ((DEBUG_ERROR, "EmmcIdentification: Executing Cmd3 fails with %r\n", Status));
1147     return Status;
1148   }
1149   //
1150   // Enter Data Tranfer Mode.
1151   //
1152   DEBUG ((DEBUG_INFO, "EmmcIdentification: Found a EMMC device at slot [%d], RCA [%d]\n", Slot, Rca));
1153   Private->Slot[Slot].CardType = EmmcCardType;
1154
1155   Status = EmmcSetBusMode (PciIo, PassThru, Slot, Rca);
1156
1157   return Status;
1158 }
1159