diff --git a/lib/dp-packet.h b/lib/dp-packet.h
index bddaa2b5d..3ba5b0665 100644
--- a/lib/dp-packet.h
+++ b/lib/dp-packet.h
@@ -62,14 +62,14 @@ enum dp_packet_offload_mask {
     /* Is the 'flow_mark' valid? */
     DEF_OL_FLAG(DP_PACKET_OL_FLOW_MARK, RTE_MBUF_F_RX_FDIR_ID, 0x2),
     /* Bad L4 checksum in the packet. */
-    DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CKSUM_BAD, RTE_MBUF_F_RX_L4_CKSUM_BAD, 0x4),
+    DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CSUM_BAD, RTE_MBUF_F_RX_L4_CKSUM_BAD, 0x4),
     /* Bad IP checksum in the packet. */
-    DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CKSUM_BAD, RTE_MBUF_F_RX_IP_CKSUM_BAD, 0x8),
+    DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CSUM_BAD, RTE_MBUF_F_RX_IP_CKSUM_BAD, 0x8),
     /* Valid L4 checksum in the packet. */
-    DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CKSUM_GOOD, RTE_MBUF_F_RX_L4_CKSUM_GOOD,
+    DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CSUM_GOOD, RTE_MBUF_F_RX_L4_CKSUM_GOOD,
                 0x10),
     /* Valid IP checksum in the packet. */
-    DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CKSUM_GOOD, RTE_MBUF_F_RX_IP_CKSUM_GOOD,
+    DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CSUM_GOOD, RTE_MBUF_F_RX_IP_CKSUM_GOOD,
                 0x20),
     /* TCP Segmentation Offload. */
     DEF_OL_FLAG(DP_PACKET_OL_TX_TCP_SEG, RTE_MBUF_F_TX_TCP_SEG, 0x40),
@@ -78,34 +78,34 @@ enum dp_packet_offload_mask {
     /* Offloaded packet is IPv6. */
     DEF_OL_FLAG(DP_PACKET_OL_TX_IPV6, RTE_MBUF_F_TX_IPV6, 0x100),
     /* Offload TCP checksum. */
-    DEF_OL_FLAG(DP_PACKET_OL_TX_TCP_CKSUM, RTE_MBUF_F_TX_TCP_CKSUM, 0x200),
+    DEF_OL_FLAG(DP_PACKET_OL_TX_TCP_CSUM, RTE_MBUF_F_TX_TCP_CKSUM, 0x200),
     /* Offload UDP checksum. */
-    DEF_OL_FLAG(DP_PACKET_OL_TX_UDP_CKSUM, RTE_MBUF_F_TX_UDP_CKSUM, 0x400),
+    DEF_OL_FLAG(DP_PACKET_OL_TX_UDP_CSUM, RTE_MBUF_F_TX_UDP_CKSUM, 0x400),
     /* Offload SCTP checksum. */
-    DEF_OL_FLAG(DP_PACKET_OL_TX_SCTP_CKSUM, RTE_MBUF_F_TX_SCTP_CKSUM, 0x800),
+    DEF_OL_FLAG(DP_PACKET_OL_TX_SCTP_CSUM, RTE_MBUF_F_TX_SCTP_CKSUM, 0x800),
     /* Adding new field requires adding to DP_PACKET_OL_SUPPORTED_MASK. */
 };
 
 #define DP_PACKET_OL_SUPPORTED_MASK (DP_PACKET_OL_RSS_HASH         | \
                                      DP_PACKET_OL_FLOW_MARK        | \
-                                     DP_PACKET_OL_RX_L4_CKSUM_BAD  | \
-                                     DP_PACKET_OL_RX_IP_CKSUM_BAD  | \
-                                     DP_PACKET_OL_RX_L4_CKSUM_GOOD | \
-                                     DP_PACKET_OL_RX_IP_CKSUM_GOOD | \
+                                     DP_PACKET_OL_RX_L4_CSUM_BAD  | \
+                                     DP_PACKET_OL_RX_IP_CSUM_BAD  | \
+                                     DP_PACKET_OL_RX_L4_CSUM_GOOD | \
+                                     DP_PACKET_OL_RX_IP_CSUM_GOOD | \
                                      DP_PACKET_OL_TX_TCP_SEG       | \
                                      DP_PACKET_OL_TX_IPV4          | \
                                      DP_PACKET_OL_TX_IPV6          | \
-                                     DP_PACKET_OL_TX_TCP_CKSUM     | \
-                                     DP_PACKET_OL_TX_UDP_CKSUM     | \
-                                     DP_PACKET_OL_TX_SCTP_CKSUM)
-
-#define DP_PACKET_OL_TX_L4_MASK (DP_PACKET_OL_TX_TCP_CKSUM | \
-                                 DP_PACKET_OL_TX_UDP_CKSUM | \
-                                 DP_PACKET_OL_TX_SCTP_CKSUM)
-#define DP_PACKET_OL_RX_IP_CKSUM_MASK (DP_PACKET_OL_RX_IP_CKSUM_GOOD | \
-                                       DP_PACKET_OL_RX_IP_CKSUM_BAD)
-#define DP_PACKET_OL_RX_L4_CKSUM_MASK (DP_PACKET_OL_RX_L4_CKSUM_GOOD | \
-                                       DP_PACKET_OL_RX_L4_CKSUM_BAD)
+                                     DP_PACKET_OL_TX_TCP_CSUM     | \
+                                     DP_PACKET_OL_TX_UDP_CSUM     | \
+                                     DP_PACKET_OL_TX_SCTP_CSUM)
+
+#define DP_PACKET_OL_TX_L4_MASK (DP_PACKET_OL_TX_TCP_CSUM | \
+                                 DP_PACKET_OL_TX_UDP_CSUM | \
+                                 DP_PACKET_OL_TX_SCTP_CSUM)
+#define DP_PACKET_OL_RX_IP_CSUM_MASK (DP_PACKET_OL_RX_IP_CSUM_GOOD | \
+                                       DP_PACKET_OL_RX_IP_CSUM_BAD)
+#define DP_PACKET_OL_RX_L4_CSUM_MASK (DP_PACKET_OL_RX_L4_CSUM_GOOD | \
+                                       DP_PACKET_OL_RX_L4_CSUM_BAD)
 
 /* Buffer for holding packet data.  A dp_packet is automatically reallocated
  * as necessary if it grows too large for the available memory.
@@ -991,7 +991,7 @@ static inline bool
 dp_packet_hwol_l4_is_tcp(const struct dp_packet *b)
 {
     return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) ==
-            DP_PACKET_OL_TX_TCP_CKSUM;
+            DP_PACKET_OL_TX_TCP_CSUM;
 }
 
 /* Returns 'true' if packet 'b' is marked for UDP checksum offloading. */
@@ -999,7 +999,7 @@ static inline bool
 dp_packet_hwol_l4_is_udp(struct dp_packet *b)
 {
     return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) ==
-            DP_PACKET_OL_TX_UDP_CKSUM;
+            DP_PACKET_OL_TX_UDP_CSUM;
 }
 
 /* Returns 'true' if packet 'b' is marked for SCTP checksum offloading. */
@@ -1007,7 +1007,7 @@ static inline bool
 dp_packet_hwol_l4_is_sctp(struct dp_packet *b)
 {
     return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) ==
-            DP_PACKET_OL_TX_SCTP_CKSUM;
+            DP_PACKET_OL_TX_SCTP_CSUM;
 }
 
 /* Mark packet 'b' for IPv4 checksum offloading. */
@@ -1029,7 +1029,7 @@ dp_packet_hwol_set_tx_ipv6(struct dp_packet *b)
 static inline void
 dp_packet_hwol_set_csum_tcp(struct dp_packet *b)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_TCP_CKSUM;
+    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_TCP_CSUM;
 }
 
 /* Mark packet 'b' for UDP checksum offloading.  It implies that either
@@ -1037,7 +1037,7 @@ dp_packet_hwol_set_csum_tcp(struct dp_packet *b)
 static inline void
 dp_packet_hwol_set_csum_udp(struct dp_packet *b)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_UDP_CKSUM;
+    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_UDP_CSUM;
 }
 
 /* Mark packet 'b' for SCTP checksum offloading.  It implies that either
@@ -1045,7 +1045,7 @@ dp_packet_hwol_set_csum_udp(struct dp_packet *b)
 static inline void
 dp_packet_hwol_set_csum_sctp(struct dp_packet *b)
 {
-    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_SCTP_CKSUM;
+    *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_SCTP_CSUM;
 }
 
 /* Mark packet 'b' for TCP segmentation offloading.  It implies that
@@ -1060,29 +1060,29 @@ dp_packet_hwol_set_tcp_seg(struct dp_packet *b)
 static inline bool
 dp_packet_ip_checksum_valid(const struct dp_packet *p)
 {
-    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CKSUM_MASK) ==
-            DP_PACKET_OL_RX_IP_CKSUM_GOOD;
+    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CSUM_MASK) ==
+            DP_PACKET_OL_RX_IP_CSUM_GOOD;
 }
 
 static inline bool
 dp_packet_ip_checksum_bad(const struct dp_packet *p)
 {
-    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CKSUM_MASK) ==
-            DP_PACKET_OL_RX_IP_CKSUM_BAD;
+    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CSUM_MASK) ==
+            DP_PACKET_OL_RX_IP_CSUM_BAD;
 }
 
 static inline bool
 dp_packet_l4_checksum_valid(const struct dp_packet *p)
 {
-    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CKSUM_MASK) ==
-            DP_PACKET_OL_RX_L4_CKSUM_GOOD;
+    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CSUM_MASK) ==
+            DP_PACKET_OL_RX_L4_CSUM_GOOD;
 }
 
 static inline bool
 dp_packet_l4_checksum_bad(const struct dp_packet *p)
 {
-    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CKSUM_MASK) ==
-            DP_PACKET_OL_RX_L4_CKSUM_BAD;
+    return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CSUM_MASK) ==
+            DP_PACKET_OL_RX_L4_CSUM_BAD;
 }
 
 static inline void ALWAYS_INLINE
diff --git a/lib/netdev-dpdk.c b/lib/netdev-dpdk.c
index f9535bfb4..d7350636e 100644
--- a/lib/netdev-dpdk.c
+++ b/lib/netdev-dpdk.c
@@ -4938,11 +4938,11 @@ netdev_dpdk_reconfigure(struct netdev *netdev)
     err = dpdk_eth_dev_init(dev);
     if (dev->hw_ol_features & NETDEV_TX_TSO_OFFLOAD) {
         netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_TSO;
-        netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CKSUM;
-        netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CKSUM;
-        netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CKSUM;
+        netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CSUM;
+        netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CSUM;
+        netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CSUM;
         if (dev->hw_ol_features & NETDEV_TX_SCTP_CHECKSUM_OFFLOAD) {
-            netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CKSUM;
+            netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CSUM;
         }
     }
 
@@ -5085,10 +5085,10 @@ netdev_dpdk_vhost_client_reconfigure(struct netdev *netdev)
 
         if (userspace_tso_enabled()) {
             netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_TSO;
-            netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CKSUM;
-            netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CKSUM;
-            netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CKSUM;
-            netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CKSUM;
+            netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CSUM;
+            netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CSUM;
+            netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CSUM;
+            netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CSUM;
             vhost_unsup_flags = 1ULL << VIRTIO_NET_F_HOST_ECN
                                 | 1ULL << VIRTIO_NET_F_HOST_UFO;
         } else {
diff --git a/lib/netdev-linux.c b/lib/netdev-linux.c
index 2766b3f2b..3cf02b76a 100644
--- a/lib/netdev-linux.c
+++ b/lib/netdev-linux.c
@@ -929,10 +929,10 @@ netdev_linux_common_construct(struct netdev *netdev_)
 
     if (userspace_tso_enabled()) {
         netdev_->ol_flags |= NETDEV_TX_OFFLOAD_TCP_TSO;
-        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CKSUM;
-        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CKSUM;
-        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CKSUM;
-        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CKSUM;
+        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CSUM;
+        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CSUM;
+        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CSUM;
+        netdev_->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CSUM;
     }
 
     return 0;
diff --git a/lib/netdev-provider.h b/lib/netdev-provider.h
index b5420947d..08bf8b871 100644
--- a/lib/netdev-provider.h
+++ b/lib/netdev-provider.h
@@ -38,10 +38,10 @@ struct netdev_tnl_build_header_params;
 #define NETDEV_NUMA_UNSPEC OVS_NUMA_UNSPEC
 
 enum netdev_ol_flags {
-    NETDEV_TX_OFFLOAD_IPV4_CKSUM = 1 << 0,
-    NETDEV_TX_OFFLOAD_TCP_CKSUM = 1 << 1,
-    NETDEV_TX_OFFLOAD_UDP_CKSUM = 1 << 2,
-    NETDEV_TX_OFFLOAD_SCTP_CKSUM = 1 << 3,
+    NETDEV_TX_OFFLOAD_IPV4_CSUM = 1 << 0,
+    NETDEV_TX_OFFLOAD_TCP_CSUM = 1 << 1,
+    NETDEV_TX_OFFLOAD_UDP_CSUM = 1 << 2,
+    NETDEV_TX_OFFLOAD_SCTP_CSUM = 1 << 3,
     NETDEV_TX_OFFLOAD_TCP_TSO = 1 << 4,
 };
 
diff --git a/lib/netdev.c b/lib/netdev.c
index 8305f6c42..e9b2bbe83 100644
--- a/lib/netdev.c
+++ b/lib/netdev.c
@@ -804,19 +804,19 @@ netdev_send_prepare_packet(const uint64_t netdev_flags,
     l4_mask = dp_packet_hwol_l4_mask(packet);
     if (l4_mask) {
         if (dp_packet_hwol_l4_is_tcp(packet)) {
-            if (!(netdev_flags & NETDEV_TX_OFFLOAD_TCP_CKSUM)) {
+            if (!(netdev_flags & NETDEV_TX_OFFLOAD_TCP_CSUM)) {
                 /* Fall back to TCP csum in software. */
                 VLOG_ERR_BUF(errormsg, "No TCP checksum support");
                 return false;
             }
         } else if (dp_packet_hwol_l4_is_udp(packet)) {
-            if (!(netdev_flags & NETDEV_TX_OFFLOAD_UDP_CKSUM)) {
+            if (!(netdev_flags & NETDEV_TX_OFFLOAD_UDP_CSUM)) {
                 /* Fall back to UDP csum in software. */
                 VLOG_ERR_BUF(errormsg, "No UDP checksum support");
                 return false;
             }
         } else if (dp_packet_hwol_l4_is_sctp(packet)) {
-            if (!(netdev_flags & NETDEV_TX_OFFLOAD_SCTP_CKSUM)) {
+            if (!(netdev_flags & NETDEV_TX_OFFLOAD_SCTP_CSUM)) {
                 /* Fall back to SCTP csum in software. */
                 VLOG_ERR_BUF(errormsg, "No SCTP checksum support");
                 return false;
