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
 675   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
 676   //
 677   // Write Byte, the Value field is written into the byte pointed by Index.
 678   //
 679   Access = 0x03;
 680   Index  = OFFSET_OF (EMMC_EXT_CSD, HsTiming);
 681   CmdSet = 0;
 682   switch (BusTiming) {
 683     case SdMmcMmcHs400:
 684       Value = (UINT8)((DriverStrength.Emmc << 4) | 3);
 685       break;
 686     case SdMmcMmcHs200:
 687       Value = (UINT8)((DriverStrength.Emmc << 4) | 2);
 688       break;
 689     case SdMmcMmcHsSdr:
 690     case SdMmcMmcHsDdr:
 691       Value = 1;
 692       break;
 693     case SdMmcMmcLegacy:
 694       Value = 0;
 695       break;
 696     default:
 697       DEBUG ((DEBUG_ERROR, "EmmcSwitchBusTiming: Unsupported BusTiming(%d\n)", BusTiming));
 698       return EFI_INVALID_PARAMETER;
 699   }
 700
 701   Status = EmmcSwitch (PassThru, Slot, Access, Index, Value, CmdSet);
 702   if (EFI_ERROR (Status)) {
 703     DEBUG ((DEBUG_ERROR, "EmmcSwitchBusTiming: Switch to bus timing %d fails with %r\n", BusTiming, Status));
 704     return Status;
 705   }
 706
 707   //
 708   // Convert the clock freq unit from MHz to KHz.
 709   //
 710   Status = SdMmcHcClockSupply (PciIo, Slot, ClockFreq * 1000, Private->BaseClkFreq[Slot], Private->ControllerVersion[Slot]);
 711   if (EFI_ERROR (Status)) {
 712     return Status;
 713   }
 714
 715   Status = EmmcSendStatus (PassThru, Slot, Rca, &DevStatus);
 716   if (EFI_ERROR (Status)) {
 717     DEBUG ((DEBUG_ERROR, "EmmcSwitchBusTiming: Send status fails with %r\n", Status));
 718     return Status;
 719   }
 720   //
 721   // Check the switch operation is really successful or not.
 722   //
 723   if ((DevStatus & BIT7) != 0) {
 724     DEBUG ((DEBUG_ERROR, "EmmcSwitchBusTiming: The switch operation fails as DevStatus is 0x%08x\n", DevStatus));
 725     return EFI_DEVICE_ERROR;
 726   }
 727
 728   if (mOverride != NULL && mOverride->NotifyPhase != NULL) {
 729     Status = mOverride->NotifyPhase (
 730                           Private->ControllerHandle,
 731                           Slot,
 732                           EdkiiSdMmcSwitchClockFreqPost,
 733                           &BusTiming
 734                           );
 735     if (EFI_ERROR (Status)) {
 736       DEBUG ((
 737         DEBUG_ERROR,
 738         "%a: SD/MMC switch clock freq post notifier callback failed - %r\n",
 739         __FUNCTION__,
 740         Status
 741         ));
 742       return Status;
 743     }
 744   }
 745
 746   return Status;
 747 }
 748
 749 /**
 750   Switch to the High Speed timing according to request.
 751
 752   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 753   Simplified Spec 3.0 Figure 2-29 for details.
 754
 755   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
 756   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 757   @param[in] Slot           The slot number of the SD card to send the command to.
 758   @param[in] Rca            The relative device address to be assigned.
 759   @param[in] BusMode        Pointer to SD_MMC_BUS_SETTINGS structure containing bus settings.
 760
 761   @retval EFI_SUCCESS       The operation is done correctly.
 762   @retval Others            The operation fails.
 763
 764 **/
 765 EFI_STATUS
 766 EmmcSwitchToHighSpeed (
 767   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 768   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 769   IN UINT8                              Slot,
 770   IN UINT16                             Rca,
 771   IN SD_MMC_BUS_SETTINGS                *BusMode
 772   )
 773 {
 774   EFI_STATUS              Status;
 775   UINT8                   HostCtrl1;
 776   SD_MMC_HC_PRIVATE_DATA  *Private;
 777   BOOLEAN                 IsDdr;
 778
 779   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
 780
 781   if ((BusMode->BusTiming != SdMmcMmcHsSdr && BusMode->BusTiming != SdMmcMmcHsDdr) ||
 782       BusMode->ClockFreq > 52) {
 783     return EFI_INVALID_PARAMETER;
 784   }
 785
 786   if (BusMode->BusTiming == SdMmcMmcHsDdr) {
 787     IsDdr = TRUE;
 788   } else {
 789     IsDdr = FALSE;
 790   }
 791
 792   Status = EmmcSwitchBusWidth (PciIo, PassThru, Slot, Rca, IsDdr, BusMode->BusWidth);
 793   if (EFI_ERROR (Status)) {
 794     return Status;
 795   }
 796
 797   //
 798   // Set to High Speed timing
 799   //
 800   HostCtrl1 = BIT2;
 801   Status = SdMmcHcOrMmio (PciIo, Slot, SD_MMC_HC_HOST_CTRL1, sizeof (HostCtrl1), &HostCtrl1);
 802   if (EFI_ERROR (Status)) {
 803     return Status;
 804   }
 805
 806   Status = SdMmcHcUhsSignaling (Private->ControllerHandle, PciIo, Slot, BusMode->BusTiming);
 807   if (EFI_ERROR (Status)) {
 808     return Status;
 809   }
 810
 811   return EmmcSwitchBusTiming (PciIo, PassThru, Slot, Rca, BusMode->DriverStrength, BusMode->BusTiming, BusMode->ClockFreq);
 812 }
 813
 814 /**
 815   Switch to the HS200 timing. This function assumes that eMMC bus is still in legacy mode.
 816
 817   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 818   Simplified Spec 3.0 Figure 2-29 for details.
 819
 820   @param[in] PciIo           A pointer to the EFI_PCI_IO_PROTOCOL instance.
 821   @param[in] PassThru        A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 822   @param[in] Slot            The slot number of the SD card to send the command to.
 823   @param[in] Rca             The relative device address to be assigned.
 824   @param[in] BusMode         Pointer to SD_MMC_BUS_SETTINGS structure containing bus settings.
 825
 826   @retval EFI_SUCCESS       The operation is done correctly.
 827   @retval Others            The operation fails.
 828
 829 **/
 830 EFI_STATUS
 831 EmmcSwitchToHS200 (
 832   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 833   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 834   IN UINT8                              Slot,
 835   IN UINT16                             Rca,
 836   IN SD_MMC_BUS_SETTINGS                *BusMode
 837   )
 838 {
 839   EFI_STATUS               Status;
 840   SD_MMC_HC_PRIVATE_DATA  *Private;
 841
 842   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
 843
 844   if (BusMode->BusTiming != SdMmcMmcHs200 ||
 845       (BusMode->BusWidth != 4 && BusMode->BusWidth != 8)) {
 846     return EFI_INVALID_PARAMETER;
 847   }
 848
 849   Status = EmmcSwitchBusWidth (PciIo, PassThru, Slot, Rca, FALSE, BusMode->BusWidth);
 850   if (EFI_ERROR (Status)) {
 851     return Status;
 852   }
 853
 854   Status = SdMmcHcUhsSignaling (Private->ControllerHandle, PciIo, Slot, BusMode->BusTiming);
 855   if (EFI_ERROR (Status)) {
 856     return Status;
 857   }
 858
 859   Status = EmmcSwitchBusTiming (PciIo, PassThru, Slot, Rca, BusMode->DriverStrength, BusMode->BusTiming, BusMode->ClockFreq);
 860   if (EFI_ERROR (Status)) {
 861     return Status;
 862   }
 863
 864   Status = EmmcTuningClkForHs200 (PciIo, PassThru, Slot, BusMode->BusWidth);
 865
 866   return Status;
 867 }
 868
 869 /**
 870   Switch to the HS400 timing. This function assumes that eMMC bus is still in legacy mode.
 871
 872   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
 873   Simplified Spec 3.0 Figure 2-29 for details.
 874
 875   @param[in] PciIo           A pointer to the EFI_PCI_IO_PROTOCOL instance.
 876   @param[in] PassThru        A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
 877   @param[in] Slot            The slot number of the SD card to send the command to.
 878   @param[in] Rca             The relative device address to be assigned.
 879   @param[in] BusMode         Pointer to SD_MMC_BUS_SETTINGS structure containing bus settings.
 880
 881   @retval EFI_SUCCESS       The operation is done correctly.
 882   @retval Others            The operation fails.
 883
 884 **/
 885 EFI_STATUS
 886 EmmcSwitchToHS400 (
 887   IN EFI_PCI_IO_PROTOCOL                *PciIo,
 888   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
 889   IN UINT8                              Slot,
 890   IN UINT16                             Rca,
 891   IN SD_MMC_BUS_SETTINGS                *BusMode
 892   )
 893 {
 894   EFI_STATUS                 Status;
 895   SD_MMC_HC_PRIVATE_DATA     *Private;
 896   SD_MMC_BUS_SETTINGS        Hs200BusMode;
 897   UINT32                     HsFreq;
 898
 899   if (BusMode->BusTiming != SdMmcMmcHs400 ||
 900       BusMode->BusWidth != 8) {
 901     return EFI_INVALID_PARAMETER;
 902   }
 903
 904   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
 905   Hs200BusMode.BusTiming = SdMmcMmcHs200;
 906   Hs200BusMode.BusWidth = BusMode->BusWidth;
 907   Hs200BusMode.ClockFreq = BusMode->ClockFreq;
 908   Hs200BusMode.DriverStrength = BusMode->DriverStrength;
 909
 910   Status = EmmcSwitchToHS200 (PciIo, PassThru, Slot, Rca, &Hs200BusMode);
 911   if (EFI_ERROR (Status)) {
 912     return Status;
 913   }
 914
 915   //
 916   // Set to High Speed timing and set the clock frequency to a value less than or equal to 52MHz.
 917   // This step is necessary to be able to switch Bus into 8 bit DDR mode which is unsupported in HS200.
 918   //
 919   Status = SdMmcHcUhsSignaling (Private->ControllerHandle, PciIo, Slot, SdMmcMmcHsSdr);
 920   if (EFI_ERROR (Status)) {
 921     return Status;
 922   }
 923
 924   HsFreq = BusMode->ClockFreq < 52 ? BusMode->ClockFreq : 52;
 925   Status = EmmcSwitchBusTiming (PciIo, PassThru, Slot, Rca, BusMode->DriverStrength, SdMmcMmcHsSdr, HsFreq);
 926   if (EFI_ERROR (Status)) {
 927     return Status;
 928   }
 929
 930   Status = EmmcSwitchBusWidth (PciIo, PassThru, Slot, Rca, TRUE, BusMode->BusWidth);
 931   if (EFI_ERROR (Status)) {
 932     return Status;
 933   }
 934
 935   Status = SdMmcHcUhsSignaling (Private->ControllerHandle, PciIo, Slot, BusMode->BusTiming);
 936   if (EFI_ERROR (Status)) {
 937     return Status;
 938   }
 939
 940   return EmmcSwitchBusTiming (PciIo, PassThru, Slot, Rca, BusMode->DriverStrength, BusMode->BusTiming, BusMode->ClockFreq);
 941 }
 942
 943 /**
 944   Check if passed BusTiming is supported in both controller and card.
 945
 946   @param[in] Private    Pointer to controller private data
 947   @param[in] SlotIndex  Index of the slot in the controller
 948   @param[in] ExtCsd     Pointer to the card's extended CSD
 949   @param[in] BusTiming  Bus timing to check
 950
 951   @retval TRUE  Both card and controller support given BusTiming
 952   @retval FALSE Card or controller doesn't support given BusTiming
 953 **/
 954 BOOLEAN
 955 EmmcIsBusTimingSupported (
 956   IN SD_MMC_HC_PRIVATE_DATA  *Private,
 957   IN UINT8                   SlotIndex,
 958   IN EMMC_EXT_CSD            *ExtCsd,
 959   IN SD_MMC_BUS_MODE         BusTiming
 960   )
 961 {
 962   BOOLEAN             Supported;
 963   SD_MMC_HC_SLOT_CAP  *Capabilities;
 964
 965   Capabilities = &Private->Capability[SlotIndex];
 966
 967   Supported = FALSE;
 968   switch (BusTiming) {
 969     case SdMmcMmcHs400:
 970       if ((((ExtCsd->DeviceType & (BIT6 | BIT7))  != 0) && (Capabilities->Hs400 != 0)) && Capabilities->BusWidth8 != 0) {
 971         Supported = TRUE;
 972       }
 973       break;
 974     case SdMmcMmcHs200:
 975       if ((((ExtCsd->DeviceType & (BIT4 | BIT5))  != 0) && (Capabilities->Sdr104 != 0))) {
 976         Supported = TRUE;
 977       }
 978       break;
 979     case SdMmcMmcHsDdr:
 980       if ((((ExtCsd->DeviceType & (BIT2 | BIT3))  != 0) && (Capabilities->Ddr50 != 0))) {
 981         Supported = TRUE;
 982       }
 983       break;
 984     case SdMmcMmcHsSdr:
 985       if ((((ExtCsd->DeviceType & BIT1)  != 0) && (Capabilities->HighSpeed != 0))) {
 986         Supported = TRUE;
 987       }
 988       break;
 989     case SdMmcMmcLegacy:
 990       if ((ExtCsd->DeviceType & BIT0) != 0) {
 991         Supported = TRUE;
 992       }
 993       break;
 994     default:
 995       ASSERT (FALSE);
 996   }
 997
 998   return Supported;
 999 }
1000
1001 /**
1002   Get the target bus timing to set on the link. This function
1003   will try to select highest bus timing supported by card, controller
1004   and the driver.
1005
1006   @param[in] Private    Pointer to controller private data
1007   @param[in] SlotIndex  Index of the slot in the controller
1008   @param[in] ExtCsd     Pointer to the card's extended CSD
1009
1010   @return  Bus timing value that should be set on link
1011 **/
1012 SD_MMC_BUS_MODE
1013 EmmcGetTargetBusTiming (
1014   IN SD_MMC_HC_PRIVATE_DATA  *Private,
1015   IN UINT8                    SlotIndex,
1016   IN EMMC_EXT_CSD             *ExtCsd
1017   )
1018 {
1019   SD_MMC_BUS_MODE  BusTiming;
1020
1021   //
1022   // We start with highest bus timing that this driver currently supports and
1023   // return as soon as we find supported timing.
1024   //
1025   BusTiming = SdMmcMmcHs400;
1026   while (BusTiming > SdMmcMmcLegacy) {
1027     if (EmmcIsBusTimingSupported (Private, SlotIndex, ExtCsd, BusTiming)) {
1028       break;
1029     }
1030     BusTiming--;
1031   }
1032
1033   return BusTiming;
1034 }
1035
1036 /**
1037   Check if the passed bus width is supported by controller and card.
1038
1039   @param[in] Private    Pointer to controller private data
1040   @param[in] SlotIndex  Index of the slot in the controller
1041   @param[in] BusTiming  Bus timing set on the link
1042   @param[in] BusWidth   Bus width to check
1043
1044   @retval TRUE   Passed bus width is supported in current bus configuration
1045   @retval FALSE  Passed bus width is not supported in current bus configuration
1046 **/
1047 BOOLEAN
1048 EmmcIsBusWidthSupported (
1049   IN SD_MMC_HC_PRIVATE_DATA   *Private,
1050   IN UINT8                    SlotIndex,
1051   IN SD_MMC_BUS_MODE          BusTiming,
1052   IN UINT16                   BusWidth
1053   )
1054 {
1055   if (BusWidth == 8 && Private->Capability[SlotIndex].BusWidth8 != 0) {
1056     return TRUE;
1057   } else if (BusWidth == 4 && BusTiming != SdMmcMmcHs400) {
1058     return TRUE;
1059   } else if (BusWidth == 1 && (BusTiming == SdMmcMmcHsSdr || BusTiming == SdMmcMmcLegacy)) {
1060     return TRUE;
1061   }
1062
1063   return FALSE;
1064 }
1065
1066 /**
1067   Get the target bus width to be set on the bus.
1068
1069   @param[in] Private    Pointer to controller private data
1070   @param[in] SlotIndex  Index of the slot in the controller
1071   @param[in] ExtCsd     Pointer to card's extended CSD
1072   @param[in] BusTiming  Bus timing set on the bus
1073
1074   @return Bus width to be set on the bus
1075 **/
1076 UINT8
1077 EmmcGetTargetBusWidth (
1078   IN SD_MMC_HC_PRIVATE_DATA   *Private,
1079   IN UINT8                    SlotIndex,
1080   IN EMMC_EXT_CSD             *ExtCsd,
1081   IN SD_MMC_BUS_MODE          BusTiming
1082   )
1083 {
1084   UINT8  BusWidth;
1085   UINT8  PreferredBusWidth;
1086
1087   PreferredBusWidth = Private->Slot[SlotIndex].OperatingParameters.BusWidth;
1088
1089   if (PreferredBusWidth != EDKII_SD_MMC_BUS_WIDTH_IGNORE &&
1090       EmmcIsBusWidthSupported (Private, SlotIndex, BusTiming, PreferredBusWidth)) {
1091     BusWidth = PreferredBusWidth;
1092   } else if (EmmcIsBusWidthSupported (Private, SlotIndex, BusTiming, 8)) {
1093     BusWidth = 8;
1094   } else if (EmmcIsBusWidthSupported (Private, SlotIndex, BusTiming, 4)) {
1095     BusWidth = 4;
1096   } else {
1097     BusWidth = 1;
1098   }
1099
1100   return BusWidth;
1101 }
1102
1103 /**
1104   Get the target clock frequency to be set on the bus.
1105
1106   @param[in] Private    Pointer to controller private data
1107   @param[in] SlotIndex  Index of the slot in the controller
1108   @param[in] ExtCsd     Pointer to card's extended CSD
1109   @param[in] BusTiming  Bus timing to be set on the bus
1110
1111   @return Value of the clock frequency to be set on bus in MHz
1112 **/
1113 UINT32
1114 EmmcGetTargetClockFreq (
1115   IN SD_MMC_HC_PRIVATE_DATA   *Private,
1116   IN UINT8                    SlotIndex,
1117   IN EMMC_EXT_CSD             *ExtCsd,
1118   IN SD_MMC_BUS_MODE          BusTiming
1119   )
1120 {
1121   UINT32 PreferredClockFreq;
1122   UINT32 MaxClockFreq;
1123
1124   PreferredClockFreq = Private->Slot[SlotIndex].OperatingParameters.ClockFreq;
1125
1126   switch (BusTiming) {
1127     case SdMmcMmcHs400:
1128     case SdMmcMmcHs200:
1129       MaxClockFreq = 200;
1130       break;
1131     case SdMmcMmcHsSdr:
1132     case SdMmcMmcHsDdr:
1133       MaxClockFreq = 52;
1134       break;
1135     default:
1136       MaxClockFreq = 26;
1137       break;
1138   }
1139
1140   if (PreferredClockFreq != EDKII_SD_MMC_CLOCK_FREQ_IGNORE && PreferredClockFreq < MaxClockFreq) {
1141     return PreferredClockFreq;
1142   } else {
1143     return MaxClockFreq;
1144   }
1145 }
1146
1147 /**
1148   Get the driver strength to be set on bus.
1149
1150   @param[in] Private    Pointer to controller private data
1151   @param[in] SlotIndex  Index of the slot in the controller
1152   @param[in] ExtCsd     Pointer to card's extended CSD
1153   @param[in] BusTiming  Bus timing set on the bus
1154
1155   @return Value of the driver strength to be set on the bus
1156 **/
1157 EDKII_SD_MMC_DRIVER_STRENGTH
1158 EmmcGetTargetDriverStrength (
1159   IN SD_MMC_HC_PRIVATE_DATA   *Private,
1160   IN UINT8                    SlotIndex,
1161   IN EMMC_EXT_CSD             *ExtCsd,
1162   IN SD_MMC_BUS_MODE          BusTiming
1163   )
1164 {
1165   EDKII_SD_MMC_DRIVER_STRENGTH  PreferredDriverStrength;
1166   EDKII_SD_MMC_DRIVER_STRENGTH  DriverStrength;
1167
1168   PreferredDriverStrength = Private->Slot[SlotIndex].OperatingParameters.DriverStrength;
1169   DriverStrength.Emmc = EmmcDriverStrengthType0;
1170
1171   if (PreferredDriverStrength.Emmc != EDKII_SD_MMC_DRIVER_STRENGTH_IGNORE &&
1172       (ExtCsd->DriverStrength & (BIT0 << PreferredDriverStrength.Emmc))) {
1173     DriverStrength.Emmc = PreferredDriverStrength.Emmc;
1174   }
1175
1176   return DriverStrength;
1177 }
1178
1179 /**
1180   Get the target settings for the bus mode.
1181
1182   @param[in]  Private    Pointer to controller private data
1183   @param[in]  SlotIndex  Index of the slot in the controller
1184   @param[in]  ExtCsd     Pointer to card's extended CSD
1185   @param[out] BusMode    Target configuration of the bus
1186 **/
1187 VOID
1188 EmmcGetTargetBusMode (
1189   IN SD_MMC_HC_PRIVATE_DATA  *Private,
1190   IN UINT8                   SlotIndex,
1191   IN EMMC_EXT_CSD            *ExtCsd,
1192   OUT SD_MMC_BUS_SETTINGS    *BusMode
1193   )
1194 {
1195   BusMode->BusTiming = EmmcGetTargetBusTiming (Private, SlotIndex, ExtCsd);
1196   BusMode->BusWidth = EmmcGetTargetBusWidth (Private, SlotIndex, ExtCsd, BusMode->BusTiming);
1197   BusMode->ClockFreq = EmmcGetTargetClockFreq (Private, SlotIndex, ExtCsd, BusMode->BusTiming);
1198   BusMode->DriverStrength = EmmcGetTargetDriverStrength (Private, SlotIndex, ExtCsd, BusMode->BusTiming);
1199 }
1200
1201 /**
1202   Switch the high speed timing according to request.
1203
1204   Refer to EMMC Electrical Standard Spec 5.1 Section 6.6.8 and SD Host Controller
1205   Simplified Spec 3.0 Figure 2-29 for details.
1206
1207   @param[in] PciIo          A pointer to the EFI_PCI_IO_PROTOCOL instance.
1208   @param[in] PassThru       A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
1209   @param[in] Slot           The slot number of the SD card to send the command to.
1210   @param[in] Rca            The relative device address to be assigned.
1211
1212   @retval EFI_SUCCESS       The operation is done correctly.
1213   @retval Others            The operation fails.
1214
1215 **/
1216 EFI_STATUS
1217 EmmcSetBusMode (
1218   IN EFI_PCI_IO_PROTOCOL                *PciIo,
1219   IN EFI_SD_MMC_PASS_THRU_PROTOCOL      *PassThru,
1220   IN UINT8                              Slot,
1221   IN UINT16                             Rca
1222   )
1223 {
1224   EFI_STATUS                    Status;
1225   EMMC_CSD                      Csd;
1226   EMMC_EXT_CSD                  ExtCsd;
1227   SD_MMC_BUS_SETTINGS           BusMode;
1228   SD_MMC_HC_PRIVATE_DATA        *Private;
1229
1230   Private = SD_MMC_HC_PRIVATE_FROM_THIS (PassThru);
1231
1232   Status = EmmcGetCsd (PassThru, Slot, Rca, &Csd);
1233   if (EFI_ERROR (Status)) {
1234     DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: GetCsd fails with %r\n", Status));
1235     return Status;
1236   }
1237
1238   Status = EmmcSelect (PassThru, Slot, Rca);
1239   if (EFI_ERROR (Status)) {
1240     DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: Select fails with %r\n", Status));
1241     return Status;
1242   }
1243
1244   ASSERT (Private->BaseClkFreq[Slot] != 0);
1245
1246   //
1247   // Get Device_Type from EXT_CSD register.
1248   //
1249   Status = EmmcGetExtCsd (PassThru, Slot, &ExtCsd);
1250   if (EFI_ERROR (Status)) {
1251     DEBUG ((DEBUG_ERROR, "EmmcSetBusMode: GetExtCsd fails with %r\n", Status));
1252     return Status;
1253   }
1254
1255   EmmcGetTargetBusMode (Private, Slot, &ExtCsd, &BusMode);
1256
1257   DEBUG ((DEBUG_INFO, "EmmcSetBusMode: Target bus mode: timing = %d, width = %d, clock freq = %d, driver strength = %d\n",
1258                           BusMode.BusTiming, BusMode.BusWidth, BusMode.ClockFreq, BusMode.DriverStrength.Emmc));
1259
1260   if (BusMode.BusTiming == SdMmcMmcHs400) {
1261     Status = EmmcSwitchToHS400 (PciIo, PassThru, Slot, Rca, &BusMode);
1262   } else if (BusMode.BusTiming == SdMmcMmcHs200) {
1263     Status = EmmcSwitchToHS200 (PciIo, PassThru, Slot, Rca, &BusMode);
1264   } else {
1265     Status = EmmcSwitchToHighSpeed (PciIo, PassThru, Slot, Rca, &BusMode);
1266   }
1267
1268   DEBUG ((DEBUG_INFO, "EmmcSetBusMode: Switch to %a %r\n", (BusMode.BusTiming == SdMmcMmcHs400) ? "HS400" : ((BusMode.BusTiming == SdMmcMmcHs200) ? "HS200" : "HighSpeed"), Status));
1269
1270   return Status;
1271 }
1272
1273 /**
1274   Execute EMMC device identification procedure.
1275
1276   Refer to EMMC Electrical Standard Spec 5.1 Section 6.4 for details.
1277
1278   @param[in] Private        A pointer to the SD_MMC_HC_PRIVATE_DATA instance.
1279   @param[in] Slot           The slot number of the SD card to send the command to.
1280
1281   @retval EFI_SUCCESS       There is a EMMC card.
1282   @retval Others            There is not a EMMC card.
1283
1284 **/
1285 EFI_STATUS
1286 EmmcIdentification (
1287   IN SD_MMC_HC_PRIVATE_DATA             *Private,
1288   IN UINT8                              Slot
1289   )
1290 {
1291   EFI_STATUS                     Status;
1292   EFI_PCI_IO_PROTOCOL            *PciIo;
1293   EFI_SD_MMC_PASS_THRU_PROTOCOL  *PassThru;
1294   UINT32                         Ocr;
1295   UINT16                         Rca;
1296   UINTN                          Retry;
1297
1298   PciIo    = Private->PciIo;
1299   PassThru = &Private->PassThru;
1300
1301   Status = EmmcReset (PassThru, Slot);
1302   if (EFI_ERROR (Status)) {
1303     DEBUG ((DEBUG_VERBOSE, "EmmcIdentification: Executing Cmd0 fails with %r\n", Status));
1304     return Status;
1305   }
1306
1307   Ocr   = 0;
1308   Retry = 0;
1309   do {
1310     Status = EmmcGetOcr (PassThru, Slot, &Ocr);
1311     if (EFI_ERROR (Status)) {
1312       DEBUG ((DEBUG_VERBOSE, "EmmcIdentification: Executing Cmd1 fails with %r\n", Status));
1313       return Status;
1314     }
1315     Ocr |= BIT30;
1316
1317     if (Retry++ == 100) {
1318       DEBUG ((DEBUG_VERBOSE, "EmmcIdentification: Executing Cmd1 fails too many times\n"));
1319       return EFI_DEVICE_ERROR;
1320     }
1321     gBS->Stall(10 * 1000);
1322   } while ((Ocr & BIT31) == 0);
1323
1324   Status = EmmcGetAllCid (PassThru, Slot);
1325   if (EFI_ERROR (Status)) {
1326     DEBUG ((DEBUG_VERBOSE, "EmmcIdentification: Executing Cmd2 fails with %r\n", Status));
1327     return Status;
1328   }
1329   //
1330   // Slot starts from 0 and valid RCA starts from 1.
1331   // Here we takes a simple formula to calculate the RCA.
1332   // Don't support multiple devices on the slot, that is
1333   // shared bus slot feature.
1334   //
1335   Rca    = Slot + 1;
1336   Status = EmmcSetRca (PassThru, Slot, Rca);
1337   if (EFI_ERROR (Status)) {
1338     DEBUG ((DEBUG_ERROR, "EmmcIdentification: Executing Cmd3 fails with %r\n", Status));
1339     return Status;
1340   }
1341   //
1342   // Enter Data Tranfer Mode.
1343   //
1344   DEBUG ((DEBUG_INFO, "EmmcIdentification: Found a EMMC device at slot [%d], RCA [%d]\n", Slot, Rca));
1345   Private->Slot[Slot].CardType = EmmcCardType;
1346
1347   Status = EmmcSetBusMode (PciIo, PassThru, Slot, Rca);
1348
1349   return Status;
1350 }
1351