1 files changed, 177 insertions, 109 deletions

diff --git a/lib/librte_eventdev/rte_eventdev.c b/lib/librte_eventdev/rte_eventdev.c
index bbb38050..ce6a5dc1 100644
--- a/lib/librte_eventdev/rte_eventdev.c
+++ b/lib/librte_eventdev/rte_eventdev.c
@@ -56,6 +56,7 @@
 #include <rte_common.h>
 #include <rte_malloc.h>
 #include <rte_errno.h>
+#include <rte_ethdev.h>
 
 #include "rte_eventdev.h"
 #include "rte_eventdev_pmd.h"
@@ -128,55 +129,77 @@ rte_event_dev_info_get(uint8_t dev_id, struct rte_event_dev_info *dev_info)
 	return 0;
 }
 
+int
+rte_event_eth_rx_adapter_caps_get(uint8_t dev_id, uint8_t eth_port_id,
+				uint32_t *caps)
+{
+	struct rte_eventdev *dev;
+
+	RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
+	RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_port_id, -EINVAL);
+
+	dev = &rte_eventdevs[dev_id];
+
+	if (caps == NULL)
+		return -EINVAL;
+	*caps = 0;
+
+	return dev->dev_ops->eth_rx_adapter_caps_get ?
+				(*dev->dev_ops->eth_rx_adapter_caps_get)(dev,
+						&rte_eth_devices[eth_port_id],
+						caps)
+				: 0;
+}
+
 static inline int
 rte_event_dev_queue_config(struct rte_eventdev *dev, uint8_t nb_queues)
 {
 	uint8_t old_nb_queues = dev->data->nb_queues;
-	uint8_t *queues_prio;
+	struct rte_event_queue_conf *queues_cfg;
 	unsigned int i;
 
 	RTE_EDEV_LOG_DEBUG("Setup %d queues on device %u", nb_queues,
 			 dev->data->dev_id);
 
 	/* First time configuration */
-	if (dev->data->queues_prio == NULL && nb_queues != 0) {
-		/* Allocate memory to store queue priority */
-		dev->data->queues_prio = rte_zmalloc_socket(
-				"eventdev->data->queues_prio",
-				sizeof(dev->data->queues_prio[0]) * nb_queues,
+	if (dev->data->queues_cfg == NULL && nb_queues != 0) {
+		/* Allocate memory to store queue configuration */
+		dev->data->queues_cfg = rte_zmalloc_socket(
+				"eventdev->data->queues_cfg",
+				sizeof(dev->data->queues_cfg[0]) * nb_queues,
 				RTE_CACHE_LINE_SIZE, dev->data->socket_id);
-		if (dev->data->queues_prio == NULL) {
+		if (dev->data->queues_cfg == NULL) {
 			dev->data->nb_queues = 0;
-			RTE_EDEV_LOG_ERR("failed to get mem for queue priority,"
+			RTE_EDEV_LOG_ERR("failed to get mem for queue cfg,"
 					"nb_queues %u", nb_queues);
 			return -(ENOMEM);
 		}
 	/* Re-configure */
-	} else if (dev->data->queues_prio != NULL && nb_queues != 0) {
+	} else if (dev->data->queues_cfg != NULL && nb_queues != 0) {
 		RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_release, -ENOTSUP);
 
 		for (i = nb_queues; i < old_nb_queues; i++)
 			(*dev->dev_ops->queue_release)(dev, i);
 
-		/* Re allocate memory to store queue priority */
-		queues_prio = dev->data->queues_prio;
-		queues_prio = rte_realloc(queues_prio,
-				sizeof(queues_prio[0]) * nb_queues,
+		/* Re allocate memory to store queue configuration */
+		queues_cfg = dev->data->queues_cfg;
+		queues_cfg = rte_realloc(queues_cfg,
+				sizeof(queues_cfg[0]) * nb_queues,
 				RTE_CACHE_LINE_SIZE);
-		if (queues_prio == NULL) {
-			RTE_EDEV_LOG_ERR("failed to realloc queue priority,"
+		if (queues_cfg == NULL) {
+			RTE_EDEV_LOG_ERR("failed to realloc queue cfg memory,"
 						" nb_queues %u", nb_queues);
 			return -(ENOMEM);
 		}
-		dev->data->queues_prio = queues_prio;
+		dev->data->queues_cfg = queues_cfg;
 
 		if (nb_queues > old_nb_queues) {
 			uint8_t new_qs = nb_queues - old_nb_queues;
 
-			memset(queues_prio + old_nb_queues, 0,
-				sizeof(queues_prio[0]) * new_qs);
+			memset(queues_cfg + old_nb_queues, 0,
+				sizeof(queues_cfg[0]) * new_qs);
 		}
-	} else if (dev->data->queues_prio != NULL && nb_queues == 0) {
+	} else if (dev->data->queues_cfg != NULL && nb_queues == 0) {
 		RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_release, -ENOTSUP);
 
 		for (i = nb_queues; i < old_nb_queues; i++)
@@ -195,8 +218,7 @@ rte_event_dev_port_config(struct rte_eventdev *dev, uint8_t nb_ports)
 	uint8_t old_nb_ports = dev->data->nb_ports;
 	void **ports;
 	uint16_t *links_map;
-	uint8_t *ports_dequeue_depth;
-	uint8_t *ports_enqueue_depth;
+	struct rte_event_port_conf *ports_cfg;
 	unsigned int i;
 
 	RTE_EDEV_LOG_DEBUG("Setup %d ports on device %u", nb_ports,
@@ -214,26 +236,14 @@ rte_event_dev_port_config(struct rte_eventdev *dev, uint8_t nb_ports)
 			return -(ENOMEM);
 		}
 
-		/* Allocate memory to store ports dequeue depth */
-		dev->data->ports_dequeue_depth =
-			rte_zmalloc_socket("eventdev->ports_dequeue_depth",
-			sizeof(dev->data->ports_dequeue_depth[0]) * nb_ports,
+		/* Allocate memory to store port configurations */
+		dev->data->ports_cfg =
+			rte_zmalloc_socket("eventdev->ports_cfg",
+			sizeof(dev->data->ports_cfg[0]) * nb_ports,
 			RTE_CACHE_LINE_SIZE, dev->data->socket_id);
-		if (dev->data->ports_dequeue_depth == NULL) {
+		if (dev->data->ports_cfg == NULL) {
 			dev->data->nb_ports = 0;
-			RTE_EDEV_LOG_ERR("failed to get mem for port deq meta,"
-					"nb_ports %u", nb_ports);
-			return -(ENOMEM);
-		}
-
-		/* Allocate memory to store ports enqueue depth */
-		dev->data->ports_enqueue_depth =
-			rte_zmalloc_socket("eventdev->ports_enqueue_depth",
-			sizeof(dev->data->ports_enqueue_depth[0]) * nb_ports,
-			RTE_CACHE_LINE_SIZE, dev->data->socket_id);
-		if (dev->data->ports_enqueue_depth == NULL) {
-			dev->data->nb_ports = 0;
-			RTE_EDEV_LOG_ERR("failed to get mem for port enq meta,"
+			RTE_EDEV_LOG_ERR("failed to get mem for port cfg,"
 					"nb_ports %u", nb_ports);
 			return -(ENOMEM);
 		}
@@ -257,8 +267,7 @@ rte_event_dev_port_config(struct rte_eventdev *dev, uint8_t nb_ports)
 		RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->port_release, -ENOTSUP);
 
 		ports = dev->data->ports;
-		ports_dequeue_depth = dev->data->ports_dequeue_depth;
-		ports_enqueue_depth = dev->data->ports_enqueue_depth;
+		ports_cfg = dev->data->ports_cfg;
 		links_map = dev->data->links_map;
 
 		for (i = nb_ports; i < old_nb_ports; i++)
@@ -273,22 +282,12 @@ rte_event_dev_port_config(struct rte_eventdev *dev, uint8_t nb_ports)
 			return -(ENOMEM);
 		}
 
-		/* Realloc memory for ports_dequeue_depth */
-		ports_dequeue_depth = rte_realloc(ports_dequeue_depth,
-			sizeof(ports_dequeue_depth[0]) * nb_ports,
+		/* Realloc memory for ports_cfg */
+		ports_cfg = rte_realloc(ports_cfg,
+			sizeof(ports_cfg[0]) * nb_ports,
 			RTE_CACHE_LINE_SIZE);
-		if (ports_dequeue_depth == NULL) {
-			RTE_EDEV_LOG_ERR("failed to realloc port dequeue meta,"
-						" nb_ports %u", nb_ports);
-			return -(ENOMEM);
-		}
-
-		/* Realloc memory for ports_enqueue_depth */
-		ports_enqueue_depth = rte_realloc(ports_enqueue_depth,
-			sizeof(ports_enqueue_depth[0]) * nb_ports,
-			RTE_CACHE_LINE_SIZE);
-		if (ports_enqueue_depth == NULL) {
-			RTE_EDEV_LOG_ERR("failed to realloc port enqueue meta,"
+		if (ports_cfg == NULL) {
+			RTE_EDEV_LOG_ERR("failed to realloc port cfg mem,"
 						" nb_ports %u", nb_ports);
 			return -(ENOMEM);
 		}
@@ -314,18 +313,15 @@ rte_event_dev_port_config(struct rte_eventdev *dev, uint8_t nb_ports)
 
 			memset(ports + old_nb_ports, 0,
 				sizeof(ports[0]) * new_ps);
-			memset(ports_dequeue_depth + old_nb_ports, 0,
-				sizeof(ports_dequeue_depth[0]) * new_ps);
-			memset(ports_enqueue_depth + old_nb_ports, 0,
-				sizeof(ports_enqueue_depth[0]) * new_ps);
+			memset(ports_cfg + old_nb_ports, 0,
+				sizeof(ports_cfg[0]) * new_ps);
 			for (i = old_links_map_end; i < links_map_end; i++)
 				links_map[i] =
 					EVENT_QUEUE_SERVICE_PRIORITY_INVALID;
 		}
 
 		dev->data->ports = ports;
-		dev->data->ports_dequeue_depth = ports_dequeue_depth;
-		dev->data->ports_enqueue_depth = ports_enqueue_depth;
+		dev->data->ports_cfg = ports_cfg;
 		dev->data->links_map = links_map;
 	} else if (dev->data->ports != NULL && nb_ports == 0) {
 		RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->port_release, -ENOTSUP);
@@ -519,13 +515,13 @@ rte_event_queue_default_conf_get(uint8_t dev_id, uint8_t queue_id,
 static inline int
 is_valid_atomic_queue_conf(const struct rte_event_queue_conf *queue_conf)
 {
-	if (queue_conf && (
-		((queue_conf->event_queue_cfg &
-			RTE_EVENT_QUEUE_CFG_TYPE_MASK)
-			== RTE_EVENT_QUEUE_CFG_ALL_TYPES) ||
+	if (queue_conf &&
+		!(queue_conf->event_queue_cfg &
+		  RTE_EVENT_QUEUE_CFG_SINGLE_LINK) &&
 		((queue_conf->event_queue_cfg &
-			RTE_EVENT_QUEUE_CFG_TYPE_MASK)
-			== RTE_EVENT_QUEUE_CFG_ATOMIC_ONLY)
+			 RTE_EVENT_QUEUE_CFG_ALL_TYPES) ||
+		(queue_conf->schedule_type
+			== RTE_SCHED_TYPE_ATOMIC)
 		))
 		return 1;
 	else
@@ -535,13 +531,13 @@ is_valid_atomic_queue_conf(const struct rte_event_queue_conf *queue_conf)
 static inline int
 is_valid_ordered_queue_conf(const struct rte_event_queue_conf *queue_conf)
 {
-	if (queue_conf && (
-		((queue_conf->event_queue_cfg &
-			RTE_EVENT_QUEUE_CFG_TYPE_MASK)
-			== RTE_EVENT_QUEUE_CFG_ALL_TYPES) ||
+	if (queue_conf &&
+		!(queue_conf->event_queue_cfg &
+		  RTE_EVENT_QUEUE_CFG_SINGLE_LINK) &&
 		((queue_conf->event_queue_cfg &
-			RTE_EVENT_QUEUE_CFG_TYPE_MASK)
-			== RTE_EVENT_QUEUE_CFG_ORDERED_ONLY)
+			 RTE_EVENT_QUEUE_CFG_ALL_TYPES) ||
+		(queue_conf->schedule_type
+			== RTE_SCHED_TYPE_ORDERED)
 		))
 		return 1;
 	else
@@ -605,31 +601,10 @@ rte_event_queue_setup(uint8_t dev_id, uint8_t queue_id,
 		queue_conf = &def_conf;
 	}
 
-	dev->data->queues_prio[queue_id] = queue_conf->priority;
+	dev->data->queues_cfg[queue_id] = *queue_conf;
 	return (*dev->dev_ops->queue_setup)(dev, queue_id, queue_conf);
 }
 
-uint8_t
-rte_event_queue_count(uint8_t dev_id)
-{
-	struct rte_eventdev *dev;
-
-	dev = &rte_eventdevs[dev_id];
-	return dev->data->nb_queues;
-}
-
-uint8_t
-rte_event_queue_priority(uint8_t dev_id, uint8_t queue_id)
-{
-	struct rte_eventdev *dev;
-
-	dev = &rte_eventdevs[dev_id];
-	if (dev->data->event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
-		return dev->data->queues_prio[queue_id];
-	else
-		return RTE_EVENT_DEV_PRIORITY_NORMAL;
-}
-
 static inline int
 is_valid_port(struct rte_eventdev *dev, uint8_t port_id)
 {
@@ -726,10 +701,7 @@ rte_event_port_setup(uint8_t dev_id, uint8_t port_id,
 		port_conf = &def_conf;
 	}
 
-	dev->data->ports_dequeue_depth[port_id] =
-			port_conf->dequeue_depth;
-	dev->data->ports_enqueue_depth[port_id] =
-			port_conf->enqueue_depth;
+	dev->data->ports_cfg[port_id] = *port_conf;
 
 	diag = (*dev->dev_ops->port_setup)(dev, port_id, port_conf);
 
@@ -743,31 +715,110 @@ rte_event_port_setup(uint8_t dev_id, uint8_t port_id,
 	return 0;
 }
 
-uint8_t
-rte_event_port_dequeue_depth(uint8_t dev_id, uint8_t port_id)
+int
+rte_event_dev_attr_get(uint8_t dev_id, uint32_t attr_id,
+		       uint32_t *attr_value)
 {
 	struct rte_eventdev *dev;
 
+	if (!attr_value)
+		return -EINVAL;
+	RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
 	dev = &rte_eventdevs[dev_id];
-	return dev->data->ports_dequeue_depth[port_id];
+
+	switch (attr_id) {
+	case RTE_EVENT_DEV_ATTR_PORT_COUNT:
+		*attr_value = dev->data->nb_ports;
+		break;
+	case RTE_EVENT_DEV_ATTR_QUEUE_COUNT:
+		*attr_value = dev->data->nb_queues;
+		break;
+	case RTE_EVENT_DEV_ATTR_STARTED:
+		*attr_value = dev->data->dev_started;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
 }
 
-uint8_t
-rte_event_port_enqueue_depth(uint8_t dev_id, uint8_t port_id)
+int
+rte_event_port_attr_get(uint8_t dev_id, uint8_t port_id, uint32_t attr_id,
+			uint32_t *attr_value)
 {
 	struct rte_eventdev *dev;
 
+	if (!attr_value)
+		return -EINVAL;
+
+	RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
 	dev = &rte_eventdevs[dev_id];
-	return dev->data->ports_enqueue_depth[port_id];
+	if (!is_valid_port(dev, port_id)) {
+		RTE_EDEV_LOG_ERR("Invalid port_id=%" PRIu8, port_id);
+		return -EINVAL;
+	}
+
+	switch (attr_id) {
+	case RTE_EVENT_PORT_ATTR_ENQ_DEPTH:
+		*attr_value = dev->data->ports_cfg[port_id].enqueue_depth;
+		break;
+	case RTE_EVENT_PORT_ATTR_DEQ_DEPTH:
+		*attr_value = dev->data->ports_cfg[port_id].dequeue_depth;
+		break;
+	case RTE_EVENT_PORT_ATTR_NEW_EVENT_THRESHOLD:
+		*attr_value = dev->data->ports_cfg[port_id].new_event_threshold;
+		break;
+	default:
+		return -EINVAL;
+	};
+	return 0;
 }
 
-uint8_t
-rte_event_port_count(uint8_t dev_id)
+int
+rte_event_queue_attr_get(uint8_t dev_id, uint8_t queue_id, uint32_t attr_id,
+			uint32_t *attr_value)
 {
+	struct rte_event_queue_conf *conf;
 	struct rte_eventdev *dev;
 
+	if (!attr_value)
+		return -EINVAL;
+
+	RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
 	dev = &rte_eventdevs[dev_id];
-	return dev->data->nb_ports;
+	if (!is_valid_queue(dev, queue_id)) {
+		RTE_EDEV_LOG_ERR("Invalid queue_id=%" PRIu8, queue_id);
+		return -EINVAL;
+	}
+
+	conf = &dev->data->queues_cfg[queue_id];
+
+	switch (attr_id) {
+	case RTE_EVENT_QUEUE_ATTR_PRIORITY:
+		*attr_value = RTE_EVENT_DEV_PRIORITY_NORMAL;
+		if (dev->data->event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
+			*attr_value = conf->priority;
+		break;
+	case RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_FLOWS:
+		*attr_value = conf->nb_atomic_flows;
+		break;
+	case RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_ORDER_SEQUENCES:
+		*attr_value = conf->nb_atomic_order_sequences;
+		break;
+	case RTE_EVENT_QUEUE_ATTR_EVENT_QUEUE_CFG:
+		*attr_value = conf->event_queue_cfg;
+		break;
+	case RTE_EVENT_QUEUE_ATTR_SCHEDULE_TYPE:
+		if (conf->event_queue_cfg & RTE_EVENT_QUEUE_CFG_ALL_TYPES)
+			return -EOVERFLOW;
+
+		*attr_value = conf->schedule_type;
+		break;
+	default:
+		return -EINVAL;
+	};
+	return 0;
 }
 
 int
@@ -912,6 +963,23 @@ rte_event_dequeue_timeout_ticks(uint8_t dev_id, uint64_t ns,
 }
 
 int
+rte_event_dev_service_id_get(uint8_t dev_id, uint32_t *service_id)
+{
+	struct rte_eventdev *dev;
+
+	RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
+	dev = &rte_eventdevs[dev_id];
+
+	if (service_id == NULL)
+		return -EINVAL;
+
+	if (dev->data->service_inited)
+		*service_id = dev->data->service_id;
+
+	return dev->data->service_inited ? 0 : -ESRCH;
+}
+
+int
 rte_event_dev_dump(uint8_t dev_id, FILE *f)
 {
 	struct rte_eventdev *dev;