linux-gen: queue: remove internal queue handle conversions

Use odp_queue_t as internal queue handle. This simplifies internal
queue interface as intermediate type (void *q_int) and additional
conversions (from_ext() and to_ext()) are not needed. Queue handle
stores pointer to queue entry as before. Conversion is a simple cast
(nop as an inline function) for both queue implementations.

Signed-off-by: Petri Savolainen <petri.savolainen@linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer@linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org>

20 files changed, 169 insertions, 200 deletions

diff --git a/platform/linux-generic/include/odp_packet_internal.h b/platform/linux-generic/include/odp_packet_internal.h
index cd2db2ecd..4b5127d93 100644
--- a/platform/linux-generic/include/odp_packet_internal.h
+++ b/platform/linux-generic/include/odp_packet_internal.h
@@ -105,7 +105,7 @@ typedef struct {
 	odp_time_t timestamp;
 
 	/* Classifier destination queue */
-	void *dst_queue;
+	odp_queue_t dst_queue;
 
 	/* Result for crypto packet op */
 	odp_crypto_packet_result_t crypto_op_result;
diff --git a/platform/linux-generic/include/odp_packet_io_internal.h b/platform/linux-generic/include/odp_packet_io_internal.h
index d2446d19f..080850783 100644
--- a/platform/linux-generic/include/odp_packet_io_internal.h
+++ b/platform/linux-generic/include/odp_packet_io_internal.h
@@ -105,7 +105,6 @@ struct pktio_entry {
 
 	struct {
 		odp_queue_t        queue;
-		void              *queue_int;
 		odp_pktin_queue_t  pktin;
 	} in_queue[PKTIO_MAX_QUEUES];
 
diff --git a/platform/linux-generic/include/odp_queue_basic_internal.h b/platform/linux-generic/include/odp_queue_basic_internal.h
index 654b9e312..369eb19a1 100644
--- a/platform/linux-generic/include/odp_queue_basic_internal.h
+++ b/platform/linux-generic/include/odp_queue_basic_internal.h
@@ -96,6 +96,11 @@ static inline odp_queue_t queue_from_index(uint32_t queue_id)
 	return (odp_queue_t)qentry_from_index(queue_id);
 }
 
+static inline queue_entry_t *qentry_from_handle(odp_queue_t handle)
+{
+	return (queue_entry_t *)(uintptr_t)handle;
+}
+
 void queue_spsc_init(queue_entry_t *queue, uint32_t queue_size);
 
 /* Functions for schedulers */
diff --git a/platform/linux-generic/include/odp_queue_if.h b/platform/linux-generic/include/odp_queue_if.h
index f89690bd7..7c7649219 100644
--- a/platform/linux-generic/include/odp_queue_if.h
+++ b/platform/linux-generic/include/odp_queue_if.h
@@ -22,19 +22,19 @@ typedef int (*queue_init_global_fn_t)(void);
 typedef int (*queue_term_global_fn_t)(void);
 typedef int (*queue_init_local_fn_t)(void);
 typedef int (*queue_term_local_fn_t)(void);
-typedef void *(*queue_from_ext_fn_t)(odp_queue_t handle);
-typedef odp_queue_t (*queue_to_ext_fn_t)(void *q_int);
-typedef int (*queue_enq_fn_t)(void *q_int, odp_buffer_hdr_t *);
-typedef int (*queue_enq_multi_fn_t)(void *q_int, odp_buffer_hdr_t **, int);
-typedef odp_buffer_hdr_t *(*queue_deq_fn_t)(void *q_int);
-typedef int (*queue_deq_multi_fn_t)(void *q_int, odp_buffer_hdr_t **, int);
-typedef odp_pktout_queue_t (*queue_get_pktout_fn_t)(void *q_int);
-typedef void (*queue_set_pktout_fn_t)(void *q_int, odp_pktio_t pktio,
+typedef int (*queue_enq_fn_t)(odp_queue_t queue, odp_buffer_hdr_t *buf_hdr);
+typedef int (*queue_enq_multi_fn_t)(odp_queue_t queue,
+				    odp_buffer_hdr_t **buf_hdr, int num);
+typedef odp_buffer_hdr_t *(*queue_deq_fn_t)(odp_queue_t queue);
+typedef int (*queue_deq_multi_fn_t)(odp_queue_t queue,
+				    odp_buffer_hdr_t **buf_hdr, int num);
+typedef odp_pktout_queue_t (*queue_get_pktout_fn_t)(odp_queue_t queue);
+typedef void (*queue_set_pktout_fn_t)(odp_queue_t queue, odp_pktio_t pktio,
 				      int index);
-typedef odp_pktin_queue_t (*queue_get_pktin_fn_t)(void *q_int);
-typedef void (*queue_set_pktin_fn_t)(void *q_int, odp_pktio_t pktio,
+typedef odp_pktin_queue_t (*queue_get_pktin_fn_t)(odp_queue_t queue);
+typedef void (*queue_set_pktin_fn_t)(odp_queue_t queue, odp_pktio_t pktio,
 				     int index);
-typedef void (*queue_set_enq_deq_fn_t)(void *q_int,
+typedef void (*queue_set_enq_deq_fn_t)(odp_queue_t queue,
 				       queue_enq_fn_t enq,
 				       queue_enq_multi_fn_t enq_multi,
 				       queue_deq_fn_t deq,
@@ -46,8 +46,6 @@ typedef struct {
 	queue_term_global_fn_t term_global;
 	queue_init_local_fn_t init_local;
 	queue_term_local_fn_t term_local;
-	queue_from_ext_fn_t from_ext;
-	queue_to_ext_fn_t to_ext;
 	queue_enq_fn_t enq;
 	queue_enq_multi_fn_t enq_multi;
 	queue_deq_fn_t deq;
diff --git a/platform/linux-generic/include/odp_queue_scalable_internal.h b/platform/linux-generic/include/odp_queue_scalable_internal.h
index 71aaa3ba7..cc5b52191 100644
--- a/platform/linux-generic/include/odp_queue_scalable_internal.h
+++ b/platform/linux-generic/include/odp_queue_scalable_internal.h
@@ -80,14 +80,14 @@ static inline uint32_t queue_to_id(odp_queue_t handle)
 	return qentry_from_ext(handle)->s.index;
 }
 
-static inline queue_entry_t *qentry_from_int(void *handle)
+static inline queue_entry_t *qentry_from_int(odp_queue_t handle)
 {
-	return (queue_entry_t *)handle;
+	return (queue_entry_t *)(uintptr_t)handle;
 }
 
-static inline void *qentry_to_int(queue_entry_t *qentry)
+static inline odp_queue_t qentry_to_int(queue_entry_t *qentry)
 {
-	return qentry;
+	return (odp_queue_t)qentry;
 }
 
 static inline odp_queue_t queue_get_handle(queue_entry_t *queue)
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index 8f082aaaf..30481773d 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -32,7 +32,7 @@ typedef int (*schedule_init_queue_fn_t)(uint32_t queue_index,
 typedef void (*schedule_destroy_queue_fn_t)(uint32_t queue_index);
 typedef int (*schedule_sched_queue_fn_t)(uint32_t queue_index);
 typedef int (*schedule_unsched_queue_fn_t)(uint32_t queue_index);
-typedef int (*schedule_ord_enq_multi_fn_t)(void *q_int,
+typedef int (*schedule_ord_enq_multi_fn_t)(odp_queue_t queue,
 					   void *buf_hdr[], int num, int *ret);
 typedef int (*schedule_init_global_fn_t)(void);
 typedef int (*schedule_term_global_fn_t)(void);
diff --git a/platform/linux-generic/include/odp_traffic_mngr_internal.h b/platform/linux-generic/include/odp_traffic_mngr_internal.h
index 919831a3d..770a64900 100644
--- a/platform/linux-generic/include/odp_traffic_mngr_internal.h
+++ b/platform/linux-generic/include/odp_traffic_mngr_internal.h
@@ -282,7 +282,7 @@ struct tm_queue_obj_s {
 	uint8_t tm_idx;
 	uint8_t delayed_cnt;
 	uint8_t blocked_cnt;
-	void *tm_qentry;
+	odp_queue_t queue;
 };
 
 struct tm_node_obj_s {
diff --git a/platform/linux-generic/odp_classification.c b/platform/linux-generic/odp_classification.c
index 70e8def69..d02fb5070 100644
--- a/platform/linux-generic/odp_classification.c
+++ b/platform/linux-generic/odp_classification.c
@@ -1036,7 +1036,7 @@ int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base,
 	pkt_hdr->p.input_flags.dst_queue = 1;
 
 	if (!cos->s.queue_group) {
-		pkt_hdr->dst_queue = queue_fn->from_ext(cos->s.queue);
+		pkt_hdr->dst_queue = cos->s.queue;
 		return 0;
 	}
 
@@ -1045,8 +1045,7 @@ int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base,
 	hash = hash & (CLS_COS_QUEUE_MAX - 1);
 	tbl_index = (cos->s.index * CLS_COS_QUEUE_MAX) + (hash %
 							  cos->s.num_queue);
-	pkt_hdr->dst_queue = queue_fn->from_ext(queue_grp_tbl->
-						s.queue[tbl_index]);
+	pkt_hdr->dst_queue = queue_grp_tbl->s.queue[tbl_index];
 	return 0;
 }
 
diff --git a/platform/linux-generic/odp_ipsec.c b/platform/linux-generic/odp_ipsec.c
index 5b739cc1a..36bea6cf8 100644
--- a/platform/linux-generic/odp_ipsec.c
+++ b/platform/linux-generic/odp_ipsec.c
@@ -1745,7 +1745,7 @@ int _odp_ipsec_try_inline(odp_packet_t *pkt)
 
 	pkt_hdr = packet_hdr(*pkt);
 	pkt_hdr->p.input_flags.dst_queue = 1;
-	pkt_hdr->dst_queue = queue_fn->from_ext(ipsec_sa->queue);
+	pkt_hdr->dst_queue = ipsec_sa->queue;
 
 	/* Last thing */
 	_odp_ipsec_sa_unuse(ipsec_sa);
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 7759f83e4..a10aaf10c 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -137,7 +137,6 @@ static void init_in_queues(pktio_entry_t *entry)
 
 	for (i = 0; i < PKTIO_MAX_QUEUES; i++) {
 		entry->s.in_queue[i].queue = ODP_QUEUE_INVALID;
-		entry->s.in_queue[i].queue_int = NULL;
 		entry->s.in_queue[i].pktin = PKTIN_INVALID;
 	}
 }
@@ -327,7 +326,6 @@ static void destroy_in_queues(pktio_entry_t *entry, int num)
 		if (entry->s.in_queue[i].queue != ODP_QUEUE_INVALID) {
 			odp_queue_destroy(entry->s.in_queue[i].queue);
 			entry->s.in_queue[i].queue = ODP_QUEUE_INVALID;
-			entry->s.in_queue[i].queue_int = NULL;
 		}
 	}
 }
@@ -637,46 +635,47 @@ static inline int pktin_recv_buf(pktio_entry_t *entry, int pktin_index,
 	return num_rx;
 }
 
-static int pktout_enqueue(void *q_int, odp_buffer_hdr_t *buf_hdr)
+static int pktout_enqueue(odp_queue_t queue, odp_buffer_hdr_t *buf_hdr)
 {
 	odp_packet_t pkt = packet_from_buf_hdr(buf_hdr);
 	int len = 1;
 	int nbr;
 
-	if (sched_fn->ord_enq_multi(q_int, (void **)buf_hdr, len, &nbr))
+	if (sched_fn->ord_enq_multi(queue, (void **)buf_hdr, len, &nbr))
 		return (nbr == len ? 0 : -1);
 
-	nbr = odp_pktout_send(queue_fn->get_pktout(q_int), &pkt, len);
+	nbr = odp_pktout_send(queue_fn->get_pktout(queue), &pkt, len);
 	return (nbr == len ? 0 : -1);
 }
 
-static int pktout_enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[], int num)
+static int pktout_enq_multi(odp_queue_t queue, odp_buffer_hdr_t *buf_hdr[],
+			    int num)
 {
 	odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
 	int nbr;
 	int i;
 
-	if (sched_fn->ord_enq_multi(q_int, (void **)buf_hdr, num, &nbr))
+	if (sched_fn->ord_enq_multi(queue, (void **)buf_hdr, num, &nbr))
 		return nbr;
 
 	for (i = 0; i < num; ++i)
 		pkt_tbl[i] = packet_from_buf_hdr(buf_hdr[i]);
 
-	nbr = odp_pktout_send(queue_fn->get_pktout(q_int), pkt_tbl, num);
+	nbr = odp_pktout_send(queue_fn->get_pktout(queue), pkt_tbl, num);
 	return nbr;
 }
 
-static odp_buffer_hdr_t *pktin_dequeue(void *q_int)
+static odp_buffer_hdr_t *pktin_dequeue(odp_queue_t queue)
 {
 	odp_buffer_hdr_t *buf_hdr;
 	odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
 	int pkts;
-	odp_pktin_queue_t pktin_queue = queue_fn->get_pktin(q_int);
+	odp_pktin_queue_t pktin_queue = queue_fn->get_pktin(queue);
 	odp_pktio_t pktio = pktin_queue.pktio;
 	int pktin_index   = pktin_queue.index;
 	pktio_entry_t *entry = get_pktio_entry(pktio);
 
-	buf_hdr = queue_fn->deq(q_int);
+	buf_hdr = queue_fn->deq(queue);
 	if (buf_hdr != NULL)
 		return buf_hdr;
 
@@ -689,7 +688,7 @@ static odp_buffer_hdr_t *pktin_dequeue(void *q_int)
 		int num_enq;
 		int num = pkts - 1;
 
-		num_enq = queue_fn->enq_multi(q_int, &hdr_tbl[1], num);
+		num_enq = queue_fn->enq_multi(queue, &hdr_tbl[1], num);
 
 		if (odp_unlikely(num_enq < num)) {
 			if (odp_unlikely(num_enq < 0))
@@ -705,17 +704,18 @@ static odp_buffer_hdr_t *pktin_dequeue(void *q_int)
 	return buf_hdr;
 }
 
-static int pktin_deq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[], int num)
+static int pktin_deq_multi(odp_queue_t queue, odp_buffer_hdr_t *buf_hdr[],
+			   int num)
 {
 	int nbr;
 	odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
 	int pkts, i, j;
-	odp_pktin_queue_t pktin_queue = queue_fn->get_pktin(q_int);
+	odp_pktin_queue_t pktin_queue = queue_fn->get_pktin(queue);
 	odp_pktio_t pktio = pktin_queue.pktio;
 	int pktin_index   = pktin_queue.index;
 	pktio_entry_t *entry = get_pktio_entry(pktio);
 
-	nbr = queue_fn->deq_multi(q_int, buf_hdr, num);
+	nbr = queue_fn->deq_multi(queue, buf_hdr, num);
 	if (odp_unlikely(nbr > num))
 		ODP_ABORT("queue_deq_multi req: %d, returned %d\n", num, nbr);
 
@@ -740,7 +740,7 @@ static int pktin_deq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[], int num)
 	if (j) {
 		int num_enq;
 
-		num_enq = queue_fn->enq_multi(q_int, hdr_tbl, j);
+		num_enq = queue_fn->enq_multi(queue, hdr_tbl, j);
 
 		if (odp_unlikely(num_enq < j)) {
 			if (odp_unlikely(num_enq < 0))
@@ -765,7 +765,7 @@ int sched_cb_pktin_poll_one(int pktio_index,
 	odp_packet_hdr_t *pkt_hdr;
 	odp_buffer_hdr_t *buf_hdr;
 	odp_packet_t packets[QUEUE_MULTI_MAX];
-	void *q_int;
+	odp_queue_t queue;
 
 	if (odp_unlikely(entry->s.state != PKTIO_STATE_STARTED)) {
 		if (entry->s.state < PKTIO_STATE_ACTIVE ||
@@ -785,9 +785,9 @@ int sched_cb_pktin_poll_one(int pktio_index,
 		pkt = packets[i];
 		pkt_hdr = packet_hdr(pkt);
 		if (odp_unlikely(pkt_hdr->p.input_flags.dst_queue)) {
-			q_int = pkt_hdr->dst_queue;
+			queue = pkt_hdr->dst_queue;
 			buf_hdr = packet_to_buf_hdr(pkt);
-			if (queue_fn->enq_multi(q_int, &buf_hdr, 1) < 0) {
+			if (queue_fn->enq_multi(queue, &buf_hdr, 1) < 0) {
 				/* Queue full? */
 				odp_packet_free(pkt);
 				__atomic_fetch_add(&entry->s.stats.in_discards,
@@ -836,7 +836,7 @@ int sched_cb_pktin_poll_old(int pktio_index, int num_queue, int index[])
 	}
 
 	for (idx = 0; idx < num_queue; idx++) {
-		void *q_int;
+		odp_queue_t queue;
 		int num_enq;
 
 		num = pktin_recv_buf(entry, index[idx], hdr_tbl,
@@ -850,8 +850,8 @@ int sched_cb_pktin_poll_old(int pktio_index, int num_queue, int index[])
 			return -1;
 		}
 
-		q_int = entry->s.in_queue[index[idx]].queue_int;
-		num_enq = queue_fn->enq_multi(q_int, hdr_tbl, num);
+		queue = entry->s.in_queue[index[idx]].queue;
+		num_enq = queue_fn->enq_multi(queue, hdr_tbl, num);
 
 		if (odp_unlikely(num_enq < num)) {
 			if (odp_unlikely(num_enq < 0))
@@ -1371,31 +1371,37 @@ int odp_pktio_stats_reset(odp_pktio_t pktio)
 	return ret;
 }
 
-static int abort_pktin_enqueue(void *q_int ODP_UNUSED,
-			       odp_buffer_hdr_t *buf_hdr ODP_UNUSED)
+static int abort_pktin_enqueue(odp_queue_t queue, odp_buffer_hdr_t *buf_hdr)
 {
+	(void)queue;
+	(void)buf_hdr;
 	ODP_ABORT("attempted enqueue to a pktin queue");
 	return -1;
 }
 
-static int abort_pktin_enq_multi(void *q_int ODP_UNUSED,
-				 odp_buffer_hdr_t *buf_hdr[] ODP_UNUSED,
-				 int num ODP_UNUSED)
+static int abort_pktin_enq_multi(odp_queue_t queue,
+				 odp_buffer_hdr_t *buf_hdr[], int num)
 {
+	(void)queue;
+	(void)buf_hdr;
+	(void)num;
 	ODP_ABORT("attempted enqueue to a pktin queue");
 	return 0;
 }
 
-static odp_buffer_hdr_t *abort_pktout_dequeue(void *q_int ODP_UNUSED)
+static odp_buffer_hdr_t *abort_pktout_dequeue(odp_queue_t queue)
 {
+	(void)queue;
 	ODP_ABORT("attempted dequeue from a pktout queue");
 	return NULL;
 }
 
-static int abort_pktout_deq_multi(void *q_int ODP_UNUSED,
-				  odp_buffer_hdr_t *buf_hdr[] ODP_UNUSED,
-				  int num ODP_UNUSED)
+static int abort_pktout_deq_multi(odp_queue_t queue,
+				  odp_buffer_hdr_t *buf_hdr[], int num)
 {
+	(void)queue;
+	(void)buf_hdr;
+	(void)num;
 	ODP_ABORT("attempted dequeue from a pktout queue");
 	return 0;
 }
@@ -1410,7 +1416,6 @@ int odp_pktin_queue_config(odp_pktio_t pktio,
 	unsigned i;
 	int rc;
 	odp_queue_t queue;
-	void *q_int;
 	odp_pktin_queue_param_t default_param;
 
 	if (param == NULL) {
@@ -1490,11 +1495,9 @@ int odp_pktin_queue_config(odp_pktio_t pktio,
 				return -1;
 			}
 
-			q_int = queue_fn->from_ext(queue);
-
 			if (mode == ODP_PKTIN_MODE_QUEUE) {
-				queue_fn->set_pktin(q_int, pktio, i);
-				queue_fn->set_enq_deq_fn(q_int,
+				queue_fn->set_pktin(queue, pktio, i);
+				queue_fn->set_enq_deq_fn(queue,
 							 abort_pktin_enqueue,
 							 abort_pktin_enq_multi,
 							 pktin_dequeue,
@@ -1502,11 +1505,9 @@ int odp_pktin_queue_config(odp_pktio_t pktio,
 			}
 
 			entry->s.in_queue[i].queue = queue;
-			entry->s.in_queue[i].queue_int = q_int;
 
 		} else {
 			entry->s.in_queue[i].queue = ODP_QUEUE_INVALID;
-			entry->s.in_queue[i].queue_int = NULL;
 		}
 
 		entry->s.in_queue[i].pktin.index = i;
@@ -1598,7 +1599,6 @@ int odp_pktout_queue_config(odp_pktio_t pktio,
 		for (i = 0; i < num_queues; i++) {
 			odp_queue_t queue;
 			odp_queue_param_t queue_param;
-			void *q_int;
 			char name[ODP_QUEUE_NAME_LEN];
 			int pktio_id = odp_pktio_index(pktio);
 
@@ -1618,11 +1618,10 @@ int odp_pktout_queue_config(odp_pktio_t pktio,
 				return -1;
 			}
 
-			q_int = queue_fn->from_ext(queue);
-			queue_fn->set_pktout(q_int, pktio, i);
+			queue_fn->set_pktout(queue, pktio, i);
 
 			/* Override default enqueue / dequeue functions */
-			queue_fn->set_enq_deq_fn(q_int,
+			queue_fn->set_enq_deq_fn(queue,
 						 pktout_enqueue,
 						 pktout_enq_multi,
 						 abort_pktout_dequeue,
diff --git a/platform/linux-generic/odp_queue_basic.c b/platform/linux-generic/odp_queue_basic.c
index 3f57a23db..2b3b6dfc4 100644
--- a/platform/linux-generic/odp_queue_basic.c
+++ b/platform/linux-generic/odp_queue_basic.c
@@ -47,11 +47,6 @@ static int queue_init(queue_entry_t *queue, const char *name,
 queue_global_t *queue_glb;
 extern _odp_queue_inline_offset_t _odp_queue_inline_offset;
 
-static inline queue_entry_t *qentry_from_handle(odp_queue_t handle)
-{
-	return (queue_entry_t *)(uintptr_t)handle;
-}
-
 static int queue_capa(odp_queue_capability_t *capa, int sched)
 {
 	memset(capa, 0, sizeof(odp_queue_capability_t));
@@ -489,7 +484,7 @@ static inline void buffer_index_to_buf(odp_buffer_hdr_t *buf_hdr[],
 	}
 }
 
-static inline int enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
+static inline int enq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 			    int num)
 {
 	int sched = 0;
@@ -499,10 +494,10 @@ static inline int enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
 	ring_st_t *ring_st;
 	uint32_t buf_idx[num];
 
-	queue = q_int;
+	queue = qentry_from_handle(handle);
 	ring_st = &queue->s.ring_st;
 
-	if (sched_fn->ord_enq_multi(q_int, (void **)buf_hdr, num, &ret))
+	if (sched_fn->ord_enq_multi(handle, (void **)buf_hdr, num, &ret))
 		return ret;
 
 	buffer_index_from_buf(buf_idx, buf_hdr, num);
@@ -536,17 +531,17 @@ static inline int enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
 	return num_enq;
 }
 
-static int queue_int_enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
+static int queue_int_enq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 			       int num)
 {
-	return enq_multi(q_int, buf_hdr, num);
+	return enq_multi(handle, buf_hdr, num);
 }
 
-static int queue_int_enq(void *q_int, odp_buffer_hdr_t *buf_hdr)
+static int queue_int_enq(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr)
 {
 	int ret;
 
-	ret = enq_multi(q_int, &buf_hdr, 1);
+	ret = enq_multi(handle, &buf_hdr, 1);
 
 	if (ret == 1)
 		return 0;
@@ -564,7 +559,7 @@ static int queue_enq_multi(odp_queue_t handle, const odp_event_t ev[], int num)
 	if (num > QUEUE_MULTI_MAX)
 		num = QUEUE_MULTI_MAX;
 
-	return queue->s.enqueue_multi(queue,
+	return queue->s.enqueue_multi(handle,
 				      (odp_buffer_hdr_t **)(uintptr_t)ev, num);
 }
 
@@ -572,17 +567,19 @@ static int queue_enq(odp_queue_t handle, odp_event_t ev)
 {
 	queue_entry_t *queue = qentry_from_handle(handle);
 
-	return queue->s.enqueue(queue,
+	return queue->s.enqueue(handle,
 				(odp_buffer_hdr_t *)(uintptr_t)ev);
 }
 
-static inline int plain_queue_deq(queue_entry_t *queue,
+static inline int plain_queue_deq(odp_queue_t handle,
 				  odp_buffer_hdr_t *buf_hdr[], int num)
 {
 	int num_deq;
+	queue_entry_t *queue;
 	ring_st_t *ring_st;
 	uint32_t buf_idx[num];
 
+	queue = qentry_from_handle(handle);
 	ring_st = &queue->s.ring_st;
 
 	LOCK(queue);
@@ -605,21 +602,18 @@ static inline int plain_queue_deq(queue_entry_t *queue,
 	return num_deq;
 }
 
-static int queue_int_deq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
+static int queue_int_deq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 			       int num)
 {
-	queue_entry_t *queue = q_int;
-
-	return plain_queue_deq(queue, buf_hdr, num);
+	return plain_queue_deq(handle, buf_hdr, num);
 }
 
-static odp_buffer_hdr_t *queue_int_deq(void *q_int)
+static odp_buffer_hdr_t *queue_int_deq(odp_queue_t handle)
 {
-	queue_entry_t *queue = q_int;
 	odp_buffer_hdr_t *buf_hdr = NULL;
 	int ret;
 
-	ret = plain_queue_deq(queue, &buf_hdr, 1);
+	ret = plain_queue_deq(handle, &buf_hdr, 1);
 
 	if (ret == 1)
 		return buf_hdr;
@@ -634,7 +628,7 @@ static int queue_deq_multi(odp_queue_t handle, odp_event_t ev[], int num)
 	if (num > QUEUE_MULTI_MAX)
 		num = QUEUE_MULTI_MAX;
 
-	return queue->s.dequeue_multi(queue,
+	return queue->s.dequeue_multi(handle,
 				      (odp_buffer_hdr_t **)ev, num);
 }
 
@@ -642,7 +636,7 @@ static odp_event_t queue_deq(odp_queue_t handle)
 {
 	queue_entry_t *queue = qentry_from_handle(handle);
 
-	return (odp_event_t)queue->s.dequeue(queue);
+	return (odp_event_t)queue->s.dequeue(handle);
 }
 
 static int queue_init(queue_entry_t *queue, const char *name,
@@ -838,43 +832,43 @@ static uint64_t queue_to_u64(odp_queue_t hdl)
 	return _odp_pri(hdl);
 }
 
-static odp_pktout_queue_t queue_get_pktout(void *q_int)
+static odp_pktout_queue_t queue_get_pktout(odp_queue_t handle)
 {
-	queue_entry_t *qentry = q_int;
+	queue_entry_t *qentry = qentry_from_handle(handle);
 
 	return qentry->s.pktout;
 }
 
-static void queue_set_pktout(void *q_int, odp_pktio_t pktio, int index)
+static void queue_set_pktout(odp_queue_t handle, odp_pktio_t pktio, int index)
 {
-	queue_entry_t *qentry = q_int;
+	queue_entry_t *qentry = qentry_from_handle(handle);
 
 	qentry->s.pktout.pktio = pktio;
 	qentry->s.pktout.index = index;
 }
 
-static odp_pktin_queue_t queue_get_pktin(void *q_int)
+static odp_pktin_queue_t queue_get_pktin(odp_queue_t handle)
 {
-	queue_entry_t *qentry = q_int;
+	queue_entry_t *qentry = qentry_from_handle(handle);
 
 	return qentry->s.pktin;
 }
 
-static void queue_set_pktin(void *q_int, odp_pktio_t pktio, int index)
+static void queue_set_pktin(odp_queue_t handle, odp_pktio_t pktio, int index)
 {
-	queue_entry_t *qentry = q_int;
+	queue_entry_t *qentry = qentry_from_handle(handle);
 
 	qentry->s.pktin.pktio = pktio;
 	qentry->s.pktin.index = index;
 }
 
-static void queue_set_enq_deq_func(void *q_int,
+static void queue_set_enq_deq_func(odp_queue_t handle,
 				   queue_enq_fn_t enq,
 				   queue_enq_multi_fn_t enq_multi,
 				   queue_deq_fn_t deq,
 				   queue_deq_multi_fn_t deq_multi)
 {
-	queue_entry_t *qentry = q_int;
+	queue_entry_t *qentry = qentry_from_handle(handle);
 
 	if (enq)
 		qentry->s.enqueue = enq;
@@ -889,18 +883,6 @@ static void queue_set_enq_deq_func(void *q_int,
 		qentry->s.dequeue_multi = deq_multi;
 }
 
-static void *queue_from_ext(odp_queue_t handle)
-{
-	return qentry_from_handle(handle);
-}
-
-static odp_queue_t queue_to_ext(void *q_int)
-{
-	queue_entry_t *qentry = q_int;
-
-	return qentry->s.handle;
-}
-
 /* API functions */
 _odp_queue_api_fn_t queue_basic_api = {
 	.queue_create = queue_create,
@@ -928,8 +910,6 @@ queue_fn_t queue_basic_fn = {
 	.term_global = queue_term_global,
 	.init_local = queue_init_local,
 	.term_local = queue_term_local,
-	.from_ext = queue_from_ext,
-	.to_ext = queue_to_ext,
 	.enq = queue_int_enq,
 	.enq_multi = queue_int_enq_multi,
 	.deq = queue_int_deq,
diff --git a/platform/linux-generic/odp_queue_lf.c b/platform/linux-generic/odp_queue_lf.c
index d12a994be..a28da2c73 100644
--- a/platform/linux-generic/odp_queue_lf.c
+++ b/platform/linux-generic/odp_queue_lf.c
@@ -162,7 +162,7 @@ static inline int next_idx(int idx)
 	return next;
 }
 
-static int queue_lf_enq(void *q_int, odp_buffer_hdr_t *buf_hdr)
+static int queue_lf_enq(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr)
 {
 	queue_entry_t *queue;
 	queue_lf_t *queue_lf;
@@ -172,7 +172,7 @@ static int queue_lf_enq(void *q_int, odp_buffer_hdr_t *buf_hdr)
 	ring_lf_node_t new_val;
 	ring_lf_node_t *node;
 
-	queue    = q_int;
+	queue    = qentry_from_handle(handle);
 	queue_lf = queue->s.queue_lf;
 
 	new_val.s.ptr     = (uintptr_t)buf_hdr;
@@ -209,18 +209,18 @@ static int queue_lf_enq(void *q_int, odp_buffer_hdr_t *buf_hdr)
 	return -1;
 }
 
-static int queue_lf_enq_multi(void *q_int, odp_buffer_hdr_t **buf_hdr,
+static int queue_lf_enq_multi(odp_queue_t handle, odp_buffer_hdr_t **buf_hdr,
 			      int num)
 {
 	(void)num;
 
-	if (queue_lf_enq(q_int, buf_hdr[0]) == 0)
+	if (queue_lf_enq(handle, buf_hdr[0]) == 0)
 		return 1;
 
 	return 0;
 }
 
-static odp_buffer_hdr_t *queue_lf_deq(void *q_int)
+static odp_buffer_hdr_t *queue_lf_deq(odp_queue_t handle)
 {
 	queue_entry_t *queue;
 	queue_lf_t *queue_lf;
@@ -231,7 +231,7 @@ static odp_buffer_hdr_t *queue_lf_deq(void *q_int)
 	uint64_t lowest, counter;
 	odp_buffer_hdr_t *buf_hdr;
 
-	queue    = q_int;
+	queue    = qentry_from_handle(handle);
 	queue_lf = queue->s.queue_lf;
 	new_val.s.counter = 0;
 	new_val.s.ptr     = 0;
@@ -287,14 +287,14 @@ static odp_buffer_hdr_t *queue_lf_deq(void *q_int)
 	return NULL;
 }
 
-static int queue_lf_deq_multi(void *q_int, odp_buffer_hdr_t **buf_hdr,
+static int queue_lf_deq_multi(odp_queue_t handle, odp_buffer_hdr_t **buf_hdr,
 			      int num)
 {
 	odp_buffer_hdr_t *buf;
 
 	(void)num;
 
-	buf = queue_lf_deq(q_int);
+	buf = queue_lf_deq(handle);
 
 	if (buf == NULL)
 		return 0;
diff --git a/platform/linux-generic/odp_queue_scalable.c b/platform/linux-generic/odp_queue_scalable.c
index 3ca865b05..5ac0c196a 100644
--- a/platform/linux-generic/odp_queue_scalable.c
+++ b/platform/linux-generic/odp_queue_scalable.c
@@ -54,12 +54,11 @@ typedef struct queue_table_t {
 static queue_table_t *queue_tbl;
 static _odp_ishm_pool_t *queue_shm_pool;
 
-static void *queue_from_ext(odp_queue_t handle);
-static int _queue_enq(void *handle, odp_buffer_hdr_t *buf_hdr);
-static odp_buffer_hdr_t *_queue_deq(void *handle);
-static int _queue_enq_multi(void *handle, odp_buffer_hdr_t *buf_hdr[],
+static int _queue_enq(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr);
+static odp_buffer_hdr_t *_queue_deq(odp_queue_t handle);
+static int _queue_enq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 			    int num);
-static int _queue_deq_multi(void *handle, odp_buffer_hdr_t *buf_hdr[],
+static int _queue_deq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 			    int num);
 
 static queue_entry_t *get_qentry(uint32_t queue_id)
@@ -610,7 +609,7 @@ int _odp_queue_enq_sp(sched_elem_t *q,
 	return actual;
 }
 
-static int _queue_enq_multi(void *handle, odp_buffer_hdr_t *buf_hdr[],
+static int _queue_enq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 			    int num)
 {
 	int actual;
@@ -646,7 +645,7 @@ static int _queue_enq_multi(void *handle, odp_buffer_hdr_t *buf_hdr[],
 	return actual;
 }
 
-static int _queue_enq(void *handle, odp_buffer_hdr_t *buf_hdr)
+static int _queue_enq(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr)
 {
 	return odp_likely(
 		_queue_enq_multi(handle, &buf_hdr, 1) == 1) ? 0 : -1;
@@ -666,7 +665,7 @@ static int queue_enq_multi(odp_queue_t handle, const odp_event_t ev[], int num)
 	for (i = 0; i < num; i++)
 		buf_hdr[i] = buf_hdl_to_hdr(odp_buffer_from_event(ev[i]));
 
-	return queue->s.enqueue_multi(qentry_to_int(queue), buf_hdr, num);
+	return queue->s.enqueue_multi(handle, buf_hdr, num);
 }
 
 static int queue_enq(odp_queue_t handle, odp_event_t ev)
@@ -677,7 +676,7 @@ static int queue_enq(odp_queue_t handle, odp_event_t ev)
 	queue   = qentry_from_ext(handle);
 	buf_hdr = buf_hdl_to_hdr(odp_buffer_from_event(ev));
 
-	return queue->s.enqueue(qentry_to_int(queue), buf_hdr);
+	return queue->s.enqueue(handle, buf_hdr);
 }
 
 /* Single-consumer dequeue. */
@@ -809,7 +808,7 @@ inline int _odp_queue_deq_mc(sched_elem_t *q, odp_event_t *evp, int num)
 	return ret;
 }
 
-static int _queue_deq_multi(void *handle, odp_buffer_hdr_t *buf_hdr[],
+static int _queue_deq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 			    int num)
 {
 	sched_elem_t *q;
@@ -820,7 +819,7 @@ static int _queue_deq_multi(void *handle, odp_buffer_hdr_t *buf_hdr[],
 	return _odp_queue_deq(q, buf_hdr, num);
 }
 
-static odp_buffer_hdr_t *_queue_deq(void *handle)
+static odp_buffer_hdr_t *_queue_deq(odp_queue_t handle)
 {
 	sched_elem_t *q;
 	odp_buffer_hdr_t *buf_hdr;
@@ -842,7 +841,7 @@ static int queue_deq_multi(odp_queue_t handle, odp_event_t ev[], int num)
 		num = QUEUE_MULTI_MAX;
 
 	queue = qentry_from_ext(handle);
-	return queue->s.dequeue_multi(qentry_to_int(queue), (odp_buffer_hdr_t **)ev, num);
+	return queue->s.dequeue_multi(handle, (odp_buffer_hdr_t **)ev, num);
 }
 
 static odp_event_t queue_deq(odp_queue_t handle)
@@ -850,7 +849,7 @@ static odp_event_t queue_deq(odp_queue_t handle)
 	queue_entry_t *queue;
 
 	queue = qentry_from_ext(handle);
-	return (odp_event_t)queue->s.dequeue(qentry_to_int(queue));
+	return (odp_event_t)queue->s.dequeue(handle);
 }
 
 static void queue_param_init(odp_queue_param_t *params)
@@ -909,29 +908,29 @@ static uint64_t queue_to_u64(odp_queue_t hdl)
 	return _odp_pri(hdl);
 }
 
-static odp_pktout_queue_t queue_get_pktout(void *handle)
+static odp_pktout_queue_t queue_get_pktout(odp_queue_t handle)
 {
 	return qentry_from_int(handle)->s.pktout;
 }
 
-static void queue_set_pktout(void *handle, odp_pktio_t pktio, int index)
+static void queue_set_pktout(odp_queue_t handle, odp_pktio_t pktio, int index)
 {
 	qentry_from_int(handle)->s.pktout.pktio = pktio;
 	qentry_from_int(handle)->s.pktout.index = index;
 }
 
-static odp_pktin_queue_t queue_get_pktin(void *handle)
+static odp_pktin_queue_t queue_get_pktin(odp_queue_t handle)
 {
 	return qentry_from_int(handle)->s.pktin;
 }
 
-static void queue_set_pktin(void *handle, odp_pktio_t pktio, int index)
+static void queue_set_pktin(odp_queue_t handle, odp_pktio_t pktio, int index)
 {
 	qentry_from_int(handle)->s.pktin.pktio = pktio;
 	qentry_from_int(handle)->s.pktin.index = index;
 }
 
-static void queue_set_enq_deq_func(void *handle,
+static void queue_set_enq_deq_func(odp_queue_t handle,
 				   queue_enq_fn_t enq,
 				   queue_enq_multi_fn_t enq_multi,
 				   queue_deq_fn_t deq,
@@ -950,16 +949,6 @@ static void queue_set_enq_deq_func(void *handle,
 		qentry_from_int(handle)->s.dequeue_multi = deq_multi;
 }
 
-static void *queue_from_ext(odp_queue_t handle)
-{
-	return (void *)handle;
-}
-
-static odp_queue_t queue_to_ext(void *handle)
-{
-	return (odp_queue_t)handle;
-}
-
 /* API functions */
 _odp_queue_api_fn_t queue_scalable_api = {
 	.queue_create = queue_create,
@@ -987,8 +976,6 @@ queue_fn_t queue_scalable_fn = {
 	.term_global = queue_term_global,
 	.init_local = queue_init_local,
 	.term_local = queue_term_local,
-	.from_ext = queue_from_ext,
-	.to_ext = queue_to_ext,
 	.enq = _queue_enq,
 	.enq_multi = _queue_enq_multi,
 	.deq = _queue_deq,
diff --git a/platform/linux-generic/odp_queue_spsc.c b/platform/linux-generic/odp_queue_spsc.c
index 3e42b0383..2dcc3d935 100644
--- a/platform/linux-generic/odp_queue_spsc.c
+++ b/platform/linux-generic/odp_queue_spsc.c
@@ -32,14 +32,14 @@ static inline void buffer_index_to_buf(odp_buffer_hdr_t *buf_hdr[],
 	}
 }
 
-static inline int spsc_enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
-				 int num)
+static inline int spsc_enq_multi(odp_queue_t handle,
+				 odp_buffer_hdr_t *buf_hdr[], int num)
 {
 	queue_entry_t *queue;
 	ring_spsc_t *ring_spsc;
 	uint32_t buf_idx[num];
 
-	queue = q_int;
+	queue = qentry_from_handle(handle);
 	ring_spsc = &queue->s.ring_spsc;
 
 	buffer_index_from_buf(buf_idx, buf_hdr, num);
@@ -52,15 +52,15 @@ static inline int spsc_enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
 	return ring_spsc_enq_multi(ring_spsc, buf_idx, num);
 }
 
-static inline int spsc_deq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
-				 int num)
+static inline int spsc_deq_multi(odp_queue_t handle,
+				 odp_buffer_hdr_t *buf_hdr[], int num)
 {
 	queue_entry_t *queue;
 	int num_deq;
 	ring_spsc_t *ring_spsc;
 	uint32_t buf_idx[num];
 
-	queue = q_int;
+	queue = qentry_from_handle(handle);
 	ring_spsc = &queue->s.ring_spsc;
 
 	if (odp_unlikely(queue->s.status < QUEUE_STATUS_READY)) {
@@ -78,17 +78,17 @@ static inline int spsc_deq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
 	return num_deq;
 }
 
-static int queue_spsc_enq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
+static int queue_spsc_enq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 				int num)
 {
-	return spsc_enq_multi(q_int, buf_hdr, num);
+	return spsc_enq_multi(handle, buf_hdr, num);
 }
 
-static int queue_spsc_enq(void *q_int, odp_buffer_hdr_t *buf_hdr)
+static int queue_spsc_enq(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr)
 {
 	int ret;
 
-	ret = spsc_enq_multi(q_int, &buf_hdr, 1);
+	ret = spsc_enq_multi(handle, &buf_hdr, 1);
 
 	if (ret == 1)
 		return 0;
@@ -96,18 +96,18 @@ static int queue_spsc_enq(void *q_int, odp_buffer_hdr_t *buf_hdr)
 		return -1;
 }
 
-static int queue_spsc_deq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
+static int queue_spsc_deq_multi(odp_queue_t handle, odp_buffer_hdr_t *buf_hdr[],
 				int num)
 {
-	return spsc_deq_multi(q_int, buf_hdr, num);
+	return spsc_deq_multi(handle, buf_hdr, num);
 }
 
-static odp_buffer_hdr_t *queue_spsc_deq(void *q_int)
+static odp_buffer_hdr_t *queue_spsc_deq(odp_queue_t handle)
 {
 	odp_buffer_hdr_t *buf_hdr = NULL;
 	int ret;
 
-	ret = spsc_deq_multi(q_int, &buf_hdr, 1);
+	ret = spsc_deq_multi(handle, &buf_hdr, 1);
 
 	if (ret == 1)
 		return buf_hdr;
diff --git a/platform/linux-generic/odp_schedule_basic.c b/platform/linux-generic/odp_schedule_basic.c
index df63da72a..345bf2b02 100644
--- a/platform/linux-generic/odp_schedule_basic.c
+++ b/platform/linux-generic/odp_schedule_basic.c
@@ -103,7 +103,7 @@ ODP_STATIC_ASSERT((8 * sizeof(pri_mask_t)) >= MAX_SPREAD,
 /* Storage for stashed enqueue operation arguments */
 typedef struct {
 	odp_buffer_hdr_t *buf_hdr[QUEUE_MULTI_MAX];
-	queue_entry_t *queue_entry;
+	odp_queue_t queue;
 	int num;
 } ordered_stash_t;
 
@@ -661,15 +661,15 @@ static inline void ordered_stash_release(void)
 	int i;
 
 	for (i = 0; i < sched_local.ordered.stash_num; i++) {
-		queue_entry_t *queue_entry;
+		odp_queue_t queue;
 		odp_buffer_hdr_t **buf_hdr;
 		int num, num_enq;
 
-		queue_entry = sched_local.ordered.stash[i].queue_entry;
+		queue = sched_local.ordered.stash[i].queue;
 		buf_hdr = sched_local.ordered.stash[i].buf_hdr;
 		num = sched_local.ordered.stash[i].num;
 
-		num_enq = queue_fn->enq_multi(queue_entry, buf_hdr, num);
+		num_enq = queue_fn->enq_multi(queue, buf_hdr, num);
 
 		/* Drop packets that were not enqueued */
 		if (odp_unlikely(num_enq < num)) {
@@ -744,12 +744,12 @@ static inline int copy_from_stash(odp_event_t out_ev[], unsigned int max)
 	return i;
 }
 
-static int schedule_ord_enq_multi(void *q_int, void *buf_hdr[],
+static int schedule_ord_enq_multi(odp_queue_t dst_queue, void *buf_hdr[],
 				  int num, int *ret)
 {
 	int i;
 	uint32_t stash_num = sched_local.ordered.stash_num;
-	queue_entry_t *dst_queue = q_int;
+	queue_entry_t *dst_qentry = qentry_from_handle(dst_queue);
 	uint32_t src_queue = sched_local.ordered.src_queue;
 
 	if ((src_queue == NULL_INDEX) || sched_local.ordered.in_order)
@@ -763,7 +763,7 @@ static int schedule_ord_enq_multi(void *q_int, void *buf_hdr[],
 	}
 
 	/* Pktout may drop packets, so the operation cannot be stashed. */
-	if (dst_queue->s.pktout.pktio != ODP_PKTIO_INVALID ||
+	if (dst_qentry->s.pktout.pktio != ODP_PKTIO_INVALID ||
 	    odp_unlikely(stash_num >=  MAX_ORDERED_STASH)) {
 		/* If the local stash is full, wait until it is our turn and
 		 * then release the stash and do enqueue directly. */
@@ -775,7 +775,7 @@ static int schedule_ord_enq_multi(void *q_int, void *buf_hdr[],
 		return 0;
 	}
 
-	sched_local.ordered.stash[stash_num].queue_entry = dst_queue;
+	sched_local.ordered.stash[stash_num].queue = dst_queue;
 	sched_local.ordered.stash[stash_num].num = num;
 	for (i = 0; i < num; i++)
 		sched_local.ordered.stash[stash_num].buf_hdr[i] = buf_hdr[i];
diff --git a/platform/linux-generic/odp_schedule_iquery.c b/platform/linux-generic/odp_schedule_iquery.c
index 2501a3f68..515e556df 100644
--- a/platform/linux-generic/odp_schedule_iquery.c
+++ b/platform/linux-generic/odp_schedule_iquery.c
@@ -171,7 +171,7 @@ typedef struct {
 /* Storage for stashed enqueue operation arguments */
 typedef struct {
 	odp_buffer_hdr_t *buf_hdr[QUEUE_MULTI_MAX];
-	queue_entry_t *queue_entry;
+	odp_queue_t queue;
 	int num;
 } ordered_stash_t;
 
@@ -1132,15 +1132,15 @@ static inline void ordered_stash_release(void)
 	int i;
 
 	for (i = 0; i < thread_local.ordered.stash_num; i++) {
-		queue_entry_t *queue_entry;
+		odp_queue_t queue;
 		odp_buffer_hdr_t **buf_hdr;
 		int num, num_enq;
 
-		queue_entry = thread_local.ordered.stash[i].queue_entry;
+		queue = thread_local.ordered.stash[i].queue;
 		buf_hdr = thread_local.ordered.stash[i].buf_hdr;
 		num = thread_local.ordered.stash[i].num;
 
-		num_enq = queue_fn->enq_multi(queue_entry, buf_hdr, num);
+		num_enq = queue_fn->enq_multi(queue, buf_hdr, num);
 
 		if (odp_unlikely(num_enq < num)) {
 			if (odp_unlikely(num_enq < 0))
@@ -1200,12 +1200,12 @@ static inline void schedule_release_context(void)
 		schedule_release_atomic();
 }
 
-static int schedule_ord_enq_multi(void *q_int, void *buf_hdr[],
+static int schedule_ord_enq_multi(odp_queue_t dst_queue, void *buf_hdr[],
 				  int num, int *ret)
 {
 	int i;
 	uint32_t stash_num = thread_local.ordered.stash_num;
-	queue_entry_t *dst_queue = q_int;
+	queue_entry_t *dst_qentry = qentry_from_handle(dst_queue);
 	uint32_t src_queue = thread_local.ordered.src_queue;
 
 	if ((src_queue == NULL_INDEX) || thread_local.ordered.in_order)
@@ -1219,7 +1219,7 @@ static int schedule_ord_enq_multi(void *q_int, void *buf_hdr[],
 	}
 
 	/* Pktout may drop packets, so the operation cannot be stashed. */
-	if (dst_queue->s.pktout.pktio != ODP_PKTIO_INVALID ||
+	if (dst_qentry->s.pktout.pktio != ODP_PKTIO_INVALID ||
 	    odp_unlikely(stash_num >=  MAX_ORDERED_STASH)) {
 		/* If the local stash is full, wait until it is our turn and
 		 * then release the stash and do enqueue directly. */
@@ -1231,7 +1231,7 @@ static int schedule_ord_enq_multi(void *q_int, void *buf_hdr[],
 		return 0;
 	}
 
-	thread_local.ordered.stash[stash_num].queue_entry = dst_queue;
+	thread_local.ordered.stash[stash_num].queue = dst_queue;
 	thread_local.ordered.stash[stash_num].num = num;
 	for (i = 0; i < num; i++)
 		thread_local.ordered.stash[stash_num].buf_hdr[i] = buf_hdr[i];
diff --git a/platform/linux-generic/odp_schedule_scalable.c b/platform/linux-generic/odp_schedule_scalable.c
index 826747ee1..9acb997a1 100644
--- a/platform/linux-generic/odp_schedule_scalable.c
+++ b/platform/linux-generic/odp_schedule_scalable.c
@@ -2007,7 +2007,7 @@ static int sched_queue(uint32_t queue_index)
 	return 0;
 }
 
-static int ord_enq_multi(void *handle, void *buf_hdr[], int num,
+static int ord_enq_multi(odp_queue_t handle, void *buf_hdr[], int num,
 			 int *ret)
 
 {
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index ae292051b..7932e1860 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -415,10 +415,10 @@ static int sched_queue(uint32_t qi)
 	return 0;
 }
 
-static int ord_enq_multi(void *q_int, void *buf_hdr[], int num,
+static int ord_enq_multi(odp_queue_t queue, void *buf_hdr[], int num,
 			 int *ret)
 {
-	(void)q_int;
+	(void)queue;
 	(void)buf_hdr;
 	(void)num;
 	(void)ret;
diff --git a/platform/linux-generic/odp_traffic_mngr.c b/platform/linux-generic/odp_traffic_mngr.c
index 0d01c0ea5..7ca1a4ce4 100644
--- a/platform/linux-generic/odp_traffic_mngr.c
+++ b/platform/linux-generic/odp_traffic_mngr.c
@@ -108,20 +108,20 @@ static odp_bool_t tm_demote_pkt_desc(tm_system_t *tm_system,
 				     tm_shaper_obj_t *timer_shaper,
 				     pkt_desc_t *demoted_pkt_desc);
 
-static int queue_tm_reenq(void *queue, odp_buffer_hdr_t *buf_hdr)
+static int queue_tm_reenq(odp_queue_t queue, odp_buffer_hdr_t *buf_hdr)
 {
-	odp_tm_queue_t tm_queue = MAKE_ODP_TM_QUEUE((uint8_t *)queue -
-						    offsetof(tm_queue_obj_t,
-							     tm_qentry));
+	odp_tm_queue_t tm_queue = MAKE_ODP_TM_QUEUE(odp_queue_context(queue));
 	odp_packet_t pkt = packet_from_buf_hdr(buf_hdr);
 
 	return odp_tm_enq(tm_queue, pkt);
 }
 
-static int queue_tm_reenq_multi(void *queue ODP_UNUSED,
-				odp_buffer_hdr_t *buf[] ODP_UNUSED,
-				int num ODP_UNUSED)
+static int queue_tm_reenq_multi(odp_queue_t queue, odp_buffer_hdr_t *buf[],
+				int num)
 {
+	(void)queue;
+	(void)buf;
+	(void)num;
 	ODP_ABORT("Invalid call to queue_tm_reenq_multi()\n");
 	return 0;
 }
@@ -3936,8 +3936,10 @@ odp_tm_queue_t odp_tm_queue_create(odp_tm_t odp_tm,
 		free(tm_queue_obj);
 		return ODP_TM_INVALID;
 	}
-	tm_queue_obj->tm_qentry = queue_fn->from_ext(queue);
-	queue_fn->set_enq_deq_fn(tm_queue_obj->tm_qentry,
+
+	tm_queue_obj->queue = queue;
+	odp_queue_context_set(queue, tm_queue_obj, sizeof(tm_queue_obj_t));
+	queue_fn->set_enq_deq_fn(queue,
 				 queue_tm_reenq, queue_tm_reenq_multi,
 				 NULL, NULL);
 
@@ -3991,7 +3993,7 @@ int odp_tm_queue_destroy(odp_tm_queue_t tm_queue)
 	odp_ticketlock_lock(&tm_system->tm_system_lock);
 	tm_system->queue_num_tbl[tm_queue_obj->queue_num - 1] = NULL;
 
-	odp_queue_destroy(queue_fn->to_ext(tm_queue_obj->tm_qentry));
+	odp_queue_destroy(tm_queue_obj->queue);
 
 	/* First delete any associated tm_wred_node and then the tm_queue_obj
 	 * itself */
diff --git a/platform/linux-generic/pktio/loop.c b/platform/linux-generic/pktio/loop.c
index faaef3ab5..3af359eb2 100644
--- a/platform/linux-generic/pktio/loop.c
+++ b/platform/linux-generic/pktio/loop.c
@@ -93,7 +93,7 @@ static int loopback_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
 {
 	int nbr, i;
 	odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
-	void *queue;
+	odp_queue_t queue;
 	odp_packet_hdr_t *pkt_hdr;
 	odp_packet_t pkt;
 	odp_time_t ts_val;
@@ -106,7 +106,7 @@ static int loopback_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
 
 	odp_ticketlock_lock(&pktio_entry->s.rxl);
 
-	queue = queue_fn->from_ext(pkt_priv(pktio_entry)->loopq);
+	queue = pkt_priv(pktio_entry)->loopq;
 	nbr = queue_fn->deq_multi(queue, hdr_tbl, num);
 
 	if (pktio_entry->s.config.pktin.bit.ts_all ||
@@ -274,7 +274,7 @@ static int loopback_send(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
 			 const odp_packet_t pkt_tbl[], int num)
 {
 	odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
-	void *queue;
+	odp_queue_t queue;
 	int i;
 	int ret;
 	int nb_tx = 0;
@@ -324,7 +324,7 @@ static int loopback_send(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
 
 	odp_ticketlock_lock(&pktio_entry->s.txl);
 
-	queue = queue_fn->from_ext(pkt_priv(pktio_entry)->loopq);
+	queue = pkt_priv(pktio_entry)->loopq;
 	ret = queue_fn->enq_multi(queue, hdr_tbl, nb_tx);
 
 	if (ret > 0) {