doc: add bus libraries to release notes

[dpdk.git] / drivers / crypto / scheduler / scheduler_pkt_size_distr.c

diff --git a/drivers/crypto/scheduler/scheduler_pkt_size_distr.c b/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
index 1066451..1dd1bc3 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
+++ b/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
@@ -52,7 +52,6 @@ struct psd_scheduler_qp_ctx {
        struct scheduler_slave primary_slave;
        struct scheduler_slave secondary_slave;
        uint32_t threshold;
-       uint32_t max_nb_objs;
        uint8_t deq_idx;
 } __rte_cache_aligned;
 
@@ -65,13 +64,12 @@ struct psd_schedule_op {
 static uint16_t
 schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
 {
-       struct psd_scheduler_qp_ctx *qp_ctx =
-                       ((struct scheduler_qp_ctx *)qp)->private_qp_ctx;
+       struct scheduler_qp_ctx *qp_ctx = qp;
+       struct psd_scheduler_qp_ctx *psd_qp_ctx = qp_ctx->private_qp_ctx;
        struct rte_crypto_op *sched_ops[NB_PKT_SIZE_SLAVES][nb_ops];
-       struct scheduler_session *sess;
        uint32_t in_flight_ops[NB_PKT_SIZE_SLAVES] = {
-                       qp_ctx->primary_slave.nb_inflight_cops,
-                       qp_ctx->secondary_slave.nb_inflight_cops
+                       psd_qp_ctx->primary_slave.nb_inflight_cops,
+                       psd_qp_ctx->secondary_slave.nb_inflight_cops
        };
        struct psd_schedule_op enq_ops[NB_PKT_SIZE_SLAVES] = {
                {PRIMARY_SLAVE_IDX, 0}, {SECONDARY_SLAVE_IDX, 0}
@@ -98,8 +96,6 @@ schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
                rte_prefetch0(ops[i + 7]->sym);
                rte_prefetch0(ops[i + 7]->sym->session);
 
-               sess = (struct scheduler_session *)
-                               ops[i]->sym->session->_private;
                /* job_len is initialized as cipher data length, once
                 * it is 0, equals to auth data length
                 */
@@ -107,7 +103,7 @@ schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
                job_len += (ops[i]->sym->cipher.data.length == 0) *
                                ops[i]->sym->auth.data.length;
                /* decide the target op based on the job length */
-               p_enq_op = &enq_ops[!(job_len & qp_ctx->threshold)];
+               p_enq_op = &enq_ops[!(job_len & psd_qp_ctx->threshold)];
 
                /* stop schedule cops before the queue is full, this shall
                 * prevent the failed enqueue
@@ -119,15 +115,12 @@ schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
                }
 
                sched_ops[p_enq_op->slave_idx][p_enq_op->pos] = ops[i];
-               ops[i]->sym->session = sess->sessions[p_enq_op->slave_idx];
                p_enq_op->pos++;
 
-               sess = (struct scheduler_session *)
-                               ops[i+1]->sym->session->_private;
                job_len = ops[i+1]->sym->cipher.data.length;
                job_len += (ops[i+1]->sym->cipher.data.length == 0) *
                                ops[i+1]->sym->auth.data.length;
-               p_enq_op = &enq_ops[!(job_len & qp_ctx->threshold)];
+               p_enq_op = &enq_ops[!(job_len & psd_qp_ctx->threshold)];
 
                if (p_enq_op->pos + in_flight_ops[p_enq_op->slave_idx] ==
                                qp_ctx->max_nb_objs) {
@@ -136,15 +129,12 @@ schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
                }
 
                sched_ops[p_enq_op->slave_idx][p_enq_op->pos] = ops[i+1];
-               ops[i+1]->sym->session = sess->sessions[p_enq_op->slave_idx];
                p_enq_op->pos++;
 
-               sess = (struct scheduler_session *)
-                               ops[i+2]->sym->session->_private;
                job_len = ops[i+2]->sym->cipher.data.length;
                job_len += (ops[i+2]->sym->cipher.data.length == 0) *
                                ops[i+2]->sym->auth.data.length;
-               p_enq_op = &enq_ops[!(job_len & qp_ctx->threshold)];
+               p_enq_op = &enq_ops[!(job_len & psd_qp_ctx->threshold)];
 
                if (p_enq_op->pos + in_flight_ops[p_enq_op->slave_idx] ==
                                qp_ctx->max_nb_objs) {
@@ -153,16 +143,12 @@ schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
                }
 
                sched_ops[p_enq_op->slave_idx][p_enq_op->pos] = ops[i+2];
-               ops[i+2]->sym->session = sess->sessions[p_enq_op->slave_idx];
                p_enq_op->pos++;
 
-               sess = (struct scheduler_session *)
-                               ops[i+3]->sym->session->_private;
-
                job_len = ops[i+3]->sym->cipher.data.length;
                job_len += (ops[i+3]->sym->cipher.data.length == 0) *
                                ops[i+3]->sym->auth.data.length;
-               p_enq_op = &enq_ops[!(job_len & qp_ctx->threshold)];
+               p_enq_op = &enq_ops[!(job_len & psd_qp_ctx->threshold)];
 
                if (p_enq_op->pos + in_flight_ops[p_enq_op->slave_idx] ==
                                qp_ctx->max_nb_objs) {
@@ -171,18 +157,14 @@ schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
                }
 
                sched_ops[p_enq_op->slave_idx][p_enq_op->pos] = ops[i+3];
-               ops[i+3]->sym->session = sess->sessions[p_enq_op->slave_idx];
                p_enq_op->pos++;
        }
 
        for (; i < nb_ops; i++) {
-               sess = (struct scheduler_session *)
-                               ops[i]->sym->session->_private;
-
                job_len = ops[i]->sym->cipher.data.length;
                job_len += (ops[i]->sym->cipher.data.length == 0) *
                                ops[i]->sym->auth.data.length;
-               p_enq_op = &enq_ops[!(job_len & qp_ctx->threshold)];
+               p_enq_op = &enq_ops[!(job_len & psd_qp_ctx->threshold)];
 
                if (p_enq_op->pos + in_flight_ops[p_enq_op->slave_idx] ==
                                qp_ctx->max_nb_objs) {
@@ -191,28 +173,27 @@ schedule_enqueue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
                }
 
                sched_ops[p_enq_op->slave_idx][p_enq_op->pos] = ops[i];
-               ops[i]->sym->session = sess->sessions[p_enq_op->slave_idx];
                p_enq_op->pos++;
        }
 
        processed_ops_pri = rte_cryptodev_enqueue_burst(
-                       qp_ctx->primary_slave.dev_id,
-                       qp_ctx->primary_slave.qp_id,
+                       psd_qp_ctx->primary_slave.dev_id,
+                       psd_qp_ctx->primary_slave.qp_id,
                        sched_ops[PRIMARY_SLAVE_IDX],
                        enq_ops[PRIMARY_SLAVE_IDX].pos);
        /* enqueue shall not fail as the slave queue is monitored */
        RTE_ASSERT(processed_ops_pri == enq_ops[PRIMARY_SLAVE_IDX].pos);
 
-       qp_ctx->primary_slave.nb_inflight_cops += processed_ops_pri;
+       psd_qp_ctx->primary_slave.nb_inflight_cops += processed_ops_pri;
 
        processed_ops_sec = rte_cryptodev_enqueue_burst(
-                       qp_ctx->secondary_slave.dev_id,
-                       qp_ctx->secondary_slave.qp_id,
+                       psd_qp_ctx->secondary_slave.dev_id,
+                       psd_qp_ctx->secondary_slave.qp_id,
                        sched_ops[SECONDARY_SLAVE_IDX],
                        enq_ops[SECONDARY_SLAVE_IDX].pos);
        RTE_ASSERT(processed_ops_sec == enq_ops[SECONDARY_SLAVE_IDX].pos);
 
-       qp_ctx->secondary_slave.nb_inflight_cops += processed_ops_sec;
+       psd_qp_ctx->secondary_slave.nb_inflight_cops += processed_ops_sec;
 
        return processed_ops_pri + processed_ops_sec;
 }
@@ -325,8 +306,6 @@ scheduler_start(struct rte_cryptodev *dev)
                ps_qp_ctx->secondary_slave.nb_inflight_cops = 0;
 
                ps_qp_ctx->threshold = psd_ctx->threshold;
-
-               ps_qp_ctx->max_nb_objs = sched_ctx->qp_conf.nb_descriptors;
        }
 
        if (sched_ctx->reordering_enabled) {
@@ -399,6 +378,51 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
 
        return 0;
 }
+static int
+scheduler_option_set(struct rte_cryptodev *dev, uint32_t option_type,
+               void *option)
+{
+       struct psd_scheduler_ctx *psd_ctx = ((struct scheduler_ctx *)
+                       dev->data->dev_private)->private_ctx;
+       uint32_t threshold;
+
+       if ((enum rte_cryptodev_schedule_option_type)option_type !=
+                       CDEV_SCHED_OPTION_THRESHOLD) {
+               CS_LOG_ERR("Option not supported");
+               return -EINVAL;
+       }
+
+       threshold = ((struct rte_cryptodev_scheduler_threshold_option *)
+                       option)->threshold;
+       if (!rte_is_power_of_2(threshold)) {
+               CS_LOG_ERR("Threshold is not power of 2");
+               return -EINVAL;
+       }
+
+       psd_ctx->threshold = ~(threshold - 1);
+
+       return 0;
+}
+
+static int
+scheduler_option_get(struct rte_cryptodev *dev, uint32_t option_type,
+               void *option)
+{
+       struct psd_scheduler_ctx *psd_ctx = ((struct scheduler_ctx *)
+                       dev->data->dev_private)->private_ctx;
+       struct rte_cryptodev_scheduler_threshold_option *threshold_option;
+
+       if ((enum rte_cryptodev_schedule_option_type)option_type !=
+                       CDEV_SCHED_OPTION_THRESHOLD) {
+               CS_LOG_ERR("Option not supported");
+               return -EINVAL;
+       }
+
+       threshold_option = option;
+       threshold_option->threshold = (~psd_ctx->threshold) + 1;
+
+       return 0;
+}
 
 struct rte_cryptodev_scheduler_ops scheduler_ps_ops = {
        slave_attach,
@@ -407,6 +431,8 @@ struct rte_cryptodev_scheduler_ops scheduler_ps_ops = {
        scheduler_stop,
        scheduler_config_qp,
        scheduler_create_private_ctx,
+       scheduler_option_set,
+       scheduler_option_get
 };
 
 struct rte_cryptodev_scheduler psd_scheduler = {