uint32_t auth_only_len = sess->ext_params.aead_ctxt.auth_only_len;
        int icv_len = sess->digest_length, retval;
        uint8_t *old_icv;
+       struct rte_mbuf *dst;
        uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
                        sess->iv.offset);
 
        PMD_INIT_FUNC_TRACE();
 
+       if (sym_op->m_dst)
+               dst = sym_op->m_dst;
+       else
+               dst = sym_op->m_src;
+
        /* TODO we are using the first FLE entry to store Mbuf and session ctxt.
         * Currently we donot know which FLE has the mbuf stored.
         * So while retreiving we can go back 1 FLE from the FD -ADDR
        DPAA2_SET_FLE_SG_EXT(fle);
 
        /* Configure Output SGE for Encap/Decap */
-       DPAA2_SET_FLE_ADDR(sge, DPAA2_MBUF_VADDR_TO_IOVA(sym_op->m_src));
+       DPAA2_SET_FLE_ADDR(sge, DPAA2_MBUF_VADDR_TO_IOVA(dst));
        DPAA2_SET_FLE_OFFSET(sge, sym_op->aead.data.offset +
-                               sym_op->m_src->data_off - auth_only_len);
+                               dst->data_off - auth_only_len);
        sge->length = sym_op->aead.data.length + auth_only_len;
 
        if (sess->dir == DIR_ENC) {
        uint8_t *old_icv;
        uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
                        sess->iv.offset);
+       struct rte_mbuf *dst;
 
        PMD_INIT_FUNC_TRACE();
 
+       if (sym_op->m_dst)
+               dst = sym_op->m_dst;
+       else
+               dst = sym_op->m_src;
+
        /* we are using the first FLE entry to store Mbuf.
         * Currently we donot know which FLE has the mbuf stored.
         * So while retreiving we can go back 1 FLE from the FD -ADDR
        DPAA2_SET_FLE_SG_EXT(fle);
 
        /* Configure Output SGE for Encap/Decap */
-       DPAA2_SET_FLE_ADDR(sge, DPAA2_MBUF_VADDR_TO_IOVA(sym_op->m_src));
+       DPAA2_SET_FLE_ADDR(sge, DPAA2_MBUF_VADDR_TO_IOVA(dst));
        DPAA2_SET_FLE_OFFSET(sge, sym_op->cipher.data.offset +
-                               sym_op->m_src->data_off);
+                               dst->data_off);
        sge->length = sym_op->cipher.data.length;
 
        if (sess->dir == DIR_ENC) {
        struct ctxt_priv *priv = sess->ctxt;
        uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
                        sess->iv.offset);
+       struct rte_mbuf *dst;
 
        PMD_INIT_FUNC_TRACE();
 
+       if (sym_op->m_dst)
+               dst = sym_op->m_dst;
+       else
+               dst = sym_op->m_src;
+
        retval = rte_mempool_get(priv->fle_pool, (void **)(&fle));
        if (retval) {
                RTE_LOG(ERR, PMD, "Memory alloc failed for SGE\n");
                   sess->iv.length,
                   sym_op->m_src->data_off);
 
-       DPAA2_SET_FLE_ADDR(fle, DPAA2_MBUF_VADDR_TO_IOVA(sym_op->m_src));
+       DPAA2_SET_FLE_ADDR(fle, DPAA2_MBUF_VADDR_TO_IOVA(dst));
        DPAA2_SET_FLE_OFFSET(fle, sym_op->cipher.data.offset +
-                            sym_op->m_src->data_off);
+                            dst->data_off);
 
        fle->length = sym_op->cipher.data.length + sess->iv.length;
 
        struct qbman_fle *fle;
        struct rte_crypto_op *op;
        struct ctxt_priv *priv;
+       struct rte_mbuf *dst, *src;
 
        fle = (struct qbman_fle *)DPAA2_IOVA_TO_VADDR(DPAA2_GET_FD_ADDR(fd));
 
                        DPAA2_GET_FLE_ADDR((fle - 1)));
 
        /* Prefeth op */
-       rte_prefetch0(op->sym->m_src);
+       src = op->sym->m_src;
+       rte_prefetch0(src);
+
+       if (op->sym->m_dst) {
+               dst = op->sym->m_dst;
+               rte_prefetch0(dst);
+       } else
+               dst = src;
 
        PMD_RX_LOG(DEBUG, "mbuf %p BMAN buf addr %p",
-                  (void *)op->sym->m_src, op->sym->m_src->buf_addr);
+                  (void *)dst, dst->buf_addr);
 
        PMD_RX_LOG(DEBUG, "fdaddr =%p bpid =%d meta =%d off =%d, len =%d",
                   (void *)DPAA2_GET_FD_ADDR(fd),
 
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_auth_decryption_test_case_256_7),
 
+               /** Out of place tests */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_oop_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_oop_test_case_1),
+
                TEST_CASES_END() /**< NULL terminate unit test array */
        }
 };
 
                .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
                .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 |
                        BLOCKCIPHER_TEST_TARGET_PMD_QAT |
-                       BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL
+                       BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
+                       BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC
        },
        {
                .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest "
                .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
                .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 |
                        BLOCKCIPHER_TEST_TARGET_PMD_QAT |
-                       BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL
+                       BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
+                       BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC
        },
        {
                .test_descr = "AES-128-CBC HMAC-SHA224 Encryption Digest",
                .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
                .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
                .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
-                       BLOCKCIPHER_TEST_TARGET_PMD_QAT
+                       BLOCKCIPHER_TEST_TARGET_PMD_QAT |
+                       BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC
        },
        {
                .test_descr = "AES-256-CBC OOP Decryption",
                .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
                .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
                .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
-                       BLOCKCIPHER_TEST_TARGET_PMD_QAT
+                       BLOCKCIPHER_TEST_TARGET_PMD_QAT |
+                       BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC
        },
        {
                .test_descr = "AES-128-CTR Encryption",
 
                .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
                .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
                .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
-                       BLOCKCIPHER_TEST_TARGET_PMD_QAT
+                       BLOCKCIPHER_TEST_TARGET_PMD_QAT |
+                       BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC
        },
        {
                .test_descr = "3DES-128-CBC HMAC-SHA1 Decryption Digest"
                .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
                .feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
                .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL |
-                       BLOCKCIPHER_TEST_TARGET_PMD_QAT
+                       BLOCKCIPHER_TEST_TARGET_PMD_QAT |
+                       BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC
        },
        {
                .test_descr = "3DES-128-CBC HMAC-SHA1 Encryption Digest"