mips_sys

@@ -30,24 +30,24 @@ struct arp_table

  */

 static void arp_send_request(unsigned char ip[4])

 {

-  struct arp_packet_pad arp_request;

+  struct arp_packet arp_request;

   // build ARP request

-  arp_request.p.arp_hdr.hw_type = htons(0x0001); // ethernet

-  arp_request.p.arp_hdr.proto_type = htons(0x0800); // IP

-  arp_request.p.arp_hdr.hw_len = 0x06; // length of a MAC address

-  arp_request.p.arp_hdr.proto_len = 0x04; // length of an IP address

-  arp_request.p.arp_hdr.op = htons(0x0001); // ARP request

-  mac_cpy(arp_request.p.arp_hdr.src_mac, config_mac.mac); // own MAC

-  ip_cpy(arp_request.p.arp_hdr.src_ip, config_ip.ip); // own IP

-  mac_cpy(arp_request.p.arp_hdr.dest_mac,

+  arp_request.arp_hdr.hw_type = htons(0x0001); // ethernet

+  arp_request.arp_hdr.proto_type = htons(0x0800); // IP

+  arp_request.arp_hdr.hw_len = 0x06; // length of a MAC address

+  arp_request.arp_hdr.proto_len = 0x04; // length of an IP address

+  arp_request.arp_hdr.op = htons(0x0001); // ARP request

+  mac_cpy(arp_request.arp_hdr.src_mac, config_mac.mac); // own MAC

+  ip_cpy(arp_request.arp_hdr.src_ip, config_ip.ip); // own IP

+  mac_cpy(arp_request.arp_hdr.dest_mac,

           "\xFF\xFF\xFF\xFF\xFF\xFF"); // broadcast MAC

-  ip_cpy(arp_request.p.arp_hdr.dest_ip, ip); // requested IP

+  ip_cpy(arp_request.arp_hdr.dest_ip, ip); // requested IP

   // send ARP request

-  mac_cpy(arp_request.p.eth_hdr.dest, arp_request.p.arp_hdr.dest_mac);

-  arp_request.p.eth_hdr.type = htons(0x0806); // ethernet packet type: ARP

-  ethernet_send(&arp_request.p, sizeof(arp_request.p));

+  mac_cpy(arp_request.eth_hdr.dest, arp_request.arp_hdr.dest_mac);

+  arp_request.eth_hdr.type = htons(0x0806); // ethernet packet type: ARP

+  ethernet_send(&arp_request, sizeof(arp_request));

 }

 /// initialize

@@ -116,26 +116,26 @@ void arp_recv(void *ptr, unsigned int sz)

   // ARP request for own IP address

   if (arp_pack->arp_hdr.op == htons(0x0001) && // ARP request

       ip_eq(arp_pack->arp_hdr.dest_ip, config_ip.ip)) { // own IP address

-    struct arp_packet_pad arp_reply;

+    struct arp_packet arp_reply;

     // build ARP reply

-    arp_reply.p.arp_hdr.hw_type = htons(0x0001); // ethernet

-    arp_reply.p.arp_hdr.proto_type = htons(0x0800); // IP

-    arp_reply.p.arp_hdr.hw_len = 0x06; // length of a MAC address

-    arp_reply.p.arp_hdr.proto_len = 0x04; // length of an IP address

-    arp_reply.p.arp_hdr.op = htons(0x0002); // ARP reply

-    mac_cpy(arp_reply.p.arp_hdr.src_mac, config_mac.mac); // own MAC

-    ip_cpy(arp_reply.p.arp_hdr.src_ip, config_ip.ip); // own IP

-    mac_cpy(arp_reply.p.arp_hdr.dest_mac,

+    arp_reply.arp_hdr.hw_type = htons(0x0001); // ethernet

+    arp_reply.arp_hdr.proto_type = htons(0x0800); // IP

+    arp_reply.arp_hdr.hw_len = 0x06; // length of a MAC address

+    arp_reply.arp_hdr.proto_len = 0x04; // length of an IP address

+    arp_reply.arp_hdr.op = htons(0x0002); // ARP reply

+    mac_cpy(arp_reply.arp_hdr.src_mac, config_mac.mac); // own MAC

+    ip_cpy(arp_reply.arp_hdr.src_ip, config_ip.ip); // own IP

+    mac_cpy(arp_reply.arp_hdr.dest_mac,

             arp_pack->arp_hdr.src_mac); // requestor's MAC

-    ip_cpy(arp_reply.p.arp_hdr.dest_ip,

+    ip_cpy(arp_reply.arp_hdr.dest_ip,

            arp_pack->arp_hdr.src_ip); // requestor's IP

     // send ARP reply

-    mac_cpy(arp_reply.p.eth_hdr.dest,

-            arp_reply.p.arp_hdr.dest_mac); // ethernet destination address

-    arp_reply.p.eth_hdr.type = htons(0x0806); // ethernet packet type: ARP

-    ethernet_send(&arp_reply.p, sizeof(arp_reply.p));

+    mac_cpy(arp_reply.eth_hdr.dest,

+            arp_reply.arp_hdr.dest_mac); // ethernet destination address

+    arp_reply.eth_hdr.type = htons(0x0806); // ethernet packet type: ARP

+    ethernet_send(&arp_reply, sizeof(arp_reply));

     return;

   }

@@ -24,9 +24,6 @@ struct arp_packet

   struct arp_header arp_hdr;

 } __attribute__((packed));

-/// ARP packet with padding

-ETHERNET_PAD(arp_packet);

-

 /// initialize

 void arp_init(void);

@@ -116,7 +116,7 @@ int eth_rx(void **pptr, unsigned int *psz)

  */

 void eth_tx(const void *ptr, unsigned int sz)

 {

-  while(sz < 60 || sz & 3) /* pad with zeros */

+  while(sz & 3) /* pad with zeros */

     ((unsigned char *)ptr)[sz++] = 0;

   eth_ptr[8] = (unsigned int)ptr; /* start */

   eth_ptr[9] = (unsigned int)ptr + sz; /* end */

@@ -46,7 +46,7 @@ void ethernet_recv(void *ptr, unsigned int sz)

  * @param[in] ptr pointer to data of packet

  * @param[in] sz size of packet

  *

- * ptr must point to a ethernet_packet of sufficient size (ethernet padding)

+ * ptr must point to a ethernet_packet

  * with eth_hdr.dest and eth_hdr.type already initialized

  */

 void ethernet_send(void *ptr, unsigned int sz)

@@ -1,19 +1,6 @@

 #ifndef ETHERNET_H

 #define ETHERNET_H

-/** padding at end of packet

-    to reach next size divisible by 4 and at least 60 bytes */

-#define ETHERNET_PADDING_SIZE(packet) \

-        (sizeof(struct packet) >= 60 ? 0 : 60 - sizeof(struct packet))

-#define ETHERNET_PADDING(packet) \

-        unsigned char padding[ETHERNET_PADDING_SIZE(packet)]

-#define ETHERNET_PAD(packet) \

-        struct packet ## _pad \

-        { \

-          struct packet p; \

-          ETHERNET_PADDING(packet); \

-        } __attribute__((packed))

-

 /// header of ethernet packet

 struct ethernet_header

 {

@@ -28,9 +15,6 @@ struct ethernet_packet

   struct ethernet_header eth_hdr;

 } __attribute__((packed));

-/// ethernet packet with padding

-ETHERNET_PAD(ethernet_packet);

-

 /**

  * @brief process a received ethernet packet

  * @param[in] ptr pointer to data of packet

@@ -43,7 +27,7 @@ void ethernet_recv(void *ptr, unsigned int sz);

  * @param[in] ptr pointer to data of packet

  * @param[in] sz size of packet

  *

- * ptr must point to a ethernet_packet of sufficient size (ethernet padding)

+ * ptr must point to a ethernet_packet

  * with eth_hdr.dest and eth_hdr.type already initialized

  */

 void ethernet_send(void *ptr, unsigned int sz);

@@ -10,7 +10,7 @@

  * @param[in] ptr pointer to data of packet

  * @param[in] sz size of packet

  *

- * ptr must point to a icmp_packet of sufficient size (ethernet padding)

+ * ptr must point to a icmp_packet

  * with icmp_hdr.type, icmp_hdr.code and ip_hdr.sest already initialized

  */

 static void icmp_send(void *ptr, unsigned int sz)

@@ -20,9 +20,6 @@ struct icmp_packet

   struct icmp_header icmp_hdr;

 } __attribute__((packed));

-/// ICMP packet with padding

-ETHERNET_PAD(icmp_packet);

-

 // header of ICMP echo request/reply packet

 struct icmp_echo_header

 {

@@ -39,9 +36,6 @@ struct icmp_echo_packet

   struct icmp_echo_header echo_hdr;

 } __attribute__((packed));

-/// ICMP echo request/reply packet with padding

-ETHERNET_PAD(icmp_echo_packet);

-

 /**

  * @brief process a received ICMP packet

  * @param[in] ptr pointer to data of packet

@@ -17,7 +17,6 @@

  *  - used if MAC is unknown when packet shall be transmitted

  *  - packet is sent when MAC becomes known

  *  - some buffers with different length (packets have different lengths)

- *  - all buffers must be larger than min ethernet frame size (eth padding)

  */

 //@{

 unsigned int ip_buffer0[20];

@@ -185,7 +184,7 @@ void ip_recv(void *ptr, unsigned int sz)

  * @param[in] ptr pointer to data of packet

  * @param[in] sz size of packet

  *

- * ptr must point to a ip_packet of sufficient size (ethernet padding)

+ * ptr must point to a ip_packet

  * with ip_hdr.proto and ip_hdr.dest already initialized

  */

 void ip_send(void *ptr, unsigned int sz)

@@ -25,9 +25,6 @@ struct ip_packet

   struct ip_header ip_hdr;

 } __attribute__((packed));

-/// IP packet with padding

-ETHERNET_PAD(ip_packet);

-

 /// initialize

 void ip_init(void);

@@ -46,7 +43,7 @@ void ip_recv(void *ptr, unsigned int sz);

  * @param[in] ptr pointer to data of packet

  * @param[in] sz size of packet

  *

- * ptr must point to a ip_packet of sufficient size (ethernet padding)

+ * ptr must point to a ip_packet

  * with ip_hdr.proto and ip_hdr.dest already initialized

  */

 void ip_send(void *ptr, unsigned int sz);

@@ -29,7 +29,7 @@ void udp_recv(void *ptr, unsigned int sz)

  * @param[in] ptr pointer to data of packet

  * @param[in] sz size of packet

  *

- * ptr must point to a udp_packet of sufficient size (ethernet padding)

+ * ptr must point to a udp_packet

  * with ip_hdr.proto and udp_hdr.src_port, udp_hdr.dest_port, ip_hdr.dest

  * already initialized

  */

@@ -21,9 +21,6 @@ struct udp_packet

   struct udp_header udp_hdr;

 } __attribute__((packed));

-/// UDP packet with padding

-ETHERNET_PAD(udp_packet);

-

 /// tick procedure - call every 200ms

 void udp_tick200(void);

@@ -39,7 +36,7 @@ void udp_recv(void *ptr, unsigned int sz);

  * @param[in] ptr pointer to data of packet

  * @param[in] sz size of packet

  *

- * ptr must point to a udp_packet of sufficient size (ethernet padding)

+ * ptr must point to a udp_packet

  * with ip_hdr.proto and udp_hdr.src_port, udp_hdr.dest_port, ip_hdr.dest

  * already initialized

  */

@@ -19,9 +19,11 @@ END ENTITY e_io_eth_txframe;

 ARCHITECTURE a_io_eth_txframe OF e_io_eth_txframe IS

-    TYPE t_state IS (st_idle, st_sync, st_start, st_data, st_crc, st_gap);

+    TYPE t_state IS (st_idle, st_sync, st_start, st_data,

+                     st_pad, st_crc, st_gap);

-    SUBTYPE t_data_cnt IS natural RANGE 0 TO 255;

+    SUBTYPE t_data_cnt IS natural RANGE 0 TO 3;

+    SUBTYPE t_byte_cnt IS natural RANGE 0 TO 255;

     SIGNAL r_state:     t_state                       := st_idle;

     SIGNAL n_state:     t_state;

@@ -29,6 +31,8 @@ ARCHITECTURE a_io_eth_txframe OF e_io_eth_txframe IS

     SIGNAL n_data_cnt:  t_data_cnt;

     SIGNAL r_data:      std_logic_vector(31 DOWNTO 0) := (OTHERS => '0');

     SIGNAL n_data:      std_logic_vector(31 DOWNTO 0);

+    SIGNAL r_byte_cnt:  t_byte_cnt                    := 0;

+    SIGNAL n_byte_cnt:  t_byte_cnt;

     SIGNAL r_crc_start: std_logic                     := '0';

     SIGNAL n_crc_start: std_logic;

@@ -60,7 +64,7 @@ BEGIN

             o_crc   => s_crc_crc

         );

-    p_next: PROCESS(r_state, r_data_cnt, r_data, r_crc_start,

+    p_next: PROCESS(r_state, r_data_cnt, r_data, r_byte_cnt, r_crc_start,

                     i_if_data_ack,

                     i_frame_en, i_frame_data, i_frame_data_en,

                     s_crc_crc)

@@ -69,6 +73,7 @@ BEGIN

         n_state          <= r_state;

         n_data_cnt       <= r_data_cnt;

         n_data           <= r_data;

+        n_byte_cnt       <= r_byte_cnt;

         n_crc_start      <= '0';

         o_if_data        <= X"00";

         o_if_data_en     <= '0';

@@ -81,14 +86,14 @@ BEGIN

             WHEN st_idle =>

                 IF i_frame_en = '1' THEN

                     n_state    <= st_sync;

-                    n_data_cnt <= 7;

+                    n_byte_cnt <= 0;

                 END IF;

             WHEN st_sync =>

                 IF i_if_data_ack = '1' THEN

-                    IF r_data_cnt = 1 THEN

+                    IF r_byte_cnt = 6 THEN

                         n_state <= st_start;

                     ELSE

-                        n_data_cnt <= r_data_cnt - 1;

+                        n_byte_cnt <= r_byte_cnt + 1;

                     END IF;

                 END IF;

                 o_if_data    <= X"55";

@@ -97,62 +102,84 @@ BEGIN

                 IF i_if_data_ack = '1' THEN

                     IF i_frame_data_en = '1' THEN

                         n_state          <= st_data;

-                        n_data_cnt       <= 4;

+                        n_data_cnt       <= 0;

                         n_data           <= i_frame_data;

+                        n_byte_cnt       <= 0;

                         n_crc_start      <= '1';

                         o_frame_data_ack <= '1';

                     ELSE

                         n_state    <= st_gap;

-                        n_data_cnt <= 12 * 8 * 2; -- 12 octets, x2 because of clk

+                        n_byte_cnt <= 0;

                     END IF;

                 END IF;

                 o_if_data    <= X"D5";

                 o_if_data_en <= '1';

             WHEN st_data =>

                 IF i_if_data_ack = '1' THEN

-                    IF r_data_cnt = 1 THEN

+                    IF r_data_cnt = 3 THEN

                         IF i_frame_data_en = '1' THEN

                             n_state          <= st_data;

-                            n_data_cnt       <= 4;

+                            n_data_cnt       <= 0;

                             n_data           <= i_frame_data;

                             o_frame_data_ack <= '1';

                         ELSE

+                            IF r_byte_cnt = 59 THEN

                                 n_state    <= st_crc;

-                            n_data_cnt       <= 4;

+                                n_data_cnt <= 0;

+                            ELSE

+                                n_state    <= st_pad;

+                            END IF;

                         END IF;

                     ELSE

-                        n_data_cnt          <= r_data_cnt - 1;

+                        n_data_cnt          <= r_data_cnt + 1;

                         n_data(23 DOWNTO 0) <= r_data(31 DOWNTO 8);

                     END IF;

+                    IF r_byte_cnt /= 59 THEN

+                        n_byte_cnt <= r_byte_cnt + 1;

+                    END IF;

                     s_crc_en    <= '1';

                     s_crc_start <= r_crc_start;

                     s_crc_data  <= r_data(7 DOWNTO 0);

                 END IF;

                 o_if_data    <= r_data(7 DOWNTO 0);

                 o_if_data_en <= '1';

+            WHEN st_pad =>

+                IF i_if_data_ack = '1' THEN

+                    IF r_byte_cnt = 59 THEN

+                        n_state    <= st_crc;

+                        n_data_cnt <= 0;

+                    ELSE

+                        n_byte_cnt <= r_byte_cnt + 1;

+                    END IF;

+                    s_crc_en   <= '1';

+                    s_crc_data <= (OTHERS => '0');

+                END IF;

+                o_if_data    <= (OTHERS => '0');

+                o_if_data_en <= '1';

             WHEN st_crc =>

-                IF r_data_cnt = 4 THEN

+                IF r_data_cnt = 0 THEN

                     v_data := s_crc_crc; -- get CRC value on first CRC byte

                 ELSE

                     v_data := r_data;

                 END IF;

                 IF i_if_data_ack = '1' THEN

-                    IF r_data_cnt = 1 THEN

+                    IF r_data_cnt = 3 THEN

                         n_state    <= st_gap;

-                        n_data_cnt <= 12 * 8 * 2; -- 12 octets, x2 because of clk

+                        n_byte_cnt <= 0;

                     ELSE

-                        n_data_cnt          <= r_data_cnt - 1;

+                        n_data_cnt          <= r_data_cnt + 1;

                         n_data(23 DOWNTO 0) <= v_data(31 DOWNTO 8);

                     END IF;

                 END IF;

                 o_if_data    <= v_data(7 DOWNTO 0);

                 o_if_data_en <= '1';

             WHEN st_gap =>

-                IF r_data_cnt = 1 THEN

+                 -- 12 octets, *2 because of clk, plus async FIFO len

+                IF r_byte_cnt = 12 * 8 * 2 + 16 THEN

                     n_state      <= st_idle;

                     o_frame_done <= '1';

                 ELSE

-                    n_data_cnt <= r_data_cnt - 1;

+                    n_byte_cnt <= r_byte_cnt + 1;

                 END IF;

             WHEN OTHERS => NULL;

         END CASE;

@@ -164,11 +191,13 @@ BEGIN

             r_state     <= st_idle;

             r_data_cnt  <= 0;

             r_data      <= (OTHERS => '0');

+            r_byte_cnt  <= 0;

             r_crc_start <= '0';

         ELSIF rising_edge(clk) THEN

             r_state     <= n_state;

             r_data_cnt  <= n_data_cnt;

             r_data      <= n_data;

+            r_byte_cnt  <= n_byte_cnt;

             r_crc_start <= n_crc_start;

         END IF;

     END PROCESS p_sync;