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