EmbeddedPkg/Universal/MmcDxe/Mmc.h

   1 /** @file
   2   Main Header file for the MMC DXE driver
   3
   4   Copyright (c) 2011, ARM Limited. All rights reserved.
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #ifndef __MMC_H
  17 #define __MMC_H
  18
  19 #include <Uefi.h>
  20
  21 #include <Protocol/DiskIo.h>
  22 #include <Protocol/BlockIo.h>
  23 #include <Protocol/DevicePath.h>
  24 #include <Protocol/MmcHost.h>
  25
  26 #include <Library/UefiLib.h>
  27
  28 #define MMC_TRACE(txt)  DEBUG((EFI_D_BLKIO, "MMC: " txt "\n"))
  29
  30 #define MMC_IOBLOCKS_READ       0
  31 #define MMC_IOBLOCKS_WRITE      1
  32
  33 #define MMC_OCR_POWERUP             0x80000000
  34
  35 #define MMC_CSD_GET_CCC(Response)    (Response[1] >> 20)
  36 #define MMC_CSD_GET_TRANSPEED(Response)    (Response[0] & 0xFF)
  37 #define MMC_CSD_GET_READBLLEN(Response)    ((Response[1] >> 16) & 0xF)
  38 #define MMC_CSD_GET_WRITEBLLEN(Response)  ((Response[3] >> 22) & 0xF)
  39 #define MMC_CSD_GET_FILEFORMAT(Response)  ((Response[3] >> 10) & 0x3)
  40 #define MMC_CSD_GET_FILEFORMATGRP(Response)  ((Response[3] >> 15) & 0x1)
  41 #define MMC_CSD_GET_DEVICESIZE(csd)         (((Response[2] >> 30) & 0x3) | ((Response[1] & 0x3FF) << 2))
  42 #define MMC_CSD_GET_DEVICESIZEMULT(csd)     ((Response[2] >> 15) & 0x7)
  43
  44 #define MMC_R0_CURRENTSTATE(Response)       ((Response[0] >> 9) & 0xF)
  45
  46 #define MMC_R0_STATE_IDLE       0
  47 #define MMC_R0_STATE_READY      1
  48 #define MMC_R0_STATE_IDENT      2
  49 #define MMC_R0_STATE_STDBY      3
  50 #define MMC_R0_STATE_TRAN       4
  51 #define MMC_R0_STATE_DATA       5
  52
  53 typedef enum {
  54   UNKNOWN_CARD,
  55   MMC_CARD,              //MMC card
  56   MMC_CARD_HIGH,         //MMC Card with High capacity
  57   SD_CARD,               //SD 1.1 card
  58   SD_CARD_2,             //SD 2.0 or above standard card
  59   SD_CARD_2_HIGH         //SD 2.0 or above high capacity card
  60 } CARD_TYPE;
  61
  62 typedef struct {
  63   UINT32  Reserved0:   7; // 0
  64   UINT32  V170_V195:   1; // 1.70V - 1.95V
  65   UINT32  V200_V260:   7; // 2.00V - 2.60V
  66   UINT32  V270_V360:   9; // 2.70V - 3.60V
  67   UINT32  RESERVED_1:  5; // Reserved
  68   UINT32  AccessMode:  2; // 00b (byte mode), 10b (sector mode)
  69   UINT32  Busy:        1; // This bit is set to LOW if the card has not finished the power up routine
  70 } OCR;
  71
  72 typedef struct {
  73   UINT32  NOT_USED;   // 1 [0:0]
  74   UINT32  CRC;        // CRC7 checksum [7:1]
  75   UINT32  MDT;        // Manufacturing date [19:8]
  76   UINT32  RESERVED_1; // Reserved [23:20]
  77   UINT32  PSN;        // Product serial number [55:24]
  78   UINT8   PRV;        // Product revision [63:56]
  79   UINT8   PNM[5];     // Product name [64:103]
  80   UINT16  OID;        // OEM/Application ID [119:104]
  81   UINT8   MID;        // Manufacturer ID [127:120]
  82 } CID;
  83
  84 typedef struct {
  85   UINT8   NOT_USED:           1; // Not used, always 1 [0:0]
  86   UINT8   CRC:                7; // CRC [7:1]
  87
  88   UINT8   RESERVED_1:         2; // Reserved [9:8]
  89   UINT8   FILE_FORMAT:        2; // File format [11:10]
  90   UINT8   TMP_WRITE_PROTECT:  1; // Temporary write protection [12:12]
  91   UINT8   PERM_WRITE_PROTECT: 1; // Permanent write protection [13:13]
  92   UINT8   COPY:               1; // Copy flag (OTP) [14:14]
  93   UINT8   FILE_FORMAT_GRP:    1; // File format group [15:15]
  94
  95   UINT16  RESERVED_2:         5; // Reserved [20:16]
  96   UINT16  WRITE_BL_PARTIAL:   1; // Partial blocks for write allowed [21:21]
  97   UINT16  WRITE_BL_LEN:       4; // Max. write data block length [25:22]
  98   UINT16  R2W_FACTOR:         3; // Write speed factor [28:26]
  99   UINT16  RESERVED_3:         2; // Reserved [30:29]
 100   UINT16  WP_GRP_ENABLE:      1; // Write protect group enable [31:31]
 101
 102   UINT32  WP_GRP_SIZE:        7; // Write protect group size [38:32]
 103   UINT32  SECTOR_SIZE:        7; // Erase sector size [45:39]
 104   UINT32  ERASE_BLK_EN:       1; // Erase single block enable [46:46]
 105   UINT32  C_SIZE_MULT:        3; // Device size multiplier [49:47]
 106   UINT32  VDD_W_CURR_MAX:     3; // Max. write current @ VDD max [52:50]
 107   UINT32  VDD_W_CURR_MIN:     3; // Max. write current @ VDD min [55:53]
 108   UINT32  VDD_R_CURR_MAX:     3; // Max. read current @ VDD max [58:56]
 109   UINT32  VDD_R_CURR_MIN:     3; // Max. read current @ VDD min [61:59]
 110   UINT32  C_SIZELow2:         2; // Device size [63:62]
 111
 112   UINT32  C_SIZEHigh10:       10;// Device size [73:64]
 113   UINT32  RESERVED_4:         2; // Reserved [75:74]
 114   UINT32  DSR_IMP:            1; // DSR implemented [76:76]
 115   UINT32  READ_BLK_MISALIGN:  1; // Read block misalignment [77:77]
 116   UINT32  WRITE_BLK_MISALIGN: 1; // Write block misalignment [78:78]
 117   UINT32  READ_BL_PARTIAL:    1; // Partial blocks for read allowed [79:79]
 118   UINT32  READ_BL_LEN:        4; // Max. read data block length [83:80]
 119   UINT32  CCC:                12;// Card command classes [95:84]
 120
 121   UINT8   TRAN_SPEED          ;  // Max. bus clock frequency [103:96]
 122   UINT8   NSAC                ;  // Data read access-time 2 in CLK cycles (NSAC*100) [111:104]
 123   UINT8   TAAC                ;  // Data read access-time 1 [119:112]
 124
 125   UINT8   RESERVED_5:         6; // Reserved [125:120]
 126   UINT8   CSD_STRUCTURE:      2; // CSD structure [127:126]
 127 } CSD;
 128
 129 typedef struct  {
 130   UINT16    RCA;
 131   CARD_TYPE CardType;
 132   OCR       OCRData;
 133   CID       CIDData;
 134   CSD       CSDData;
 135 } CARD_INFO;
 136
 137 typedef struct _MMC_HOST_INSTANCE {
 138   UINTN                     Signature;
 139   LIST_ENTRY                Link;
 140   EFI_HANDLE                MmcHandle;
 141   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 142
 143   MMC_STATE                 State;
 144   EFI_BLOCK_IO_PROTOCOL     BlockIo;
 145   CARD_INFO                 CardInfo;
 146   EFI_MMC_HOST_PROTOCOL     *MmcHost;
 147 } MMC_HOST_INSTANCE;
 148
 149 #define MMC_HOST_INSTANCE_SIGNATURE                 SIGNATURE_32('m', 'm', 'c', 'h')
 150 #define MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(a)     CR (a, MMC_HOST_INSTANCE, BlockIo, MMC_HOST_INSTANCE_SIGNATURE)
 151 #define MMC_HOST_INSTANCE_FROM_LINK(a)              CR (a, MMC_HOST_INSTANCE, Link, MMC_HOST_INSTANCE_SIGNATURE)
 152
 153
 154 EFI_STATUS
 155 EFIAPI
 156 MmcGetDriverName (
 157   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
 158   IN  CHAR8                        *Language,
 159   OUT CHAR16                       **DriverName
 160   );
 161
 162 EFI_STATUS
 163 EFIAPI
 164 MmcGetControllerName (
 165   IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
 166   IN  EFI_HANDLE                                      ControllerHandle,
 167   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 168   IN  CHAR8                                           *Language,
 169   OUT CHAR16                                          **ControllerName
 170   );
 171
 172 extern EFI_COMPONENT_NAME_PROTOCOL  gMmcComponentName;
 173 extern EFI_COMPONENT_NAME2_PROTOCOL gMmcComponentName2;
 174
 175 extern EFI_DRIVER_DIAGNOSTICS2_PROTOCOL gMmcDriverDiagnostics2;
 176
 177 extern LIST_ENTRY mMmcHostPool;
 178
 179 /**
 180   Reset the block device.
 181
 182   This function implements EFI_BLOCK_IO_PROTOCOL.Reset().
 183   It resets the block device hardware.
 184   ExtendedVerification is ignored in this implementation.
 185
 186   @param  This                   Indicates a pointer to the calling context.
 187   @param  ExtendedVerification   Indicates that the driver may perform a more exhaustive
 188                                  verification operation of the device during reset.
 189
 190   @retval EFI_SUCCESS            The block device was reset.
 191   @retval EFI_DEVICE_ERROR       The block device is not functioning correctly and could not be reset.
 192
 193 **/
 194 EFI_STATUS
 195 EFIAPI
 196 MmcReset (
 197   IN EFI_BLOCK_IO_PROTOCOL    *This,
 198   IN BOOLEAN                  ExtendedVerification
 199   );
 200
 201 /**
 202   Reads the requested number of blocks from the device.
 203
 204   This function implements EFI_BLOCK_IO_PROTOCOL.ReadBlocks().
 205   It reads the requested number of blocks from the device.
 206   All the blocks are read, or an error is returned.
 207
 208   @param  This                   Indicates a pointer to the calling context.
 209   @param  MediaId                The media ID that the read request is for.
 210   @param  Lba                    The starting logical block address to read from on the device.
 211   @param  BufferSize             The size of the Buffer in bytes.
 212                                  This must be a multiple of the intrinsic block size of the device.
 213   @param  Buffer                 A pointer to the destination buffer for the data. The caller is
 214                                  responsible for either having implicit or explicit ownership of the buffer.
 215
 216   @retval EFI_SUCCESS            The data was read correctly from the device.
 217   @retval EFI_DEVICE_ERROR       The device reported an error while attempting to perform the read operation.
 218   @retval EFI_NO_MEDIA           There is no media in the device.
 219   @retval EFI_MEDIA_CHANGED      The MediaId is not for the current media.
 220   @retval EFI_BAD_BUFFER_SIZE    The BufferSize parameter is not a multiple of the intrinsic block size of the device.
 221   @retval EFI_INVALID_PARAMETER  The read request contains LBAs that are not valid,
 222                                  or the buffer is not on proper alignment.
 223
 224 **/
 225 EFI_STATUS
 226 EFIAPI
 227 MmcReadBlocks (
 228   IN EFI_BLOCK_IO_PROTOCOL    *This,
 229   IN UINT32                   MediaId,
 230   IN EFI_LBA                  Lba,
 231   IN UINTN                    BufferSize,
 232   OUT VOID                    *Buffer
 233   );
 234
 235 /**
 236   Writes a specified number of blocks to the device.
 237
 238   This function implements EFI_BLOCK_IO_PROTOCOL.WriteBlocks().
 239   It writes a specified number of blocks to the device.
 240   All blocks are written, or an error is returned.
 241
 242   @param  This                   Indicates a pointer to the calling context.
 243   @param  MediaId                The media ID that the write request is for.
 244   @param  Lba                    The starting logical block address to be written.
 245   @param  BufferSize             The size of the Buffer in bytes.
 246                                  This must be a multiple of the intrinsic block size of the device.
 247   @param  Buffer                 Pointer to the source buffer for the data.
 248
 249   @retval EFI_SUCCESS            The data were written correctly to the device.
 250   @retval EFI_WRITE_PROTECTED    The device cannot be written to.
 251   @retval EFI_NO_MEDIA           There is no media in the device.
 252   @retval EFI_MEDIA_CHANGED      The MediaId is not for the current media.
 253   @retval EFI_DEVICE_ERROR       The device reported an error while attempting to perform the write operation.
 254   @retval EFI_BAD_BUFFER_SIZE    The BufferSize parameter is not a multiple of the intrinsic
 255                                  block size of the device.
 256   @retval EFI_INVALID_PARAMETER  The write request contains LBAs that are not valid,
 257                                  or the buffer is not on proper alignment.
 258
 259 **/
 260 EFI_STATUS
 261 EFIAPI
 262 MmcWriteBlocks (
 263   IN EFI_BLOCK_IO_PROTOCOL    *This,
 264   IN UINT32                   MediaId,
 265   IN EFI_LBA                  Lba,
 266   IN UINTN                    BufferSize,
 267   IN VOID                     *Buffer
 268   );
 269
 270 /**
 271   Flushes all modified data to a physical block device.
 272
 273   @param  This                   Indicates a pointer to the calling context.
 274
 275   @retval EFI_SUCCESS            All outstanding data were written correctly to the device.
 276   @retval EFI_DEVICE_ERROR       The device reported an error while attempting to write data.
 277   @retval EFI_NO_MEDIA           There is no media in the device.
 278
 279 **/
 280 EFI_STATUS
 281 EFIAPI
 282 MmcFlushBlocks (
 283   IN EFI_BLOCK_IO_PROTOCOL  *This
 284   );
 285
 286 #endif