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 95

Go to most recent revision | Details | Compare with Previous | View Log


-------------------------------------------------
-- file: SdController-Rtl-ea.vhdl
-- author: Rainer Kastl
--
-- Main statemachine for a SDHC compatible SD Controller
-- Simplified Physical Layer Spec. 2.00
-------------------------------------------------
 
architecture Rtl of SdController is
 
        type aSdControllerState is (startup, init, config, idle, invalidCard);
        type aCmdRegion is (CMD0, CMD8, CMD55, ACMD41, CMD2, CMD3, SelectCard);
        type aRegion is (send, receive, waitstate);
 
        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;
                HCS        : std_ulogic;
                CCS        : std_ulogic;
                RCA        : aSdRCA;
                CardStatus : aSdCardStatus;
                ToSdCmd    : aSdCmdFromController;
                ToSdData   : aSdDataFromController;
        end record aSdControllerReg;
 
        constant cDefaultSdControllerReg : aSdControllerReg := (
        State      => startup,
        CmdRegion  => CMD0,
        Region     => send,
        HCS        => cActivated,
        CCS        => cInactivated,
        RCA        => cDefaultRCA,
        CardStatus => cDefaultSdCardStatus,
        ToSdCmd    => cDefaultToSdCmd,
        ToSdData   => cDefaultSdDataFromController);
 
        signal R, NextR      : aSdControllerReg;
        signal TimeoutEnable : std_ulogic;
        signal Timeout       : std_ulogic;
 
        signal NextCmdTimeout       : std_ulogic;
        signal NextCmdTimeoutEnable : std_ulogic;
 
begin
 
        oSdRegisters.CardStatus <= R.CardStatus;
        oSdCmd <= R.ToSdCmd;
        oSdData <= R.ToSdData;
 
        Regs : process (iClk, inResetAsync)
        begin
                if (inResetAsync = cnActivated) then
                        R <= cDefaultSdControllerReg;
                elsif (iClk'event and iClk = cActivated) then
                        R <= NextR;
                end if;
        end process Regs;
 
        Comb : process (iSdCmd, Timeout, NextCmdTimeout, R)
                variable ocr : aSdRegOCR;
                variable arg : aSdCmdArg;
        begin
                -- default assignments
                NextR                <= R;
                NextR.ToSdCmd        <= cDefaultToSdCmd;
                TimeoutEnable        <= cInactivated;
                NextCmdTimeoutEnable <= cInactivated;
 
                -- Status
                oLedBank <= (others => cInactivated);
 
                case R.State is
                        when startup =>
                                TimeoutEnable <= cActivated;
 
                                if (Timeout = cActivated) then
                                        TimeoutEnable <= cInactivated;
                                        NextR.State <= init;
                                end if;
 
                        when init =>
                                case R.CmdRegion is
                                        when CMD0 =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdGoIdleState;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
 
                                                                if (iSdCmd.Ack = cActivated) then
                                                                        NextR.ToSdCmd.Valid <= cInactivated;
                                                                        NextR.Region        <= waitstate;
                                                                        NextR.CardStatus    <= cDefaultSdCardStatus;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextCmdTimeoutEnable <= cActivated;
 
                                                                if (NextCmdTimeout = cActivated) then
                                                                        NextCmdTimeoutEnable <= cInactivated;
                                                                        NextR.Region    <= send;
                                                                        NextR.CmdRegion <= CMD8;
                                                                end if;
 
                                                        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;
                                                                NextR.ToSdCmd.Valid       <= cActivated;
 
                                                                if (iSdCmd.Ack = cActivated) then
                                                                        NextR.ToSdCmd.Valid <= cInactivated;
                                                                        NextR.Region <= receive;
                                                                end if;
 
                                                        when receive =>
                                                                oLedBank(0) <= cActivated;
                                                                TimeoutEnable <= cActivated;
 
                                                                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 <= CMD55;
                                                                        NextR.Region    <= send;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextCmdTimeoutEnable <= cActivated;
 
                                                                if (NextCmdTimeout = cActivated) then
                                                                        NextCmdTimeoutEnable <= cInactivated;
                                                                        NextR.CmdRegion      <= CMD55;
                                                                        NextR.Region         <= send;
                                                                end if;
 
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when CMD55 =>
                                                oLedBank(1) <= cActivated;
 
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id  <= cSdNextIsACMD;
                                                                NextR.ToSdCmd.Content.arg <= cSdACMDArg;
                                                                NextR.ToSdCmd.Valid       <= cActivated;
 
                                                                if (iSdCmd.Ack = cActivated) then
                                                                        NextR.ToSdCmd.Valid <= cInactivated;
                                                                        NextR.Region <= receive;
                                                                end if;
 
                                                        when receive =>
                                                                oLedBank(0)   <= cActivated;
                                                                TimeoutEnable <= cActivated;
 
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdNextIsACMD) then
                                                                                NextR.CardStatus <= iSdCmd.Content.arg;
                                                                                NextR.CmdRegion  <= CMD55;
 
                                                                                if (iSdCmd.Content.arg(cSdArgAppCmdPos) = cActivated) then
                                                                                        NextR.Region <= waitstate;
                                                                                else
                                                                                        NextR.Region <= send;
                                                                                end if;
                                                                        else
                                                                                NextR.State <= invalidCard;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when waitstate =>
                                                                NextCmdTimeoutEnable <= cActivated;
 
                                                                if (NextCmdTimeout = cActivated) then
                                                                        NextR.CmdRegion <= ACMD41;
                                                                        NextR.Region    <= send;
                                                                end if;
 
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when ACMD41 =>
                                                oLedBank(2) <= cActivated;
 
                                                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);
                                                                NextR.ToSdCmd.Valid       <= cActivated;
                                                                if (iSdCmd.Ack = cActivated) then
                                                                        NextR.ToSdCmd.Valid <= cInactivated;
                                                                        NextR.Region <= receive;
                                                                end if;
 
                                                        when receive =>
                                                                oLedBank(0)     <= cActivated;
                                                                TimeoutEnable   <= cActivated;
                                                                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 =>
                                                                NextCmdTimeoutEnable <= cActivated;
 
                                                                if (NextCmdTimeout = cActivated) then
                                                                        NextR.CmdRegion <= CMD2;
                                                                        NextR.Region    <= send;
                                                                end if;
 
 
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when CMD2 =>
                                                oLedBank(3) <= cActivated;
 
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdAllSendCID;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
 
                                                                if (iSdCmd.Ack = cActivated) then
                                                                        NextR.ToSdCmd.Valid <= cInactivated;
                                                                        NextR.Region <= receive;
                                                                end if;
 
                                                        when receive =>
                                                                oLedBank(0)      <= cActivated;
                                                                NextR.ToSdCmd.ExpectCID <= cActivated;
                                                                TimeoutEnable    <= 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 =>
                                                                NextCmdTimeoutEnable <= cActivated;
 
                                                                if (NextCmdTimeout = cActivated) then
                                                                        NextR.CmdRegion <= CMD3;
                                                                        NextR.Region    <= send;
                                                                end if;
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when CMD3 =>
                                                oLedBank(4) <= cActivated;
 
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdSendRelAdr;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
 
                                                                if (iSdCmd.Ack = cActivated) then
                                                                        NextR.ToSdCmd.Valid <= cInactivated;
                                                                        NextR.Region <= receive;
                                                                end if;
 
                                                        when receive =>
                                                                oLedBank(0) <= cActivated;
                                                                TimeoutEnable    <= cActivated;
 
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSendRelAdr) then
                                                                                NextR.RCA <= iSdCmd.Content.arg(31 downto 16);
                                                                                NextR.State <= idle; -- config;
                                                                                NextR.CmdRegion <= SelectCard;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        when others =>
                                                                report "SdController: Unhandled state" severity error;
                                                end case;
 
                                        when others =>
                                                report "SdController: Unhandled state" severity error;
                                end case;
 
                        when config =>
                                oLedBank(5) <= cActivated;
 
                                case R.CmdRegion is
                                        when SelectCard =>
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdSelCard;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
 
                                                                if (iSdCmd.Ack = cActivated) then
                                                                        NextR.ToSdCmd.Valid <= cInactivated;
                                                                        NextR.Region <= receive;
                                                                end if;
 
                                                        when receive => -- Response R1b: with busy!
 
                                                        when waitstate =>
 
                                                        when others =>
                                                                report "Unhandled Region" severity error;
                                                end case;
 
                                        when others =>
                                                report "Unhandled CmdRegion" severity error;
                                end case;
 
                        when idle =>
                                oLedBank(6) <= cActivated;
 
                        when invalidCard =>
                                oLedBank(7) <= cActivated;
 
                        when others =>
                                report "SdController: Unhandled state" severity error;
                end case;
        end process Comb;
 
        TimeoutGenerator_inst: entity work.TimeoutGenerator
        generic map (
                gClkFrequency => 25E6,
                gTimeoutTime  => 100 ms
        )
        port map (
                iClk => iClk,
                inResetAsync => inResetAsync,
                iEnable => TimeoutEnable,
                oTimeout => Timeout);
 
        NextCmdTimeoutGenerator_inst: entity work.TimeoutGenerator
        generic map (
                gClkFrequency => 25E6,
                gTimeoutTime  => 1 sec / 25E6 * (8)
        )
        port map (
                iClk => iClk,
                inResetAsync => inResetAsync,
                iEnable => NextCmdTimeoutEnable,
                oTimeout => NextCmdTimeout);
 
end architecture Rtl;
 

Line No.	Rev	Author	Line
1	54	rkastl	`-------------------------------------------------`
2			`-- file: SdController-Rtl-ea.vhdl`
3			`-- author: Rainer Kastl`
4			`--`
5			`-- Main statemachine for a SDHC compatible SD Controller`
6			`-- Simplified Physical Layer Spec. 2.00`
7			`-------------------------------------------------`
8
9			`architecture Rtl of SdController is`
10
11	95	rkastl	`type aSdControllerState is (startup, init, config, idle, invalidCard);`
12			`type aCmdRegion is (CMD0, CMD8, CMD55, ACMD41, CMD2, CMD3, SelectCard);`
13	86	rkastl	`type aRegion is (send, receive, waitstate);`
14	84	rkastl
15	95	rkastl	`constant cDefaultToSdCmd : aSdCmdFromController := (`
16	84	rkastl	`(id => (others => '0'),`
17			`arg => (others => '0')),`
18			`Valid => cInactivated,`
19	89	rkastl	`ExpectCID => cInactivated,`
20			`CheckCrc => cActivated);`
21	54	rkastl
22	57	rkastl	`type aSdControllerReg is record`
23	88	rkastl	`State : aSdControllerState;`
24			`CmdRegion : aCmdRegion;`
25			`Region : aRegion;`
26			`HCS : std_ulogic;`
27			`CCS : std_ulogic;`
28			`RCA : aSdRCA;`
29			`CardStatus : aSdCardStatus;`
30	95	rkastl	`ToSdCmd : aSdCmdFromController;`
31			`ToSdData : aSdDataFromController;`
32	57	rkastl	`end record aSdControllerReg;`
33
34	84	rkastl	`constant cDefaultSdControllerReg : aSdControllerReg := (`
35	88	rkastl	`State => startup,`
36			`CmdRegion => CMD0,`
37			`Region => send,`
38			`HCS => cActivated,`
39			`CCS => cInactivated,`
40			`RCA => cDefaultRCA,`
41	95	rkastl	`CardStatus => cDefaultSdCardStatus,`
42			`ToSdCmd => cDefaultToSdCmd,`
43			`ToSdData => cDefaultSdDataFromController);`
44	57	rkastl
45	85	rkastl	`signal R, NextR : aSdControllerReg;`
46			`signal TimeoutEnable : std_ulogic;`
47			`signal Timeout : std_ulogic;`
48
49	94	rkastl	`signal NextCmdTimeout : std_ulogic;`
50			`signal NextCmdTimeoutEnable : std_ulogic;`
51
52	54	rkastl	`begin`
53
54	88	rkastl	`oSdRegisters.CardStatus <= R.CardStatus;`
55	95	rkastl	`oSdCmd <= R.ToSdCmd;`
56			`oSdData <= R.ToSdData;`
57	88	rkastl
58	54	rkastl	`Regs : process (iClk, inResetAsync)`
59			`begin`
60			`if (inResetAsync = cnActivated) then`
61	84	rkastl	`R <= cDefaultSdControllerReg;`
62	54	rkastl	`elsif (iClk'event and iClk = cActivated) then`
63	84	rkastl	`R <= NextR;`
64	54	rkastl	`end if;`
65			`end process Regs;`
66
67	94	rkastl	`Comb : process (iSdCmd, Timeout, NextCmdTimeout, R)`
68	60	rkastl	`variable ocr : aSdRegOCR;`
69			`variable arg : aSdCmdArg;`
70	54	rkastl	`begin`
71			`-- default assignments`
72	94	rkastl	`NextR <= R;`
73	95	rkastl	`NextR.ToSdCmd <= cDefaultToSdCmd;`
74	94	rkastl	`TimeoutEnable <= cInactivated;`
75			`NextCmdTimeoutEnable <= cInactivated;`
76	54	rkastl
77	70	rkastl	`-- Status`
78	75	rkastl	`oLedBank <= (others => cInactivated);`
79	70	rkastl
80	84	rkastl	`case R.State is`
81	85	rkastl	`when startup =>`
82			`TimeoutEnable <= cActivated;`
83
84			`if (Timeout = cActivated) then`
85	88	rkastl	`TimeoutEnable <= cInactivated;`
86	85	rkastl	`NextR.State <= init;`
87	88	rkastl	`end if;`
88	85	rkastl
89	84	rkastl	`when init =>`
90			`case R.CmdRegion is`
91			`when CMD0 =>`
92			`case R.Region is`
93			`when send =>`
94	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdGoIdleState;`
95			`NextR.ToSdCmd.Valid <= cActivated;`
96	54	rkastl
97	84	rkastl	`if (iSdCmd.Ack = cActivated) then`
98	95	rkastl	`NextR.ToSdCmd.Valid <= cInactivated;`
99			`NextR.Region <= waitstate;`
100			`NextR.CardStatus <= cDefaultSdCardStatus;`
101	85	rkastl	`end if;`
102
103	86	rkastl	`when waitstate =>`
104	94	rkastl	`NextCmdTimeoutEnable <= cActivated;`
105	85	rkastl
106	94	rkastl	`if (NextCmdTimeout = cActivated) then`
107			`NextCmdTimeoutEnable <= cInactivated;`
108	85	rkastl	`NextR.Region <= send;`
109	84	rkastl	`NextR.CmdRegion <= CMD8;`
110			`end if;`
111	85	rkastl
112	84	rkastl	`when others =>`
113			`report "SdController: Unhandled state" severity error;`
114			`end case;`
115	54	rkastl
116	84	rkastl	`when CMD8 =>`
117			`case R.Region is`
118			`when send =>`
119	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSendIfCond;`
120			`NextR.ToSdCmd.Content.arg <= cSdArgVoltage;`
121			`NextR.ToSdCmd.Valid <= cActivated;`
122	54	rkastl
123	84	rkastl	`if (iSdCmd.Ack = cActivated) then`
124	95	rkastl	`NextR.ToSdCmd.Valid <= cInactivated;`
125	84	rkastl	`NextR.Region <= receive;`
126			`end if;`
127	57	rkastl
128	84	rkastl	`when receive =>`
129			`oLedBank(0) <= cActivated;`
130	86	rkastl	`TimeoutEnable <= cActivated;`
131	57	rkastl
132	84	rkastl	`if (iSdCmd.Valid = cActivated) then`
133			`if (iSdCmd.Content.id = cSdCmdSendIfCond and iSdCmd.Content.arg = cSdArgVoltage) then`
134	86	rkastl	`NextR.Region <= waitstate;`
135			`NextR.HCS <= cActivated;`
136	54	rkastl
137	84	rkastl	`else`
138			`NextR.State <= invalidCard;`
139			`end if;`
140	86	rkastl	`elsif (Timeout = cActivated) then`
141			`NextR.HCS <= cInactivated;`
142			`NextR.CmdRegion <= CMD55;`
143			`NextR.Region <= send;`
144	84	rkastl	`end if;`
145	86	rkastl
146			`when waitstate =>`
147	94	rkastl	`NextCmdTimeoutEnable <= cActivated;`
148	86	rkastl
149	94	rkastl	`if (NextCmdTimeout = cActivated) then`
150			`NextCmdTimeoutEnable <= cInactivated;`
151			`NextR.CmdRegion <= CMD55;`
152			`NextR.Region <= send;`
153	86	rkastl	`end if;`
154
155	84	rkastl	`when others =>`
156			`report "SdController: Unhandled state" severity error;`
157			`end case;`
158	57	rkastl
159	84	rkastl	`when CMD55 =>`
160	86	rkastl	`oLedBank(1) <= cActivated;`
161
162	84	rkastl	`case R.Region is`
163			`when send =>`
164	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdNextIsACMD;`
165			`NextR.ToSdCmd.Content.arg <= cSdACMDArg;`
166			`NextR.ToSdCmd.Valid <= cActivated;`
167	57	rkastl
168	84	rkastl	`if (iSdCmd.Ack = cActivated) then`
169	95	rkastl	`NextR.ToSdCmd.Valid <= cInactivated;`
170	84	rkastl	`NextR.Region <= receive;`
171			`end if;`
172	57	rkastl
173	84	rkastl	`when receive =>`
174	90	rkastl	`oLedBank(0) <= cActivated;`
175			`TimeoutEnable <= cActivated;`
176	57	rkastl
177	84	rkastl	`if (iSdCmd.Valid = cActivated) then`
178			`if (iSdCmd.Content.id = cSdNextIsACMD) then`
179	88	rkastl	`NextR.CardStatus <= iSdCmd.Content.arg;`
180			`NextR.CmdRegion <= CMD55;`
181	62	rkastl
182	84	rkastl	`if (iSdCmd.Content.arg(cSdArgAppCmdPos) = cActivated) then`
183	88	rkastl	`NextR.Region <= waitstate;`
184			`else`
185			`NextR.Region <= send;`
186	84	rkastl	`end if;`
187			`else`
188			`NextR.State <= invalidCard;`
189			`end if;`
190	90	rkastl	`elsif (Timeout = cActivated) then`
191			`NextR.State <= invalidCard;`
192	84	rkastl	`end if;`
193	62	rkastl
194	86	rkastl	`when waitstate =>`
195	94	rkastl	`NextCmdTimeoutEnable <= cActivated;`
196	86	rkastl
197	94	rkastl	`if (NextCmdTimeout = cActivated) then`
198	86	rkastl	`NextR.CmdRegion <= ACMD41;`
199	88	rkastl	`NextR.Region <= send;`
200	86	rkastl	`end if;`
201
202	84	rkastl	`when others =>`
203			`report "SdController: Unhandled state" severity error;`
204			`end case;`
205	62	rkastl
206	84	rkastl	`when ACMD41 =>`
207			`oLedBank(2) <= cActivated;`
208
209			`case R.Region is`
210			`when send =>`
211	88	rkastl	`ocr.nBusy := '0';`
212	84	rkastl	`ocr.ccs := R.HCS;`
213			`ocr.voltagewindow := cVoltageWindow;`
214
215	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdACMD41;`
216			`NextR.ToSdCmd.Content.arg <= OCRToArg(ocr);`
217			`NextR.ToSdCmd.Valid <= cActivated;`
218	84	rkastl	`if (iSdCmd.Ack = cActivated) then`
219	95	rkastl	`NextR.ToSdCmd.Valid <= cInactivated;`
220	84	rkastl	`NextR.Region <= receive;`
221			`end if;`
222	60	rkastl
223	84	rkastl	`when receive =>`
224	89	rkastl	`oLedBank(0) <= cActivated;`
225	90	rkastl	`TimeoutEnable <= cActivated;`
226	95	rkastl	`NextR.ToSdCmd.CheckCrc <= cInactivated;`
227	63	rkastl
228	84	rkastl	`if (iSdCmd.Valid = cActivated) then`
229	90	rkastl	`NextR.CmdRegion <= CMD8;`
230			`NextR.Region <= waitstate;`
231	84	rkastl
232			`if (iSdCmd.Content.id = cSdR3Id) then`
233			`ocr := ArgToOcr(iSdCmd.Content.arg);`
234
235			`if (ocr.nBusy = cnInactivated) then`
236			`if (ocr.voltagewindow /= cVoltageWindow) then`
237			`NextR.State <= invalidCard;`
238			`else`
239			`NextR.CCS <= ocr.ccs;`
240	89	rkastl	`NextR.CmdRegion <= ACMD41;`
241			`NextR.Region <= waitstate;`
242	84	rkastl	`end if;`
243			`end if;`
244			`end if;`
245	86	rkastl	`elsif (Timeout = cActivated) then`
246	89	rkastl	`NextR.State <= invalidCard;`
247			`end if;`
248
249			`when waitstate =>`
250	94	rkastl	`NextCmdTimeoutEnable <= cActivated;`
251	89	rkastl
252	94	rkastl	`if (NextCmdTimeout = cActivated) then`
253	89	rkastl	`NextR.CmdRegion <= CMD2;`
254	86	rkastl	`NextR.Region <= send;`
255	84	rkastl	`end if;`
256
257	89	rkastl
258	84	rkastl	`when others =>`
259			`report "SdController: Unhandled state" severity error;`
260			`end case;`
261
262			`when CMD2 =>`
263			`oLedBank(3) <= cActivated;`
264
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			`if (iSdCmd.Ack = cActivated) then`
271	95	rkastl	`NextR.ToSdCmd.Valid <= cInactivated;`
272	84	rkastl	`NextR.Region <= receive;`
273			`end if;`
274
275			`when receive =>`
276			`oLedBank(0) <= cActivated;`
277	95	rkastl	`NextR.ToSdCmd.ExpectCID <= cActivated;`
278	90	rkastl	`TimeoutEnable <= cActivated;`
279	84	rkastl
280			`if (iSdCmd.Valid = cActivated) then`
281			`NextR.State <= invalidCard;`
282
283			`if (iSdCmd.Content.id = cSdR2Id) then`
284			`NextR.State <= init;`
285	89	rkastl	`NextR.Region <= waitstate;`
286	84	rkastl	`end if;`
287	90	rkastl	`elsif (Timeout = cActivated) then`
288			`NextR.State <= invalidCard;`
289	84	rkastl	`end if;`
290	89	rkastl
291			`when waitstate =>`
292	94	rkastl	`NextCmdTimeoutEnable <= cActivated;`
293	84	rkastl
294	94	rkastl	`if (NextCmdTimeout = cActivated) then`
295	89	rkastl	`NextR.CmdRegion <= CMD3;`
296			`NextR.Region <= send;`
297			`end if;`
298	84	rkastl	`when others =>`
299			`report "SdController: Unhandled state" severity error;`
300			`end case;`
301
302			`when CMD3 =>`
303			`oLedBank(4) <= cActivated;`
304
305			`case R.Region is`
306			`when send =>`
307	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSendRelAdr;`
308			`NextR.ToSdCmd.Valid <= cActivated;`
309	84	rkastl
310			`if (iSdCmd.Ack = cActivated) then`
311	95	rkastl	`NextR.ToSdCmd.Valid <= cInactivated;`
312	84	rkastl	`NextR.Region <= receive;`
313			`end if;`
314
315			`when receive =>`
316			`oLedBank(0) <= cActivated;`
317	90	rkastl	`TimeoutEnable <= cActivated;`
318	84	rkastl
319			`if (iSdCmd.Valid = cActivated) then`
320			`if (iSdCmd.Content.id = cSdCmdSendRelAdr) then`
321			`NextR.RCA <= iSdCmd.Content.arg(31 downto 16);`
322	95	rkastl	`NextR.State <= idle; -- config;`
323			`NextR.CmdRegion <= SelectCard;`
324	84	rkastl	`end if;`
325	90	rkastl	`elsif (Timeout = cActivated) then`
326			`NextR.State <= invalidCard;`
327	84	rkastl	`end if;`
328
329			`when others =>`
330			`report "SdController: Unhandled state" severity error;`
331			`end case;`
332
333			`when others =>`
334			`report "SdController: Unhandled state" severity error;`
335			`end case;`
336
337	95	rkastl	`when config =>`
338			`oLedBank(5) <= cActivated;`
339
340			`case R.CmdRegion is`
341			`when SelectCard =>`
342			`case R.Region is`
343			`when send =>`
344			`NextR.ToSdCmd.Content.id <= cSdCmdSelCard;`
345			`NextR.ToSdCmd.Valid <= cActivated;`
346
347			`if (iSdCmd.Ack = cActivated) then`
348			`NextR.ToSdCmd.Valid <= cInactivated;`
349			`NextR.Region <= receive;`
350			`end if;`
351
352			`when receive => -- Response R1b: with busy!`
353
354			`when waitstate =>`
355
356			`when others =>`
357			`report "Unhandled Region" severity error;`
358			`end case;`
359
360			`when others =>`
361			`report "Unhandled CmdRegion" severity error;`
362			`end case;`
363
364	84	rkastl	`when idle =>`
365			`oLedBank(6) <= cActivated;`
366
367			`when invalidCard =>`
368			`oLedBank(7) <= cActivated;`
369
370	54	rkastl	`when others =>`
371	84	rkastl	`report "SdController: Unhandled state" severity error;`
372	54	rkastl	`end case;`
373			`end process Comb;`
374	85	rkastl
375			`TimeoutGenerator_inst: entity work.TimeoutGenerator`
376			`generic map (`
377			`gClkFrequency => 25E6,`
378	94	rkastl	`gTimeoutTime => 100 ms`
379	85	rkastl	`)`
380			`port map (`
381			`iClk => iClk,`
382			`inResetAsync => inResetAsync,`
383			`iEnable => TimeoutEnable,`
384			`oTimeout => Timeout);`
385
386	94	rkastl	`NextCmdTimeoutGenerator_inst: entity work.TimeoutGenerator`
387			`generic map (`
388			`gClkFrequency => 25E6,`
389	95	rkastl	`gTimeoutTime => 1 sec / 25E6 * (8)`
390	94	rkastl	`)`
391			`port map (`
392			`iClk => iClk,`
393			`inResetAsync => inResetAsync,`
394			`iEnable => NextCmdTimeoutEnable,`
395			`oTimeout => NextCmdTimeout);`
396
397	54	rkastl	`end architecture Rtl;`
398

Browse

Tools

Subversion Repositories sdhc-sc-core

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