New upstream version 18.08

[deb_dpdk.git] / lib / librte_cryptodev / rte_crypto.h

diff --git a/lib/librte_cryptodev/rte_crypto.h b/lib/librte_cryptodev/rte_crypto.h
index 95cf861..fd5ef3a 100644 (file)
--- a/lib/librte_cryptodev/rte_crypto.h
+++ b/lib/librte_cryptodev/rte_crypto.h
@@ -23,6 +23,7 @@ extern "C" {
 #include <rte_common.h>
 
 #include "rte_crypto_sym.h"
+#include "rte_crypto_asym.h"
 
 /** Crypto operation types */
 enum rte_crypto_op_type {
@@ -30,6 +31,8 @@ enum rte_crypto_op_type {
        /**< Undefined operation type */
        RTE_CRYPTO_OP_TYPE_SYMMETRIC,
        /**< Symmetric operation */
+       RTE_CRYPTO_OP_TYPE_ASYMMETRIC
+       /**< Asymmetric operation */
 };
 
 /** Status of crypto operation */
@@ -73,20 +76,37 @@ enum rte_crypto_op_sess_type {
  * rte_cryptodev_enqueue_burst() / rte_cryptodev_dequeue_burst() .
  */
 struct rte_crypto_op {
-       uint8_t type;
-       /**< operation type */
-       uint8_t status;
-       /**<
-        * operation status - this is reset to
-        * RTE_CRYPTO_OP_STATUS_NOT_PROCESSED on allocation from mempool and
-        * will be set to RTE_CRYPTO_OP_STATUS_SUCCESS after crypto operation
-        * is successfully processed by a crypto PMD
-        */
-       uint8_t sess_type;
-       /**< operation session type */
-
-       uint8_t reserved[5];
-       /**< Reserved bytes to fill 64 bits for future additions */
+       __extension__
+       union {
+               uint64_t raw;
+               __extension__
+               struct {
+                       uint8_t type;
+                       /**< operation type */
+                       uint8_t status;
+                       /**<
+                        * operation status - this is reset to
+                        * RTE_CRYPTO_OP_STATUS_NOT_PROCESSED on allocation
+                        * from mempool and will be set to
+                        * RTE_CRYPTO_OP_STATUS_SUCCESS after crypto operation
+                        * is successfully processed by a crypto PMD
+                        */
+                       uint8_t sess_type;
+                       /**< operation session type */
+                       uint8_t reserved[3];
+                       /**< Reserved bytes to fill 64 bits for
+                        * future additions
+                        */
+                       uint16_t private_data_offset;
+                       /**< Offset to indicate start of private data (if any).
+                        * The offset is counted from the start of the
+                        * rte_crypto_op including IV.
+                        * The private data may be used by the application
+                        * to store information which should remain untouched
+                        * in the library/driver
+                        */
+               };
+       };
        struct rte_mempool *mempool;
        /**< crypto operation mempool which operation is allocated from */
 
@@ -97,6 +117,10 @@ struct rte_crypto_op {
        union {
                struct rte_crypto_sym_op sym[0];
                /**< Symmetric operation parameters */
+
+               struct rte_crypto_asym_op asym[0];
+               /**< Asymmetric operation parameters */
+
        }; /**< operation specific parameters */
 };
 
@@ -117,6 +141,9 @@ __rte_crypto_op_reset(struct rte_crypto_op *op, enum rte_crypto_op_type type)
        case RTE_CRYPTO_OP_TYPE_SYMMETRIC:
                __rte_crypto_sym_op_reset(op->sym);
                break;
+       case RTE_CRYPTO_OP_TYPE_ASYMMETRIC:
+               memset(op->asym, 0, sizeof(struct rte_crypto_asym_op));
+       break;
        case RTE_CRYPTO_OP_TYPE_UNDEFINED:
        default:
                break;
@@ -283,9 +310,14 @@ __rte_crypto_op_get_priv_data(struct rte_crypto_op *op, uint32_t size)
        if (likely(op->mempool != NULL)) {
                priv_size = __rte_crypto_op_get_priv_data_size(op->mempool);
 
-               if (likely(priv_size >= size))
-                       return (void *)((uint8_t *)(op + 1) +
+               if (likely(priv_size >= size)) {
+                       if (op->type == RTE_CRYPTO_OP_TYPE_SYMMETRIC)
+                               return (void *)((uint8_t *)(op + 1) +
                                        sizeof(struct rte_crypto_sym_op));
+                       if (op->type == RTE_CRYPTO_OP_TYPE_ASYMMETRIC)
+                               return (void *)((uint8_t *)(op + 1) +
+                                       sizeof(struct rte_crypto_asym_op));
+               }
        }
 
        return NULL;
@@ -388,6 +420,24 @@ rte_crypto_op_attach_sym_session(struct rte_crypto_op *op,
        return __rte_crypto_sym_op_attach_sym_session(op->sym, sess);
 }
 
+/**
+ * Attach a asymmetric session to a crypto operation
+ *
+ * @param      op      crypto operation, must be of type asymmetric
+ * @param      sess    cryptodev session
+ */
+static inline int
+rte_crypto_op_attach_asym_session(struct rte_crypto_op *op,
+               struct rte_cryptodev_asym_session *sess)
+{
+       if (unlikely(op->type != RTE_CRYPTO_OP_TYPE_ASYMMETRIC))
+               return -1;
+
+       op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
+       op->asym->session = sess;
+       return 0;
+}
+
 #ifdef __cplusplus
 }
 #endif