path: root/ArmPkg/Drivers/PL180MciDxe/PL180Mci.c

/** @file
  This file implement the MMC Host Protocol for the ARM PrimeCell PL180.

  Copyright (c) 2011, ARM Limited. All rights reserved.
  
  This program and the accompanying materials                          
  are licensed and made available under the terms and conditions of the BSD License         
  which accompanies this distribution.  The full text of the license may be found at        
  http://opensource.org/licenses/bsd-license.php                                            

  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

**/

#include "PL180Mci.h"

#include <Library/DevicePathLib.h>
#include <Library/BaseMemoryLib.h>

EFI_MMC_HOST_PROTOCOL     *gpMmcHost;

// Untested ...
//#define USE_STREAM

#define MMCI0_BLOCKLEN 512
#define MMCI0_POW2_BLOCKLEN     9
#define MMCI0_TIMEOUT           1000

BOOLEAN MciIsPowerOn() {
    return ((MmioRead32(MCI_POWER_CONTROL_REG) & 0x3) == MCI_POWER_ON);
}

EFI_STATUS MciInitialize() {
    MCI_TRACE("MciInitialize()");
    return EFI_SUCCESS;
}

BOOLEAN MciIsCardPresent() {
    return (MmioRead32(FixedPcdGet32(PcdPL180SysMciRegAddress)) & 1);
}

BOOLEAN MciIsReadOnly() {
    return (MmioRead32(FixedPcdGet32(PcdPL180SysMciRegAddress)) & 2);
}

// Convert block size to 2^n
UINT32 GetPow2BlockLen(UINT32 BlockLen) {
    UINTN Loop;
    UINTN Pow2BlockLen;
    
    Loop    = 0x8000;
    Pow2BlockLen = 15;
    do {
        Loop = (Loop >> 1) & 0xFFFF;
        Pow2BlockLen--;
    } while (Pow2BlockLen && (!(Loop & BlockLen)));

    return Pow2BlockLen;
}

VOID MciPrepareDataPath(UINTN TransferDirection) {
    // Set Data Length & Data Timer
    MmioWrite32(MCI_DATA_TIMER_REG,0xFFFFFFF);
    MmioWrite32(MCI_DATA_LENGTH_REG,MMCI0_BLOCKLEN);

#ifndef USE_STREAM
    //Note: we are using a hardcoded BlockLen (=512). If we decide to use a variable size, we could
    // compute the pow2 of BlockLen with the above function GetPow2BlockLen()
    MmioWrite32(MCI_DATA_CTL_REG, MCI_DATACTL_ENABLE | TransferDirection | (MMCI0_POW2_BLOCKLEN << 4));
#else
    MmioWrite32(MCI_DATA_CTL_REG, MCI_DATACTL_ENABLE | TransferDirection | MCI_DATACTL_STREAM_TRANS);
#endif
}

EFI_STATUS MciSendCommand(MMC_CMD MmcCmd, UINT32 Argument) {
    UINT32 Status;
    UINT32  Timer;
    UINT32 Cmd;

    if ((MmcCmd == MMC_CMD17) || (MmcCmd == MMC_CMD11)) {
        MciPrepareDataPath(MCI_DATACTL_CARD_TO_CONT);
    } else if ((MmcCmd == MMC_CMD24) || (MmcCmd == MMC_CMD20)) {
        MciPrepareDataPath(MCI_DATACTL_CONT_TO_CARD);
    }

    // Create Command for PL180
    Cmd = INDX(MmcCmd);
    if (MmcCmd & MMC_CMD_WAIT_RESPONSE)
        Cmd |= MCI_CPSM_WAIT_RESPONSE;
    if (MmcCmd & MMC_CMD_LONG_RESPONSE)
        Cmd |= MCI_CPSM_LONG_RESPONSE;

    MmioWrite32(MCI_CLEAR_STATUS_REG,0x5FFF);
    MmioWrite32(MCI_ARGUMENT_REG,Argument);
    MmioWrite32(MCI_COMMAND_REG,Cmd);

    Timer = 1000;
    if (Cmd & MCI_CPSM_WAIT_RESPONSE) {
        Status = MmioRead32(MCI_STATUS_REG);
        while (!(Status & (MCI_STATUS_CMD_RESPEND | MCI_STATUS_CMD_CMDCRCFAIL | MCI_STATUS_CMD_CMDTIMEOUT)) && Timer) {
            //NanoSecondDelay(10);
            Status = MmioRead32(MCI_STATUS_REG);
            Timer--;
        }

        if ((Timer == 0) || (Status == MCI_STATUS_CMD_CMDTIMEOUT)) {
            //DEBUG ((EFI_D_ERROR, "MciSendCommand(CmdIndex:%d) TIMEOUT! Response:0x%X Status:0x%X\n",Cmd & 0x3F,MmioRead32(MCI_RESPONSE0_REG),Status));
            return EFI_TIMEOUT;
        } else if (!((Cmd & 0x3F) == INDX(1)) && (Status & MCI_STATUS_CMD_CMDCRCFAIL)) {
            // The CMD1 does not contain CRC. We should ignore the CRC failed Status.
            return EFI_CRC_ERROR;
        } else {
            return EFI_SUCCESS;
        }
    } else {
        Status = MmioRead32(MCI_STATUS_REG);
        while (!(Status & MCI_STATUS_CMD_SENT) && Timer) {
            //NanoSecondDelay(10);
            Status = MmioRead32(MCI_STATUS_REG);
            Timer--;
        }

        if (Timer == 0) {
            //DEBUG ((EFI_D_ERROR, "MciSendCommand(CmdIndex:%d) TIMEOUT2! 0x%X\n",Cmd & 0x3F,MmioRead32(MCI_RESPONSE0_REG)));
            return EFI_TIMEOUT;
        } else {
            return EFI_SUCCESS;
        }
    }
}

EFI_STATUS MciReceiveResponse(MMC_RESPONSE_TYPE Type, UINT32* Buffer) {
    if (Buffer == NULL) {
        return EFI_INVALID_PARAMETER;
    }

    if ((Type == MMC_RESPONSE_TYPE_R1) || (Type == MMC_RESPONSE_TYPE_R1b) ||
        (Type == MMC_RESPONSE_TYPE_R3) || (Type == MMC_RESPONSE_TYPE_R6) ||
        (Type == MMC_RESPONSE_TYPE_R7)) {
        Buffer[0] = MmioRead32(MCI_RESPONSE0_REG);
        Buffer[1] = MmioRead32(MCI_RESPONSE1_REG);
    } else if (Type == MMC_RESPONSE_TYPE_R2) {
        Buffer[0] = MmioRead32(MCI_RESPONSE0_REG);
        Buffer[1] = MmioRead32(MCI_RESPONSE1_REG);
        Buffer[2] = MmioRead32(MCI_RESPONSE2_REG);
        Buffer[3] = MmioRead32(MCI_RESPONSE3_REG);
    }

    return EFI_SUCCESS;
}

EFI_STATUS MciReadBlockData(EFI_LBA Lba, UINTN Length, UINT32* Buffer) {
    UINTN Loop;
    UINTN Finish;
    UINTN Timer;
    UINTN Status;

    // Read data from the RX FIFO
    Loop   = 0;
    Finish = MMCI0_BLOCKLEN / 4;
    Timer  = MMCI0_TIMEOUT * 10;
    do {
        // Read the Status flags
        Status = MmioRead32(MCI_STATUS_REG);
        // Do eight reads if possible else a single read
        if (Status & MCI_STATUS_CMD_RXFIFOHALFFULL) {
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
        }
        else if (!(Status & MCI_STATUS_CMD_RXFIFOEMPTY)) {
            Buffer[Loop] = MmioRead32(MCI_FIFO_REG);
            Loop++;
        } else
            Timer--;
    } while ((Loop < Finish) && Timer);

    if (Timer == 0) {
        DEBUG ((EFI_D_ERROR, "MciReadBlockData: Timeout Status:0x%X Loop:%d // Finish:%d\n",MmioRead32(MCI_STATUS_REG),Loop,Finish));
        return EFI_TIMEOUT;
    } else
        return EFI_SUCCESS;
}

EFI_STATUS MciWriteBlockData(EFI_LBA Lba, UINTN Length, UINT32* Buffer) {
    UINTN Loop;
    UINTN Finish;
    UINTN Timer;
    UINTN Status;

    // Write the data to the TX FIFO
    Loop   = 0;
    Finish = MMCI0_BLOCKLEN / 4;
    Timer  = MMCI0_TIMEOUT * 100;
    do {
        // Read the Status flags
        Status = MmioRead32(MCI_STATUS_REG);

        // Do eight writes if possible else a single write
        if (Status & MCI_STATUS_CMD_TXFIFOHALFEMPTY) {
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
        }
        else if (!(Status & MCI_STATUS_CMD_TXFIFOFULL)) {
            MmioWrite32(MCI_FIFO_REG, Buffer[Loop]);
            Loop++;
        }
        else
            Timer--;
    } while ((Loop < Finish) && Timer);

    ASSERT(Timer > 0);

    // Wait for FIFO to drain
    Timer = MMCI0_TIMEOUT;
    Status = MmioRead32(MCI_STATUS_REG);
/*#ifndef USE_STREAM
    // Single block
    while (((Status & MCI_STATUS_CMD_TXDONE) != MCI_STATUS_CMD_TXDONE) && Timer) {
#else*/
    // Stream
    while (((Status & MCI_STATUS_CMD_DATAEND) != MCI_STATUS_CMD_DATAEND) && Timer) {
//#endif
        NanoSecondDelay(10);
        Status = MmioRead32(MCI_STATUS_REG);
        Timer--;
    }

    ASSERT(Timer > 0);

    if (Timer == 0)
        return EFI_TIMEOUT;
    else
        return EFI_SUCCESS;
}

EFI_STATUS MciNotifyState(MMC_STATE State) {
    UINT32      Data32;

    switch(State) {
    case MmcInvalidState:
        ASSERT(0);
        break;
    case MmcHwInitializationState:
        // If device already turn on then restart it
        Data32 = MmioRead32(MCI_POWER_CONTROL_REG);
        if ((Data32 & 0x2) == MCI_POWER_UP) {
            MCI_TRACE("MciNotifyState(MmcHwInitializationState): TurnOff MCI");

            // Turn off
            MmioWrite32(MCI_CLOCK_CONTROL_REG, 0);
            MmioWrite32(MCI_POWER_CONTROL_REG, 0);
            MicroSecondDelay(100);
        }
        
        MCI_TRACE("MciNotifyState(MmcHwInitializationState): TurnOn MCI");
        // Setup clock
        //  - 0x1D = 29 => should be the clock divider to be less than 400kHz at MCLK = 24Mhz
        MmioWrite32(MCI_CLOCK_CONTROL_REG,0x1D | MCI_CLOCK_ENABLE | MCI_CLOCK_POWERSAVE);
        //MmioWrite32(MCI_CLOCK_CONTROL_REG,0x1D | MCI_CLOCK_ENABLE);

        // Set the voltage
        MmioWrite32(MCI_POWER_CONTROL_REG,MCI_POWER_OPENDRAIN | (15<<2));
        MmioWrite32(MCI_POWER_CONTROL_REG,MCI_POWER_ROD | MCI_POWER_OPENDRAIN | (15<<2) | MCI_POWER_UP);
        MicroSecondDelay(10);
        MmioWrite32(MCI_POWER_CONTROL_REG,MCI_POWER_ROD | MCI_POWER_OPENDRAIN | (15<<2) | MCI_POWER_ON);
        MicroSecondDelay(100);

        // Set Data Length & Data Timer
        MmioWrite32(MCI_DATA_TIMER_REG,0xFFFFF);
        MmioWrite32(MCI_DATA_LENGTH_REG,8);

        ASSERT((MmioRead32(MCI_POWER_CONTROL_REG) & 0x3) == MCI_POWER_ON);
        break;
    case MmcIdleState:
        MCI_TRACE("MciNotifyState(MmcIdleState)");
        break;
    case MmcReadyState:
        MCI_TRACE("MciNotifyState(MmcReadyState)");
        break;
    case MmcIdentificationState:
        MCI_TRACE("MciNotifyState(MmcIdentificationState)");
        break;
    case MmcStandByState:
        MCI_TRACE("MciNotifyState(MmcStandByState)");
 
        // Enable MCICMD push-pull drive
        MmioWrite32(MCI_POWER_CONTROL_REG,MCI_POWER_ROD | (15<<2) | MCI_POWER_ON);

        /*// Set MMCI0 clock to 4MHz (24MHz may be possible with cache enabled)
        MmioWrite32(MCI_CLOCK_CONTROL_REG,0x02 | MCI_CLOCK_ENABLE | MCI_CLOCK_POWERSAVE);*/
        // Set MMCI0 clock to 24MHz (by bypassing the divider)
        MmioWrite32(MCI_CLOCK_CONTROL_REG,MCI_CLOCK_BYPASS | MCI_CLOCK_ENABLE);
        break;
    case MmcTransferState:
        //MCI_TRACE("MciNotifyState(MmcTransferState)");
        break;
    case MmcSendingDataState:
        MCI_TRACE("MciNotifyState(MmcSendingDataState)");
        break;
    case MmcReceiveDataState:
        MCI_TRACE("MciNotifyState(MmcReceiveDataState)");
        break;
    case MmcProgrammingState:
        MCI_TRACE("MciNotifyState(MmcProgrammingState)");
        break;
    case MmcDisconnectState:
        MCI_TRACE("MciNotifyState(MmcDisconnectState)");
        break;
    default:
        ASSERT(0);
    }
    return EFI_SUCCESS;
}

EFI_GUID mPL180MciDevicePathGuid = { 0x621b6fa5, 0x4dc1, 0x476f, 0xb9, 0xd8, 0x52, 0xc5, 0x57, 0xd8, 0x10, 0x70 };

EFI_STATUS MciBuildDevicePath(EFI_DEVICE_PATH_PROTOCOL **DevicePath) {
    EFI_DEVICE_PATH_PROTOCOL    *NewDevicePathNode;

    NewDevicePathNode = CreateDeviceNode(HARDWARE_DEVICE_PATH,HW_VENDOR_DP,sizeof(VENDOR_DEVICE_PATH));
    CopyGuid(&((VENDOR_DEVICE_PATH*)NewDevicePathNode)->Guid,&mPL180MciDevicePathGuid);
    
    *DevicePath = NewDevicePathNode;
    return EFI_SUCCESS;
}

EFI_MMC_HOST_PROTOCOL gMciHost = {
    MciIsCardPresent,
    MciIsReadOnly,
    MciBuildDevicePath,
    MciNotifyState,
    MciSendCommand,
    MciReceiveResponse,
    MciReadBlockData,
    MciWriteBlockData
};

EFI_STATUS
PL180MciDxeInitialize (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
  EFI_STATUS    Status;
  EFI_HANDLE    Handle = NULL;

  MCI_TRACE("PL180MciDxeInitialize()");

  //Publish Component Name, BlockIO protocol interfaces
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Handle, 
                  &gEfiMmcHostProtocolGuid,         &gMciHost,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);

  return EFI_SUCCESS;
}