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

Last change on this file since 9912 was 9912, checked in by neise, 10 years ago
most recent version quasi initial commit
File size: 28.0 KB
Line 
1----------------------------------------------------------------------------------
2-- Company:
3-- Engineer:
4--
5-- Create Date:    11:48:48 11/10/2009
6-- Design Name:
7-- Module Name:    w5300_modul - Behavioral
8-- Project Name:
9-- Target Devices:
10-- Tool versions:
11-- Description:
12--
13-- Dependencies:
14--
15-- Revision:
16-- Revision 0.01 - File Created
17-- Additional Comments:
18--
19----------------------------------------------------------------------------------
20library IEEE;
21use IEEE.STD_LOGIC_1164.ALL;
22use IEEE.STD_LOGIC_ARITH.ALL;
23use IEEE.STD_LOGIC_UNSIGNED.ALL;
24library FACT_FAD_lib;
25use FACT_FAD_lib.fad_definitions.ALL;
26
27---- Uncomment the following library declaration if instantiating
28---- any Xilinx primitives in this code.
29--library UNISIM;
30--use UNISIM.VComponents.all;
31
32ENTITY w5300_modul IS
33  generic(
34    RAM_ADDR_WIDTH : integer := 14
35  );
36   PORT(
37      clk            : IN     std_logic;
38      wiz_reset      : OUT    std_logic                     := '1';
39      addr           : OUT    std_logic_vector (9 DOWNTO 0);
40      data           : INOUT  std_logic_vector (15 DOWNTO 0);
41      cs             : OUT    std_logic                     := '1';
42      wr             : OUT    std_logic                     := '1';
43      led            : OUT    std_logic_vector (7 DOWNTO 0) := (OTHERS => '0');
44      rd             : OUT    std_logic                     := '1';
45      int            : IN     std_logic;
46      write_length   : IN     std_logic_vector (16 DOWNTO 0);
47      ram_start_addr : IN     std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
48      ram_data       : IN     std_logic_vector (15 DOWNTO 0);
49      ram_addr       : OUT    std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
50      data_valid     : IN     std_logic;
51          data_valid_ack : OUT    std_logic := '0';
52      busy           : OUT    std_logic                     := '1';
53      write_header_flag, write_end_flag : IN std_logic;
54      fifo_channels : IN std_logic_vector (3 downto 0);
55      s_trigger : OUT std_logic := '0';
56      new_config : OUT std_logic := '0';
57      config_started : in std_logic;
58      config_addr : out std_logic_vector (7 downto 0);
59      config_data : inout std_logic_vector (15 downto 0) := (others => 'Z');
60      config_wr_en : out std_logic := '0';
61      config_rd_en : out std_logic := '0';
62      config_busy : in std_logic;
63     
64
65     
66      denable : out std_logic := '0'; -- default domino wave off
67      dwrite_enable : out std_logic := '0'; -- default DWRITE low.
68      sclk_enable : out std_logic := '1'; -- default DWRITE HIGH.
69      ps_direction : out std_logic := '1'; -- default phase shift upwards
70      ps_do_phase_shift : out std_logic := '0'; --pulse this to phase shift once
71      ps_reset : out std_logic := '0' -- pulse this to reset the variable phase shift
72   );
73
74-- Declarations
75
76END w5300_modul ;
77
78architecture Behavioral of w5300_modul is
79
80type state_init_type is (INTERRUPT, RESET, WRITE_REG, READ_REG, WRITE_DATA,
81                         INIT, IM, MT, STX, STX1, STX2, STX3, SRX, SRX1, SRX2, SRX3, MAC, MAC1, MAC2, GW, GW1, SNM, SNM1, IP, IP1, TIMEOUT, RETRY,
82                         SI, SI1, SI2, SI3, SI4, SI5, SI6,      ESTABLISH, EST1, CONFIG, MAIN, CHK_RECEIVED, READ_DATA);
83type state_write_type is (WR_START, WR_LENGTH, WR_WAIT1, WR_01, WR_02, WR_03, WR_04, WR_05, WR_06, WR_07, WR_08, WR_FIFO, WR_FIFO1, WR_ADC, WR_ADC1, WR_ADC2,
84                          WR_ENDFLAG, WR_ENDFLAG1, WR_ENDFLAG2, WR_ENDFLAG3);
85type state_interrupt_1_type is (IR1_01, IR1_02, IR1_03, IR1_04);
86type state_interrupt_2_type is (IR2_01, IR2_02, IR2_03, IR2_04, IR2_05, IR2_06);
87type state_read_data_type is (RD_1, RD_2, RD_3, RD_4, RD_5, RD_6, RD_WAIT, RD_WAIT1, RD_END);
88
89signal RST_TIME : std_logic_vector(19 downto 0) := X"7A120";
90
91signal par_addr : std_logic_vector (9 downto 0) := (OTHERS => '0');
92signal par_data : std_logic_vector (15 downto 0) := (OTHERS => '0');
93signal data_read : std_logic_vector (15 downto 0) := (OTHERS => '0');
94signal adc_data_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
95
96signal state_init, next_state , next_state_tmp : state_init_type := RESET;
97signal count : std_logic_vector (2 downto 0) := "000";
98signal state_write : state_write_type := WR_START;
99signal state_interrupt_1 : state_interrupt_1_type := IR1_01;
100signal state_interrupt_2 : state_interrupt_2_type := IR2_01;
101signal state_read_data : state_read_data_type := RD_1;
102
103signal interrupt_ignore : std_logic := '1';
104signal int_flag : std_logic := '0';
105signal ram_access : std_logic := '0';
106
107signal zaehler : std_logic_vector (19 downto 0) := (OTHERS => '0');
108signal data_cnt : integer := 0;
109signal drs_cnt : integer :=0;
110signal channel_cnt : integer range 0 to 9 :=0;
111signal socket_cnt : std_logic_vector (2 downto 0) := "000";
112signal roi_max : std_logic_vector (10 downto 0);
113signal data_end : integer := 0;
114
115signal socket_tx_free : std_logic_vector (31 downto 0) := (others => '0');
116signal write_length_bytes : std_logic_vector (16 downto 0);
117
118signal socket_rx_received : std_logic_vector (31 downto 0) := (others => '0');
119signal chk_recv_cntr : integer range 0 to 10000 := 0;
120signal rx_packets_cnt : std_logic_vector (15 downto 0);
121signal next_packet_data : std_logic := '0';
122signal new_config_flag : std_logic := '0';
123
124signal trigger_stop : std_logic := '1';
125
126signal local_write_length   : std_logic_vector (16 DOWNTO 0);
127signal local_ram_start_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
128signal local_ram_addr       : std_logic_vector (RAM_ADDR_WIDTH-1 downto 0);
129signal local_socket_nr      : std_logic_vector (2 DOWNTO 0);
130signal local_write_header_flag, local_write_end_flag : std_logic;
131signal local_fifo_channels : std_logic_vector (3 downto 0);
132
133begin
134
135  --synthesis translate_off
136  RST_TIME <= X"00120";
137  --synthesis translate_on
138
139        w5300_init_proc : process (clk, int)
140        begin
141               
142                if rising_edge (clk) then
143
144                        -- Interrupt low
145                        if (int = '0') and (interrupt_ignore = '0') then
146                                case state_interrupt_1 is
147                                        when IR1_01 =>
148                                                int_flag <= '1';
149                                                busy <= '1';
150                                                state_interrupt_1 <= IR1_02;
151                                        when IR1_02 =>
152                                                state_interrupt_1 <= IR1_03;
153                                        when IR1_03 =>
154                                                state_init <= INTERRUPT;
155                                                socket_cnt <= "000";
156                                                ram_access <= '0';
157                                                zaehler <= X"00000";
158                                                count <= "000";
159                                                int_flag <= '0';
160                                                interrupt_ignore <= '1';
161                                                state_interrupt_1 <= IR1_04;
162                                        when others =>
163                                                null;
164                                end case;
165                        end if; -- int = '0'
166                       
167                        if int_flag = '0' then
168                                case state_init is
169                                        -- Interrupt
170                                        when INTERRUPT =>
171                                                case state_interrupt_2 is
172                                                        when IR2_01 =>
173                                                                par_addr <= W5300_IR;
174                                                                state_init <= READ_REG;
175                                                                next_state <= INTERRUPT;
176                                                                state_interrupt_2 <= IR2_02;
177                                                        when IR2_02 =>
178                                                                if (data_read (conv_integer(socket_cnt)) = '1') then -- Sx Interrupt
179                                                                        state_interrupt_2 <= IR2_03;
180                                                                else
181                  socket_cnt <= socket_cnt + 1;
182                  if (socket_cnt = 7) then
183                    state_interrupt_2 <= IR2_06;
184                  else
185                    state_interrupt_2 <= IR2_02;
186                  end if;
187                                                                end if;
188                                                        when IR2_03 =>
189                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC; -- Sx Interrupt Register
190                                                                state_init <= READ_REG;
191                                                                next_state <= INTERRUPT;
192                                                                state_interrupt_2 <= IR2_04;
193                                                        when IR2_04 =>
194                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC;
195                                                                par_data <= data_read; -- clear Interrupts
196                                                                state_init <= WRITE_REG;
197                                                                next_state <= INTERRUPT;
198                                                                state_interrupt_2 <= IR2_05;
199                                                        when IR2_05 =>
200                                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
201                                                                par_data <= X"0010"; -- CLOSE
202                                                                state_init <= WRITE_REG;
203                                                                next_state <= INTERRUPT;
204                                                                socket_cnt <= socket_cnt + 1;
205                                                                if (socket_cnt = 7) then
206                                                                  state_interrupt_2 <= IR2_06;
207                                                                else
208                                                                  state_interrupt_2 <= IR2_01;
209                                                                end if;
210
211                                                        when IR2_06 =>
212                                                                state_interrupt_1 <= IR1_01;
213                                                                state_interrupt_2 <= IR2_01;
214                                                                socket_cnt <= "000";
215                                                                state_init <= RESET;
216                                                end case;
217                                               
218                                        -- reset W5300
219                                        when RESET =>
220                                                zaehler <= zaehler + 1;
221            wiz_reset <= '0';
222            led <= X"FF";
223                                                if (zaehler >= X"00064") then -- wait 2µs
224                                                        wiz_reset <= '1';
225                                                end if;
226                                                if (zaehler = RST_TIME) then -- wait 10ms
227                                                        zaehler <= X"00000";
228                                                        socket_cnt <= "000";
229                                                        count <= "000";
230                                                        ram_access <= '0';
231                                                        interrupt_ignore <= '0';
232                                                        rd <= '1';
233                                                        wr <= '1';
234                                                        cs <= '1';
235                                                        state_write <= WR_START;
236                                                        state_init <= INIT;
237                                                end if;
238                                               
239                                        -- Init
240                                        when INIT =>
241                                                par_addr <= W5300_MR;
242                                                par_data <= X"0000";
243                                                state_init <= WRITE_REG;
244                                                next_state <= IM;
245                                               
246                                        -- Interrupt Mask
247                                        when IM =>
248                                                par_addr <= W5300_IMR;
249                                                par_data <= X"00FF"; -- S0-S7 Interrupts
250                                                state_init <= WRITE_REG;
251                                                next_state <= MT;
252                                               
253                                        -- Memory Type
254                                        when MT =>
255                                          par_addr <=   W5300_MTYPER;
256                                          par_data <= X"7FFF"; -- 8K RX, 120K TX-Buffer
257                                          state_init <= WRITE_REG;
258                                          next_state <= STX;
259                                         
260                                        -- Socket TX Memory Size
261                                        when STX =>
262                                          par_data <= X"0F0F"; -- 15K TX
263
264                                                par_addr <= W5300_TMS01R;
265                                                state_init <=WRITE_REG;
266                                                next_state <= STX1;
267          when STX1 =>
268            par_addr <= W5300_TMS23R;
269            state_init <=WRITE_REG;
270            next_state <= STX2;
271          when STX2 =>
272            par_addr <= W5300_TMS45R;
273            state_init <=WRITE_REG;
274            next_state <= STX3;
275          when STX3 =>
276            par_addr <= W5300_TMS67R;
277            state_init <=WRITE_REG;
278            next_state <= SRX;
279                                       
280          -- Socket RX Memory Size
281          when SRX =>
282            par_data <= X"0101"; -- 1K RX
283             
284            par_addr <= W5300_RMS01R;
285            state_init <=WRITE_REG;
286            next_state <= SRX1;
287          when SRX1 =>
288            par_addr <= W5300_RMS23R;
289            state_init <=WRITE_REG;
290            next_state <= SRX2;
291          when SRX2 =>
292            par_addr <= W5300_RMS45R;
293            state_init <=WRITE_REG;
294            next_state <= SRX3;
295          when SRX3 =>
296            par_addr <= W5300_RMS67R;
297            state_init <=WRITE_REG;
298            next_state <= MAC;
299         
300                                        -- MAC
301                                        when MAC =>
302                                                par_addr <= W5300_SHAR;
303                                                par_data <= MAC_ADDRESS (0);
304                                                state_init <= WRITE_REG;
305                                                next_state <= MAC1;
306                                        when MAC1 =>
307                                                par_addr <= W5300_SHAR + 2;
308                                                par_data <= MAC_ADDRESS (1);
309                                                state_init <= WRITE_REG;
310                                                next_state <= MAC2;
311                                        when MAC2 =>
312                                                par_addr <= W5300_SHAR + 4;
313                                                par_data <= MAC_ADDRESS (2);
314                                                state_init <= WRITE_REG;
315                                                next_state <= GW;
316                                               
317                                        -- Gateway
318                                        when GW =>
319                                                par_addr <= W5300_GAR;
320                                                par_data (15 downto 8) <= conv_std_logic_vector(GATEWAY (0),8);
321                                                par_data (7 downto 0) <= conv_std_logic_vector(GATEWAY (1),8);
322                                                state_init <= WRITE_REG;
323                                                next_state <= GW1;
324                                        when GW1 =>
325                                                par_addr <= W5300_GAR + 2;
326                                                par_data (15 downto 8) <= conv_std_logic_vector(GATEWAY (2),8);
327                                                par_data (7 downto 0) <= conv_std_logic_vector(GATEWAY (3),8);
328                                                state_init <= WRITE_REG;
329                                                next_state <= SNM;
330                                               
331                                        -- Subnet Mask
332                                        when SNM =>
333                                                par_addr <= W5300_SUBR;
334                                                par_data (15 downto 8) <= conv_std_logic_vector(NETMASK (0),8);
335                                                par_data (7 downto 0) <= conv_std_logic_vector(NETMASK (1),8);
336                                                state_init <= WRITE_REG;
337                                                next_state <= SNM1;
338                                        when SNM1 =>
339                                                par_addr <= W5300_SUBR + 2;
340                                                par_data (15 downto 8) <= conv_std_logic_vector(NETMASK (2),8);
341                                                par_data (7 downto 0) <= conv_std_logic_vector(NETMASK (3),8);
342                                                state_init <= WRITE_REG;
343                                                next_state <= IP;
344                                        -- Own IP-Address
345                                        when IP =>
346                                                par_addr <= W5300_SIPR;
347                                                par_data (15 downto 8) <= conv_std_logic_vector(IP_ADDRESS (0),8);
348                                                par_data (7 downto 0) <= conv_std_logic_vector(IP_ADDRESS (1),8);
349                                                state_init <= WRITE_REG;
350                                                next_state <= IP1;
351                                        when IP1 =>
352                                                par_addr <= W5300_SIPR + 2;
353                                                par_data (15 downto 8) <= conv_std_logic_vector(IP_ADDRESS (2),8);
354                                                par_data (7 downto 0) <= conv_std_logic_vector(IP_ADDRESS (3),8);
355                                                state_init <= WRITE_REG;
356                                                next_state <= TIMEOUT;
357                                        when TIMEOUT =>
358                                                par_addr <=     W5300_RTR;
359                                                par_data <= X"07D0"; -- 0x07D0 = 200ms
360                                                state_init <= WRITE_REG;
361                                                next_state <= RETRY;
362                                        when RETRY =>
363                                                par_addr <=     W5300_RCR;
364                                                par_data <= X"0008";
365                                                state_init <= WRITE_REG;
366                                                next_state <= SI;
367
368                                        -- Socket Init
369                                        when SI =>
370                                                par_addr <= W5300_S0_MR + socket_cnt * W5300_S_INC;
371                                                par_data <= X"0101"; -- ALIGN, TCP
372                                                state_init <= WRITE_REG;
373                                                next_state <= SI1;
374                                        -- Sx Interrupt Mask
375                                        when SI1 =>
376                                                par_addr <= W5300_S0_IMR + socket_cnt * W5300_S_INC;
377                                                par_data <= X"000A"; -- TIMEOUT, DISCON
378                                                state_init <= WRITE_REG;
379                                                next_state <= SI2;
380                                        when SI2 =>
381                                                par_addr <= W5300_S0_PORTR + socket_cnt * W5300_S_INC;
382                                                par_data <= conv_std_logic_vector(FIRST_PORT + unsigned (socket_cnt), 16);
383                                                state_init <= WRITE_REG;
384                                                next_state <= SI3;
385                                        when SI3 =>
386                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
387                                                par_data <= X"0001"; -- OPEN
388                                                state_init <= WRITE_REG;
389                                                next_state <= SI4;
390                                        when SI4 =>
391                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
392                                                state_init <= READ_REG;
393                                                next_state <= SI5;
394                                        when SI5 =>
395                                                if (data_read (7 downto 0) = X"13") then -- is open?
396                                                        state_init <= SI6;
397                                                else
398                                                        state_init <= SI4;
399                                                end if;
400                                        when SI6 =>
401                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
402                                                par_data <= X"0002"; -- LISTEN
403                                                state_init <= WRITE_REG;
404                                                socket_cnt <= socket_cnt + 1;
405                                                if (socket_cnt = 7) then
406                                                  socket_cnt <= "000";
407                                                  next_state <= ESTABLISH; -- All Sockets open
408                                                else
409                                                  next_state <= SI; -- Next Socket
410                                                end if;
411                                  -- End Socket Init
412                                               
413                                        when ESTABLISH =>
414                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
415                                                state_init <= READ_REG;
416                                                next_state <= EST1;
417                                        when EST1 =>
418                                                led <= data_read (7 downto 0);
419                                                case data_read (7 downto 0) is
420                                                        when X"17" => -- established
421                if (socket_cnt = 7) then
422                  socket_cnt <= "000";
423                  busy <= '0';
424                  state_init <= MAIN;
425                else
426                  socket_cnt <= socket_cnt + 1;
427                  state_init <= ESTABLISH;
428                end if;
429                                                        when others =>
430                                                                state_init <= ESTABLISH;
431                                                end case;
432                                       
433                                        when CONFIG =>
434            led <= X"F0";
435                                          new_config <= '1';
436                                          if (config_started = '1') then
437                                            led <= X"0F";
438                                            new_config <= '0';
439                                            busy <= '0';
440                                            state_init <= MAIN;
441                                          end if;
442                                       
443          -- main "loop"
444                                        when MAIN =>
445                                          ps_do_phase_shift <= '0';
446                                          ps_reset <= '0';
447            if (trigger_stop = '1') then
448                                            s_trigger <= '0';
449                                          end if;
450            if (chk_recv_cntr = 1000) then
451              chk_recv_cntr <= 0;
452              state_read_data <= RD_1;
453              state_init <= READ_DATA;
454              busy <= '1';
455            else
456              busy <= '0';
457              data_valid_ack <= '0';
458              chk_recv_cntr <= chk_recv_cntr + 1; 
459                                                  if (data_valid = '1') then
460                                                    data_valid_ack <= '1';
461                local_write_length <= write_length;
462                local_ram_start_addr <= ram_start_addr;
463                local_ram_addr <= (others => '0');
464                local_write_header_flag <= write_header_flag;
465                local_write_end_flag <= write_end_flag;
466                local_fifo_channels <= fifo_channels;
467                                                          next_state <= MAIN;
468                                                          state_init <= WRITE_DATA;
469                                                          busy <= '1';
470              end if;
471                                                end if;
472
473                                        -- read data from socket 0 
474          when READ_DATA =>
475            case state_read_data is
476              when RD_1 =>
477                par_addr <= W5300_S0_RX_RSR;
478                state_init <= READ_REG;
479                next_state <= READ_DATA;
480                state_read_data <= RD_2;
481              when RD_2 =>
482                socket_rx_received (31 downto 16) <= data_read;
483                par_addr <= W5300_S0_RX_RSR + X"2";
484                state_init <= READ_REG;
485                next_state <= READ_DATA;
486                state_read_data <= RD_3;
487              when RD_3 =>
488                socket_rx_received (15 downto 0) <= data_read;
489                state_read_data <= RD_4;
490              when RD_4 =>
491                if (socket_rx_received (16 downto 0) > ('0' & X"000")) then
492                  rx_packets_cnt <= socket_rx_received (16 downto 1); -- socket_rx_received / 2
493                  state_read_data <= RD_5;
494                else
495                  busy <= '0';
496                  state_init <= MAIN;
497                end if;
498              when RD_5 =>
499                if (rx_packets_cnt > 0) then
500                  rx_packets_cnt <= rx_packets_cnt - '1';
501                  par_addr <= W5300_S0_RX_FIFOR;
502                  state_init <= READ_REG;
503                  next_state <= READ_DATA;
504                  state_read_data <= RD_6;
505                else
506                  state_read_data <= RD_END;
507--                  if (new_config_flag = '1') then
508--                    new_config_flag <= '0';
509--                    state_init <= CONFIG;
510--                  else
511--                    busy <= '0';
512--                    state_init <= MAIN;
513--                  end if;
514                end if;
515              when RD_6 =>
516                led <= data_read (15 downto 8);
517                -- read command
518                if (next_packet_data = '0') then
519                  case data_read (15 downto 8) is
520                    when CMD_TRIGGER =>
521                      trigger_stop <= '1';
522                      s_trigger <= '1';
523                      state_read_data <= RD_WAIT;
524                    when CMD_DWRITE_RUN =>
525                      dwrite_enable <= '1';
526                      state_read_data <= RD_WAIT;
527                    when CMD_DWRITE_STOP =>
528                      dwrite_enable <= '0';
529                      state_read_data <= RD_WAIT;
530                    when CMD_SCLK_ON =>
531                      sclk_enable <= '1';
532                      state_read_data <= RD_WAIT;
533                    when CMD_SCLK_OFF =>
534                      sclk_enable <= '0';
535                      state_read_data <= RD_WAIT;
536                    when CMD_DENABLE =>
537                      denable <= '1';
538                      state_read_data <= RD_WAIT;
539                    when CMD_DDISABLE =>
540                      denable <= '0';
541                      state_read_data <= RD_WAIT;
542                    when CMD_TRIGGER_C =>
543                      trigger_stop <= '0';
544                      s_trigger <= '1';
545                      state_read_data <= RD_WAIT;
546                    when CMD_TRIGGER_S =>
547                      trigger_stop <= '1';
548                      state_read_data <= RD_WAIT;
549                    -- phase shift commands here:
550                    when CMD_PS_DO =>
551                      ps_do_phase_shift <= '1';
552                      state_read_data <= RD_WAIT;
553                    when CMD_PS_DIRINC =>
554                      ps_direction <= '1';
555                      state_read_data <= RD_WAIT;
556                    when CMD_PS_RESET =>
557                      ps_reset <= '1';
558                      state_read_data <= RD_WAIT;
559                    when CMD_PS_DIRDEC =>
560                      ps_direction <= '0';
561                      state_read_data <= RD_WAIT;
562                    when CMD_WRITE =>
563                      next_packet_data <= '1';
564                      config_addr <= data_read (7 downto 0);
565                      state_read_data <= RD_5;
566                    when others =>
567                      state_read_data <= RD_5;
568                  end case;
569                -- read data
570                else
571                  if (config_busy = '0') then
572                    config_data <= data_read;
573                    config_wr_en <= '1';
574                    new_config_flag <= '1';
575                    next_packet_data <= '0';
576                    state_read_data <= RD_WAIT;
577                  end if;
578                end if;
579              when RD_WAIT =>
580                state_read_data <= RD_WAIT1;
581              when RD_WAIT1 =>
582                config_data <= (others => 'Z');
583                config_wr_en <= '0';
584                state_read_data <= RD_5;
585              when RD_END =>
586                par_addr <= W5300_S0_CR;
587                par_data <= X"0040"; -- RECV
588                state_init <= WRITE_REG;
589                if (new_config_flag = '1') then
590                  new_config_flag <= '0';
591                  next_state <= CONFIG;
592                else
593--                busy <= '0';
594                  next_state <= MAIN;
595                end if;
596
597            end case; -- state_data_read
598               
599   
600
601                                        when WRITE_DATA =>
602                                                case state_write is
603                                                  when WR_START =>
604                                                    if (local_write_header_flag = '1') then
605                                                      ram_addr <= local_ram_start_addr + 5; -- Address of Trigger-ID (15 downto 0) ????
606                                                    end if;
607                                                    state_write <= WR_WAIT1;
608                                                  when WR_WAIT1 =>
609                                                    state_write <= WR_LENGTH;
610                                                        when WR_LENGTH =>
611                                                          if (local_write_header_flag = '1') then
612                                                            local_socket_nr <= ram_data (2 downto 0);
613                                                          end if;
614                                                                next_state_tmp <= next_state;
615                                                                write_length_bytes <= local_write_length (15 downto 0) & '0'; -- shift left (*2)
616                                                                data_cnt <= 0;
617                                                                state_write <= WR_01;
618                                                        -- Check FIFO Size
619                                                        when WR_01 =>
620                                                                par_addr <= W5300_S0_TX_FSR + local_socket_nr * W5300_S_INC;
621                                                                state_init <= READ_REG;
622                                                                next_state <= WRITE_DATA;
623                                                                state_write <= WR_02;
624                                                        when WR_02 =>
625                                                                socket_tx_free (31 downto 16) <= data_read;
626                                                                par_addr <= W5300_S0_TX_FSR + (local_socket_nr * W5300_S_INC) + X"2";
627                                                                state_init <= READ_REG;
628                                                                next_state <= WRITE_DATA;
629                                                                state_write <= WR_03;
630                                                        when WR_03 =>
631                                                                socket_tx_free (15 downto 0) <= data_read;
632                                                                state_write <= WR_04;
633                                                        when WR_04 =>
634                                                                if (socket_tx_free (16 downto 0) < write_length_bytes) then
635                                                                        state_write <= WR_01;
636                                                                else
637                                                                  if (local_write_header_flag = '1') then
638                                                                          state_write <= WR_FIFO;
639                                                                        else
640                                                                          state_write <= WR_ADC;
641                                                                        end if;
642                                                                end if;
643                                                       
644                                                        -- Fill FIFO
645
646                                                        -- Write Header
647                                                        when WR_FIFO =>
648                ram_addr <= local_ram_start_addr + local_ram_addr;
649                                                          state_write <= WR_FIFO1;
650                                                        when WR_FIFO1 =>
651                                                                data_cnt <= data_cnt + 1;
652                                                                if (data_cnt < PACKAGE_HEADER_LENGTH) then --???
653                                                                  local_ram_addr <= local_ram_addr + 1;
654                                                                  if (data_cnt = 2 or data_cnt = 5 or data_cnt = 8 ) then -- skip empty words
655                                                                    local_ram_addr <= local_ram_addr + 2;
656                                                                  end if;
657                                                                  if (data_cnt = 9) then -- skip empty words
658                                                                    local_ram_addr <= local_ram_addr + 4;
659                                                                  end if; 
660                                                                        par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
661                                                                        ram_access <= '1';
662                                                                        state_init <= WRITE_REG;
663                                                                        next_state <= WRITE_DATA;
664                                                                        state_write <= WR_FIFO;
665                                                                else
666                                                                        state_write <= WR_ADC;
667                                                                end if;
668                                                        -- End Write Header
669                                                       
670                                                        -- Write ADC-Data
671                                                        ---- Start...
672                                                        when WR_ADC =>
673                                                          adc_data_addr <= local_ram_start_addr + local_ram_addr;
674                                                          drs_cnt <= 0;
675                                                          channel_cnt <= 1;
676                data_cnt <= 0;
677                                                          roi_max <= (others => '0');
678                                                          data_end <= 3;
679                                                          state_write <= WR_ADC1;
680
681                                                        ---- Write Channel
682                                                        when WR_ADC1 =>
683                                                          -- read ROI and set end of Channel-Data
684                                                          if (data_cnt = 3) then
685                                                            data_end <= conv_integer (ram_data) + 3;
686                                                            if (ram_data > roi_max) then
687                                                              roi_max <= ram_data (10 downto 0);
688                                                            end if;
689                                                          end if;
690                                                          ram_addr <= adc_data_addr + drs_cnt + (data_cnt * 4);
691                state_write <= WR_ADC2;
692                                                        when WR_ADC2 =>
693                if (data_cnt < data_end) then
694                  par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
695                  ram_access <= '1';
696                  state_init <= WRITE_REG;
697                  next_state <= WRITE_DATA;
698                  data_cnt <= data_cnt + 1;
699                  state_write <= WR_ADC1;
700                else
701                  -- Next DRS
702                  if (drs_cnt < 3) then
703                    drs_cnt <= drs_cnt + 1;
704                    data_cnt <= 0;
705                    data_end <= 3;
706                    state_write <= WR_ADC1;
707                  else
708                    -- Next Channel
709                    if (channel_cnt < local_fifo_channels) then
710                      channel_cnt <= channel_cnt + 1;
711                      roi_max <= (others => '0');
712                      drs_cnt <= 0;
713                      data_cnt <= 0;
714                      data_end <= 3;
715                      adc_data_addr <= adc_data_addr + ((conv_integer(roi_max) + 3) * 4);
716                      state_write <= WR_ADC1;
717                    else
718                      -- Ready
719                      if (local_write_end_flag = '1') then
720                        state_write <= WR_ENDFLAG;
721                      else
722                        state_write <= WR_05;
723                      end if;
724                    end if;
725                  end if;   
726                end if;
727                                                        -- End Write ADC-Data
728
729              -- Write End Package Flag
730              when WR_ENDFLAG =>
731                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + 3) * 4);
732                state_write <= WR_ENDFLAG1;
733              when WR_ENDFLAG1 =>
734                par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
735                ram_access <= '1';
736                state_init <= WRITE_REG;
737                next_state <= WRITE_DATA;
738                state_write <= WR_ENDFLAG2;
739              when WR_ENDFLAG2 =>
740                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + 3) * 4) + 1;
741                state_write <= WR_ENDFLAG3;
742              when WR_ENDFLAG3 =>
743                state_init <= WRITE_REG;
744                next_state <= WRITE_DATA;
745                state_write <= WR_05;
746             
747              -- End Write End Package Flag
748
749              --Send FIFO
750                                                        when WR_05 =>
751                                                          ram_access <= '0';
752                                                                par_addr <= W5300_S0_TX_WRSR + local_socket_nr * W5300_S_INC;
753                                                                par_data <= (0 => write_length_bytes (16), others => '0');
754                                                                state_init <= WRITE_REG;
755                                                                state_write <= WR_06;
756                                                        when WR_06 =>
757                                                                par_addr <= W5300_S0_TX_WRSR + (local_socket_nr * W5300_S_INC) + X"2";
758                                                                par_data <= write_length_bytes (15 downto 0);
759                                                                state_init <= WRITE_REG;
760                                                                state_write <= WR_07;
761                                                        when WR_07 =>
762                                                                par_addr <= W5300_S0_CR + local_socket_nr * W5300_S_INC;
763                                                                par_data <= X"0020"; -- Send
764                                                                state_init <= WRITE_REG;
765                                                                state_write <= WR_08;
766                                                        when others =>
767--                                                      busy <= '0';
768                                                                state_init <= next_state_tmp;
769                                                                state_write <= WR_START;
770                                                end case;
771                                                -- End WRITE_DATA
772                                               
773                                        when READ_REG =>
774                                                case count is
775                                                        when "000" =>
776                                                                cs <= '0';
777                                                                rd <= '0';
778                                                                wr <= '1';
779                                                                data <= (others => 'Z'); -- !!!!!!!!!!
780                                                                count <= "001";
781                                                                addr <= par_addr;
782                                                        when "001" =>
783                                                                count <= "010";
784                                                        when "010" =>
785                                                                count <= "100";
786                                                        when "100" =>
787                                                                data_read <= data;
788                                                                count <= "110";
789                                                        when "110" =>
790                                                                count <= "111";
791                                                        when "111" =>
792                                                                cs <= '1';
793                                                                rd <= '1';
794                                                                count <= "000";
795                                                                state_init <= next_state;
796                                                        when others =>
797                                                                null;
798                                                end case;
799                                       
800                                        when WRITE_REG =>
801                                                case count is
802                                                        when "000" =>
803                                                                cs <= '0';
804                                                                wr <= '0';
805                                                                rd <= '1';
806                                                                addr <= par_addr;
807                                                                if (ram_access = '1') then
808                                                                        data <= ram_data;
809                                                                else
810                                                                        data <= par_data;
811                                                                end if;
812                                                                count <= "100";
813                                                        when "100" =>
814                                                                count <= "101";
815                                                        when "101" =>
816                                                                count <= "110";
817                                                        when "110" =>
818                                                                cs <= '1';
819                                                                wr <= '1';
820                                                                state_init <= next_state;
821                                                                count <= "000";
822                                                        when others =>
823                                                                null;
824                                                end case;
825                                       
826                                        when others =>
827                                                null;
828                                end case;
829                        end if; -- int_flag = '0'
830
831                end if; -- rising_edge (clk)
832
833        end process w5300_init_proc;
834
835end Behavioral;
836
Note: See TracBrowser for help on using the repository browser.