OpenCores
Issue List
alu_trf not complete #3
Closed vm505 opened this issue over 18 years ago
vm505 commented over 18 years ago

alu_tfr not completely supported

The changed source:

case alu_ctrl is
when alu_add8 | alu_adc  =>
    cc_out(CBIT)   <= (left(7) and right(7)) or
                      (left(7) and not out_alu(7)) or
                      (right(7) and not out_alu(7));
when alu_sub8 | alu_sbc  =>
    cc_out(CBIT)   <= ((not left(7)) and right(7)) or
                      ((not left(7)) and out_alu(7)) or
                      (right(7) and out_alu(7));
when alu_add16   =>
    cc_out(CBIT)   <= (left(15) and right(15)) or
                      (left(15) and not out_alu(15)) or
                      (right(15) and not out_alu(15));
when alu_sub16   =>
    cc_out(CBIT)   <= ((not left(15)) and right(15)) or
                      ((not left(15)) and out_alu(15)) or
                      (right(15) and out_alu(15));
when alu_ror8 | alu_lsr16 | alu_lsr8 | alu_asr8 =>
    cc_out(CBIT)   <= left(0);
when alu_rol8 | alu_asl8 =>
    cc_out(CBIT)   <= left(7);
when alu_lsl16   =>
    cc_out(CBIT)   <= left(15);
when alu_com =>
    cc_out(CBIT)   <= '1';
when alu_neg | alu_clr   =>
    cc_out(CBIT)   <= out_alu(7) or out_alu(6) or out_alu(5) or out_alu(4) or
                      out_alu(3) or out_alu(2) or out_alu(1) or out_alu(0);
when alu_daa     =>
    if ( daa_reg(7 downto 4) = "0110" ) then
        cc_out(CBIT) <= '1';
    else
        cc_out(CBIT) <= '0';
    end if;
when alu_andcc   =>
    cc_out(CBIT)   <= left(CBIT) and cc(CBIT);
when alu_orcc    =>
    cc_out(CBIT)   <= left(CBIT) or cc(CBIT);
when alu_tfr   =>
    cc_out(CBIT)   <= left(CBIT); 
when others      =>
    cc_out(CBIT)   <= cc(CBIT);
end case;
--
-- Zero flag
--
case alu_ctrl is
when alu_add8 | alu_sub8 |
    alu_adc | alu_sbc |
    alu_and | alu_ora | alu_eor |
    alu_inc | alu_dec |
    alu_neg | alu_com | alu_clr |
    alu_rol8 | alu_ror8 | alu_asr8 | alu_asl8 | alu_lsr8 |
    alu_ld8 | alu_st8 | alu_sex   =>
    cc_out(ZBIT)   <= not( out_alu(7) or out_alu(6) or out_alu(5) or out_alu(4) or
                           out_alu(3) or out_alu(2) or out_alu(1) or out_alu(0) );
when alu_add16 | alu_sub16 |
    alu_lsl16 | alu_lsr16 |
    alu_ld16 | alu_st16 | alu_lea =>
    cc_out(ZBIT)   <= not( out_alu(15) or out_alu(14) or out_alu(13) or out_alu(12) or
                           out_alu(11) or out_alu(10) or out_alu(9) or out_alu(8) or
                           out_alu(7) or out_alu(6) or out_alu(5) or out_alu(4) or
                           out_alu(3) or out_alu(2) or out_alu(1) or out_alu(0) );
when alu_andcc   =>
    cc_out(ZBIT)   <= left(ZBIT) and cc(ZBIT);
when alu_orcc    =>
    cc_out(ZBIT)   <= left(ZBIT) or cc(ZBIT);
when alu_tfr   =>
    cc_out(ZBIT)   <= left(ZBIT);  
when others      =>
    cc_out(ZBIT)   <= cc(ZBIT);
end case;

--
-- negative flag
--
case alu_ctrl is
when alu_add8 | alu_sub8 |
     alu_adc | alu_sbc |
     alu_and | alu_ora | alu_eor |
     alu_rol8 | alu_ror8 | alu_asr8 | alu_asl8 | alu_lsr8 |
     alu_inc | alu_dec | alu_neg | alu_com | alu_clr |
     alu_ld8 | alu_st8 | alu_sex =>
    cc_out(NBIT) <= out_alu(7);
when alu_add16 | alu_sub16 |
     alu_lsl16 | alu_lsr16 |
     alu_ld16 | alu_st16     =>
    cc_out(NBIT) <= out_alu(15);
when alu_andcc    =>
    cc_out(NBIT) <= left(NBIT) and cc(NBIT);
when alu_orcc =>
    cc_out(NBIT) <= left(NBIT) or cc(NBIT);
when alu_tfr   =>
    cc_out(NBIT) <= left(NBIT); 
when others   =>
    cc_out(NBIT) <= cc(NBIT);
end case;

--
-- Interrupt mask flag
--
case alu_ctrl is
when alu_andcc      =>
    cc_out(IBIT) <= left(IBIT) and cc(IBIT);
when alu_orcc       =>
    cc_out(IBIT) <= left(IBIT) or cc(IBIT);
when alu_tfr   =>
    cc_out(IBIT) <= left(IBIT); 
when alu_seif | alu_sei =>
    cc_out(IBIT) <= '1';
when others =>
    cc_out(IBIT) <= cc(IBIT);       -- interrupt mask
end case;

--
-- Half Carry flag
--
case alu_ctrl is
when alu_add8 | alu_adc =>
    cc_out(HBIT) <= (left(3)  and     right(3)) or
                    (right(3) and not out_alu(3)) or
                    (left(3)  and not out_alu(3));
when alu_andcc      =>
    cc_out(HBIT) <= left(HBIT) and cc(HBIT);
when alu_orcc       =>
    cc_out(HBIT) <= left(HBIT) or cc(HBIT);
when alu_tfr   =>
    cc_out(HBIT) <= left(HBIT); 
when others =>
    cc_out(HBIT) <= cc(HBIT);
end case;

--
-- Overflow flag
--
case alu_ctrl is
when alu_add8 | alu_adc  =>
    cc_out(VBIT) <= (left(7) and right(7) and (not out_alu(7))) or
                    ((not left(7)) and (not right(7)) and out_alu(7));
when alu_sub8 | alu_sbc  =>
    cc_out(VBIT) <= (left(7) and (not right(7)) and (not out_alu(7))) or
                    ((not left(7)) and right(7) and out_alu(7));
when alu_add16       =>
    cc_out(VBIT) <= (left(15) and right(15) and (not out_alu(15))) or
                    ((not left(15)) and (not right(15)) and out_alu(15));
when alu_sub16       =>
    cc_out(VBIT) <= (left(15) and (not right(15)) and (not out_alu(15))) or
                    ((not left(15)) and right(15) and out_alu(15));
when alu_inc =>
    cc_out(VBIT) <= ((not left(7)) and left(6) and left(5) and left(4) and
                     left(3) and left(2) and left(1) and left(0));
when alu_dec | alu_neg   =>
    cc_out(VBIT) <= (left(7) and (not left(6)) and (not left(5)) and (not left(4)) and
                     (not left(3)) and (not left(2)) and (not left(1)) and (not left(0)));
when alu_asr8=>
    cc_out(VBIT) <= left(0) xor left(7);
when alu_lsr8 | alu_lsr16=>
    cc_out(VBIT) <= left(0);
when alu_ror8=>
    cc_out(VBIT) <= left( 0) xor cc(CBIT);
when alu_lsl16       =>
    cc_out(VBIT) <= left(15) xor left(14);
when alu_rol8 | alu_asl8 =>
    cc_out(VBIT) <= left( 7) xor left(6);
when alu_and | alu_ora | alu_eor | alu_com |
    alu_st8 | alu_st16 | alu_ld8 | alu_ld16 | alu_sex =>
    cc_out(VBIT) <= '0';
when alu_andcc       =>
    cc_out(VBIT) <= left(VBIT) and cc(VBIT);
when alu_orcc =>
    cc_out(VBIT) <= left(VBIT) or cc(VBIT);
when alu_tfr   =>
    cc_out(VBIT) <= left(VBIT);  
when others =>
    cc_out(VBIT) <= cc(VBIT);
end case;

case alu_ctrl is
when alu_andcc =>
    cc_out(FBIT) <= left(FBIT) and cc(FBIT);
when alu_orcc =>
    cc_out(FBIT) <= left(FBIT) or cc(FBIT);
when alu_tfr   =>
    cc_out(FBIT) <= left(FBIT); 
when alu_seif =>
    cc_out(FBIT) <= '1';
when others =>
    cc_out(FBIT) <= cc(FBIT);
end case;

case alu_ctrl is
when alu_andcc =>
    cc_out(EBIT) <= left(EBIT) and cc(EBIT);
when alu_orcc =>
    cc_out(EBIT) <= left(EBIT) or cc(EBIT);
when alu_tfr   =>
    cc_out(EBIT) <= left(EBIT);
when alu_see =>
    cc_out(EBIT) <= '1';
when alu_cle =>
    cc_out(EBIT) <= '0';
when others =>
    cc_out(EBIT) <= cc(EBIT);
end case;

end process;


Corrections committed to CVS 17th September 2005

dilbert57@opencores.org

dilbert57 closed this over 18 years ago

Assignee
No one
Labels
Bug