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