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

Subversion Repositories sdhc-sc-core

[/] [sdhc-sc-core/] [trunk/] [grpSdVerification/] [unitSdCardModel/] [src/] [SdCardModel.sv] - Blame information for rev 57

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


//
// file: SdCardModel.sv
// author: Rainer Kastl
//
// Models a SDCard for verification
//
 
const logic cActivated = 1;
const logic cInactivated = 0;
 
`define cSDArgWith 32
typedef logic[`cSDArgWith-1:0] SDCommandArg;
typedef logic[6:0] aCrc;
 
typedef enum {
         cSdCmdGoIdleState = 0,
         cSdCmdAllSendCID = 2,
         cSdCmdSendRelAdr = 3,
         cSdCmdSetDSR = 4, // [31:16] DSR
         cSdCmdSelCard = 7, // [31:16] RCA
         cSdCmdSendIfCond = 8, // [31:12] reserved, [11:8] supply voltage, [7:0] check pattern
         cSdCmdSendCSD = 9, // [31:16] RCA
         cSdCmdSendCID = 10, // [31:16] RCA
         cSdCmdStopTrans = 12,
         cSdCmdSendStatus = 13, // [31:16] RCA
         cSdCmdNextIsACMD = 55 // [31:16] RCA
} SDCommandId;
 
typedef enum {
        cSdCmdACMD41 = 41
} SDAppCommandId;
 
const SDCommandArg cSdArgACMD41HCS = 'b01000000111111111000000000000000;
 
typedef enum {
        idle = 0, ready = 1, ident = 2, stby = 3, trans = 4,
        data = 5, rcv = 6, prg = 7, dis = 8
} SDCardStates;
 
class SDCardState;
        local logic OutOfRange;
        local logic AddressError;
        local logic BlockLenError;
 
        local logic[3:0] state;
 
        local logic AppCmd;
 
        function new();
                OutOfRange = 0;
                AddressError = 0;
                BlockLenError = 0;
                state = idle;
                AppCmd = 0;
        endfunction
 
        function void recvCMD55();
                AppCmd = 1;
        endfunction
 
        function automatic SDCommandArg get();
                SDCommandArg temp = 0;
                temp[31] = OutOfRange;
                temp[30] = AddressError;
                temp[29] = BlockLenError;
                temp[12:9] = state;
                temp[5] = AppCmd;
                return temp;
        endfunction
 
endclass
 
class SDCommandToken;
        logic startbit;
        logic transbit;
        rand logic[5:0] id;
        rand SDCommandArg arg;
        aCrc crc7;
        logic endbit;
 
        function void display();
                $display("Startbit: %b", startbit);
                $display("Transbit: %b", transbit);
                $display("ID: %b", id);
                $display("Arg: %h", arg);
                $display("CRC: %b", crc7);
                $display("Endbit: %b" , endbit);
        endfunction
 
        function void checkStartEnd();
                assert(startbit == 0);
                assert(endbit == 1);
        endfunction
 
        function void checkFromHost();
                checkStartEnd();
                checkCrc();
                assert(transbit == 1);
        endfunction
 
        function void checkCrc();
                assert(crc7 == calcCrcOfToken());
        endfunction
 
        function automatic aCrc calcCrcOfToken();
                logic[39:0] temp;
                aCrc crc = 0;
 
                temp[39] = startbit;
                temp[38] = transbit;
                temp[37:32] = id;
                temp[31:0] = arg;
 
                for(int i = 39; i >= 0; i--) begin
                        if (((crc[6] & 1)) != temp[i])
                                 crc = (crc << 1) ^ 'b10001001;
                        else
                                 crc <<= 1;
                end
                return crc;
        endfunction
 
        function automatic bit equals(SDCommandToken rhs);
                if(id == rhs.id && arg == rhs.arg) begin
                        return 1;
                end
                return 0;
        endfunction
 
endclass
 
class SDCommandResponse;
        protected logic startbit;
        protected logic transbit;
        protected logic[5:0] id;
        protected SDCommandArg arg;
        protected aCrc crc;
        protected logic endbit;
 
        function automatic void calcCrc();
                logic[39:0] temp;
                crc = 0;
 
                temp[39] = startbit;
                temp[38] = transbit;
                temp[37:32] = id;
                temp[31:0] = arg;
 
                for(int i = 39; i >= 0; i--) begin
                        if (((crc[6] & 1)) != temp[i])
                                 crc = (crc << 1) ^ 'b10001001;
                        else
                                 crc <<= 1;
                end
        endfunction
 
 
        task automatic send(virtual ISdCmd.Card ICmd);
                calcCrc();
 
                @ICmd.cb;
                ICmd.cb.Cmd <= startbit;
 
                @ICmd.cb;
                ICmd.cb.Cmd <= transbit;
 
                for(int i = 5; i >= 0; i--) begin
                        @ICmd.cb;
                        ICmd.cb.Cmd <= id[i];
                end
 
                for (int i = 31; i>= 0; i--) begin
                        @ICmd.cb;
                        ICmd.cb.Cmd <= arg[i];
                end
 
                for (int i = 6; i >= 0; i--) begin
                        @ICmd.cb;
                        ICmd.cb.Cmd <= crc[i];
                end
 
                @ICmd.cb;
                ICmd.cb.Cmd <= endbit;
 
                @ICmd.cb;
                ICmd.cb.Cmd <= 'z;
        endtask
endclass
 
class SDCommandR7 extends SDCommandResponse;
 
        function new(SDCommandArg arg);
                startbit = 0;
                transbit = 0;
                id = cSdCmdSendIfCond;
                this.arg = arg;
                endbit = 1;
        endfunction
 
endclass
 
class SDCommandR1 extends SDCommandResponse;
 
        function new(SDCommandId id, SDCardState state);
                startbit = 0;
                transbit = 0;
                this.id = id;
                this.arg = state.get();
                endbit = 1;
        endfunction
 
endclass
 
class SDCard;
        local virtual ISdCmd.Card ICmd;
 
        local SDCardState state;
        local SDCommandToken recvcmd;
 
        local event CmdReceived, InitDone;
 
        function new(virtual ISdCmd CmdInterface, event CmdReceived, event InitDone);
                ICmd = CmdInterface;
                state = new();
                this.CmdReceived = CmdReceived;
                this.InitDone = InitDone;
        endfunction
 
        task reset();
        endtask
 
        // Receive a command token and handle it
        task recv();
                recvcmd = new();
                ICmd.cb.Cmd <= 'z;
 
                wait(ICmd.cb.Cmd == 0);
                // Startbit
                recvcmd.startbit = ICmd.cb.Cmd;
 
                @ICmd.cb;
                // Transbit
                recvcmd.transbit = ICmd.cb.Cmd;
 
                // CmdID
                for (int i = 5; i >= 0; i--) begin
                        @ICmd.cb;
                        recvcmd.id[i] = ICmd.cb.Cmd;
                end
 
                // Arg
                for (int i = 31; i >= 0; i--) begin
                        @ICmd.cb;
                        recvcmd.arg[i] = ICmd.cb.Cmd;
                end
 
                // CRC
                for (int i = 6; i >= 0; i--) begin
                        @ICmd.cb;
                        recvcmd.crc7[i] = ICmd.cb.Cmd;
                end
 
                // Endbit
                @ICmd.cb;
                recvcmd.endbit = ICmd.cb.Cmd;
 
                recvcmd.checkFromHost();
                -> CmdReceived;
        endtask
 
        task automatic init();
                SDCommandR7 voltageresponse;
                SDCommandR1 response;
 
                // expect CMD0 so that state is clear
                recv();
                assert(recvcmd.id == cSdCmdGoIdleState);
 
                // expect CMD8: voltage and SD 2.00 compatible
                recv();
                assert(recvcmd.id == cSdCmdSendIfCond);
                assert(recvcmd.arg[12:8] == 'b0001); // Standard voltage
 
                // respond with R7: we are SD 2.00 compatible and compatible to the
                // voltage
                voltageresponse = new(recvcmd.arg);
                voltageresponse.send(ICmd);
 
                // expect CMD55 with default RCA
                recv();
                assert(recvcmd.id == cSdCmdNextIsACMD);
                assert(recvcmd.arg == 0);
                state.recvCMD55();
 
                // respond with R1
                response = new(cSdCmdNextIsACMD, state);
                response.send(ICmd);
 
                // expect ACMD41 with HCS = 1
                recv();
                assert(recvcmd.id == cSdCmdACMD41);
                assert(recvcmd.arg == cSdArgACMD41HCS);
 
                -> InitDone;
 
        endtask
 
        function automatic SDCommandToken getCmd();
                return recvcmd;
        endfunction
 
 
        task recvCmd(input SDCommandToken cmd, output SDCommandResponse response);
                case (cmd.id)
                        cSdCmdGoIdleState: reset();
                        default: $display("SDCard: CmdId %d not implemented", cmd.id);
                endcase
        endtask
 
endclass
 

Line No.	Rev	Author	Line
1	44	rkastl	`//`
2			`// file: SdCardModel.sv`
3			`// author: Rainer Kastl`
4			`//`
5			`// Models a SDCard for verification`
6			`//`
7
8			`const logic cActivated = 1;`
9			`const logic cInactivated = 0;`
10
11			`define cSDArgWith 32
12			typedef logic[`cSDArgWith-1:0] SDCommandArg;
13	50	rkastl	`typedef logic[6:0] aCrc;`
14	44	rkastl
15			`typedef enum {`
16			`cSdCmdGoIdleState = 0,`
17			`cSdCmdAllSendCID = 2,`
18			`cSdCmdSendRelAdr = 3,`
19			`cSdCmdSetDSR = 4, // [31:16] DSR`
20			`cSdCmdSelCard = 7, // [31:16] RCA`
21			`cSdCmdSendIfCond = 8, // [31:12] reserved, [11:8] supply voltage, [7:0] check pattern`
22			`cSdCmdSendCSD = 9, // [31:16] RCA`
23			`cSdCmdSendCID = 10, // [31:16] RCA`
24			`cSdCmdStopTrans = 12,`
25	57	rkastl	`cSdCmdSendStatus = 13, // [31:16] RCA`
26			`cSdCmdNextIsACMD = 55 // [31:16] RCA`
27	44	rkastl	`} SDCommandId;`
28
29			`typedef enum {`
30	57	rkastl	`cSdCmdACMD41 = 41`
31			`} SDAppCommandId;`
32	44	rkastl
33	57	rkastl	`const SDCommandArg cSdArgACMD41HCS = 'b01000000111111111000000000000000;`
34
35			`typedef enum {`
36			`idle = 0, ready = 1, ident = 2, stby = 3, trans = 4,`
37			`data = 5, rcv = 6, prg = 7, dis = 8`
38			`} SDCardStates;`
39
40			`class SDCardState;`
41			`local logic OutOfRange;`
42			`local logic AddressError;`
43			`local logic BlockLenError;`
44
45			`local logic[3:0] state;`
46
47			`local logic AppCmd;`
48
49			`function new();`
50			`OutOfRange = 0;`
51			`AddressError = 0;`
52			`BlockLenError = 0;`
53			`state = idle;`
54			`AppCmd = 0;`
55			`endfunction`
56
57			`function void recvCMD55();`
58			`AppCmd = 1;`
59			`endfunction`
60
61			`function automatic SDCommandArg get();`
62			`SDCommandArg temp = 0;`
63			`temp[31] = OutOfRange;`
64			`temp[30] = AddressError;`
65			`temp[29] = BlockLenError;`
66			`temp[12:9] = state;`
67			`temp[5] = AppCmd;`
68			`return temp;`
69			`endfunction`
70
71			`endclass`
72
73	44	rkastl	`class SDCommandToken;`
74	46	rkastl	`logic startbit;`
75			`logic transbit;`
76	51	rkastl	`rand logic[5:0] id;`
77			`rand SDCommandArg arg;`
78	50	rkastl	`aCrc crc7;`
79	46	rkastl	`logic endbit;`
80	50	rkastl
81			`function void display();`
82			`$display("Startbit: %b", startbit);`
83			`$display("Transbit: %b", transbit);`
84			`$display("ID: %b", id);`
85			`$display("Arg: %h", arg);`
86			`$display("CRC: %b", crc7);`
87			`$display("Endbit: %b" , endbit);`
88			`endfunction`
89
90			`function void checkStartEnd();`
91			`assert(startbit == 0);`
92			`assert(endbit == 1);`
93			`endfunction`
94
95			`function void checkFromHost();`
96			`checkStartEnd();`
97			`checkCrc();`
98			`assert(transbit == 1);`
99			`endfunction`
100
101			`function void checkCrc();`
102	53	rkastl	`assert(crc7 == calcCrcOfToken());`
103	50	rkastl	`endfunction`
104
105	53	rkastl	`function automatic aCrc calcCrcOfToken();`
106			`logic[39:0] temp;`
107	50	rkastl	`aCrc crc = 0;`
108	53	rkastl
109	50	rkastl	`temp[39] = startbit;`
110			`temp[38] = transbit;`
111			`temp[37:32] = id;`
112			`temp[31:0] = arg;`
113	53	rkastl
114	50	rkastl	`for(int i = 39; i >= 0; i--) begin`
115			`if (((crc[6] & 1)) != temp[i])`
116	53	rkastl	`crc = (crc << 1) ^ 'b10001001;`
117			`else`
118			`crc <<= 1;`
119			`end`
120	50	rkastl	`return crc;`
121			`endfunction`
122
123	51	rkastl	`function automatic bit equals(SDCommandToken rhs);`
124			`if(id == rhs.id && arg == rhs.arg) begin`
125			`return 1;`
126			`end`
127			`return 0;`
128			`endfunction`
129
130	44	rkastl	`endclass`
131
132			`class SDCommandResponse;`
133	53	rkastl	`protected logic startbit;`
134			`protected logic transbit;`
135			`protected logic[5:0] id;`
136			`protected SDCommandArg arg;`
137			`protected aCrc crc;`
138			`protected logic endbit;`
139	44	rkastl
140	53	rkastl	`function automatic void calcCrc();`
141			`logic[39:0] temp;`
142	56	rkastl	`crc = 0;`
143	53	rkastl
144			`temp[39] = startbit;`
145			`temp[38] = transbit;`
146			`temp[37:32] = id;`
147			`temp[31:0] = arg;`
148
149			`for(int i = 39; i >= 0; i--) begin`
150			`if (((crc[6] & 1)) != temp[i])`
151			`crc = (crc << 1) ^ 'b10001001;`
152			`else`
153			`crc <<= 1;`
154			`end`
155			`endfunction`
156
157
158			`task automatic send(virtual ISdCmd.Card ICmd);`
159			`calcCrc();`
160
161	54	rkastl	`@ICmd.cb;`
162			`ICmd.cb.Cmd <= startbit;`
163	53	rkastl
164	54	rkastl	`@ICmd.cb;`
165			`ICmd.cb.Cmd <= transbit;`
166	53	rkastl
167			`for(int i = 5; i >= 0; i--) begin`
168	54	rkastl	`@ICmd.cb;`
169			`ICmd.cb.Cmd <= id[i];`
170	53	rkastl	`end`
171
172			`for (int i = 31; i>= 0; i--) begin`
173	54	rkastl	`@ICmd.cb;`
174			`ICmd.cb.Cmd <= arg[i];`
175	53	rkastl	`end`
176
177	56	rkastl	`for (int i = 6; i >= 0; i--) begin`
178	54	rkastl	`@ICmd.cb;`
179			`ICmd.cb.Cmd <= crc[i];`
180	53	rkastl	`end`
181
182	54	rkastl	`@ICmd.cb;`
183			`ICmd.cb.Cmd <= endbit;`
184	53	rkastl
185	54	rkastl	`@ICmd.cb;`
186			`ICmd.cb.Cmd <= 'z;`
187	53	rkastl	`endtask`
188	44	rkastl	`endclass`
189
190	53	rkastl	`class SDCommandR7 extends SDCommandResponse;`
191
192			`function new(SDCommandArg arg);`
193			`startbit = 0;`
194			`transbit = 0;`
195			`id = cSdCmdSendIfCond;`
196			`this.arg = arg;`
197			`endbit = 1;`
198			`endfunction`
199
200			`endclass`
201
202	57	rkastl	`class SDCommandR1 extends SDCommandResponse;`
203
204			`function new(SDCommandId id, SDCardState state);`
205			`startbit = 0;`
206			`transbit = 0;`
207			`this.id = id;`
208			`this.arg = state.get();`
209			`endbit = 1;`
210			`endfunction`
211
212			`endclass`
213
214	44	rkastl	`class SDCard;`
215	53	rkastl	`local virtual ISdCmd.Card ICmd;`
216	50	rkastl
217	53	rkastl	`local SDCardState state;`
218			`local SDCommandToken recvcmd;`
219	44	rkastl
220	53	rkastl	`local event CmdReceived, InitDone;`
221	50	rkastl
222	53	rkastl	`function new(virtual ISdCmd CmdInterface, event CmdReceived, event InitDone);`
223			`ICmd = CmdInterface;`
224	57	rkastl	`state = new();`
225	50	rkastl	`this.CmdReceived = CmdReceived;`
226	53	rkastl	`this.InitDone = InitDone;`
227	44	rkastl	`endfunction`
228
229			`task reset();`
230			`endtask`
231
232	53	rkastl	`// Receive a command token and handle it`
233	50	rkastl	`task recv();`
234			`recvcmd = new();`
235	54	rkastl	`ICmd.cb.Cmd <= 'z;`
236	50	rkastl
237	54	rkastl	`wait(ICmd.cb.Cmd == 0);`
238	50	rkastl	`// Startbit`
239	54	rkastl	`recvcmd.startbit = ICmd.cb.Cmd;`
240	50	rkastl
241	54	rkastl	`@ICmd.cb;`
242	50	rkastl	`// Transbit`
243	54	rkastl	`recvcmd.transbit = ICmd.cb.Cmd;`
244	50	rkastl
245			`// CmdID`
246			`for (int i = 5; i >= 0; i--) begin`
247	54	rkastl	`@ICmd.cb;`
248			`recvcmd.id[i] = ICmd.cb.Cmd;`
249	50	rkastl	`end`
250
251			`// Arg`
252			`for (int i = 31; i >= 0; i--) begin`
253	54	rkastl	`@ICmd.cb;`
254			`recvcmd.arg[i] = ICmd.cb.Cmd;`
255	50	rkastl	`end`
256
257			`// CRC`
258			`for (int i = 6; i >= 0; i--) begin`
259	54	rkastl	`@ICmd.cb;`
260			`recvcmd.crc7[i] = ICmd.cb.Cmd;`
261	50	rkastl	`end`
262
263			`// Endbit`
264	54	rkastl	`@ICmd.cb;`
265			`recvcmd.endbit = ICmd.cb.Cmd;`
266	50	rkastl
267	53	rkastl	`recvcmd.checkFromHost();`
268	50	rkastl	`-> CmdReceived;`
269			`endtask`
270
271	53	rkastl	`task automatic init();`
272			`SDCommandR7 voltageresponse;`
273	57	rkastl	`SDCommandR1 response;`
274	53	rkastl
275			`// expect CMD0 so that state is clear`
276			`recv();`
277			`assert(recvcmd.id == cSdCmdGoIdleState);`
278
279			`// expect CMD8: voltage and SD 2.00 compatible`
280			`recv();`
281			`assert(recvcmd.id == cSdCmdSendIfCond);`
282			`assert(recvcmd.arg[12:8] == 'b0001); // Standard voltage`
283
284			`// respond with R7: we are SD 2.00 compatible and compatible to the`
285			`// voltage`
286			`voltageresponse = new(recvcmd.arg);`
287	57	rkastl	`voltageresponse.send(ICmd);`
288	53	rkastl
289	57	rkastl	`// expect CMD55 with default RCA`
290			`recv();`
291			`assert(recvcmd.id == cSdCmdNextIsACMD);`
292			`assert(recvcmd.arg == 0);`
293			`state.recvCMD55();`
294
295			`// respond with R1`
296			`response = new(cSdCmdNextIsACMD, state);`
297			`response.send(ICmd);`
298
299			`// expect ACMD41 with HCS = 1`
300			`recv();`
301			`assert(recvcmd.id == cSdCmdACMD41);`
302			`assert(recvcmd.arg == cSdArgACMD41HCS);`
303
304	53	rkastl	`-> InitDone;`
305
306			`endtask`
307	50	rkastl
308			`function automatic SDCommandToken getCmd();`
309			`return recvcmd;`
310			`endfunction`
311
312
313	44	rkastl	`task recvCmd(input SDCommandToken cmd, output SDCommandResponse response);`
314	45	rkastl	`case (cmd.id)`
315			`cSdCmdGoIdleState: reset();`
316			`default: $display("SDCard: CmdId %d not implemented", cmd.id);`
317			`endcase`
318	44	rkastl	`endtask`
319
320			`endclass`
321

Browse

Tools

Subversion Repositories sdhc-sc-core

[/] [sdhc-sc-core/] [trunk/] [grpSdVerification/] [unitSdCardModel/] [src/] [SdCardModel.sv] - Blame information for rev 57