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/] [bench/] [sdc_dma/] [verilog/] [sdModel.v] - Blame information for rev 102

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


//`include "timescale.v"
`include "SD_defines.v"
`define tTLH 10 //Clock rise time
`define tHL 10 //Clock fall time
`define tISU 6 //Input setup time
`define tIH 0 //Input hold time
`define tODL 14 //Output delay
`define DLY_TO_OUTP 47
 
`define BLOCKSIZE 512
`define MEMSIZE 2048 // 4 block
`define BLOCK_BUFFER_SIZE 1
`define TIME_BUSY 64
 
`define PRG 7
`define RCV 6
`define DATAS 5
`define TRAN 4
module sdModel(
  input sdClk,
  tri cmd,
  tri [3:0] dat
 
);
 
 
reg oeCmd;
reg oeDat;
reg cmdOut;
reg [3:0] datOut;
reg [10:0] transf_cnt;
 
 
 
reg [5:0] lastCMD;
reg cardIdentificationState;
reg CardTransferActive;
reg [2:0] BusWidth;
 
assign cmd = oeCmd ? cmdOut : 1'bz;
assign dat = oeDat ? datOut : 4'bz;
 
reg InbuffStatus;
reg [31:0] BlockAddr;
reg [7:0] Inbuff [0:511];
reg [7:0] FLASHmem [0:`MEMSIZE];
 
 
reg [46:0]inCmd;
reg [5:0]cmdRead;
reg [7:0] cmdWrite;
reg crcIn;
reg crcEn;
reg crcRst;
reg [31:0] CardStatus;
reg [15:0] RCA;
reg [31:0] OCR;
reg [120:0] CID;
reg Busy; //0 when busy
wire [6:0] crcOut;
reg [4:0] crc_c;
 
reg [3:0] CurrentState;
reg [3:0] DataCurrentState;
`define RCASTART 16'h20
`define OCRSTART 32'hff8000
`define STATUSSTART 32'h0
`define CIDSTART 128'h00ffffffddddddddaaaaaaaa99999999  //Just some random data not really usefull anyway 
 
`define outDelay 4
reg [2:0] outDelayCnt;
reg [9:0] flash_write_cnt;
reg [8:0] flash_blockwrite_cnt;
 
parameter SIZE = 10;
parameter CONTENT_SIZE = 40;
parameter
    IDLE   =  10'b0000_0000_01,
    READ_CMD   =  10'b0000_0000_10,
    ANALYZE_CMD     =  10'b0000_0001_00,
    SEND_CMD        =  10'b0000_0010_00;
reg [SIZE-1:0] state;
reg [SIZE-1:0] next_state;
 
parameter
    DATA_IDLE   =10'b0000_0000_01,
    READ_WAITS  =10'b0000_0000_10,
    READ_DATA  = 10'b0000_0001_00,
    WRITE_FLASH =10'b0000_0010_00,
    WRITE_DATA  =10'b0000_0100_00;
parameter okcrctoken = 4'b0101;
parameter invalidcrctoken = 4'b1111;
reg [SIZE-1:0] dataState;
reg [SIZE-1:0] next_datastate;
 
reg ValidCmd;
reg inValidCmd;
 
reg [7:0] response_S;
reg [135:0] response_CMD;
integer responseType;
 
     reg [9:0] block_cnt;
     reg wptr;
     reg crc_ok;
     reg [3:0] last_din;
 
 
 
reg crcDat_rst;
reg crcDat_en;
reg [3:0] crcDat_in;
wire [15:0] crcDat_out [3:0];
 
genvar i;
generate
for(i=0; i<4; i=i+1) begin:CRC_16_gen
  SD_CRC_16 CRC_16_i (crcDat_in[i],crcDat_en, sdClk, crcDat_rst, crcDat_out[i]);
end
endgenerate
SD_CRC_7 CRC_7(
crcIn,
crcEn,
sdClk,
crcRst,
crcOut);
 
 
reg appendCrc;
reg [5:0] startUppCnt;
 
reg q_start_bit;
//Card initinCMd
initial $readmemh("FLASH.txt",FLASHmem);
 
integer k;
initial begin
        $display("Contents of Mem after reading data file:");
        for (k=0; k<10; k=k+1) $display("%d:%h",k,FLASHmem[k]);
end
reg qCmd;
reg [2:0] crcCnt;
initial begin
  cardIdentificationState<=1;
  state<=IDLE;
  dataState<=DATA_IDLE;
  Busy<=0;
  oeCmd<=0;
  crcCnt<=0;
  CardTransferActive<=0;
  qCmd<=1;
  oeDat<=0;
  cmdOut<=0;
  cmdWrite<=0;
  InbuffStatus<=0;
  datOut<=0;
  inCmd<=0;
  BusWidth<=1;
  responseType=0;
  crcIn<=0;
  response_S<=0;
  crcEn<=0;
  crcRst<=0;
  cmdRead<=0;
  ValidCmd<=0;
  inValidCmd=0;
  appendCrc<=0;
  RCA<= `RCASTART;
  OCR<= `OCRSTART;
  CardStatus <= `STATUSSTART;
  CID<=`CIDSTART;
  response_CMD<=0;
  outDelayCnt<=0;
  crcDat_rst<=1;
  crcDat_en<=0;
  crcDat_in<=0;
  transf_cnt<=0;
  BlockAddr<=0;
  block_cnt <=0;
  wptr<=0;
  transf_cnt<=0;
  crcDat_rst<=1;
  crcDat_en<=0;
  crcDat_in<=0;
  flash_write_cnt<=0;
  flash_blockwrite_cnt<=0;
end
 
//CARD logic
 
always @ (state or cmd or cmdRead or ValidCmd or inValidCmd or cmdWrite or outDelayCnt)
begin : FSM_COMBO
 next_state  = 0;
case(state)
IDLE: begin
   if (!cmd)
     next_state = READ_CMD;
  else
     next_state = IDLE;
end
READ_CMD: begin
  if (cmdRead>= 47)
     next_state = ANALYZE_CMD;
  else
     next_state =  READ_CMD;
 end
 ANALYZE_CMD: begin
  if ((ValidCmd  )   && (outDelayCnt >= `outDelay ))
     next_state = SEND_CMD;
  else if (inValidCmd)
     next_state =  IDLE;
 else
    next_state =  ANALYZE_CMD;
 end
 SEND_CMD: begin
    if (cmdWrite>= response_S)
     next_state = IDLE;
  else
     next_state =  SEND_CMD;
 
 end
 
 
 endcase
end
 
always @ (dataState or CardStatus or crc_c or flash_write_cnt or dat[0] )
begin : FSM_COMBODAT
 next_datastate  = 0;
case(dataState)
 DATA_IDLE: begin
   if (CardStatus[12:9]==`RCV )
     next_datastate = READ_WAITS;
   else if (CardStatus[12:9]==`DATAS )
     next_datastate = WRITE_DATA;
   else
     next_datastate = DATA_IDLE;
 end
 
 READ_WAITS: begin
   if ( dat[0] == 1'b0 )
     next_datastate =  READ_DATA;
   else
     next_datastate =  READ_WAITS;
 end
 
 READ_DATA : begin
  if (crc_c==0  )
     next_datastate =  WRITE_FLASH;
  else
     next_datastate =  READ_DATA;
 end
  WRITE_FLASH : begin
  if (flash_write_cnt>265 )
     next_datastate =  DATA_IDLE;
  else
     next_datastate =  WRITE_FLASH;
end
  WRITE_DATA : begin
    if (transf_cnt >= `BIT_BLOCK)
       next_datastate= DATA_IDLE;
    else
       next_datastate=WRITE_DATA;
  end
 
 
 
 
 
 endcase
end
 
always @ (posedge sdClk  )
 begin
 
    q_start_bit <= dat[0];
 end
 
always @ (posedge sdClk  )
begin : FSM_SEQ
    state <= next_state;
end
 
always @ (posedge sdClk  )
begin : FSM_SEQDAT
    dataState <= next_datastate;
end
 
 
 
always @ (posedge sdClk) begin
if (CardTransferActive) begin
 if (InbuffStatus==0) //empty
   CardStatus[8]<=1;
  else
   CardStatus[8]<=0;
  end
else
  CardStatus[8]<=0;
 
 startUppCnt<=startUppCnt+1;
 OCR[31]<=Busy;
 if (startUppCnt == `TIME_BUSY)
   Busy <=1;
end
 
 
always @ (posedge sdClk) begin
   qCmd<=cmd;
end
 
//read data and cmd on rising edge
always @ (posedge sdClk) begin
 case(state)
   IDLE: begin
 
      crcIn<=0;
      crcEn<=0;
      crcRst<=1;
      oeCmd<=0;
 
      cmdRead<=0;
      appendCrc<=0;
      ValidCmd<=0;
      inValidCmd=0;
      cmdWrite<=0;
      crcCnt<=0;
      response_CMD<=0;
      response_S<=0;
      outDelayCnt<=0;
      responseType=0;
    end
   READ_CMD: begin //read cmd
      crcEn<=1;
      crcRst<=0;
      crcIn <= #`tIH qCmd;
      inCmd[47-cmdRead]  <= #`tIH qCmd;
      cmdRead <= #1 cmdRead+1;
      if (cmdRead >= 40)
         crcEn<=0;
 
      if (cmdRead == 46) begin
          oeCmd<=1;
     cmdOut<=1;
      end
   end
 
   ANALYZE_CMD: begin//check for valid cmd
   //Wrong CRC go idle
    if (inCmd[46] == 0) //start
      inValidCmd=1;
    else if (inCmd[7:1] != crcOut) begin
      inValidCmd=1;
      $fdisplay(sdModel_file_desc, "**sd_Model Commando CRC Error") ;
      $display(sdModel_file_desc, "**sd_Model Commando CRC Error") ;
    end
    else if  (inCmd[0] != 1)  begin//stop 
      inValidCmd=1;
      $fdisplay(sdModel_file_desc, "**sd_Model Commando No Stop Bit Error") ;
      $display(sdModel_file_desc, "**sd_Model Commando No Stop Bit Error") ;
    end
    else begin
      if(outDelayCnt ==0)
        CardStatus[3]<=0;
      case(inCmd[45:40])
 
        2 : response_S <= 136;
        3 : response_S <= 48;
        7 : response_S <= 48;
        8 : response_S <= 0;
        14 : response_S <= 0;
        16 : response_S <= 48;
        17 : response_S <= 48;
        24 : response_S <= 48;
        33 : response_S <= 48;
        55 : response_S <= 48;
        41 : response_S <= 48;
    endcase
         case(inCmd[45:40])
 
            response_CMD <= 0;
            cardIdentificationState<=1;
            ResetCard;
        end
        2 : begin
         if (lastCMD != 41 && outDelayCnt==0) begin
               $fdisplay(sdModel_file_desc, "**Error in sequnce, ACMD 41 should precede 2 in Startup state") ;
               $display(sdModel_file_desc, "**Error in sequnce, ACMD 41 should precede 2 in Startup state") ;
               CardStatus[3]<=1;
            end
        response_CMD[127:8] <= CID;
        appendCrc<=0;
        CardStatus[12:9] <=2;
        end
        3 :  begin
           if (lastCMD != 2 && outDelayCnt==0 ) begin
               $fdisplay(sdModel_file_desc, "**Error in sequnce, CMD 2 should precede 3 in Startup state") ;
               $display(sdModel_file_desc, "**Error in sequnce, CMD 2 should precede 3 in Startup state") ;
               CardStatus[3]<=1;
            end
        response_CMD[127:112] <= RCA[15:0] ;
        response_CMD[111:96] <= CardStatus[15:0] ;
        appendCrc<=1;
        CardStatus[12:9] <=3;
        cardIdentificationState<=0;
       end
        6 : begin
           if (lastCMD == 55 && outDelayCnt==0) begin
              if (inCmd[9:8] == 2'b10) begin
               BusWidth <=4;
                    $display(sdModel_file_desc, "**BUS WIDTH 4 ") ;
               end
              else
               BusWidth <=1;
 
              response_S<=48;
              response_CMD[127:96] <= CardStatus;
           end
           else if (outDelayCnt==0)begin
             response_CMD <= 0;
             response_S<=0;
             $fdisplay(sdModel_file_desc, "**Error Invalid CMD, %h",inCmd[45:40]) ;
             $display(sdModel_file_desc, "**Error Invalid CMD, %h",inCmd[45:40]) ;
            end
        end
        7: begin
         if (outDelayCnt==0) begin
          if (inCmd[39:24]== RCA[15:0]) begin
              CardTransferActive <= 1;
              response_CMD[127:96] <= CardStatus ;
              CardStatus[12:9] <=`TRAN;
          end
          else begin
               CardTransferActive <= 0;
               response_CMD[127:96] <= CardStatus ;
               CardStatus[12:9] <=3;
          end
         end
        end
        8 : response_CMD[127:96] <= 0; //V1.0 card
        16 : begin
          response_CMD[127:96] <= CardStatus ;
 
        end
        17 :  begin
          if (outDelayCnt==0) begin
            if (CardStatus[12:9] == `TRAN) begin //If card is in transferstate                               
                CardStatus[12:9] <=`DATAS;//Put card in data state
                response_CMD[127:96] <= CardStatus ;
                BlockAddr = inCmd[39:8];
                if (BlockAddr%512 !=0)
                  $display("**Block Misalign Error");
          end
           else begin
             response_S <= 0;
             response_CMD[127:96] <= 0;
           end
         end
 
       end
 
        24 : begin
          if (outDelayCnt==0) begin
            if (CardStatus[12:9] == `TRAN) begin //If card is in transferstate
              if (CardStatus[8]) begin //If Free write buffer           
                CardStatus[12:9] <=`RCV;//Put card in Rcv state
                response_CMD[127:96] <= CardStatus ;
                BlockAddr = inCmd[39:8];
                if (BlockAddr%512 !=0)
                  $display("**Block Misalign Error");
              end
              else begin
                response_CMD[127:96] <= CardStatus;
                 $fdisplay(sdModel_file_desc, "**Error Try to blockwrite when No Free Writebuffer") ;
                 $display("**Error Try to blockwrite when No Free Writebuffer") ;
             end
           end
           else begin
             response_S <= 0;
             response_CMD[127:96] <= 0;
           end
         end
 
       end
        33 : response_CMD[127:96] <= 48;
        55 :
        begin
          response_CMD[127:96] <= CardStatus ;
          CardStatus[5] <=1;      //Next CMD is AP specific CMD
          appendCrc<=1;
        end
        41 :
        begin
         if (cardIdentificationState) begin
            if (lastCMD != 55 && outDelayCnt==0) begin
               $fdisplay(sdModel_file_desc, "**Error in sequnce, CMD 55 should precede 41 in Startup state") ;
               $display( "**Error in sequnce, CMD 55 should precede 41 in Startup state") ;
               CardStatus[3]<=1;
            end
            else begin
             responseType=3;
             response_CMD[127:96] <= OCR;
             appendCrc<=0;
             CardStatus[5] <=0;
            if (Busy==1)
              CardStatus[12:9] <=1;
           end
        end
       end
 
    endcase
     ValidCmd<=1;
     crcIn<=0;
 
     outDelayCnt<=outDelayCnt+1;
     if (outDelayCnt==`outDelay)
       crcRst<=1;
     oeCmd<=1;
     cmdOut<=1;
     response_CMD[135:134] <=0;
 
    if (responseType != 3)
       response_CMD[133:128] <=inCmd[45:40];
    if (responseType == 3)
       response_CMD[133:128] <=6'b111111;
 
     lastCMD <=inCmd[45:40];
    end
   end
 
 
 
 endcase
end
 
always @ ( negedge sdClk) begin
 case(state)
 
SEND_CMD: begin
     crcRst<=0;
     crcEn<=1;
    cmdWrite<=cmdWrite+1;
    if (response_S!=0)
     cmdOut<=0;
   else
      cmdOut<=1;
 
    if ((cmdWrite>0) &&  (cmdWrite < response_S-8)) begin
      cmdOut<=response_CMD[135-cmdWrite];
      crcIn<=response_CMD[134-cmdWrite];
      if (cmdWrite >= response_S-9)
       crcEn<=0;
    end
   else if (cmdWrite!=0) begin
     crcEn<=0;
     cmdOut<=crcOut[6-crcCnt];
     crcCnt<=crcCnt+1;
      if (responseType == 3)
           cmdOut<=1;
   end
  if (cmdWrite == response_S-1)
    cmdOut<=1;
 
  end
 endcase
end
 
 
 
integer outdly_cnt;
 
 
 
 
 
 
 
always @ (posedge sdClk) begin
 
  case (dataState)
  DATA_IDLE: begin
 
  end
 
  READ_WAITS: begin
      oeDat<=0;
      crcDat_rst<=0;
      crcDat_en<=1;
      crcDat_in<=0;
      crc_c<=15;//
      crc_ok<=1;
  end
  READ_DATA: begin
 
 
    InbuffStatus<=1;
    if (transf_cnt<`BIT_BLOCK_REC) begin
       if (wptr)
         Inbuff[block_cnt][7:4] <= dat;
       else
          Inbuff[block_cnt][3:0] <= dat;
 
       crcDat_in<=dat;
       crc_ok<=1;
       transf_cnt<=transf_cnt+1;
       if (wptr)
         block_cnt<=block_cnt+1;
       wptr<=~wptr;
 
 
    end
    else if  ( transf_cnt <= (`BIT_BLOCK_REC +`BIT_CRC_CYCLE-1)) begin
       transf_cnt<=transf_cnt+1;
       crcDat_en<=0;
       last_din <=dat;
 
       if (transf_cnt> `BIT_BLOCK_REC) begin
        crc_c<=crc_c-1;
 
          if (crcDat_out[0][crc_c] != last_din[0])
           crc_ok<=0;
          if  (crcDat_out[1][crc_c] != last_din[1])
           crc_ok<=0;
          if  (crcDat_out[2][crc_c] != last_din[2])
           crc_ok<=0;
          if  (crcDat_out[3][crc_c] != last_din[3])
           crc_ok<=0;
      end
    end
  end
  WRITE_FLASH: begin
     oeDat<=1;
     block_cnt <=0;
     wptr<=0;
     transf_cnt<=0;
     crcDat_rst<=1;
     crcDat_en<=0;
     crcDat_in<=0;
 
 
  end
 
  endcase
 
 
end
 
 
 
reg data_send_index;
integer write_out_index;
always @ (negedge sdClk) begin
 
  case (dataState)
  DATA_IDLE: begin
     write_out_index<=0;
     transf_cnt<=0;
     data_send_index<=0;
     outdly_cnt<=0;
 
  end
 
 
   WRITE_DATA: begin
      oeDat<=1;
      outdly_cnt<=outdly_cnt+1;
 
      if ( outdly_cnt > `DLY_TO_OUTP) begin
         transf_cnt <= transf_cnt+1;
         crcDat_en<=1;
         crcDat_rst<=0;
 
      end
      else begin
        crcDat_en<=0;
        crcDat_rst<=1;
        oeDat<=1;
        crc_c<=16;
     end
 
       if (transf_cnt==1) begin
 
          last_din <= FLASHmem[BlockAddr+(write_out_index)][7:4];
          datOut<=0;
          crcDat_in<= FLASHmem[BlockAddr+(write_out_index)][7:4];
          data_send_index<=1;
        end
        else if ( (transf_cnt>=2) && (transf_cnt<=`BIT_BLOCK-`CRC_OFF )) begin
          data_send_index<=~data_send_index;
          if (!data_send_index) begin
             last_din<=FLASHmem[BlockAddr+(write_out_index)][7:4];
             crcDat_in<= FLASHmem[BlockAddr+(write_out_index)][7:4];
          end
          else begin
             last_din<=FLASHmem[BlockAddr+(write_out_index)][3:0];
             crcDat_in<= FLASHmem[BlockAddr+(write_out_index)][3:0];
             write_out_index<=write_out_index+1;
         end
 
          datOut<= last_din;
 
 
          if ( transf_cnt >=`BIT_BLOCK-`CRC_OFF ) begin
             crcDat_en<=0;
         end
 
       end
       else if (transf_cnt>`BIT_BLOCK-`CRC_OFF & crc_c!=0) begin
         datOut<= last_din;
         crcDat_en<=0;
         crc_c<=crc_c-1;
         if (crc_c<= 16) begin
         datOut[0]<=crcDat_out[0][crc_c-1];
         datOut[1]<=crcDat_out[1][crc_c-1];
         datOut[2]<=crcDat_out[2][crc_c-1];
         datOut[3]<=crcDat_out[3][crc_c-1];
       end
       end
       else if (transf_cnt==`BIT_BLOCK-2) begin
          datOut<=4'b1111;
      end
       else if ((transf_cnt !=0) && (crc_c == 0 ))begin
         oeDat<=0;
         CardStatus[12:9] <= `TRAN;
         end
 
 
 
  end
 
 
 
  WRITE_FLASH: begin
    flash_write_cnt<=flash_write_cnt+1;
     CardStatus[12:9] <= `PRG;
      datOut[0]<=0;
       datOut[1]<=1;
       datOut[2]<=1;
       datOut[3]<=1;
    if (flash_write_cnt == 0)
      datOut<=1;
    else if(flash_write_cnt == 1)
     datOut[0]<=1;
    else if(flash_write_cnt == 2)
     datOut[0]<=0;
 
 
    else if ((flash_write_cnt > 2) && (flash_write_cnt < 7)) begin
      if (crc_ok)
        datOut[0] <=okcrctoken[6-flash_write_cnt];
      else
        datOut[0] <= invalidcrctoken[6-flash_write_cnt];
    end
    else if  ((flash_write_cnt >= 7) && (flash_write_cnt < 264)) begin
       datOut[0]<=0;
 
      flash_blockwrite_cnt<=flash_blockwrite_cnt+2;
       FLASHmem[BlockAddr+(flash_blockwrite_cnt)]<=Inbuff[flash_blockwrite_cnt];
       FLASHmem[BlockAddr+(flash_blockwrite_cnt+1)]<=Inbuff[flash_blockwrite_cnt+1];
    end
    else begin
      datOut<=1;
      InbuffStatus<=0;
      CardStatus[12:9] <= `TRAN;
    end
  end
endcase
end
 
integer sdModel_file_desc;
 
initial
begin
  sdModel_file_desc = $fopen("log/sd_model.log");
  if (sdModel_file_desc < 2)
  begin
    $display("*E Could not open/create testbench log file in /log/ directory!");
    $finish;
  end
end
 
task ResetCard; //  MAC registers
begin
 cardIdentificationState<=1;
  state<=IDLE;
  dataState<=DATA_IDLE;
  Busy<=0;
  oeCmd<=0;
  crcCnt<=0;
  CardTransferActive<=0;
  qCmd<=1;
  oeDat<=0;
  cmdOut<=0;
  cmdWrite<=0;
 
  InbuffStatus<=0;
  datOut<=0;
  inCmd<=0;
  BusWidth<=1;
  responseType=0;
  crcIn<=0;
  response_S<=0;
  crcEn<=0;
  crcRst<=0;
  cmdRead<=0;
  ValidCmd<=0;
  inValidCmd=0;
  appendCrc<=0;
  RCA<= `RCASTART;
  OCR<= `OCRSTART;
  CardStatus <= `STATUSSTART;
  CID<=`CIDSTART;
  response_CMD<=0;
  outDelayCnt<=0;
  crcDat_rst<=1;
  crcDat_en<=0;
  crcDat_in<=0;
  transf_cnt<=0;
  BlockAddr<=0;
  block_cnt <=0;
     wptr<=0;
     transf_cnt<=0;
     crcDat_rst<=1;
     crcDat_en<=0;
     crcDat_in<=0;
flash_write_cnt<=0;
flash_blockwrite_cnt<=0;
end
endtask
 
 
endmodule

Line No.	Rev	Author	Line
1	79	tac2	//`include "timescale.v"
2	96	tac2	`include "SD_defines.v"
3	79	tac2	`define tTLH 10 //Clock rise time
4			`define tHL 10 //Clock fall time
5			`define tISU 6 //Input setup time
6			`define tIH 0 //Input hold time
7			`define tODL 14 //Output delay
8	98	tac2	`define DLY_TO_OUTP 47
9	79	tac2
10			`define BLOCKSIZE 512
11	96	tac2	`define MEMSIZE 2048 // 4 block
12	79	tac2	`define BLOCK_BUFFER_SIZE 1
13			`define TIME_BUSY 64
14
15	96	tac2	`define PRG 7
16			`define RCV 6
17			`define DATAS 5
18			`define TRAN 4
19	79	tac2	`module sdModel(`
20			`input sdClk,`
21			`tri cmd,`
22			`tri [3:0] dat`
23
24			`);`
25
26
27			`reg oeCmd;`
28			`reg oeDat;`
29			`reg cmdOut;`
30	96	tac2	`reg [3:0] datOut;`
31			`reg [10:0] transf_cnt;`
32	79	tac2
33	96	tac2
34
35	79	tac2	`reg [5:0] lastCMD;`
36			`reg cardIdentificationState;`
37	96	tac2	`reg CardTransferActive;`
38			`reg [2:0] BusWidth;`
39	79	tac2
40			`assign cmd = oeCmd ? cmdOut : 1'bz;`
41			`assign dat = oeDat ? datOut : 4'bz;`
42
43	96	tac2	`reg InbuffStatus;`
44			`reg [31:0] BlockAddr;`
45			`reg [7:0] Inbuff [0:511];`
46			reg [7:0] FLASHmem [0:`MEMSIZE];
47	79	tac2
48
49			`reg [46:0]inCmd;`
50			`reg [5:0]cmdRead;`
51			`reg [7:0] cmdWrite;`
52			`reg crcIn;`
53			`reg crcEn;`
54			`reg crcRst;`
55			`reg [31:0] CardStatus;`
56			`reg [15:0] RCA;`
57			`reg [31:0] OCR;`
58			`reg [120:0] CID;`
59			`reg Busy; //0 when busy`
60			`wire [6:0] crcOut;`
61	102	tac2	`reg [4:0] crc_c;`
62	96	tac2
63			`reg [3:0] CurrentState;`
64			`reg [3:0] DataCurrentState;`
65	79	tac2	`define RCASTART 16'h20
66			`define OCRSTART 32'hff8000
67			`define STATUSSTART 32'h0
68			`define CIDSTART 128'h00ffffffddddddddaaaaaaaa99999999 //Just some random data not really usefull anyway
69
70			`define outDelay 4
71			`reg [2:0] outDelayCnt;`
72	96	tac2	`reg [9:0] flash_write_cnt;`
73			`reg [8:0] flash_blockwrite_cnt;`
74
75	79	tac2	`parameter SIZE = 10;`
76			`parameter CONTENT_SIZE = 40;`
77			`parameter`
78			`IDLE = 10'b0000_0000_01,`
79			`READ_CMD = 10'b0000_0000_10,`
80			`ANALYZE_CMD = 10'b0000_0001_00,`
81			`SEND_CMD = 10'b0000_0010_00;`
82			`reg [SIZE-1:0] state;`
83			`reg [SIZE-1:0] next_state;`
84
85	96	tac2	`parameter`
86			`DATA_IDLE =10'b0000_0000_01,`
87			`READ_WAITS =10'b0000_0000_10,`
88			`READ_DATA = 10'b0000_0001_00,`
89			`WRITE_FLASH =10'b0000_0010_00,`
90			`WRITE_DATA =10'b0000_0100_00;`
91			`parameter okcrctoken = 4'b0101;`
92			`parameter invalidcrctoken = 4'b1111;`
93			`reg [SIZE-1:0] dataState;`
94			`reg [SIZE-1:0] next_datastate;`
95
96	79	tac2	`reg ValidCmd;`
97			`reg inValidCmd;`
98
99			`reg [7:0] response_S;`
100			`reg [135:0] response_CMD;`
101			`integer responseType;`
102	96	tac2
103			`reg [9:0] block_cnt;`
104			`reg wptr;`
105			`reg crc_ok;`
106			`reg [3:0] last_din;`
107
108
109
110			`reg crcDat_rst;`
111			`reg crcDat_en;`
112			`reg [3:0] crcDat_in;`
113			`wire [15:0] crcDat_out [3:0];`
114
115			`genvar i;`
116			`generate`
117			`for(i=0; i<4; i=i+1) begin:CRC_16_gen`
118	97	tac2	`SD_CRC_16 CRC_16_i (crcDat_in[i],crcDat_en, sdClk, crcDat_rst, crcDat_out[i]);`
119	96	tac2	`end`
120			`endgenerate`
121			`SD_CRC_7 CRC_7(`
122	79	tac2	`crcIn,`
123			`crcEn,`
124			`sdClk,`
125			`crcRst,`
126			`crcOut);`
127	96	tac2
128
129	79	tac2	`reg appendCrc;`
130			`reg [5:0] startUppCnt;`
131
132	96	tac2	`reg q_start_bit;`
133	79	tac2	`//Card initinCMd`
134			`initial $readmemh("FLASH.txt",FLASHmem);`
135
136			`integer k;`
137			`initial begin`
138			`$display("Contents of Mem after reading data file:");`
139			`for (k=0; k<10; k=k+1) $display("%d:%h",k,FLASHmem[k]);`
140			`end`
141			`reg qCmd;`
142			`reg [2:0] crcCnt;`
143			`initial begin`
144			`cardIdentificationState<=1;`
145			`state<=IDLE;`
146	96	tac2	`dataState<=DATA_IDLE;`
147	79	tac2	`Busy<=0;`
148			`oeCmd<=0;`
149			`crcCnt<=0;`
150	96	tac2	`CardTransferActive<=0;`
151	79	tac2	`qCmd<=1;`
152			`oeDat<=0;`
153			`cmdOut<=0;`
154	98	tac2	`cmdWrite<=0;`
155	96	tac2	`InbuffStatus<=0;`
156	79	tac2	`datOut<=0;`
157			`inCmd<=0;`
158	96	tac2	`BusWidth<=1;`
159	79	tac2	`responseType=0;`
160			`crcIn<=0;`
161			`response_S<=0;`
162			`crcEn<=0;`
163			`crcRst<=0;`
164			`cmdRead<=0;`
165			`ValidCmd<=0;`
166			`inValidCmd=0;`
167			`appendCrc<=0;`
168			RCA<= `RCASTART;
169			OCR<= `OCRSTART;
170			CardStatus <= `STATUSSTART;
171			CID<=`CIDSTART;
172			`response_CMD<=0;`
173			`outDelayCnt<=0;`
174	96	tac2	`crcDat_rst<=1;`
175			`crcDat_en<=0;`
176			`crcDat_in<=0;`
177			`transf_cnt<=0;`
178			`BlockAddr<=0;`
179			`block_cnt <=0;`
180	98	tac2	`wptr<=0;`
181			`transf_cnt<=0;`
182			`crcDat_rst<=1;`
183			`crcDat_en<=0;`
184			`crcDat_in<=0;`
185			`flash_write_cnt<=0;`
186			`flash_blockwrite_cnt<=0;`
187	79	tac2	`end`
188
189			`//CARD logic`
190
191			`always @ (state or cmd or cmdRead or ValidCmd or inValidCmd or cmdWrite or outDelayCnt)`
192			`begin : FSM_COMBO`
193			`next_state = 0;`
194			`case(state)`
195			`IDLE: begin`
196			`if (!cmd)`
197			`next_state = READ_CMD;`
198			`else`
199			`next_state = IDLE;`
200			`end`
201			`READ_CMD: begin`
202			`if (cmdRead>= 47)`
203			`next_state = ANALYZE_CMD;`
204			`else`
205			`next_state = READ_CMD;`
206			`end`
207			`ANALYZE_CMD: begin`
208			if ((ValidCmd ) && (outDelayCnt >= `outDelay ))
209			`next_state = SEND_CMD;`
210			`else if (inValidCmd)`
211			`next_state = IDLE;`
212			`else`
213			`next_state = ANALYZE_CMD;`
214			`end`
215			`SEND_CMD: begin`
216			`if (cmdWrite>= response_S)`
217			`next_state = IDLE;`
218			`else`
219			`next_state = SEND_CMD;`
220
221			`end`
222
223
224			`endcase`
225			`end`
226
227	98	tac2	`always @ (dataState or CardStatus or crc_c or flash_write_cnt or dat[0] )`
228	96	tac2	`begin : FSM_COMBODAT`
229			`next_datastate = 0;`
230			`case(dataState)`
231			`DATA_IDLE: begin`
232			if (CardStatus[12:9]==`RCV )
233			`next_datastate = READ_WAITS;`
234			else if (CardStatus[12:9]==`DATAS )
235			`next_datastate = WRITE_DATA;`
236			`else`
237			`next_datastate = DATA_IDLE;`
238			`end`
239
240			`READ_WAITS: begin`
241	98	tac2	`if ( dat[0] == 1'b0 )`
242	96	tac2	`next_datastate = READ_DATA;`
243			`else`
244			`next_datastate = READ_WAITS;`
245			`end`
246
247			`READ_DATA : begin`
248			`if (crc_c==0 )`
249			`next_datastate = WRITE_FLASH;`
250			`else`
251			`next_datastate = READ_DATA;`
252			`end`
253			`WRITE_FLASH : begin`
254			`if (flash_write_cnt>265 )`
255			`next_datastate = DATA_IDLE;`
256			`else`
257			`next_datastate = WRITE_FLASH;`
258	98	tac2	`end`
259			`WRITE_DATA : begin`
260			if (transf_cnt >= `BIT_BLOCK)
261			`next_datastate= DATA_IDLE;`
262			`else`
263			`next_datastate=WRITE_DATA;`
264			`end`
265	96	tac2
266
267
268
269
270			`endcase`
271			`end`
272
273	79	tac2	`always @ (posedge sdClk )`
274	96	tac2	`begin`
275
276			`q_start_bit <= dat[0];`
277			`end`
278
279			`always @ (posedge sdClk )`
280	79	tac2	`begin : FSM_SEQ`
281	96	tac2	`state <= next_state;`
282	79	tac2	`end`
283
284	96	tac2	`always @ (posedge sdClk )`
285			`begin : FSM_SEQDAT`
286			`dataState <= next_datastate;`
287			`end`
288	79	tac2
289	96	tac2
290
291	79	tac2	`always @ (posedge sdClk) begin`
292	96	tac2	`if (CardTransferActive) begin`
293			`if (InbuffStatus==0) //empty`
294			`CardStatus[8]<=1;`
295			`else`
296			`CardStatus[8]<=0;`
297			`end`
298			`else`
299			`CardStatus[8]<=0;`
300
301	79	tac2	`startUppCnt<=startUppCnt+1;`
302			`OCR[31]<=Busy;`
303			if (startUppCnt == `TIME_BUSY)
304			`Busy <=1;`
305			`end`
306
307
308			`always @ (posedge sdClk) begin`
309			`qCmd<=cmd;`
310			`end`
311
312			`//read data and cmd on rising edge`
313			`always @ (posedge sdClk) begin`
314			`case(state)`
315			`IDLE: begin`
316
317			`crcIn<=0;`
318			`crcEn<=0;`
319			`crcRst<=1;`
320			`oeCmd<=0;`
321	98	tac2
322	79	tac2	`cmdRead<=0;`
323			`appendCrc<=0;`
324			`ValidCmd<=0;`
325			`inValidCmd=0;`
326			`cmdWrite<=0;`
327			`crcCnt<=0;`
328			`response_CMD<=0;`
329			`response_S<=0;`
330			`outDelayCnt<=0;`
331			`responseType=0;`
332			`end`
333			`READ_CMD: begin //read cmd`
334			`crcEn<=1;`
335			`crcRst<=0;`
336			crcIn <= #`tIH qCmd;
337			inCmd[47-cmdRead] <= #`tIH qCmd;
338			`cmdRead <= #1 cmdRead+1;`
339			`if (cmdRead >= 40)`
340			`crcEn<=0;`
341
342			`if (cmdRead == 46) begin`
343			`oeCmd<=1;`
344			`cmdOut<=1;`
345			`end`
346			`end`
347
348			`ANALYZE_CMD: begin//check for valid cmd`
349			`//Wrong CRC go idle`
350			`if (inCmd[46] == 0) //start`
351			`inValidCmd=1;`
352			`else if (inCmd[7:1] != crcOut) begin`
353			`inValidCmd=1;`
354			`$fdisplay(sdModel_file_desc, "**sd_Model Commando CRC Error") ;`
355			`$display(sdModel_file_desc, "**sd_Model Commando CRC Error") ;`
356			`end`
357			`else if (inCmd[0] != 1) begin//stop`
358			`inValidCmd=1;`
359			`$fdisplay(sdModel_file_desc, "**sd_Model Commando No Stop Bit Error") ;`
360			`$display(sdModel_file_desc, "**sd_Model Commando No Stop Bit Error") ;`
361			`end`
362			`else begin`
363	96	tac2	`if(outDelayCnt ==0)`
364			`CardStatus[3]<=0;`
365	79	tac2	`case(inCmd[45:40])`
366
367			`2 : response_S <= 136;`
368			`3 : response_S <= 48;`
369			`7 : response_S <= 48;`
370			`8 : response_S <= 0;`
371			`14 : response_S <= 0;`
372	96	tac2	`16 : response_S <= 48;`
373	79	tac2	`17 : response_S <= 48;`
374			`24 : response_S <= 48;`
375			`33 : response_S <= 48;`
376			`55 : response_S <= 48;`
377			`41 : response_S <= 48;`
378			`endcase`
379			`case(inCmd[45:40])`
380
381			`response_CMD <= 0;`
382			`cardIdentificationState<=1;`
383			`ResetCard;`
384			`end`
385			`2 : begin`
386			`if (lastCMD != 41 && outDelayCnt==0) begin`
387			`$fdisplay(sdModel_file_desc, "**Error in sequnce, ACMD 41 should precede 2 in Startup state") ;`
388			`$display(sdModel_file_desc, "**Error in sequnce, ACMD 41 should precede 2 in Startup state") ;`
389			`CardStatus[3]<=1;`
390			`end`
391			`response_CMD[127:8] <= CID;`
392			`appendCrc<=0;`
393			`CardStatus[12:9] <=2;`
394			`end`
395			`3 : begin`
396	96	tac2	`if (lastCMD != 2 && outDelayCnt==0 ) begin`
397	79	tac2	`$fdisplay(sdModel_file_desc, "**Error in sequnce, CMD 2 should precede 3 in Startup state") ;`
398			`$display(sdModel_file_desc, "**Error in sequnce, CMD 2 should precede 3 in Startup state") ;`
399			`CardStatus[3]<=1;`
400			`end`
401			`response_CMD[127:112] <= RCA[15:0] ;`
402			`response_CMD[111:96] <= CardStatus[15:0] ;`
403			`appendCrc<=1;`
404			`CardStatus[12:9] <=3;`
405			`cardIdentificationState<=0;`
406	96	tac2	`end`
407			`6 : begin`
408			`if (lastCMD == 55 && outDelayCnt==0) begin`
409			`if (inCmd[9:8] == 2'b10) begin`
410			`BusWidth <=4;`
411			`$display(sdModel_file_desc, "**BUS WIDTH 4 ") ;`
412			`end`
413			`else`
414			`BusWidth <=1;`
415
416			`response_S<=48;`
417			`response_CMD[127:96] <= CardStatus;`
418			`end`
419			`else if (outDelayCnt==0)begin`
420			`response_CMD <= 0;`
421			`response_S<=0;`
422			`$fdisplay(sdModel_file_desc, "**Error Invalid CMD, %h",inCmd[45:40]) ;`
423			`$display(sdModel_file_desc, "**Error Invalid CMD, %h",inCmd[45:40]) ;`
424			`end`
425			`end`
426			`7: begin`
427			`if (outDelayCnt==0) begin`
428			`if (inCmd[39:24]== RCA[15:0]) begin`
429			`CardTransferActive <= 1;`
430			`response_CMD[127:96] <= CardStatus ;`
431			CardStatus[12:9] <=`TRAN;
432			`end`
433			`else begin`
434			`CardTransferActive <= 0;`
435			`response_CMD[127:96] <= CardStatus ;`
436			`CardStatus[12:9] <=3;`
437			`end`
438			`end`
439			`end`
440	79	tac2	`8 : response_CMD[127:96] <= 0; //V1.0 card`
441	96	tac2	`16 : begin`
442			`response_CMD[127:96] <= CardStatus ;`
443
444			`end`
445	98	tac2	`17 : begin`
446			`if (outDelayCnt==0) begin`
447			if (CardStatus[12:9] == `TRAN) begin //If card is in transferstate
448			CardStatus[12:9] <=`DATAS;//Put card in data state
449			`response_CMD[127:96] <= CardStatus ;`
450			`BlockAddr = inCmd[39:8];`
451			`if (BlockAddr%512 !=0)`
452			`$display("**Block Misalign Error");`
453			`end`
454			`else begin`
455			`response_S <= 0;`
456			`response_CMD[127:96] <= 0;`
457			`end`
458			`end`
459
460			`end`
461
462	96	tac2	`24 : begin`
463			`if (outDelayCnt==0) begin`
464	98	tac2	if (CardStatus[12:9] == `TRAN) begin //If card is in transferstate
465	96	tac2	`if (CardStatus[8]) begin //If Free write buffer`
466			CardStatus[12:9] <=`RCV;//Put card in Rcv state
467			`response_CMD[127:96] <= CardStatus ;`
468			`BlockAddr = inCmd[39:8];`
469			`if (BlockAddr%512 !=0)`
470			`$display("**Block Misalign Error");`
471			`end`
472			`else begin`
473			`response_CMD[127:96] <= CardStatus;`
474			`$fdisplay(sdModel_file_desc, "**Error Try to blockwrite when No Free Writebuffer") ;`
475			`$display("**Error Try to blockwrite when No Free Writebuffer") ;`
476			`end`
477			`end`
478			`else begin`
479			`response_S <= 0;`
480			`response_CMD[127:96] <= 0;`
481			`end`
482			`end`
483
484			`end`
485	79	tac2	`33 : response_CMD[127:96] <= 48;`
486			`55 :`
487			`begin`
488			`response_CMD[127:96] <= CardStatus ;`
489			`CardStatus[5] <=1; //Next CMD is AP specific CMD`
490			`appendCrc<=1;`
491			`end`
492			`41 :`
493			`begin`
494			`if (cardIdentificationState) begin`
495			`if (lastCMD != 55 && outDelayCnt==0) begin`
496			`$fdisplay(sdModel_file_desc, "**Error in sequnce, CMD 55 should precede 41 in Startup state") ;`
497	96	tac2	`$display( "**Error in sequnce, CMD 55 should precede 41 in Startup state") ;`
498	79	tac2	`CardStatus[3]<=1;`
499			`end`
500			`else begin`

Browse

Tools

Subversion Repositories sdcard_mass_storage_controller

[/] [sdcard_mass_storage_controller/] [trunk/] [bench/] [sdc_dma/] [verilog/] [sdModel.v] - Blame information for rev 102