crc8_8.v

用于计算CRC的verilog HDL源码

//////////////////////////////////////////////////////////////////////////////
//
// crc calculation
// This VERILOG code was generated using CRCGEN.PL version 1.6
// Last Modified: 02/26/2001
// Options Used:
//    Module Name = crc32
//      CRC Width = 8
//     Data Width = 8
//     CRC Init   = 0
//     Polynomial = [0 -> 8]
//        1 1 1 0 0 0 0 0 1
//
// Disclaimer: THESE DESIGNS ARE PROVIDED "AS IS" WITH NO WARRANTY 
//             WHATSOEVER AND XILINX SPECIFICALLY DISCLAIMS ANY 
//             IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
//             A PARTICULAR PURPOSE, OR AGAINST INFRINGEMENT.
//
// Copyright (c) 2001 Xilinx, Inc.  All rights reserved.
//
//
//////////////////////////////////////////////////////////////////////////////

module crc32 (
   crc_reg, 
   crc,
   d,
   calc,
   init,
   d_valid,
   clk,
   reset
   );

output [31:0] crc_reg;
output [7:0]  crc;

input  [7:0]  d;
input         calc;
input         init;
input         d_valid;
input         clk;
input         reset;

reg    [31:0] crc_reg;
reg    [7:0]  crc;

//////////////////////////////////////////////////////////////////////////////
// Internal Signals
//////////////////////////////////////////////////////////////////////////////
wire   [31:0] next_crc;

//////////////////////////////////////////////////////////////////////////////
// Infer CRC-8 registers
// 
// The crc_reg register stores the CRC-8 value.
// The crc register is the most significant 8 bits of the 
// CRC-8 value.
//
// Truth Table:
// -----+---------+----------+----------------------------------------------
// calc | d_valid | crc_reg  | crc 
// -----+---------+----------+----------------------------------------------
//  0   |     0   | crc_reg  | crc 
//  0   |     1   |  shift   | bit-swapped, complimented msbyte of crc_reg
//  1   |     0   | crc_reg  | crc 
//  1   |     1   | next_crc | bit-swapped, complimented msbyte of next_crc
// -----+---------+----------+----------------------------------------------
// 
//////////////////////////////////////////////////////////////////////////////
 
always @ (posedge clk or posedge reset)
begin
   if (reset) begin
      crc_reg <= 8'h00;
      crc     <= 8'h00;
   end
   
   else if (init) begin
      crc_reg <= 8'h00;
      crc     <=  8'h00;
   end

   else if (calc & d_valid) begin
      crc_reg <= next_crc;
      crc     <= ~{next_crc[0], next_crc[1], next_crc[2], next_crc[3],
                   next_crc[4], next_crc[5], next_crc[6], next_crc[7]};
   end
   
   else if (~calc & d_valid) begin
      crc_reg <=  {crc_reg[-1:0], 8'h00};
      crc     <= ~{crc_reg[-8], crc_reg[-7], crc_reg[-6], crc_reg[-5],
                   crc_reg[-4], crc_reg[-3], crc_reg[-2], crc_reg[-1]};
   end
end

//////////////////////////////////////////////////////////////////////////////
// CRC XOR equations
//////////////////////////////////////////////////////////////////////////////

assign next_crc[0] = d[7] ^ crc_reg[6] ^ d[0] ^ crc_reg[7] ^ d[1] ^ crc_reg[0];
assign next_crc[1] = d[6] ^ d[7] ^ crc_reg[6] ^ d[1] ^ crc_reg[0] ^ crc_reg[1];
assign next_crc[2] = d[5] ^ d[6] ^ d[7] ^ crc_reg[6] ^ d[1] ^ crc_reg[0] ^ crc_reg[1] ^ crc_reg[2];
assign next_crc[3] = d[4] ^ crc_reg[3] ^ d[5] ^ d[6] ^ crc_reg[7] ^ d[0] ^ crc_reg[1] ^ crc_reg[2];
assign next_crc[4] = d[4] ^ crc_reg[3] ^ d[5] ^ crc_reg[4] ^ crc_reg[2] ^ d[3];
assign next_crc[5] = d[4] ^ crc_reg[3] ^ crc_reg[4] ^ crc_reg[5] ^ d[2] ^ d[3];
assign next_crc[6] = crc_reg[4] ^ crc_reg[5] ^ crc_reg[6] ^ d[1] ^ d[2] ^ d[3];
assign next_crc[7] = crc_reg[5] ^ crc_reg[6] ^ crc_reg[7] ^ d[0] ^ d[1] ^ d[2];
endmodule