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