New upstream version 18.08

[deb_dpdk.git] / drivers / event / sw / sw_evdev.c

diff --git a/drivers/event/sw/sw_evdev.c b/drivers/event/sw/sw_evdev.c
index 6672fd8..a6bb913 100644 (file)
--- a/drivers/event/sw/sw_evdev.c
+++ b/drivers/event/sw/sw_evdev.c
@@ -361,9 +361,99 @@ sw_init_qid_iqs(struct sw_evdev *sw)
        }
 }
 
+static int
+sw_qids_empty(struct sw_evdev *sw)
+{
+       unsigned int i, j;
+
+       for (i = 0; i < sw->qid_count; i++) {
+               for (j = 0; j < SW_IQS_MAX; j++) {
+                       if (iq_count(&sw->qids[i].iq[j]))
+                               return 0;
+               }
+       }
+
+       return 1;
+}
+
+static int
+sw_ports_empty(struct sw_evdev *sw)
+{
+       unsigned int i;
+
+       for (i = 0; i < sw->port_count; i++) {
+               if ((rte_event_ring_count(sw->ports[i].rx_worker_ring)) ||
+                    rte_event_ring_count(sw->ports[i].cq_worker_ring))
+                       return 0;
+       }
+
+       return 1;
+}
+
 static void
-sw_clean_qid_iqs(struct sw_evdev *sw)
+sw_drain_ports(struct rte_eventdev *dev)
 {
+       struct sw_evdev *sw = sw_pmd_priv(dev);
+       eventdev_stop_flush_t flush;
+       unsigned int i;
+       uint8_t dev_id;
+       void *arg;
+
+       flush = dev->dev_ops->dev_stop_flush;
+       dev_id = dev->data->dev_id;
+       arg = dev->data->dev_stop_flush_arg;
+
+       for (i = 0; i < sw->port_count; i++) {
+               struct rte_event ev;
+
+               while (rte_event_dequeue_burst(dev_id, i, &ev, 1, 0)) {
+                       if (flush)
+                               flush(dev_id, ev, arg);
+
+                       ev.op = RTE_EVENT_OP_RELEASE;
+                       rte_event_enqueue_burst(dev_id, i, &ev, 1);
+               }
+       }
+}
+
+static void
+sw_drain_queue(struct rte_eventdev *dev, struct sw_iq *iq)
+{
+       struct sw_evdev *sw = sw_pmd_priv(dev);
+       eventdev_stop_flush_t flush;
+       uint8_t dev_id;
+       void *arg;
+
+       flush = dev->dev_ops->dev_stop_flush;
+       dev_id = dev->data->dev_id;
+       arg = dev->data->dev_stop_flush_arg;
+
+       while (iq_count(iq) > 0) {
+               struct rte_event ev;
+
+               iq_dequeue_burst(sw, iq, &ev, 1);
+
+               if (flush)
+                       flush(dev_id, ev, arg);
+       }
+}
+
+static void
+sw_drain_queues(struct rte_eventdev *dev)
+{
+       struct sw_evdev *sw = sw_pmd_priv(dev);
+       unsigned int i, j;
+
+       for (i = 0; i < sw->qid_count; i++) {
+               for (j = 0; j < SW_IQS_MAX; j++)
+                       sw_drain_queue(dev, &sw->qids[i].iq[j]);
+       }
+}
+
+static void
+sw_clean_qid_iqs(struct rte_eventdev *dev)
+{
+       struct sw_evdev *sw = sw_pmd_priv(dev);
        int i, j;
 
        /* Release the IQ memory of all configured qids */
@@ -464,6 +554,33 @@ sw_eth_rx_adapter_caps_get(const struct rte_eventdev *dev,
        return 0;
 }
 
+static int
+sw_timer_adapter_caps_get(const struct rte_eventdev *dev,
+                         uint64_t flags,
+                         uint32_t *caps,
+                         const struct rte_event_timer_adapter_ops **ops)
+{
+       RTE_SET_USED(dev);
+       RTE_SET_USED(flags);
+       *caps = 0;
+
+       /* Use default SW ops */
+       *ops = NULL;
+
+       return 0;
+}
+
+static int
+sw_crypto_adapter_caps_get(const struct rte_eventdev *dev,
+                          const struct rte_cryptodev *cdev,
+                          uint32_t *caps)
+{
+       RTE_SET_USED(dev);
+       RTE_SET_USED(cdev);
+       *caps = RTE_EVENT_CRYPTO_ADAPTER_SW_CAP;
+       return 0;
+}
+
 static void
 sw_info_get(struct rte_eventdev *dev, struct rte_event_dev_info *info)
 {
@@ -702,10 +819,30 @@ static void
 sw_stop(struct rte_eventdev *dev)
 {
        struct sw_evdev *sw = sw_pmd_priv(dev);
-       sw_clean_qid_iqs(sw);
+       int32_t runstate;
+
+       /* Stop the scheduler if it's running */
+       runstate = rte_service_runstate_get(sw->service_id);
+       if (runstate == 1)
+               rte_service_runstate_set(sw->service_id, 0);
+
+       while (rte_service_may_be_active(sw->service_id))
+               rte_pause();
+
+       /* Flush all events out of the device */
+       while (!(sw_qids_empty(sw) && sw_ports_empty(sw))) {
+               sw_event_schedule(dev);
+               sw_drain_ports(dev);
+               sw_drain_queues(dev);
+       }
+
+       sw_clean_qid_iqs(dev);
        sw_xstats_uninit(sw);
        sw->started = 0;
        rte_smp_wmb();
+
+       if (runstate == 1)
+               rte_service_runstate_set(sw->service_id, 1);
 }
 
 static int
@@ -772,7 +909,7 @@ static int32_t sw_sched_service_func(void *args)
 static int
 sw_probe(struct rte_vdev_device *vdev)
 {
-       static const struct rte_eventdev_ops evdev_sw_ops = {
+       static struct rte_eventdev_ops evdev_sw_ops = {
                        .dev_configure = sw_dev_configure,
                        .dev_infos_get = sw_info_get,
                        .dev_close = sw_close,
@@ -791,6 +928,10 @@ sw_probe(struct rte_vdev_device *vdev)
 
                        .eth_rx_adapter_caps_get = sw_eth_rx_adapter_caps_get,
 
+                       .timer_adapter_caps_get = sw_timer_adapter_caps_get,
+
+                       .crypto_adapter_caps_get = sw_crypto_adapter_caps_get,
+
                        .xstats_get = sw_xstats_get,
                        .xstats_get_names = sw_xstats_get_names,
                        .xstats_get_by_name = sw_xstats_get_by_name,
@@ -933,9 +1074,7 @@ RTE_PMD_REGISTER_PARAM_STRING(event_sw, NUMA_NODE_ARG "=<int> "
 /* declared extern in header, for access from other .c files */
 int eventdev_sw_log_level;
 
-RTE_INIT(evdev_sw_init_log);
-static void
-evdev_sw_init_log(void)
+RTE_INIT(evdev_sw_init_log)
 {
        eventdev_sw_log_level = rte_log_register("pmd.event.sw");
        if (eventdev_sw_log_level >= 0)