source: firmware/FAD/FACT_FAD_20MHz_VAR_PS/FACT_FAD_lib/hdl/w5300_modul.vhd @ 10176

Last change on this file since 10176 was 10176, checked in by neise, 9 years ago
File size: 38.7 KB
Line 
1-- Module Name:    w5300_modul - Behavioral
2library IEEE;
3use IEEE.STD_LOGIC_1164.ALL;
4use IEEE.STD_LOGIC_ARITH.ALL;
5use IEEE.STD_LOGIC_UNSIGNED.ALL;
6library FACT_FAD_lib;
7use FACT_FAD_lib.fad_definitions.ALL;
8
9ENTITY w5300_modul IS
10  generic(
11    RAM_ADDR_WIDTH : integer := 14
12  );
13   PORT( 
14      clk            : IN     std_logic;
15      wiz_reset      : OUT    std_logic                     := '1';
16      addr           : OUT    std_logic_vector (9 DOWNTO 0);
17      data           : INOUT  std_logic_vector (15 DOWNTO 0);
18      cs             : OUT    std_logic                     := '1';
19      wr             : OUT    std_logic                     := '1';
20      led            : OUT    std_logic_vector (7 DOWNTO 0) := (OTHERS => '0');
21      rd             : OUT    std_logic                     := '1';
22      int            : IN     std_logic;
23      write_length   : IN     std_logic_vector (16 DOWNTO 0);
24      ram_start_addr : IN     std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
25      ram_data       : IN     std_logic_vector (15 DOWNTO 0);
26      ram_addr       : OUT    std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
27      data_valid     : IN     std_logic;
28      data_valid_ack : OUT    std_logic := '0';
29      busy           : OUT    std_logic                     := '1';
30      write_header_flag, write_end_flag : IN std_logic;
31      fifo_channels : IN std_logic_vector (3 downto 0);
32      -- softtrigger:
33      s_trigger : OUT std_logic := '0';
34      c_trigger_enable: out std_logic := '0';
35      c_trigger_mult: out std_logic_vector (15 DOWNTO 0) := conv_std_logic_vector(100 ,16); --subject to changes
36
37          -- FAD configuration signals:
38          ------------------------------------------------------------------------------
39                -- start entire configuration chain
40      new_config : OUT std_logic := '0';
41          config_chain_done : IN std_logic;
42         
43                -- read/write configRAM
44      config_addr : out std_logic_vector (7 downto 0);
45      config_data : inout std_logic_vector (15 downto 0) := (others => 'Z');
46      config_wr_en : out std_logic := '0';
47      config_rd_en : out std_logic := '0';
48      config_rw_ack, config_rw_ready : in std_logic;
49      config_busy : in std_logic;
50          ------------------------------------------------------------------------------
51     
52          -- MAC/IP calculation signals:
53          ------------------------------------------------------------------------------
54      MAC_jumper : in std_logic_vector (1 downto 0);
55      BoardID : in std_logic_vector (3 downto 0);
56      CrateID : in std_logic_vector (1 downto 0);
57          ------------------------------------------------------------------------------
58     
59          -- user controllable enable signals
60          ------------------------------------------------------------------------------
61          trigger_enable : out std_logic := '0'; -- default triggers are NOT accepted
62          data_generator_run_mode : out std_logic := '0'; -- default triggers are NOT accepted
63      denable : out std_logic := '0'; -- default domino wave off
64      dwrite_enable : out std_logic := '0'; -- default DWRITE low.
65      sclk_enable : out std_logic := '1'; -- default DWRITE HIGH.
66      srclk_enable : out std_logic := '1'; -- default SRCLK on.
67          ------------------------------------------------------------------------------
68         
69          -- ADC CLK generator, is able to shift phase with respect to X_50M
70          -- these signals control the behavior of the digital clock manager (DCM)
71          ------------------------------------------------------------------------------
72          ps_direction : out std_logic := '1'; -- default phase shift upwards
73      ps_do_phase_shift : out std_logic := '0'; --pulse this to phase shift once
74      ps_reset : out std_logic := '0'; -- pulse this to reset the variable phase shift
75      ------------------------------------------------------------------------------
76         
77          -- signals used to control FAD LED bahavior:
78          -- one of the three LEDs is used for com-status info
79          ------------------------------------------------------------------------------
80      socks_waiting : out std_logic;
81      socks_connected: out std_logic
82          ------------------------------------------------------------------------------
83         
84         
85   );
86END w5300_modul ;
87
88architecture Behavioral of w5300_modul is
89
90type state_init_type is (
91        INTERRUPT, RESET, WRITE_REG, READ_REG, WRITE_DATA,
92        INIT, LOCATE, IM, MT, STX, STX1, STX2, STX3, SRX, SRX1, SRX2, SRX3, MAC, MAC1, MAC2, GW, GW1, SNM, SNM1, IP, IP1, TIMEOUT, RETRY,
93        SI, SI1, SI2, SI3, SI4, SI5, SI6,       ESTABLISH, EST1, 
94        CONFIG, WAIT_FOR_CONFIG_DONE,
95        MAIN, MAIN1, MAIN2, MAIN3, CHK_RECEIVED, READ_DATA
96);
97type state_write_type is (
98        WR_START, 
99        WR_GET_EVT_ID_WAIT1, WR_GET_EVT_ID1, WR_GET_EVT_ID_WAIT2, WR_GET_EVT_ID2,
100        WR_MOD7_STARTED, WR_WAIT_FOR_MOD7,
101        WR_CHECK_FOR_FIFO_SPACE_01, WR_CHECK_FOR_FIFO_SPACE_02, WR_CHECK_FOR_FIFO_SPACE_03, WR_CHECK_FOR_FIFO_SPACE_04, 
102        WR_05, WR_05a, WR_05b, WR_06, WR_07, WR_08, WR_FIFO, WR_FIFO1, WR_ADC, WR_ADC1, WR_ADC2,
103        WR_ENDFLAG, WR_ENDFLAG1, WR_ENDFLAG2, WR_ENDFLAG3
104); 
105type state_interrupt_1_type is (IR1_01, IR1_02, IR1_03, IR1_04);
106type state_interrupt_2_type is (IR2_01, IR2_02, IR2_03, IR2_04, IR2_05, IR2_06);
107type state_read_data_type is (
108        RD_1, 
109        RD_2, 
110        RD_3, 
111        RD_4, 
112        RD_5, 
113        RD_6,
114        READ_COMMAND_DATA_SECTION,
115        PUT_COMMAND_DATA_SECTION,
116        NEW_CONT_TRIGGER_MULT_FACTOR_READ,
117        NEW_CONT_TRIGGER_MULT_FACTOR_PUT,
118        RD_WAIT,
119        RD_WAIT1, 
120        RD_END
121);
122
123signal RST_TIME : std_logic_vector(19 downto 0) := X"7A120";
124
125signal par_addr : std_logic_vector (9 downto 0) := (OTHERS => '0');
126signal par_data : std_logic_vector (15 downto 0) := (OTHERS => '0');
127signal data_read : std_logic_vector (15 downto 0) := (OTHERS => '0');
128signal adc_data_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
129
130signal state_init, next_state , next_state_tmp : state_init_type := RESET;
131signal count : std_logic_vector (2 downto 0) := "000";
132signal state_write : state_write_type := WR_START;
133signal state_interrupt_1 : state_interrupt_1_type := IR1_01;
134signal state_interrupt_2 : state_interrupt_2_type := IR2_01;
135signal state_read_data : state_read_data_type := RD_1;
136
137signal interrupt_ignore : std_logic := '1';
138signal int_flag : std_logic := '0';
139signal ram_access : std_logic := '0';
140
141signal zaehler : std_logic_vector (19 downto 0) := (OTHERS => '0');
142signal data_cnt : integer := 0;
143signal drs_cnt : integer :=0;
144signal channel_cnt : integer range 0 to 9 :=0;
145signal socket_cnt : std_logic_vector (2 downto 0) := "000";
146signal roi_max : std_logic_vector (10 downto 0);
147signal data_end : integer := 0;
148
149signal socket_tx_free : std_logic_vector (31 downto 0) := (others => '0');
150signal write_length_bytes : std_logic_vector (16 downto 0);
151
152signal socket_rx_received : std_logic_vector (31 downto 0) := (others => '0');
153signal chk_recv_cntr : integer range 0 to 10000 := 0;
154
155-- --
156signal wait_cntr : integer range 0 to 10000 := 0;
157-- --
158
159signal rx_packets_cnt : std_logic_vector (15 downto 0);
160signal new_config_flag : std_logic := '0';
161
162signal trigger_stop : std_logic := '1';
163
164signal local_write_length   : std_logic_vector (16 DOWNTO 0);
165signal local_ram_start_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
166signal local_ram_addr       : std_logic_vector (RAM_ADDR_WIDTH-1 downto 0);
167signal local_socket_nr      : std_logic_vector (2 DOWNTO 0);
168signal local_write_header_flag, local_write_end_flag : std_logic;
169signal local_fifo_channels : std_logic_vector (3 downto 0);
170
171
172
173
174-- signals used for MAC/IP calculation:
175-- these 2 synch in, the jumper state.
176signal FAD_in_cam : std_logic := '0';
177signal FAD_at_ETHZ : std_logic := '0';
178-- these 2 synch in the FMP lines encoding the FAD position in the cam.
179signal bid : std_logic_vector (3 downto 0);
180signal cid : std_logic_vector (1 downto 0);
181-- these are just used as local variables, to make reading easier.
182signal mac_loc : mac_type;
183signal ip_loc : ip_type;
184signal gateway_loc : ip_type;
185signal netmask_loc : ip_type;
186
187        -- signals for synching in asynchronous input signals
188        ------------------------------------------------------------------------------
189        signal w5300_interrupt_sr : std_logic_vector(1 downto 0) := "11";
190         --?? not sure if this init value is good
191         -- but should be no problem, because interrupt_ignore is not true during the first 2 clock cycles.
192         -- I hope!
193        signal data_valid_sr : std_logic_vector(1 downto 0) := "00"; 
194        ------------------------------------------------------------------------------
195
196
197-- only for debugging
198--signal error_cnt : std_logic_vector (7 downto 0) := (others => '0');
199--signal last_trigger_id : std_logic_vector (15 downto 0) := (others => '0');
200
201
202-- signals for different socket modes: DN 04.01.11
203signal socket_nr_counter : integer range 1 to 7 :=1; --used to determine which socket is used for data sending
204signal socket_send_mode : std_logic := '0'; -- if 0 data is send via socket 0; if 1 data is send via the other sockets.
205-- signals for Sockek Number calculation
206signal event_number : std_logic_vector(31 downto 0);
207signal mod7_start : std_logic := '0';
208signal mod7_started : std_logic;
209signal mod7_valid : std_logic;
210signal mod7_result : std_logic_vector(2 downto 0);
211
212COMPONENT mod7
213         PORT (
214                        clk       : IN     std_logic;
215                        number    : IN     std_logic_vector (31 DOWNTO 0);
216                        start     : IN     std_logic;
217                        remainder : OUT    std_logic_vector (2 DOWNTO 0) := (others => '0');
218                        started   : OUT    std_logic                     := '0';
219                        valid     : OUT    std_logic                     := '0'
220         );
221         END COMPONENT;
222
223
224
225begin
226       
227        mod7_calculator : mod7
228        PORT MAP (
229                --locals => actuals
230                clk                     =>clk   ,
231                number          =>event_number  ,
232                start           =>mod7_start    ,
233                remainder       =>mod7_result   ,
234                started         =>mod7_started  ,
235                valid           =>mod7_valid
236        );
237
238
239  --synthesis translate_off
240  RST_TIME <= X"00120";
241  --synthesis translate_on
242
243
244        w5300_proc : process (clk)
245        begin
246                if rising_edge (clk) then
247                -- synch asynchronous input in:
248                w5300_interrupt_sr <= w5300_interrupt_sr(1) & int;
249                data_valid_sr <= data_valid_sr(1) & data_valid;
250               
251                        -- interrupt is handled synchronously
252                        -- W5300 pulls low its interrpt line in case of:
253                        --      When Sockets time out and
254                        -- When sockets receive disconnection request.
255                       
256                        if (w5300_interrupt_sr = "01") and (interrupt_ignore = '0') then
257                                case state_interrupt_1 is
258                                        when IR1_01 =>
259                                                int_flag <= '1';
260                                                busy <= '1';
261                                                state_interrupt_1 <= IR1_02;  --wait one cycle
262                                        when IR1_02 =>
263                                                state_interrupt_1 <= IR1_03;
264                                        when IR1_03 =>
265                                                state_init <= INTERRUPT;
266                                                socket_cnt <= "000";
267                                                ram_access <= '0';
268                                                zaehler <= X"00000";    --what is this zaehler counting?
269                                                count <= "000";                 --what is this count counting?
270                                                int_flag <= '0';
271                                                interrupt_ignore <= '1';
272                                                state_interrupt_1 <= IR1_04;  --this state is not existing? bad coding habit???
273                                        when others =>
274                                                null;
275                                end case;
276                        end if; -- int = '0'
277                       
278                        if int_flag = '0' then
279                                case state_init is
280                                        -- Interrupt
281                                        when INTERRUPT =>
282                                                case state_interrupt_2 is
283                                                        when IR2_01 =>
284                                                                par_addr <= W5300_IR;
285                                                                state_init <= READ_REG;
286                                                                next_state <= INTERRUPT;
287                                                                state_interrupt_2 <= IR2_02;
288                                                               
289                                                        -- check if it was a Sx Interrupt of Socket n
290                                                        -- therfor: loop over all channel.
291                                                        -- if the loop ended but no Sx Interrupt was found --> IR2_06
292                                                        -- if an Sx Interrupt was found go to --> IR2_03 and check what happened.
293                                                        when IR2_02 => 
294                                                                if (data_read (conv_integer(socket_cnt)) = '1') then -- Sx Interrupt
295                                                                        state_interrupt_2 <= IR2_03;
296                                                                else
297                                                                        socket_cnt <= socket_cnt + 1;
298                                                                        if (socket_cnt = 7) then
299                                                                                state_interrupt_2 <= IR2_06;
300                                                                        else
301                                                                                state_interrupt_2 <= IR2_02;  -- go on with loop
302                                                                        end if; 
303                                                                end if;
304                                                               
305                                                        -- check the Interrupt register of the Socket, which caused the Interrupt.
306                                                        when IR2_03 =>
307                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC; -- Sx Interrupt Register
308                                                                state_init <= READ_REG;
309                                                                next_state <= INTERRUPT;
310                                                                state_interrupt_2 <= IR2_04;
311                                                        -- before checking what happened, clear the Interrupt register, so we can proceed.
312                                                        when IR2_04 =>
313                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC;
314                                                                par_data <= data_read; -- clear Interrupts
315                                                                state_init <= WRITE_REG;
316                                                                next_state <= INTERRUPT;
317                                                                state_interrupt_2 <= IR2_05;
318                                                        -- send the command to close this socket
319                                                        -- then go back and read the main Interrupt register again,
320                                                        -- if this was not Socket 7 ... if it was Socket 7, we're done anyway.
321                                                        when IR2_05 =>
322                                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
323                                                                par_data <= X"0010"; -- CLOSE
324                                                                state_init <= WRITE_REG;
325                                                                next_state <= INTERRUPT;
326                                                                socket_cnt <= socket_cnt + 1;
327                                                                if (socket_cnt = 7) then
328                                                                  state_interrupt_2 <= IR2_06;
329                                                                else
330                                                                  state_interrupt_2 <= IR2_01;
331                                                                end if; 
332
333                                                        -- we go on and reset, the W5300 and this entire state machine.
334                                                        when IR2_06 =>
335                                                                state_interrupt_1 <= IR1_01;
336                                                                state_interrupt_2 <= IR2_01;
337                                                                socket_cnt <= "000";
338                                                                state_init <= RESET;
339                                                end case;
340                                               
341                                        -- reset W5300
342                                        when RESET =>
343                                                socket_send_mode <= '0';
344                                                busy <= '1';
345                                                zaehler <= zaehler + 1;
346                                                socks_waiting <= '0';
347                                                socks_connected <= '0';
348                                                wiz_reset <= '0';
349                                                --led <= X"FF";
350                                                if (zaehler >= X"00064") then -- wait 2µs
351                                                        wiz_reset <= '1';
352                                                end if; 
353                                                if (zaehler = RST_TIME) then -- wait 10ms
354                                                        zaehler <= X"00000";
355                                                        socket_cnt <= "000";
356                                                        count <= "000";
357                                                        ram_access <= '0';
358                                                        interrupt_ignore <= '0';
359                                                        rd <= '1';
360                                                        wr <= '1';
361                                                        cs <= '1';
362                                                        state_write <= WR_START;
363                                                        state_init <= INIT;
364                                                end if;
365                                               
366                                        -- Init
367                                        when INIT =>
368                                                -- status of MAC jumpers is synched in
369                                                -- and Board- and CrateID are synched in
370                                                FAD_in_cam <= MAC_jumper(1); -- see position of jumpers in FACT logbook
371                                                FAD_at_ETHZ <= MAC_jumper(0); -- MAC_jumper(1) is where D_T(7) was; MAC_jumper(0) is where D_T(6) was;
372                                                bid <= BoardID;
373                                                cid <= CrateID;
374                                                par_addr <= W5300_MR;
375                                                par_data <= X"0000";
376                                                state_init <= WRITE_REG;
377                                                next_state <= LOCATE;
378                               
379                                        when LOCATE =>                                   
380                                                state_init <= IM;
381
382                                                if (FAD_in_cam = '1') then
383                                                        if (bid = "1111" and cid="11") then
384                                                                -- if BID = "1111" and CID="11" then FAD is not really in cam
385                                                                -- I don't know what to do now.
386                                                                -- I could wait a long time, and then just assume, I was not in cam.
387                                                                -- this should never happen!!!!!
388                                                                -- impossible to find this out, if in cam
389                                                                state_init <= INIT;
390                                                        else -- everything is fine
391                                                                -- IP & MAC are calculated from BID & CID
392                                                                -- code here
393                                                                gateway_loc <= CAM_GATEWAY;
394                                                                netmask_loc <= CAM_NETMASK;                                             
395                                                                mac_loc <= (CAM_MAC_prefix (0), CAM_MAC_prefix (1)  , conv_std_logic_vector ( conv_integer(cid)*10+conv_integer(bid)  , 16)   ); 
396                                                                ip_loc <= ( CAM_IP_PREFIX(0) , CAM_IP_PREFIX(1) , IP_offset + conv_integer(cid) , IP_offset + conv_integer(bid) );
397                                                        end if;
398                                                else -- FAD is tested, either at ETHZ or at TUDO AND either with FMP or without.
399                                                        if ( FAD_at_ETHZ = '0' ) then
400                                                                -- easy FAD is at TUDO -> only one choice.
401                                                                mac_loc <= MAC_FAD0;
402                                                                ip_loc <= IP_TUDO;
403                                                                gateway_loc <= TUDO_GATEWAY;
404                                                                netmask_loc <= TUDO_NETMASK;
405                                                        else -- FAD is at ETHZ but not in cam --> IP lookup table is needed.
406                                                                if (bid = "1111" and cid="11") then -- FAD is not in crate
407                                                                        mac_loc <= MAC_FAD0;
408                                                                        ip_loc <= IP_ETHZ_FAD0;
409                                                                        gateway_loc <= ETHZ_GATEWAY;
410                                                                        netmask_loc <= ETHZ_NETMASK;                                           
411                                                                else
412                                                                        -- FAD is at ETHZ and in crate:
413                                                                        -- crate ID is not of importance.
414                                                                        -- we only have 3 MACs and IPs so far, so only the first boardIDs are allowed.
415                                                                        if ( conv_integer(bid) < MAC_LIST'length) then
416                                                                                gateway_loc <= ETHZ_GATEWAY;
417                                                                                netmask_loc <= ETHZ_NETMASK;                                           
418                                                                                mac_loc <= MAC_LIST(conv_integer(bid));
419                                                                                ip_loc <= IP_LIST(conv_integer(bid));
420                                                                        end if; -- conv_integer
421                                                                end if; -- bid=1111 & cid=11
422                                                        end if; --FAD_at_ETHZ = 0
423                                                end if; --FAD_in_cam = 1
424                                               
425                                        -- Interrupt Mask
426                                        when IM =>
427                                                par_addr <= W5300_IMR;
428                                                par_data <= X"00FF"; -- S0-S7 Interrupts
429                                                state_init <= WRITE_REG;
430                                                next_state <= MT;
431                                               
432                                        -- Memory Type
433                                        when MT =>
434                                          par_addr <=   W5300_MTYPER;
435                                          par_data <= X"7FFF"; -- 8K RX, 120K TX-Buffer
436                                          state_init <= WRITE_REG;
437                                          next_state <= STX;
438                                         
439                                        -- Socket TX Memory Size
440                                        when STX =>
441                                          par_data <= X"0F0F"; -- 15K TX
442
443                                                par_addr <= W5300_TMS01R;
444                                                state_init <=WRITE_REG;
445                                                next_state <= STX1;
446          when STX1 =>
447            par_addr <= W5300_TMS23R;
448            state_init <=WRITE_REG;
449            next_state <= STX2;
450          when STX2 =>
451            par_addr <= W5300_TMS45R;
452            state_init <=WRITE_REG;
453            next_state <= STX3;
454          when STX3 =>
455            par_addr <= W5300_TMS67R;
456            state_init <=WRITE_REG;
457            next_state <= SRX;
458                                       
459          -- Socket RX Memory Size
460          when SRX =>
461            par_data <= X"0101"; -- 1K RX
462             
463            par_addr <= W5300_RMS01R;
464            state_init <=WRITE_REG;
465            next_state <= SRX1;
466          when SRX1 =>
467            par_addr <= W5300_RMS23R;
468            state_init <=WRITE_REG;
469            next_state <= SRX2;
470          when SRX2 =>
471            par_addr <= W5300_RMS45R;
472            state_init <=WRITE_REG;
473            next_state <= SRX3;
474          when SRX3 =>
475            par_addr <= W5300_RMS67R;
476            state_init <=WRITE_REG;
477            next_state <= MAC;
478         
479                                        -- MAC
480                                        when MAC =>
481                                                par_addr <= W5300_SHAR;
482                                                par_data <= mac_loc(0);
483                                                state_init <= WRITE_REG;
484                                                next_state <= MAC1;
485                                        when MAC1 =>
486                                                par_addr <= W5300_SHAR + 2;
487                                                par_data <= mac_loc(1);
488                                                state_init <= WRITE_REG;
489                                                next_state <= MAC2;
490                                        when MAC2 =>
491                                                par_addr <= W5300_SHAR + 4;
492                                                par_data <= mac_loc(2);
493                                                state_init <= WRITE_REG;
494                                                next_state <= GW;
495                                               
496                                        -- Gateway
497                                        when GW =>
498                                                par_addr <= W5300_GAR;
499                                                par_data (15 downto 8) <= conv_std_logic_vector(gateway_loc(0),8);
500                                                par_data (7 downto 0) <= conv_std_logic_vector(gateway_loc(1),8);
501                                                state_init <= WRITE_REG;
502                                                next_state <= GW1;
503                                        when GW1 =>
504                                                par_addr <= W5300_GAR + 2;
505                                                par_data (15 downto 8) <= conv_std_logic_vector(gateway_loc(2),8);
506                                                par_data (7 downto 0) <= conv_std_logic_vector(gateway_loc(3),8);
507                                                state_init <= WRITE_REG;
508                                                next_state <= SNM;
509                                               
510                                        -- Subnet Mask
511                                        when SNM =>
512                                                par_addr <= W5300_SUBR;
513                                                par_data (15 downto 8) <= conv_std_logic_vector(netmask_loc(0),8);
514                                                par_data (7 downto 0) <= conv_std_logic_vector(netmask_loc(1),8);
515                                                state_init <= WRITE_REG;
516                                                next_state <= SNM1;
517                                        when SNM1 =>
518                                                par_addr <= W5300_SUBR + 2;
519                                                par_data (15 downto 8) <= conv_std_logic_vector(netmask_loc(2),8);
520                                                par_data (7 downto 0) <= conv_std_logic_vector(netmask_loc(3),8);
521                                                state_init <= WRITE_REG;
522                                                next_state <= IP;
523                                        -- Own IP-Address
524                                        when IP =>
525                                                par_addr <= W5300_SIPR;
526                                                par_data (15 downto 8) <= conv_std_logic_vector(ip_loc(0),8);
527                                                par_data (7 downto 0) <= conv_std_logic_vector(ip_loc(1),8);
528                                                state_init <= WRITE_REG;
529                                                next_state <= IP1;
530                                        when IP1 =>
531                                                par_addr <= W5300_SIPR + 2;
532                                                par_data (15 downto 8) <= conv_std_logic_vector(ip_loc(2),8);
533                                                par_data (7 downto 0) <= conv_std_logic_vector(ip_loc(3),8);
534                                                state_init <= WRITE_REG;
535                                                next_state <= SI;
536--                                      when TIMEOUT =>
537--            par_addr <=       W5300_RTR;
538--            par_data <= X"07D0"; -- 0x07D0 = 200ms
539--            state_init <= WRITE_REG;
540--            next_state <= RETRY;
541--          when RETRY =>
542--            par_addr <=       W5300_RCR;
543--            par_data <= X"0008";
544--            state_init <= WRITE_REG;
545--            next_state <= SI;
546--                                       
547
548                                        -- Socket Init
549                                        when SI =>
550                                                par_addr <= W5300_S0_MR + socket_cnt * W5300_S_INC;
551                                                par_data <= X"0101"; -- ALIGN, TCP
552                                                state_init <= WRITE_REG;
553                                                next_state <= SI1;
554                                        -- Sx Interrupt Mask
555                                        when SI1 =>
556                                                par_addr <= W5300_S0_IMR + socket_cnt * W5300_S_INC;
557                                                par_data <= X"000A"; -- TIMEOUT, DISCON
558                                                state_init <= WRITE_REG;
559                                                next_state <= SI2;
560                                        when SI2 =>
561                                                par_addr <= W5300_S0_PORTR + socket_cnt * W5300_S_INC;
562                                                par_data <= conv_std_logic_vector(FIRST_PORT + unsigned (socket_cnt), 16);
563                                                state_init <= WRITE_REG;
564                                                next_state <= SI3;
565                                        when SI3 =>
566                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
567                                                par_data <= X"0001"; -- OPEN
568                                                state_init <= WRITE_REG;
569                                                next_state <= SI4;
570                                        when SI4 =>
571                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
572                                                state_init <= READ_REG;
573                                                next_state <= SI5;
574                                        when SI5 =>
575                                                if (data_read (7 downto 0) = X"13") then -- is open?
576                                                        state_init <= SI6;
577                                                else
578                                                        state_init <= SI4;
579                                                end if;
580                                        when SI6 =>
581                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
582                                                par_data <= X"0002"; -- LISTEN
583                                                state_init <= WRITE_REG;
584                                                socket_cnt <= socket_cnt + 1;
585                                                if (socket_cnt = 7) then
586                                                  socket_cnt <= "000";
587                                                  next_state <= ESTABLISH; -- All Sockets open
588                                                else
589                                                  next_state <= SI; -- Next Socket
590                                                end if;
591                                  -- End Socket Init
592                                               
593                                        when ESTABLISH =>
594                                                socks_waiting <= '1';
595                                                socks_connected <= '0';
596                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
597                                                state_init <= READ_REG;
598                                                next_state <= EST1;
599                                        when EST1 =>
600                                                case data_read (7 downto 0) is
601                                                        when X"17" => -- established
602                                                                if (socket_cnt = 7) then
603                                                                  socket_cnt <= "000";
604                                                                  busy <= '0';
605                                                                  state_init <= MAIN;
606                                                                else
607                                                                  socket_cnt <= socket_cnt + 1;
608                                                                  state_init <= ESTABLISH;
609                                                                end if;
610                                                        when others =>
611                                                                state_init <= ESTABLISH;
612                                                end case;
613                                       
614                                        when CONFIG =>
615                                                new_config <= '1';
616                                                state_init <= WAIT_FOR_CONFIG_DONE;
617                                        when WAIT_FOR_CONFIG_DONE =>
618                                                new_config <= '0';
619                                                if (config_chain_done ='1') then
620                                                        state_init <= MAIN;
621                                                end if;
622                                               
623----------------------------------------------------------------------------------
624-- MAIN "loop" -------------------------------------------------------------------
625----------------------------------------------------------------------------------
626         
627                                        when MAIN =>
628                                                socks_waiting <= '0';
629                                                socks_connected <= '1';
630                                                ps_do_phase_shift <= '0';
631                                                ps_reset <= '0';
632                                                if (trigger_stop = '1') then
633                                                        s_trigger <= '0';
634                                                end if;
635                                                data_valid_ack <= '0';
636                                                state_init <= MAIN1;
637                                                --data_valid_int <= data_valid;
638                                        when MAIN1 =>
639                                                if (chk_recv_cntr = 1000) then
640                                                        chk_recv_cntr <= 0;
641                                                        state_read_data <= RD_1;
642                                                        state_init <= READ_DATA;
643                                                        busy <= '1';
644                                                else
645                                                        chk_recv_cntr <= chk_recv_cntr + 1; 
646                                                        state_init <= MAIN2;
647                                                end if;
648                                        when MAIN2 =>
649                                                busy <= '0';
650                                                --if (data_valid = '1') then
651                                                if (data_valid_sr = "01" or data_valid_sr = "11") then
652                                                        --data_valid_int <= '0';
653                                                        busy <= '1';
654                                                        local_write_length <= write_length;
655                                                        local_ram_start_addr <= ram_start_addr;
656                                                        local_ram_addr <= (others => '0');
657                                                        local_write_header_flag <= write_header_flag;
658                                                        local_write_end_flag <= write_end_flag;
659                                                        local_fifo_channels <= fifo_channels;
660                                                        --                data_valid_ack <= '1';
661                                                        --                next_state <= MAIN;
662                                                        --                state_init <= WRITE_DATA;
663                                                        state_init <= MAIN3;
664                                                else
665                                                        state_init <= MAIN1;
666                                                end if;
667                                        when MAIN3 =>
668                                                -- needed for the check: if there is enough space in W5300 FIFO
669                                                write_length_bytes <= local_write_length (15 downto 0) & '0'; -- shift left (*2)
670                                                data_valid_ack <= '1';
671                                                next_state <= MAIN;
672                                                state_init <= WRITE_DATA;
673                                               
674----------------------------------------------------------------------------------
675-- END OF MAIN         -----------------------------------------------------------
676----------------------------------------------------------------------------------
677
678                                        -- read data from socket 0 
679                                        when READ_DATA =>
680                                                case state_read_data is
681                                                when RD_1 =>
682                                                        par_addr <= W5300_S0_RX_RSR;
683                                                        state_init <= READ_REG;
684                                                        next_state <= READ_DATA;
685                                                        state_read_data <= RD_2;
686                                                when RD_2 =>
687                                                        socket_rx_received (31 downto 16) <= data_read;
688                                                        par_addr <= W5300_S0_RX_RSR + X"2";
689                                                        state_init <= READ_REG;
690                                                        next_state <= READ_DATA;
691                                                        state_read_data <= RD_3;
692                                                when RD_3 =>
693                                                        socket_rx_received (15 downto 0) <= data_read;
694                                                        state_read_data <= RD_4;
695                                                when RD_4 =>
696                                                        if (socket_rx_received (16 downto 0) > ('0' & X"000")) then
697                                                                rx_packets_cnt <= socket_rx_received (16 downto 1); -- socket_rx_received / 2
698                                                                state_read_data <= RD_5;
699                                                        else
700                                                                busy <= '0';
701                                                                state_init <= MAIN;
702                                                        end if;
703                                                when RD_5 =>
704                                                        if (rx_packets_cnt > 0) then
705                                                                rx_packets_cnt <= rx_packets_cnt - '1';
706                                                                par_addr <= W5300_S0_RX_FIFOR;
707                                                                state_init <= READ_REG;
708                                                                next_state <= READ_DATA;
709                                                                state_read_data <= RD_6;
710                                                        else
711                                                                state_read_data <= RD_END;
712                                                        end if;
713                                                       
714                                                when RD_6 =>
715                                                        -- The next 16bit word is assumed to contain a 'command' so it is
716                                                        -- beeing parsed in this state
717                                                        case data_read (15 downto 8) is
718                                                        when CMD_START =>
719                                                                data_generator_run_mode <= '1';
720                                                                state_read_data <= RD_5;
721                                                        when CMD_STOP => 
722                                                                data_generator_run_mode <= '0';
723                                                                state_read_data <= RD_5;
724                                                        when CMD_MODE_ALL_SOCKETS =>  -- all data will be send via socket 1..7
725                                                                socket_send_mode <= '1';
726                                                                state_read_data <= RD_5;
727                                                        when CMC_MODE_COMMAND => -- all data will be send via socket 0
728                                                                socket_send_mode <= '0';
729                                                                state_read_data <= RD_5;   
730                                                        when CMD_TRIGGER =>
731                                                                trigger_stop <= '1';
732                                                                s_trigger <= '1';
733                                                                state_read_data <= RD_5;
734                                                        when CMD_DWRITE_RUN =>
735                                                                dwrite_enable <= '1';
736                                                                state_read_data <= RD_5;
737                                                        when CMD_DWRITE_STOP =>
738                                                                dwrite_enable <= '0';
739                                                                state_read_data <= RD_5;
740                                                        when CMD_SCLK_ON =>
741                                                                sclk_enable <= '1';
742                                                                state_read_data <= RD_5;
743                                                        when CMD_SCLK_OFF =>
744                                                                sclk_enable <= '0';
745                                                                state_read_data <= RD_5;
746                                                        when CMD_DENABLE =>
747                                                                denable <= '1';
748                                                                state_read_data <= RD_5;
749                                                        when CMD_DDISABLE =>
750                                                                denable <= '0';
751                                                                state_read_data <= RD_5;
752                                                        when CMD_TRIGGER_C =>
753                                                                c_trigger_enable <= '1';
754                                                                state_read_data <= RD_5;
755                                                        when CMD_TRIGGER_S =>
756                                                          c_trigger_enable <= '0';
757                                                          state_read_data <= RD_5;
758                                                        when CMD_SET_TRIGGER_MULT =>
759                                                                state_read_data <= NEW_CONT_TRIGGER_MULT_FACTOR_READ;
760                                                        -- phase shift commands here:
761                                                        when CMD_PS_DO =>
762                                                          ps_do_phase_shift <= '1';
763                                                          state_read_data <= RD_5;
764                                                        when CMD_PS_DIRINC =>
765                                                          ps_direction <= '1';
766                                                          state_read_data <= RD_5;
767                                                        when CMD_PS_RESET =>
768                                                          ps_reset <= '1';
769                                                          state_read_data <= RD_5;
770                                                        when CMD_SRCLK_ON =>
771                                                          srclk_enable <= '1';
772                                                          state_read_data <= RD_5;
773                                                        when CMD_SRCLK_OFF =>
774                                                          srclk_enable <= '0';
775                                                          state_read_data <= RD_5;
776                                                        when CMD_TRIGGERS_ON =>
777                                                          trigger_enable <= '1';
778                                                          state_read_data <= RD_5;
779                                                        when CMD_TRIGGERS_OFF =>
780                                                          trigger_enable <= '0';
781                                                          state_read_data <= RD_5;
782                                                        when CMD_PS_DIRDEC =>
783                                                          ps_direction <= '0';
784                                                          state_read_data <= RD_5;
785                                                        when CMD_WRITE =>
786                                                                config_addr <= data_read (7 downto 0);
787                                                                state_read_data <= READ_COMMAND_DATA_SECTION;
788                                                        when others =>
789                                                                state_read_data <= RD_5;
790                                                        end case;
791                -- read data
792
793                        -- these states are beeing precessed, if the 'command' was a 'write command'
794                        --      so it is assumed, that some data in config RAM changed, and we need full (re)config
795                        when READ_COMMAND_DATA_SECTION =>
796                                if (rx_packets_cnt > 0) then
797                                        rx_packets_cnt <= rx_packets_cnt - '1';
798                                        par_addr <= W5300_S0_RX_FIFOR;
799                                        state_init <= READ_REG;
800                                        next_state <= READ_DATA;
801                                        state_read_data <= PUT_COMMAND_DATA_SECTION;
802                                else
803                                        state_read_data <= RD_END;
804                                end if;
805                       
806                        when PUT_COMMAND_DATA_SECTION =>
807                                if (config_busy = '0') then
808                                        config_data <= data_read;
809                                        config_wr_en <= '1';
810                                        new_config_flag <= '1';
811                                        state_read_data <= RD_WAIT;
812                                end if;
813
814                                -- these states are beeing precessed, if the 'command' was a 'set new continouus trigger prescaler multiplication factor'-command
815                        --      so the next 16bit word is just put out at the apropriate output.
816                        when NEW_CONT_TRIGGER_MULT_FACTOR_READ =>
817                                if (rx_packets_cnt > 0) then
818                                        rx_packets_cnt <= rx_packets_cnt - '1';
819                                        par_addr <= W5300_S0_RX_FIFOR;
820                                        state_init <= READ_REG;
821                                        next_state <= READ_DATA;
822                                        state_read_data <= NEW_CONT_TRIGGER_MULT_FACTOR_PUT;
823                                else
824                                        state_read_data <= RD_END;
825                                end if;
826                        when NEW_CONT_TRIGGER_MULT_FACTOR_PUT =>
827                                c_trigger_mult <= data_read;
828                                state_read_data <= RD_5;
829
830
831              when RD_WAIT =>
832                if (config_rw_ack = '1') then
833                  state_read_data <= RD_WAIT1;
834                end if;
835              when RD_WAIT1 =>
836                if (config_rw_ready = '1') then
837                  config_data <= (others => 'Z');
838                  config_wr_en <= '0';
839                  state_read_data <= RD_5;
840                end if;
841              when RD_END =>
842                par_addr <= W5300_S0_CR;
843                par_data <= X"0040"; -- RECV
844                state_init <= WRITE_REG;
845                if (new_config_flag = '1') then
846                  new_config_flag <= '0';
847                  next_state <= CONFIG;
848                else
849                  next_state <= MAIN;
850                end if;
851
852            end case; -- state_data_read
853               
854   
855
856                                        when WRITE_DATA =>
857                                                case state_write is
858                                                       
859                                                  when WR_START =>
860                                                    if (local_write_header_flag = '1') then
861                                                      ram_addr <= local_ram_start_addr + 6; -- Address of HIGH word of Event ID
862                                                      state_write <= WR_GET_EVT_ID_WAIT1;
863                                              else
864                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01;
865                                                    end if;
866                                                     
867                                                  when WR_GET_EVT_ID_WAIT1 =>
868                                                    state_write <= WR_GET_EVT_ID1;
869                                                  when WR_GET_EVT_ID1 =>
870                                                                event_number(31 downto 16) <= ram_data;
871                                                                ram_addr <= local_ram_start_addr + 7; -- Address of LOW word of Event ID
872                                                                state_write <= WR_GET_EVT_ID_WAIT2;
873                                                        when WR_GET_EVT_ID_WAIT2 =>
874                                                                state_write <= WR_GET_EVT_ID2;
875                                                  when WR_GET_EVT_ID2 =>
876                                                                event_number(15 downto 0) <= ram_data;
877                                                                if (mod7_valid = '1') then
878                                                                        mod7_start <= '1';
879                                                                        state_write <= WR_MOD7_STARTED;
880                                                                else
881                                                                        state_write <= WR_GET_EVT_ID2;
882                                                                end if;
883                                                               
884                                                        when WR_MOD7_STARTED =>
885                                                                if (mod7_started = '1') then
886                                                                        mod7_start <= '0';
887                                                                        state_write <= WR_WAIT_FOR_MOD7;
888                                                                end if;
889
890                                                        when WR_WAIT_FOR_MOD7 =>
891                                                                if (mod7_valid = '1') then
892                                                                        if (socket_send_mode = '1') then -- send via all sockets
893                                                                                                local_socket_nr <= mod7_result;
894                                                                        else -- only send via socket 0\
895                                                                                                local_socket_nr <= "000";
896                                                                        end if;
897                                                                        next_state_tmp <= next_state;
898                                                                        data_cnt <= 0;
899                                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01; 
900                                                                else 
901                                                                        state_write <= WR_WAIT_FOR_MOD7;
902                                                                end if;
903                                                               
904                                                        -- Check FIFO Size
905                                                        when WR_CHECK_FOR_FIFO_SPACE_01 =>
906                                                                par_addr <= W5300_S0_TX_FSR + local_socket_nr * W5300_S_INC;
907                                                                state_init <= READ_REG;
908                                                                next_state <= WRITE_DATA;
909                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_02;
910                                                        when WR_CHECK_FOR_FIFO_SPACE_02 =>
911                                                                socket_tx_free (31 downto 16) <= data_read;
912                                                                par_addr <= W5300_S0_TX_FSR + (local_socket_nr * W5300_S_INC) + X"2";
913                                                                state_init <= READ_REG;
914                                                                next_state <= WRITE_DATA;
915                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_03;
916                                                        when WR_CHECK_FOR_FIFO_SPACE_03 =>
917                                                                socket_tx_free (15 downto 0) <= data_read;
918                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_04;
919                                                        when WR_CHECK_FOR_FIFO_SPACE_04 =>
920--                                                              if (socket_tx_free (16 downto 0) < write_length_bytes) then
921                                                                if (socket_tx_free (16 downto 0) < W5300_TX_FIFO_SIZE_8B) then
922                                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01;
923                                                                else
924                                                                        if (local_write_header_flag = '1') then
925                                                                                state_write <= WR_FIFO;
926                                                                        else
927                                                                                state_write <= WR_ADC;
928                                                                        end if; 
929                                                                end if;
930                                                       
931                                                        -- Fill FIFO
932
933                                                        -- Write Header
934                                                        when WR_FIFO =>
935                                                                ram_addr <= local_ram_start_addr + local_ram_addr;
936                                                                state_write <= WR_FIFO1;
937                                                        when WR_FIFO1 =>
938                                                                data_cnt <= data_cnt + 1;
939                                                                if (data_cnt < PACKAGE_HEADER_LENGTH) then --???
940                                                                  local_ram_addr <= local_ram_addr + 1;
941--                                                                if (data_cnt = 2 or data_cnt = 5 or data_cnt = 8 ) then -- skip empty words
942--                                                                  local_ram_addr <= local_ram_addr + 2;
943--                                                                end if;
944--                                                                if (data_cnt = 9) then -- skip empty words
945--                                                                  local_ram_addr <= local_ram_addr + 4;
946--                                                                end if; 
947                                                                        par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
948                                                                        ram_access <= '1';
949                                                                        state_init <= WRITE_REG;
950                                                                        next_state <= WRITE_DATA;
951                                                                        state_write <= WR_FIFO;
952                                                                else
953                                                                        state_write <= WR_ADC;
954                                                                end if;
955                                                        -- End Write Header
956                                                       
957                                                        -- Write ADC-Data
958                                                        ---- Start...
959                                                        when WR_ADC =>
960                                                          adc_data_addr <= local_ram_start_addr + local_ram_addr;
961                                                          drs_cnt <= 0;
962                                                          channel_cnt <= 1;
963                data_cnt <= 0;
964                                                          roi_max <= (others => '0');
965                                                          data_end <= 3;
966                                                          state_write <= WR_ADC1;
967
968                                                        ---- Write Channel
969                                                        when WR_ADC1 =>
970                                                          -- read ROI and set end of Channel-Data
971                                                          if (data_cnt = 3) then
972                                                            data_end <= conv_integer (ram_data) + 3;
973                                                            if (ram_data > roi_max) then
974                                                              roi_max <= ram_data (10 downto 0);
975                                                            end if;
976                                                          end if;
977                                                          ram_addr <= adc_data_addr + drs_cnt + (data_cnt * 4);
978                state_write <= WR_ADC2;
979                                                        when WR_ADC2 =>
980                if (data_cnt < data_end) then
981                  par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
982                  ram_access <= '1';
983                  state_init <= WRITE_REG;
984                  next_state <= WRITE_DATA;
985                  data_cnt <= data_cnt + 1;
986                  state_write <= WR_ADC1;
987                else
988                  -- Next DRS
989                  if (drs_cnt < 3) then
990                    drs_cnt <= drs_cnt + 1;
991                    data_cnt <= 0;
992                    data_end <= 3;
993                    state_write <= WR_ADC1;
994                  else
995                    -- Next Channel
996                    if (channel_cnt < local_fifo_channels) then
997                      channel_cnt <= channel_cnt + 1;
998                      roi_max <= (others => '0');
999                      drs_cnt <= 0;
1000                      data_cnt <= 0;
1001                      data_end <= 3;
1002                      adc_data_addr <= adc_data_addr + ((conv_integer(roi_max) + 3) * 4);
1003                      state_write <= WR_ADC1;
1004                    else
1005                      -- Ready
1006                      if (local_write_end_flag = '1') then
1007                        state_write <= WR_ENDFLAG;
1008                      else
1009                        state_write <= WR_05;
1010                      end if;
1011                    end if;
1012                  end if;   
1013                end if;
1014                                                        -- End Write ADC-Data
1015
1016              -- Write End Package Flag
1017              when WR_ENDFLAG =>
1018                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + 3) * 4);
1019                state_write <= WR_ENDFLAG1;
1020              when WR_ENDFLAG1 =>
1021                par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
1022                ram_access <= '1';
1023                state_init <= WRITE_REG;
1024                next_state <= WRITE_DATA;
1025                state_write <= WR_ENDFLAG2;
1026              when WR_ENDFLAG2 =>
1027                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + 3) * 4) + 1;
1028                state_write <= WR_ENDFLAG3;
1029              when WR_ENDFLAG3 =>
1030                state_init <= WRITE_REG;
1031                next_state <= WRITE_DATA;
1032                state_write <= WR_05a;
1033             
1034              -- End Write End Package Flag
1035             
1036              -- Wait????
1037              when WR_05a =>
1038                if (wait_cntr < 10) then -- 3000 works???
1039                  wait_cntr <= wait_cntr + 1;
1040                else
1041                  wait_cntr <= 0;
1042                  state_write <= WR_05b;
1043                end if;
1044              when WR_05b =>
1045                state_write <= WR_05;
1046
1047              --Send FIFO
1048                                                        when WR_05 =>
1049                                                          ram_access <= '0';
1050                                                                par_addr <= W5300_S0_TX_WRSR + local_socket_nr * W5300_S_INC;
1051                                                                par_data <= (0 => write_length_bytes (16), others => '0');
1052                                                                state_init <= WRITE_REG;
1053                                                                state_write <= WR_06;
1054                                                        when WR_06 =>
1055                                                                par_addr <= W5300_S0_TX_WRSR + (local_socket_nr * W5300_S_INC) + X"2";
1056                                                                par_data <= write_length_bytes (15 downto 0);
1057                                                                state_init <= WRITE_REG;
1058                                                                state_write <= WR_07;
1059                                                        when WR_07 =>
1060                                                                par_addr <= W5300_S0_CR + local_socket_nr * W5300_S_INC;
1061                                                                par_data <= X"0020"; -- Send
1062                                                                state_init <= WRITE_REG;
1063                                                                state_write <= WR_08;
1064                                                        when others =>
1065                                                                state_init <= next_state_tmp;
1066                                                                state_write <= WR_START;
1067                                                end case;
1068                                                -- End WRITE_DATA
1069                                               
1070                                        when READ_REG =>
1071                                                case count is
1072                                                        when "000" =>
1073                                                                cs <= '0';
1074                                                                rd <= '0';
1075                                                                wr <= '1';
1076                                                                data <= (others => 'Z'); -- !!!!!!!!!!
1077                                                                count <= "001";
1078                                                                addr <= par_addr;
1079                                                        when "001" =>
1080                                                                count <= "010";
1081                                                        when "010" =>
1082                                                                count <= "100";
1083                                                        when "100" =>
1084                                                                data_read <= data;
1085                                                                count <= "110";
1086                                                        when "110" =>
1087                                                                count <= "111";
1088                                                        when "111" =>
1089                                                                cs <= '1';
1090                                                                rd <= '1';
1091                                                                count <= "000";
1092                                                                state_init <= next_state;
1093                                                        when others =>
1094                                                                null;
1095                                                end case;
1096                                       
1097                                        when WRITE_REG =>
1098                                                case count is
1099                                                        when "000" =>
1100                                                                cs <= '0';
1101                                                                wr <= '0';
1102                                                                rd <= '1';
1103                                                                addr <= par_addr; 
1104                                                                if (ram_access = '1') then
1105                                                                        data <= ram_data;
1106                                                                else
1107                                                                        data <= par_data;
1108                                                                end if;
1109                                                                count <= "100";
1110                                                        when "100" =>
1111                                                                count <= "101";
1112                                                        when "101" =>
1113                                                                count <= "110";
1114                                                        when "110" =>
1115                                                                cs <= '1';
1116                                                                wr <= '1';
1117                                                                state_init <= next_state;
1118                                                                count <= "000";
1119                                                        when others =>
1120                                                                null;
1121                                                end case;
1122                                       
1123                                        when others =>
1124                                                null;
1125                                end case;
1126                        end if; -- int_flag = '0'
1127
1128                end if; -- rising_edge (clk)
1129
1130        end process w5300_proc;
1131
1132end Behavioral;
1133
Note: See TracBrowser for help on using the repository browser.