linux-gen: byteorder: remove separate API inlining header

Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov@linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer@linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org>

13 files changed, 123 insertions, 200 deletions

diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index e084eb2cb..373a1b104 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -26,7 +26,6 @@ odpapiplatinclude_HEADERS = \
 		  include/odp/api/plat/atomic_inlines.h \
 		  include/odp/api/plat/buffer_inline_types.h \
 		  include/odp/api/plat/byteorder_inlines.h \
-		  include/odp/api/plat/byteorder_inlines_api.h \
 		  include/odp/api/plat/event_inlines.h \
 		  include/odp/api/plat/packet_flag_inlines.h \
 		  include/odp/api/plat/packet_inline_types.h \
@@ -214,7 +213,7 @@ __LIB__libodp_linux_la_SOURCES = \
 if ODP_ABI_COMPAT
 __LIB__libodp_linux_la_SOURCES += \
 			   odp_atomic_api.c \
-			   odp_byteorder.c \
+			   odp_byteorder_api.c \
 			   odp_event_api.c \
 			   odp_packet_api.c \
 			   odp_packet_flags_api.c \
diff --git a/platform/linux-generic/include-abi/odp/api/abi/byteorder.h b/platform/linux-generic/include-abi/odp/api/abi/byteorder.h
index 8be28603f..c0b5ebe0c 100644
--- a/platform/linux-generic/include-abi/odp/api/abi/byteorder.h
+++ b/platform/linux-generic/include-abi/odp/api/abi/byteorder.h
@@ -75,9 +75,7 @@ typedef uint64_t __odp_bitwise	odp_u64be_t;
 typedef uint16_t __odp_bitwise  odp_u16sum_t;
 typedef uint32_t __odp_bitwise  odp_u32sum_t;
 
-#define _ODP_INLINE static inline
 #include <odp/api/plat/byteorder_inlines.h>
-#include <odp/api/plat/byteorder_inlines_api.h>
 
 /**
  * @}
diff --git a/platform/linux-generic/include/odp/api/plat/byteorder_inlines.h b/platform/linux-generic/include/odp/api/plat/byteorder_inlines.h
index 56a2b31cd..6cc2a9a18 100644
--- a/platform/linux-generic/include/odp/api/plat/byteorder_inlines.h
+++ b/platform/linux-generic/include/odp/api/plat/byteorder_inlines.h
@@ -17,13 +17,30 @@
 extern "C" {
 #endif
 
+/** @cond _ODP_HIDE_FROM_DOXYGEN_ */
+
 #ifndef __odp_force
 #define __odp_force
 #endif
 
-/** @ingroup odp_compiler_optim
- *  @{
- */
+#ifndef _ODP_NO_INLINE
+	/* Inline functions by default */
+	#define _ODP_INLINE static inline
+	#define odp_be_to_cpu_16 __odp_be_to_cpu_16
+	#define odp_be_to_cpu_32 __odp_be_to_cpu_32
+	#define odp_be_to_cpu_64 __odp_be_to_cpu_64
+	#define odp_cpu_to_be_16 __odp_cpu_to_be_16
+	#define odp_cpu_to_be_32 __odp_cpu_to_be_32
+	#define odp_cpu_to_be_64 __odp_cpu_to_be_64
+	#define odp_le_to_cpu_16 __odp_le_to_cpu_16
+	#define odp_le_to_cpu_32 __odp_le_to_cpu_32
+	#define odp_le_to_cpu_64 __odp_le_to_cpu_64
+	#define odp_cpu_to_le_16 __odp_cpu_to_le_16
+	#define odp_cpu_to_le_32 __odp_cpu_to_le_32
+	#define odp_cpu_to_le_64 __odp_cpu_to_le_64
+#else
+	#define _ODP_INLINE
+#endif
 
 /** @internal GNU compiler version */
 #define GCC_VERSION (__GNUC__ * 10000 \
@@ -43,7 +60,7 @@ extern "C" {
 #define __odp_builtin_bswap16(u16) __builtin_bswap16(u16)
 #endif
 
-static inline uint16_t _odp_be_to_cpu_16(odp_u16be_t be16)
+_ODP_INLINE uint16_t odp_be_to_cpu_16(odp_u16be_t be16)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return __odp_builtin_bswap16((__odp_force uint16_t)be16);
@@ -52,7 +69,7 @@ static inline uint16_t _odp_be_to_cpu_16(odp_u16be_t be16)
 #endif
 }
 
-static inline uint32_t _odp_be_to_cpu_32(odp_u32be_t be32)
+_ODP_INLINE uint32_t odp_be_to_cpu_32(odp_u32be_t be32)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return __builtin_bswap32((__odp_force uint32_t)be32);
@@ -61,7 +78,7 @@ static inline uint32_t _odp_be_to_cpu_32(odp_u32be_t be32)
 #endif
 }
 
-static inline uint64_t _odp_be_to_cpu_64(odp_u64be_t be64)
+_ODP_INLINE uint64_t odp_be_to_cpu_64(odp_u64be_t be64)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return __builtin_bswap64((__odp_force uint64_t)be64);
@@ -70,7 +87,7 @@ static inline uint64_t _odp_be_to_cpu_64(odp_u64be_t be64)
 #endif
 }
 
-static inline odp_u16be_t _odp_cpu_to_be_16(uint16_t cpu16)
+_ODP_INLINE odp_u16be_t odp_cpu_to_be_16(uint16_t cpu16)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force odp_u16be_t)__odp_builtin_bswap16(cpu16);
@@ -79,7 +96,7 @@ static inline odp_u16be_t _odp_cpu_to_be_16(uint16_t cpu16)
 #endif
 }
 
-static inline odp_u32be_t _odp_cpu_to_be_32(uint32_t cpu32)
+_ODP_INLINE odp_u32be_t odp_cpu_to_be_32(uint32_t cpu32)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force odp_u32be_t)__builtin_bswap32(cpu32);
@@ -88,7 +105,7 @@ static inline odp_u32be_t _odp_cpu_to_be_32(uint32_t cpu32)
 #endif
 }
 
-static inline odp_u64be_t _odp_cpu_to_be_64(uint64_t cpu64)
+_ODP_INLINE odp_u64be_t odp_cpu_to_be_64(uint64_t cpu64)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force odp_u64be_t)__builtin_bswap64(cpu64);
@@ -97,7 +114,7 @@ static inline odp_u64be_t _odp_cpu_to_be_64(uint64_t cpu64)
 #endif
 }
 
-static inline uint16_t _odp_le_to_cpu_16(odp_u16le_t le16)
+_ODP_INLINE uint16_t odp_le_to_cpu_16(odp_u16le_t le16)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force uint16_t)le16;
@@ -106,7 +123,7 @@ static inline uint16_t _odp_le_to_cpu_16(odp_u16le_t le16)
 #endif
 }
 
-static inline uint32_t _odp_le_to_cpu_32(odp_u32le_t le32)
+_ODP_INLINE uint32_t odp_le_to_cpu_32(odp_u32le_t le32)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force uint32_t)le32;
@@ -115,7 +132,7 @@ static inline uint32_t _odp_le_to_cpu_32(odp_u32le_t le32)
 #endif
 }
 
-static inline uint64_t _odp_le_to_cpu_64(odp_u64le_t le64)
+_ODP_INLINE uint64_t odp_le_to_cpu_64(odp_u64le_t le64)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force uint64_t)le64;
@@ -124,7 +141,7 @@ static inline uint64_t _odp_le_to_cpu_64(odp_u64le_t le64)
 #endif
 }
 
-static inline odp_u16le_t _odp_cpu_to_le_16(uint16_t cpu16)
+_ODP_INLINE odp_u16le_t odp_cpu_to_le_16(uint16_t cpu16)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force odp_u16le_t)cpu16;
@@ -133,7 +150,7 @@ static inline odp_u16le_t _odp_cpu_to_le_16(uint16_t cpu16)
 #endif
 }
 
-static inline odp_u32le_t _odp_cpu_to_le_32(uint32_t cpu32)
+_ODP_INLINE odp_u32le_t odp_cpu_to_le_32(uint32_t cpu32)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force odp_u32le_t)cpu32;
@@ -142,7 +159,7 @@ static inline odp_u32le_t _odp_cpu_to_le_32(uint32_t cpu32)
 #endif
 }
 
-static inline odp_u64le_t _odp_cpu_to_le_64(uint64_t cpu64)
+_ODP_INLINE odp_u64le_t odp_cpu_to_le_64(uint64_t cpu64)
 {
 #if ODP_BYTE_ORDER == ODP_LITTLE_ENDIAN
 	return (__odp_force odp_u64le_t)cpu64;
@@ -151,9 +168,7 @@ static inline odp_u64le_t _odp_cpu_to_le_64(uint64_t cpu64)
 #endif
 }
 
-/**
- * @}
- */
+/** @endcond */
 
 #ifdef __cplusplus
 }
diff --git a/platform/linux-generic/include/odp/api/plat/byteorder_inlines_api.h b/platform/linux-generic/include/odp/api/plat/byteorder_inlines_api.h
deleted file mode 100644
index f979f601e..000000000
--- a/platform/linux-generic/include/odp/api/plat/byteorder_inlines_api.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/* Copyright (c) 2018-2018, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier:     BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODP byteorder
- */
-
-#ifndef ODP_PLAT_BYTEORDER_INLINES_API_H_
-#define ODP_PLAT_BYTEORDER_INLINES_API_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-_ODP_INLINE uint16_t odp_be_to_cpu_16(odp_u16be_t be16)
-{
-	return _odp_be_to_cpu_16(be16);
-}
-
-_ODP_INLINE uint32_t odp_be_to_cpu_32(odp_u32be_t be32)
-{
-	return _odp_be_to_cpu_32(be32);
-}
-
-_ODP_INLINE uint64_t odp_be_to_cpu_64(odp_u64be_t be64)
-{
-	return _odp_be_to_cpu_64(be64);
-}
-
-_ODP_INLINE odp_u16be_t odp_cpu_to_be_16(uint16_t cpu16)
-{
-	return _odp_cpu_to_be_16(cpu16);
-}
-
-_ODP_INLINE odp_u32be_t odp_cpu_to_be_32(uint32_t cpu32)
-{
-	return _odp_cpu_to_be_32(cpu32);
-}
-
-_ODP_INLINE odp_u64be_t odp_cpu_to_be_64(uint64_t cpu64)
-{
-	return _odp_cpu_to_be_64(cpu64);
-}
-
-_ODP_INLINE uint16_t odp_le_to_cpu_16(odp_u16le_t le16)
-{
-	return _odp_le_to_cpu_16(le16);
-}
-
-_ODP_INLINE uint32_t odp_le_to_cpu_32(odp_u32le_t le32)
-{
-	return _odp_le_to_cpu_32(le32);
-}
-
-_ODP_INLINE uint64_t odp_le_to_cpu_64(odp_u64le_t le64)
-{
-	return _odp_le_to_cpu_64(le64);
-}
-
-_ODP_INLINE odp_u16le_t odp_cpu_to_le_16(uint16_t cpu16)
-{
-	return _odp_cpu_to_le_16(cpu16);
-}
-
-_ODP_INLINE odp_u32le_t odp_cpu_to_le_32(uint32_t cpu32)
-{
-	return _odp_cpu_to_le_32(cpu32);
-}
-
-_ODP_INLINE odp_u64le_t odp_cpu_to_le_64(uint64_t cpu64)
-{
-	return _odp_cpu_to_le_64(cpu64);
-}
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/platform/linux-generic/include/odp_classification_inlines.h b/platform/linux-generic/include/odp_classification_inlines.h
index 3f1d9ce6a..698192766 100644
--- a/platform/linux-generic/include/odp_classification_inlines.h
+++ b/platform/linux-generic/include/odp_classification_inlines.h
@@ -70,7 +70,7 @@ static inline int verify_pmr_ipv4_saddr(const uint8_t *pkt_addr,
 	if (!pkt_hdr->p.input_flags.ipv4)
 		return 0;
 	ip = (const _odp_ipv4hdr_t *)(pkt_addr + pkt_hdr->p.l3_offset);
-	ipaddr = _odp_be_to_cpu_32(ip->src_addr);
+	ipaddr = odp_be_to_cpu_32(ip->src_addr);
 	if (term_value->match.value == (ipaddr & term_value->match.mask))
 		return 1;
 
@@ -86,7 +86,7 @@ static inline int verify_pmr_ipv4_daddr(const uint8_t *pkt_addr,
 	if (!pkt_hdr->p.input_flags.ipv4)
 		return 0;
 	ip = (const _odp_ipv4hdr_t *)(pkt_addr + pkt_hdr->p.l3_offset);
-	ipaddr = _odp_be_to_cpu_32(ip->dst_addr);
+	ipaddr = odp_be_to_cpu_32(ip->dst_addr);
 	if (term_value->match.value == (ipaddr & term_value->match.mask))
 		return 1;
 
@@ -102,7 +102,7 @@ static inline int verify_pmr_tcp_sport(const uint8_t *pkt_addr,
 	if (!pkt_hdr->p.input_flags.tcp)
 		return 0;
 	tcp = (const _odp_tcphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
-	sport = _odp_be_to_cpu_16(tcp->src_port);
+	sport = odp_be_to_cpu_16(tcp->src_port);
 	if (term_value->match.value == (sport & term_value->match.mask))
 		return 1;
 
@@ -118,7 +118,7 @@ static inline int verify_pmr_tcp_dport(const uint8_t *pkt_addr,
 	if (!pkt_hdr->p.input_flags.tcp)
 		return 0;
 	tcp = (const _odp_tcphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
-	dport = _odp_be_to_cpu_16(tcp->dst_port);
+	dport = odp_be_to_cpu_16(tcp->dst_port);
 	if (term_value->match.value == (dport & term_value->match.mask))
 		return 1;
 
@@ -134,7 +134,7 @@ static inline int verify_pmr_udp_dport(const uint8_t *pkt_addr,
 	if (!pkt_hdr->p.input_flags.udp)
 		return 0;
 	udp = (const _odp_udphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
-	dport = _odp_be_to_cpu_16(udp->dst_port);
+	dport = odp_be_to_cpu_16(udp->dst_port);
 	if (term_value->match.value == (dport & term_value->match.mask))
 			return 1;
 
@@ -151,7 +151,7 @@ static inline int verify_pmr_udp_sport(const uint8_t *pkt_addr,
 	if (!pkt_hdr->p.input_flags.udp)
 		return 0;
 	udp = (const _odp_udphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
-	sport = _odp_be_to_cpu_16(udp->src_port);
+	sport = odp_be_to_cpu_16(udp->src_port);
 	if (term_value->match.value == (sport & term_value->match.mask))
 		return 1;
 
@@ -171,9 +171,9 @@ static inline int verify_pmr_dmac(const uint8_t *pkt_addr,
 
 	eth = (const _odp_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
 	memcpy(&dmac_be, eth->dst.addr, _ODP_ETHADDR_LEN);
-	dmac = _odp_be_to_cpu_64(dmac_be);
+	dmac = odp_be_to_cpu_64(dmac_be);
 	/* since we are converting a 48 bit ethernet address from BE to cpu
-	format using _odp_be_to_cpu_64() the last 16 bits needs to be right
+	format using odp_be_to_cpu_64() the last 16 bits needs to be right
 	shifted */
 	if (dmac_be != dmac)
 		dmac = dmac >> (64 - (_ODP_ETHADDR_LEN * 8));
@@ -247,7 +247,7 @@ static inline int verify_pmr_vlan_id_0(const uint8_t *pkt_addr,
 
 	eth = (const _odp_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
 	vlan = (const _odp_vlanhdr_t *)(eth + 1);
-	tci = _odp_be_to_cpu_16(vlan->tci);
+	tci = odp_be_to_cpu_16(vlan->tci);
 	vlan_id = tci & 0x0fff;
 
 	if (term_value->match.value == (vlan_id & term_value->match.mask))
@@ -271,7 +271,7 @@ static inline int verify_pmr_vlan_id_x(const uint8_t *pkt_addr ODP_UNUSED,
 	eth = (const _odp_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
 	vlan = (const _odp_vlanhdr_t *)(eth + 1);
 	vlan++;
-	tci = _odp_be_to_cpu_16(vlan->tci);
+	tci = odp_be_to_cpu_16(vlan->tci);
 	vlan_id = tci & 0x0fff;
 
 	if (term_value->match.value == (vlan_id & term_value->match.mask))
@@ -291,11 +291,11 @@ static inline int verify_pmr_ipsec_spi(const uint8_t *pkt_addr,
 	if (pkt_hdr->p.input_flags.ipsec_ah) {
 		const _odp_ahhdr_t *ahhdr = (const _odp_ahhdr_t *)pkt_addr;
 
-		spi = _odp_be_to_cpu_32(ahhdr->spi);
+		spi = odp_be_to_cpu_32(ahhdr->spi);
 	} else if (pkt_hdr->p.input_flags.ipsec_esp) {
 		const _odp_esphdr_t *esphdr = (const _odp_esphdr_t *)pkt_addr;
 
-		spi = _odp_be_to_cpu_32(esphdr->spi);
+		spi = odp_be_to_cpu_32(esphdr->spi);
 	} else {
 		return 0;
 	}
@@ -345,7 +345,7 @@ static inline int verify_pmr_eth_type_0(const uint8_t *pkt_addr,
 		return 0;
 
 	eth = (const _odp_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
-	ethtype = _odp_be_to_cpu_16(eth->type);
+	ethtype = odp_be_to_cpu_16(eth->type);
 
 	if (term_value->match.value == (ethtype & term_value->match.mask))
 		return 1;
@@ -366,7 +366,7 @@ static inline int verify_pmr_eth_type_x(const uint8_t *pkt_addr,
 
 	eth = (const _odp_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
 	vlan = (const _odp_vlanhdr_t *)(eth + 1);
-	ethtype = _odp_be_to_cpu_16(vlan->type);
+	ethtype = odp_be_to_cpu_16(vlan->type);
 
 	if (term_value->match.value == (ethtype & term_value->match.mask))
 		return 1;
diff --git a/platform/linux-generic/include/protocols/thash.h b/platform/linux-generic/include/protocols/thash.h
index 0f10a3cb2..2109c8a56 100644
--- a/platform/linux-generic/include/protocols/thash.h
+++ b/platform/linux-generic/include/protocols/thash.h
@@ -67,10 +67,10 @@ void thash_load_ipv6_addr(const _odp_ipv6hdr_t *ipv6,
 
 	for (i = 0; i < 4; i++) {
 		*(tuple->v6.src_addr.u32 + i) =
-		_odp_be_to_cpu_32(*(ipv6->src_addr.u32 + i));
+		odp_be_to_cpu_32(*(ipv6->src_addr.u32 + i));
 
 		*(tuple->v6.dst_addr.u32 + i) =
-		_odp_be_to_cpu_32(*(ipv6->dst_addr.u32 + i));
+		odp_be_to_cpu_32(*(ipv6->dst_addr.u32 + i));
 	}
 }
 
@@ -83,9 +83,9 @@ uint32_t thash_softrss(uint32_t *tuple, uint8_t len,
 	for (j = 0; j < len; j++) {
 		for (i = 0; i < 32; i++) {
 			if (tuple[j] & (1 << (31 - i))) {
-				ret ^= _odp_cpu_to_be_32(((const uint32_t *)
+				ret ^= odp_cpu_to_be_32(((const uint32_t *)
 				key.u32)[j]) << i | (uint32_t)((uint64_t)
-				(_odp_cpu_to_be_32(((const uint32_t *)key.u32)
+				(odp_cpu_to_be_32(((const uint32_t *)key.u32)
 				[j + 1])) >> (32 - i));
 			}
 		}
diff --git a/platform/linux-generic/odp_byteorder.c b/platform/linux-generic/odp_byteorder_api.c
index ec7d261da..7d8c9516d 100644
--- a/platform/linux-generic/odp_byteorder.c
+++ b/platform/linux-generic/odp_byteorder_api.c
@@ -9,6 +9,5 @@
 #include <odp/api/byteorder.h>
 
 /* Include non-inlined versions of API functions */
-#define _ODP_INLINE
+#define _ODP_NO_INLINE
 #include <odp/api/plat/byteorder_inlines.h>
-#include <odp/api/plat/byteorder_inlines_api.h>
diff --git a/platform/linux-generic/odp_classification.c b/platform/linux-generic/odp_classification.c
index ae4eb5854..8b25cf4cc 100644
--- a/platform/linux-generic/odp_classification.c
+++ b/platform/linux-generic/odp_classification.c
@@ -1133,7 +1133,7 @@ cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, const uint8_t *pkt_addr,
 	    packet_hdr_has_eth(hdr)) {
 		eth = (const _odp_ethhdr_t *)(pkt_addr + hdr->p.l2_offset);
 		vlan = (const _odp_vlanhdr_t *)(eth + 1);
-		qos = _odp_be_to_cpu_16(vlan->tci);
+		qos = odp_be_to_cpu_16(vlan->tci);
 		qos = ((qos >> 13) & 0x07);
 		cos = l2_cos->cos[qos];
 	}
diff --git a/platform/linux-generic/odp_ipsec.c b/platform/linux-generic/odp_ipsec.c
index 7401f590a..a72dee33c 100644
--- a/platform/linux-generic/odp_ipsec.c
+++ b/platform/linux-generic/odp_ipsec.c
@@ -251,11 +251,11 @@ static int ipsec_parse_ipv4(ipsec_state_t *state, odp_packet_t pkt)
 	odp_packet_copy_to_mem(pkt, state->ip_offset,
 			       _ODP_IPV4HDR_LEN, &ipv4hdr);
 
-	if (_ODP_IPV4HDR_IS_FRAGMENT(_odp_be_to_cpu_16(ipv4hdr.frag_offset)))
+	if (_ODP_IPV4HDR_IS_FRAGMENT(odp_be_to_cpu_16(ipv4hdr.frag_offset)))
 		return -1;
 
 	state->ip_hdr_len = ipv4_hdr_len(&ipv4hdr);
-	state->ip_tot_len = _odp_be_to_cpu_16(ipv4hdr.tot_len);
+	state->ip_tot_len = odp_be_to_cpu_16(ipv4hdr.tot_len);
 	state->ip_next_hdr = ipv4hdr.proto;
 	state->ip_next_hdr_offset = state->ip_offset +
 		_ODP_IPV4HDR_PROTO_OFFSET;
@@ -276,7 +276,7 @@ static int ipsec_parse_ipv6(ipsec_state_t *state, odp_packet_t pkt)
 	state->ip_next_hdr = ipv6hdr.next_hdr;
 	state->ip_next_hdr_offset = state->ip_offset + _ODP_IPV6HDR_NHDR_OFFSET;
 	/* FIXME: Jumbo frames */
-	state->ip_tot_len = _odp_be_to_cpu_16(ipv6hdr.payload_len) +
+	state->ip_tot_len = odp_be_to_cpu_16(ipv6hdr.payload_len) +
 			    _ODP_IPV6HDR_LEN;
 	memcpy(state->ipv6_addr, &ipv6hdr.dst_addr, _ODP_IPV6ADDR_LEN);
 
@@ -379,8 +379,8 @@ static int ipsec_in_esp(odp_packet_t *pkt,
 		odp_packet_copy_to_mem(*pkt, ipsec_offset,
 				       _ODP_UDPHDR_LEN, &udp);
 
-		if (udp.dst_port != _odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT) ||
-		    udp.length != _odp_cpu_to_be_16(ip_data_len)) {
+		if (udp.dst_port != odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT) ||
+		    udp.length != odp_cpu_to_be_16(ip_data_len)) {
 			status->error.proto = 1;
 			return -1;
 		}
@@ -397,7 +397,7 @@ static int ipsec_in_esp(odp_packet_t *pkt,
 	}
 
 	ipsec_sa = ipsec_get_sa(sa, ODP_IPSEC_ESP,
-				_odp_be_to_cpu_32(esp.spi),
+				odp_be_to_cpu_32(esp.spi),
 				state->is_ipv4 ? ODP_IPSEC_IPV4 :
 						ODP_IPSEC_IPV6,
 				&state->ipv4_addr, status);
@@ -435,7 +435,7 @@ static int ipsec_in_esp(odp_packet_t *pkt,
 
 	state->esp.aad.spi = esp.spi;
 	state->esp.aad.seq_no = esp.seq_no;
-	state->in.seq_no = _odp_be_to_cpu_32(esp.seq_no);
+	state->in.seq_no = odp_be_to_cpu_32(esp.seq_no);
 
 	param->aad_ptr = (uint8_t *)&state->esp.aad;
 
@@ -500,7 +500,7 @@ static int ipsec_in_ah(odp_packet_t *pkt,
 	}
 
 	ipsec_sa = ipsec_get_sa(sa, ODP_IPSEC_AH,
-				_odp_be_to_cpu_32(ah.spi),
+				odp_be_to_cpu_32(ah.spi),
 				state->is_ipv4 ? ODP_IPSEC_IPV4 :
 						ODP_IPSEC_IPV6,
 				&state->ipv4_addr, status);
@@ -541,11 +541,11 @@ static int ipsec_in_ah(odp_packet_t *pkt,
 		state->ah_ipv6.ver_tc_flow = ipv6hdr->ver_tc_flow;
 		state->ah_ipv6.hop_limit = ipv6hdr->hop_limit;
 		ipv6hdr->ver_tc_flow =
-			_odp_cpu_to_be_32(6 << _ODP_IPV6HDR_VERSION_SHIFT);
+			odp_cpu_to_be_32(6 << _ODP_IPV6HDR_VERSION_SHIFT);
 		ipv6hdr->hop_limit = 0;
 	}
 
-	state->in.seq_no = _odp_be_to_cpu_32(ah.seq_no);
+	state->in.seq_no = odp_be_to_cpu_32(ah.seq_no);
 
 	param->auth_range.offset = state->ip_offset;
 	param->auth_range.length = state->ip_tot_len;
@@ -755,7 +755,7 @@ static ipsec_sa_t *ipsec_in_single(odp_packet_t pkt,
 		_odp_ipv4hdr_t *ipv4hdr = odp_packet_l3_ptr(pkt, NULL);
 
 		if (ODP_IPSEC_MODE_TRANSPORT == ipsec_sa->mode)
-			ipv4hdr->tot_len = _odp_cpu_to_be_16(state.ip_tot_len);
+			ipv4hdr->tot_len = odp_cpu_to_be_16(state.ip_tot_len);
 		else
 			ipv4hdr->ttl -= ipsec_sa->dec_ttl;
 		_odp_packet_ipv4_chksum_insert(pkt);
@@ -764,7 +764,7 @@ static ipsec_sa_t *ipsec_in_single(odp_packet_t pkt,
 
 		if (ODP_IPSEC_MODE_TRANSPORT == ipsec_sa->mode)
 			ipv6hdr->payload_len =
-				_odp_cpu_to_be_16(state.ip_tot_len -
+				odp_cpu_to_be_16(state.ip_tot_len -
 						  _ODP_IPV6HDR_LEN);
 		else
 			ipv6hdr->hop_limit -= ipsec_sa->dec_ttl;
@@ -820,7 +820,7 @@ static int ipsec_out_tunnel_parse_ipv4(ipsec_state_t *state,
 				       ipsec_sa_t *ipsec_sa)
 {
 	_odp_ipv4hdr_t *ipv4hdr = state->ip;
-	uint16_t flags = _odp_be_to_cpu_16(ipv4hdr->frag_offset);
+	uint16_t flags = odp_be_to_cpu_16(ipv4hdr->frag_offset);
 
 	ipv4hdr->ttl -= ipsec_sa->dec_ttl;
 	state->out_tunnel.ip_tos = ipv4hdr->tos;
@@ -868,7 +868,7 @@ static int ipsec_out_tunnel_ipv4(odp_packet_t *pkt,
 	state->ip_tot_len = odp_packet_len(*pkt) - state->ip_offset;
 	state->ip_tot_len += _ODP_IPV4HDR_LEN;
 
-	out_ip.tot_len = _odp_cpu_to_be_16(state->ip_tot_len);
+	out_ip.tot_len = odp_cpu_to_be_16(state->ip_tot_len);
 	/* No need to convert to BE: ID just should not be duplicated */
 	out_ip.id = odp_atomic_fetch_add_u32(&ipsec_sa->out.tun_ipv4.hdr_id,
 					     1);
@@ -876,7 +876,7 @@ static int ipsec_out_tunnel_ipv4(odp_packet_t *pkt,
 		flags = state->out_tunnel.ip_df;
 	else
 		flags = ((uint16_t)ipv4_param->df) << 14;
-	out_ip.frag_offset = _odp_cpu_to_be_16(flags);
+	out_ip.frag_offset = odp_cpu_to_be_16(flags);
 	out_ip.ttl = ipv4_param->ttl;
 	/* Will be filled later by packet checksum update */
 	out_ip.chksum = 0;
@@ -937,7 +937,7 @@ static int ipsec_out_tunnel_ipv6(odp_packet_t *pkt,
 	out_ip.ver_tc_flow = odp_cpu_to_be_32(ver);
 
 	state->ip_tot_len = odp_packet_len(*pkt) - state->ip_offset;
-	out_ip.payload_len = _odp_cpu_to_be_16(state->ip_tot_len);
+	out_ip.payload_len = odp_cpu_to_be_16(state->ip_tot_len);
 	state->ip_tot_len += _ODP_IPV6HDR_LEN;
 
 	out_ip.hop_limit = ipv6_param->hlimit;
@@ -1054,9 +1054,9 @@ static int ipsec_out_esp(odp_packet_t *pkt,
 	if (ipsec_sa->udp_encap) {
 		hdr_len += _ODP_UDPHDR_LEN;
 		proto = _ODP_IPPROTO_UDP;
-		udphdr.src_port = _odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
-		udphdr.dst_port = _odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
-		udphdr.length = _odp_cpu_to_be_16(ip_data_len +
+		udphdr.src_port = odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
+		udphdr.dst_port = odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
+		udphdr.length = odp_cpu_to_be_16(ip_data_len +
 						  hdr_len + trl_len);
 		udphdr.chksum = 0; /* should be 0 by RFC */
 	}
@@ -1075,8 +1075,8 @@ static int ipsec_out_esp(odp_packet_t *pkt,
 	param->auth_iv_ptr = state->iv;
 
 	memset(&esp, 0, sizeof(esp));
-	esp.spi = _odp_cpu_to_be_32(ipsec_sa->spi);
-	esp.seq_no = _odp_cpu_to_be_32(ipsec_seq_no(ipsec_sa));
+	esp.spi = odp_cpu_to_be_32(ipsec_sa->spi);
+	esp.seq_no = odp_cpu_to_be_32(ipsec_seq_no(ipsec_sa));
 
 	state->esp.aad.spi = esp.spi;
 	state->esp.aad.seq_no = esp.seq_no;
@@ -1092,11 +1092,11 @@ static int ipsec_out_esp(odp_packet_t *pkt,
 	if (state->is_ipv4) {
 		_odp_ipv4hdr_t *ipv4hdr = state->ip;
 
-		ipv4hdr->tot_len = _odp_cpu_to_be_16(state->ip_tot_len);
+		ipv4hdr->tot_len = odp_cpu_to_be_16(state->ip_tot_len);
 	} else if (state->is_ipv6) {
 		_odp_ipv6hdr_t *ipv6hdr = state->ip;
 
-		ipv6hdr->payload_len = _odp_cpu_to_be_16(state->ip_tot_len -
+		ipv6hdr->payload_len = odp_cpu_to_be_16(state->ip_tot_len -
 							 _ODP_IPV6HDR_LEN);
 	}
 
@@ -1205,8 +1205,8 @@ static int ipsec_out_ah(odp_packet_t *pkt,
 	}
 
 	memset(&ah, 0, sizeof(ah));
-	ah.spi = _odp_cpu_to_be_32(ipsec_sa->spi);
-	ah.seq_no = _odp_cpu_to_be_32(ipsec_seq_no(ipsec_sa));
+	ah.spi = odp_cpu_to_be_32(ipsec_sa->spi);
+	ah.seq_no = odp_cpu_to_be_32(ipsec_seq_no(ipsec_sa));
 	ah.next_header = state->ip_next_hdr;
 
 	odp_packet_copy_from_mem(*pkt, state->ip_next_hdr_offset, 1, &proto);
@@ -1223,19 +1223,19 @@ static int ipsec_out_ah(odp_packet_t *pkt,
 		ipv4hdr->ttl = 0;
 		hdr_len = IPSEC_PAD_LEN(hdr_len, 4);
 		state->ip_tot_len += hdr_len;
-		ipv4hdr->tot_len = _odp_cpu_to_be_16(state->ip_tot_len);
+		ipv4hdr->tot_len = odp_cpu_to_be_16(state->ip_tot_len);
 	} else {
 		_odp_ipv6hdr_t *ipv6hdr = state->ip;
 
 		state->ah_ipv6.ver_tc_flow = ipv6hdr->ver_tc_flow;
 		state->ah_ipv6.hop_limit = ipv6hdr->hop_limit;
 		ipv6hdr->ver_tc_flow =
-			_odp_cpu_to_be_32(6 << _ODP_IPV6HDR_VERSION_SHIFT);
+			odp_cpu_to_be_32(6 << _ODP_IPV6HDR_VERSION_SHIFT);
 		ipv6hdr->hop_limit = 0;
 
 		hdr_len = IPSEC_PAD_LEN(hdr_len, 8);
 		state->ip_tot_len += hdr_len;
-		ipv6hdr->payload_len = _odp_cpu_to_be_16(state->ip_tot_len -
+		ipv6hdr->payload_len = odp_cpu_to_be_16(state->ip_tot_len -
 							 _ODP_IPV6HDR_LEN);
 	}
 
diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c
index 50dbdc45e..b3e1d150c 100644
--- a/platform/linux-generic/odp_packet.c
+++ b/platform/linux-generic/odp_packet.c
@@ -2036,16 +2036,16 @@ static inline uint16_t parse_eth(packet_parser_t *prs, const uint8_t **parseptr,
 		input_flags.jumbo = 1;
 
 	/* Handle Ethernet broadcast/multicast addresses */
-	macaddr0 = _odp_be_to_cpu_16(*((const uint16_t *)(const void *)eth));
+	macaddr0 = odp_be_to_cpu_16(*((const uint16_t *)(const void *)eth));
 	if (odp_unlikely((macaddr0 & 0x0100) == 0x0100))
 		input_flags.eth_mcast = 1;
 
 	if (odp_unlikely(macaddr0 == 0xffff)) {
 		macaddr2 =
-			_odp_be_to_cpu_16(*((const uint16_t *)
+			odp_be_to_cpu_16(*((const uint16_t *)
 					    (const void *)eth + 1));
 		macaddr4 =
-			_odp_be_to_cpu_16(*((const uint16_t *)
+			odp_be_to_cpu_16(*((const uint16_t *)
 					    (const void *)eth + 2));
 
 		if ((macaddr2 == 0xffff) && (macaddr4 == 0xffff))
@@ -2053,7 +2053,7 @@ static inline uint16_t parse_eth(packet_parser_t *prs, const uint8_t **parseptr,
 	}
 
 	/* Get Ethertype */
-	ethtype = _odp_be_to_cpu_16(eth->type);
+	ethtype = odp_be_to_cpu_16(eth->type);
 	*offset += sizeof(*eth);
 	*parseptr += sizeof(*eth);
 
@@ -2065,7 +2065,7 @@ static inline uint16_t parse_eth(packet_parser_t *prs, const uint8_t **parseptr,
 			ethtype = 0;
 			goto error;
 		}
-		ethtype = _odp_be_to_cpu_16(*((const uint16_t *)(uintptr_t)
+		ethtype = odp_be_to_cpu_16(*((const uint16_t *)(uintptr_t)
 					      (parseptr + 6)));
 		*offset   += 8;
 		*parseptr += 8;
@@ -2077,7 +2077,7 @@ static inline uint16_t parse_eth(packet_parser_t *prs, const uint8_t **parseptr,
 		input_flags.vlan = 1;
 
 		vlan = (const _odp_vlanhdr_t *)*parseptr;
-		ethtype = _odp_be_to_cpu_16(vlan->type);
+		ethtype = odp_be_to_cpu_16(vlan->type);
 		*offset += sizeof(_odp_vlanhdr_t);
 		*parseptr += sizeof(_odp_vlanhdr_t);
 	}
@@ -2085,7 +2085,7 @@ static inline uint16_t parse_eth(packet_parser_t *prs, const uint8_t **parseptr,
 	if (ethtype == _ODP_ETHTYPE_VLAN) {
 		input_flags.vlan = 1;
 		vlan = (const _odp_vlanhdr_t *)*parseptr;
-		ethtype = _odp_be_to_cpu_16(vlan->type);
+		ethtype = odp_be_to_cpu_16(vlan->type);
 		*offset += sizeof(_odp_vlanhdr_t);
 		*parseptr += sizeof(_odp_vlanhdr_t);
 	}
@@ -2105,9 +2105,9 @@ static inline uint8_t parse_ipv4(packet_parser_t *prs, const uint8_t **parseptr,
 				 uint32_t *l4_part_sum)
 {
 	const _odp_ipv4hdr_t *ipv4 = (const _odp_ipv4hdr_t *)*parseptr;
-	uint32_t dstaddr = _odp_be_to_cpu_32(ipv4->dst_addr);
-	uint32_t l3_len = _odp_be_to_cpu_16(ipv4->tot_len);
-	uint16_t frag_offset = _odp_be_to_cpu_16(ipv4->frag_offset);
+	uint32_t dstaddr = odp_be_to_cpu_32(ipv4->dst_addr);
+	uint32_t l3_len = odp_be_to_cpu_16(ipv4->tot_len);
+	uint16_t frag_offset = odp_be_to_cpu_16(ipv4->frag_offset);
 	uint8_t ver = _ODP_IPV4HDR_VER(ipv4->ver_ihl);
 	uint8_t ihl = _ODP_IPV4HDR_IHL(ipv4->ver_ihl);
 
@@ -2166,12 +2166,12 @@ static inline uint8_t parse_ipv6(packet_parser_t *prs, const uint8_t **parseptr,
 {
 	const _odp_ipv6hdr_t *ipv6 = (const _odp_ipv6hdr_t *)*parseptr;
 	const _odp_ipv6hdr_ext_t *ipv6ext;
-	uint32_t dstaddr0 = _odp_be_to_cpu_32(ipv6->dst_addr.u8[0]);
-	uint32_t l3_len = _odp_be_to_cpu_16(ipv6->payload_len) +
+	uint32_t dstaddr0 = odp_be_to_cpu_32(ipv6->dst_addr.u8[0]);
+	uint32_t l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
 			  _ODP_IPV6HDR_LEN;
 
 	/* Basic sanity checks on IPv6 header */
-	if ((_odp_be_to_cpu_32(ipv6->ver_tc_flow) >> 28) != 6 ||
+	if ((odp_be_to_cpu_32(ipv6->ver_tc_flow) >> 28) != 6 ||
 	    l3_len > frame_len - *offset) {
 		prs->flags.ip_err = 1;
 		return 0;
@@ -2205,7 +2205,7 @@ static inline uint8_t parse_ipv6(packet_parser_t *prs, const uint8_t **parseptr,
 			 *offset < seg_len);
 
 		if (*offset >= prs->l3_offset +
-		    _odp_be_to_cpu_16(ipv6->payload_len)) {
+		    odp_be_to_cpu_16(ipv6->payload_len)) {
 			prs->flags.ip_err = 1;
 			return 0;
 		}
@@ -2259,8 +2259,8 @@ static inline void parse_udp(packet_parser_t *prs, const uint8_t **parseptr,
 			     uint32_t *l4_part_sum)
 {
 	const _odp_udphdr_t *udp = (const _odp_udphdr_t *)*parseptr;
-	uint32_t udplen = _odp_be_to_cpu_16(udp->length);
-	uint16_t ipsec_port = _odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
+	uint32_t udplen = odp_be_to_cpu_16(udp->length);
+	uint16_t ipsec_port = odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
 
 	if (odp_unlikely(udplen < sizeof(_odp_udphdr_t))) {
 		prs->flags.udp_err = 1;
@@ -2528,7 +2528,7 @@ static int _odp_packet_tcp_udp_chksum_insert(odp_packet_t pkt, uint16_t proto)
 #endif
 
 	if (proto == _ODP_IPPROTO_TCP) {
-		sum += _odp_cpu_to_be_16(pkt_hdr->frame_len -
+		sum += odp_cpu_to_be_16(pkt_hdr->frame_len -
 					 pkt_hdr->p.l4_offset);
 		chksum_offset = pkt_hdr->p.l4_offset + _ODP_UDP_CSUM_OFFSET;
 	} else {
diff --git a/platform/linux-generic/odp_traffic_mngr.c b/platform/linux-generic/odp_traffic_mngr.c
index 96dde266a..6e741e01b 100644
--- a/platform/linux-generic/odp_traffic_mngr.c
+++ b/platform/linux-generic/odp_traffic_mngr.c
@@ -1948,7 +1948,7 @@ static void egress_vlan_marking(tm_vlan_marking_t *vlan_marking,
 		vlan_hdr_ptr = &vlan_hdr;
 	}
 
-	old_tci = _odp_be_to_cpu_16(vlan_hdr_ptr->tci);
+	old_tci = odp_be_to_cpu_16(vlan_hdr_ptr->tci);
 	new_tci = old_tci;
 	if (vlan_marking->drop_eligible_enabled)
 		new_tci |= _ODP_VLANHDR_DEI_MASK;
@@ -1956,7 +1956,7 @@ static void egress_vlan_marking(tm_vlan_marking_t *vlan_marking,
 	if (new_tci == old_tci)
 		return;
 
-	vlan_hdr_ptr->tci = _odp_cpu_to_be_16(new_tci);
+	vlan_hdr_ptr->tci = odp_cpu_to_be_16(new_tci);
 	if (split_hdr)
 		_odp_packet_copy_from_mem(odp_pkt, _ODP_ETHHDR_LEN,
 					  _ODP_VLANHDR_LEN, &vlan_hdr);
@@ -2013,7 +2013,7 @@ static void egress_ipv4_tos_marking(tm_tos_marking_t *tos_marking,
 	 * in this specific case the carry out check does NOT need to be
 	 * repeated since it can be proven that the carry in sum cannot
 	 * cause another carry out. */
-	old_chksum     = (uint32_t)_odp_be_to_cpu_16(ipv4_hdr_ptr->chksum);
+	old_chksum     = (uint32_t)odp_be_to_cpu_16(ipv4_hdr_ptr->chksum);
 	ones_compl_sum = (~old_chksum) & 0xFFFF;
 	tos_diff       = ((uint32_t)new_tos) + ((~(uint32_t)old_tos) & 0xFFFF);
 	ones_compl_sum += tos_diff;
@@ -2022,7 +2022,7 @@ static void egress_ipv4_tos_marking(tm_tos_marking_t *tos_marking,
 				 (ones_compl_sum & 0xFFFF);
 
 	ipv4_hdr_ptr->tos    = new_tos;
-	ipv4_hdr_ptr->chksum = _odp_cpu_to_be_16((~ones_compl_sum) & 0xFFFF);
+	ipv4_hdr_ptr->chksum = odp_cpu_to_be_16((~ones_compl_sum) & 0xFFFF);
 	if (split_hdr)
 		_odp_packet_copy_from_mem(odp_pkt, l3_offset,
 					  _ODP_IPV4HDR_LEN, &ipv4_hdr);
@@ -2053,7 +2053,7 @@ static void egress_ipv6_tc_marking(tm_tos_marking_t *tos_marking,
 		ipv6_hdr_ptr = &ipv6_hdr;
 	}
 
-	old_ver_tc_flow = _odp_be_to_cpu_32(ipv6_hdr_ptr->ver_tc_flow);
+	old_ver_tc_flow = odp_be_to_cpu_32(ipv6_hdr_ptr->ver_tc_flow);
 	old_tc          = (old_ver_tc_flow & _ODP_IPV6HDR_TC_MASK)
 				>> _ODP_IPV6HDR_TC_SHIFT;
 	new_tc          = old_tc;
@@ -2074,7 +2074,7 @@ static void egress_ipv6_tc_marking(tm_tos_marking_t *tos_marking,
 
 	new_ver_tc_flow = (old_ver_tc_flow & ~_ODP_IPV6HDR_TC_MASK) |
 			  (new_tc << _ODP_IPV6HDR_TC_SHIFT);
-	ipv6_hdr_ptr->ver_tc_flow = _odp_cpu_to_be_32(new_ver_tc_flow);
+	ipv6_hdr_ptr->ver_tc_flow = odp_cpu_to_be_32(new_ver_tc_flow);
 
 	if (split_hdr)
 		_odp_packet_copy_from_mem(odp_pkt, l3_offset,
diff --git a/platform/linux-generic/pktio/dpdk_parse.c b/platform/linux-generic/pktio/dpdk_parse.c
index 155c68326..e9de0756a 100644
--- a/platform/linux-generic/pktio/dpdk_parse.c
+++ b/platform/linux-generic/pktio/dpdk_parse.c
@@ -47,16 +47,16 @@ static inline uint16_t dpdk_parse_eth(packet_parser_t *prs,
 		input_flags.jumbo = 1;
 
 	/* Handle Ethernet broadcast/multicast addresses */
-	macaddr0 = _odp_be_to_cpu_16(*((const uint16_t *)(const void *)eth));
+	macaddr0 = odp_be_to_cpu_16(*((const uint16_t *)(const void *)eth));
 	if (odp_unlikely((macaddr0 & 0x0100) == 0x0100))
 		input_flags.eth_mcast = 1;
 
 	if (odp_unlikely(macaddr0 == 0xffff)) {
 		macaddr2 =
-			_odp_be_to_cpu_16(*((const uint16_t *)
+			odp_be_to_cpu_16(*((const uint16_t *)
 					    (const void *)eth + 1));
 		macaddr4 =
-			_odp_be_to_cpu_16(*((const uint16_t *)
+			odp_be_to_cpu_16(*((const uint16_t *)
 					    (const void *)eth + 2));
 
 		if ((macaddr2 == 0xffff) && (macaddr4 == 0xffff))
@@ -72,13 +72,13 @@ static inline uint16_t dpdk_parse_eth(packet_parser_t *prs,
 		else if (RTE_ETH_IS_IPV6_HDR(mbuf_packet_type))
 			ethtype = _ODP_ETHTYPE_IPV6;
 		else
-			ethtype = _odp_be_to_cpu_16(eth->type);
+			ethtype = odp_be_to_cpu_16(eth->type);
 		break;
 	case RTE_PTYPE_L2_ETHER_VLAN:
 		ethtype = _ODP_ETHTYPE_VLAN;
 		break;
 	default:
-		ethtype = _odp_be_to_cpu_16(eth->type);
+		ethtype = odp_be_to_cpu_16(eth->type);
 	}
 
 	*offset += sizeof(*eth);
@@ -92,7 +92,7 @@ static inline uint16_t dpdk_parse_eth(packet_parser_t *prs,
 			ethtype = 0;
 			goto error;
 		}
-		ethtype = _odp_be_to_cpu_16(*((const uint16_t *)(uintptr_t)
+		ethtype = odp_be_to_cpu_16(*((const uint16_t *)(uintptr_t)
 					      (parseptr + 6)));
 		*offset   += 8;
 		*parseptr += 8;
@@ -104,7 +104,7 @@ static inline uint16_t dpdk_parse_eth(packet_parser_t *prs,
 		input_flags.vlan = 1;
 
 		vlan = (const _odp_vlanhdr_t *)*parseptr;
-		ethtype = _odp_be_to_cpu_16(vlan->type);
+		ethtype = odp_be_to_cpu_16(vlan->type);
 		*offset += sizeof(_odp_vlanhdr_t);
 		*parseptr += sizeof(_odp_vlanhdr_t);
 	}
@@ -112,7 +112,7 @@ static inline uint16_t dpdk_parse_eth(packet_parser_t *prs,
 	if (ethtype == _ODP_ETHTYPE_VLAN) {
 		input_flags.vlan = 1;
 		vlan = (const _odp_vlanhdr_t *)*parseptr;
-		ethtype = _odp_be_to_cpu_16(vlan->type);
+		ethtype = odp_be_to_cpu_16(vlan->type);
 		*offset += sizeof(_odp_vlanhdr_t);
 		*parseptr += sizeof(_odp_vlanhdr_t);
 	}
@@ -134,8 +134,8 @@ static inline uint8_t dpdk_parse_ipv4(packet_parser_t *prs,
 				      uint32_t do_csum)
 {
 	const _odp_ipv4hdr_t *ipv4 = (const _odp_ipv4hdr_t *)*parseptr;
-	uint32_t dstaddr = _odp_be_to_cpu_32(ipv4->dst_addr);
-	uint32_t l3_len = _odp_be_to_cpu_16(ipv4->tot_len);
+	uint32_t dstaddr = odp_be_to_cpu_32(ipv4->dst_addr);
+	uint32_t l3_len = odp_be_to_cpu_16(ipv4->tot_len);
 	uint8_t ver = _ODP_IPV4HDR_VER(ipv4->ver_ihl);
 	uint8_t ihl = _ODP_IPV4HDR_IHL(ipv4->ver_ihl);
 	uint32_t l4_packet_type = mbuf_packet_type & RTE_PTYPE_L4_MASK;
@@ -173,7 +173,7 @@ static inline uint8_t dpdk_parse_ipv4(packet_parser_t *prs,
 		proto = _ODP_IPPROTO_TCP;
 	} else {
 		proto = ipv4->proto;
-		frag_offset = _odp_be_to_cpu_16(ipv4->frag_offset);
+		frag_offset = odp_be_to_cpu_16(ipv4->frag_offset);
 
 		/* A packet is a fragment if:
 		*  "more fragments" flag is set (all fragments except the last)
@@ -205,13 +205,13 @@ static inline uint8_t dpdk_parse_ipv6(packet_parser_t *prs,
 {
 	const _odp_ipv6hdr_t *ipv6 = (const _odp_ipv6hdr_t *)*parseptr;
 	const _odp_ipv6hdr_ext_t *ipv6ext;
-	uint32_t dstaddr0 = _odp_be_to_cpu_32(ipv6->dst_addr.u8[0]);
-	uint32_t l3_len = _odp_be_to_cpu_16(ipv6->payload_len) +
+	uint32_t dstaddr0 = odp_be_to_cpu_32(ipv6->dst_addr.u8[0]);
+	uint32_t l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
 			  _ODP_IPV6HDR_LEN;
 	uint32_t l4_packet_type = mbuf_packet_type & RTE_PTYPE_L4_MASK;
 
 	/* Basic sanity checks on IPv6 header */
-	if ((_odp_be_to_cpu_32(ipv6->ver_tc_flow) >> 28) != 6 ||
+	if ((odp_be_to_cpu_32(ipv6->ver_tc_flow) >> 28) != 6 ||
 	    l3_len > frame_len - *offset) {
 		prs->flags.ip_err = 1;
 		return 0;
@@ -246,7 +246,7 @@ static inline uint8_t dpdk_parse_ipv6(packet_parser_t *prs,
 			 *offset < seg_len);
 
 		if (*offset >= prs->l3_offset +
-		    _odp_be_to_cpu_16(ipv6->payload_len)) {
+		    odp_be_to_cpu_16(ipv6->payload_len)) {
 			prs->flags.ip_err = 1;
 			return 0;
 		}
@@ -303,8 +303,8 @@ static inline void dpdk_parse_udp(packet_parser_t *prs,
 				  uint32_t do_csum)
 {
 	const _odp_udphdr_t *udp = (const _odp_udphdr_t *)*parseptr;
-	uint32_t udplen = _odp_be_to_cpu_16(udp->length);
-	uint16_t ipsec_port = _odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
+	uint32_t udplen = odp_be_to_cpu_16(udp->length);
+	uint16_t ipsec_port = odp_cpu_to_be_16(_ODP_UDP_IPSEC_PORT);
 
 	if (odp_unlikely(udplen < sizeof(_odp_udphdr_t)))
 		prs->flags.udp_err = 1;
diff --git a/platform/linux-generic/pktio/loop.c b/platform/linux-generic/pktio/loop.c
index 99b09e6ac..5e30447fa 100644
--- a/platform/linux-generic/pktio/loop.c
+++ b/platform/linux-generic/pktio/loop.c
@@ -188,7 +188,7 @@ static inline int check_proto(void *l3_hdr,
 
 	if (l3_proto_ver == _ODP_IPV4 && l3_len >= _ODP_IPV4HDR_LEN) {
 		_odp_ipv4hdr_t *ip = l3_hdr;
-		uint16_t frag_offset = _odp_be_to_cpu_16(ip->frag_offset);
+		uint16_t frag_offset = odp_be_to_cpu_16(ip->frag_offset);
 
 		*l3_proto_v4 = 1;
 		if (!_ODP_IPV4HDR_IS_FRAGMENT(frag_offset))