URL https://opencores.org/ocsvn/sdcard_mass_storage_controller/sdcard_mass_storage_controller/trunk

Subversion Repositories sdcard_mass_storage_controller

[/] [sdcard_mass_storage_controller/] [trunk/] [rtl/] [sdc_dma/] [verilog/] [sd_data_serial_host.v] - Blame information for rev 134

Details | Compare with Previous | View Log


 
 
`include "sd_defines.v"
 
 
module sd_data_serial_host(
input sd_clk,
input rst,
//Tx Fifo
input [31:0] data_in ,
 
output reg rd,
//Rx Fifo
output  reg  [`SD_BUS_W-1:0] data_out ,
output reg we,
//tristate data
output reg DAT_oe_o,
output reg[`SD_BUS_W-1:0] DAT_dat_o,
input  [`SD_BUS_W-1:0] DAT_dat_i,
//Controll signals
input [1:0] start_dat,
input ack_transfer,
 
output reg busy_n,
output reg transm_complete,
output reg crc_ok
);
 
//CRC16 
reg [`SD_BUS_W-1:0] crc_in;
reg crc_en;
reg crc_rst;
wire [15:0] crc_out [`SD_BUS_W-1:0];
reg  [`SD_BUS_W-1:0] temp_in;
 
reg [10:0] transf_cnt;
parameter SIZE = 6;
reg [SIZE-1:0] state;
reg [SIZE-1:0] next_state;
parameter IDLE        = 6'b000001;
parameter WRITE_DAT   = 6'b000010;
parameter WRITE_CRC   = 6'b000100;
parameter WRITE_BUSY  = 6'b001000;
parameter READ_WAIT   = 6'b010000;
parameter READ_DAT    = 6'b100000;
reg [2:0] crc_status;
reg busy_int;
 
genvar i;
generate
for(i=0; i<`SD_BUS_W; i=i+1) begin:CRC_16_gen
  sd_crc_16 CRC_16_i (crc_in[i],crc_en, sd_clk, crc_rst, crc_out[i]);
end
endgenerate
 
reg ack_transfer_int;
reg ack_q;
always @ (posedge sd_clk or posedge rst   )
begin: ACK_SYNC
if (rst) begin
  ack_transfer_int <=0;
  ack_q<=0;end
else begin
  ack_q<=ack_transfer;
  ack_transfer_int<=ack_q;
  end
end
 
reg q_start_bit;
always @ (state or start_dat or q_start_bit or  transf_cnt or crc_status or busy_int or DAT_dat_i or ack_transfer_int)
begin : FSM_COMBO
 next_state  = 0;
case(state)
  IDLE: begin
   if (start_dat == 2'b01)
      next_state=WRITE_DAT;
    else if  (start_dat == 2'b10)
      next_state=READ_WAIT;
    else
      next_state=IDLE;
    end
  WRITE_DAT: begin
    if (transf_cnt >= `BIT_BLOCK)
       next_state= WRITE_CRC;
   else if (start_dat == 2'b11)
        next_state=IDLE;
    else
       next_state=WRITE_DAT;
  end
 
  WRITE_CRC: begin
    if (crc_status ==0)
       next_state= WRITE_BUSY;
    else
       next_state=WRITE_CRC;
 
  end
  WRITE_BUSY: begin
      if ( (busy_int ==1)  & ack_transfer_int)
       next_state= IDLE;
    else
       next_state  = WRITE_BUSY;
  end
 
  READ_WAIT: begin
    if (q_start_bit== 0 )
       next_state= READ_DAT;
    else
       next_state=READ_WAIT;
  end
 
  READ_DAT: begin
    if ( ack_transfer_int)  //Startbit consumed...
       next_state= IDLE;
    else if (start_dat == 2'b11)
        next_state=IDLE;
    else
       next_state=READ_DAT;
    end
 
 
 
 
 
 endcase
end
 
always @ (posedge sd_clk or posedge rst   )
 begin :START_SYNC
  if (rst ) begin
    q_start_bit<=1;
 end
 else begin
    if (!DAT_dat_i[0] & state == READ_WAIT)
    q_start_bit <= 0;
    else
    q_start_bit <= 1;
 
 end
end
 
 
//----------------Seq logic------------
always @ (posedge sd_clk or posedge rst   )
begin : FSM_SEQ
  if (rst ) begin
    state <= #1 IDLE;
 end
 else begin
    state <= #1 next_state;
 end
end
 
reg [4:0] crc_c;
reg [3:0] last_din;
reg [2:0] crc_s ;
reg [31:0] write_buf_0,write_buf_1, sd_data_out;
reg out_buff_ptr,in_buff_ptr;
reg [2:0] data_send_index;
 
always @ (negedge sd_clk or posedge rst   )
begin  : FSM_OUT
 if (rst) begin
write_buf_0<=0;
write_buf_1<=0;
   DAT_oe_o<=0;
   crc_en<=0;
   crc_rst<=1;
   transf_cnt<=0;
   crc_c<=15;
   rd<=0;
   last_din<=0;
   crc_c<=0;
   crc_in<=0;
   DAT_dat_o<=0;
   crc_status<=7;
   crc_s<=0;
   transm_complete<=0;
   busy_n<=1;
   we<=0;
   data_out<=0;
   crc_ok<=0;
   busy_int<=0;
     data_send_index<=0;
        out_buff_ptr<=0;
        in_buff_ptr<=0;
 end
 else begin
 case(state)
   IDLE: begin
      DAT_oe_o<=0;
      DAT_dat_o<=4'b1111;
      crc_en<=0;
      crc_rst<=1;
      transf_cnt<=0;
      crc_c<=16;
      crc_status<=7;
      crc_s<=0;
      we<=0;
      rd<=0;
      busy_n<=1;
        data_send_index<=0;
        out_buff_ptr<=0;
        in_buff_ptr<=0;
 
   end
   WRITE_DAT: begin
      transm_complete <=0;
      busy_n<=0;
      crc_ok<=0;
      transf_cnt<=transf_cnt+1;
       rd<=0;
 
 
 
      if ( (in_buff_ptr != out_buff_ptr) ||  (!transf_cnt) ) begin
        rd <=1;
       if (!in_buff_ptr)
         write_buf_0<=data_in;
       else
        write_buf_1 <=data_in;
 
       in_buff_ptr<=in_buff_ptr+1;
     end
 
      if (!out_buff_ptr)
        sd_data_out<=write_buf_0;
      else
       sd_data_out<=write_buf_1;
 
        if (transf_cnt==1) begin
 
          crc_rst<=0;
          crc_en<=1;
          `ifdef LITLE_ENDIAN
                last_din <=write_buf_0[3:0];
                crc_in<= write_buf_0[3:0];
          `endif
          `ifdef BIG_ENDIAN
                last_din <=write_buf_0[31:28];
                crc_in<= write_buf_0[31:28];
          `endif
 
          DAT_oe_o<=1;
          DAT_dat_o<=0;
 
          data_send_index<=1;
        end
        else if ( (transf_cnt>=2) && (transf_cnt<=`BIT_BLOCK-`CRC_OFF )) begin
          DAT_oe_o<=1;
        case (data_send_index)
          `ifdef LITLE_ENDIAN
           0:begin
              last_din <=sd_data_out[3:0];
              crc_in <=sd_data_out[3:0];
           end
           1:begin
              last_din <=sd_data_out[7:4];
              crc_in <=sd_data_out[7:4];
           end
           2:begin
              last_din <=sd_data_out[11:8];
              crc_in <=sd_data_out[11:8];
           end
           3:begin
              last_din <=sd_data_out[15:12];
              crc_in <=sd_data_out[15:12];
           end
           4:begin
              last_din <=sd_data_out[19:16];
              crc_in <=sd_data_out[19:16];
           end
           5:begin
              last_din <=sd_data_out[23:20];
              crc_in <=sd_data_out[23:20];
           end
           6:begin
              last_din <=sd_data_out[27:24];
              crc_in <=sd_data_out[27:24];
              out_buff_ptr<=out_buff_ptr+1;
           end
           7:begin
              last_din <=sd_data_out[31:28];
              crc_in <=sd_data_out[31:28];
           end
          `endif
          `ifdef BIG_ENDIAN
           0:begin
              last_din <=sd_data_out[31:28];
              crc_in <=sd_data_out[31:28];
           end
           1:begin
              last_din <=sd_data_out[27:24];
              crc_in <=sd_data_out[27:24];
           end
           2:begin
              last_din <=sd_data_out[23:20];
              crc_in <=sd_data_out[23:20];
           end
           3:begin
              last_din <=sd_data_out[19:16];
              crc_in <=sd_data_out[19:16];
           end
           4:begin
              last_din <=sd_data_out[15:12];
              crc_in <=sd_data_out[15:12];
           end
           5:begin
              last_din <=sd_data_out[11:8];
              crc_in <=sd_data_out[11:8];
           end
           6:begin
              last_din <=sd_data_out[7:4];
              crc_in <=sd_data_out[7:4];
              out_buff_ptr<=out_buff_ptr+1;
           end
           7:begin
              last_din <=sd_data_out[3:0];
              crc_in <=sd_data_out[3:0];
           end
          `endif
 
 
         endcase
          data_send_index<=data_send_index+1;
 
          DAT_dat_o<= last_din;
 
 
 
          if ( transf_cnt >=`BIT_BLOCK-`CRC_OFF ) begin
             crc_en<=0;
         end
       end
       else if (transf_cnt>`BIT_BLOCK-`CRC_OFF & crc_c!=0) begin
        rd<=0;
         crc_en<=0;
         crc_c<=crc_c-1;
         DAT_oe_o<=1;
         DAT_dat_o[0]<=crc_out[0][crc_c-1];
         DAT_dat_o[1]<=crc_out[1][crc_c-1];
         DAT_dat_o[2]<=crc_out[2][crc_c-1];
         DAT_dat_o[3]<=crc_out[3][crc_c-1];
       end
       else if (transf_cnt==`BIT_BLOCK-2) begin
          DAT_oe_o<=1;
          DAT_dat_o<=4'b1111;
           rd<=0;
      end
       else if (transf_cnt !=0) begin
         DAT_oe_o<=0;
         rd<=0;
         end
   end
   WRITE_CRC : begin
      rd<=0;
      DAT_oe_o<=0;
      crc_status<=crc_status-1;
      if  (( crc_status<=4) && ( crc_status>=2) )
      crc_s[crc_status-2] <=DAT_dat_i[0];
   end
   WRITE_BUSY : begin
       transm_complete <=1;
     if (crc_s == 3'b010)
       crc_ok<=1;
     else
       crc_ok<=0;
 
       busy_int<=DAT_dat_i[0];
 
 
   end
   READ_WAIT:begin
      DAT_oe_o<=0;
      crc_rst<=0;
      crc_en<=1;
      crc_in<=0;
      crc_c<=15;// end 
      busy_n<=0;
      transm_complete<=0;
   end
 
   READ_DAT: begin
 
 
     if (transf_cnt<`BIT_BLOCK_REC) begin
       we<=1;
 
       data_out<=DAT_dat_i;
       crc_in<=DAT_dat_i;
       crc_ok<=1;
       transf_cnt<=transf_cnt+1;
 
     end
     else if  ( transf_cnt <= (`BIT_BLOCK_REC +`BIT_CRC_CYCLE)) begin
       transf_cnt<=transf_cnt+1;
       crc_en<=0;
       last_din <=DAT_dat_i;
 
       if (transf_cnt> `BIT_BLOCK_REC) begin
        crc_c<=crc_c-1;
          we<=0;
        `ifdef SD_BUS_WIDTH_1
         if  (crc_out[0][crc_status] == last_din[0])
           crc_ok<=0;
        `endif
 
       `ifdef SD_BUS_WIDTH_4
          if  (crc_out[0][crc_c] != last_din[0])
           crc_ok<=0;
          if  (crc_out[1][crc_c] != last_din[1])
           crc_ok<=0;
          if  (crc_out[2][crc_c] != last_din[2])
           crc_ok<=0;
          if  (crc_out[3][crc_c] != last_din[3])
           crc_ok<=0;
 
        `endif
         `ifdef SIM
          crc_ok<=1;
       `endif
         if (crc_c==0) begin
          transm_complete <=1;
          busy_n<=0;
           we<=0;
         end
      end
    end
 
 
 
  end
 
 
 
 endcase
 
 end
 
end
 
 
 
 
 
 
 
 
 
//Sync
 
 
 
 
 
 
 
endmodule
 
 
 
 
 

Browse

Tools

Subversion Repositories sdcard_mass_storage_controller

[/] [sdcard_mass_storage_controller/] [trunk/] [rtl/] [sdc_dma/] [verilog/] [sd_data_serial_host.v] - Blame information for rev 134

Line No.	Rev	Author	Line
1	134	tac2
2
3			`include "sd_defines.v"
4
5
6			`module sd_data_serial_host(`
7			`input sd_clk,`
8			`input rst,`
9			`//Tx Fifo`
10			`input [31:0] data_in ,`
11
12			`output reg rd,`
13			`//Rx Fifo`
14			output reg [`SD_BUS_W-1:0] data_out ,
15			`output reg we,`
16			`//tristate data`
17			`output reg DAT_oe_o,`
18			output reg[`SD_BUS_W-1:0] DAT_dat_o,
19			input [`SD_BUS_W-1:0] DAT_dat_i,
20			`//Controll signals`
21			`input [1:0] start_dat,`
22			`input ack_transfer,`
23
24			`output reg busy_n,`
25			`output reg transm_complete,`
26			`output reg crc_ok`
27			`);`
28
29			`//CRC16`
30			reg [`SD_BUS_W-1:0] crc_in;
31			`reg crc_en;`
32			`reg crc_rst;`
33			wire [15:0] crc_out [`SD_BUS_W-1:0];
34			reg [`SD_BUS_W-1:0] temp_in;
35
36			`reg [10:0] transf_cnt;`
37			`parameter SIZE = 6;`
38			`reg [SIZE-1:0] state;`
39			`reg [SIZE-1:0] next_state;`
40			`parameter IDLE = 6'b000001;`
41			`parameter WRITE_DAT = 6'b000010;`
42			`parameter WRITE_CRC = 6'b000100;`
43			`parameter WRITE_BUSY = 6'b001000;`
44			`parameter READ_WAIT = 6'b010000;`
45			`parameter READ_DAT = 6'b100000;`
46			`reg [2:0] crc_status;`
47			`reg busy_int;`
48
49			`genvar i;`
50			`generate`
51			for(i=0; i<`SD_BUS_W; i=i+1) begin:CRC_16_gen
52			`sd_crc_16 CRC_16_i (crc_in[i],crc_en, sd_clk, crc_rst, crc_out[i]);`
53			`end`
54			`endgenerate`
55
56			`reg ack_transfer_int;`
57			`reg ack_q;`
58			`always @ (posedge sd_clk or posedge rst )`
59			`begin: ACK_SYNC`
60			`if (rst) begin`
61			`ack_transfer_int <=0;`
62			`ack_q<=0;end`
63			`else begin`
64			`ack_q<=ack_transfer;`
65			`ack_transfer_int<=ack_q;`
66			`end`
67			`end`
68
69			`reg q_start_bit;`
70			`always @ (state or start_dat or q_start_bit or transf_cnt or crc_status or busy_int or DAT_dat_i or ack_transfer_int)`
71			`begin : FSM_COMBO`
72			`next_state = 0;`
73			`case(state)`
74			`IDLE: begin`
75			`if (start_dat == 2'b01)`
76			`next_state=WRITE_DAT;`
77			`else if (start_dat == 2'b10)`
78			`next_state=READ_WAIT;`
79			`else`
80			`next_state=IDLE;`
81			`end`
82			`WRITE_DAT: begin`
83			if (transf_cnt >= `BIT_BLOCK)
84			`next_state= WRITE_CRC;`
85			`else if (start_dat == 2'b11)`
86			`next_state=IDLE;`
87			`else`
88			`next_state=WRITE_DAT;`
89			`end`
90
91			`WRITE_CRC: begin`
92			`if (crc_status ==0)`
93			`next_state= WRITE_BUSY;`
94			`else`
95			`next_state=WRITE_CRC;`
96
97			`end`
98			`WRITE_BUSY: begin`
99			`if ( (busy_int ==1) & ack_transfer_int)`
100			`next_state= IDLE;`
101			`else`
102			`next_state = WRITE_BUSY;`
103			`end`
104
105			`READ_WAIT: begin`
106			`if (q_start_bit== 0 )`
107			`next_state= READ_DAT;`
108			`else`
109			`next_state=READ_WAIT;`
110			`end`
111
112			`READ_DAT: begin`
113			`if ( ack_transfer_int) //Startbit consumed...`
114			`next_state= IDLE;`
115			`else if (start_dat == 2'b11)`
116			`next_state=IDLE;`
117			`else`
118			`next_state=READ_DAT;`
119			`end`
120
121
122
123
124
125			`endcase`
126			`end`
127
128			`always @ (posedge sd_clk or posedge rst )`
129			`begin :START_SYNC`
130			`if (rst ) begin`
131			`q_start_bit<=1;`
132			`end`
133			`else begin`
134			`if (!DAT_dat_i[0] & state == READ_WAIT)`
135			`q_start_bit <= 0;`
136			`else`
137			`q_start_bit <= 1;`
138
139			`end`
140			`end`
141
142
143			`//----------------Seq logic------------`
144			`always @ (posedge sd_clk or posedge rst )`
145			`begin : FSM_SEQ`
146			`if (rst ) begin`
147			`state <= #1 IDLE;`
148			`end`
149			`else begin`
150			`state <= #1 next_state;`
151			`end`
152			`end`
153
154			`reg [4:0] crc_c;`
155			`reg [3:0] last_din;`
156			`reg [2:0] crc_s ;`
157			`reg [31:0] write_buf_0,write_buf_1, sd_data_out;`
158			`reg out_buff_ptr,in_buff_ptr;`
159			`reg [2:0] data_send_index;`
160
161			`always @ (negedge sd_clk or posedge rst )`
162			`begin : FSM_OUT`
163			`if (rst) begin`
164			`write_buf_0<=0;`
165			`write_buf_1<=0;`
166			`DAT_oe_o<=0;`
167			`crc_en<=0;`
168			`crc_rst<=1;`
169			`transf_cnt<=0;`
170			`crc_c<=15;`
171			`rd<=0;`
172			`last_din<=0;`
173			`crc_c<=0;`
174			`crc_in<=0;`
175			`DAT_dat_o<=0;`
176			`crc_status<=7;`
177			`crc_s<=0;`
178			`transm_complete<=0;`
179			`busy_n<=1;`
180			`we<=0;`
181			`data_out<=0;`
182			`crc_ok<=0;`
183			`busy_int<=0;`
184			`data_send_index<=0;`
185			`out_buff_ptr<=0;`
186			`in_buff_ptr<=0;`
187			`end`
188			`else begin`
189			`case(state)`
190			`IDLE: begin`
191			`DAT_oe_o<=0;`
192			`DAT_dat_o<=4'b1111;`
193			`crc_en<=0;`
194			`crc_rst<=1;`
195			`transf_cnt<=0;`
196			`crc_c<=16;`
197			`crc_status<=7;`
198			`crc_s<=0;`
199			`we<=0;`
200			`rd<=0;`
201			`busy_n<=1;`
202			`data_send_index<=0;`
203			`out_buff_ptr<=0;`
204			`in_buff_ptr<=0;`
205
206			`end`
207			`WRITE_DAT: begin`
208			`transm_complete <=0;`
209			`busy_n<=0;`
210			`crc_ok<=0;`
211			`transf_cnt<=transf_cnt+1;`
212			`rd<=0;`
213
214
215
216			`if ( (in_buff_ptr != out_buff_ptr) \|\| (!transf_cnt) ) begin`
217			`rd <=1;`
218			`if (!in_buff_ptr)`
219			`write_buf_0<=data_in;`
220			`else`
221			`write_buf_1 <=data_in;`
222
223			`in_buff_ptr<=in_buff_ptr+1;`
224			`end`
225
226			`if (!out_buff_ptr)`
227			`sd_data_out<=write_buf_0;`
228			`else`
229			`sd_data_out<=write_buf_1;`
230
231			`if (transf_cnt==1) begin`
232
233			`crc_rst<=0;`
234			`crc_en<=1;`
235			`ifdef LITLE_ENDIAN
236			`last_din <=write_buf_0[3:0];`
237			`crc_in<= write_buf_0[3:0];`
238			`endif
239			`ifdef BIG_ENDIAN
240			`last_din <=write_buf_0[31:28];`
241			`crc_in<= write_buf_0[31:28];`
242			`endif
243
244			`DAT_oe_o<=1;`
245			`DAT_dat_o<=0;`
246
247			`data_send_index<=1;`
248			`end`
249			else if ( (transf_cnt>=2) && (transf_cnt<=`BIT_BLOCK-`CRC_OFF )) begin
250			`DAT_oe_o<=1;`
251			`case (data_send_index)`
252			`ifdef LITLE_ENDIAN
253			`0:begin`
254			`last_din <=sd_data_out[3:0];`
255			`crc_in <=sd_data_out[3:0];`
256			`end`
257			`1:begin`
258			`last_din <=sd_data_out[7:4];`
259			`crc_in <=sd_data_out[7:4];`
260			`end`
261			`2:begin`
262			`last_din <=sd_data_out[11:8];`
263			`crc_in <=sd_data_out[11:8];`
264			`end`
265			`3:begin`
266			`last_din <=sd_data_out[15:12];`
267			`crc_in <=sd_data_out[15:12];`
268			`end`
269			`4:begin`
270			`last_din <=sd_data_out[19:16];`
271			`crc_in <=sd_data_out[19:16];`
272			`end`
273			`5:begin`
274			`last_din <=sd_data_out[23:20];`
275			`crc_in <=sd_data_out[23:20];`
276			`end`
277			`6:begin`
278			`last_din <=sd_data_out[27:24];`
279			`crc_in <=sd_data_out[27:24];`
280			`out_buff_ptr<=out_buff_ptr+1;`
281			`end`
282			`7:begin`
283			`last_din <=sd_data_out[31:28];`
284			`crc_in <=sd_data_out[31:28];`
285			`end`
286			`endif
287			`ifdef BIG_ENDIAN
288			`0:begin`
289			`last_din <=sd_data_out[31:28];`
290			`crc_in <=sd_data_out[31:28];`
291			`end`
292			`1:begin`
293			`last_din <=sd_data_out[27:24];`
294			`crc_in <=sd_data_out[27:24];`
295			`end`
296			`2:begin`
297			`last_din <=sd_data_out[23:20];`
298			`crc_in <=sd_data_out[23:20];`
299			`end`
300			`3:begin`
301			`last_din <=sd_data_out[19:16];`
302			`crc_in <=sd_data_out[19:16];`
303			`end`
304			`4:begin`
305			`last_din <=sd_data_out[15:12];`
306			`crc_in <=sd_data_out[15:12];`
307			`end`
308			`5:begin`
309			`last_din <=sd_data_out[11:8];`
310			`crc_in <=sd_data_out[11:8];`
311			`end`
312			`6:begin`
313			`last_din <=sd_data_out[7:4];`
314			`crc_in <=sd_data_out[7:4];`
315			`out_buff_ptr<=out_buff_ptr+1;`
316			`end`
317			`7:begin`
318			`last_din <=sd_data_out[3:0];`
319			`crc_in <=sd_data_out[3:0];`
320			`end`
321			`endif
322
323
324			`endcase`
325			`data_send_index<=data_send_index+1;`
326
327			`DAT_dat_o<= last_din;`
328
329
330
331			if ( transf_cnt >=`BIT_BLOCK-`CRC_OFF ) begin
332			`crc_en<=0;`
333			`end`
334			`end`
335			else if (transf_cnt>`BIT_BLOCK-`CRC_OFF & crc_c!=0) begin
336			`rd<=0;`
337			`crc_en<=0;`
338			`crc_c<=crc_c-1;`
339			`DAT_oe_o<=1;`
340			`DAT_dat_o[0]<=crc_out[0][crc_c-1];`
341			`DAT_dat_o[1]<=crc_out[1][crc_c-1];`
342			`DAT_dat_o[2]<=crc_out[2][crc_c-1];`
343			`DAT_dat_o[3]<=crc_out[3][crc_c-1];`
344			`end`
345			else if (transf_cnt==`BIT_BLOCK-2) begin
346			`DAT_oe_o<=1;`
347			`DAT_dat_o<=4'b1111;`
348			`rd<=0;`
349			`end`
350			`else if (transf_cnt !=0) begin`
351			`DAT_oe_o<=0;`
352			`rd<=0;`
353			`end`
354			`end`
355			`WRITE_CRC : begin`
356			`rd<=0;`
357			`DAT_oe_o<=0;`
358			`crc_status<=crc_status-1;`
359			`if (( crc_status<=4) && ( crc_status>=2) )`
360			`crc_s[crc_status-2] <=DAT_dat_i[0];`
361			`end`
362			`WRITE_BUSY : begin`
363			`transm_complete <=1;`
364			`if (crc_s == 3'b010)`
365			`crc_ok<=1;`
366			`else`
367			`crc_ok<=0;`
368
369			`busy_int<=DAT_dat_i[0];`
370
371
372			`end`
373			`READ_WAIT:begin`
374			`DAT_oe_o<=0;`
375			`crc_rst<=0;`
376			`crc_en<=1;`
377			`crc_in<=0;`
378			`crc_c<=15;// end`
379			`busy_n<=0;`
380			`transm_complete<=0;`
381			`end`
382
383			`READ_DAT: begin`
384
385
386			if (transf_cnt<`BIT_BLOCK_REC) begin
387			`we<=1;`
388
389			`data_out<=DAT_dat_i;`
390			`crc_in<=DAT_dat_i;`
391			`crc_ok<=1;`
392			`transf_cnt<=transf_cnt+1;`
393
394			`end`
395			else if ( transf_cnt <= (`BIT_BLOCK_REC +`BIT_CRC_CYCLE)) begin
396			`transf_cnt<=transf_cnt+1;`
397			`crc_en<=0;`
398			`last_din <=DAT_dat_i;`
399
400			if (transf_cnt> `BIT_BLOCK_REC) begin
401			`crc_c<=crc_c-1;`
402			`we<=0;`
403			`ifdef SD_BUS_WIDTH_1
404			`if (crc_out[0][crc_status] == last_din[0])`
405			`crc_ok<=0;`
406			`endif
407
408			`ifdef SD_BUS_WIDTH_4
409			`if (crc_out[0][crc_c] != last_din[0])`
410			`crc_ok<=0;`
411			`if (crc_out[1][crc_c] != last_din[1])`
412			`crc_ok<=0;`
413			`if (crc_out[2][crc_c] != last_din[2])`
414			`crc_ok<=0;`
415			`if (crc_out[3][crc_c] != last_din[3])`
416			`crc_ok<=0;`
417
418			`endif
419			`ifdef SIM
420			`crc_ok<=1;`
421			`endif
422			`if (crc_c==0) begin`
423			`transm_complete <=1;`
424			`busy_n<=0;`
425			`we<=0;`
426			`end`
427			`end`
428			`end`
429
430
431
432			`end`
433
434
435
436			`endcase`
437
438			`end`
439
440			`end`
441
442
443
444
445
446
447
448
449
450			`//Sync`
451
452
453
454
455
456
457
458			`endmodule`
459
460
461
462
463