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