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 } MMC_HOST_INSTANCE;
 150
 151 #define MMC_HOST_INSTANCE_SIGNATURE                 SIGNATURE_32('m', 'm', 'c', 'h')
 152 #define MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(a)     CR (a, MMC_HOST_INSTANCE, BlockIo, MMC_HOST_INSTANCE_SIGNATURE)
 153 #define MMC_HOST_INSTANCE_FROM_LINK(a)              CR (a, MMC_HOST_INSTANCE, Link, MMC_HOST_INSTANCE_SIGNATURE)
 154
 155
 156 EFI_STATUS
 157 EFIAPI
 158 MmcGetDriverName (
 159   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
 160   IN  CHAR8                        *Language,
 161   OUT CHAR16                       **DriverName
 162   );
 163
 164 EFI_STATUS
 165 EFIAPI
 166 MmcGetControllerName (
 167   IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
 168   IN  EFI_HANDLE                                      ControllerHandle,
 169   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 170   IN  CHAR8                                           *Language,
 171   OUT CHAR16                                          **ControllerName
 172   );
 173
 174 extern EFI_COMPONENT_NAME_PROTOCOL  gMmcComponentName;
 175 extern EFI_COMPONENT_NAME2_PROTOCOL gMmcComponentName2;
 176
 177 extern EFI_DRIVER_DIAGNOSTICS2_PROTOCOL gMmcDriverDiagnostics2;
 178
 179 extern LIST_ENTRY mMmcHostPool;
 180
 181 /**
 182   Reset the block device.
 183
 184   This function implements EFI_BLOCK_IO_PROTOCOL.Reset().
 185   It resets the block device hardware.
 186   ExtendedVerification is ignored in this implementation.
 187
 188   @param  This                   Indicates a pointer to the calling context.
 189   @param  ExtendedVerification   Indicates that the driver may perform a more exhaustive
 190                                  verification operation of the device during reset.
 191
 192   @retval EFI_SUCCESS            The block device was reset.
 193   @retval EFI_DEVICE_ERROR       The block device is not functioning correctly and could not be reset.
 194
 195 **/
 196 EFI_STATUS
 197 EFIAPI
 198 MmcReset (
 199   IN EFI_BLOCK_IO_PROTOCOL    *This,
 200   IN BOOLEAN                  ExtendedVerification
 201   );
 202
 203 /**
 204   Reads the requested number of blocks from the device.
 205
 206   This function implements EFI_BLOCK_IO_PROTOCOL.ReadBlocks().
 207   It reads the requested number of blocks from the device.
 208   All the blocks are read, or an error is returned.
 209
 210   @param  This                   Indicates a pointer to the calling context.
 211   @param  MediaId                The media ID that the read request is for.
 212   @param  Lba                    The starting logical block address to read from on the device.
 213   @param  BufferSize             The size of the Buffer in bytes.
 214                                  This must be a multiple of the intrinsic block size of the device.
 215   @param  Buffer                 A pointer to the destination buffer for the data. The caller is
 216                                  responsible for either having implicit or explicit ownership of the buffer.
 217
 218   @retval EFI_SUCCESS            The data was read correctly from the device.
 219   @retval EFI_DEVICE_ERROR       The device reported an error while attempting to perform the read operation.
 220   @retval EFI_NO_MEDIA           There is no media in the device.
 221   @retval EFI_MEDIA_CHANGED      The MediaId is not for the current media.
 222   @retval EFI_BAD_BUFFER_SIZE    The BufferSize parameter is not a multiple of the intrinsic block size of the device.
 223   @retval EFI_INVALID_PARAMETER  The read request contains LBAs that are not valid,
 224                                  or the buffer is not on proper alignment.
 225
 226 **/
 227 EFI_STATUS
 228 EFIAPI
 229 MmcReadBlocks (
 230   IN EFI_BLOCK_IO_PROTOCOL    *This,
 231   IN UINT32                   MediaId,
 232   IN EFI_LBA                  Lba,
 233   IN UINTN                    BufferSize,
 234   OUT VOID                    *Buffer
 235   );
 236
 237 /**
 238   Writes a specified number of blocks to the device.
 239
 240   This function implements EFI_BLOCK_IO_PROTOCOL.WriteBlocks().
 241   It writes a specified number of blocks to the device.
 242   All blocks are written, or an error is returned.
 243
 244   @param  This                   Indicates a pointer to the calling context.
 245   @param  MediaId                The media ID that the write request is for.
 246   @param  Lba                    The starting logical block address to be written.
 247   @param  BufferSize             The size of the Buffer in bytes.
 248                                  This must be a multiple of the intrinsic block size of the device.
 249   @param  Buffer                 Pointer to the source buffer for the data.
 250
 251   @retval EFI_SUCCESS            The data were written correctly to the device.
 252   @retval EFI_WRITE_PROTECTED    The device cannot be written to.
 253   @retval EFI_NO_MEDIA           There is no media in the device.
 254   @retval EFI_MEDIA_CHANGED      The MediaId is not for the current media.
 255   @retval EFI_DEVICE_ERROR       The device reported an error while attempting to perform the write operation.
 256   @retval EFI_BAD_BUFFER_SIZE    The BufferSize parameter is not a multiple of the intrinsic
 257                                  block size of the device.
 258   @retval EFI_INVALID_PARAMETER  The write request contains LBAs that are not valid,
 259                                  or the buffer is not on proper alignment.
 260
 261 **/
 262 EFI_STATUS
 263 EFIAPI
 264 MmcWriteBlocks (
 265   IN EFI_BLOCK_IO_PROTOCOL    *This,
 266   IN UINT32                   MediaId,
 267   IN EFI_LBA                  Lba,
 268   IN UINTN                    BufferSize,
 269   IN VOID                     *Buffer
 270   );
 271
 272 /**
 273   Flushes all modified data to a physical block device.
 274
 275   @param  This                   Indicates a pointer to the calling context.
 276
 277   @retval EFI_SUCCESS            All outstanding data were written correctly to the device.
 278   @retval EFI_DEVICE_ERROR       The device reported an error while attempting to write data.
 279   @retval EFI_NO_MEDIA           There is no media in the device.
 280
 281 **/
 282 EFI_STATUS
 283 EFIAPI
 284 MmcFlushBlocks (
 285   IN EFI_BLOCK_IO_PROTOCOL  *This
 286   );
 287
 288 #endif