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 66

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
-------------------------------------------------
 
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.Global.all;
use work.Sd.all;
 
entity SdController is
        port (
                iClk : in std_ulogic; -- rising edge
                inResetAsync : in std_ulogic;
 
                -- SDCmd
                iSdCmd : in aSdCmdToController;
                oSdCmd : out aSdCmdFromController
        );
end entity SdController;
 
architecture Rtl of SdController is
 
        type aSdControllerState is (CMD0, CMD8Ws, CMD8, CMD8Response, CMD55,
        CMD55Response, ACMD41, ACMD41Response, CMD2, CMD2Response, CMD3,
        CMD3Response, idle, invalidCard);
        constant cDefaultControllerState : aSdControllerState := CMD0;
        constant cDefaultoSdCmd : aSdCmdFromController := ((id => (others => '0'),
        arg => (others => '0')), Valid => cInactivated, ExpectCID => cInactivated);
 
        type aSdControllerReg is record
                HCS : std_ulogic;
                CCS : std_ulogic;
                RCA : aSdRCA;
        end record aSdControllerReg;
        constant cDefaultSdControllerReg : aSdControllerReg := (cActivated,
        cInactivated, cDefaultRCA);
 
        signal Reg, NextReg : aSdControllerReg;
 
        signal State, NextState : aSdControllerState;
 
begin
 
        Regs : process (iClk, inResetAsync)
        begin
                if (inResetAsync = cnActivated) then
                        State <= cDefaultControllerState;
                        Reg <= cDefaultSdControllerReg;
                elsif (iClk'event and iClk = cActivated) then
                        Reg <= NextReg;
                        State <= NextState;
                end if;
        end process Regs;
 
        Comb : process (iSdCmd, State, Reg)
                variable ocr : aSdRegOCR;
                variable arg : aSdCmdArg;
        begin
                -- default assignments
                oSdCmd <= cDefaultoSdCmd;
                NextReg <= Reg;
                NextState <= State;
 
                case State is
                        when idle => null;
 
                        when CMD0 =>
                                oSdCmd.Content.id <= cSdCmdGoIdleState;
                                oSdCmd.Valid <= cActivated;
                                if (iSdCmd.Ack = cActivated) then
                                        NextState <= CMD8Ws;
                                end if;
 
                        when CMD8Ws =>
                                if (iSdCmd.Ack = cInactivated) then
                                        NextState <= CMD8;
                                end if;
 
                        when CMD8 =>
                                oSdCmd.Content.id <= cSdCmdSendIfCond;
                                oSdCmd.Content.arg <= cSdArgVoltage;
                                oSdCmd.Valid <= cActivated;
                                if (iSdCmd.Ack = cActivated) then
                                        NextState <= CMD8Response;
                                end if;
 
                        when CMD8Response =>
                                if (iSdCmd.Valid = cActivated) then
                                        if (iSdCmd.Content.id = cSdCmdSendIfCond and
                                        iSdCmd.Content.arg = cSdArgVoltage) then
                                                NextReg.HCS <= cActivated;
                                                NextState <= CMD55;
                                        else
                                                NextState <= invalidCard;
                                        end if;
                                -- elsif timeout
                                end if;
 
                        when invalidCard =>
                                null;
 
                        when CMD55 =>
                                oSdCmd.Content.id <= cSdNextIsACMD;
                                oSdCmd.Content.arg <= cSdACMDArg;
                                oSdCmd.Valid <= cActivated;
                                if (iSdCmd.Ack = cActivated) then
                                        NextState <= CMD55Response;
                                end if;
 
                        when CMD55Response =>
                                if (iSdCmd.Valid = cActivated) then
                                        NextState <= invalidCard;
                                        if (iSdCmd.Content.id = cSdNextIsACMD) then
                                                if (iSdCmd.Content.arg(cSdArgAppCmdPos) = cActivated)
                                                then
                                                        NextState <= ACMD41;
                                                end if;
                                        end if;
                                -- elsif timeout
                                end if;
 
                        when ACMD41 =>
                                oSdCmd.Content.id <= cSdCmdACMD41;
                                ocr.nBusy := cnActivated;
                                ocr.ccs := Reg.HCS;
                                ocr.voltagewindow := cVoltageWindow;
                                oSdCmd.Content.arg <= OCRToArg(ocr);
                                oSdCmd.Valid <= cActivated;
                                if (iSdCmd.Ack = cActivated) then
                                        NextState <= ACMD41Response;
                                end if;
 
                        when ACMD41Response =>
                                if (iSdCmd.Valid = cActivated) then
                                        NextState <= CMD55;
                                        if (iSdCmd.Content.id = cSdR3Id) then
                                                ocr := ArgToOcr(iSdCmd.Content.arg);
                                                if (ocr.nBusy = cnInactivated) then
                                                        if (ocr.voltagewindow /= cVoltageWindow) then
                                                                NextState <= invalidCard;
                                                        else
                                                                NextReg.CCS <= ocr.ccs;
                                                                NextState <= CMD2;
                                                        end if;
                                                end if;
                                        end if;
                                end if;
 
                        when CMD2 =>
                                oSdCmd.Content.id <= cSdCmdAllSendCID;
                                oSdCmd.Valid <= cActivated;
                                if (iSdCmd.Ack = cActivated) then
                                        NextState <= CMD2Response;
                                end if;
 
                        when CMD2Response =>
                                oSdCmd.ExpectCID <= cActivated;
 
                                if (iSdCmd.Valid = cActivated) then
                                        NextState <= invalidCard;
 
                                        if (iSdCmd.Content.id = cSdR2Id) then
                                                NextState <= CMD3;
                                        end if;
                                end if;
 
                        when CMD3 =>
                                oSdCmd.Content.id <= cSdCmdSendRelAdr;
                                oSdCmd.Valid <= cActivated;
                                if (iSdCmd.Ack = cActivated) then
                                        NextState <= CMD3Response;
                                end if;
 
                        when CMD3Response =>
                                if (iSdCmd.Valid = cActivated) then
                                        if (iSdCmd.Content.id = cSdCmdSendRelAdr) then
                                                -- todo: check status
                                                NextReg.RCA <= iSdCmd.Content.arg(31 downto 16);
                                                NextState <= idle;
                                        end if;
                                end if;
 
                        when others =>
                                report "SdController: State not handled" severity error;
                end case;
        end process Comb;
 
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			`library ieee;`
10			`use ieee.std_logic_1164.all;`
11			`use ieee.numeric_std.all;`
12			`use work.Global.all;`
13			`use work.Sd.all;`
14
15			`entity SdController is`
16			`port (`
17			`iClk : in std_ulogic; -- rising edge`
18			`inResetAsync : in std_ulogic;`
19
20			`-- SDCmd`
21			`iSdCmd : in aSdCmdToController;`
22			`oSdCmd : out aSdCmdFromController`
23			`);`
24			`end entity SdController;`
25
26			`architecture Rtl of SdController is`
27
28	57	rkastl	`type aSdControllerState is (CMD0, CMD8Ws, CMD8, CMD8Response, CMD55,`
29	62	rkastl	`CMD55Response, ACMD41, ACMD41Response, CMD2, CMD2Response, CMD3,`
30			`CMD3Response, idle, invalidCard);`
31	54	rkastl	`constant cDefaultControllerState : aSdControllerState := CMD0;`
32			`constant cDefaultoSdCmd : aSdCmdFromController := ((id => (others => '0'),`
33	62	rkastl	`arg => (others => '0')), Valid => cInactivated, ExpectCID => cInactivated);`
34	54	rkastl
35	57	rkastl	`type aSdControllerReg is record`
36			`HCS : std_ulogic;`
37			`CCS : std_ulogic;`
38	63	rkastl	`RCA : aSdRCA;`
39	57	rkastl	`end record aSdControllerReg;`
40			`constant cDefaultSdControllerReg : aSdControllerReg := (cActivated,`
41	63	rkastl	`cInactivated, cDefaultRCA);`
42	57	rkastl
43			`signal Reg, NextReg : aSdControllerReg;`
44
45	54	rkastl	`signal State, NextState : aSdControllerState;`
46
47			`begin`
48
49			`Regs : process (iClk, inResetAsync)`
50			`begin`
51			`if (inResetAsync = cnActivated) then`
52			`State <= cDefaultControllerState;`
53	57	rkastl	`Reg <= cDefaultSdControllerReg;`
54	54	rkastl	`elsif (iClk'event and iClk = cActivated) then`
55	57	rkastl	`Reg <= NextReg;`
56	54	rkastl	`State <= NextState;`
57			`end if;`
58			`end process Regs;`
59
60	57	rkastl	`Comb : process (iSdCmd, State, Reg)`
61	60	rkastl	`variable ocr : aSdRegOCR;`
62			`variable arg : aSdCmdArg;`
63	54	rkastl	`begin`
64			`-- default assignments`
65			`oSdCmd <= cDefaultoSdCmd;`
66	57	rkastl	`NextReg <= Reg;`
67	66	rkastl	`NextState <= State;`
68	54	rkastl
69			`case State is`
70			`when idle => null;`
71
72			`when CMD0 =>`
73			`oSdCmd.Content.id <= cSdCmdGoIdleState;`
74			`oSdCmd.Valid <= cActivated;`
75			`if (iSdCmd.Ack = cActivated) then`
76			`NextState <= CMD8Ws;`
77			`end if;`
78
79			`when CMD8Ws =>`
80			`if (iSdCmd.Ack = cInactivated) then`
81			`NextState <= CMD8;`
82			`end if;`
83
84			`when CMD8 =>`
85			`oSdCmd.Content.id <= cSdCmdSendIfCond;`
86			`oSdCmd.Content.arg <= cSdArgVoltage;`
87			`oSdCmd.Valid <= cActivated;`
88			`if (iSdCmd.Ack = cActivated) then`
89			`NextState <= CMD8Response;`
90			`end if;`
91	57	rkastl
92	54	rkastl	`when CMD8Response =>`
93	57	rkastl	`if (iSdCmd.Valid = cActivated) then`
94			`if (iSdCmd.Content.id = cSdCmdSendIfCond and`
95			`iSdCmd.Content.arg = cSdArgVoltage) then`
96			`NextReg.HCS <= cActivated;`
97			`NextState <= CMD55;`
98			`else`
99			`NextState <= invalidCard;`
100			`end if;`
101			`-- elsif timeout`
102			`end if;`
103
104			`when invalidCard =>`
105	54	rkastl	`null;`
106
107	57	rkastl	`when CMD55 =>`
108			`oSdCmd.Content.id <= cSdNextIsACMD;`
109			`oSdCmd.Content.arg <= cSdACMDArg;`
110			`oSdCmd.Valid <= cActivated;`
111			`if (iSdCmd.Ack = cActivated) then`
112			`NextState <= CMD55Response;`
113			`end if;`
114
115			`when CMD55Response =>`
116			`if (iSdCmd.Valid = cActivated) then`
117			`NextState <= invalidCard;`
118			`if (iSdCmd.Content.id = cSdNextIsACMD) then`
119			`if (iSdCmd.Content.arg(cSdArgAppCmdPos) = cActivated)`
120			`then`
121			`NextState <= ACMD41;`
122			`end if;`
123			`end if;`
124			`-- elsif timeout`
125			`end if;`
126
127			`when ACMD41 =>`
128			`oSdCmd.Content.id <= cSdCmdACMD41;`
129	60	rkastl	`ocr.nBusy := cnActivated;`
130			`ocr.ccs := Reg.HCS;`
131			`ocr.voltagewindow := cVoltageWindow;`
132			`oSdCmd.Content.arg <= OCRToArg(ocr);`
133	57	rkastl	`oSdCmd.Valid <= cActivated;`
134			`if (iSdCmd.Ack = cActivated) then`
135			`NextState <= ACMD41Response;`
136			`end if;`
137
138			`when ACMD41Response =>`
139	60	rkastl	`if (iSdCmd.Valid = cActivated) then`
140			`NextState <= CMD55;`
141			`if (iSdCmd.Content.id = cSdR3Id) then`
142			`ocr := ArgToOcr(iSdCmd.Content.arg);`
143			`if (ocr.nBusy = cnInactivated) then`
144	64	rkastl	`if (ocr.voltagewindow /= cVoltageWindow) then`
145			`NextState <= invalidCard;`
146			`else`
147			`NextReg.CCS <= ocr.ccs;`
148			`NextState <= CMD2;`
149			`end if;`
150	60	rkastl	`end if;`
151			`end if;`
152			`end if;`
153	57	rkastl
154	60	rkastl	`when CMD2 =>`
155	62	rkastl	`oSdCmd.Content.id <= cSdCmdAllSendCID;`
156			`oSdCmd.Valid <= cActivated;`
157			`if (iSdCmd.Ack = cActivated) then`
158			`NextState <= CMD2Response;`
159			`end if;`
160
161			`when CMD2Response =>`
162			`oSdCmd.ExpectCID <= cActivated;`
163
164			`if (iSdCmd.Valid = cActivated) then`
165			`NextState <= invalidCard;`
166
167	64	rkastl	`if (iSdCmd.Content.id = cSdR2Id) then`
168	62	rkastl	`NextState <= CMD3;`
169			`end if;`
170			`end if;`
171
172			`when CMD3 =>`
173	63	rkastl	`oSdCmd.Content.id <= cSdCmdSendRelAdr;`
174			`oSdCmd.Valid <= cActivated;`
175			`if (iSdCmd.Ack = cActivated) then`
176			`NextState <= CMD3Response;`
177			`end if;`
178	60	rkastl
179	63	rkastl	`when CMD3Response =>`
180			`if (iSdCmd.Valid = cActivated) then`
181			`if (iSdCmd.Content.id = cSdCmdSendRelAdr) then`
182			`-- todo: check status`
183			`NextReg.RCA <= iSdCmd.Content.arg(31 downto 16);`
184			`NextState <= idle;`
185			`end if;`
186			`end if;`
187
188	54	rkastl	`when others =>`
189			`report "SdController: State not handled" severity error;`
190			`end case;`
191			`end process Comb;`
192
193			`end architecture Rtl;`
194

Browse

Tools

Subversion Repositories sdhc-sc-core

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