Cleanup SerailIO drivers to have a device path and use PCD settings for various stuff...
[mirror_edk2.git] / Omap35xxPkg / MMCHSDxe / MMCHS.c
1 /** @file
2
3   Copyright (c) 2008-2009, Apple Inc. All rights reserved.
4   
5   All rights reserved. This program and the accompanying materials
6   are licensed and made available under the terms and conditions of the BSD License
7   which accompanies this distribution.  The full text of the license may be found at
8   http://opensource.org/licenses/bsd-license.php
9
10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include <Uefi.h>
16
17 #include "MMCHS.h"
18
19 EFI_BLOCK_IO_MEDIA MMCHSMedia = {
20   SIGNATURE_32('s','d','i','o'),            // MediaId
21   TRUE,                                     // RemovableMedia
22   TRUE,                                     // MediaPresent
23   FALSE,                                    // LogicalPartition
24   FALSE,                                    // ReadOnly
25   FALSE,                                    // WriteCaching
26   512,                                      // BlockSize
27   4,                                        // IoAlign
28   0,                                        // Pad
29   0                                         // LastBlock
30 };
31
32 typedef struct {
33   VENDOR_DEVICE_PATH  Mmc;
34   EFI_DEVICE_PATH     End;
35 } MMCHS_DEVICE_PATH;
36
37 MMCHS_DEVICE_PATH gMmcHsDevicePath = 
38 {
39   {
40     HARDWARE_DEVICE_PATH,
41     HW_VENDOR_DP,
42     (UINT8)(sizeof(VENDOR_DEVICE_PATH)),
43     (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),
44     0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 
45   },
46   {
47     END_DEVICE_PATH_TYPE,
48     END_ENTIRE_DEVICE_PATH_SUBTYPE,
49     sizeof (EFI_DEVICE_PATH_PROTOCOL),
50     0
51   }
52 };
53
54 CARD_INFO                  *gCardInfo;
55 EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
56
57 //
58 // Internal Functions
59 //
60
61 STATIC
62 VOID
63 ParseCardCIDData (
64   UINT32 Response0, 
65   UINT32 Response1, 
66   UINT32 Response2,
67   UINT32 Response3
68   )
69 {
70   gCardInfo->CIDData.MDT = ((Response0 >> 8) & 0xFFF);
71   gCardInfo->CIDData.PSN = (((Response0 >> 24) & 0xFF) | ((Response1 & 0xFFFFFF) << 8));
72   gCardInfo->CIDData.PRV = ((Response1 >> 24) & 0xFF);
73   gCardInfo->CIDData.PNM[4] = ((Response2) & 0xFF);
74   gCardInfo->CIDData.PNM[3] = ((Response2 >> 8) & 0xFF);
75   gCardInfo->CIDData.PNM[2] = ((Response2 >> 16) & 0xFF);
76   gCardInfo->CIDData.PNM[1] = ((Response2 >> 24) & 0xFF);
77   gCardInfo->CIDData.PNM[0] = ((Response3) & 0xFF);
78   gCardInfo->CIDData.OID = ((Response3 >> 8) & 0xFFFF);
79   gCardInfo->CIDData.MID = ((Response3 >> 24) & 0xFF);
80 }
81
82 STATIC
83 VOID
84 UpdateMMCHSClkFrequency (
85   UINTN NewCLKD
86   )
87 {
88   //Set Clock enable to 0x0 to not provide the clock to the card
89   MmioAnd32(MMCHS_SYSCTL, ~CEN);
90
91   //Set new clock frequency.
92   MmioAndThenOr32(MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6); 
93
94   //Poll till Internal Clock Stable
95   while ((MmioRead32(MMCHS_SYSCTL) & ICS_MASK) != ICS);
96
97   //Set Clock enable to 0x1 to provide the clock to the card
98   MmioOr32(MMCHS_SYSCTL, CEN);
99 }
100
101 STATIC
102 EFI_STATUS
103 SendCmd (
104   UINTN Cmd,
105   UINTN CmdInterruptEnableVal,
106   UINTN CmdArgument
107   )
108 {
109   UINTN MmcStatus;
110   UINTN RetryCount = 0;
111
112   //Check if command line is in use or not. Poll till command line is available.
113   while ((MmioRead32(MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);
114
115   //Provide the block size.
116   MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);
117
118   //Setting Data timeout counter value to max value.
119   MmioAndThenOr32(MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);
120
121   //Clear Status register.
122   MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);
123
124   //Set command argument register
125   MmioWrite32 (MMCHS_ARG, CmdArgument);
126
127   //Enable interrupt enable events to occur
128   MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);
129
130   //Send a command
131   MmioWrite32 (MMCHS_CMD, Cmd);
132
133   //Check for the command status.
134   while (RetryCount < MAX_RETRY_COUNT) {
135     do {
136       MmcStatus = MmioRead32(MMCHS_STAT);
137     } while (MmcStatus == 0);
138
139     //Read status of command response
140     if ((MmcStatus & ERRI) != 0) {
141
142       //Perform soft-reset for mmci_cmd line.
143       MmioOr32(MMCHS_SYSCTL, SRC);
144       while ((MmioRead32(MMCHS_SYSCTL) & SRC));
145
146       DEBUG ((EFI_D_INFO, "MmcStatus: %x\n", MmcStatus));
147       return EFI_DEVICE_ERROR;
148     }
149
150     //Check if command is completed.
151     if ((MmcStatus & CC) == CC) {
152       MmioWrite32 (MMCHS_STAT, CC);
153       break;
154     }
155
156     RetryCount++;
157   }
158
159   if (RetryCount == MAX_RETRY_COUNT) {
160     return EFI_TIMEOUT;
161   }
162
163   return EFI_SUCCESS;
164 }
165
166 STATIC
167 VOID
168 GetBlockInformation (
169   UINTN *BlockSize,
170   UINTN *NumBlocks
171   )
172 {
173   CSD_SDV2 *CsdSDV2Data;
174   UINTN    CardSize;
175
176   if (gCardInfo->CardType == SD_CARD_2_HIGH) {
177     CsdSDV2Data = (CSD_SDV2 *)&gCardInfo->CSDData;
178
179     //Populate BlockSize.
180     *BlockSize = (0x1UL << CsdSDV2Data->READ_BL_LEN);
181
182     //Calculate Total number of blocks.
183     CardSize = CsdSDV2Data->C_SIZELow16 | (CsdSDV2Data->C_SIZEHigh6 << 2);
184     *NumBlocks = ((CardSize + 1) * 1024);
185   } else {
186     //Populate BlockSize.
187     *BlockSize = (0x1UL << gCardInfo->CSDData.READ_BL_LEN);
188
189     //Calculate Total number of blocks.
190     CardSize = gCardInfo->CSDData.C_SIZELow2 | (gCardInfo->CSDData.C_SIZEHigh10 << 2);
191     *NumBlocks = (CardSize + 1) * (1 << (gCardInfo->CSDData.C_SIZE_MULT + 2));
192   }
193
194   //For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.
195   if (*BlockSize > 512) {
196     *NumBlocks = MultU64x32(*NumBlocks, *BlockSize/2);
197     *BlockSize = 512;
198   }
199
200   DEBUG ((EFI_D_INFO, "Card type: %x, BlockSize: %x, NumBlocks: %x\n", gCardInfo->CardType, *BlockSize, *NumBlocks));
201 }
202
203 STATIC
204 VOID
205 CalculateCardCLKD (
206   UINTN *ClockFrequencySelect
207   )
208 {
209   UINT8    MaxDataTransferRate;
210   UINTN    TransferRateValue = 0;
211   UINTN    TimeValue = 0 ;
212   UINTN    Frequency = 0;
213
214   MaxDataTransferRate = gCardInfo->CSDData.TRAN_SPEED;
215
216   //Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
217   switch (MaxDataTransferRate & 0x7) {
218     case 0:
219       TransferRateValue = 100 * 1000;
220       break;
221
222     case 1:
223       TransferRateValue = 1 * 1000 * 1000;
224       break;
225
226     case 2:
227       TransferRateValue = 10 * 1000 * 1000;
228       break;
229
230     case 3:
231       TransferRateValue = 100 * 1000 * 1000;
232       break;
233
234     default:
235       DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
236       ASSERT(FALSE);
237   }
238
239   //Calculate Time value (Bits 6:3 of TRAN_SPEED)
240   switch ((MaxDataTransferRate >> 3) & 0xF) {
241     case 1:
242       TimeValue = 10;
243       break;
244
245     case 2:
246       TimeValue = 12;
247       break;
248
249     case 3:
250       TimeValue = 13;
251       break;
252
253     case 4:
254       TimeValue = 15;
255       break;
256
257     case 5:
258       TimeValue = 20;
259       break;
260
261     case 6:
262       TimeValue = 25;
263       break;
264
265     case 7:
266       TimeValue = 30;
267       break;
268
269     case 8:
270       TimeValue = 35;
271       break;
272
273     case 9:
274       TimeValue = 40;
275       break;
276
277     case 10:
278       TimeValue = 45;
279       break;
280
281     case 11:
282       TimeValue = 50;
283       break;
284
285     case 12:
286       TimeValue = 55;
287       break;
288
289     case 13:
290       TimeValue = 60;
291       break;
292
293     case 14:
294       TimeValue = 70;
295       break;
296
297     case 15:
298       TimeValue = 80;
299       break;
300
301     default:
302       DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
303       ASSERT(FALSE);
304   }
305
306   Frequency = TransferRateValue * TimeValue/10;
307
308   //Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
309   *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);
310
311   DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));
312 }
313
314 STATIC
315 VOID
316 GetCardConfigurationData (
317   VOID
318   )
319 {
320   UINTN  BlockSize;
321   UINTN  NumBlocks;
322   UINTN  ClockFrequencySelect;
323
324   //Calculate BlockSize and Total number of blocks in the detected card.
325   GetBlockInformation(&BlockSize, &NumBlocks);
326   gCardInfo->BlockSize = BlockSize;
327   gCardInfo->NumBlocks = NumBlocks;
328
329   //Calculate Card clock divider value.
330   CalculateCardCLKD(&ClockFrequencySelect);
331   gCardInfo->ClockFrequencySelect = ClockFrequencySelect;
332 }
333
334 STATIC
335 EFI_STATUS
336 InitializeMMCHS (
337   VOID
338   )
339 {
340   UINT8      Data = 0;
341   EFI_STATUS Status;
342
343   //Select Device group to belong to P1 device group in Power IC.
344   Data = DEV_GRP_P1;
345   Status = gTPS65950->Write(gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
346   ASSERT_EFI_ERROR(Status);
347
348   //Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
349   Data = VSEL_3_00V;
350   Status = gTPS65950->Write(gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
351   ASSERT_EFI_ERROR(Status);
352   
353   //After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
354   MmioOr32(CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));
355
356   //Software reset of the MMCHS host controller.
357   MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
358   gBS->Stall(1000);
359   while ((MmioRead32(MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);
360
361   //Soft reset for all.
362   MmioWrite32 (MMCHS_SYSCTL, SRA);
363   gBS->Stall(1000);
364   while ((MmioRead32(MMCHS_SYSCTL) & SRA) != 0x0);
365
366   //Voltage capabilities initialization. Activate VS18 and VS30.
367   MmioOr32(MMCHS_CAPA, (VS30 | VS18));
368
369   //Wakeup configuration
370   MmioOr32(MMCHS_SYSCONFIG, ENAWAKEUP);
371   MmioOr32(MMCHS_HCTL, IWE);
372
373   //MMCHS Controller default initialization
374   MmioOr32(MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));
375
376   MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));
377
378   //Enable internal clock
379   MmioOr32(MMCHS_SYSCTL, ICE);
380
381   //Set the clock frequency to 80KHz.
382   UpdateMMCHSClkFrequency(CLKD_80KHZ);
383
384   //Enable SD bus power.
385   MmioOr32(MMCHS_HCTL, (SDBP_ON));
386
387   //Poll till SD bus power bit is set.
388   while ((MmioRead32(MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);
389
390   return Status;
391 }
392
393 STATIC
394 EFI_STATUS
395 PerformCardIdenfication (
396   VOID
397   )
398 {
399   EFI_STATUS Status;
400   UINTN      CmdArgument = 0;
401   UINTN      Response = 0;
402   UINTN      RetryCount = 0;
403   BOOLEAN    SDCmd8Supported = FALSE;
404
405   //Enable interrupts.
406         MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |
407     CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));
408
409   //Controller INIT procedure start.
410   MmioOr32(MMCHS_CON, INIT);
411   MmioWrite32 (MMCHS_CMD, 0x00000000);
412   while (!(MmioRead32(MMCHS_STAT) & CC));
413
414   //Wait for 1 ms
415   gBS->Stall(1000);
416
417   //Set CC bit to 0x1 to clear the flag
418   MmioOr32(MMCHS_STAT, CC);
419
420   //Retry INIT procedure.
421   MmioWrite32 (MMCHS_CMD, 0x00000000);
422   while (!(MmioRead32(MMCHS_STAT) & CC));
423
424   //End initialization sequence
425   MmioAnd32(MMCHS_CON, ~INIT);
426
427   MmioOr32(MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));
428
429   //Change clock frequency to 400KHz to fit protocol
430   UpdateMMCHSClkFrequency(CLKD_400KHZ);
431
432   MmioOr32(MMCHS_CON, OD);
433
434   //Send CMD0 command.
435   Status = SendCmd(CMD0, CMD0_INT_EN, CmdArgument);
436   if (EFI_ERROR(Status)) {
437     DEBUG ((EFI_D_ERROR, "Cmd0 fails.\n"));
438     return Status;
439   }
440
441   DEBUG ((EFI_D_INFO, "CMD0 response: %x\n", MmioRead32(MMCHS_RSP10)));
442
443   //Send CMD5 command. 
444   Status = SendCmd(CMD5, CMD5_INT_EN, CmdArgument);
445   if (Status == EFI_SUCCESS) {
446     DEBUG ((EFI_D_ERROR, "CMD5 Success. SDIO card. Follow SDIO card specification.\n"));
447     DEBUG ((EFI_D_INFO, "CMD5 response: %x\n", MmioRead32(MMCHS_RSP10)));
448     //NOTE: Returning unsupported error for now. Need to implement SDIO specification.
449     return EFI_UNSUPPORTED; 
450   } else {
451     DEBUG ((EFI_D_INFO, "CMD5 fails. Not an SDIO card.\n"));
452   }
453
454   MmioOr32(MMCHS_SYSCTL, SRC);
455   gBS->Stall(1000);
456   while ((MmioRead32(MMCHS_SYSCTL) & SRC));
457
458   //Send CMD8 command. (New v2.00 command for Voltage check)
459   //Only 2.7V - 3.6V is supported for SD2.0, only SD 2.0 card can pass.
460   //MMC & SD1.1 card will fail this command.
461   CmdArgument = CMD8_ARG;
462   Status = SendCmd(CMD8, CMD8_INT_EN, CmdArgument);
463   if (Status == EFI_SUCCESS) {
464     Response = MmioRead32(MMCHS_RSP10);
465     DEBUG ((EFI_D_INFO, "CMD8 success. CMD8 response: %x\n", Response));
466     if (Response != CmdArgument) {
467       return EFI_DEVICE_ERROR;
468     }
469     DEBUG ((EFI_D_INFO, "Card is SD2.0\n"));
470     SDCmd8Supported = TRUE; //Supports high capacity.
471   } else {
472     DEBUG ((EFI_D_INFO, "CMD8 fails. Not an SD2.0 card.\n"));
473   }
474
475   MmioOr32(MMCHS_SYSCTL, SRC);
476   gBS->Stall(1000);
477   while ((MmioRead32(MMCHS_SYSCTL) & SRC));
478
479   //Poll till card is busy
480   while (RetryCount < MAX_RETRY_COUNT) {
481     //Send CMD55 command. 
482     CmdArgument = 0;
483     Status = SendCmd(CMD55, CMD55_INT_EN, CmdArgument);
484     if (Status == EFI_SUCCESS) {
485       DEBUG ((EFI_D_INFO, "CMD55 success. CMD55 response: %x\n", MmioRead32(MMCHS_RSP10)));
486       gCardInfo->CardType = SD_CARD;
487     } else {
488       DEBUG ((EFI_D_INFO, "CMD55 fails.\n"));
489       gCardInfo->CardType = MMC_CARD;
490     }
491
492     //Send appropriate command for the card type which got detected.
493     if (gCardInfo->CardType == SD_CARD) {
494       CmdArgument = ((UINTN *) &(gCardInfo->OCRData))[0];
495
496       //Set HCS bit.
497       if (SDCmd8Supported) {
498         CmdArgument |= HCS;
499       }
500
501       Status = SendCmd(ACMD41, ACMD41_INT_EN, CmdArgument);
502       if (EFI_ERROR(Status)) {
503         DEBUG ((EFI_D_INFO, "ACMD41 fails.\n"));
504         return Status;
505       }
506       ((UINT32 *) &(gCardInfo->OCRData))[0] = MmioRead32(MMCHS_RSP10);
507       DEBUG ((EFI_D_INFO, "SD card detected. ACMD41 OCR: %x\n", ((UINT32 *) &(gCardInfo->OCRData))[0]));
508     } else if (gCardInfo->CardType == MMC_CARD) {
509       CmdArgument = 0;
510       Status = SendCmd(CMD1, CMD1_INT_EN, CmdArgument);
511       if (EFI_ERROR(Status)) {
512         DEBUG ((EFI_D_INFO, "CMD1 fails.\n"));
513         return Status;
514       }
515       Response = MmioRead32(MMCHS_RSP10);
516       DEBUG ((EFI_D_INFO, "MMC card detected.. CMD1 response: %x\n", Response));
517
518       //NOTE: For now, I am skipping this since I only have an SD card.
519       //Compare card OCR and host OCR (Section 22.6.1.3.2.4)
520       return EFI_UNSUPPORTED; //For now, MMC is not supported.
521     }
522
523     //Poll the card until it is out of its power-up sequence.
524     if (gCardInfo->OCRData.Busy == 1) {
525
526       if (SDCmd8Supported) {
527         gCardInfo->CardType = SD_CARD_2;
528       }
529
530       //Card is ready. Check CCS (Card capacity status) bit (bit#30).
531       //SD 2.0 standard card will response with CCS 0, SD high capacity card will respond with CCS 1.
532       if (gCardInfo->OCRData.AccessMode & BIT1) {
533         gCardInfo->CardType = SD_CARD_2_HIGH;
534         DEBUG ((EFI_D_INFO, "High capacity card.\n"));
535       } else {
536         DEBUG ((EFI_D_INFO, "Standard capacity card.\n"));
537       }
538
539       break;
540     }
541
542     gBS->Stall(1000);
543     RetryCount++;
544   }
545
546   if (RetryCount == MAX_RETRY_COUNT) {
547     DEBUG ((EFI_D_ERROR, "Timeout error. RetryCount: %d\n", RetryCount));
548     return EFI_TIMEOUT;
549   }
550
551   //Read CID data.
552   CmdArgument = 0;
553   Status = SendCmd(CMD2, CMD2_INT_EN, CmdArgument);
554   if (EFI_ERROR(Status)) {
555     DEBUG ((EFI_D_ERROR, "CMD2 fails. Status: %x\n", Status));
556     return Status;
557   }
558
559   DEBUG ((EFI_D_INFO, "CMD2 response: %x %x %x %x\n", MmioRead32(MMCHS_RSP10), MmioRead32(MMCHS_RSP32), MmioRead32(MMCHS_RSP54), MmioRead32(MMCHS_RSP76)));
560
561   //Parse CID register data.
562   ParseCardCIDData(MmioRead32(MMCHS_RSP10), MmioRead32(MMCHS_RSP32), MmioRead32(MMCHS_RSP54), MmioRead32(MMCHS_RSP76));
563
564   //Read RCA
565   CmdArgument = 0;
566   Status = SendCmd(CMD3, CMD3_INT_EN, CmdArgument);
567   if (EFI_ERROR(Status)) {
568     DEBUG ((EFI_D_ERROR, "CMD3 fails. Status: %x\n", Status));
569     return Status;
570   }
571
572   //Set RCA for the detected card. RCA is CMD3 response.
573   gCardInfo->RCA = (MmioRead32(MMCHS_RSP10) >> 16);
574   DEBUG ((EFI_D_INFO, "CMD3 response: RCA %x\n", gCardInfo->RCA));
575
576   //MMC Bus setting change after card identification.
577   MmioAnd32(MMCHS_CON, ~OD);
578   MmioOr32(MMCHS_HCTL, SDVS_3_0_V);
579   UpdateMMCHSClkFrequency(CLKD_400KHZ); //Set the clock frequency to 400KHz.
580
581   return EFI_SUCCESS;
582 }
583
584 STATIC
585 EFI_STATUS
586 GetCardSpecificData (
587   VOID
588   )
589 {
590   EFI_STATUS Status;
591   UINTN      CmdArgument;
592
593   //Send CMD9 to retrieve CSD.
594   CmdArgument = gCardInfo->RCA << 16;
595   Status = SendCmd(CMD9, CMD9_INT_EN, CmdArgument);
596   if (EFI_ERROR(Status)) {
597     DEBUG ((EFI_D_ERROR, "CMD9 fails. Status: %x\n", Status));
598     return Status;
599   }
600
601   //Populate 128-bit CSD register data.
602   ((UINT32 *)&(gCardInfo->CSDData))[0] = MmioRead32(MMCHS_RSP10);
603   ((UINT32 *)&(gCardInfo->CSDData))[1] = MmioRead32(MMCHS_RSP32);
604   ((UINT32 *)&(gCardInfo->CSDData))[2] = MmioRead32(MMCHS_RSP54);
605   ((UINT32 *)&(gCardInfo->CSDData))[3] = MmioRead32(MMCHS_RSP76);
606
607   DEBUG ((EFI_D_INFO, "CMD9 response: %x %x %x %x\n", MmioRead32(MMCHS_RSP10), MmioRead32(MMCHS_RSP32), MmioRead32(MMCHS_RSP54), MmioRead32(MMCHS_RSP76)));
608
609   //Calculate total number of blocks and max. data transfer rate supported by the detected card.
610   GetCardConfigurationData();
611
612   //Change MMCHS clock frequency to what detected card can support.
613   UpdateMMCHSClkFrequency(gCardInfo->ClockFrequencySelect);
614
615   return Status;
616 }
617
618 STATIC
619 EFI_STATUS
620 PerformCardConfiguration (
621   VOID
622   )
623 {
624   UINTN      CmdArgument = 0;
625   EFI_STATUS Status;
626
627   //Send CMD7
628   CmdArgument = gCardInfo->RCA << 16;
629   Status = SendCmd(CMD7, CMD7_INT_EN, CmdArgument);
630   if (EFI_ERROR(Status)) {
631     DEBUG ((EFI_D_ERROR, "CMD7 fails. Status: %x\n", Status));
632     return Status;
633   }
634
635   //Send CMD16 to set the block length
636   CmdArgument = gCardInfo->BlockSize;
637   Status = SendCmd(CMD16, CMD16_INT_EN, CmdArgument);
638   if (EFI_ERROR(Status)) {
639     DEBUG ((EFI_D_ERROR, "CMD16 fails. Status: %x\n", Status));
640     return Status;
641   }
642
643   return EFI_SUCCESS;
644 }
645
646 STATIC
647 EFI_STATUS
648 ReadBlockData(
649   IN  EFI_BLOCK_IO_PROTOCOL       *This,
650   OUT VOID                        *Buffer
651   )
652 {
653   UINTN MmcStatus;
654   UINTN *DataBuffer = Buffer;
655   UINTN DataSize = This->Media->BlockSize/4;
656   UINTN Count;
657   UINTN RetryCount = 0;
658
659   //Check controller status to make sure there is no error.
660   while (RetryCount < MAX_RETRY_COUNT) {
661     do {
662       //Read Status.
663       MmcStatus = MmioRead32(MMCHS_STAT);
664     } while(MmcStatus == 0);
665
666     //Check if Buffer read ready (BRR) bit is set?
667     if (MmcStatus & BRR) {
668
669       //Clear BRR bit
670       MmioOr32(MMCHS_STAT, BRR);
671
672       //Read block worth of data.
673       for (Count = 0; Count < DataSize; Count++) {
674         *DataBuffer++ = MmioRead32(MMCHS_DATA);
675       }
676       break;
677     }
678     RetryCount++;
679   }
680
681   if (RetryCount == MAX_RETRY_COUNT) {
682     return EFI_TIMEOUT;
683   }
684
685   return EFI_SUCCESS;
686 }
687
688 STATIC
689 EFI_STATUS
690 WriteBlockData(
691   IN  EFI_BLOCK_IO_PROTOCOL       *This,
692   OUT VOID                        *Buffer
693   )
694 {
695   UINTN MmcStatus;
696   UINTN *DataBuffer = Buffer;
697   UINTN DataSize = This->Media->BlockSize/4;
698   UINTN Count;
699   UINTN RetryCount = 0;
700
701   //Check controller status to make sure there is no error.
702   while (RetryCount < MAX_RETRY_COUNT) {
703     do {
704       //Read Status.
705       MmcStatus = MmioRead32(MMCHS_STAT);
706     } while(MmcStatus == 0);
707
708     //Check if Buffer write ready (BWR) bit is set?
709     if (MmcStatus & BWR) {
710
711       //Clear BWR bit
712       MmioOr32(MMCHS_STAT, BWR);
713
714       //Write block worth of data.
715       for (Count = 0; Count < DataSize; Count++) {
716         MmioWrite32 (MMCHS_DATA, *DataBuffer++);
717       }
718
719       break;
720     }
721     RetryCount++;
722   }
723
724   if (RetryCount == MAX_RETRY_COUNT) {
725     return EFI_TIMEOUT;
726   }
727
728   return EFI_SUCCESS;
729 }
730
731 STATIC
732 EFI_STATUS
733 TransferBlockData(
734   IN  EFI_BLOCK_IO_PROTOCOL       *This,
735   OUT VOID                        *Buffer,
736   IN  OPERATION_TYPE              OperationType
737   )
738 {
739   EFI_STATUS Status;
740   UINTN      MmcStatus;
741   UINTN      RetryCount = 0;
742
743   //Read or Write data.
744   if (OperationType == READ) {
745     Status = ReadBlockData(This, Buffer);
746     if (EFI_ERROR(Status)) {
747       DEBUG((EFI_D_ERROR, "ReadBlockData fails.\n"));
748       return Status;
749     }
750   } else if (OperationType == WRITE) {
751     Status = WriteBlockData(This, Buffer);
752     if (EFI_ERROR(Status)) {
753       DEBUG((EFI_D_ERROR, "WriteBlockData fails.\n"));
754       return Status;
755     }
756   }
757
758   //Check for the Transfer completion.
759   while (RetryCount < MAX_RETRY_COUNT) {
760     //Read Status
761     do {
762       MmcStatus = MmioRead32(MMCHS_STAT);
763     } while (MmcStatus == 0);
764
765     //Check if Transfer complete (TC) bit is set?
766     if (MmcStatus & TC) {
767       break;
768     } else {
769       DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));
770       //Check if DEB, DCRC or DTO interrupt occured.
771       if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {
772         //There was an error during the data transfer.
773
774         //Set SRD bit to 1 and wait until it return to 0x0.
775         MmioOr32(MMCHS_SYSCTL, SRD);
776         while((MmioRead32(MMCHS_SYSCTL) & SRD) != 0x0);
777
778         return EFI_DEVICE_ERROR;
779       }
780     }
781     RetryCount++;
782   } 
783
784   if (RetryCount == MAX_RETRY_COUNT) {
785     DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));
786     return EFI_TIMEOUT;
787   }
788
789   return EFI_SUCCESS;
790 }
791
792 STATIC
793 EFI_STATUS
794 SdReadWrite (
795   IN EFI_BLOCK_IO_PROTOCOL    *This,
796   IN  UINTN                   Lba, 
797   OUT VOID                    *Buffer, 
798   IN  UINTN                   BufferSize,
799   IN  OPERATION_TYPE          OperationType
800   )
801 {
802   EFI_STATUS Status;
803   UINTN      RetryCount = 0;
804   UINTN      NumBlocks;
805   UINTN      Cmd = 0;
806   UINTN      CmdInterruptEnable = 0;
807   UINTN      CmdArgument = 0;
808
809   //Check if the data lines are not in use.
810   while ((RetryCount++ < MAX_RETRY_COUNT) && ((MmioRead32(MMCHS_PSTATE) & DATI_MASK) != DATI_ALLOWED));
811   if (RetryCount == MAX_RETRY_COUNT) {
812     return EFI_TIMEOUT;
813   }
814
815   //Populate the command information based on the operation type.
816   if (OperationType == READ) {
817     Cmd = CMD17; //Single block read
818     CmdInterruptEnable = CMD17_INT_EN;
819   } else if (OperationType == WRITE) {
820     Cmd = CMD24; //Single block write
821     CmdInterruptEnable = CMD24_INT_EN;
822   }
823
824   //Calculate total number of blocks its going to read.
825   NumBlocks = (BufferSize + (This->Media->BlockSize - 1))/This->Media->BlockSize;
826
827   //Set command argument based on the card access mode (Byte mode or Block mode)
828   if (gCardInfo->OCRData.AccessMode & BIT1) {
829     CmdArgument = (UINTN)Lba;
830   } else {
831     CmdArgument = (UINTN)Lba * This->Media->BlockSize;
832   }
833
834   while(NumBlocks) {
835     //Send Command.
836     Status = SendCmd(Cmd, CmdInterruptEnable, CmdArgument);
837     if (EFI_ERROR(Status)) {
838       DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));
839       return Status;
840     }
841
842     //Transfer a block worth of data.
843     Status = TransferBlockData(This, Buffer, OperationType);
844     if (EFI_ERROR(Status)) {
845       DEBUG ((EFI_D_ERROR, "TransferBlockData fails. %x\n", Status));
846       return Status;
847     }
848
849     //Adjust command argument.
850     if (gCardInfo->OCRData.AccessMode & BIT1) {
851       CmdArgument++; //Increase BlockIndex by one.
852     } else {
853       CmdArgument += This->Media->BlockSize; //Increase BlockIndex by BlockSize
854     }
855
856     //Adjust Buffer.
857     Buffer = (UINT8 *)Buffer + This->Media->BlockSize;
858     NumBlocks--;
859   }
860
861   return EFI_SUCCESS;
862 }
863
864 EFI_STATUS
865 EFIAPI
866 MMCHSReset (
867   IN EFI_BLOCK_IO_PROTOCOL          *This,
868   IN BOOLEAN                        ExtendedVerification
869   )
870 {
871   return EFI_SUCCESS;
872 }
873
874 EFI_STATUS
875 EFIAPI
876 MMCHSReadBlocks (
877   IN EFI_BLOCK_IO_PROTOCOL          *This,
878   IN UINT32                         MediaId,
879   IN EFI_LBA                        Lba,
880   IN UINTN                          BufferSize,
881   OUT VOID                          *Buffer
882   )
883 {
884   EFI_STATUS Status;
885
886   if (Buffer == NULL)
887   {
888     return EFI_INVALID_PARAMETER;
889   }
890   
891   if (Lba > This->Media->LastBlock)
892   {
893     return EFI_INVALID_PARAMETER;
894   }
895   
896   if ((BufferSize % This->Media->BlockSize) != 0)
897   {
898     return EFI_BAD_BUFFER_SIZE;
899   }
900
901   //Perform Read operation.
902   Status = SdReadWrite(This, (UINTN)Lba, Buffer, BufferSize, READ);
903   if (EFI_ERROR(Status)) {
904     DEBUG ((EFI_D_ERROR, "Read operation fails.\n"));
905   }
906
907   return Status;
908 }
909
910 EFI_STATUS
911 EFIAPI
912 MMCHSWriteBlocks (
913   IN EFI_BLOCK_IO_PROTOCOL          *This,
914   IN UINT32                         MediaId,
915   IN EFI_LBA                        Lba,
916   IN UINTN                          BufferSize,
917   IN VOID                           *Buffer
918   )
919 {
920   EFI_STATUS Status;
921
922   if (Buffer == NULL) {
923     return EFI_INVALID_PARAMETER;
924   }
925   
926   if (Lba > This->Media->LastBlock) {
927     return EFI_INVALID_PARAMETER;
928   }
929   
930   if ((BufferSize % This->Media->BlockSize) != 0) {
931     return EFI_BAD_BUFFER_SIZE;
932   }
933
934   if (This->Media->ReadOnly) {
935     return EFI_WRITE_PROTECTED;
936   }
937
938   //Perform write operation.
939   Status = SdReadWrite(This, (UINTN)Lba, Buffer, BufferSize, WRITE);
940   if (EFI_ERROR(Status)) {
941     DEBUG ((EFI_D_ERROR, "Write operation fails.\n"));
942   }
943
944   return Status;
945 }
946
947 EFI_STATUS
948 EFIAPI
949 MMCHSFlushBlocks (
950   IN EFI_BLOCK_IO_PROTOCOL  *This
951   )
952 {
953   return EFI_SUCCESS;
954 }
955
956 EFI_BLOCK_IO_PROTOCOL BlockIo = 
957 {
958   EFI_BLOCK_IO_INTERFACE_REVISION,   // Revision
959   &MMCHSMedia,                       // *Media
960   MMCHSReset,                        // Reset
961   MMCHSReadBlocks,                   // ReadBlocks
962   MMCHSWriteBlocks,                  // WriteBlocks
963   MMCHSFlushBlocks                   // FlushBlocks
964 };
965
966 EFI_STATUS
967 MMCHSInitialize (
968   IN EFI_HANDLE         ImageHandle,
969   IN EFI_SYSTEM_TABLE   *SystemTable
970   )
971 {
972   EFI_STATUS  Status;
973
974   Status = gBS->LocateProtocol(&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
975   ASSERT_EFI_ERROR(Status);
976
977   gCardInfo = (CARD_INFO *)AllocateZeroPool(sizeof(CARD_INFO));
978   if (gCardInfo == NULL) {
979     return EFI_OUT_OF_RESOURCES;
980   }
981         
982   //Initialize MMC host controller.
983   Status = InitializeMMCHS();
984   if (EFI_ERROR(Status)) {
985     DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));
986     return Status;
987   }
988   
989   //Card idenfication
990   Status = PerformCardIdenfication();
991   if (EFI_ERROR(Status)) {
992     DEBUG ((EFI_D_ERROR, "No MMC/SD card detected.\n"));
993     return EFI_SUCCESS; //NOTE: Check if this is correct..
994   }
995   
996   //Get CSD (Card specific data) for the detected card.
997   Status = GetCardSpecificData();
998   if (EFI_ERROR(Status)) {
999     return Status;
1000   }
1001   
1002   //Configure the card in data transfer mode.
1003   Status = PerformCardConfiguration();
1004   if (EFI_ERROR(Status)) {
1005     return Status;
1006   }
1007
1008   //Patch the Media structure.
1009   MMCHSMedia.LastBlock = (gCardInfo->NumBlocks - 1);
1010   MMCHSMedia.BlockSize = gCardInfo->BlockSize;
1011
1012   //Publish BlockIO.
1013   Status = gBS->InstallMultipleProtocolInterfaces(&ImageHandle, 
1014                                                   &gEfiBlockIoProtocolGuid, &BlockIo, 
1015                                                   &gEfiDevicePathProtocolGuid, &gMmcHsDevicePath,
1016                                                   NULL);
1017   return Status;
1018 }