MdePkg/Include/IndustryStandard/Sd.h

   1 /** @file
   2   Header file for SD memory card support.
   3
   4   This header file contains some definitions defined in SD Physical Layer Simplified
   5   Specification Version 4.10 spec.
   6
   7   Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
   8   This program and the accompanying materials
   9   are licensed and made available under the terms and conditions of the BSD License
  10   which accompanies this distribution.  The full text of the license may be found at
  11   http://opensource.org/licenses/bsd-license.php
  12
  13   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17
  18 #ifndef __SD_H__
  19 #define __SD_H__
  20
  21 //
  22 // SD command index
  23 //
  24 #define  SD_GO_IDLE_STATE           0
  25 #define  SD_ALL_SEND_CID            2
  26 #define  SD_SET_RELATIVE_ADDR       3
  27 #define  SD_SET_DSR                 4
  28 #define  SDIO_SEND_OP_COND          5
  29 #define  SD_SWITCH_FUNC             6
  30 #define  SD_SELECT_DESELECT_CARD    7
  31 #define  SD_SEND_IF_COND            8
  32 #define  SD_SEND_CSD                9
  33 #define  SD_SEND_CID                10
  34 #define  SD_VOLTAGE_SWITCH          11
  35 #define  SD_STOP_TRANSMISSION       12
  36 #define  SD_SEND_STATUS             13
  37 #define  SD_GO_INACTIVE_STATE       15
  38 #define  SD_SET_BLOCKLEN            16
  39 #define  SD_READ_SINGLE_BLOCK       17
  40 #define  SD_READ_MULTIPLE_BLOCK     18
  41 #define  SD_SEND_TUNING_BLOCK       19
  42 #define  SD_SPEED_CLASS_CONTROL     20
  43 #define  SD_SET_BLOCK_COUNT         23
  44 #define  SD_WRITE_SINGLE_BLOCK      24
  45 #define  SD_WRITE_MULTIPLE_BLOCK    25
  46 #define  SD_PROGRAM_CSD             27
  47 #define  SD_SET_WRITE_PROT          28
  48 #define  SD_CLR_WRITE_PROT          29
  49 #define  SD_SEND_WRITE_PROT         30
  50 #define  SD_ERASE_WR_BLK_START      32
  51 #define  SD_ERASE_WR_BLK_END        33
  52 #define  SD_ERASE                   38
  53 #define  SD_LOCK_UNLOCK             42
  54 #define  SD_READ_EXTR_SINGLE        48
  55 #define  SD_WRITE_EXTR_SINGLE       49
  56 #define  SDIO_RW_DIRECT             52
  57 #define  SDIO_RW_EXTENDED           53
  58 #define  SD_APP_CMD                 55
  59 #define  SD_GEN_CMD                 56
  60 #define  SD_READ_EXTR_MULTI         58
  61 #define  SD_WRITE_EXTR_MULTI        59
  62
  63 #define  SD_SET_BUS_WIDTH           6           // ACMD6
  64 #define  SD_STATUS                  13          // ACMD13
  65 #define  SD_SEND_NUM_WR_BLOCKS      22          // ACMD22
  66 #define  SD_SET_WR_BLK_ERASE_COUNT  23          // ACMD23
  67 #define  SD_SEND_OP_COND            41          // ACMD41
  68 #define  SD_SET_CLR_CARD_DETECT     42          // ACMD42
  69 #define  SD_SEND_SCR                51          // ACMD51
  70
  71 #pragma pack(1)
  72 typedef struct {
  73   UINT8   NotUsed:1;                            // Not used [0:0]
  74   UINT8   Crc:7;                                // CRC [7:1]
  75   UINT16  ManufacturingDate:12;                 // Manufacturing date [19:8]
  76   UINT16  Reserved:4;                           // Reserved [23:20]
  77   UINT8   ProductSerialNumber[4];               // Product serial number [55:24]
  78   UINT8   ProductRevision;                      // Product revision [63:56]
  79   UINT8   ProductName[5];                       // Product name [103:64]
  80   UINT8   OemId[2];                             // OEM/Application ID [119:104]
  81   UINT8   ManufacturerId;                       // Manufacturer ID [127:120]
  82 } SD_CID;
  83
  84 typedef struct {
  85   UINT32  NotUsed:1;                            // Not used [0:0]
  86   UINT32  Crc:7;                                // CRC [7:1]
  87   UINT32  Reserved:2;                           // Reserved [9:8]
  88   UINT32  FileFormat:2;                         // File format [11:10]
  89   UINT32  TmpWriteProtect:1;                    // Temporary write protection [12:12]
  90   UINT32  PermWriteProtect:1;                   // Permanent write protection [13:13]
  91   UINT32  Copy:1;                               // Copy flag (OTP) [14:14]
  92   UINT32  FileFormatGrp:1;                      // File format group [15:15]
  93   UINT32  Reserved1:5;                          // Reserved [20:16]
  94   UINT32  WriteBlPartial:1;                     // Partial blocks for write allowed [21:21]
  95   UINT32  WriteBlLen:4;                         // Max. write data block length [25:22]
  96   UINT32  R2WFactor:3;                          // Write speed factor [28:26]
  97   UINT32  Reserved2:2;                          // Manufacturer default ECC [30:29]
  98   UINT32  WpGrpEnable:1;                        // Write protect group enable [31:31]
  99
 100   UINT32  WpGrpSize:7;                          // Write protect group size [38:32]
 101   UINT32  SectorSize:7;                         // Erase sector size [45:39]
 102   UINT32  EraseBlkEn:1;                         // Erase single block enable [46:46]
 103   UINT32  CSizeMul:3;                           // device size multiplier [49:47]
 104   UINT32  VddWCurrMax:3;                        // max. write current @VDD max [52:50]
 105   UINT32  VddWCurrMin:3;                        // max. write current @VDD min [55:53]
 106   UINT32  VddRCurrMax:3;                        // max. read current @VDD max [58:56]
 107   UINT32  VddRCurrMin:3;                        // max. read current @VDD min [61:59]
 108   UINT32  CSizeLow:2;                           // Device size low 2 bits [63:62]
 109
 110   UINT32  CSizeHigh:10;                         // Device size high 10 bits [73:64]
 111   UINT32  Reserved4:2;                          // Reserved [75:74]
 112   UINT32  DsrImp:1;                             // DSR implemented [76:76]
 113   UINT32  ReadBlkMisalign:1;                    // Read block misalignment [77:77]
 114   UINT32  WriteBlkMisalign:1;                   // Write block misalignment [78:78]
 115   UINT32  ReadBlPartial:1;                      // Partial blocks for read allowed [79:79]
 116   UINT32  ReadBlLen:4;                          // Max. read data block length [83:80]
 117   UINT32  Ccc:12;                               // Card command classes [95:84]
 118
 119   UINT32  TranSpeed:8;                          // Max. data transfer rate [103:96]
 120   UINT32  Nsac:8;                               // Data read access-time in CLK cycles (NSAC*100) [111:104]
 121   UINT32  Taac:8;                               // Data read access-time [119:112]
 122   UINT32  Reserved5:6;                          // Reserved [125:120]
 123   UINT32  CsdStructure:2;                       // CSD structure [127:126]
 124 } SD_CSD;
 125
 126 typedef struct {
 127   UINT32  NotUsed:1;                            // Not used [0:0]
 128   UINT32  Crc:7;                                // CRC [7:1]
 129   UINT32  Reserved:2;                           // Reserved [9:8]
 130   UINT32  FileFormat:2;                         // File format [11:10]
 131   UINT32  TmpWriteProtect:1;                    // Temporary write protection [12:12]
 132   UINT32  PermWriteProtect:1;                   // Permanent write protection [13:13]
 133   UINT32  Copy:1;                               // Copy flag (OTP) [14:14]
 134   UINT32  FileFormatGrp:1;                      // File format group [15:15]
 135   UINT32  Reserved1:5;                          // Reserved [20:16]
 136   UINT32  WriteBlPartial:1;                     // Partial blocks for write allowed [21:21]
 137   UINT32  WriteBlLen:4;                         // Max. write data block length [25:22]
 138   UINT32  R2WFactor:3;                          // Write speed factor [28:26]
 139   UINT32  Reserved2:2;                          // Manufacturer default ECC [30:29]
 140   UINT32  WpGrpEnable:1;                        // Write protect group enable [31:31]
 141
 142   UINT32  WpGrpSize:7;                          // Write protect group size [38:32]
 143   UINT32  SectorSize:7;                         // Erase sector size [45:39]
 144   UINT32  EraseBlkEn:1;                         // Erase single block enable [46:46]
 145   UINT32  Reserved3:1;                          // Reserved [47:47]
 146   UINT32  CSizeLow:16;                          // Device size low 16 bits [63:48]
 147
 148   UINT32  CSizeHigh:6;                          // Device size high 6 bits [69:64]
 149   UINT32  Reserved4:6;                          // Reserved [75:70]
 150   UINT32  DsrImp:1;                             // DSR implemented [76:76]
 151   UINT32  ReadBlkMisalign:1;                    // Read block misalignment [77:77]
 152   UINT32  WriteBlkMisalign:1;                   // Write block misalignment [78:78]
 153   UINT32  ReadBlPartial:1;                      // Partial blocks for read allowed [79:79]
 154   UINT32  ReadBlLen:4;                          // Max. read data block length [83:80]
 155   UINT32  Ccc:12;                               // Card command classes [95:84]
 156
 157   UINT32  TranSpeed:8;                          // Max. data transfer rate [103:96]
 158   UINT32  Nsac:8;                               // Data read access-time in CLK cycles (NSAC*100) [111:104]
 159   UINT32  Taac:8;                               // Data read access-time [119:112]
 160   UINT32  Reserved5:6;                          // Reserved [125:120]
 161   UINT32  CsdStructure:2;                       // CSD structure [127:126]
 162 } SD_CSD2;
 163
 164 typedef struct {
 165   UINT32  Reserved;                             // Reserved [31:0]
 166
 167   UINT32  CmdSupport:4;                         // Command Support bits [35:32]
 168   UINT32  Reserved1:6;                          // Reserved [41:36]
 169   UINT32  SdSpec4:1;                            // Spec. Version 4.00 or higher [42:42]
 170   UINT32  ExSecurity:4;                         // Extended Security Support [46:43]
 171   UINT32  SdSpec3:1;                            // Spec. Version 3.00 or higher [47:47]
 172   UINT32  SdBusWidths:4;                        // DAT Bus widths supported [51:48]
 173   UINT32  SdSecurity:3;                         // CPRM security support [54:52]
 174   UINT32  DataStatAfterErase:1;                 // Data status after erases [55]
 175   UINT32  SdSpec:4;                             // SD Memory Card Spec. Version [59:56]
 176   UINT32  ScrStructure:4;                       // SCR Structure [63:60]
 177 } SD_SCR;
 178
 179 #pragma pack()
 180
 181 #endif