net/bnx2x: replace macro with static function

[dpdk.git] / drivers / net / virtio / virtio_rxtx.c

diff --git a/drivers/net/virtio/virtio_rxtx.c b/drivers/net/virtio/virtio_rxtx.c
index 675dc43..b4c4aa4 100644 (file)
--- a/drivers/net/virtio/virtio_rxtx.c
+++ b/drivers/net/virtio/virtio_rxtx.c
@@ -209,10 +209,53 @@ virtqueue_enqueue_recv_refill(struct virtqueue *vq, struct rte_mbuf *cookie)
        return 0;
 }
 
+/* When doing TSO, the IP length is not included in the pseudo header
+ * checksum of the packet given to the PMD, but for virtio it is
+ * expected.
+ */
+static void
+virtio_tso_fix_cksum(struct rte_mbuf *m)
+{
+       /* common case: header is not fragmented */
+       if (likely(rte_pktmbuf_data_len(m) >= m->l2_len + m->l3_len +
+                       m->l4_len)) {
+               struct ipv4_hdr *iph;
+               struct ipv6_hdr *ip6h;
+               struct tcp_hdr *th;
+               uint16_t prev_cksum, new_cksum, ip_len, ip_paylen;
+               uint32_t tmp;
+
+               iph = rte_pktmbuf_mtod_offset(m, struct ipv4_hdr *, m->l2_len);
+               th = RTE_PTR_ADD(iph, m->l3_len);
+               if ((iph->version_ihl >> 4) == 4) {
+                       iph->hdr_checksum = 0;
+                       iph->hdr_checksum = rte_ipv4_cksum(iph);
+                       ip_len = iph->total_length;
+                       ip_paylen = rte_cpu_to_be_16(rte_be_to_cpu_16(ip_len) -
+                               m->l3_len);
+               } else {
+                       ip6h = (struct ipv6_hdr *)iph;
+                       ip_paylen = ip6h->payload_len;
+               }
+
+               /* calculate the new phdr checksum not including ip_paylen */
+               prev_cksum = th->cksum;
+               tmp = prev_cksum;
+               tmp += ip_paylen;
+               tmp = (tmp & 0xffff) + (tmp >> 16);
+               new_cksum = tmp;
+
+               /* replace it in the packet */
+               th->cksum = new_cksum;
+       }
+}
+
 static inline int
 tx_offload_enabled(struct virtio_hw *hw)
 {
-       return vtpci_with_feature(hw, VIRTIO_NET_F_CSUM);
+       return vtpci_with_feature(hw, VIRTIO_NET_F_CSUM) ||
+               vtpci_with_feature(hw, VIRTIO_NET_F_HOST_TSO4) ||
+               vtpci_with_feature(hw, VIRTIO_NET_F_HOST_TSO6);
 }
 
 static inline void
@@ -274,8 +317,11 @@ virtqueue_enqueue_xmit(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
                idx = start_dp[idx].next;
        }
 
+       /* Checksum Offload / TSO */
        if (offload) {
-               /* Checksum Offload */
+               if (cookie->ol_flags & PKT_TX_TCP_SEG)
+                       cookie->ol_flags |= PKT_TX_TCP_CKSUM;
+
                switch (cookie->ol_flags & PKT_TX_L4_MASK) {
                case PKT_TX_UDP_CKSUM:
                        hdr->csum_start = cookie->l2_len + cookie->l3_len;
@@ -297,9 +343,22 @@ virtqueue_enqueue_xmit(struct virtnet_tx *txvq, struct rte_mbuf *cookie,
                        break;
                }
 
-               hdr->gso_type = 0;
-               hdr->gso_size = 0;
-               hdr->hdr_len = 0;
+               /* TCP Segmentation Offload */
+               if (cookie->ol_flags & PKT_TX_TCP_SEG) {
+                       virtio_tso_fix_cksum(cookie);
+                       hdr->gso_type = (cookie->ol_flags & PKT_TX_IPV6) ?
+                               VIRTIO_NET_HDR_GSO_TCPV6 :
+                               VIRTIO_NET_HDR_GSO_TCPV4;
+                       hdr->gso_size = cookie->tso_segsz;
+                       hdr->hdr_len =
+                               cookie->l2_len +
+                               cookie->l3_len +
+                               cookie->l4_len;
+               } else {
+                       hdr->gso_type = 0;
+                       hdr->gso_size = 0;
+                       hdr->hdr_len = 0;
+               }
        }
 
        do {
@@ -715,13 +774,36 @@ virtio_rx_offload(struct rte_mbuf *m, struct virtio_net_hdr *hdr)
                m->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
        }
 
+       /* GSO request, save required information in mbuf */
+       if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
+               /* Check unsupported modes */
+               if ((hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN) ||
+                   (hdr->gso_size == 0)) {
+                       return -EINVAL;
+               }
+
+               /* Update mss lengthes in mbuf */
+               m->tso_segsz = hdr->gso_size;
+               switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
+                       case VIRTIO_NET_HDR_GSO_TCPV4:
+                       case VIRTIO_NET_HDR_GSO_TCPV6:
+                               m->ol_flags |= PKT_RX_LRO | \
+                                       PKT_RX_L4_CKSUM_NONE;
+                               break;
+                       default:
+                               return -EINVAL;
+               }
+       }
+
        return 0;
 }
 
 static inline int
 rx_offload_enabled(struct virtio_hw *hw)
 {
-       return vtpci_with_feature(hw, VIRTIO_NET_F_GUEST_CSUM);
+       return vtpci_with_feature(hw, VIRTIO_NET_F_GUEST_CSUM) ||
+               vtpci_with_feature(hw, VIRTIO_NET_F_GUEST_TSO4) ||
+               vtpci_with_feature(hw, VIRTIO_NET_F_GUEST_TSO6);
 }
 
 #define VIRTIO_MBUF_BURST_SZ 64