Subversion Repositories yahamm

-------------------------------------------------------------------------------
-- Yahamm IP core
--
-- This file is part of the Yahamm project
-- http://www.opencores.org/cores/yahamm
--
-- Description
-- A hamming encoder and decoder with single-error correcting and
-- double-error detecting capability. The message length can be configured
-- through a generic. Both the code generator matrix and the parity-check
-- matrix are computed in the VHDL itself.
--
-- Author:
-- - Nicola De Simone, ndesimone@opencores.org
--
-------------------------------------------------------------------------------
--
-- Copyright (C) 2017 Authors and OPENCORES.ORG
--
-- 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
--
-------------------------------------------------------------------------------
 
library ieee;
use ieee.std_logic_1164.all;
 
use std.textio.all;
 
--library ieee_proposed;
--use ieee_proposed.std_logic_1164_additions.all;
--use ieee_proposed.standard_additions.all;
---- pragma synthesis_off
--use ieee_proposed.standard_textio_additions.all;
---- pragma synthesis_on
 
package matrix_pkg is
 
  -----------------------------------------------------------------------------
  -- Here 2D arrays are used to implement matrices.  There are various
  -- limitations to the use of 2D arrays (e.g. limited easy slicing)
  -- that would maybe suggest an implementation with 1Dx1D matrices.
  -- But anyway this would make easy slicing either rows or columns
  -- but not both.  The approach used here is implementing functions
  -- to handle various matrix operations.  Having a 2D type allows to
  -- use one type definition for any matrix.
  -----------------------------------------------------------------------------
 
  type matrix_t is array (integer range <>, integer range<>) of bit;
 
  function get_row (
    constant matrix : matrix_t;
    constant row    : natural)
    return bit_vector;
 
  function get_col (
    constant matrix : matrix_t;
    constant col    : natural)
    return bit_vector;
 
  procedure set_col (
    variable M : inout matrix_t;
    constant icol    : natural;
    constant col : bit_vector);
 
-- pragma synthesis_off
  procedure pretty_print_matrix (
    constant matrix : in matrix_t);
 
  procedure pretty_print_vector (
    constant vin : in bit_vector);
-- pragma synthesis_on
 
  function find_col (
    constant M   : matrix_t;
    constant col : bit_vector)
    return integer;
 
  procedure swap_cols (
    variable M       : inout matrix_t;
    constant icol1, icol2 : in natural);
 
  function and_reduce (L  : BIT_VECTOR) return BIT;
  function or_reduce (L  : BIT_VECTOR) return BIT;
  function xor_reduce (L  : BIT_VECTOR) return BIT;
 
end package matrix_pkg;
 
package body matrix_pkg is
 
  -- purpose: Return matrix M with columns at positions col1 and col2
  -- swapped.
  procedure swap_cols (
    variable M          : inout matrix_t;
    constant icol1, icol2 : in natural) is
 
    variable col1, col2 : bit_vector(M'range(1));
    variable Mout : matrix_t(M'range(1), M'range(2));
 
  begin
 
    col1 := get_col(M, icol1);
    col2 := get_col(M, icol2);
 
    set_col(M, icol1, col2);
    set_col(M, icol2, col1);
 
  end procedure swap_cols;
 
  -- purpose: Return the matrix row.
  function get_row (
    constant matrix : matrix_t;
    constant row    : natural)
    return bit_vector is
    variable y : bit_vector(matrix'range(2));
  begin  -- function get_row
 
    for col in matrix'range(2) loop
      y(col) := matrix(row, col);
    end loop;  -- irow
 
    return y;
  end function get_row;
 
  -- purpose: Return the matrix col.
  function get_col (
    constant matrix : matrix_t;
    constant col    : natural)
    return bit_vector is
    variable y : bit_vector(matrix'range(1));
  begin  -- function get_col
 
    for row in matrix'range(1) loop
      y(row) := matrix(row, col);
    end loop;  -- irow
 
    return y;
  end function get_col;
 
  -- purpose: Set the matrix column icol to col.
  procedure set_col (
    variable M : inout matrix_t;
    constant icol    : natural;
    constant col : bit_vector) is
  begin  -- function get_col
 
    for row in M'range(1) loop
      M(row, icol) := col(row);
    end loop;  -- irow
 
  end procedure set_col;
 
-- pragma synthesis_off
 
  -- purpose: Print out matrix for debugging.
  procedure pretty_print_matrix (
    constant matrix : in matrix_t) is
    variable l : line;
 
  begin  -- procedure pretty_print_matrix
 
    for row in matrix'range(1) loop
 
      for col in matrix'range(2) loop
        write(l, matrix(row, col));
        swrite(l, " ");
      end loop;  -- col
 
      writeline(output, l);
    end loop;  -- row
 
    writeline(output, l);               -- blank line
 
  end procedure pretty_print_matrix;
 
  -- purpose: Print out vector for debugging.
  procedure pretty_print_vector (
    constant vin : in bit_vector) is
    variable l : line;
 
  begin  -- procedure pretty_print_matrix
 
    swrite(l, integer'image(vin'left));
    swrite(l, " to/downto ");
    swrite(l, integer'image(vin'right));
    swrite(l, ": ");
    for i in vin'range loop
      write(l, vin(i));
      swrite(l, " ");
    end loop;  -- i
 
    writeline(output, l);
    writeline(output, l);               -- blank line
 
  end procedure pretty_print_vector;
 
-- pragma synthesis_on
 
  -- purpose: Return the position of col in M or -1 if not found.
  function find_col (
    constant M   : matrix_t;                -- Any matrix
    constant col : bit_vector)  -- The column to find
    return integer is
    variable match : boolean;
  begin  -- function find_col
    for icol in M'range(2) loop
 
      match := true;
      for j in col'range loop
        if col(j) /= M(j, icol) then
          match := false;
        end if;
      end loop;
 
      if match then
        return icol;
      end if;
 
    end loop;
 
    -- not found
    return -1;
  end function find_col;
 
  function and_reduce (L : BIT_VECTOR) return BIT is
    variable result : BIT := '1';
  begin
    for i in l'reverse_range loop
      result := l(i) and result;
    end loop;
    return result;
  end function and_reduce;
 
  function or_reduce (L : BIT_VECTOR) return BIT is
    variable result : BIT := '0';
  begin
    for i in l'reverse_range loop
      result := l(i) or result;
    end loop;
    return result;
  end function or_reduce;
 
  function xor_reduce (L : BIT_VECTOR) return BIT is
    variable result : BIT := '0';
  begin
    for i in l'reverse_range loop
      result := l(i) xor result;
    end loop;
    return result;
  end function xor_reduce;
 
end package body matrix_pkg;