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 96

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 (idle, 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     => idle,
        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;
                variable NextRegion    : aRegion;
                variable NextCmdRegion : aCmdRegion;
                variable NextState     : aSdControllerState;
        begin
                -- default assignments
                NextR                <= R;
                NextR.ToSdCmd        <= cDefaultToSdCmd;
                TimeoutEnable        <= cInactivated;
                NextCmdTimeoutEnable <= cInactivated;
 
                -- variables
                NextRegion    := R.Region;
                NextCmdRegion := R.CmdRegion;
                NextState     := R.State;
 
                -- Status
                oLedBank <= (others => cInactivated);
 
                case R.State is
                        when startup =>
                                TimeoutEnable <= cActivated;
 
                                if (Timeout = cActivated) then
                                        TimeoutEnable <= cInactivated;
                                        NextR.State   <= init;
                                        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                := receive;
 
                                                        when receive =>
                                                                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 =>
                                                                NextCmdRegion      := CMD55;
                                                                NextRegion         := send;
 
                                                        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;
                                                                NextRegion                := receive;
 
                                                        when receive =>
                                                                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 =>
                                                                NextCmdRegion := ACMD41;
                                                                NextRegion    := send;
 
                                                        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);
                                                                NextRegion                := receive;
 
                                                        when receive =>
                                                                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;
 
                                        when CMD2 =>
                                                oLedBank(3) <= cActivated;
 
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdAllSendCID;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
 
                                                                NextRegion := receive;
 
                                                        when receive =>
                                                                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 =>
                                                oLedBank(4) <= cActivated;
 
                                                case R.Region is
                                                        when send =>
                                                                NextR.ToSdCmd.Content.id <= cSdCmdSendRelAdr;
                                                                NextR.ToSdCmd.Valid      <= cActivated;
 
                                                                NextRegion := receive;
 
                                                        when receive =>
                                                                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 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.Content.arg <= R.RCA & X"0000";
 
                                                                NextRegion := receive;
 
                                                        when receive => -- Response R1b: with busy!
                                                                if (iSdCmd.Valid = cActivated) then
                                                                        if (iSdCmd.Content.id = cSdCmdSelCard) then
                                                                                NextR.CardStatus <= iSdCmd.Content.arg;
                                                                                NextR.State      <= idle;
                                                                        end if;
                                                                elsif (Timeout = cActivated) then
                                                                        NextR.State <= invalidCard;
                                                                end if;
 
                                                        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;
 
                case R.Region is
                        when idle => -- do nothing
                                null;
 
                        when send =>
                                NextR.ToSdCmd.Valid <= cActivated;
 
                                if (iSdCmd.Ack = cActivated) then
                                        NextR.ToSdCmd.Valid <= cInactivated;
                                        NextR.Region        <= NextRegion;
                                end if;
 
                        when receive =>
                                oLedBank(0)   <= cActivated;
                                TimeoutEnable <= cActivated;
 
                        when waitstate =>
                                NextCmdTimeoutEnable <= cActivated;
 
                                if (NextCmdTimeout = cActivated) then
                                        NextCmdTimeoutEnable <= cInactivated;
                                        NextR.Region         <= NextRegion;
                                        NextR.CmdRegion      <= NextCmdRegion;
                                        NextR.State                      <= NextState;
                                end if;
 
                        when others =>
                                report "Unhandled region" 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  => 600 us--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	96	rkastl	`type aRegion is (idle, 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	96	rkastl	`Region => idle,`
38	88	rkastl	`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	96	rkastl	`variable ocr : aSdRegOCR;`
69			`variable arg : aSdCmdArg;`
70			`variable NextRegion : aRegion;`
71			`variable NextCmdRegion : aCmdRegion;`
72			`variable NextState : aSdControllerState;`
73	54	rkastl	`begin`
74			`-- default assignments`
75	94	rkastl	`NextR <= R;`
76	95	rkastl	`NextR.ToSdCmd <= cDefaultToSdCmd;`
77	94	rkastl	`TimeoutEnable <= cInactivated;`
78			`NextCmdTimeoutEnable <= cInactivated;`
79	54	rkastl
80	96	rkastl	`-- variables`
81			`NextRegion := R.Region;`
82			`NextCmdRegion := R.CmdRegion;`
83			`NextState := R.State;`
84
85	70	rkastl	`-- Status`
86	75	rkastl	`oLedBank <= (others => cInactivated);`
87	70	rkastl
88	84	rkastl	`case R.State is`
89	85	rkastl	`when startup =>`
90			`TimeoutEnable <= cActivated;`
91
92			`if (Timeout = cActivated) then`
93	88	rkastl	`TimeoutEnable <= cInactivated;`
94	96	rkastl	`NextR.State <= init;`
95			`NextR.Region <= send;`
96	88	rkastl	`end if;`
97	85	rkastl
98	84	rkastl	`when init =>`
99			`case R.CmdRegion is`
100			`when CMD0 =>`
101			`case R.Region is`
102			`when send =>`
103	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdGoIdleState;`
104	96	rkastl	`NextR.CardStatus <= cDefaultSdCardStatus;`
105			`NextRegion := waitstate;`
106	54	rkastl
107	86	rkastl	`when waitstate =>`
108	96	rkastl	`NextRegion := send;`
109			`NextCmdRegion := CMD8;`
110	85	rkastl
111	84	rkastl	`when others =>`
112			`report "SdController: Unhandled state" severity error;`
113			`end case;`
114	54	rkastl
115	84	rkastl	`when CMD8 =>`
116			`case R.Region is`
117			`when send =>`
118	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSendIfCond;`
119			`NextR.ToSdCmd.Content.arg <= cSdArgVoltage;`
120	96	rkastl	`NextRegion := receive;`
121	54	rkastl
122	84	rkastl	`when receive =>`
123			`if (iSdCmd.Valid = cActivated) then`
124			`if (iSdCmd.Content.id = cSdCmdSendIfCond and iSdCmd.Content.arg = cSdArgVoltage) then`
125	86	rkastl	`NextR.Region <= waitstate;`
126			`NextR.HCS <= cActivated;`
127	54	rkastl
128	84	rkastl	`else`
129			`NextR.State <= invalidCard;`
130			`end if;`
131	86	rkastl	`elsif (Timeout = cActivated) then`
132			`NextR.HCS <= cInactivated;`
133			`NextR.CmdRegion <= CMD55;`
134			`NextR.Region <= send;`
135	84	rkastl	`end if;`
136	86	rkastl
137			`when waitstate =>`
138	96	rkastl	`NextCmdRegion := CMD55;`
139			`NextRegion := send;`
140	86	rkastl
141	84	rkastl	`when others =>`
142			`report "SdController: Unhandled state" severity error;`
143			`end case;`
144	57	rkastl
145	84	rkastl	`when CMD55 =>`
146	86	rkastl	`oLedBank(1) <= cActivated;`
147
148	84	rkastl	`case R.Region is`
149			`when send =>`
150	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdNextIsACMD;`
151			`NextR.ToSdCmd.Content.arg <= cSdACMDArg;`
152	96	rkastl	`NextRegion := receive;`
153	57	rkastl
154	84	rkastl	`when receive =>`
155			`if (iSdCmd.Valid = cActivated) then`
156			`if (iSdCmd.Content.id = cSdNextIsACMD) then`
157	88	rkastl	`NextR.CardStatus <= iSdCmd.Content.arg;`
158			`NextR.CmdRegion <= CMD55;`
159	62	rkastl
160	84	rkastl	`if (iSdCmd.Content.arg(cSdArgAppCmdPos) = cActivated) then`
161	88	rkastl	`NextR.Region <= waitstate;`
162			`else`
163			`NextR.Region <= send;`
164	84	rkastl	`end if;`
165			`else`
166			`NextR.State <= invalidCard;`
167			`end if;`
168	90	rkastl	`elsif (Timeout = cActivated) then`
169			`NextR.State <= invalidCard;`
170	84	rkastl	`end if;`
171	62	rkastl
172	86	rkastl	`when waitstate =>`
173	96	rkastl	`NextCmdRegion := ACMD41;`
174			`NextRegion := send;`
175	86	rkastl
176	84	rkastl	`when others =>`
177			`report "SdController: Unhandled state" severity error;`
178			`end case;`
179	62	rkastl
180	84	rkastl	`when ACMD41 =>`
181			`oLedBank(2) <= cActivated;`
182
183			`case R.Region is`
184			`when send =>`
185	88	rkastl	`ocr.nBusy := '0';`
186	84	rkastl	`ocr.ccs := R.HCS;`
187			`ocr.voltagewindow := cVoltageWindow;`
188
189	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdACMD41;`
190			`NextR.ToSdCmd.Content.arg <= OCRToArg(ocr);`
191	96	rkastl	`NextRegion := receive;`
192	60	rkastl
193	84	rkastl	`when receive =>`
194	95	rkastl	`NextR.ToSdCmd.CheckCrc <= cInactivated;`
195	63	rkastl
196	84	rkastl	`if (iSdCmd.Valid = cActivated) then`
197	90	rkastl	`NextR.CmdRegion <= CMD8;`
198			`NextR.Region <= waitstate;`
199	84	rkastl
200			`if (iSdCmd.Content.id = cSdR3Id) then`
201			`ocr := ArgToOcr(iSdCmd.Content.arg);`
202
203			`if (ocr.nBusy = cnInactivated) then`
204			`if (ocr.voltagewindow /= cVoltageWindow) then`
205			`NextR.State <= invalidCard;`
206			`else`
207			`NextR.CCS <= ocr.ccs;`
208	89	rkastl	`NextR.CmdRegion <= ACMD41;`
209			`NextR.Region <= waitstate;`
210	84	rkastl	`end if;`
211			`end if;`
212			`end if;`
213	86	rkastl	`elsif (Timeout = cActivated) then`
214	89	rkastl	`NextR.State <= invalidCard;`
215			`end if;`
216
217			`when waitstate =>`
218	96	rkastl	`NextCmdRegion := CMD2;`
219			`NextRegion := send;`
220	89	rkastl
221	84	rkastl
222			`when others =>`
223			`report "SdController: Unhandled state" severity error;`
224			`end case;`
225
226			`when CMD2 =>`
227			`oLedBank(3) <= cActivated;`
228
229			`case R.Region is`
230			`when send =>`
231	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdAllSendCID;`
232			`NextR.ToSdCmd.Valid <= cActivated;`
233	84	rkastl
234	96	rkastl	`NextRegion := receive;`
235	84	rkastl
236			`when receive =>`
237	95	rkastl	`NextR.ToSdCmd.ExpectCID <= cActivated;`
238	84	rkastl
239			`if (iSdCmd.Valid = cActivated) then`
240			`NextR.State <= invalidCard;`
241
242			`if (iSdCmd.Content.id = cSdR2Id) then`
243			`NextR.State <= init;`
244	89	rkastl	`NextR.Region <= waitstate;`
245	84	rkastl	`end if;`
246	90	rkastl	`elsif (Timeout = cActivated) then`
247			`NextR.State <= invalidCard;`
248	84	rkastl	`end if;`
249	89	rkastl
250			`when waitstate =>`
251	96	rkastl	`NextCmdRegion := CMD3;`
252			`NextRegion := send;`
253	84	rkastl
254			`when others =>`
255			`report "SdController: Unhandled state" severity error;`
256			`end case;`
257
258			`when CMD3 =>`
259			`oLedBank(4) <= cActivated;`
260
261			`case R.Region is`
262			`when send =>`
263	95	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSendRelAdr;`
264			`NextR.ToSdCmd.Valid <= cActivated;`
265	84	rkastl
266	96	rkastl	`NextRegion := receive;`
267	84	rkastl
268			`when receive =>`
269			`if (iSdCmd.Valid = cActivated) then`
270			`if (iSdCmd.Content.id = cSdCmdSendRelAdr) then`
271	96	rkastl	`NextR.RCA <= iSdCmd.Content.arg(31 downto 16);`
272			`NextR.Region <= waitstate;`
273	84	rkastl	`end if;`
274	90	rkastl	`elsif (Timeout = cActivated) then`
275			`NextR.State <= invalidCard;`
276	84	rkastl	`end if;`
277
278	96	rkastl	`when waitstate =>`
279			`NextState := config;`
280			`NextCmdRegion := SelectCard;`
281			`NextRegion := send;`
282
283	84	rkastl	`when others =>`
284			`report "SdController: Unhandled state" severity error;`
285			`end case;`
286
287			`when others =>`
288			`report "SdController: Unhandled state" severity error;`
289			`end case;`
290
291	95	rkastl	`when config =>`
292			`oLedBank(5) <= cActivated;`
293
294			`case R.CmdRegion is`
295			`when SelectCard =>`
296			`case R.Region is`
297			`when send =>`
298	96	rkastl	`NextR.ToSdCmd.Content.id <= cSdCmdSelCard;`
299			`NextR.ToSdCmd.Content.arg <= R.RCA & X"0000";`
300	95	rkastl
301	96	rkastl	`NextRegion := receive;`
302	95	rkastl
303			`when receive => -- Response R1b: with busy!`
304	96	rkastl	`if (iSdCmd.Valid = cActivated) then`
305			`if (iSdCmd.Content.id = cSdCmdSelCard) then`
306			`NextR.CardStatus <= iSdCmd.Content.arg;`
307			`NextR.State <= idle;`
308			`end if;`
309			`elsif (Timeout = cActivated) then`
310			`NextR.State <= invalidCard;`
311			`end if;`
312	95	rkastl
313			`when waitstate =>`
314
315			`when others =>`
316			`report "Unhandled Region" severity error;`
317			`end case;`
318
319			`when others =>`
320			`report "Unhandled CmdRegion" severity error;`
321			`end case;`
322
323	84	rkastl	`when idle =>`
324			`oLedBank(6) <= cActivated;`
325
326			`when invalidCard =>`
327			`oLedBank(7) <= cActivated;`
328
329	54	rkastl	`when others =>`
330	84	rkastl	`report "SdController: Unhandled state" severity error;`
331	54	rkastl	`end case;`
332	96	rkastl
333			`case R.Region is`
334			`when idle => -- do nothing`
335			`null;`
336
337			`when send =>`
338			`NextR.ToSdCmd.Valid <= cActivated;`
339
340			`if (iSdCmd.Ack = cActivated) then`
341			`NextR.ToSdCmd.Valid <= cInactivated;`
342			`NextR.Region <= NextRegion;`
343			`end if;`
344
345			`when receive =>`
346			`oLedBank(0) <= cActivated;`
347			`TimeoutEnable <= cActivated;`
348
349			`when waitstate =>`
350			`NextCmdTimeoutEnable <= cActivated;`
351
352			`if (NextCmdTimeout = cActivated) then`
353			`NextCmdTimeoutEnable <= cInactivated;`
354			`NextR.Region <= NextRegion;`
355			`NextR.CmdRegion <= NextCmdRegion;`
356			`NextR.State <= NextState;`
357			`end if;`
358
359			`when others =>`
360			`report "Unhandled region" severity error;`
361			`end case;`
362	54	rkastl	`end process Comb;`
363	85	rkastl
364			`TimeoutGenerator_inst: entity work.TimeoutGenerator`
365			`generic map (`
366			`gClkFrequency => 25E6,`
367	94	rkastl	`gTimeoutTime => 100 ms`
368	85	rkastl	`)`
369			`port map (`
370			`iClk => iClk,`
371			`inResetAsync => inResetAsync,`
372			`iEnable => TimeoutEnable,`
373			`oTimeout => Timeout);`
374
375	94	rkastl	`NextCmdTimeoutGenerator_inst: entity work.TimeoutGenerator`
376			`generic map (`
377			`gClkFrequency => 25E6,`
378	96	rkastl	`gTimeoutTime => 600 us--1 sec / 25E6 * (8)`
379	94	rkastl	`)`
380			`port map (`
381			`iClk => iClk,`
382			`inResetAsync => inResetAsync,`
383			`iEnable => NextCmdTimeoutEnable,`
384			`oTimeout => NextCmdTimeout);`
385
386	54	rkastl	`end architecture Rtl;`
387

Browse

Tools

Subversion Repositories sdhc-sc-core

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