1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
|
/** @file
Main Header file for the MMC DXE driver
Copyright (c) 2011-2015, ARM Limited. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef __MMC_H
#define __MMC_H
#include <Uefi.h>
#include <Protocol/DiskIo.h>
#include <Protocol/BlockIo.h>
#include <Protocol/DevicePath.h>
#include <Protocol/MmcHost.h>
#include <Library/UefiLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#define MMC_TRACE(txt) DEBUG((DEBUG_BLKIO, "MMC: " txt "\n"))
#define MMC_IOBLOCKS_READ 0
#define MMC_IOBLOCKS_WRITE 1
#define MMC_OCR_POWERUP 0x80000000
#define MMC_OCR_ACCESS_MASK 0x3 /* bit[30-29] */
#define MMC_OCR_ACCESS_BYTE 0x1 /* bit[29] */
#define MMC_OCR_ACCESS_SECTOR 0x2 /* bit[30] */
#define MMC_CSD_GET_CCC(Response) (Response[2] >> 20)
#define MMC_CSD_GET_TRANSPEED(Response) (Response[3] & 0xFF)
#define MMC_CSD_GET_READBLLEN(Response) ((Response[2] >> 16) & 0xF)
#define MMC_CSD_GET_WRITEBLLEN(Response) ((Response[0] >> 22) & 0xF)
#define MMC_CSD_GET_FILEFORMAT(Response) ((Response[0] >> 10) & 0x3)
#define MMC_CSD_GET_FILEFORMATGRP(Response) ((Response[0] >> 15) & 0x1)
#define MMC_CSD_GET_DEVICESIZE(csd) (((Response[1] >> 30) & 0x3) | ((Response[2] & 0x3FF) << 2))
#define HC_MMC_CSD_GET_DEVICESIZE(Response) ((Response[1] >> 16) | ((Response[2] & 0x40) << 16));
#define MMC_CSD_GET_DEVICESIZEMULT(csd) ((Response[1] >> 15) & 0x7)
#define MMC_R0_READY_FOR_DATA (1 << 8)
#define MMC_R0_CURRENTSTATE(Response) ((Response[0] >> 9) & 0xF)
#define MMC_R0_STATE_IDLE 0
#define MMC_R0_STATE_READY 1
#define MMC_R0_STATE_IDENT 2
#define MMC_R0_STATE_STDBY 3
#define MMC_R0_STATE_TRAN 4
#define MMC_R0_STATE_DATA 5
#define EMMC_CMD6_ARG_ACCESS(x) (((x) & 0x3) << 24)
#define EMMC_CMD6_ARG_INDEX(x) (((x) & 0xFF) << 16)
#define EMMC_CMD6_ARG_VALUE(x) (((x) & 0xFF) << 8)
#define EMMC_CMD6_ARG_CMD_SET(x) (((x) & 0x7) << 0)
#define SWITCH_CMD_DATA_LENGTH 64
#define SD_HIGH_SPEED_SUPPORTED 0x20000
#define SD_DEFAULT_SPEED 25000000
#define SD_HIGH_SPEED 50000000
#define SWITCH_CMD_SUCCESS_MASK 0x0f000000
#define SD_CARD_CAPACITY 0x00000002
#define BUSWIDTH_4 4
typedef enum {
UNKNOWN_CARD,
MMC_CARD, // MMC card
MMC_CARD_HIGH, // MMC Card with High capacity
EMMC_CARD, // eMMC 4.41 card
SD_CARD, // SD 1.1 card
SD_CARD_2, // SD 2.0 or above standard card
SD_CARD_2_HIGH // SD 2.0 or above high capacity card
} CARD_TYPE;
typedef struct {
UINT32 Reserved0 : 7; // 0
UINT32 V170_V195 : 1; // 1.70V - 1.95V
UINT32 V200_V260 : 7; // 2.00V - 2.60V
UINT32 V270_V360 : 9; // 2.70V - 3.60V
UINT32 RESERVED_1 : 5; // Reserved
UINT32 AccessMode : 2; // 00b (byte mode), 10b (sector mode)
UINT32 PowerUp : 1; // This bit is set to LOW if the card has not finished the power up routine
} OCR;
typedef struct {
UINT8 SD_SPEC : 4; // SD Memory Card - Spec. Version [59:56]
UINT8 SCR_STRUCTURE : 4; // SCR Structure [63:60]
UINT8 SD_BUS_WIDTHS : 4; // DAT Bus widths supported [51:48]
UINT8 DATA_STAT_AFTER_ERASE : 1; // Data Status after erases [55]
UINT8 SD_SECURITY : 3; // CPRM Security Support [54:52]
UINT8 EX_SECURITY_1 : 1; // Extended Security Support [43]
UINT8 SD_SPEC4 : 1; // Spec. Version 4.00 or higher [42]
UINT8 RESERVED_1 : 2; // Reserved [41:40]
UINT8 SD_SPEC3 : 1; // Spec. Version 3.00 or higher [47]
UINT8 EX_SECURITY_2 : 3; // Extended Security Support [46:44]
UINT8 CMD_SUPPORT : 4; // Command Support bits [35:32]
UINT8 RESERVED_2 : 4; // Reserved [39:36]
UINT32 RESERVED_3; // Manufacturer Usage [31:0]
} SCR;
typedef struct {
UINT32 NOT_USED; // 1 [0:0]
UINT32 CRC; // CRC7 checksum [7:1]
UINT32 MDT; // Manufacturing date [19:8]
UINT32 RESERVED_1; // Reserved [23:20]
UINT32 PSN; // Product serial number [55:24]
UINT8 PRV; // Product revision [63:56]
UINT8 PNM[5]; // Product name [64:103]
UINT16 OID; // OEM/Application ID [119:104]
UINT8 MID; // Manufacturer ID [127:120]
} CID;
typedef struct {
UINT8 NOT_USED : 1; // Not used, always 1 [0:0]
UINT8 CRC : 7; // CRC [7:1]
UINT8 RESERVED_1 : 2; // Reserved [9:8]
UINT8 FILE_FORMAT : 2; // File format [11:10]
UINT8 TMP_WRITE_PROTECT : 1; // Temporary write protection [12:12]
UINT8 PERM_WRITE_PROTECT : 1; // Permanent write protection [13:13]
UINT8 COPY : 1; // Copy flag (OTP) [14:14]
UINT8 FILE_FORMAT_GRP : 1; // File format group [15:15]
UINT16 RESERVED_2 : 5; // Reserved [20:16]
UINT16 WRITE_BL_PARTIAL : 1; // Partial blocks for write allowed [21:21]
UINT16 WRITE_BL_LEN : 4; // Max. write data block length [25:22]
UINT16 R2W_FACTOR : 3; // Write speed factor [28:26]
UINT16 RESERVED_3 : 2; // Reserved [30:29]
UINT16 WP_GRP_ENABLE : 1; // Write protect group enable [31:31]
UINT32 WP_GRP_SIZE : 7; // Write protect group size [38:32]
UINT32 SECTOR_SIZE : 7; // Erase sector size [45:39]
UINT32 ERASE_BLK_EN : 1; // Erase single block enable [46:46]
UINT32 C_SIZE_MULT : 3; // Device size multiplier [49:47]
UINT32 VDD_W_CURR_MAX : 3; // Max. write current @ VDD max [52:50]
UINT32 VDD_W_CURR_MIN : 3; // Max. write current @ VDD min [55:53]
UINT32 VDD_R_CURR_MAX : 3; // Max. read current @ VDD max [58:56]
UINT32 VDD_R_CURR_MIN : 3; // Max. read current @ VDD min [61:59]
UINT32 C_SIZELow2 : 2; // Device size [63:62]
UINT32 C_SIZEHigh10 : 10; // Device size [73:64]
UINT32 RESERVED_4 : 2; // Reserved [75:74]
UINT32 DSR_IMP : 1; // DSR implemented [76:76]
UINT32 READ_BLK_MISALIGN : 1; // Read block misalignment [77:77]
UINT32 WRITE_BLK_MISALIGN : 1; // Write block misalignment [78:78]
UINT32 READ_BL_PARTIAL : 1; // Partial blocks for read allowed [79:79]
UINT32 READ_BL_LEN : 4; // Max. read data block length [83:80]
UINT32 CCC : 12; // Card command classes [95:84]
UINT8 TRAN_SPEED; // Max. bus clock frequency [103:96]
UINT8 NSAC; // Data read access-time 2 in CLK cycles (NSAC*100) [111:104]
UINT8 TAAC; // Data read access-time 1 [119:112]
UINT8 RESERVED_5 : 2; // Reserved [121:120]
UINT8 SPEC_VERS : 4; // System specification version [125:122]
UINT8 CSD_STRUCTURE : 2; // CSD structure [127:126]
} CSD;
typedef struct {
UINT8 RESERVED_1[16]; // Reserved [15:0]
UINT8 SECURE_REMOVAL_TYPE; // Secure Removal Type [16:16]
UINT8 PRODUCT_STATE_AWARENESS_ENABLEMENT; // Product state awareness enablement [17:17]
UINT8 MAX_PRE_LOADING_DATA_SIZE[4]; // MAX pre loading data size [21:18]
UINT8 PRE_LOADING_DATA_SIZE[4]; // Pre loading data size [25:22]
UINT8 FFU_STATUS; // FFU Status [26:26]
UINT8 RESERVED_2[2]; // Reserved [28:27]
UINT8 MODE_OPERATION_CODES; // Mode operation codes [29:29]
UINT8 MODE_CONFIG; // Mode config [30:30]
UINT8 RESERVED_3; // Reserved [31:31]
UINT8 FLUSH_CACHE; // Flushing of the cache [32:32]
UINT8 CACHE_CTRL; // Control to turn the cache ON/OFF [33:33]
UINT8 POWER_OFF_NOTIFICATION; // Power Off Notification [34:34]
UINT8 PACKED_FAILURE_INDEX; // Packed command failure index [35:35]
UINT8 PACKED_COMMAND_STATUS; // Packed command status [36:36]
UINT8 CONTEXT_CONF[15]; // Context configuration [51:37]
UINT8 EXT_PARTITIONS_ATTRIBUTE[2]; // Extended partitions attribute [53:52]
UINT8 EXCEPTION_EVENTS_STATUS[2]; // Exception events status [55:54]
UINT8 EXCEPTION_EVENTS_CTRL[2]; // Exception events control [57:56]
UINT8 DYNCAP_NEEDED; // Number of addressed group to be released [58:58]
UINT8 CLASS_6_CTRL; // Class 6 commands control [59:59]
UINT8 INI_TIMEOUT_EMU; // 1st initialization after disabling sector size emulation [60:60]
UINT8 DATA_SECTOR_SIZE; // Sector size [61:61]
UINT8 USE_NATIVE_SECTOR; // Sector size emulation [62:62]
UINT8 NATIVE_SECTOR_SIZE; // Native sector size [63:63]
UINT8 VENDOR_SPECIFIC_FIELD[64]; // Vendor specific fields [127:64]
UINT8 RESERVED_4[2]; // Reserved [129:128]
UINT8 PROGRAM_CID_CSD_DDR_SUPPORT; // Program CID/CSD in DDR mode support [130:130]
UINT8 PERIODIC_WAKEUP; // Periodic wake-up [131:131]
UINT8 TCASE_SUPPORT; // Package case temperature is controlled [132:132]
UINT8 PRODUCTION_STATE_AWARENESS; // Production state awareness [133:133]
UINT8 SECTOR_BAD_BLK_MGMNT; // Bad block management mode [134:134]
UINT8 RESERVED_5; // Reserved [135:135]
UINT8 ENH_START_ADDR[4]; // Enhanced user data start address [139:136]
UINT8 ENH_SIZE_MULT[3]; // Enhanced user data area size [142:140]
UINT8 GP_SIZE_MULT[12]; // General purpose partition size [154:143]
UINT8 PARTITION_SETTING_COMPLETED; // Partitioning setting [155:155]
UINT8 PARTITIONS_ATTRIBUTE; // Partitions attribute [156:156]
UINT8 MAX_ENH_SIZE_MULT[3]; // Max enhanced area size [159:157]
UINT8 PARTITIONING_SUPPORT; // Partitioning [160:160]
UINT8 HPI_MGMT; // HPI management [161:161]
UINT8 RST_N_FUNCTION; // H/W reset function [162:162]
UINT8 BKOPS_EN; // Enable background operations handshake [163:163]
UINT8 BKOPS_START; // Manually start background operations [164:164]
UINT8 SANITIZE_START; // Start sanitize operation [165:165]
UINT8 WR_REL_PARAM; // Write reliability parameter register [166:166]
UINT8 WR_REL_SET; // Write reliability setting register [167:167]
UINT8 RPMB_SIZE_MULT; // RPMB size [168:168]
UINT8 FW_CONFIG; // FW configuration [169:169]
UINT8 RESERVED_6; // Reserved [170:170]
UINT8 USER_WP; // User area write protection register [171:171]
UINT8 RESERVED_7; // Reserved [172:172]
UINT8 BOOT_WP; // Boot area write protection register [173:173]
UINT8 BOOT_WP_STATUS; // Boot write protection register [174:174]
UINT8 ERASE_GROUP_DEF; // High-density erase group definition [175:175]
UINT8 RESERVED_8; // Reserved [176:176]
UINT8 BOOT_BUS_CONDITIONS; // Boot bus conditions [177:177]
UINT8 BOOT_CONFIG_PROT; // Boot config protection [178:178]
UINT8 PARTITION_CONFIG; // Partition config [179:179]
UINT8 RESERVED_9; // Reserved [180:180]
UINT8 ERASED_MEM_CONT; // Erased memory content [181:181]
UINT8 RESERVED_10; // Reserved [182:182]
UINT8 BUS_WIDTH; // Bus width mode [183:183]
UINT8 RESERVED_11; // Reserved [184:184]
UINT8 HS_TIMING; // High-speed interface timing [185:185]
UINT8 RESERVED_12; // Reserved [186:186]
UINT8 POWER_CLASS; // Power class [187:187]
UINT8 RESERVED_13; // Reserved [188:188]
UINT8 CMD_SET_REV; // Command set revision [189:189]
UINT8 RESERVED_14; // Reserved [190:190]
UINT8 CMD_SET; // Command set [191:191]
UINT8 EXT_CSD_REV; // Extended CSD revision [192:192]
UINT8 RESERVED_15; // Reserved [193:193]
UINT8 CSD_STRUCTURE; // CSD Structure [194:194]
UINT8 RESERVED_16; // Reserved [195:195]
UINT8 DEVICE_TYPE; // Device type [196:196]
UINT8 DRIVER_STRENGTH; // I/O Driver strength [197:197]
UINT8 OUT_OF_INTERRUPT_TIME; // Out-of-interrupt busy timing [198:198]
UINT8 PARTITION_SWITCH_TIME; // Partition switching timing [199:199]
UINT8 PWR_CL_52_195; // Power class for 52MHz at 1.95V 1 R [200:200]
UINT8 PWR_CL_26_195; // Power class for 26MHz at 1.95V 1 R [201:201]
UINT8 PWR_CL_52_360; // Power class for 52MHz at 3.6V 1 R [202:202]
UINT8 PWR_CL_26_360; // Power class for 26MHz at 3.6V 1 R [203:203]
UINT8 RESERVED_17; // Reserved [204:204]
UINT8 MIN_PERF_R_4_26; // Minimum read performance for 4bit at 26MHz [205:205]
UINT8 MIN_PERF_W_4_26; // Minimum write performance for 4bit at 26MHz [206:206]
UINT8 MIN_PERF_R_8_26_4_52; // Minimum read performance for 8bit at 26MHz, for 4bit at 52MHz [207:207]
UINT8 MIN_PERF_W_8_26_4_52; // Minimum write performance for 8bit at 26MHz, for 4bit at 52MHz [208:208]
UINT8 MIN_PERF_R_8_52; // Minimum read performance for 8bit at 52MHz [209:209]
UINT8 MIN_PERF_W_8_52; // Minimum write performance for 8bit at 52MHz [210:210]
UINT8 RESERVED_18; // Reserved [211:211]
UINT32 SECTOR_COUNT; // Sector count [215:212]
UINT8 SLEEP_NOTIFICATION_TIME; // Sleep notification timeout [216:216]
UINT8 S_A_TIMEOUT; // Sleep/awake timeout [217:217]
UINT8 PRODUCTION_STATE_AWARENESS_TIMEOUT; // Production state awareness timeout [218:218]
UINT8 S_C_VCCQ; // Sleep current (VCCQ) [219:219]
UINT8 S_C_VCC; // Sleep current (VCC) [220:220]
UINT8 HC_WP_GRP_SIZE; // High-capacity write protect group size [221:221]
UINT8 REL_WR_SECTOR_C; // Reliable write sector count [222:222]
UINT8 ERASE_TIMEOUT_MULT; // High-capacity erase timeout [223:223]
UINT8 HC_ERASE_GRP_SIZE; // High-capacity erase unit size [224:224]
UINT8 ACC_SIZE; // Access size [225:225]
UINT8 BOOT_SIZE_MULTI; // Boot partition size [226:226]
UINT8 RESERVED_19; // Reserved [227:227]
UINT8 BOOT_INFO; // Boot information [228:228]
UINT8 SECURE_TRIM_MULT; // Secure TRIM Multiplier [229:229]
UINT8 SECURE_ERASE_MULT; // Secure Erase Multiplier [230:230]
UINT8 SECURE_FEATURE_SUPPORT; // Secure Feature Support [231:231]
UINT8 TRIM_MULT; // TRIM Multiplier [232:232]
UINT8 RESERVED_20; // Reserved [233:233]
UINT8 MIN_PREF_DDR_R_8_52; // Minimum read performance for 8bit at 52MHz in DDR mode [234:234]
UINT8 MIN_PREF_DDR_W_8_52; // Minimum write performance for 8bit at 52MHz in DDR mode [235:235]
UINT8 PWR_CL_200_130; // Power class for 200MHz at VCCQ=1.3V, VCC=3.6V [236:236]
UINT8 PWR_CL_200_195; // Power class for 200MHz at VCCQ=1.95V, VCC=3.6V [237:237]
UINT8 PWR_CL_DDR_52_195; // Power class for 52MHz, DDR at 1.95V [238:238]
UINT8 PWR_CL_DDR_52_360; // Power class for 52Mhz, DDR at 3.6V [239:239]
UINT8 RESERVED_21; // Reserved [240:240]
UINT8 INI_TIMEOUT_AP; // 1st initialization time after partitioning [241:241]
UINT8 CORRECTLY_PRG_SECTORS_NUM[4]; // Number of correctly programmed sectors [245:242]
UINT8 BKOPS_STATUS; // Background operations status [246:246]
UINT8 POWER_OFF_LONG_TIME; // Power off notification (long) timeout [247:247]
UINT8 GENERIC_CMD6_TIME; // Generic CMD6 timeout [248:248]
UINT8 CACHE_SIZE[4]; // Cache size [252:249]
UINT8 PWR_CL_DDR_200_360; // Power class for 200MHz, DDR at VCC=3.6V [253:253]
UINT8 FIRMWARE_VERSION[8]; // Firmware version [261:254]
UINT8 DEVICE_VERSION[2]; // Device version [263:262]
UINT8 OPTIMAL_TRIM_UNIT_SIZE; // Optimal trim unit size [264:264]
UINT8 OPTIMAL_WRITE_SIZE; // Optimal write size [265:265]
UINT8 OPTIMAL_READ_SIZE; // Optimal read size [266:266]
UINT8 PRE_EOL_INFO; // Pre EOL information [267:267]
UINT8 DEVICE_LIFE_TIME_EST_TYP_A; // Device life time estimation type A [268:268]
UINT8 DEVICE_LIFE_TIME_EST_TYP_B; // Device life time estimation type B [269:269]
UINT8 VENDOR_PROPRIETARY_HEALTH_REPORT[32]; // Vendor proprietary health report [301:270]
UINT8 NUMBER_OF_FW_SECTORS_CORRECTLY_PROGRAMMED[4]; // Number of FW sectors correctly programmed [305:302]
UINT8 RESERVED_22[181]; // Reserved [486:306]
UINT8 FFU_ARG[4]; // FFU argument [490:487]
UINT8 OPERATION_CODE_TIMEOUT; // Operation codes timeout [491:491]
UINT8 FFU_FEATURES; // FFU features [492:492]
UINT8 SUPPORTED_MODES; // Supported modes [493:493]
UINT8 EXT_SUPPORT; // Extended partitions attribute support [494:494]
UINT8 LARGE_UNIT_SIZE_M1; // Large unit size [495:495]
UINT8 CONTEXT_CAPABILITIES; // Context management capabilities [496:496]
UINT8 TAG_RES_SIZE; // Tag resource size [497:497]
UINT8 TAG_UNIT_SIZE; // Tag unit size [498:498]
UINT8 DATA_TAG_SUPPORT; // Data tag support [499:499]
UINT8 MAX_PACKED_WRITES; // Max packed write commands [500:500]
UINT8 MAX_PACKED_READS; // Max packed read commands [501:501]
UINT8 BKOPS_SUPPORT; // Background operations support [502:502]
UINT8 HPI_FEATURES; // HPI features [503:503]
UINT8 S_CMD_SET; // Supported command sets [504:504]
UINT8 EXT_SECURITY_ERR; // Extended security commands error [505:505]
UINT8 RESERVED_23[6]; // Reserved [511:506]
} ECSD;
typedef struct {
UINT16 RCA;
CARD_TYPE CardType;
OCR OCRData;
CID CIDData;
CSD CSDData;
ECSD *ECSDData; // MMC V4 extended card specific
} CARD_INFO;
typedef struct _MMC_HOST_INSTANCE {
UINTN Signature;
LIST_ENTRY Link;
EFI_HANDLE MmcHandle;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
MMC_STATE State;
EFI_BLOCK_IO_PROTOCOL BlockIo;
CARD_INFO CardInfo;
EFI_MMC_HOST_PROTOCOL *MmcHost;
BOOLEAN Initialized;
} MMC_HOST_INSTANCE;
#define MMC_HOST_INSTANCE_SIGNATURE SIGNATURE_32('m', 'm', 'c', 'h')
#define MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(a) CR (a, MMC_HOST_INSTANCE, BlockIo, MMC_HOST_INSTANCE_SIGNATURE)
#define MMC_HOST_INSTANCE_FROM_LINK(a) CR (a, MMC_HOST_INSTANCE, Link, MMC_HOST_INSTANCE_SIGNATURE)
EFI_STATUS
EFIAPI
MmcGetDriverName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN CHAR8 *Language,
OUT CHAR16 **DriverName
);
EFI_STATUS
EFIAPI
MmcGetControllerName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_HANDLE ChildHandle OPTIONAL,
IN CHAR8 *Language,
OUT CHAR16 **ControllerName
);
extern EFI_COMPONENT_NAME_PROTOCOL gMmcComponentName;
extern EFI_COMPONENT_NAME2_PROTOCOL gMmcComponentName2;
extern EFI_DRIVER_DIAGNOSTICS2_PROTOCOL gMmcDriverDiagnostics2;
extern LIST_ENTRY mMmcHostPool;
/**
Reset the block device.
This function implements EFI_BLOCK_IO_PROTOCOL.Reset().
It resets the block device hardware.
ExtendedVerification is ignored in this implementation.
@param This Indicates a pointer to the calling context.
@param ExtendedVerification Indicates that the driver may perform a more exhaustive
verification operation of the device during reset.
@retval EFI_SUCCESS The block device was reset.
@retval EFI_DEVICE_ERROR The block device is not functioning correctly and could not be reset.
**/
EFI_STATUS
EFIAPI
MmcReset (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
);
/**
Reads the requested number of blocks from the device.
This function implements EFI_BLOCK_IO_PROTOCOL.ReadBlocks().
It reads the requested number of blocks from the device.
All the blocks are read, or an error is returned.
@param This Indicates a pointer to the calling context.
@param MediaId The media ID that the read request is for.
@param Lba The starting logical block address to read from on the device.
@param BufferSize The size of the Buffer in bytes.
This must be a multiple of the intrinsic block size of the device.
@param Buffer A pointer to the destination buffer for the data. The caller is
responsible for either having implicit or explicit ownership of the buffer.
@retval EFI_SUCCESS The data was read correctly from the device.
@retval EFI_DEVICE_ERROR The device reported an error while attempting to perform the read operation.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHANGED The MediaId is not for the current media.
@retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of the intrinsic block size of the device.
@retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
MmcReadBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
);
/**
Writes a specified number of blocks to the device.
This function implements EFI_BLOCK_IO_PROTOCOL.WriteBlocks().
It writes a specified number of blocks to the device.
All blocks are written, or an error is returned.
@param This Indicates a pointer to the calling context.
@param MediaId The media ID that the write request is for.
@param Lba The starting logical block address to be written.
@param BufferSize The size of the Buffer in bytes.
This must be a multiple of the intrinsic block size of the device.
@param Buffer Pointer to the source buffer for the data.
@retval EFI_SUCCESS The data were written correctly to the device.
@retval EFI_WRITE_PROTECTED The device cannot be written to.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHANGED The MediaId is not for the current media.
@retval EFI_DEVICE_ERROR The device reported an error while attempting to perform the write operation.
@retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of the intrinsic
block size of the device.
@retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
MmcWriteBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
IN VOID *Buffer
);
/**
Flushes all modified data to a physical block device.
@param This Indicates a pointer to the calling context.
@retval EFI_SUCCESS All outstanding data were written correctly to the device.
@retval EFI_DEVICE_ERROR The device reported an error while attempting to write data.
@retval EFI_NO_MEDIA There is no media in the device.
**/
EFI_STATUS
EFIAPI
MmcFlushBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This
);
EFI_STATUS
MmcNotifyState (
IN MMC_HOST_INSTANCE *MmcHostInstance,
IN MMC_STATE State
);
EFI_STATUS
InitializeMmcDevice (
IN MMC_HOST_INSTANCE *MmcHost
);
VOID
EFIAPI
CheckCardsCallback (
IN EFI_EVENT Event,
IN VOID *Context
);
VOID
PrintCSD (
IN UINT32 *Csd
);
VOID
PrintRCA (
IN UINT32 Rca
);
VOID
PrintOCR (
IN UINT32 Ocr
);
VOID
PrintResponseR1 (
IN UINT32 Response
);
VOID
PrintCID (
IN UINT32 *Cid
);
#endif
|
