开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VHDL/FPGA/Verilog > 查看源码
control_mem_rtl.vhd
资源名称：8051的内核(vhdl).zip　[点击查看]
上传用户：sztwq510
上传日期：2007-04-20
资源大小：209k
文件大小：45k
源码类别：

VHDL/FPGA/Verilog

开发平台：

Matlab

control_mem_rtl.vhd：源码内容
  1. -------------------------------------------------------------------------------
  2. --                                                                           --
  3. --          X       X   XXXXXX    XXXXXX    XXXXXX    XXXXXX      X          --
  4. --          XX     XX  X      X  X      X  X      X  X           XX          --
  5. --          X X   X X  X         X      X  X      X  X          X X          --
  6. --          X  X X  X  X         X      X  X      X  X         X  X          --
  7. --          X   X   X  X          XXXXXX   X      X   XXXXXX      X          --
  8. --          X       X  X         X      X  X      X         X     X          --
  9. --          X       X  X         X      X  X      X         X     X          --
  10. --          X       X  X      X  X      X  X      X         X     X          --
  11. --          X       X   XXXXXX    XXXXXX    XXXXXX    XXXXXX      X          --
  12. --                                                                           --
  13. --                                                                           --
  14. --                       O R E G A N O   S Y S T E M S                       --
  15. --                                                                           --
  16. --                            Design & Consulting                            --
  17. --                                                                           --
  18. -------------------------------------------------------------------------------
  19. --                                                                           --
  20. --         Web:           http://www.oregano.at/                             --
  21. --                                                                           --
  22. --         Contact:       mc8051@oregano.at                                  --
  23. --                                                                           --
  24. -------------------------------------------------------------------------------
  25. --                                                                           --
  26. --  MC8051 - VHDL 8051 Microcontroller IP Core                               --
  27. --  Copyright (C) 2001 OREGANO SYSTEMS                                       --
  28. --                                                                           --
  29. --  This library is free software; you can redistribute it and/or            --
  30. --  modify it under the terms of the GNU Lesser General Public               --
  31. --  License as published by the Free Software Foundation; either             --
  32. --  version 2.1 of the License, or (at your option) any later version.       --
  33. --                                                                           --
  34. --  This library is distributed in the hope that it will be useful,          --
  35. --  but WITHOUT ANY WARRANTY; without even the implied warranty of           --
  36. --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        --
  37. --  Lesser General Public License for more details.                          --
  38. --                                                                           --
  39. --  Full details of the license can be found in the file LGPL.TXT.           --
  40. --                                                                           --
  41. --  You should have received a copy of the GNU Lesser General Public         --
  42. --  License along with this library; if not, write to the Free Software      --
  43. --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  --
  44. --                                                                           --
  45. -------------------------------------------------------------------------------
  46. --
  47. --
  48. --         Author:                 Helmut Mayrhofer
  49. --
  50. --         Filename:               control_mem_rtl.vhd
  51. --
  52. --         Date of Creation:       Mon Aug  9 12:14:48 1999
  53. --
  54. --         Version:                $Revision: 1.7 $
  55. --
  56. --         Date of Latest Version: $Date: 2002/01/07 12:17:44 $
  57. --
  58. --
  59. --         Description: Describe all sequential funcitonality like read from
  60. --                      special function registers, observe interrupt sources,
  61. --                      write to special function registers, and read or write
  62. --                      to the bit addressable memory area.
  63. --
  64. --
  65. --
  66. --
  67. -------------------------------------------------------------------------------
  68. architecture rtl of control_mem is  
  70.  
  71.    type    t_gprbit is array (15 downto 0) of unsigned(7 downto 0); 
  72.    subtype muxint is integer range C_IMPL_N_TMR-1 downto 0;
  74.    signal s_help:        unsigned (7 downto 0);   -- general help-register 
  75.    signal s_help16:      unsigned (15 downto 0);  -- 16 bit help-register
  76.    signal s_helpb :      std_logic;               -- general help-bit 
  77.    signal s_ir:          unsigned (7 downto 0);   -- reg for saving the command
  78.    signal gprbit:        t_gprbit;         -- bitadressable general purpose RAM
  79.    signal s_r0_b0:  unsigned (7 downto 0);   -- Register R0 / Bank 0
  80.    signal s_r1_b0:  unsigned (7 downto 0);   -- Register R1 / Bank 0
  81.    signal s_r0_b1:  unsigned (7 downto 0);   -- Register R0 / Bank 1
  82.    signal s_r1_b1:  unsigned (7 downto 0);   -- Register R1 / Bank 1
  83.    signal s_r0_b2:  unsigned (7 downto 0);   -- Register R0 / Bank 2
  84.    signal s_r1_b2:  unsigned (7 downto 0);   -- Register R1 / Bank 2
  85.    signal s_r0_b3:  unsigned (7 downto 0);   -- Register R0 / Bank 3
  86.    signal s_r1_b3:  unsigned (7 downto 0);   -- Register R1 / Bank 3
  87.    signal s_reg_data:    unsigned (7 downto 0);   -- equals reg_data_o 
  88.    Signal state:         t_state;                 -- actual state 
  89.    signal s_command:     std_logic_vector (7 downto 0); 
  91.    signal s_pc_inc_en  : std_logic_vector (3 downto 0); 
  92.    signal s_regs_wr_en : std_logic_vector (2 downto 0); 
  93.    signal s_data_mux   : std_logic_vector (3 downto 0);
  94.    signal s_bdata_mux  : std_logic_vector (3 downto 0);
  95.    signal s_adr_mux    : std_logic_vector (3 downto 0);
  96.    signal s_adrx_mux   : std_logic_vector (1 downto 0);
  97.    signal s_help_en    : std_logic_vector (3 downto 0);
  98.    signal s_help16_en  : std_logic_vector (1 downto 0);
  99.    signal s_helpb_en   : std_logic;
  100.    signal s_intpre2_d : std_logic;
  101.    signal s_intpre2_en: std_logic;
  102.    signal s_intlow_d  : std_logic;
  103.    signal s_intlow_en : std_logic;
  104.    signal s_inthigh_d : std_logic;
  105.    signal s_inthigh_en: std_logic;
  106.    signal s_nextstate : t_state;              -- enable signal for state
  108.    signal s_bit_data :   std_logic; 
  109.    signal s_intpre:      std_logic;           -- an interrupt must start 
  110.    signal s_intpre2:     std_logic;           -- prepare for interrupt 
  111.    signal s_inthigh:     std_logic;           -- high priority int is running 
  112.    signal s_intlow:      std_logic;           -- low priority int is running 
  114.    signal s_int0_edge :  t_ext_l; 
  115.    signal s_int1_edge :  t_ext_l; 
  117.    signal s_tf0_edge :   t_tmr_l; 
  118.    signal s_tf1_edge :   t_tmr_l; 
  119.    signal s_ri_edge  :   t_siu_l; 
  120.    signal s_ti_edge  :   t_siu_l;
  121.    signal s_smodreg  :   t_siu_l;
  122.    signal s_tl0      :   t_tmr_us;
  123.    signal s_tl1      :   t_tmr_us;
  124.    signal s_th0      :   t_tmr_us;
  125.    signal s_th1      :   t_tmr_us;
  126.    signal s_sbufi    :   t_siu_us;
  127.    signal s_reload   :   t_tmr_us;
  128.    signal s_wt       :   t_tmr_us2;
  129.    
  130.    signal s_tf1 :        std_logic;
  131.    signal s_tf0 :        std_logic;
  132.    signal s_ie1 :        std_logic;
  133.    signal s_it1 :        std_logic;
  134.    signal s_ie0 :        std_logic;
  135.    signal s_it0 :        std_logic;   
  136.    
  137.    signal s_ri : std_logic;
  138.    signal s_ti : std_logic;
  139.    signal s_rb8 : std_logic;
  140.    signal s_tb8 : std_logic;
  141.    signal s_ren : std_logic;
  142.    signal s_sm2 : std_logic;
  143.    signal s_sm1 : std_logic;
  144.    signal s_sm0 : std_logic;
  145.    signal s_smod : std_logic;
  146.  
  147.    signal s_int0_h1 : t_ext_l;          -- help-bit for edge detection
  148.    signal s_int0_h2 : t_ext_l; 
  149.    signal s_int0_h3 : t_ext_l; 
  150.    signal s_int1_h1 : t_ext_l;
  151.    signal s_int1_h2 : t_ext_l; 
  152.    signal s_int1_h3 : t_ext_l; 
  154.    signal s_tf0_h1,s_tf0_h2 :         t_tmr_l; 
  155.    signal s_tf1_h1,s_tf1_h2 :         t_tmr_l; 
  156.    signal s_ri_h1,s_ri_h2 :           t_siu_l; 
  157.    signal s_ti_h1,s_ti_h2 :           t_siu_l; 
  158.  
  159.    signal s_tsel : muxint;
  160.    signal s_ssel : muxint;
  161.  
  162.    signal s_p :          std_logic; 
  163.    
  164.    signal s_p0 :         std_logic_vector(7 downto 0);
  165.    signal s_p1 :         std_logic_vector(7 downto 0);
  166.    signal s_p2 :         std_logic_vector(7 downto 0);
  167.    signal s_p3 :         std_logic_vector(7 downto 0);
  168.       
  169.    signal pc:            unsigned(15 downto 0);   -- program counter register
  170.    signal pc_comb:       unsigned(15 downto 0);   -- program counter
  171.    signal pc_plus1:      unsigned(15 downto 0);   -- program counter + 1
  172.    signal pc_plus2:      unsigned(15 downto 0);   -- program counter + 2
  174.    signal s_data    : unsigned(7 downto 0); 
  175.    signal s_adr     : unsigned(7 downto 0); 
  176.    signal s_preadr  : unsigned(7 downto 0); 
  177.    signal s_bdata   : std_logic; 
  178.    signal s_rr_adr  : unsigned (7 downto 0);
  179.    signal s_ri_adr  : std_logic_vector (7 downto 0);
  180.    signal s_ri_data : unsigned (7 downto 0);
  181.  
  182.   
  183.  -- 8051 standard special-function-register (SFR)
  184.  
  185.    signal p0:           unsigned(7 downto 0); 
  186.    signal sp:           unsigned(7 downto 0); 
  187.    signal dpl:          unsigned(7 downto 0); 
  188.    signal dph:          unsigned(7 downto 0); 
  189.    signal pcon:         unsigned(3 downto 0); 
  190.    signal tcon:         t_tmr_lv;
  191.    signal tmod:         t_tmr_us;
  192.    signal p1:           unsigned(7 downto 0); 
  193.    signal scon:         t_siu_lv; 
  194.    signal sbuf:         t_siu_us; 
  195.    signal p2:           unsigned(7 downto 0); 
  196.    signal ie:           std_logic_vector(7 downto 0); 
  197.    signal p3:           unsigned(7 downto 0); 
  198.    signal ip:           std_logic_vector(7 downto 0); 
  199.    signal psw:          std_logic_vector(7 downto 0); 
  200.    signal acc:          unsigned(7 downto 0); 
  201.    signal b:            unsigned(7 downto 0); 
  202.  
  203.  -- 8051 extended special-function-register
  204.  
  205.    signal tsel:         unsigned(7 downto 0);          -- select a Timer-Unit 
  206.    signal ssel:         unsigned(7 downto 0);          -- select a SIU-Unit 
  208.    alias CY : std_logic is psw(7); 
  209.    alias AC : std_logic is psw(6); 
  210.    alias OV : std_logic is psw(2); 
  211.    alias EA:  std_logic is ie(7); 
  212.    alias ES:  std_logic is ie(4); 
  213.    alias ET1: std_logic is ie(3); 
  214.    alias EX1: std_logic is ie(2); 
  215.    alias ET0: std_logic is ie(1); 
  216.    alias EX0: std_logic is ie(0); 
  217.    alias PS0: std_logic is ip(4); 
  218.    alias PT1: std_logic is ip(3); 
  219.    alias PX1: std_logic is ip(2); 
  220.    alias PT0: std_logic is ip(1); 
  221.    alias PX0: std_logic is ip(0); 
  223. begin 
  225.   -- some simple assignments 
  226.  
  227.   pc_o <= std_logic_vector(pc_comb);
  228.   pc_plus1 <= pc + conv_unsigned(1,1);
  229.   pc_plus2 <= pc + conv_unsigned(2,2);
  230.   ram_adr_o <= std_logic_vector(s_adr(6 downto 0)); 
  231.   reg_data_o <= std_logic_vector(s_reg_data); 
  232.   ram_data_o <= std_logic_vector(s_data);
  233.   acc_o <= std_logic_vector(acc); 
  234.   cy_o(1) <= cy; 
  235.   ov_o <= ov; 
  236.   cy_o(0) <= ac; 
  237.   
  238.   ie_o <= ie;
  239.   ip_o <= ip;
  240.   psw_o <= psw;
  241.   state_o <= state;
  242.   command_o <= s_command;
  243.   ri_o <= s_ri;
  244.   ti_o <= s_ti;
  245.   help_o <= std_logic_vector(s_help);
  246.   bit_data_o <= s_bit_data;
  247.   intpre_o <= s_intpre;
  248.   intpre2_o <= s_intpre2;
  249.   inthigh_o <= s_inthigh;
  250.   intlow_o <= s_intlow;
  251.   tf1_o <= s_tf1;
  252.   tf0_o <= s_tf0;
  253.   ie1_o <= s_ie1;
  254.   it1_o <= s_it1;
  255.   ie0_o <= s_ie0;
  256.   it0_o <= s_it0;
  258.   s_pc_inc_en <= pc_inc_en_i;   
  259.   s_nextstate <= nextstate_i;    
  260.   s_adr_mux <= adr_mux_i;     
  261.   s_adrx_mux <= adrx_mux_i;     
  262.   s_data_mux <= data_mux_i;    
  263.   s_bdata_mux <= bdata_mux_i;   
  264.   s_regs_wr_en <= regs_wr_en_i;  
  265.   s_help_en <= help_en_i;     
  266.   s_help16_en <= help16_en_i;   
  267.   s_helpb_en <= helpb_en_i;    
  268.   s_inthigh_en <= inthigh_en_i;  
  269.   s_intlow_en <=  intlow_en_i;   
  270.   s_intpre2_en <= intpre2_en_i;  
  271.   s_inthigh_d <=  inthigh_d_i;   
  272.   s_intlow_d <=   intlow_d_i;    
  273.   s_intpre2_d <=  intpre2_d_i;   
  275.   s_tsel <= conv_integer(tsel) when tsel < C_IMPL_N_TMR
  276.          else conv_integer(0);      -- selected timer unit is (not) implemented
  277.   s_ssel <= conv_integer(ssel) when ssel < C_IMPL_N_SIU
  278.          else conv_integer(0);      -- selected siu unit is (not) implemented  
  279.   
  280.   for_tmr:
  281.   for i in 0 to C_IMPL_N_TMR-1 generate
  282.     all_tcon_tr0_o(i) <= tcon(i)(4); 
  283.     all_tcon_tr1_o(i) <= tcon(i)(6);   
  284.     all_tmod_o((i*8)+7 downto i*8) <= std_logic_vector(tmod(i)); 
  285.     s_tl0(i) <= unsigned(all_tl0_i((i*8)+7 downto i*8));
  286.     s_tl1(i) <= unsigned(all_tl1_i((i*8)+7 downto i*8));
  287.     s_th0(i) <= unsigned(all_th0_i((i*8)+7 downto i*8));
  288.     s_th1(i) <= unsigned(all_th1_i((i*8)+7 downto i*8));
  289.     all_reload_o((i*8)+7 downto i*8) <= std_logic_vector(s_reload(i));
  290.     all_wt_o((i*2)+1 downto i*2) <= std_logic_vector(s_wt(i));
  291.   end generate for_tmr;
  293.   s_tf1 <= tcon(s_tsel)(7);
  294.   s_tf0 <= tcon(s_tsel)(5);
  295.   s_ie1 <= tcon(s_tsel)(3);
  296.   s_it1 <= tcon(s_tsel)(2);
  297.   s_ie0 <= tcon(s_tsel)(1);
  298.   s_it0 <= tcon(s_tsel)(0);
  299.   
  300.   for_siu:
  301.   for i in 0 to C_IMPL_N_SIU-1 generate
  302.     all_scon_o((6*i)+5) <= scon(i)(0);          -- RI
  303.     all_scon_o((6*i)+4) <= scon(i)(7);          -- SM0
  304.     all_scon_o((6*i)+3) <= scon(i)(6);          -- SM1
  305.     all_scon_o((6*i)+2) <= scon(i)(5);          -- SM2
  306.     all_scon_o((6*i)+1) <= scon(i)(4);          -- REN
  307.     all_scon_o(6*i) <= scon(i)(3);              -- TB8
  308.     all_smod_o(i) <= s_smodreg(i);              -- SMOD
  309.     all_sbuf_o((8*i)+7 downto 8*i) <= std_logic_vector(sbuf(i)); 
  310.     s_sbufi(i) <= unsigned(all_sbuf_i((i*8)+7 downto i*8));
  311.   end generate for_siu;
  313.   s_sm0 <= scon(s_ssel)(7);
  314.   s_sm1 <= scon(s_ssel)(6);
  315.   s_sm2 <= scon(s_ssel)(5);
  316.   s_ren <= scon(s_ssel)(4);
  317.   s_tb8 <= scon(s_ssel)(3);
  318.   s_rb8 <= all_scon_i((s_ssel*3)+2);
  319.   s_ti  <= scon(s_ssel)(1);
  320.   s_ri  <= scon(s_ssel)(0);
  321.   s_smod<= s_smodreg(s_ssel);
  322.      
  323.   p0_o <= std_logic_vector(p0); 
  324.   p1_o <= std_logic_vector(p1); 
  325.   p2_o <= std_logic_vector(p2); 
  326.   p3_o <= std_logic_vector(p3);
  327.  
  328.   s_p <= acc(7) xor acc(6) xor acc(5) xor acc(4) xor 
  329.          acc(3) xor acc(2) xor acc(1) xor acc(0); 
  330.                                     -- P should be set, if the count 
  331.                                     -- of 1 in the acc is even   
  332.  
  333.   s_command <= rom_data_i when state=FETCH 
  334.          else conv_std_logic_vector(s_ir,8); 
  336.   s_rr_adr <= unsigned((psw and "00011000") or (rom_data_i  
  337.               and "00000111"));     -- calculate registerdirect-adress
  338.              
  339.   s_ri_adr <= ((psw and "00011000") or (s_command(7 downto 0) and "00000001"));
  340.         
  341.   datax_o <= std_logic_vector(acc);
  342.   wrx_o <= wrx_mux_i;  
  343.       
  344. ------------------------------------------------------------------------------ 
  345. -- purpose: process to read SFR, bitadressable or normal RAM
  346. -- inputs:  s_adr,s_preadr,sp,dpl,dph,pcon,tcon,tmod,all_tl0_i,
  347. --          all_tl1_i,all_th0_i,all_th1_i,s_p0,s_p1,all_scon_i,all_sbuf_i,
  348. --          s_p2,ie,s_p3,ip,psw,acc,b,gprbit,ram_data_i
  349. -- outputs: s_reg_data, s_bit_data
  350. ------------------------------------------------------------------------------ 
  351.  
  352.   p_readram : process (s_preadr,s_p0,sp,dpl,dph,pcon,tcon,tmod,s_p1,scon,s_p2,
  353.                        ie,s_p3,ip,psw,acc,b,gprbit,ram_data_i,s_r0_b0,s_r1_b0,
  354.                        s_r0_b1,s_r1_b1,s_r0_b2,s_r1_b2,s_r0_b3,s_r1_b3,
  355.                        s_smod,s_sm0,s_sm1,s_sm2,s_ren,s_tb8,s_rb8,s_ti,s_ri,
  356.                        s_sbufi,s_th1,s_th0,s_ssel,s_tsel,s_tl1,s_tl0,
  357.        ssel,tsel) 
  358.   begin  
  359.     if s_preadr(7)='1' then 
  360.       case conv_integer(s_preadr) is         -- read one byte of a SFR  
  361.             when 16#80# => s_reg_data <= unsigned(s_p0);  
  362.             when 16#81# => s_reg_data <= sp; 
  363.             when 16#82# => s_reg_data <= dpl; 
  364.             when 16#83# => s_reg_data <= dph; 
  365.             when 16#87# => 
  366.               s_reg_data(7) <= s_smod;
  367.               s_reg_data(6 downto 4) <= "000";
  368.               s_reg_data(3 downto 0) <= pcon;
  369.             when 16#88# => s_reg_data <= unsigned(tcon(s_tsel));
  370.             when 16#89# => s_reg_data <= unsigned(tmod(s_tsel));
  371.             when 16#8A# => s_reg_data <= s_tl0(s_tsel);
  372.             when 16#8B# => s_reg_data <= s_tl1(s_tsel);
  373.             when 16#8C# => s_reg_data <= s_th0(s_tsel);
  374.             when 16#8D# => s_reg_data <= s_th1(s_tsel);
  375.             when 16#8E# => s_reg_data <= tsel;             
  376.             when 16#90# => s_reg_data <= unsigned(s_p1); 
  377.             when 16#98# => 
  378.               s_reg_data(0) <= s_ri;    -- from SCON register 
  379.               s_reg_data(1) <= s_ti;    -- from SCON register                
  380.               s_reg_data(2) <= s_rb8;   -- read extern input!!! 
  381.               s_reg_data(3) <= s_tb8;   
  382.               s_reg_data(4) <= s_ren;   
  383.               s_reg_data(5) <= s_sm2;   
  384.               s_reg_data(6) <= s_sm1;   
  385.               s_reg_data(7) <= s_sm0;   
  386.             when 16#99# => s_reg_data <= s_sbufi(s_ssel);
  387.             when 16#9A# => s_reg_data <= ssel; 
  388.             when 16#A0# => s_reg_data <= unsigned(s_p2); 
  389.             when 16#A8# => s_reg_data <= unsigned(ie);
  390.             when 16#B0# => s_reg_data <= unsigned(s_p3); 
  391.             when 16#B8# => s_reg_data <= unsigned(ip);
  392.             when 16#D0# => s_reg_data <= unsigned(psw);
  393.             when 16#E0# => s_reg_data <= acc; 
  394.             when 16#F0# => s_reg_data <= b;     
  395.             when others => s_reg_data <= conv_unsigned(0,8); 
  396.           end case; 
  397.                                  -- read one byte to bitadressable GPR 
  398.     elsif conv_std_logic_vector(s_preadr(7 downto 4),4)="0010" then   
  399.             s_reg_data <= gprbit(conv_integer(s_preadr(3 downto 0)));  
  400.              
  401.     elsif conv_std_logic_vector(s_preadr,8)="00000000" then
  402.             s_reg_data <= s_r0_b0;     -- read R0 / Bank 0
  403.     elsif conv_std_logic_vector(s_preadr,8)="00000001" then
  404.             s_reg_data <= s_r1_b0;     -- read R1 / Bank 0
  405.     elsif conv_std_logic_vector(s_preadr,8)="00001000" then
  406.             s_reg_data <= s_r0_b1;     -- read R0 / Bank 1
  407.     elsif conv_std_logic_vector(s_preadr,8)="00001001" then
  408.             s_reg_data <= s_r1_b1;     -- read R1 / Bank 1
  409.     elsif conv_std_logic_vector(s_preadr,8)="00010000" then
  410.             s_reg_data <= s_r0_b2;     -- read R0 / Bank 2
  411.     elsif conv_std_logic_vector(s_preadr,8)="00010001" then
  412.             s_reg_data <= s_r1_b2;     -- read R1 / Bank 2
  413.     elsif conv_std_logic_vector(s_preadr,8)="00011000" then
  414.             s_reg_data <= s_r0_b3;     -- read R0 / Bank 3
  415.     elsif conv_std_logic_vector(s_preadr,8)="00011001" then
  416.             s_reg_data <= s_r1_b3;     -- read R1 / Bank 3
  417.      
  418.     else                               -- read on general purpose RAM 
  419.             s_reg_data <= unsigned(ram_data_i); 
  420.     end if; 
  422.     if s_preadr(7)='1' then 
  423.       case s_preadr(6 downto 3) is    -- read only one bit from a SFR 
  424.         when "0000" => s_bit_data <= s_p0(conv_integer(s_preadr(2 downto 0))); 
  425.         when "0001" => 
  426.           s_bit_data <= tcon(s_tsel)(conv_integer(s_preadr(2 downto 0))); 
  427.         when "0010" => s_bit_data <= s_p1(conv_integer(s_preadr(2 downto 0))); 
  428.         when "0011" => 
  429.           if conv_integer(s_preadr(2 downto 0))=2 then 
  430.             s_bit_data <= s_rb8; 
  431.           else 
  432.             s_bit_data <= scon(s_ssel)(conv_integer(s_preadr(2 downto 0))); 
  433.           end if; 
  434.         when "0100" => s_bit_data <= s_p2(conv_integer(s_preadr(2 downto 0))); 
  435.         when "0101" => s_bit_data <= ie(conv_integer(s_preadr(2 downto 0))); 
  436.         when "0110" => s_bit_data <= s_p3(conv_integer(s_preadr(2 downto 0))); 
  437.         when "0111" => s_bit_data <= ip(conv_integer(s_preadr(2 downto 0))); 
  438.         when "1010" => s_bit_data <= psw(conv_integer(s_preadr(2 downto 0))); 
  439.         when "1100" => s_bit_data <= acc(conv_integer(s_preadr(2 downto 0))); 
  440.         when "1110" => s_bit_data <= b(conv_integer(s_preadr(2 downto 0))); 
  441.         when others => s_bit_data <= '0'; 
  442.       end case; 
  443.     else                               -- read one bit from bitadressable GP 
  444.             s_bit_data <= gprbit(conv_integer(s_preadr(6 downto 3))) 
  445.                           (conv_integer(s_preadr(2 downto 0)));  
  446.     end if;           
  447.   end process p_readram; 
  449. ------------------------------------------------------------------------------ 
  450. -- detect the rising/falling edge of interupt-sources
  451. ------------------------------------------------------------------------------ 
  453. for_intext_edge:
  454.   for i in 0 to C_IMPL_N_EXT-1 generate
  455.     -- falling edge of int0_i
  456.     s_int0_edge(i) <= not s_int0_h2(i) and s_int0_h3(i);
  457.     -- falling edge of int1_i
  458.     s_int1_edge(i) <= not s_int1_h2(i) and s_int1_h3(i);
  459.   end generate for_intext_edge;
  460.     
  461. for_tf_edge:       
  462.   for i in 0 to C_IMPL_N_TMR-1 generate
  463.     -- on rising edge of tf0_i
  464.     s_tf0_edge(i) <= s_tf0_h1(i) and not s_tf0_h2(i);
  465.     -- on rising edge of tf1_i
  466.     s_tf1_edge(i) <= s_tf1_h1(i) and not s_tf1_h2(i);
  467.   end generate for_tf_edge;
  468.     
  469. for_siu_edge:       
  470.   for i in 0 to C_IMPL_N_SIU-1 generate
  471.     -- on rising edge of RI
  472.     s_ri_edge(i) <= s_ri_h1(i) and not s_ri_h2(i);
  473.     -- on rising edge of TI
  474.     s_ti_edge(i) <= s_ti_h1(i) and not s_ti_h2(i);
  475.   end generate for_siu_edge;   
  477.  
  478. ------------------------------------------------------------------------------ 
  479. -- purpose: write some help-regs for detecting the falling/rising edge
  480. --          of interupt-sources
  481. -- inputs:  clk,reset,int0_i,int1_i,all_tf0_i,all_tf1_i,all_scon_i,
  482. --          s_tf0_h1,s_tf1_h1,s_ri_h1,s_ti_h1 
  483. -- outputs: s_int0_h1,s_int0_h2,s_int0_h3,s_int1_h1,s_int1_h2,s_int1_h3,
  484. --          s_tf0_h1,s_tf0_h2
  485. --          s_tf1_h1,s_tf1_h2,s_ri_h1,s_ri_h2,s_ti_h1,s_ti_h2
  486. ------------------------------------------------------------------------------ 
  487.     
  488.   iep: process (clk,reset) 
  489.  
  490.   begin  -- process iep 
  491.     
  492.     -- activities triggered by asynchronous reset 
  493.     if reset = '1' then 
  494.       s_int0_h1 <= (others => '1'); 
  495.       s_int0_h2 <= (others => '1'); 
  496.       s_int0_h3 <= (others => '1'); 
  497.       s_int1_h1 <= (others => '1'); 
  498.       s_int1_h2 <= (others => '1'); 
  499.       s_int1_h3 <= (others => '1'); 
  500.       s_tf0_h1 <= (others => '0'); 
  501.       s_tf0_h2 <= (others => '0'); 
  502.       s_tf1_h1 <= (others => '0'); 
  503.       s_tf1_h2 <= (others => '0'); 
  504.       s_ri_h1 <= (others => '0'); 
  505.       s_ri_h2 <= (others => '0'); 
  506.       s_ti_h1 <= (others => '0'); 
  507.       s_ti_h2 <= (others => '0'); 
  508.     -- activities triggered by rising edge of clock 
  509.     elsif clk'event and clk = '1' then 
  510.       for i in 0 to C_IMPL_N_EXT-1 loop
  511.         s_int0_h1(i) <= int0_i(i);              -- external INT0 
  512.         s_int0_h2(i) <= s_int0_h1(i); 
  513.         s_int0_h3(i) <= s_int0_h2(i); 
  514.         s_int1_h1(i) <= int1_i(i);              -- external INT1 
  515.         s_int1_h2(i) <= s_int1_h1(i);
  516.         s_int1_h3(i) <= s_int1_h2(i);
  517.       end loop; 
  518.       for i in 0 to C_IMPL_N_TMR-1 loop
  519.         s_tf0_h1(i) <= all_tf0_i(i);          -- TF0 flags 
  520.         s_tf0_h2(i) <= s_tf0_h1(i); 
  521.         s_tf1_h1(i) <= all_tf1_i(i);          -- TF1 flags 
  522.         s_tf1_h2(i) <= s_tf1_h1(i);      
  523.         -- all_xxx is a std_logic_vector, s_xxx is a array of std_logic !!!
  524.       end loop;
  525.       for i in 0 to C_IMPL_N_SIU-1 loop
  526.         s_ri_h1(i) <= all_scon_i(i*3);        -- RI flag
  527.         s_ri_h2(i) <= s_ri_h1(i); 
  528.         s_ti_h1(i) <= all_scon_i((i*3)+1);    -- TI flag 
  529.         s_ti_h2(i) <= s_ti_h1(i);      
  530.         -- all_xxx is a std_logic_vector, s_xxx is a array of std_logic !!!
  531.       end loop;
  532.     end if; 
  533.   end process iep; 
  534.  
  535. ------------------------------------------------------------------------------ 
  536. -- purpose: check the interupt-sources and start an interupt if necessary
  537. -- inputs:  ie,ip,scon,tcon,s_inthigh,s_intlow,s_ti,s_ri,s_ie0,
  538. --          s_ie1,s_tf0,s_tf1
  539. -- outputs: s_intpre
  540. ------------------------------------------------------------------------------ 
  541.  
  542.   intpre : process (ie,ip,scon,tcon,s_inthigh,s_intlow,s_ti,s_ri,s_ie0,
  543.                     s_ie1,s_tf0,s_tf1) 
  544.   begin   
  545.     if (EA='1' and (EX0='1' or ET0='1' or EX1='1' or ET1='1' or ES='1')) then 
  546.       if s_inthigh='1' then       -- interrupt with high priority is running 
  547.         s_intpre <= '0';           
  548.       elsif s_intlow='1' then     -- interrupt with low priority is running 
  549.         if ((PX0 and EX0 and s_ie0) or 
  550.             (PT0 and ET0 and s_tf0) or 
  551.             (PX1 and EX1 and s_ie1) or 
  552.             (PT1 and ET1 and s_tf1) or 
  553.             (PS0 and ES and (s_ri or s_ti)))='1' then 
  554.           s_intpre <= '1';        -- a second interrupt must start 
  555.         else                      
  556.           s_intpre <= '0'; 
  557.         end if; 
  558.       else                        -- no interrupt is running 
  559.         if ((EX0 and s_ie0) or 
  560.             (ET0 and s_tf0) or
  561.             (EX1 and s_ie1) or
  562.             (ET1 and s_tf1) or
  563.             (ES and (s_ri or s_ti)))='1' then 
  564.           s_intpre <= '1';        -- an interrupt must start 
  565.         else 
  566.           s_intpre <= '0'; 
  567.         end if; 
  568.       end if; 
  569.     else                          -- no interrupt must be carry out 
  570.       s_intpre <= '0'; 
  571.     end if;     
  572.   end process intpre; 
  574. ------------------------------------------------------------------------------ 
  575. -- purpose: this are the main-multiplexer for reading and writing regs
  576. -- inputs:  s_data_mux,pc,aludata_i,s_reg_data,rom_data_i,acc,
  577. --          s_bdata_mux,s_bit_data,psw,new_cy_i,s_helpb,sp,s_rr_adr,
  578. --          s_ri_data,s_help,s_adr_mux,s_adr,s_regs_wr_en,pc_plus2,
  579. --          s_help16,s_ri_adr,s_r0_b0,s_r1_b0,s_r0_b1,s_r1_b1,
  580. --          s_r0_b2,s_r1_b2,s_r0_b3,s_r1_b3
  581. -- outputs: s_data,s_bdata,s_adr,s_ri_data,ram_wr_o
  582. ------------------------------------------------------------------------------ 
  583.  
  584.   p_multiplexer : process (s_data_mux,pc,aludata_i,s_reg_data,rom_data_i,acc,
  585.                      s_bdata_mux,s_bit_data,psw,new_cy_i,s_helpb,sp,s_rr_adr,
  586.                      s_ri_data,s_help,s_adr_mux,s_adr,s_regs_wr_en,pc_plus2,
  587.                      s_help16,s_ri_adr,s_r0_b0,s_r1_b0,s_r0_b1,s_r1_b1,
  588.                      s_r0_b2,s_r1_b2,s_r0_b3,s_r1_b3,s_adrx_mux,dph,dpl,
  589.      datax_i) 
  590.   begin
  591.     case s_data_mux is
  592.       when "0000" => s_data <= conv_unsigned(0,8);
  593.       when "0001" => s_data <= pc(7 downto 0);
  594.       when "0010" => s_data <= pc(15 downto 8);
  595.       when "0011" => s_data <= unsigned(aludata_i);
  596.       when "0100" => s_data <= s_reg_data;
  597.       when "0101" => s_data <= unsigned(rom_data_i);
  598.       when "0110" => s_data <= acc;
  599.       when "0111" => 
  600.         s_data(7 downto 4) <= acc(3 downto 0);
  601.         s_data(3 downto 0) <= acc(7 downto 4);
  602.       when "1001" => 
  603.         s_data(7 downto 4) <= s_reg_data(7 downto 4);
  604.         s_data(3 downto 0) <= s_help(3 downto 0);
  605.       when "1010" => 
  606.         s_data(7 downto 4) <= acc(7 downto 4);
  607.         s_data(3 downto 0) <= s_reg_data(3 downto 0);
  608.       when "1100" => s_data <= s_help16(7 downto 0);
  609.       when "1101" => s_data <= s_help16(15 downto 8);
  610.       when "1110" => s_data <= pc_plus2(7 downto 0);
  611.       when "1111" => s_data <= unsigned(datax_i);
  612.       when others => s_data <= conv_unsigned(0,8);
  613.     end case;
  615.     case s_bdata_mux is
  616.       when "0000" => s_bdata <= '0';
  617.       when "0001" => s_bdata <= s_bit_data and cy;
  618.       when "0010" => s_bdata <= not(s_bit_data and cy);
  619.       when "0011" => s_bdata <= new_cy_i(1);
  620.       when "0100" => s_bdata <= s_helpb;
  621.       when "0101" => s_bdata <= not cy;
  622.       when "0110" => s_bdata <= not s_bit_data;
  623.       when "0111" => s_bdata <= s_bit_data;
  624.       when "1000" => s_bdata <= cy;
  625.       when "1001" => s_bdata <= s_bit_data or cy;
  626.       when "1010" => s_bdata <= not(s_bit_data or cy);
  627.       when "1011" => s_bdata <= '1';
  628.       when others => s_bdata <= '0';
  629.     end case;
  631.     case s_adr_mux is
  632.       when "0000" => s_adr <= conv_unsigned(0,8);
  633.       when "0001" => s_adr <= conv_unsigned(16#89#,8); 
  634.       when "0010" => s_adr <= conv_unsigned(16#8D#,8); 
  635.       when "0011" => s_adr <= conv_unsigned(16#8B#,8);
  636.       when "0100" => s_adr <= conv_unsigned(16#8F#,8); 
  637.       when "0101" => s_adr <= sp;
  638.       when "0110" => s_adr <= s_rr_adr;
  639.       when "0111" => s_adr <= s_ri_data;
  640.       when "1000" => s_adr <= unsigned(rom_data_i);
  641.       when "1001" => s_adr <= s_reg_data;
  642.       when "1010" => s_adr <= s_help ;
  643.       when "1011" => s_adr <= conv_unsigned(16#D7#,8); 
  644.       when "1100" => s_adr <= conv_unsigned(16#F0#,8);
  645.       when "1101" => s_adr <= conv_unsigned(16#82#,8); 
  646.       when "1110" => s_adr <= conv_unsigned(16#83#,8); 
  647.       when "1111" => s_adr <= sp + conv_unsigned(1,1); 
  648.       when others => s_adr <= conv_unsigned(0,8);
  649.     end case;
  651.     case s_adrx_mux is
  652.       when "00" => adrx_o <= (others => '0');
  653.       when "01" => 
  654.         adrx_o(15 downto 8) <= std_logic_vector(dph); 
  655.         adrx_o(7 downto 0) <= std_logic_vector(dpl); 
  656.       when "10" => 
  657.         adrx_o(15 downto 8) <= (others => '0'); 
  658.         adrx_o(7 downto 0) <= std_logic_vector(s_ri_data); 
  659.       when others => adrx_o <= (others => '0');
  660.     end case;
  661.           
  662.     case s_ri_adr is
  663.       when "00000000" => s_ri_data <= s_r0_b0;    
  664.       when "00000001" => s_ri_data <= s_r1_b0;    
  665.       when "00001000" => s_ri_data <= s_r0_b1;    
  666.       when "00001001" => s_ri_data <= s_r1_b1;    
  667.       when "00010000" => s_ri_data <= s_r0_b2;    
  668.       when "00010001" => s_ri_data <= s_r1_b2;    
  669.       when "00011000" => s_ri_data <= s_r0_b3;    
  670.       when "00011001" => s_ri_data <= s_r1_b3;
  671.       when others => s_ri_data <= conv_unsigned(0,8);
  672.     end case;   
  674.     if ((s_regs_wr_en="100") or (s_regs_wr_en="101")) then    -- write one byte
  675.       if ((s_adr(7)='1') or                                   -- SFR
  676.         (conv_std_logic_vector(s_adr(7 downto 4),4)="0010")   -- bitadressable
  677.         or ((std_logic_vector(s_adr) AND "11100110") = "00000000"))   -- R0,R1
  678.       then
  679.          ram_wr_o <= '0';
  680.       else
  681.         ram_wr_o <= '1';                -- to RAM-block
  682.       end if;
  683.     else
  684.       ram_wr_o <= '0';
  685.     end if;
  686.   end process p_multiplexer; 
  688. ------------------------------------------------------------------------------ 
  689. -- purpose: writes internal registers, on which the user have no 
  690. --          direct access
  691. -- inputs:  reset,clk,s_nextstate,state,s_help_en,
  692. --          rom_data_i,aludata_i,s_reg_data,s_rr_adr,new_cy_i
  693. -- outputs: state,s_ir,s_help,s_help16,s_helpb,s_intpre2,s_intlow,
  694. --          s_inthigh,s_preadr
  695. ------------------------------------------------------------------------------ 
  696.  
  697.   p_wr_internal_reg : process (reset,clk)
  698.   begin
  699.     if reset='1' then 
  700.       state <= STARTUP; 
  701.       s_ir <= conv_unsigned(0,8); 
  702.       s_help <= conv_unsigned(0,8);
  703.       s_help16 <= conv_unsigned(0,16);
  704.       s_helpb <= '0';
  705.       s_intpre2 <= '0';
  706.       s_intlow <= '0';
  707.       s_inthigh <= '0';
  708.       s_preadr <= conv_unsigned(0,8);
  709.       pc <= conv_unsigned(0,16); 
  710.       s_p0 <= "11111111";
  711.       s_p1 <= "11111111";
  712.       s_p2 <= "11111111";
  713.       s_p3 <= "11111111";
  714.     else
  715.       if Rising_Edge(clk) then  
  717.         state <= s_nextstate;                        -- update current state
  719.         if state=FETCH then 
  720.           s_ir <= unsigned(rom_data_i);              -- save OP-Code in IR 
  721.         end if; 
  722.         
  723.         case s_help_en is
  724.           when "0000" => NULL;
  725.           when "0001" => s_help <= unsigned(rom_data_i);
  726.           when "0010" => s_help <= unsigned(aludata_i);
  727.           when "0011" => s_help <= s_reg_data;
  728.           when "0100" => s_help <= s_rr_adr;
  729.           when "0101" => s_help <= conv_unsigned(16#03#,8);
  730.           when "0110" => s_help <= conv_unsigned(16#0B#,8);
  731.           when "0111" => s_help <= conv_unsigned(16#13#,8); 
  732.           when "1000" => s_help <= conv_unsigned(16#1B#,8);
  733.           when "1001" => s_help <= conv_unsigned(16#23#,8);
  734.           when "1010" => s_help <= acc;
  735.           when others => NULL;
  736.         end case;
  737.     
  738.         case s_help16_en is
  739.           when "00" => NULL;
  740.           when "01" => s_help16 <= pc + conv_unsigned(3,2);
  741.           when "10" => s_help16 <= pc_plus2;
  742.           when "11" => s_help16 <= pc_plus1;
  743.           when others => NULL;
  744.         end case;
  746.         case s_helpb_en is
  747.           when '0' => NULL;
  748.           when '1' => s_helpb <= new_cy_i(1);
  749.           when others => NULL;
  750.         end case;
  752.         if s_intpre2_en='1' then           -- help-reg for s_intpre
  753.           s_intpre2 <= s_intpre2_d;
  754.         else
  755.           NULL;
  756.         end if;
  758.         if s_intlow_en='1' then
  759.           s_intlow <= s_intlow_d;
  760.         else
  761.           NULL;
  762.         end if;
  764.         if s_inthigh_en='1' then
  765.           s_inthigh <= s_inthigh_d;
  766.         else
  767.           NULL;
  768.         end if;
  770.         s_preadr <= s_adr;
  772.         pc <= pc_comb;               -- write pc-register
  774. s_p0 <= p0_i;
  775. s_p1 <= p1_i;
  776. s_p2 <= p2_i;
  777. s_p3 <= p3_i;
  779.       end if;
  780.     end if;
  781.   end process p_wr_internal_reg; 
  783. ------------------------------------------------------------------------------ 
  784. -- purpose: calculate the next PC-adress 
  785. -- inputs:  s_pc_inc_en,pc_plus1,rom_data_i,s_intpre2,s_help,s_command,
  786. --          s_help16,s_ir,dph,dpl,acc,s_reg_data,pc
  787. -- outputs: pc_comb
  788. ------------------------------------------------------------------------------ 
  789.  
  790.   p_pc : process (s_pc_inc_en,pc_plus1,rom_data_i,s_help,
  791.                   s_help16,s_ir,dph,dpl,acc,s_reg_data,pc) 
  792.   variable v_dptr: unsigned(15 downto 0);
  793.   begin
  794.     v_dptr(15 downto 8) := dph;
  795.     v_dptr(7 downto 0) := dpl;
  796.     case s_pc_inc_en is 
  797.       when "0001" =>                  -- increment PC 
  798.         pc_comb <= pc_plus1; 
  799.       when "0010" =>                  -- for relativ jumps and calls 
  800.         pc_comb <= conv_unsigned(pc_plus1 + signed(rom_data_i),16);  
  801.       when "0011" =>                  -- load interrupt vectoradress
  802.         pc_comb(15 downto 8) <= conv_unsigned(0,8);
  803.         pc_comb(7 downto 0) <= s_help; 
  804.       when "0100" =>                  -- ACALL and AJMP
  805.         pc_comb(15 downto 11) <= s_help16(15 downto 11);
  806.         pc_comb(10 downto 8) <= s_ir(7 downto 5);
  807.         pc_comb(7 downto 0) <= unsigned(rom_data_i);
  808.       when "0101" =>                  -- JMP_A_DPTR, MOVC_A_ATDPTR
  809.         pc_comb <= v_dptr + conv_unsigned(acc,8); 
  810.       when "0110" =>                  -- MOVC
  811.         pc_comb <= s_help16;
  812.       when "0111" =>                  -- LJMP, LCALL
  813.         pc_comb(15 downto 8) <= s_help;
  814.         pc_comb(7 downto 0) <= unsigned(rom_data_i);
  815.       when "1000" =>                  -- RET, RETI
  816.         pc_comb(15 downto 8) <= s_help;
  817.         pc_comb(7 downto 0) <= s_reg_data;
  818.       when "1001" =>                  -- MOVC_A_ATPC
  819.         pc_comb <= pc_plus1 + conv_unsigned(acc,8);
  820.       when others => pc_comb <= pc;
  821.     end case;
  822.   end process p_pc;
  823.   
  824. ------------------------------------------------------------------------------ 
  825. -- purpose: write RAM, SFR or bitadressable Registers
  826. -- inputs:  reset,clk
  827. -- outputs: SFR, gprbit
  828. ------------------------------------------------------------------------------ 
  829.  
  830.   p_write_ram : process (reset,clk) 
  831.   begin
  832.     if reset='1' then 
  833.       ram_en_o <= '0'; 
  834.       gprbit(0) <= conv_unsigned(0,8);                                        
  835.       gprbit(1) <= conv_unsigned(0,8);                                        
  836.       gprbit(2) <= conv_unsigned(0,8);                                        
  837.       gprbit(3) <= conv_unsigned(0,8);                                        
  838.       gprbit(4) <= conv_unsigned(0,8);                                        
  839.       gprbit(5) <= conv_unsigned(0,8);                                        
  840.       gprbit(6) <= conv_unsigned(0,8);                                        
  841.       gprbit(7) <= conv_unsigned(0,8);                                        
  842.       gprbit(8) <= conv_unsigned(0,8);                                        
  843.       gprbit(9) <= conv_unsigned(0,8);                                        
  844.       gprbit(10) <= conv_unsigned(0,8);                                        
  845.       gprbit(11) <= conv_unsigned(0,8);                                        
  846.       gprbit(12) <= conv_unsigned(0,8);                                        
  847.       gprbit(13) <= conv_unsigned(0,8);                                        
  848.       gprbit(14) <= conv_unsigned(0,8);                                        
  849.       gprbit(15) <= conv_unsigned(0,8);
  850.       s_r0_b0 <= conv_unsigned(0,8);
  851.       s_r1_b0 <= conv_unsigned(0,8);
  852.       s_r0_b1 <= conv_unsigned(0,8);
  853.       s_r1_b1 <= conv_unsigned(0,8);
  854.       s_r0_b2 <= conv_unsigned(0,8);
  855.       s_r1_b2 <= conv_unsigned(0,8);
  856.       s_r0_b3 <= conv_unsigned(0,8);
  857.       s_r1_b3 <= conv_unsigned(0,8);
  858.       p0 <= conv_unsigned(255,8);                            
  859.       sp <= conv_unsigned(7,8);    
  860.       dpl <= conv_unsigned(0,8);                           
  861.       dph <= conv_unsigned(0,8);                           
  862.       pcon <= conv_unsigned(0,4);                          
  863.       tcon <= (others => (others => '0'));                          
  864.       tmod <= (others => (others => '0'));                          
  865.       tsel <= conv_unsigned(0,8);                          
  866.       p1 <= conv_unsigned(255,8);                            
  867.       scon <= (others => (others => '0'));                           
  868.       s_smodreg <= (others => '0');
  869.       sbuf <= (others => (others => '0'));
  870.       ssel <= conv_unsigned(0,8);                          
  871.       p2 <= conv_unsigned(255,8);                            
  872.       ie <= conv_std_logic_vector(0,8);                            
  873.       p3 <= conv_unsigned(255,8);                            
  874.       ip <= conv_std_logic_vector(0,8);                            
  875.       psw <= conv_std_logic_vector(0,8);  
  876.       acc <= conv_unsigned(0,8);                           
  877.       b <= conv_unsigned(0,8); 
  878.       s_reload <= (others => (others => '0'));
  879.       all_wt_en_o <= (others => '0'); 
  880.       s_wt <= (others => (others => '0')); 
  881.       all_trans_o <= (others => '0');
  882.     else 
  883.       ram_en_o <= '1'; 
  885.       if Rising_Edge(clk) then  
  886.         all_wt_en_o <= ( others => '0' );              -- default values 
  887.         all_trans_o <= ( others => '0' ); 
  888.         psw(0) <= s_p; 
  889.         for i in 0 to C_IMPL_N_TMR-1 loop
  890.           tcon(i)(3) <= tcon(i)(3) or ((tcon(i)(2) and s_int1_edge(i)) or 
  891.                         (not tcon(i)(2) and not s_int1_h2(i)));
  892.           tcon(i)(1) <= tcon(i)(1) or ((tcon(i)(0) and s_int0_edge(i)) or 
  893.                         (not tcon(i)(0) and not s_int0_h2(i)));
  894.           tcon(i)(5) <= tcon(i)(5) or s_tf0_edge(i);
  895.           tcon(i)(7) <= tcon(i)(7) or s_tf1_edge(i);
  896.         end loop;
  897.         -- update TF1, TF0 and IE1, IE0 in dependance on the IT flags 
  898.         for i in 0 to C_IMPL_N_SIU-1 loop
  899.           scon(i)(0) <= scon(i)(0) or s_ri_edge(i);
  900.           scon(i)(1) <= scon(i)(1) or s_ti_edge(i);
  901.         end loop;
  903.         case s_regs_wr_en is 
  904.           when "001" =>                 -- inc or dec SP
  905.             case s_command is 
  906.               when RET | RETI => 
  907.                 sp <= sp - conv_unsigned(1,1); 
  908.               when others => 
  909.                 sp <= sp + conv_unsigned(1,1); 
  910.               end case; 
  911.           when "010" =>                 -- write to ACC
  912.             acc <= s_data; 
  913.           when "011" =>                 -- write to ACC and PSW
  914.             acc <= s_data; 
  915.             psw(7) <= new_cy_i(1);
  916.             psw(6) <= new_cy_i(0);
  917.             psw(2) <= new_ov_i;
  918.           when "100" | "101" =>
  919.             case s_regs_wr_en is                  -- sp register
  920.               when "100" => if conv_integer(s_adr)=16#81# then 
  921.                               sp <= s_data; 
  922.                             end if;
  923.               when "101" => if s_command = POP then 
  924.                               sp <= sp - conv_unsigned(1,1); 
  925.                             else 
  926.                               sp <= sp + conv_unsigned(1,1); 
  927.                             end if; 
  928.               when others => NULL;
  929.             end case;
  930.             
  931.             if s_adr(7)='1' then 
  932.               case conv_integer(s_adr) is         -- write one byte of a SFR  
  933.               when 16#80# => p0 <= s_data;                
  934.               when 16#82# => dpl <= s_data; 
  935.               when 16#83# => dph <= s_data; 
  936.               when 16#87# => 
  937.                 pcon <= s_data(3 downto 0); 
  938.                 s_smodreg(s_ssel) <= s_data(7);
  939.               when 16#88# => tcon(s_tsel) <= std_logic_vector(s_data);
  940.               when 16#89# => tmod(s_tsel) <= s_data;
  941.               when 16#8A# => 
  942.                   s_reload(s_tsel) <= s_data;  -- tl0 
  943.                   s_wt(s_tsel) <= "00"; 
  944.                   all_wt_en_o(s_tsel) <= '1'; 
  945.               when 16#8B# => 
  946.                   s_reload(s_tsel) <= s_data;  -- tl1
  947.                   s_wt(s_tsel) <= "01"; 
  948.                   all_wt_en_o(s_tsel) <= '1'; 
  949.               when 16#8C# => 
  950.                   s_reload(s_tsel) <= s_data;  -- th0 
  951.                   s_wt(s_tsel) <= "10"; 
  952.                   all_wt_en_o(s_tsel) <= '1'; 
  953.               when 16#8D# => 
  954.                   s_reload(s_tsel) <= s_data;  -- th1 
  955.                   s_wt(s_tsel) <= "11"; 
  956.                   all_wt_en_o(s_tsel) <= '1'; 
  957.               when 16#8E# => tsel <= s_data; 
  958.               when 16#90# => p1 <= s_data; 
  959.               when 16#98# => scon(s_ssel) <= std_logic_vector(s_data);
  960.               when 16#99# => 
  961.                 sbuf(s_ssel) <= s_data;
  962.                 all_trans_o(s_ssel) <= '1'; 
  963.               when 16#9A# => ssel <= s_data; 
  964.               when 16#A0# => p2 <= s_data; 
  965.               when 16#A8# => ie <= conv_std_logic_vector(s_data,8); 
  966.               when 16#B0# => p3 <= s_data; 
  967.               when 16#B8# => ip <= conv_std_logic_vector(s_data,8); 
  968.               when 16#D0# =>  
  969.                 psw(7 downto 1) <= conv_std_logic_vector(s_data(7 downto 1),7);
  970.               when 16#E0# => acc <= s_data; 
  971.               when 16#F0# => b <= s_data;     
  972.               when others => NULL; 
  973.               end case; 
  974.                                    -- write one byte to bitadressable GPR 
  975.             elsif conv_std_logic_vector(s_adr(7 downto 4),4)="0010" then   
  976.               gprbit(conv_integer(s_adr(3 downto 0))) <= s_data; 
  977.             elsif conv_std_logic_vector(s_adr,8)="00000000" then
  978.               s_r0_b0 <= s_data;         -- write R0 / Bank 0
  979.             elsif conv_std_logic_vector(s_adr,8)="00000001" then
  980.               s_r1_b0 <= s_data;         -- write R1 / Bank 0
  981.             elsif conv_std_logic_vector(s_adr,8)="00001000" then
  982.               s_r0_b1 <= s_data;         -- write R0 / Bank 1
  983.             elsif conv_std_logic_vector(s_adr,8)="00001001" then
  984.               s_r1_b1 <= s_data;         -- write R1 / Bank 1
  985.             elsif conv_std_logic_vector(s_adr,8)="00010000" then
  986.               s_r0_b2 <= s_data;         -- write R0 / Bank 2
  987.             elsif conv_std_logic_vector(s_adr,8)="00010001" then
  988.               s_r1_b2 <= s_data;         -- write R1 / Bank 2
  989.             elsif conv_std_logic_vector(s_adr,8)="00011000" then
  990.               s_r0_b3 <= s_data;         -- write R0 / Bank 3
  991.             elsif conv_std_logic_vector(s_adr,8)="00011001" then
  992.               s_r1_b3 <= s_data;         -- write R1 / Bank 3
  993.             else                               -- write on general purpose RAM 
  994.               NULL;
  995.             end if; 
  996.           when "110" => 
  997.             case s_command is
  998.               when ANL_C_BIT | 
  999.                    ANL_C_NBIT | 
  1000.                    MOV_C_BIT | 
  1001.                    ORL_C_BIT | 
  1002.                    ORL_C_NBIT => psw(7) <= s_bdata;               -- write CY
  1003.               when others =>
  1004.               if s_adr(7)='1' then 
  1005.                 case s_adr(6 downto 3) is  -- write only one bit of an SFR 
  1006.                   when "0000" => 
  1007.                     p0(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1008.                   when "0001" => 
  1009.                     tcon(s_tsel)(conv_integer(s_adr(2 downto 0))) <= s_bdata;
  1010.                   when "0010" => 
  1011.                     p1(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1012.                   when "0011" => 
  1013.                     scon(s_ssel)(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1014.                   when "0100" => 
  1015.                     p2(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1016.                   when "0101" => 
  1017.                     ie(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1018.                   when "0110" => 
  1019.                     p3(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1020.                   when "0111" => 
  1021.                     ip(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1022.                   when "1010" =>  
  1023.                     case s_adr(2 downto 0) is 
  1024.                       when "000" => NULL; 
  1025.                       when "001" => psw(1) <= s_bdata;
  1026.                       when "010" => psw(2) <= s_bdata;
  1027.                       when "011" => psw(3) <= s_bdata;
  1028.                       when "100" => psw(4) <= s_bdata;
  1029.                       when "101" => psw(5) <= s_bdata;
  1030.                       when "110" => psw(6) <= s_bdata;
  1031.                       when "111" => psw(7) <= s_bdata;
  1032.                       when others => NULL; 
  1033.                     end case; 
  1034.                   when "1100" => 
  1035.                     acc(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1036.                   when "1110" => 
  1037.                     b(conv_integer(s_adr(2 downto 0))) <= s_bdata; 
  1038.                   when others => NULL; 
  1039.                 end case; 
  1040.               else                  -- write one bit to bitadressable GP 
  1041.                 gprbit(conv_integer(s_adr(6 downto 3))) 
  1042.                       (conv_integer(s_adr(2 downto 0))) <= s_bdata;  
  1043.               end if; 
  1044.             end case;
  1045.           when "111" => 
  1046.             case s_command is 
  1047.               when DA_A | RLC_A | RRC_A =>     -- write ACC, CY 
  1048.                 acc <= s_data; 
  1049.                 psw(7) <= new_cy_i(1);
  1050.               when DIV_AB | MUL_AB =>          -- write ACC, B, CY, OV 
  1051.                 acc <= s_data; 
  1052.                 b <= unsigned(aludatb_i); 
  1053.                 psw(7) <= '0';
  1054.                 psw(2) <= new_ov_i;
  1055.               when others => NULL; 
  1056.             end case; 
  1057.           when others => NULL;
  1058.         end case; 
  1059.       end if;
  1060.     end if; 
  1061.   end process p_write_ram; 
  1063. end rtl;  
  1064.