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

Subversion Repositories can

[/] [can/] [tags/] [rel_6/] [rtl/] [verilog/] [can_bsp.v] - Blame information for rev 16

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


//////////////////////////////////////////////////////////////////////
////                                                              ////
////  can_bsp.v                                                   ////
////                                                              ////
////                                                              ////
////  This file is part of the CAN Protocol Controller            ////
////  http://www.opencores.org/projects/can/                      ////
////                                                              ////
////                                                              ////
////  Author(s):                                                  ////
////       Igor Mohor                                             ////
////       igorm@opencores.org                                    ////
////                                                              ////
////                                                              ////
////  All additional information is available in the README.txt   ////
////  file.                                                       ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2002, 2003 Authors                             ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// restriction provided that this copyright statement is not    ////
//// removed from the file and that any derivative work contains  ////
//// the original copyright notice and the associated disclaimer. ////
////                                                              ////
//// This source file is free software; you can redistribute it   ////
//// and/or modify it under the terms of the GNU Lesser General   ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any   ////
//// later version.                                               ////
////                                                              ////
//// This source is distributed in the hope that it will be       ////
//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////
//// PURPOSE.  See the GNU Lesser General Public License for more ////
//// details.                                                     ////
////                                                              ////
//// You should have received a copy of the GNU Lesser General    ////
//// Public License along with this source; if not, download it   ////
//// from http://www.opencores.org/lgpl.shtml                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
//
// CVS Revision History
//
// $Log: not supported by cvs2svn $
// Revision 1.8  2003/01/10 17:51:33  mohor
// Temporary version (backup).
//
// Revision 1.7  2003/01/09 21:54:45  mohor
// rx fifo added. Not 100 % verified, yet.
//
// Revision 1.6  2003/01/09 14:46:58  mohor
// Temporary files (backup).
//
// Revision 1.5  2003/01/08 13:30:31  mohor
// Temp version.
//
// Revision 1.4  2003/01/08 02:10:53  mohor
// Acceptance filter added.
//
// Revision 1.3  2002/12/28 04:13:23  mohor
// Backup version.
//
// Revision 1.2  2002/12/27 00:12:52  mohor
// Header changed, testbench improved to send a frame (crc still missing).
//
// Revision 1.1.1.1  2002/12/20 16:39:21  mohor
// Initial
//
//
//
 
// synopsys translate_off
`include "timescale.v"
// synopsys translate_on
`include "can_defines.v"
 
module can_bsp
(
  clk,
  rst,
 
  sample_point,
  sampled_bit,
  sampled_bit_q,
  hard_sync,
  resync,
 
  addr,
  data_out,
 
 
  /* Mode register */
  reset_mode,
  acceptance_filter_mode,
 
  /* Command register */
  release_buffer,
 
  /* Clock Divider register */
  extended_mode,
 
  rx_idle,
 
  /* This section is for BASIC and EXTENDED mode */
  /* Acceptance code register */
  acceptance_code_0,
 
  /* Acceptance mask register */
  acceptance_mask_0,
  /* End: This section is for BASIC and EXTENDED mode */
 
  /* This section is for EXTENDED mode */
  /* Acceptance code register */
  acceptance_code_1,
  acceptance_code_2,
  acceptance_code_3,
 
  /* Acceptance mask register */
  acceptance_mask_1,
  acceptance_mask_2,
  acceptance_mask_3
  /* End: This section is for EXTENDED mode */
 
);
 
parameter Tp = 1;
 
input         clk;
input         rst;
input         sample_point;
input         sampled_bit;
input         sampled_bit_q;
input         hard_sync;
input         resync;
input   [7:0] addr;
output  [7:0] data_out;
 
 
input         reset_mode;
input         acceptance_filter_mode;
input         extended_mode;
 
/* Command register */
input         release_buffer;
 
output        rx_idle;
 
/* This section is for BASIC and EXTENDED mode */
/* Acceptance code register */
input   [7:0] acceptance_code_0;
 
/* Acceptance mask register */
input   [7:0] acceptance_mask_0;
 
/* End: This section is for BASIC and EXTENDED mode */
 
 
/* This section is for EXTENDED mode */
/* Acceptance code register */
input   [7:0] acceptance_code_1;
input   [7:0] acceptance_code_2;
input   [7:0] acceptance_code_3;
 
/* Acceptance mask register */
input   [7:0] acceptance_mask_1;
input   [7:0] acceptance_mask_2;
input   [7:0] acceptance_mask_3;
 
/* End: This section is for EXTENDED mode */
 
 
 
reg           reset_mode_q;
reg     [5:0] bit_cnt;
 
reg     [3:0] data_len;
reg    [28:0] id;
reg     [2:0] bit_stuff_cnt;
reg           stuff_error;
 
wire          bit_de_stuff;
 
 
/* Rx state machine */
wire          go_rx_idle;
wire          go_rx_id1;
wire          go_rx_rtr1;
wire          go_rx_ide;
wire          go_rx_id2;
wire          go_rx_rtr2;
wire          go_rx_r1;
wire          go_rx_r0;
wire          go_rx_dlc;
wire          go_rx_data;
wire          go_rx_crc;
wire          go_rx_crc_lim;
wire          go_rx_ack;
wire          go_rx_ack_lim;
wire          go_rx_eof;
 
wire          go_crc_enable;
wire          rst_crc_enable;
 
wire          bit_de_stuff_set;
wire          bit_de_stuff_reset;
 
reg           rx_idle;
reg           rx_id1;
reg           rx_rtr1;
reg           rx_ide;
reg           rx_id2;
reg           rx_rtr2;
reg           rx_r1;
reg           rx_r0;
reg           rx_dlc;
reg           rx_data;
reg           rx_crc;
reg           rx_crc_lim;
reg           rx_ack;
reg           rx_ack_lim;
reg           rx_eof;
 
reg           crc_enable;
 
reg     [2:0] eof_cnt;
wire   [14:0] calculated_crc;
 
assign go_rx_idle     =                   sample_point &  rx_eof  & (eof_cnt == 6);
assign go_rx_id1      =                   sample_point &  rx_idle & (~sampled_bit);
assign go_rx_rtr1     = (~bit_de_stuff) & sample_point &  rx_id1  & (bit_cnt == 10);
assign go_rx_ide      = (~bit_de_stuff) & sample_point &  rx_rtr1;
assign go_rx_id2      = (~bit_de_stuff) & sample_point &  rx_ide  &   sampled_bit;
assign go_rx_rtr2     = (~bit_de_stuff) & sample_point &  rx_id2  & (bit_cnt == 17);
assign go_rx_r1       = (~bit_de_stuff) & sample_point &  rx_rtr2;
assign go_rx_r0       = (~bit_de_stuff) & sample_point & (rx_ide  & (~sampled_bit) | rx_r1);
assign go_rx_dlc      = (~bit_de_stuff) & sample_point &  rx_r0;
assign go_rx_data     = (~bit_de_stuff) & sample_point &  rx_dlc  & (bit_cnt == 3) & (sampled_bit | (|data_len[2:0]));
assign go_rx_crc      = (~bit_de_stuff) & sample_point & (rx_dlc  & (bit_cnt == 3) & (~sampled_bit) & (~(|data_len[2:0])) |
                                                          rx_data & (bit_cnt == ((data_len<<3) - 1'b1)));
assign go_rx_crc_lim  =                   sample_point &  rx_crc  & (bit_cnt == 14);
assign go_rx_ack      =                   sample_point &  rx_crc_lim;
assign go_rx_ack_lim  =                   sample_point &  rx_ack;
assign go_rx_eof      =                   sample_point &  rx_ack_lim  | (~reset_mode) & reset_mode_q;
 
assign go_crc_enable  = hard_sync;
assign rst_crc_enable = go_rx_crc;
 
assign bit_de_stuff_set   = go_rx_id1;
assign bit_de_stuff_reset = go_rx_crc_lim;
 
 
// Rx idle state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_idle <= 1'b1;
  else if (reset_mode | go_rx_id1)
    rx_idle <=#Tp 1'b0;
  else if (go_rx_idle)
    rx_idle <=#Tp 1'b1;
end
 
 
// Rx id1 state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_id1 <= 1'b0;
  else if (reset_mode | go_rx_rtr1)
    rx_id1 <=#Tp 1'b0;
  else if (go_rx_id1)
    rx_id1 <=#Tp 1'b1;
end
 
 
// Rx rtr1 state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_rtr1 <= 1'b0;
  else if (reset_mode | go_rx_ide)
    rx_rtr1 <=#Tp 1'b0;
  else if (go_rx_rtr1)
    rx_rtr1 <=#Tp 1'b1;
end
 
 
// Rx ide state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_ide <= 1'b0;
  else if (reset_mode | go_rx_r0 | go_rx_id2)
    rx_ide <=#Tp 1'b0;
  else if (go_rx_ide)
    rx_ide <=#Tp 1'b1;
end
 
 
// Rx id2 state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_id2 <= 1'b0;
  else if (reset_mode | go_rx_rtr2)
    rx_id2 <=#Tp 1'b0;
  else if (go_rx_id2)
    rx_id2 <=#Tp 1'b1;
end
 
 
// Rx rtr2 state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_rtr2 <= 1'b0;
  else if (reset_mode | go_rx_r1)
    rx_rtr2 <=#Tp 1'b0;
  else if (go_rx_rtr2)
    rx_rtr2 <=#Tp 1'b1;
end
 
 
// Rx r0 state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_r1 <= 1'b0;
  else if (reset_mode | go_rx_r0)
    rx_r1 <=#Tp 1'b0;
  else if (go_rx_r1)
    rx_r1 <=#Tp 1'b1;
end
 
 
// Rx r0 state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_r0 <= 1'b0;
  else if (reset_mode | go_rx_dlc)
    rx_r0 <=#Tp 1'b0;
  else if (go_rx_r0)
    rx_r0 <=#Tp 1'b1;
end
 
 
// Rx dlc state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_dlc <= 1'b0;
  else if (reset_mode | go_rx_data | go_rx_crc)
    rx_dlc <=#Tp 1'b0;
  else if (go_rx_dlc)
    rx_dlc <=#Tp 1'b1;
end
 
 
// Rx data state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_data <= 1'b0;
  else if (reset_mode | go_rx_crc)
    rx_data <=#Tp 1'b0;
  else if (go_rx_data)
    rx_data <=#Tp 1'b1;
end
 
 
// Rx crc state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_crc <= 1'b0;
  else if (reset_mode | go_rx_crc_lim)
    rx_crc <=#Tp 1'b0;
  else if (go_rx_crc)
    rx_crc <=#Tp 1'b1;
end
 
 
// Rx crc delimiter state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_crc_lim <= 1'b0;
  else if (reset_mode | go_rx_ack)
    rx_crc_lim <=#Tp 1'b0;
  else if (go_rx_crc_lim)
    rx_crc_lim <=#Tp 1'b1;
end
 
 
// Rx ack state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_ack <= 1'b0;
  else if (reset_mode | go_rx_ack_lim)
    rx_ack <=#Tp 1'b0;
  else if (go_rx_ack)
    rx_ack <=#Tp 1'b1;
end
 
 
// Rx ack delimiter state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_ack_lim <= 1'b0;
  else if (reset_mode | go_rx_eof)
    rx_ack_lim <=#Tp 1'b0;
  else if (go_rx_ack_lim)
    rx_ack_lim <=#Tp 1'b1;
end
 
 
// Rx eof state
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rx_eof <= 1'b0;
  else if (go_rx_idle)
    rx_eof <=#Tp 1'b0;
  else if (go_rx_eof)
    rx_eof <=#Tp 1'b1;
end
 
 
 
 
reg rtr1;
reg ide;
reg rtr2;
reg [14:0] crc_in;
 
// ID register
always @ (posedge clk or posedge rst)
begin
  if (rst)
    id <= 0;
  else if (sample_point & (rx_id1 | rx_id2) & (~bit_de_stuff))
    id <=#Tp {id[27:0], sampled_bit};
end
 
 
// rtr1 bit
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rtr1 <= 0;
  else if (sample_point & rx_rtr1 & (~bit_de_stuff))
    rtr1 <=#Tp sampled_bit;
end
 
 
// rtr2 bit
always @ (posedge clk or posedge rst)
begin
  if (rst)
    rtr2 <= 0;
  else if (sample_point & rx_rtr2 & (~bit_de_stuff))
    rtr2 <=#Tp sampled_bit;
end
 
 
// ide bit
always @ (posedge clk or posedge rst)
begin
  if (rst)
    ide <= 0;
  else if (sample_point & rx_ide & (~bit_de_stuff))
    ide <=#Tp sampled_bit;
end
 
 
// Data length
always @ (posedge clk or posedge rst)
begin
  if (rst)
    data_len <= 0;
  else if (sample_point & rx_dlc & (~bit_de_stuff))
    data_len <=#Tp {data_len[2:0], sampled_bit};
end
 
 
// Data
reg [7:0] tmp_data;
reg [7:0] tmp_fifo [0:7];
always @ (posedge clk or posedge rst)
begin
  if (rst)
    tmp_data <= 0;
  else if (sample_point & rx_data & (~bit_de_stuff))
    tmp_data <=#Tp {tmp_data[6:0], sampled_bit};
end
 
 
reg write_data_to_tmp_fifo;
always @ (posedge clk or posedge rst)
begin
  if (rst)
    write_data_to_tmp_fifo <= 0;
  else if (sample_point & rx_data & (~bit_de_stuff) & (&bit_cnt[2:0]))
    write_data_to_tmp_fifo <=#Tp 1'b1;
  else
    write_data_to_tmp_fifo <=#Tp 0;
end
 
 
reg [2:0] byte_cnt;
always @ (posedge clk or posedge rst)
begin
  if (rst)
    byte_cnt <= 0;
  else if (write_data_to_tmp_fifo)
    byte_cnt <=#Tp byte_cnt + 1;
  else if (sample_point & go_rx_crc_lim)
    byte_cnt <=#Tp 0;
end
 
 
always @ (posedge clk or posedge rst)
begin
  if (write_data_to_tmp_fifo)
    tmp_fifo[byte_cnt] <=#Tp tmp_data;
end
 
 
 
// CRC
always @ (posedge clk or posedge rst)
begin
  if (rst)
    crc_in <= 0;
  else if (sample_point & rx_crc & (~bit_de_stuff))
    crc_in <=#Tp {crc_in[13:0], sampled_bit};
end
 
 
// bit_cnt
always @ (posedge clk or posedge rst)
begin
  if (rst)
    bit_cnt <= 0;
  else if (go_rx_id1 | go_rx_id2 | go_rx_dlc | go_rx_data | go_rx_crc | go_rx_ack | go_rx_eof)
    bit_cnt <=#Tp 0;
  else if (sample_point & (~bit_de_stuff))
    bit_cnt <=#Tp bit_cnt + 1'b1;
end
 
 
// eof_cnt
always @ (posedge clk or posedge rst)
begin
  if (rst)
    eof_cnt <= 0;
  else if (sample_point)
    begin
      if (rx_eof & sampled_bit)
        eof_cnt <=#Tp eof_cnt + 1'b1;
      else
        eof_cnt <=#Tp 0;
    end
end
 
 
// Enabling bit de-stuffing
reg bit_stuff_cnt_en;
always @ (posedge clk or posedge rst)
begin
  if (rst)
    bit_stuff_cnt_en <= 1'b0;
  else if (bit_de_stuff_set)
    bit_stuff_cnt_en <=#Tp 1'b1;
  else if (bit_de_stuff_reset)
    bit_stuff_cnt_en <=#Tp 1'b0;
end
 
// bit_stuff_cnt
always @ (posedge clk or posedge rst)
begin
  if (rst)
    bit_stuff_cnt <= 1;
  else if (bit_de_stuff_reset)
    bit_stuff_cnt <=#Tp 1;
  else if (sample_point & bit_stuff_cnt_en)
    begin
      if (bit_stuff_cnt == 5)
        bit_stuff_cnt <=#Tp 1;
      else if (sampled_bit == sampled_bit_q)
        bit_stuff_cnt <=#Tp bit_stuff_cnt + 1'b1;
      else
        bit_stuff_cnt <=#Tp 1;
    end
end
 
 
assign bit_de_stuff = bit_stuff_cnt == 5;
 
 
// stuff_error
always @ (posedge clk or posedge rst)
begin
  if (rst)
    stuff_error <= 0;
  else if (sample_point & (rx_id1) & bit_de_stuff & (sampled_bit == sampled_bit_q))   // Add other stages (data, control, etc.) !!!
    stuff_error <=#Tp 1'b1;
//  else if (reset condition)       // Add reset condition
//    stuff_error <=#Tp 0;
end
 
 
// Generating delayed reset_mode signal
always @ (posedge clk)
begin
  reset_mode_q <=#Tp reset_mode;
end
 
 
 
always @ (posedge clk or posedge rst)
begin
  if (rst)
    crc_enable <= 1'b0;
  else if (go_crc_enable)
    crc_enable <=#Tp 1'b1;
  else if (reset_mode | rst_crc_enable)
    crc_enable <=#Tp 1'b0;
end
 
 
reg crc_error;
// CRC error generation
always @ (posedge clk or posedge rst)
begin
  if (rst)
    crc_error <= 0;
  else if (go_rx_ack)
    crc_error <=#Tp crc_in != calculated_crc;
  else if (reset_mode | rx_eof)
    crc_error <=#Tp 0;
end
 
 
 
// Instantiation of the RX CRC module
can_crc i_can_crc_rx
(
  .clk(clk),
//  .data(sampled_bit & (~rx_crc)),     // Zeros are shifted in for calculation when we are in crc stage
  .data(sampled_bit ),     // Zeros are shifted in for calculation when we are in crc stage
  .enable(crc_enable & sample_point & (~bit_de_stuff)),
  .initialize(rx_eof),
  .crc(calculated_crc)
);
 
 
 
wire          id_ok;        // If received ID matches ID set in registers
wire          no_byte0;     // There is no byte 0 (RTR bit set to 1 or DLC field equal to 0). Signal used for acceptance filter.
wire          no_byte1;     // There is no byte 1 (RTR bit set to 1 or DLC field equal to 1). Signal used for acceptance filter.
 
assign no_byte0 = rtr1 | (data_len<1);
assign no_byte1 = rtr1 | (data_len<2);
 
can_acf i_can_acf
(
  .clk(clk),
  .rst(rst),
 
  .id(id),
 
  /* Mode register */
  .reset_mode(reset_mode),
  .acceptance_filter_mode(acceptance_filter_mode),
 
  // Clock Divider register
  .extended_mode(extended_mode),
 
  /* This section is for BASIC and EXTENDED mode */
  /* Acceptance code register */
  .acceptance_code_0(acceptance_code_0),
 
  /* Acceptance mask register */
  .acceptance_mask_0(acceptance_mask_0),
  /* End: This section is for BASIC and EXTENDED mode */
 
  /* This section is for EXTENDED mode */
  /* Acceptance code register */
  .acceptance_code_1(acceptance_code_1),
  .acceptance_code_2(acceptance_code_2),
  .acceptance_code_3(acceptance_code_3),
 
  /* Acceptance mask register */
  .acceptance_mask_1(acceptance_mask_1),
  .acceptance_mask_2(acceptance_mask_2),
  .acceptance_mask_3(acceptance_mask_3),
  /* End: This section is for EXTENDED mode */
 
  .sample_point(sample_point),
  .go_rx_crc_lim(go_rx_crc_lim),
  .go_rx_idle(go_rx_idle),
 
  .data0(tmp_fifo[0]),
  .data1(tmp_fifo[1]),
  .rtr1(rtr1),
  .rtr2(rtr2),
  .ide(ide),
  .no_byte0(no_byte0),
  .no_byte1(no_byte1),
 
  .id_ok(id_ok)
 
);
 
 
 
reg [3:0]   data_cnt;       // Counting the data bytes that are written to FIFO
reg [2:0]   header_cnt;     // Counting header length
reg         wr_fifo;        // Write data and header to 64-byte fifo
reg [7:0]   data_for_fifo;  // Multiplexed data that is stored to 64-byte fifo
 
 
wire [2:0]  header_len;
wire        storing_header;
wire [3:0]  limited_data_len;
wire        reset_wr_fifo;
 
assign header_len[2:0] = extended_mode ? (ide? (3'h5) : (3'h3)) : 3'h2;
assign storing_header = header_cnt < header_len;
assign limited_data_len[3:0] = (data_len < 8)? (data_len -1'b1) : 4'h7;   // - 1 because counter counts from 0
assign reset_wr_fifo = data_cnt == limited_data_len + header_len;
 
 
// Write enable signal for 64-byte rx fifo
always @ (posedge clk or posedge rst)
begin
  if (rst)
    wr_fifo <= 1'b0;
  else if (reset_wr_fifo)
    wr_fifo <=#Tp 1'b0;
  else if (go_rx_ack_lim & (~extended_mode) & id_ok & (~crc_error))
    wr_fifo <=#Tp 1'b1;
end
 
 
// Header counter. Header length depends on the mode of operation and frame format.
always @ (posedge clk or posedge rst)
begin
  if (rst)
    header_cnt <= 0;
  else if (reset_wr_fifo)
    header_cnt <=#Tp 0;
  else if (wr_fifo & storing_header)
    header_cnt <=#Tp header_cnt + 1;
end
 
 
// Data counter. Length of the data is limited to 8 bytes.
always @ (posedge clk or posedge rst)
begin
  if (rst)
    data_cnt <= 0;
  else if (reset_wr_fifo)
    data_cnt <=#Tp 0;
  else if (wr_fifo)
    data_cnt <=#Tp data_cnt + 1;
end
 
 
// Multiplexing data that is stored to 64-byte fifo depends on the mode of operation and frame format
always @ (extended_mode or ide or data_cnt or header_cnt or storing_header or id or rtr1 or rtr2 or data_len or
          tmp_fifo[0] or tmp_fifo[2] or tmp_fifo[4] or tmp_fifo[6] or
          tmp_fifo[1] or tmp_fifo[3] or tmp_fifo[5] or tmp_fifo[7])
begin
  if (storing_header)
    begin
      if (extended_mode)      // extended mode
        begin
          if (ide)              // extended format
            begin
              case (header_cnt)            // synopsys parallel_case synopsys full_case
                4'h0  : data_for_fifo <= {1'b1, rtr2, 2'h0, data_len};
                4'h1  : data_for_fifo <= id[28:21];
                4'h2  : data_for_fifo <= id[20:13];
                4'h3  : data_for_fifo <= id[12:5];
                4'h4  : data_for_fifo <= {id[4:0], 3'h0};
              endcase
            end
          else                  // standard format
            begin
              case (header_cnt)            // synopsys parallel_case synopsys full_case
                4'h0  : data_for_fifo <= {1'b0, rtr1, 2'h0, data_len};
                4'h1  : data_for_fifo <= id[10:3];
                4'h2  : data_for_fifo <= {id[2:0], 5'h0};
              endcase
            end
        end
      else                    // normal mode
        begin
          case (header_cnt)            // synopsys parallel_case synopsys full_case
            4'h0  : data_for_fifo <= id[10:3];
            4'h1  : data_for_fifo <= {id[2:0], rtr1, data_len};
          endcase
        end
    end
  else
    data_for_fifo <= tmp_fifo[data_cnt-header_len];
end
 
 
 
 
// Instantiation of the RX fifo module
can_fifo i_can_fifo
(
  .clk(clk),
  .rst(rst),
 
  .rd(1'b0),                // FIX ME
  .wr(wr_fifo),
 
  .data_in(data_for_fifo),
  .addr(addr),
  .data_out(data_out),
 
  .reset_mode(reset_mode),
  .release_buffer(release_buffer),
  .extended_mode(extended_mode)
 
 
);
 
 
 
 
 
 
 
 
endmodule

Line No.	Rev	Author	Line
1	2	mohor	`//////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// can_bsp.v ////`
4			`//// ////`
5			`//// ////`
6	9	mohor	`//// This file is part of the CAN Protocol Controller ////`
7	2	mohor	`//// http://www.opencores.org/projects/can/ ////`
8			`//// ////`
9			`//// ////`
10			`//// Author(s): ////`
11			`//// Igor Mohor ////`
12			`//// igorm@opencores.org ////`
13			`//// ////`
14			`//// ////`
15	9	mohor	`//// All additional information is available in the README.txt ////`
16	2	mohor	`//// file. ////`
17			`//// ////`
18			`//////////////////////////////////////////////////////////////////////`
19			`//// ////`
20	9	mohor	`//// Copyright (C) 2002, 2003 Authors ////`
21	2	mohor	`//// ////`
22			`//// This source file may be used and distributed without ////`
23			`//// restriction provided that this copyright statement is not ////`
24			`//// removed from the file and that any derivative work contains ////`
25			`//// the original copyright notice and the associated disclaimer. ////`
26			`//// ////`
27			`//// This source file is free software; you can redistribute it ////`
28			`//// and/or modify it under the terms of the GNU Lesser General ////`
29			`//// Public License as published by the Free Software Foundation; ////`
30			`//// either version 2.1 of the License, or (at your option) any ////`
31			`//// later version. ////`
32			`//// ////`
33			`//// This source is distributed in the hope that it will be ////`
34			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
35			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
36			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
37			`//// details. ////`
38			`//// ////`
39			`//// You should have received a copy of the GNU Lesser General ////`
40			`//// Public License along with this source; if not, download it ////`
41			`//// from http://www.opencores.org/lgpl.shtml ////`
42			`//// ////`
43			`//////////////////////////////////////////////////////////////////////`
44			`//`
45			`// CVS Revision History`
46			`//`
47			`// $Log: not supported by cvs2svn $`
48	16	mohor	`// Revision 1.8 2003/01/10 17:51:33 mohor`
49			`// Temporary version (backup).`
50			`//`
51	15	mohor	`// Revision 1.7 2003/01/09 21:54:45 mohor`
52			`// rx fifo added. Not 100 % verified, yet.`
53			`//`
54	14	mohor	`// Revision 1.6 2003/01/09 14:46:58 mohor`
55			`// Temporary files (backup).`
56			`//`
57	13	mohor	`// Revision 1.5 2003/01/08 13:30:31 mohor`
58			`// Temp version.`
59			`//`
60	12	mohor	`// Revision 1.4 2003/01/08 02:10:53 mohor`
61			`// Acceptance filter added.`
62			`//`
63	11	mohor	`// Revision 1.3 2002/12/28 04:13:23 mohor`
64			`// Backup version.`
65			`//`
66	10	mohor	`// Revision 1.2 2002/12/27 00:12:52 mohor`
67			`// Header changed, testbench improved to send a frame (crc still missing).`
68			`//`
69	9	mohor	`// Revision 1.1.1.1 2002/12/20 16:39:21 mohor`
70			`// Initial`
71	2	mohor	`//`
72			`//`
73	9	mohor	`//`
74	2	mohor
75			`// synopsys translate_off`
76			`include "timescale.v"
77			`// synopsys translate_on`
78			`include "can_defines.v"
79
80			`module can_bsp`
81			`(`
82			`clk,`
83	10	mohor	`rst,`
84
85			`sample_point,`
86			`sampled_bit,`
87			`sampled_bit_q,`
88	11	mohor	`hard_sync,`
89			`resync,`
90
91	14	mohor	`addr,`
92			`data_out,`
93
94
95	11	mohor	`/* Mode register */`
96	10	mohor	`reset_mode,`
97	11	mohor	`acceptance_filter_mode,`
98
99	15	mohor	`/* Command register */`
100			`release_buffer,`
101
102			`/* Clock Divider register */`
103	11	mohor	`extended_mode,`
104
105			`rx_idle,`
106
107			`/* This section is for BASIC and EXTENDED mode */`
108			`/* Acceptance code register */`
109			`acceptance_code_0,`
110
111			`/* Acceptance mask register */`
112			`acceptance_mask_0,`
113			`/* End: This section is for BASIC and EXTENDED mode */`
114	10	mohor
115	11	mohor	`/* This section is for EXTENDED mode */`
116			`/* Acceptance code register */`
117			`acceptance_code_1,`
118			`acceptance_code_2,`
119			`acceptance_code_3,`
120	10	mohor
121	11	mohor	`/* Acceptance mask register */`
122			`acceptance_mask_1,`
123			`acceptance_mask_2,`
124			`acceptance_mask_3`
125			`/* End: This section is for EXTENDED mode */`
126	10	mohor
127	2	mohor	`);`
128
129			`parameter Tp = 1;`
130
131	10	mohor	`input clk;`
132			`input rst;`
133			`input sample_point;`
134			`input sampled_bit;`
135			`input sampled_bit_q;`
136	11	mohor	`input hard_sync;`
137			`input resync;`
138	14	mohor	`input [7:0] addr;`
139			`output [7:0] data_out;`
140	11	mohor
141	14	mohor
142	10	mohor	`input reset_mode;`
143	11	mohor	`input acceptance_filter_mode;`
144			`input extended_mode;`
145	2	mohor
146	15	mohor	`/* Command register */`
147			`input release_buffer;`
148	11	mohor
149	10	mohor	`output rx_idle;`
150	2	mohor
151	11	mohor	`/* This section is for BASIC and EXTENDED mode */`
152			`/* Acceptance code register */`
153			`input [7:0] acceptance_code_0;`
154
155			`/* Acceptance mask register */`
156			`input [7:0] acceptance_mask_0;`
157
158			`/* End: This section is for BASIC and EXTENDED mode */`
159
160
161			`/* This section is for EXTENDED mode */`
162			`/* Acceptance code register */`
163			`input [7:0] acceptance_code_1;`
164			`input [7:0] acceptance_code_2;`
165			`input [7:0] acceptance_code_3;`
166
167			`/* Acceptance mask register */`
168			`input [7:0] acceptance_mask_1;`
169			`input [7:0] acceptance_mask_2;`
170			`input [7:0] acceptance_mask_3;`
171
172			`/* End: This section is for EXTENDED mode */`
173
174
175
176	10	mohor	`reg reset_mode_q;`
177			`reg [5:0] bit_cnt;`
178	2	mohor
179	10	mohor	`reg [3:0] data_len;`
180			`reg [28:0] id;`
181			`reg [2:0] bit_stuff_cnt;`
182			`reg stuff_error;`
183
184			`wire bit_de_stuff;`
185
186
187			`/* Rx state machine */`
188			`wire go_rx_idle;`
189			`wire go_rx_id1;`
190			`wire go_rx_rtr1;`
191			`wire go_rx_ide;`
192			`wire go_rx_id2;`
193			`wire go_rx_rtr2;`
194			`wire go_rx_r1;`
195			`wire go_rx_r0;`
196			`wire go_rx_dlc;`
197			`wire go_rx_data;`
198			`wire go_rx_crc;`
199	11	mohor	`wire go_rx_crc_lim;`
200	10	mohor	`wire go_rx_ack;`
201	11	mohor	`wire go_rx_ack_lim;`
202	10	mohor	`wire go_rx_eof;`
203
204	11	mohor	`wire go_crc_enable;`
205			`wire rst_crc_enable;`
206
207			`wire bit_de_stuff_set;`
208			`wire bit_de_stuff_reset;`
209
210	10	mohor	`reg rx_idle;`
211			`reg rx_id1;`
212			`reg rx_rtr1;`
213			`reg rx_ide;`
214			`reg rx_id2;`
215			`reg rx_rtr2;`
216			`reg rx_r1;`
217			`reg rx_r0;`
218			`reg rx_dlc;`
219			`reg rx_data;`
220			`reg rx_crc;`
221	11	mohor	`reg rx_crc_lim;`
222	10	mohor	`reg rx_ack;`
223	11	mohor	`reg rx_ack_lim;`
224	10	mohor	`reg rx_eof;`
225
226	11	mohor	`reg crc_enable;`
227
228	10	mohor	`reg [2:0] eof_cnt;`
229	11	mohor	`wire [14:0] calculated_crc;`
230	10	mohor
231	11	mohor	`assign go_rx_idle = sample_point & rx_eof & (eof_cnt == 6);`
232			`assign go_rx_id1 = sample_point & rx_idle & (~sampled_bit);`
233			`assign go_rx_rtr1 = (~bit_de_stuff) & sample_point & rx_id1 & (bit_cnt == 10);`
234			`assign go_rx_ide = (~bit_de_stuff) & sample_point & rx_rtr1;`
235			`assign go_rx_id2 = (~bit_de_stuff) & sample_point & rx_ide & sampled_bit;`
236			`assign go_rx_rtr2 = (~bit_de_stuff) & sample_point & rx_id2 & (bit_cnt == 17);`
237			`assign go_rx_r1 = (~bit_de_stuff) & sample_point & rx_rtr2;`
238			`assign go_rx_r0 = (~bit_de_stuff) & sample_point & (rx_ide & (~sampled_bit) \| rx_r1);`
239			`assign go_rx_dlc = (~bit_de_stuff) & sample_point & rx_r0;`
240			`assign go_rx_data = (~bit_de_stuff) & sample_point & rx_dlc & (bit_cnt == 3) & (sampled_bit \| (\|data_len[2:0]));`
241			`assign go_rx_crc = (~bit_de_stuff) & sample_point & (rx_dlc & (bit_cnt == 3) & (~sampled_bit) & (~(\|data_len[2:0])) \|`
242			`rx_data & (bit_cnt == ((data_len<<3) - 1'b1)));`
243			`assign go_rx_crc_lim = sample_point & rx_crc & (bit_cnt == 14);`
244			`assign go_rx_ack = sample_point & rx_crc_lim;`
245			`assign go_rx_ack_lim = sample_point & rx_ack;`
246			`assign go_rx_eof = sample_point & rx_ack_lim \| (~reset_mode) & reset_mode_q;`
247	10	mohor
248	11	mohor	`assign go_crc_enable = hard_sync;`
249			`assign rst_crc_enable = go_rx_crc;`
250	10	mohor
251	11	mohor	`assign bit_de_stuff_set = go_rx_id1;`
252			`assign bit_de_stuff_reset = go_rx_crc_lim;`
253
254
255	10	mohor	`// Rx idle state`
256			`always @ (posedge clk or posedge rst)`
257			`begin`
258			`if (rst)`
259			`rx_idle <= 1'b1;`
260			`else if (reset_mode \| go_rx_id1)`
261			`rx_idle <=#Tp 1'b0;`
262			`else if (go_rx_idle)`
263			`rx_idle <=#Tp 1'b1;`
264			`end`
265
266
267			`// Rx id1 state`
268			`always @ (posedge clk or posedge rst)`
269			`begin`
270			`if (rst)`
271			`rx_id1 <= 1'b0;`
272			`else if (reset_mode \| go_rx_rtr1)`
273			`rx_id1 <=#Tp 1'b0;`
274			`else if (go_rx_id1)`
275			`rx_id1 <=#Tp 1'b1;`
276			`end`
277
278
279			`// Rx rtr1 state`
280			`always @ (posedge clk or posedge rst)`
281			`begin`
282			`if (rst)`
283			`rx_rtr1 <= 1'b0;`
284			`else if (reset_mode \| go_rx_ide)`
285			`rx_rtr1 <=#Tp 1'b0;`
286			`else if (go_rx_rtr1)`
287			`rx_rtr1 <=#Tp 1'b1;`
288			`end`
289
290
291			`// Rx ide state`
292			`always @ (posedge clk or posedge rst)`
293			`begin`
294			`if (rst)`
295			`rx_ide <= 1'b0;`
296			`else if (reset_mode \| go_rx_r0 \| go_rx_id2)`
297			`rx_ide <=#Tp 1'b0;`
298			`else if (go_rx_ide)`
299			`rx_ide <=#Tp 1'b1;`
300			`end`
301
302
303			`// Rx id2 state`
304			`always @ (posedge clk or posedge rst)`
305			`begin`
306			`if (rst)`
307			`rx_id2 <= 1'b0;`
308			`else if (reset_mode \| go_rx_rtr2)`
309			`rx_id2 <=#Tp 1'b0;`
310			`else if (go_rx_id2)`
311			`rx_id2 <=#Tp 1'b1;`
312			`end`
313
314
315			`// Rx rtr2 state`
316			`always @ (posedge clk or posedge rst)`
317			`begin`
318			`if (rst)`
319			`rx_rtr2 <= 1'b0;`
320			`else if (reset_mode \| go_rx_r1)`
321			`rx_rtr2 <=#Tp 1'b0;`
322			`else if (go_rx_rtr2)`
323			`rx_rtr2 <=#Tp 1'b1;`
324			`end`
325
326
327			`// Rx r0 state`
328			`always @ (posedge clk or posedge rst)`
329			`begin`
330			`if (rst)`
331			`rx_r1 <= 1'b0;`
332			`else if (reset_mode \| go_rx_r0)`
333			`rx_r1 <=#Tp 1'b0;`
334			`else if (go_rx_r1)`
335			`rx_r1 <=#Tp 1'b1;`
336			`end`
337
338
339			`// Rx r0 state`
340			`always @ (posedge clk or posedge rst)`
341			`begin`
342			`if (rst)`
343			`rx_r0 <= 1'b0;`
344			`else if (reset_mode \| go_rx_dlc)`
345			`rx_r0 <=#Tp 1'b0;`
346			`else if (go_rx_r0)`
347			`rx_r0 <=#Tp 1'b1;`
348			`end`
349
350
351			`// Rx dlc state`
352			`always @ (posedge clk or posedge rst)`
353			`begin`
354			`if (rst)`
355			`rx_dlc <= 1'b0;`
356			`else if (reset_mode \| go_rx_data \| go_rx_crc)`
357			`rx_dlc <=#Tp 1'b0;`
358			`else if (go_rx_dlc)`
359			`rx_dlc <=#Tp 1'b1;`
360			`end`
361
362
363			`// Rx data state`
364			`always @ (posedge clk or posedge rst)`
365			`begin`
366			`if (rst)`
367			`rx_data <= 1'b0;`
368			`else if (reset_mode \| go_rx_crc)`
369			`rx_data <=#Tp 1'b0;`
370			`else if (go_rx_data)`
371			`rx_data <=#Tp 1'b1;`
372			`end`
373
374
375			`// Rx crc state`
376			`always @ (posedge clk or posedge rst)`
377			`begin`
378			`if (rst)`
379			`rx_crc <= 1'b0;`
380	11	mohor	`else if (reset_mode \| go_rx_crc_lim)`
381	10	mohor	`rx_crc <=#Tp 1'b0;`
382			`else if (go_rx_crc)`
383			`rx_crc <=#Tp 1'b1;`
384			`end`
385
386
387	11	mohor	`// Rx crc delimiter state`
388			`always @ (posedge clk or posedge rst)`
389			`begin`
390			`if (rst)`
391			`rx_crc_lim <= 1'b0;`
392			`else if (reset_mode \| go_rx_ack)`
393			`rx_crc_lim <=#Tp 1'b0;`
394			`else if (go_rx_crc_lim)`
395			`rx_crc_lim <=#Tp 1'b1;`
396			`end`
397
398
399	10	mohor	`// Rx ack state`
400			`always @ (posedge clk or posedge rst)`
401			`begin`
402			`if (rst)`
403			`rx_ack <= 1'b0;`
404	11	mohor	`else if (reset_mode \| go_rx_ack_lim)`
405	10	mohor	`rx_ack <=#Tp 1'b0;`
406			`else if (go_rx_ack)`
407			`rx_ack <=#Tp 1'b1;`
408			`end`
409
410
411	11	mohor	`// Rx ack delimiter state`
412			`always @ (posedge clk or posedge rst)`
413			`begin`
414			`if (rst)`
415			`rx_ack_lim <= 1'b0;`
416			`else if (reset_mode \| go_rx_eof)`
417			`rx_ack_lim <=#Tp 1'b0;`
418			`else if (go_rx_ack_lim)`
419			`rx_ack_lim <=#Tp 1'b1;`
420			`end`
421
422
423	10	mohor	`// Rx eof state`
424			`always @ (posedge clk or posedge rst)`
425			`begin`
426			`if (rst)`
427			`rx_eof <= 1'b0;`
428			`else if (go_rx_idle)`
429			`rx_eof <=#Tp 1'b0;`
430			`else if (go_rx_eof)`
431			`rx_eof <=#Tp 1'b1;`
432			`end`
433
434
435
436
437	11	mohor	`reg rtr1;`
438			`reg ide;`
439			`reg rtr2;`
440			`reg [14:0] crc_in;`
441	10	mohor
442			`// ID register`
443			`always @ (posedge clk or posedge rst)`
444			`begin`
445			`if (rst)`
446			`id <= 0;`
447	11	mohor	`else if (sample_point & (rx_id1 \| rx_id2) & (~bit_de_stuff))`
448	10	mohor	`id <=#Tp {id[27:0], sampled_bit};`
449			`end`
450
451	11	mohor
452			`// rtr1 bit`
453			`always @ (posedge clk or posedge rst)`
454			`begin`
455			`if (rst)`
456			`rtr1 <= 0;`
457			`else if (sample_point & rx_rtr1 & (~bit_de_stuff))`
458			`rtr1 <=#Tp sampled_bit;`
459			`end`
460
461
462			`// rtr2 bit`
463			`always @ (posedge clk or posedge rst)`
464			`begin`
465			`if (rst)`
466			`rtr2 <= 0;`
467			`else if (sample_point & rx_rtr2 & (~bit_de_stuff))`
468			`rtr2 <=#Tp sampled_bit;`
469			`end`
470
471
472			`// ide bit`
473			`always @ (posedge clk or posedge rst)`
474			`begin`
475			`if (rst)`
476			`ide <= 0;`
477			`else if (sample_point & rx_ide & (~bit_de_stuff))`
478			`ide <=#Tp sampled_bit;`
479			`end`
480
481
482	10	mohor	`// Data length`
483			`always @ (posedge clk or posedge rst)`
484			`begin`
485			`if (rst)`
486			`data_len <= 0;`
487			`else if (sample_point & rx_dlc & (~bit_de_stuff))`
488			`data_len <=#Tp {data_len[2:0], sampled_bit};`
489			`end`
490
491
492	11	mohor	`// Data`
493			`reg [7:0] tmp_data;`
494			`reg [7:0] tmp_fifo [0:7];`
495			`always @ (posedge clk or posedge rst)`
496			`begin`
497			`if (rst)`
498			`tmp_data <= 0;`
499			`else if (sample_point & rx_data & (~bit_de_stuff))`
500			`tmp_data <=#Tp {tmp_data[6:0], sampled_bit};`

Browse

Tools

Subversion Repositories can

[/] [can/] [tags/] [rel_6/] [rtl/] [verilog/] [can_bsp.v] - Blame information for rev 16