URL https://opencores.org/ocsvn/sdhc-sc-core/sdhc-sc-core/trunk

Subversion Repositories sdhc-sc-core

[/] [sdhc-sc-core/] [trunk/] [grpSd/] [unitSdController/] [src/] [SdController-Rtl-a.vhdl] - Blame information for rev 185

Details | Compare with Previous | View Log


-- SDHC-SC-Core
-- Secure Digital High Capacity Self Configuring Core
-- 
-- (C) Copyright 2010, Rainer Kastl
-- All rights reserved.
-- 
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--     * Redistributions of source code must retain the above copyright
--       notice, this list of conditions and the following disclaimer.
--     * Redistributions in binary form must reproduce the above copyright
--       notice, this list of conditions and the following disclaimer in the
--       documentation and/or other materials provided with the distribution.
--     * Neither the name of the <organization> nor the
--       names of its contributors may be used to endorse or promote products
--       derived from this software without specific prior written permission.
-- 
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS  "AS IS" AND
-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-- DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-- 
-- File        : SdController-Rtl-a.vhdl
-- Owner       : Rainer Kastl
-- Description : Main FSM controlling Cmd and Data FSMs, communicates with Wb
-- Links       : 
-- 
 
architecture Rtl of SdController is
 
        type aSdControllerState is (startup, init, config, requestnewoperation, idle, invalidCard, read, write);
        type aCmdRegion is (CMD0, CMD8, ACMD41, CMD2, CMD3, SelectCard, CheckBusWidth, SetBusWidth, CheckSpeed, ChangeSpeed, GetStatus);
        type aRegion is (idle, send, response, waitstate, senddata, receivedata, checkbusy, waitstatedata);
 
        subtype aCounter is natural range 0 to (512/32)-1;
 
        constant cDefaultToSdCmd : aSdCmdFromController := (
        (id       => (others        => '0'),
        arg       => (others        => '0')),
        Valid     => cInactivated,
        ExpectCID => cInactivated,
        CheckCrc  => cActivated);
 
        type aSdControllerReg is record
                State          : aSdControllerState;
                CmdRegion      : aCmdRegion;
                Region         : aRegion;
                Counter        : aCounter;
                SendCMD55      : std_ulogic;
                SentCMD55      : std_ulogic;
                HCS            : std_ulogic;
                CCS            : std_ulogic;
                RCA            : aSdRCA;
                CardStatus     : aSdCardStatus;
                ToSdCmd        : aSdCmdFromController;
                ToSdData       : aSdDataFromController;
                ToDataRam      : aSdControllerToRam;
                ToSdWbSlave    : aSdControllerToSdWbSlave;
                HighSpeed      : std_ulogic;
                OperationBlock : aOperationBlock;
                LedBank            : std_ulogic_vector(7 downto 0);
        end record aSdControllerReg;
 
        constant cDefaultSdControllerReg : aSdControllerReg := (
        State          => startup,
        CmdRegion      => CMD0,
        Region         => idle,
        Counter        => 0,
        SendCMD55      => cInactivated,
        SentCMD55      => cInactivated,
        HCS            => cActivated,
        CCS            => cInactivated,
        RCA            => cDefaultRCA,
        CardStatus     => cDefaultSdCardStatus,
        ToSdCmd        => cDefaultToSdCmd,
        ToSdData       => cDefaultSdDataFromController,
        ToDataRam      => cDefaultSdControllerToRam,
        ToSdWbSlave    => cDefaultSdControllerToSdWbSlave,
        HighSpeed      => cInactivated,
        OperationBlock => cDefaultOperationBlock,
        LedBank        => (others => '0'));
 
        signal R, NextR       : aSdControllerReg;
 
        constant cReadTimeoutNat    : natural := gClkFrequency / (1 sec / gReadTimeout) - 1;
        constant cWriteTimeoutNat   : natural := gClkFrequency / (1 sec / gWriteTimeout) - 1;
        constant cNcrTimeoutNatLow  : natural := gClkFrequency / (1 sec / (1 sec / 25E6 * 8)) - 1;
        constant cNcrTimeoutNatHigh : natural := gClkFrequency / (1 sec / (1 sec / 50E6 * 8)) - 1;
        constant cStartupTimeoutNat : natural := gClkFrequency / (1 sec / gStartupTimeout) - 1;
 
        constant cMaxTimeoutBitWidth : natural := LogDualis(cWriteTimeoutNat);
        subtype aTimeoutValue is unsigned(cMaxTimeoutBitWidth - 1 downto 0);
 
        constant cNcrTimeoutLow  : aTimeoutValue := to_unsigned(cNcrTimeoutNatLow, aTimeoutValue'length);
        constant cNcrTimeoutHigh : aTimeoutValue := to_unsigned(cNcrTimeoutNatHigh, aTimeoutValue'length);
        constant cStartupTimeout : aTimeoutValue := to_unsigned(cStartupTimeoutNat, aTimeoutValue'length);
        constant cReadTimeout    : aTimeoutValue := to_unsigned(cReadTimeoutNat, aTimeoutValue'length);
        constant cWriteTimeout   : aTimeoutValue := to_unsigned(cWriteTimeoutNat, aTimeoutValue'length);
 
        signal TimeoutEnable  : std_ulogic;
        signal TimeoutDisable : std_ulogic;
        signal Timeout        : std_ulogic;
        signal TimeoutMax     : unsigned(cMaxTimeoutBitWidth - 1 downto 0);
 
begin
 
        oSdCmd     <= R.ToSdCmd;
        oSdData    <= R.ToSdData;
        oSdWbSlave <= R.ToSdWbSlave;
        oHighSpeed <= R.HighSpeed;
        oLedBank   <= R.LedBank;
 
        Regs : process (iClk, iRstSync)
        begin
                if (iClk'event and iClk = cActivated) then
                        if (iRstSync = cActivated) then
                                R <= cDefaultSdControllerReg;
                        else
                                R <= NextR;
                        end if;
                end if;
        end process Regs;
 
        Comb : process (iSdCmd, iSdData, iSdWbSlave, Timeout, R)
                variable ocr           : aSdRegOCR;
                variable arg           : aSdCmdArg;
                variable NextRegion    : aRegion;
                variable NextCmdRegion : aCmdRegion;
                variable NextState     : aSdControllerState;
 
                procedure EnableNcrTimeout is
                begin
                        TimeoutEnable <= cActivated;
 
                        if (R.HighSpeed = cInactivated) then
                                TimeoutMax <= cNcrTimeoutLow;
                        else
                                TimeoutMax <= cNcrTimeoutHigh;
                        end if;
                end procedure EnableNcrTimeout;
 
        begin
                -- default assignments
                NextR          <= R;
                NextR.ToSdCmd  <= cDefaultToSdCmd;
                TimeoutEnable  <= cInactivated;
                TimeoutDisable <= cInactivated;
                TimeoutMax     <= to_unsigned(0, TimeoutMax'length);
                NextRegion     := R.Region;
                NextCmdRegion  := R.CmdRegion;
                NextState      := R.State;
 
                case R.State is
                        when startup =>
                                TimeoutEnable <= cActivated;
                                TimeoutMax    <= cStartupTimeout;
 
                                if (Timeout = cActivated) then
                                        TimeoutDisable  <= cActivated;
                                        NextR.State     <= init;
                                        NextR.CmdRegion <= CMD0;
                                        NextR.Region    <= send;
                                end if;
 
                        when init =>
                                case R.CmdRegion is
                                        when CMD0 =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdGoIdleState;
                                                                NextR.CardStatus         <= cDefaultSdCardStatus;
                                                                NextRegion               := waitstate;
 
                                                        when waitstate =>
                                                                NextRegion    := send;
                                                                NextCmdRegion := CMD8;
 
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when CMD8 =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id  <= cSdCmdSendIfCond;
                                                                NextR.ToSdCmd.Content.arg <= cSdArgVoltage;
                                                                NextRegion                := response;
 
                                                        when response =>
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSendIfCond and iSdCmd.Content.arg = cSdArgVoltage) then
                                                                                NextR.Region <= waitstate;
                                                                                NextR.HCS    <= cActivated;
 
                                                                        else
                                                                                NextR.State <= invalidCard;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.HCS       <= cInactivated;
                                                                        NextR.CmdRegion <= ACMD41;
                                                                        NextR.Region    <= send;
                                                                        NextR.SendCMD55 <= cActivated;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextCmdRegion   := ACMD41;
                                                                NextRegion      := send;
                                                                NextR.SendCMD55 <= cActivated;
 
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when ACMD41 =>
                                                if (R.SendCMD55 = cInactivated) then
                                                        case R.Region is
                                                                when send =>
                                                                        ocr.nBusy                 := '0';
                                                                        ocr.ccs                   := R.HCS;
                                                                        ocr.voltagewindow         := cVoltageWindow;
                                                                        NextR.ToSdCmd.Content.id  <= cSdCmdACMD41;
                                                                        NextR.ToSdCmd.Content.arg <= OCRToArg(ocr);
                                                                        NextRegion                := response;
 
                                                                when response =>
                                                                        NextR.ToSdCmd.CheckCrc <= cInactivated;
 
                                                                        if (iSdCmd.Valid = cActivated) then
                                                                                NextR.CmdRegion <= CMD8;
                                                                                NextR.Region    <= waitstate;
 
                                                                                if (iSdCmd.Content.id = cSdR3Id) then
                                                                                        ocr := ArgToOcr(iSdCmd.Content.arg);
 
                                                                                        if (ocr.nBusy = cnInactivated) then
                                                                                                if (ocr.voltagewindow /= cVoltageWindow) then
                                                                                                        NextR.State <= invalidCard;
                                                                                                else
                                                                                                        NextR.CCS       <= ocr.ccs;
                                                                                                        NextR.CmdRegion <= ACMD41;
                                                                                                        NextR.Region    <= waitstate;
                                                                                                end if;
                                                                                        end if;
                                                                                end if;
                                                                        elsif (Timeout = cActivated) then
                                                                                NextR.State <= invalidCard;
                                                                        end if;
 
                                                                when waitstate =>
                                                                        NextCmdRegion := CMD2;
                                                                        NextRegion    := send;
 
                                                                when others =>
                                                                        report "SdController: Unhandled state" severity error;
                                                        end case;
                                                end if;
 
                                        when CMD2 =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdAllSendCID;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
 
                                                                NextRegion := response;
 
                                                        when response =>
                                                                NextR.ToSdCmd.ExpectCID <= cActivated;
 
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        NextR.State    <= invalidCard;
 
                                                                        if (iSdCmd.Content.id = cSdR2Id) then
                                                                                NextR.State     <= init;
                                                                                NextR.Region    <= waitstate;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextCmdRegion := CMD3;
                                                                NextRegion    := send;
 
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when CMD3 =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdSendRelAdr;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
                                                                NextRegion               := response;
 
                                                        when response =>
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSendRelAdr) then
                                                                                NextR.RCA    <= iSdCmd.Content.arg(31 downto 16);
                                                                                NextR.Region <= waitstate;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextState     := config;
                                                                NextCmdRegion := SelectCard;
                                                                NextRegion    := send;
 
                                                        when others =>
                                                                report "SdController: Unhandled region" severity error;
                                                end case;
 
                                        when others =>
                                                report "SdController: Unhandled CmdRegion" severity error;
                                end case;
 
                        when config =>
                                case R.CmdRegion is
                                        when SelectCard =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id  <= cSdCmdSelCard;
                                                                NextR.ToSdCmd.Content.arg <= R.RCA & X"0000";
                                                                NextRegion                := response;
 
                                                        when response => -- Response R1b: with busy!
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSelCard) then
                                                                                NextR.CardStatus <= iSdCmd.Content.arg;
 
                                                                                if (iSdCmd.Content.arg(cSdStatusReadyForDataBit) = cActivated) then
                                                                                        NextR.Region <= waitstatedata;
                                                                                else
                                                                                        NextR.Region <= waitstate;
                                                                                end if;
 
                                                                        else
                                                                                NextR.State <= invalidCard;
                                                                        end if;
 
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextRegion := checkbusy;
 
                                                        when waitstatedata =>
                                                                NextR.SendCMD55 <= cActivated;
                                                                NextCmdRegion   := CheckBusWidth;
                                                                NextRegion      := send;
 
                                                        when others =>
                                                                report "Unhandled Region" severity error;
                                                end case;
 
                                        when CheckBusWidth =>
                                                if (R.SendCMD55 = cInactivated) then
                                                        NextR.ToSdData.DataMode <= widewidth;
                                                        NextR.ToSdData.ExpectBits <= ScrBits;
 
                                                        case R.Region is
                                                                when send =>
                                                                        NextR.ToSdCmd.Content.id  <= cSdCmdSendSCR;
                                                                        NextR.ToSdCmd.Content.arg <= (others => '0'); -- stuff bits
                                                                        NextRegion                := response;
 
                                                                when response =>
                                                                        if (iSdCmd.Valid = cActivated) then
                                                                                if (iSdCmd.Content.id = cSdCmdSendSCR) then
                                                                                        NextR.CardStatus <= iSdCmd.Content.arg;
                                                                                        NextR.Region     <= receivedata;
                                                                                        TimeoutDisable   <= cActivated;
 
                                                                                else
                                                                                        NextR.State <= invalidCard;
                                                                                end if;
                                                                        elsif (Timeout = cActivated) then
                                                                                NextR.State <= invalidCard;
                                                                        end if;
 
                                                                when receivedata =>
                                                                        null;
 
                                                                when waitstatedata =>
                                                                        NextRegion           := send;
 
                                                                        if (Timeout = cActivated) then
                                                                                if (iSdData.WideMode = cActivated) then
                                                                                        NextCmdRegion   := SetBusWidth;
                                                                                        NextR.SendCMD55 <= cActivated;
 
                                                                                else
                                                                                        NextCmdRegion := CheckSpeed;
                                                                                end if;
                                                                        end if;
 
                                                                when others =>
                                                                        report "Unhandled region" severity error;
                                                        end case;
                                                end if;
 
                                        when SetBusWidth =>
                                                if (R.SendCMD55 = cInactivated) then
                                                        case R.Region is
                                                                when send =>
                                                                        NextR.ToSdCmd.Content.id              <= cSdCmdSetBusWidth;
                                                                        NextR.ToSdCmd.Content.arg(1 downto 0) <= cSdWideBusWidth;
                                                                        NextRegion                            := response;
 
                                                                when response =>
                                                                        if (iSdCmd.Valid = cActivated) then
                                                                                if (iSdCmd.Content.id = cSdCmdSetBusWidth) then
                                                                                        NextR.CardStatus <= iSdCmd.Content.arg;
                                                                                        NextR.Region <= waitstate;
 
                                                                                else
                                                                                        NextR.State <= invalidCard;
                                                                                end if;
                                                                        elsif (Timeout = cActivated) then
                                                                                NextR.State <= invalidCard;
                                                                        end if;
 
                                                                        when waitstate =>
                                                                        NextR.ToSdData.Mode <= wide;
                                                                        -- NextR.LedBank(4) <= cActivated;
 
                                                                        if gHighSpeedMode = true then
 
                                                                                NextRegion          := send;
                                                                                NextCmdRegion       := CheckSpeed;
 
                                                                        else
 
                                                                                NextState := idle;
 
                                                                        end if;
 
                                                                when others =>
                                                                        report "Unhandled region" severity error;
                                                        end case;
                                                end if;
 
                                        when CheckSpeed =>
                                                NextR.ToSdData.DataMode   <= widewidth;
                                                NextR.ToSdData.ExpectBits <= SwitchFunctionBits;
 
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id  <= cSdCmdSwitchFunction;
                                                                NextR.ToSdCmd.Content.arg <= cSdCmdCheckSpeedSupport;
                                                                NextRegion                := response;
 
                                                        when response =>
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSwitchFunction) then
                                                                                NextR.CardStatus <= iSdCmd.Content.arg;
                                                                                NextR.Region     <= receivedata;
 
                                                                        else
                                                                                NextR.State <= invalidCard;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when receivedata =>
                                                                null;
 
                                                        when waitstatedata =>
                                                                if (Timeout = cActivated) then
                                                                        -- check if high speed mode is supported
                                                                        if (iSdData.SpeedBits.HighSpeedSupported = cActivated and
                                                                        iSdData.SpeedBits.SwitchFunctionOK = X"1") then
                                                                                NextRegion    := send;
                                                                                NextCmdRegion := ChangeSpeed;
                                                                        else
                                                                                NextRegion := idle;
                                                                                NextState  := requestnewoperation;
                                                                        end if;
                                                                end if;
 
                                                        when others =>
                                                                report "Unhandled region" severity error;
                                                end case;
 
                                        when ChangeSpeed =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id  <= cSdCmdSwitchFunction;
                                                                NextR.ToSdCmd.Content.arg <= cSdCmdSwitchSpeed;
                                                                NextRegion                := response;
 
                                                        when response =>
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSwitchFunction) then
                                                                                NextR.CardStatus <= iSdCmd.Content.arg;
                                                                                NextR.Region     <= receivedata;
 
                                                                        else
                                                                                NextR.State <= invalidCard;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when receivedata =>
 
                                                        when waitstatedata =>
                                                                if (Timeout = cActivated) then
                                                                        -- check if switching was successful
                                                                        if (iSdData.SpeedBits.HighSpeedSupported = cActivated and
                                                                        iSdData.SpeedBits.SwitchFunctionOK = X"1") then
                                                                                NextR.HighSpeed <= cActivated;
                                                                                NextRegion      := send;
                                                                                NextCmdRegion   := GetStatus;
                                                                                --NextR.LedBank(5)<= cActivated;
                                                                        else
                                                                                NextRegion := idle;
                                                                                NextState  := requestnewoperation;
                                                                        end if;
                                                                end if;
 
                                                        when others =>
                                                                report "Unhandled region" severity error;
                                                end case;
 
                                        when GetStatus =>
                                                case R.Region is
                                                        when idle =>
                                                                EnableNcrTimeout;
 
                                                                if (Timeout = cActivated) then
                                                                        NextR.Region <= send;
                                                                end if;
 
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id              <= cSdCmdSendStatus;
                                                                NextR.ToSdCmd.Content.arg(31 downto 16) <= R.RCA;
                                                                NextRegion                            := response;
 
                                                        when response =>
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSendStatus) then
                                                                                NextR.CardStatus <= iSdCmd.Content.arg;
                                                                                NextR.Region <= waitstate;
 
                                                                        else
                                                                                NextR.State <= invalidCard;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextRegion    := idle;
                                                                NextState     := requestnewoperation;
 
                                                        when others =>
                                                                report "Unhandled region" severity error;
                                                end case;
 
                                        when others =>
                                                report "Unhandled CmdRegion" severity error;
                                end case;
 
                        when read =>
                                NextR.ToSdData.DataMode <= usual;
 
                                case R.Region is
                                        when send =>
                                                NextR.LedBank(0) <= cActivated;
                                                -- send a read command
                                                NextR.ToSdCmd.Content.id  <= cSdCmdReadSingleBlock;
 
                                                -- we get a block address, but a standard capacity card needs a byte address
                                                case R.CCS is
                                                        when cActivated =>
                                                                NextR.ToSdCmd.Content.arg <= R.OperationBlock.StartAddr;
 
                                                        when cInactivated =>
                                                                NextR.ToSdCmd.Content.arg <= R.OperationBlock.StartAddr(31-9 downto 0) & X"00" & '0'; -- calculate byte address
 
                                                        when others =>
                                                                report "Invalid CCS" severity error;
                                                end case;
 
                                                NextRegion                := response;
 
                                        when response =>
                                                NextR.LedBank(1) <= cActivated;
 
                                                -- wait for the response and handle it
                                                if (iSdCmd.Valid = cActivated) then
                                                        if (iSdCmd.Content.id = cSdCmdReadSingleBlock) then
                                                                NextR.CardStatus <= iSdCmd.Content.arg;
                                                                NextR.Region     <= receivedata;
 
                                                        else
                                                                NextR.State <= invalidCard;
                                                        end if;
                                                elsif (Timeout = cActivated) then
                                                        NextR.State <= invalidCard;
                                                end if;
 
                                        when receivedata =>
                                                NextR.LedBank(2) <= cActivated;
 
                                        when waitstatedata =>
                                                NextR.LedBank(3) <= cActivated;
                                                NextRegion := idle;
                                                NextState  := requestnewoperation;
 
                                        when others =>
                                                report "Unhandled region";
                                end case;
 
                        when write =>
                                NextR.ToSdData.DataMode <= usual;
 
                                case R.Region is
                                        when send =>
                                                -- send a write command
                                                NextR.ToSdCmd.Content.id  <= cSdCmdWriteSingleBlock;
 
                                                -- we get a block address, but a standard capacity card needs a byte address
                                                case R.CCS is
                                                        when cActivated =>
                                                                NextR.ToSdCmd.Content.arg <= R.OperationBlock.StartAddr;
 
                                                        when cInactivated =>
                                                                NextR.ToSdCmd.Content.arg <= R.OperationBlock.StartAddr(31-9 downto 0) & X"00" & '0'; -- calculate byte address
 
                                                        when others =>
                                                                report "Invalid CCS" severity error;
                                                end case;
 
                                                NextRegion                := response;
 
                                        when response =>
                                                -- wait for the response and handle it
                                                if (iSdCmd.Valid = cActivated) then
                                                        if (iSdCmd.Content.id = cSdCmdWriteSingleBlock) then
                                                                NextR.CardStatus <= iSdCmd.Content.arg;
                                                                NextR.Region     <= senddata;
 
                                                        else
                                                                NextR.State <= invalidCard;
                                                        end if;
                                                elsif (Timeout = cActivated) then
                                                        NextR.State <= invalidCard;
                                                end if;
 
                                        when senddata =>
                                                NextRegion := checkbusy;
 
                                        when checkbusy => null;
 
                                        when waitstatedata =>
                                                NextRegion := idle;
                                                NextState  := requestnewoperation;
 
                                        when others =>
                                                report "Unhandled region";
                                end case;
 
                        when requestnewoperation =>
                                NextR.LedBank <= (others => '0');
                                NextR.ToSdData.DisableRb       <= cInactivated;
                                NextR.ToSdWbSlave.ReqOperation <= not R.ToSdWbSlave.ReqOperation;
                                NextR.State                    <= idle;
 
                        when idle =>
                                NextR.LedBank(6) <= cActivated;
 
                                -- wait for next operation
                                if (iSdWbSlave.AckOperation = cActivated) then
 
                                        -- save operation
                                        NextR.OperationBlock <= iSdWbSlave.OperationBlock;
 
                                        -- handle operations
                                        case iSdWbSlave.OperationBlock.Operation is
                                                when cOperationRead =>
 
                                                        NextR.State  <= read;
                                                        NextR.Region <= send;
 
                                                when cOperationWrite =>
 
                                                        NextR.State  <= write;
                                                        NextR.Region <= send;
 
                                                when others =>
                                                        NextR.State <= requestnewoperation;
                                                        report "Unknown operation" severity error;
                                        end case;
 
                                        NextR.LedBank(6) <= cInactivated;
                                end if;
 
                        when invalidCard =>
                                NextR.LedBank(7) <= cActivated;
 
                        when others =>
                                report "SdController: Unhandled state" severity error;
                end case;
 
                case R.Region is
                        when idle => -- do nothing
                                null;
 
                        when send =>
                                NextR.ToSdCmd.Valid <= cActivated;
 
                                if (R.SendCMD55 = cActivated) then
                                        NextR.ToSdCmd.Content.id  <= cSdNextIsACMD;
                                        NextR.ToSdCmd.Content.arg <= R.RCA & X"0000";
                                        NextRegion                := response;
                                end if;
 
                                if (iSdCmd.Ack = cActivated) then
                                        NextR.ToSdCmd.Valid <= cInactivated;
                                        NextR.Region        <= NextRegion;
                                end if;
 
                        when response =>
                                -- oLedBank(0)   <= cActivated;
                                TimeoutEnable <= cActivated;
                                TimeoutMax    <= cReadTimeout;
 
                                if (iSdCmd.Valid = cActivated) then
                                        TimeoutDisable <= cActivated;
                                end if;
 
                                if (R.SendCMD55 = cActivated) then
                                        if (iSdCmd.Valid = cActivated) then
                                                if (iSdCmd.Content.id = cSdNextIsACMD) then
                                                        NextR.CardStatus <= iSdCmd.Content.arg;
                                                        NextR.Region <= waitstate;
 
                                                        if (iSdCmd.Content.arg(cSdArgAppCmdPos) = cActivated) then
                                                                NextR.SentCMD55 <= cActivated;
                                                        end if;
                                                else
                                                        NextR.State <= invalidCard;
                                                end if;
                                        elsif (Timeout = cActivated) then
                                                NextR.State     <= startup;
                                                NextR.CmdRegion <= CMD0;
                                                NextR.Region    <= idle;
                                        end if;
                                end if;
 
 
                        when waitstate =>
                                EnableNcrTimeout;
 
                                if (Timeout = cActivated) then
                                        if (R.SentCMD55 = cActivated) then
                                                NextR.SentCMD55 <= cInactivated;
                                                NextR.SendCMD55 <= cInactivated;
                                                NextRegion := send;
                                        end if;
 
                                        TimeoutDisable  <= cActivated;
                                        NextR.Region    <= NextRegion;
                                        NextR.CmdRegion <= NextCmdRegion;
                                        NextR.State     <= NextState;
                                end if;
 
                        when senddata =>
                                NextR.ToSdData.Valid <= cActivated;
 
                                if (iSdData.Ack = cActivated) then
                                        NextR.ToSdData.Valid <= cInactivated;
                                        NextR.Region         <= NextRegion;
                                end if;
 
                        when checkbusy =>
                                NextR.ToSdData.CheckBusy <= cActivated;
                                TimeoutEnable <= cActivated;
                                TimeoutMax    <= cWriteTimeout;
 
                                if (iSdData.Valid = cActivated) then
                                        NextR.Region <= waitstatedata;
                                        NextR.ToSdData.CheckBusy <= cInactivated;
                                        TimeoutDisable <= cActivated;
                                end if;
 
                        when receivedata =>
                                TimeoutEnable <= cActivated;
                                TimeoutMax    <= cReadTimeout;
 
                                if (iSdData.Err = cActivated) then
                                        NextR.State    <= init;
                                        TimeoutDisable <= cActivated;
 
                                elsif (iSdData.Valid = cActivated) then
                                        NextR.Region   <= waitstatedata;
                                        TimeoutDisable <= cActivated;
 
                                elsif (Timeout = cActivated) then
                                        NextR.State <= invalidCard;
                                        NextR.LedBank(5) <= cActivated;
                                end if;
 
 
                        when waitstatedata =>
                                EnableNcrTimeout;
 
                                if (Timeout = cActivated) then
                                        TimeoutDisable  <= cActivated;
                                        NextR.Region    <= NextRegion;
                                        NextR.CmdRegion <= NextCmdRegion;
                                        NextR.State     <= NextState;
                                end if;
 
                        when others =>
                                report "Unhandled region" severity error;
                end case;
        end process Comb;
 
        TimeoutCounter_inst : entity work.Counter
        generic map (
                gBitWidth => cMaxTimeoutBitWidth
        )
        port map (
                iClk         => iClk,
                iRstSync     => iRstSync,
                iEnable      => TimeoutEnable,
                iDisable     => TimeoutDisable,
                iMax         => TimeoutMax,
                oStrobe      => Timeout);
 
end architecture Rtl;
 

Line No.	Rev	Author	Line
1	164	rkastl	`-- SDHC-SC-Core`
2			`-- Secure Digital High Capacity Self Configuring Core`
3	98	rkastl	`--`
4	170	rkastl	`-- (C) Copyright 2010, Rainer Kastl`
5			`-- All rights reserved.`
6	164	rkastl	`--`
7	170	rkastl	`-- Redistribution and use in source and binary forms, with or without`
8			`-- modification, are permitted provided that the following conditions are met:`
9			`-- * Redistributions of source code must retain the above copyright`
10			`-- notice, this list of conditions and the following disclaimer.`
11			`-- * Redistributions in binary form must reproduce the above copyright`
12			`-- notice, this list of conditions and the following disclaimer in the`
13			`-- documentation and/or other materials provided with the distribution.`
14			`-- * Neither the name of the <organization> nor the`
15			`-- names of its contributors may be used to endorse or promote products`
16			`-- derived from this software without specific prior written permission.`
17	164	rkastl	`--`
18	170	rkastl	`-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND`
19			`-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED`
20			`-- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE`
21			`-- DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY`
22			`-- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES`
23			`-- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;`
24			`-- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND`
25			`-- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT`
26			`-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS`
27			`-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
28	164	rkastl	`--`
29			`-- File : SdController-Rtl-a.vhdl`
30			`-- Owner : Rainer Kastl`
31			`-- Description : Main FSM controlling Cmd and Data FSMs, communicates with Wb`
32			`-- Links :`
33			`--`
34	54	rkastl
35			`architecture Rtl of SdController is`
36
37	122	rkastl	`type aSdControllerState is (startup, init, config, requestnewoperation, idle, invalidCard, read, write);`
38	105	rkastl	`type aCmdRegion is (CMD0, CMD8, ACMD41, CMD2, CMD3, SelectCard, CheckBusWidth, SetBusWidth, CheckSpeed, ChangeSpeed, GetStatus);`
39	98	rkastl	`type aRegion is (idle, send, response, waitstate, senddata, receivedata, checkbusy, waitstatedata);`
40	105	rkastl
41	110	rkastl	`subtype aCounter is natural range 0 to (512/32)-1;`
42
43	95	rkastl	`constant cDefaultToSdCmd : aSdCmdFromController := (`
44	84	rkastl	`(id => (others => '0'),`
45			`arg => (others => '0')),`
46			`Valid => cInactivated,`
47	89	rkastl	`ExpectCID => cInactivated,`
48			`CheckCrc => cActivated);`
49	54	rkastl
50	57	rkastl	`type aSdControllerReg is record`
51	122	rkastl	`State : aSdControllerState;`
52			`CmdRegion : aCmdRegion;`
53			`Region : aRegion;`
54			`Counter : aCounter;`
55			`SendCMD55 : std_ulogic;`
56			`SentCMD55 : std_ulogic;`
57			`HCS : std_ulogic;`
58			`CCS : std_ulogic;`
59			`RCA : aSdRCA;`
60			`CardStatus : aSdCardStatus;`
61			`ToSdCmd : aSdCmdFromController;`
62			`ToSdData : aSdDataFromController;`
63			`ToDataRam : aSdControllerToRam;`
64			`ToSdWbSlave : aSdControllerToSdWbSlave;`
65			`HighSpeed : std_ulogic;`
66			`OperationBlock : aOperationBlock;`
67	167	rkastl	`LedBank : std_ulogic_vector(7 downto 0);`
68	57	rkastl	`end record aSdControllerReg;`
69
70	84	rkastl	`constant cDefaultSdControllerReg : aSdControllerReg := (`
71	122	rkastl	`State => startup,`
72			`CmdRegion => CMD0,`
73			`Region => idle,`
74			`Counter => 0,`
75			`SendCMD55 => cInactivated,`
76			`SentCMD55 => cInactivated,`
77			`HCS => cActivated,`
78			`CCS => cInactivated,`
79			`RCA => cDefaultRCA,`
80			`CardStatus => cDefaultSdCardStatus,`
81			`ToSdCmd => cDefaultToSdCmd,`
82			`ToSdData => cDefaultSdDataFromController,`
83			`ToDataRam => cDefaultSdControllerToRam,`
84			`ToSdWbSlave => cDefaultSdControllerToSdWbSlave,`
85			`HighSpeed => cInactivated,`
86	167	rkastl	`OperationBlock => cDefaultOperationBlock,`
87			`LedBank => (others => '0'));`
88	57	rkastl
89	100	rkastl	`signal R, NextR : aSdControllerReg;`
90	106	rkastl
91			`constant cReadTimeoutNat : natural := gClkFrequency / (1 sec / gReadTimeout) - 1;`
92	167	rkastl	`constant cWriteTimeoutNat : natural := gClkFrequency / (1 sec / gWriteTimeout) - 1;`
93	106	rkastl	`constant cNcrTimeoutNatLow : natural := gClkFrequency / (1 sec / (1 sec / 25E6 * 8)) - 1;`
94			`constant cNcrTimeoutNatHigh : natural := gClkFrequency / (1 sec / (1 sec / 50E6 * 8)) - 1;`
95			`constant cStartupTimeoutNat : natural := gClkFrequency / (1 sec / gStartupTimeout) - 1;`
96
97	167	rkastl	`constant cMaxTimeoutBitWidth : natural := LogDualis(cWriteTimeoutNat);`
98	106	rkastl	`subtype aTimeoutValue is unsigned(cMaxTimeoutBitWidth - 1 downto 0);`
99
100			`constant cNcrTimeoutLow : aTimeoutValue := to_unsigned(cNcrTimeoutNatLow, aTimeoutValue'length);`
101			`constant cNcrTimeoutHigh : aTimeoutValue := to_unsigned(cNcrTimeoutNatHigh, aTimeoutValue'length);`
102			`constant cStartupTimeout : aTimeoutValue := to_unsigned(cStartupTimeoutNat, aTimeoutValue'length);`
103			`constant cReadTimeout : aTimeoutValue := to_unsigned(cReadTimeoutNat, aTimeoutValue'length);`
104	167	rkastl	`constant cWriteTimeout : aTimeoutValue := to_unsigned(cWriteTimeoutNat, aTimeoutValue'length);`
105	106	rkastl
106	100	rkastl	`signal TimeoutEnable : std_ulogic;`
107			`signal TimeoutDisable : std_ulogic;`
108			`signal Timeout : std_ulogic;`
109	106	rkastl	`signal TimeoutMax : unsigned(cMaxTimeoutBitWidth - 1 downto 0);`
110
111	54	rkastl	`begin`
112
113	110	rkastl	`oSdCmd <= R.ToSdCmd;`
114			`oSdData <= R.ToSdData;`
115	122	rkastl	`oSdWbSlave <= R.ToSdWbSlave;`
116	110	rkastl	`oHighSpeed <= R.HighSpeed;`
117	167	rkastl	`oLedBank <= R.LedBank;`
118	88	rkastl
119	165	rkastl	`Regs : process (iClk, iRstSync)`
120	54	rkastl	`begin`
121	165	rkastl	`if (iClk'event and iClk = cActivated) then`
122			`if (iRstSync = cActivated) then`
123			`R <= cDefaultSdControllerReg;`
124			`else`
125			`R <= NextR;`
126			`end if;`
127	54	rkastl	`end if;`
128			`end process Regs;`
129
130	126	rkastl	`Comb : process (iSdCmd, iSdData, iSdWbSlave, Timeout, R)`
131	96	rkastl	`variable ocr : aSdRegOCR;`
132			`variable arg : aSdCmdArg;`
133			`variable NextRegion : aRegion;`
134			`variable NextCmdRegion : aCmdRegion;`
135			`variable NextState : aSdControllerState;`
136	106	rkastl
137			`procedure EnableNcrTimeout is`
138			`begin`
139			`TimeoutEnable <= cActivated;`
140
141			`if (R.HighSpeed = cInactivated) then`
142			`TimeoutMax <= cNcrTimeoutLow;`
143			`else`
144			`TimeoutMax <= cNcrTimeoutHigh;`
145			`end if;`
146			`end procedure EnableNcrTimeout;`
147	110	rkastl
148	54	rkastl	`begin`
149			`-- default assignments`
150	106	rkastl	`NextR <= R;`
151			`NextR.ToSdCmd <= cDefaultToSdCmd;`
152			`TimeoutEnable <= cInactivated;`
153			`TimeoutDisable <= cInactivated;`
154			`TimeoutMax <= to_unsigned(0, TimeoutMax'length);`
155			`NextRegion := R.Region;`
156			`NextCmdRegion := R.CmdRegion;`
157			`NextState := R.State;`
158	54	rkastl
159	84	rkastl	`case R.State is`
160	106	rkastl	`when startup =>`
161	85	rkastl	`TimeoutEnable <= cActivated;`
162	106	rkastl	`TimeoutMax <= cStartupTimeout;`
163	105	rkastl
164	85	rkastl	`if (Timeout = cActivated) then`
165	106	rkastl	`TimeoutDisable <= cActivated;`
166			`NextR.State <= init;`
167			`NextR.CmdRegion <= CMD0;`
168			`NextR.Region <= send;`
169	88	rkastl	`end if;`
170	85	rkastl
171	84	rkastl	`when init =>`
172			`case R.CmdRegion is`
173			`when CMD0 =>`
174			`case R.Region is`
175			`when send =>`
176	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdGoIdleState;`
177	96	rkastl	`NextR.CardStatus <= cDefaultSdCardStatus;`
178			`NextRegion := waitstate;`
179	54	rkastl
180	86	rkastl	`when waitstate =>`
181	96	rkastl	`NextRegion := send;`
182			`NextCmdRegion := CMD8;`
183	85	rkastl
184	84	rkastl	`when others =>`
185			`report "SdController: Unhandled state" severity error;`
186			`end case;`
187	54	rkastl
188	84	rkastl	`when CMD8 =>`
189			`case R.Region is`
190			`when send =>`
191	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSendIfCond;`
192			`NextR.ToSdCmd.Content.arg <= cSdArgVoltage;`
193	98	rkastl	`NextRegion := response;`
194	54	rkastl
195	98	rkastl	`when response =>`
196	84	rkastl	`if (iSdCmd.Valid = cActivated) then`
197			`if (iSdCmd.Content.id = cSdCmdSendIfCond and iSdCmd.Content.arg = cSdArgVoltage) then`
198	86	rkastl	`NextR.Region <= waitstate;`
199			`NextR.HCS <= cActivated;`
200	54	rkastl
201	84	rkastl	`else`
202			`NextR.State <= invalidCard;`
203			`end if;`
204	86	rkastl	`elsif (Timeout = cActivated) then`
205			`NextR.HCS <= cInactivated;`
206	99	rkastl	`NextR.CmdRegion <= ACMD41;`
207	86	rkastl	`NextR.Region <= send;`
208	99	rkastl	`NextR.SendCMD55 <= cActivated;`
209	84	rkastl	`end if;`
210	86	rkastl
211			`when waitstate =>`
212	99	rkastl	`NextCmdRegion := ACMD41;`
213			`NextRegion := send;`
214			`NextR.SendCMD55 <= cActivated;`
215	86	rkastl
216	84	rkastl	`when others =>`
217			`report "SdController: Unhandled state" severity error;`
218			`end case;`
219	57	rkastl
220	84	rkastl	`when ACMD41 =>`
221	99	rkastl	`if (R.SendCMD55 = cInactivated) then`
222			`case R.Region is`
223			`when send =>`
224			`ocr.nBusy := '0';`
225			`ocr.ccs := R.HCS;`
226			`ocr.voltagewindow := cVoltageWindow;`
227			`NextR.ToSdCmd.Content.id <= cSdCmdACMD41;`
228			`NextR.ToSdCmd.Content.arg <= OCRToArg(ocr);`
229			`NextRegion := response;`
230	63	rkastl
231	99	rkastl	`when response =>`
232			`NextR.ToSdCmd.CheckCrc <= cInactivated;`
233	84	rkastl
234	99	rkastl	`if (iSdCmd.Valid = cActivated) then`
235			`NextR.CmdRegion <= CMD8;`
236			`NextR.Region <= waitstate;`
237	84	rkastl
238	99	rkastl	`if (iSdCmd.Content.id = cSdR3Id) then`
239			`ocr := ArgToOcr(iSdCmd.Content.arg);`
240
241			`if (ocr.nBusy = cnInactivated) then`
242			`if (ocr.voltagewindow /= cVoltageWindow) then`
243			`NextR.State <= invalidCard;`
244			`else`
245			`NextR.CCS <= ocr.ccs;`
246			`NextR.CmdRegion <= ACMD41;`
247			`NextR.Region <= waitstate;`
248			`end if;`
249	84	rkastl	`end if;`
250			`end if;`
251	99	rkastl	`elsif (Timeout = cActivated) then`
252			`NextR.State <= invalidCard;`
253	84	rkastl	`end if;`
254	105	rkastl
255	99	rkastl	`when waitstate =>`
256			`NextCmdRegion := CMD2;`
257			`NextRegion := send;`
258	89	rkastl
259	99	rkastl	`when others =>`
260			`report "SdController: Unhandled state" severity error;`
261			`end case;`
262			`end if;`
263	84	rkastl
264			`when CMD2 =>`
265			`case R.Region is`
266			`when send =>`
267	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdAllSendCID;`
268			`NextR.ToSdCmd.Valid <= cActivated;`
269	84	rkastl
270	98	rkastl	`NextRegion := response;`
271	84	rkastl
272	98	rkastl	`when response =>`
273	95	rkastl	`NextR.ToSdCmd.ExpectCID <= cActivated;`
274	84	rkastl
275			`if (iSdCmd.Valid = cActivated) then`
276	106	rkastl	`NextR.State <= invalidCard;`
277	84	rkastl
278			`if (iSdCmd.Content.id = cSdR2Id) then`
279			`NextR.State <= init;`
280	89	rkastl	`NextR.Region <= waitstate;`
281	84	rkastl	`end if;`
282	90	rkastl	`elsif (Timeout = cActivated) then`
283			`NextR.State <= invalidCard;`
284	84	rkastl	`end if;`
285	105	rkastl
286	89	rkastl	`when waitstate =>`
287	96	rkastl	`NextCmdRegion := CMD3;`
288			`NextRegion := send;`
289	84	rkastl
290			`when others =>`
291			`report "SdController: Unhandled state" severity error;`
292			`end case;`
293
294			`when CMD3 =>`
295			`case R.Region is`
296			`when send =>`
297	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSendRelAdr;`
298			`NextR.ToSdCmd.Valid <= cActivated;`
299	99	rkastl	`NextRegion := response;`
300	84	rkastl
301	98	rkastl	`when response =>`
302	84	rkastl	`if (iSdCmd.Valid = cActivated) then`
303			`if (iSdCmd.Content.id = cSdCmdSendRelAdr) then`
304	96	rkastl	`NextR.RCA <= iSdCmd.Content.arg(31 downto 16);`
305			`NextR.Region <= waitstate;`
306	84	rkastl	`end if;`
307	90	rkastl	`elsif (Timeout = cActivated) then`
308			`NextR.State <= invalidCard;`
309	84	rkastl	`end if;`
310
311	96	rkastl	`when waitstate =>`
312	105	rkastl	`NextState := config;`
313			`NextCmdRegion := SelectCard;`
314			`NextRegion := send;`
315	96	rkastl
316	84	rkastl	`when others =>`
317	103	rkastl	`report "SdController: Unhandled region" severity error;`
318	84	rkastl	`end case;`
319
320			`when others =>`
321	103	rkastl	`report "SdController: Unhandled CmdRegion" severity error;`
322	84	rkastl	`end case;`
323
324	167	rkastl	`when config =>`
325	95	rkastl	`case R.CmdRegion is`
326			`when SelectCard =>`
327			`case R.Region is`
328			`when send =>`
329	96	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSelCard;`
330			`NextR.ToSdCmd.Content.arg <= R.RCA & X"0000";`
331	99	rkastl	`NextRegion := response;`
332	95	rkastl
333	98	rkastl	`when response => -- Response R1b: with busy!`
334	96	rkastl	`if (iSdCmd.Valid = cActivated) then`
335			`if (iSdCmd.Content.id = cSdCmdSelCard) then`
336			`NextR.CardStatus <= iSdCmd.Content.arg;`
337	98	rkastl
338			`if (iSdCmd.Content.arg(cSdStatusReadyForDataBit) = cActivated) then`
339			`NextR.Region <= waitstatedata;`
340			`else`
341			`NextR.Region <= waitstate;`
342			`end if;`
343
344	99	rkastl	`else`
345			`NextR.State <= invalidCard;`
346	96	rkastl	`end if;`
347	99	rkastl
348	96	rkastl	`elsif (Timeout = cActivated) then`
349			`NextR.State <= invalidCard;`
350			`end if;`
351	95	rkastl
352			`when waitstate =>`
353	98	rkastl	`NextRegion := checkbusy;`
354	95	rkastl
355	98	rkastl	`when waitstatedata =>`
356	99	rkastl	`NextR.SendCMD55 <= cActivated;`
357			`NextCmdRegion := CheckBusWidth;`
358			`NextRegion := send;`
359	98	rkastl
360	95	rkastl	`when others =>`
361			`report "Unhandled Region" severity error;`
362			`end case;`
363
364	99	rkastl	`when CheckBusWidth =>`
365			`if (R.SendCMD55 = cInactivated) then`
366	100	rkastl	`NextR.ToSdData.DataMode <= widewidth;`
367	101	rkastl	`NextR.ToSdData.ExpectBits <= ScrBits;`
368	100	rkastl
369	99	rkastl	`case R.Region is`
370			`when send =>`
371			`NextR.ToSdCmd.Content.id <= cSdCmdSendSCR;`
372			`NextR.ToSdCmd.Content.arg <= (others => '0'); -- stuff bits`
373			`NextRegion := response;`
374
375			`when response =>`
376			`if (iSdCmd.Valid = cActivated) then`
377			`if (iSdCmd.Content.id = cSdCmdSendSCR) then`
378			`NextR.CardStatus <= iSdCmd.Content.arg;`
379	100	rkastl	`NextR.Region <= receivedata;`
380			`TimeoutDisable <= cActivated;`
381	99	rkastl
382			`else`
383			`NextR.State <= invalidCard;`
384			`end if;`
385			`elsif (Timeout = cActivated) then`
386			`NextR.State <= invalidCard;`
387			`end if;`
388
389	100	rkastl	`when receivedata =>`
390	103	rkastl	`null;`
391	102	rkastl
392			`when waitstatedata =>`
393	109	rkastl	`NextRegion := send;`
394	102	rkastl
395	106	rkastl	`if (Timeout = cActivated) then`
396	126	rkastl	`if (iSdData.WideMode = cActivated) then`
397	105	rkastl	`NextCmdRegion := SetBusWidth;`
398			`NextR.SendCMD55 <= cActivated;`
399
400			`else`
401			`NextCmdRegion := CheckSpeed;`
402	102	rkastl	`end if;`
403	105	rkastl	`end if;`
404	102	rkastl
405	99	rkastl	`when others =>`
406			`report "Unhandled region" severity error;`
407			`end case;`
408			`end if;`
409
410	102	rkastl	`when SetBusWidth =>`
411			`if (R.SendCMD55 = cInactivated) then`
412			`case R.Region is`
413			`when send =>`
414			`NextR.ToSdCmd.Content.id <= cSdCmdSetBusWidth;`
415			`NextR.ToSdCmd.Content.arg(1 downto 0) <= cSdWideBusWidth;`
416			`NextRegion := response;`
417
418			`when response =>`
419			`if (iSdCmd.Valid = cActivated) then`
420			`if (iSdCmd.Content.id = cSdCmdSetBusWidth) then`
421			`NextR.CardStatus <= iSdCmd.Content.arg;`
422			`NextR.Region <= waitstate;`
423	105	rkastl
424	102	rkastl	`else`
425			`NextR.State <= invalidCard;`
426			`end if;`
427			`elsif (Timeout = cActivated) then`
428			`NextR.State <= invalidCard;`
429			`end if;`
430
431	167	rkastl	`when waitstate =>`
432	112	rkastl	`NextR.ToSdData.Mode <= wide;`
433	167	rkastl	`-- NextR.LedBank(4) <= cActivated;`
434	102	rkastl
435	109	rkastl	`if gHighSpeedMode = true then`
436
437			`NextRegion := send;`
438			`NextCmdRegion := CheckSpeed;`
439
440			`else`
441
442			`NextState := idle;`
443
444			`end if;`
445
446	102	rkastl	`when others =>`
447			`report "Unhandled region" severity error;`
448			`end case;`
449			`end if;`
450
451			`when CheckSpeed =>`
452	104	rkastl	`NextR.ToSdData.DataMode <= widewidth;`
453	103	rkastl	`NextR.ToSdData.ExpectBits <= SwitchFunctionBits;`
454	102	rkastl
455	103	rkastl	`case R.Region is`
456			`when send =>`
457	104	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSwitchFunction;`
458	103	rkastl	`NextR.ToSdCmd.Content.arg <= cSdCmdCheckSpeedSupport;`
459	104	rkastl	`NextRegion := response;`
460	103	rkastl
461			`when response =>`
462			`if (iSdCmd.Valid = cActivated) then`
463			`if (iSdCmd.Content.id = cSdCmdSwitchFunction) then`
464			`NextR.CardStatus <= iSdCmd.Content.arg;`
465	104	rkastl	`NextR.Region <= receivedata;`
466	105	rkastl
467	103	rkastl	`else`
468	122	rkastl	`NextR.State <= invalidCard;`
469	103	rkastl	`end if;`
470			`elsif (Timeout = cActivated) then`
471			`NextR.State <= invalidCard;`
472			`end if;`
473
474			`when receivedata =>`
475	126	rkastl	`null;`
476	105	rkastl
477	103	rkastl	`when waitstatedata =>`
478	106	rkastl	`if (Timeout = cActivated) then`
479	126	rkastl	`-- check if high speed mode is supported`
480			`if (iSdData.SpeedBits.HighSpeedSupported = cActivated and`
481			`iSdData.SpeedBits.SwitchFunctionOK = X"1") then`
482			`NextRegion := send;`
483			`NextCmdRegion := ChangeSpeed;`
484			`else`
485			`NextRegion := idle;`
486			`NextState := requestnewoperation;`
487			`end if;`
488	103	rkastl	`end if;`
489
490			`when others =>`
491	104	rkastl	`report "Unhandled region" severity error;`
492	103	rkastl	`end case;`
493
494			`when ChangeSpeed =>`
495	104	rkastl	`case R.Region is`
496			`when send =>`
497			`NextR.ToSdCmd.Content.id <= cSdCmdSwitchFunction;`
498			`NextR.ToSdCmd.Content.arg <= cSdCmdSwitchSpeed;`
499			`NextRegion := response;`
500	103	rkastl

Browse

Tools

Subversion Repositories sdhc-sc-core

[/] [sdhc-sc-core/] [trunk/] [grpSd/] [unitSdController/] [src/] [SdController-Rtl-a.vhdl] - Blame information for rev 185