Subversion Repositories System09

--===========================================================================--
--                                                                           --
--                  Synthesizable unsigned 32 bit integer divider            --
--                                                                           --
--===========================================================================--
--
--  File name      : divs32.vhd
--
--  Entity name    : sdiv32
--
--  Purpose        : Implements a 32 bit signed integer divider 
--                  
--  Dependencies   : ieee.std_logic_1164
--                   ieee.numeric_std
--                   ieee.std_logic_unsigned
--
--  Author         : John E. Kent
--
--  Email          : dilbert57@opencores.org      
--
--  Web            : http://opencores.org/project,system09
--
--  Registers      :
--  0 Dividend  1st Byte MSB
--  1           2nd Byte
--  2           3rd Byte 
--  3           4th Byte LSB
--  4 Divisor   1st Byte MSB
--  5           2nd Byte
--  6           3rd Byte
--  7           4th Byte LSB
--  8 quotient    1st Byte MSB
--  9           2nd Byte
-- 10           3rd Byte
-- 11           4th byte LSB
-- 12 Remainder 1st Byte MSB
-- 13           2nd Byte
-- 14           3rd Byte
-- 15           4th byte LSB
--
--  32 bit unsigned binary division.
--
--  Write the most significant byte of the dividend at the 0th register first 
--  down to the least significant byte of the divisor in the 7th register.
--  Writing the least significant byte of the divisor will start the division.
--
--  The 32 bit division will take 32 clock cycles.
--  There is no status register so the CPU must execute a software delay
--  to wait 32 clock cycles after the least significant byte of the divisor 
--  is written before reading the quotient of the division or the remainder.
--
--  The dividend and divisor input registers are read/writable
--  The quotient and remainder output registers are read only.
--  The quotient register holds the integer part of the result of the division.
--  The remainder register holds the dividend modulo the divisor.
--
--  Copyright (C) 2012 - 2014 John Kent
--
--  This program is free software: you can redistribute it and/or modify
--  it under the terms of the GNU General Public License as published by
--  the Free Software Foundation, either version 3 of the License, or
--  (at your option) any later version.
--
--  This program 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 General Public License for more details.
--
--  You should have received a copy of the GNU General Public License
--  along with this program.  If not, see <http://www.gnu.org/licenses/>.
--
--===========================================================================--
--                                                                           --
--                              Revision  History                            --
--                                                                           --
--===========================================================================--
--
-- Version Author        Date         Changes
--
-- 0.1     John Kent     2012-04-06    Initial version
-- 0.2     John Kent     2014-05-07    Replaced Status register with 4 byte remainder
-- 0.3     John Kent     2016-02-04    Shortend result_temp to 33 bits so subtraction is faster.
--                                     Add hold output to pause CPU until result is valid.
-- 0.4     John Kent     2018-03-21    Changed unsigned udiv32 to signed sdiv32
--
library ieee;
  use ieee.std_logic_1164.all;
  use ieee.numeric_std.all;
  use ieee.std_logic_unsigned.all;
--library unisim;
--  use unisim.vcomponents.all;
 
entity sdiv32 is
  port (
    --
    -- CPU Interface signals
    --
    clk      : in  std_logic;                     -- CPU Clock
    rst      : in  std_logic;                     -- Reset input (active high)
    cs       : in  std_logic;                     -- Chip Select
    addr     : in  std_logic_vector(3 downto 0);  -- Register Select
    rw       : in  std_logic;                     -- Read / Not Write
    data_in  : in  std_logic_vector(7 downto 0);  -- Data Bus In 
    data_out : out std_logic_vector(7 downto 0);  -- Data Bus Out
	 hold     : out std_logic                      -- Result access hold
    );
end sdiv32;  
--================== End of entity ==============================--
 
-------------------------------------------------------------------
-- Architecture for unsigned 32 bit integer divider interface
-------------------------------------------------------------------
 
architecture rtl of sdiv32 is
 
signal dividend      : std_logic_vector(31 downto 0) := (others => '0');
signal divisor       : std_logic_vector(31 downto 0) := (others => '0');
signal result        : std_logic_vector(63 downto 0) := (others => '0');
signal quotient      : std_logic_vector(31 downto 0) := (others => '0');
signal remainder     : std_logic_vector(31 downto 0) := (others => '0');
signal count         : std_logic_vector( 4 downto 0) := (others => '0');
signal req_flag      : std_logic := '0';  -- Request Division
signal act_flag      : std_logic := '0';  -- Division Active
 
begin
 
--
-- Write registers
--
sdiv32_write : process( clk, rst, cs, rw, addr, data_in, req_flag, act_flag )
begin
  if rst = '1' then
      dividend    <= (others=> '0');   -- reset the dividend to zero
      divisor     <= (others=> '0');   -- reset the divisor to zero
      req_flag    <= '0';				   -- the default state is stopped
  elsif falling_edge( clk ) then
      --
      -- write to registers
      --
      if (cs = '1') and (rw = '0') then
        case addr is
        when "0000" =>
          dividend(31 downto 24) <= data_in;
        when "0001" =>
          dividend(23 downto 16) <= data_in;
        when "0010" =>
          dividend(15 downto  8) <= data_in;
        when "0011" =>
          dividend( 7 downto  0) <= data_in;
        when "0100" =>
          divisor(31 downto 24)  <= data_in;
        when "0101" =>
          divisor(23 downto 16)  <= data_in;
        when "0110" =>
          divisor(15 downto  8)  <= data_in;
        when "0111" =>
          divisor( 7 downto  0)  <= data_in;
          --
          -- writing the last byte of the divisor 
			 -- should pulse the request flag high for one cycle 
			 -- starting the division,
          -- provided the previous division has finished
          --
			 if (req_flag = '0') and (act_flag = '0') then
				req_flag <= '1';
			 end if;
        when others =>
           null;
        end case;
      end if;
  end if; -- rst/clk
  if (req_flag = '1') and (act_flag = '1') then
    req_flag <= '0';
  end if;
  hold <= cs and rw and addr(3) and act_flag;
end process;
 
--
-- Read registers
--
sdiv32_read : process( addr, dividend, divisor, quotient, remainder )
begin
  case addr is
  when "0000" =>
    data_out <= dividend(31 downto 24);
  when "0001" =>
    data_out <= dividend(23 downto 16);
  when "0010" =>
    data_out <= dividend(15 downto  8);
  when "0011" =>
    data_out <= dividend( 7 downto  0);
  when "0100" =>
    data_out <= divisor(31 downto 24);
  when "0101" =>
    data_out <= divisor(23 downto 16);
  when "0110" =>
    data_out <= divisor(15 downto  8);
  when "0111" =>
    data_out <= divisor( 7 downto  0);
  when "1000" =>
    data_out <= quotient(31 downto 24);
  when "1001" =>
    data_out <= quotient(23 downto 16);
  when "1010" =>
    data_out <= quotient(15 downto  8);
  when "1011" =>
    data_out <= quotient( 7 downto  0);
  when "1100" =>
    data_out <= remainder(31 downto 24);
  when "1101" =>
    data_out <= remainder(23 downto 16);
  when "1110" =>
    data_out <= remainder(15 downto 8);
  when "1111" =>
    data_out <= remainder(7 downto 0);
  when others =>
    null;
  end case;
end process;
 
--
-- When the finish flag is high and the start flag goes high, 
-- start the division by clearing the finish flag
-- When the finish flag is low and the count reaches 31 
sdiv32_divide : process( rst, clk, dividend, divisor, remainder, req_flag, act_flag, count )
variable result_temp  : std_logic_vector(32 downto 0);
begin
    if (rst = '1') then
	   result          <= (others=>'0');
		result_temp     := (others=>'0');
      remainder       <= (others=>'0');
      quotient        <= (others=>'0');
      count           <= (others=>'0');
      act_flag        <= '0';             -- default state is inactive
    elsif falling_edge( clk ) then
      --
      -- activate the division if the last division was complete
		-- i.e. the active flag was clear
      -- and the last byte of the divisor was just written
      -- i.e. the request flag was pulsed high for one clock cycle
		--
      if (req_flag = '1') and (act_flag = '0') then  
		  --
		  -- put dividend in result and make positive
		  --
        result(63 downto 32) <= (others => '0');
		  if dividend(31) = '0' then
          result(31 downto  0) <= dividend;                 -- Dividend in the Least Significant Word of remainder
		  else
		    result(31 downto  0) <= "00000000000000000000000000000000" - dividend;
		  end if;
		  --
		  -- Initialize temp variables
		  --
        result_temp        := (others => '0');            -- Clear the remainder temp variable
		  --
		  -- reset bit counter and activate division
		  --
        count              <= (others => '0');            -- Clear the bit counter
        act_flag           <= '1';                        -- Flag division in progress
 
      elsif (req_flag = '0') and (act_flag = '1') then                              -- If active flag is set the division must be in progress
		  --
		  -- if dividend positive, subrtact divisor
		  -- if dividend negative, add divisor
		  --
        if (divisor(31)) = '0' then 
          result_temp := result(63 downto 31) - (divisor(31) & divisor);   -- subtract the divisor from the remainder if positive
        else
          result_temp := result(63 downto 31) + (divisor(31) & divisor);   -- add the divisor to the remainder if negative
        end if;
 
		  --
		  -- if carry clear from add or subract
		  -- update the remainder
		  --
        if result_temp(32) = '0' then                          -- if the remainder temp carry is clear
          result(63 downto 32) <= result_temp(31 downto 0);    -- update the result with remainder
        else
          result(63 downto 32) <= result(62 downto 31);        -- otherwise shift remainder up one bit
		  end if;
 
        --
        -- shift the quotient up one bit
        -- The LSBit is the inverted remainder carry
        --
        result(31 downto  1) <= result(30 downto 0);        -- shift lower remainder up one bit
		  result(0) <= not result_temp(32);                   -- shift quotient in bottom of remainder
 
        --
        -- 32 bit division should take 32 clock cycles
        --
        count               <= count + "00001";
        --
		  -- When the count reaches the 31st cycle of the division 
        -- flag that the division is complete by clrearing the active flag.
        -- 
        if count = "11111" then
          act_flag <= '0';  -- flag division complete
        end if;
 
      end if; -- start/finish
 
		--
		-- negating the result will take another clock cycle.
		-- If the cpu is held on a read access of the
		-- quotient or remainder it may get the wrong result.
		--
 
		--
		-- quotient has sign of dividend exclusive or divisor
		--
      if( (dividend(31) xor divisor(31)) = '0') then
        quotient <= result(31 downto 0);
      else
        quotient <= "00000000000000000000000000000000" - result(31 downto 0);
      end if;
 
		--
		-- remainder has sign of dividend
		--
		if dividend(31) = '0' then
		  remainder <= result(63 downto 32);
		else
		  remainder <= "00000000000000000000000000000000" - result(63 downto 32);
		end if;
 
    end if; -- rst/clk
end process;
 
end rtl; -- end of architecture