---------------------------------------------------------------------------------------------------------------
-- RISA Project
-- Author: A.Greensted
-- Module:
-- Description:
-- History:
---------------------------------------------------------------------------------------------------------------

library ieee;
use ieee.std_logic_1164.all;

library SnapLib;
use SnapLib.SnapPkg.all;

entity FlagsRegisters is
	port (	clk					: in		std_logic;
				enable				: in		std_logic;
				nReset				: in		std_logic;

				dIn					: in		std_logic_vector(12 downto 0);

				flagReg0WEn			: in		std_logic;
				flagReg0Out			: out		std_logic_vector(15 downto 0);
				flagReg1WEn			: in		std_logic;
				flagReg1Out			: out		std_logic_vector(15 downto 0);

				extFlagsIn			: in		SNAPTYPE_EXTERNAL_FLAGS;

				aluFlagsWEn			: in		std_logic;
				aluFlagsIn			: in		SNAPTYPE_ALU_FLAGS;

				conditionCodeWEn	: in		std_logic;
				conditionCodeIn	: in		SNAPTYPE_CONDITION_CODE;

				intFlagsWEn			: in		std_logic;
				intFlagsIn			: in		std_logic_vector(7 downto 0);
				intFlagsMaskIn		: in		std_logic_vector(7 downto 0);

				setGIEEn				: in		std_logic;
				clrGIEEn				: in		std_logic;

				flagsOut				: out		SNAPTYPE_FLAGS;
				conditionCodeOut	: out		SNAPTYPE_CONDITION_CODE);

end FlagsRegisters;

architecture General of FlagsRegisters is

	signal internalFlags		: SNAPTYPE_INTERNAL_FLAGS;

	signal conditionReg		: SNAPTYPE_CONDITION_CODE;

	signal extFlagsMasked	: std_logic_vector(7 downto 0);
	signal extFlagsMask		: std_logic_vector(7 downto 0);

begin

-- Create Masked External Flags
extFlagsMasked <= extFlagsIn.flags and extFlagsMask;

-- Connect flags and condition code outputs
flagsOut.intFlags			<= internalFlags;
flagsOut.extFlags.flags	<= extFlagsMasked;

conditionCodeOut	<= conditionReg;

-- Connect FlagsRegister 0
flagReg0Out(15 downto 13)	<= (others => '0');
flagReg0Out(12 downto 8)	<= to_std_logic_vector(conditionReg);
flagReg0Out(7)					<= internalFlags.globalInterruptEn;
flagReg0Out(6)					<= internalFlags.equalityTests(2);
flagReg0Out(5)					<= internalFlags.equalityTests(1);
flagReg0Out(4)					<= internalFlags.equalityTests(0);
flagReg0Out(2)					<= internalFlags.aluFlags.negative;
flagReg0Out(3)					<= internalFlags.aluFlags.overflow;
flagReg0Out(1)					<= internalFlags.aluFlags.carryBorrow;
flagReg0Out(0)					<= internalFlags.aluFlags.zero;

-- Connect FlagsRegister 1
flagReg1Out(15 downto 8)	<= extFlagsMasked;
flagReg1Out(7 downto 0)		<= extFlagsMask;


FReg : process(clk)
begin

	if (clk'event and clk='1') then

		if (nReset='0') then
			internalFlags	<= SNAP_INTERNAL_FLAGS_RESET;
			conditionReg	<= SNAP_CC_ZERO;
			extFlagsMask	<= (others => '0');

		elsif (enable='1') then

			-- Write Internal flags (fset instruction)
			if (intFlagsWEn='1') then

				if (intFlagsMaskIn(0)='1') then
					internalFlags.aluFlags.zero			<= intFlagsIn(0);
				end if;

				if (intFlagsMaskIn(1)='1') then
					internalFlags.aluFlags.carryBorrow	<= intFlagsIn(1);
				end if;

				if (intFlagsMaskIn(2)='1') then
					internalFlags.aluFlags.negative		<= intFlagsIn(2);
				end if;

				if (intFlagsMaskIn(3)='1') then
					internalFlags.aluFlags.overflow		<= intFlagsIn(3);
				end if;

				if (intFlagsMaskIn(4)='1') then
					internalFlags.equalityTests(0)		<= intFlagsIn(4);
				end if;

				if (intFlagsMaskIn(5)='1') then
					internalFlags.equalityTests(1)		<= intFlagsIn(5);
				end if;

				if (intFlagsMaskIn(6)='1') then
					internalFlags.equalityTests(2)		<= intFlagsIn(6);
				end if;

			-- Write Flags from ALU
			elsif (aluFlagsWEn='1') then
				internalFlags.aluFlags.zero				<= aluFlagsIn.zero;
				internalFlags.aluFlags.carryBorrow		<= aluFlagsIn.carryBorrow;
				internalFlags.aluFlags.negative			<= aluFlagsIn.negative;
				internalFlags.aluFlags.overflow			<= aluFlagsIn.overflow;
				internalFlags.equalityTests(0)			<= aluFlagsIn.negative xor aluFlagsIn.overflow;
				internalFlags.equalityTests(1)			<= aluFlagsIn.zero or (aluFlagsIn.negative xor aluFlagsIn.overflow);
				internalFlags.equalityTests(2)			<= aluFlagsIn.carryBorrow or aluFlagsIn.zero;

			-- Normal Register write
			elsif (flagReg0WEn='1') then
				internalFlags.aluFlags.zero				<= dIn(0);
				internalFlags.aluFlags.carryBorrow		<= dIn(1);
				internalFlags.aluFlags.negative			<= dIn(2);
				internalFlags.aluFlags.overflow			<= dIn(3);
				internalFlags.equalityTests(0)			<= dIn(4);
				internalFlags.equalityTests(1)			<= dIn(5);
				internalFlags.equalityTests(2)			<= dIn(6);

			end if;


			-- Clear GIE
			if (clrGIEEn='1') then
				internalFlags.globalInterruptEn <= '0';

			-- Set GIE
			elsif (setGIEEn='1') then
				internalFlags.globalInterruptEn <= '1';

			-- Write Internal flags (GIE) (fset instruction)
			elsif (intFlagsWEn='1' and intFlagsMaskIn(7)='1') then
				internalFlags.globalInterruptEn <= intFlagsIn(7);

			-- Normal Register write
			elsif (flagReg0WEn='1') then
				internalFlags.globalInterruptEn <= dIn(7);

			end if;


			-- Write condition (cset Instruction)
			if (conditionCodeWEn='1') then
				conditionReg	<= conditionCodeIn;

			-- Normal Register write
			elsif (flagReg0WEn='1') then
				conditionReg	<= to_SNAPTYPE_CONDITION_CODE( dIn(12 downto 8) );

			end if;

			-- Normal Register write
			if (flagReg1WEn='1') then
				extFlagsMask	<= dIn(7 downto 0);

			end if;

		end if;

	end if;

end process;

end General;