From patchwork Tue Aug 28 13:01:05 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Akhil Goyal X-Patchwork-Id: 43927 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 6BDFE4CB9; Tue, 28 Aug 2018 15:04:25 +0200 (CEST) Received: from EUR02-HE1-obe.outbound.protection.outlook.com (mail-eopbgr10078.outbound.protection.outlook.com [40.107.1.78]) by dpdk.org (Postfix) with ESMTP id DC8544CA0 for ; Tue, 28 Aug 2018 15:04:20 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=AEWNWBB6wo2cFFMnTnQj/LdroSgunXUzygnrScwRAiA=; b=nr6S0PD8/pw2jqnqekl1uXnF0057jLvVuIo7nDPetodzmyyS+JMhtD7KVjImq9EiUAb9iTM9yIyeUNyo5o6YbwlS40+V0NL8SYHXl2EA6fSfTCyCh5rVdSIaCujcOX++hp/35B5O5ClLZ4Gy13GndKp6QVOCVIBH3Uvayy3XzrU= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=akhil.goyal@nxp.com; Received: from GDB1.ap.freescale.net (14.143.30.134) by VI1PR04MB1390.eurprd04.prod.outlook.com (2a01:111:e400:5348::21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1080.17; Tue, 28 Aug 2018 13:04:18 +0000 From: akhil.goyal@nxp.com To: dev@dpdk.org Cc: Akhil Goyal Date: Tue, 28 Aug 2018 18:31:05 +0530 Message-Id: <20180828130105.30779-4-akhil.goyal@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180828130105.30779-1-akhil.goyal@nxp.com> References: <20180828130105.30779-1-akhil.goyal@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.143.30.134] X-ClientProxiedBy: MAXPR0101CA0046.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00:d::32) To VI1PR04MB1390.eurprd04.prod.outlook.com (2a01:111:e400:5348::21) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 3418fc5d-39fc-4ca4-652c-08d60ce6c439 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:VI1PR04MB1390; X-Microsoft-Exchange-Diagnostics: 1; VI1PR04MB1390; 3:xwAWXVeGxhNr9HA5fwcgVeoXa/recL8qvO3zp5p0dsJYcJ+3LIeSaCZAyJsbOCaGXap6JkWtctRbztbbyKFcBmYewlOEGt33HxHWoTlCAMBawPbQ+J9d89xelo+a65RZmpo09IlTRlkKmRh54607ZvUov6bZ+/TmaGuTjBYdHxmlwjSiYpJEgZkzox8hGAZHG7lpXLUF+0nQJbBGXvugWEAfJi6hYjb4H4T2R4/Vql2RT/GQwKZhROnkNJAZtRI7; 25:xpgdJxpRcfXENBqKsXSvScXd0WW7ewuFl5mkn2r8n10EuP1oT2TjQ/L39h6RCBZEVXqStTNJ1MvJbLiO7D9t2JVrvo08TLX8FOiEkRAKzrVXN6s8eUQ1gAHzkDOIcP/rrEIJtTxsQRVa4nBHpXAS5BtqHHJ2x6GEVdOKe9VdCkDNRCVqXFX8rM91JG4p3Y3b7+fcdh8gIvqpe+kVGhGjkjN2NsURSPDcAVF9mmSXwhhzafLR7+vEQNEQtAlkHZ8YJbLNtMPn4k9sH4eDQk8Qr5YMHaVmjxGz3D6NHKbIz5i2PDfarxLdQuqGgjRdl6FkkV4Be+OtjbxYg7uexrFjBA==; 31:GBrx8YGzVa20mRGRa2h2A7l9oykj+luQQzNhfLM9PKNUECCvsI5lH8HVAyrZdu7IwO3gaBMNgOCBicswEi36n/Cme+5pJ8vZ5TH/vIQNyqP080GsHZB9Y9d1UNYO6Dk/ylQZYssRBvmhp0qASKOy4qYt9neGL+WIT7cu5aWrvPgah1j8amGh59anVyzn0EeOmGrcRo3bpbttDbEUKZMFgdfvIRD0TNbOq1iFh1oSjpM= X-MS-TrafficTypeDiagnostic: VI1PR04MB1390: X-Microsoft-Exchange-Diagnostics: 1; VI1PR04MB1390; 20:n+Dw4pLP62djH0GiL/5xvt2MAUIXaEVxsH6o9aq9tx4wLXxwYwcUiX0OuOJXabsRcin2QA1j+loVi1WqqzCPE7WsxgJ9FGA79mhdK8MR176iVivnz5txNTFuP8xgRoZAYAlsHBlyKUg/CCZi+jfh6+7RhiQOylF1/MZHO4z4BUZa0NcwjVHvT8C0U6oDu4ZrlfvG7dOEGQmsB8hiohwOAK7wKFviVjWoFpWxuuvXDSu8R5ZwU0/jHpIed48c/TmFnSLMNpwHM2c8yHkqtJPHN3BtImosfS7K9BvtvTWUnXqUG2RrjfBk68NEjeLzWOZqycam0KDETdDopzi/mezhz0pEs/1HCrE0k5vej4CP692IjNdYtqtKkz2s/YwoSKdOude14XVVcKNmgDFJAZUNbdBoD845CUJcljhP5Zaed3237omV9Hrax3tTepCiMCTU9hNQ2X0Yww9xTR29xqES7tbDfpQsek9+X0lXuxD/gexpxB3oC1NlvNTuOkBZsxha; 4:Ax1HFIBcwdHWiv11YBhCDh3HkxYUusxjBi39ua8k1vtZpBGUNRL/S+MGaEgffXwNEOjN/+2rtkYngwkJdi/NbUQkA9jws4SCLTlreB7Kk2wNpsBnKLrUJaRcteGwmizNQWeNeUEQEvPvv+wvf4UpK1tlkPU8c2Ok5mmckO7RC7MlDia7f0MVDqeKTz5EHCyVchewQ/thblr5L0LbPRRJW851Mq3MCrfUN+x0m8ehVO8grGoIOOgoPfjz7LNSdQ1DPVyIMCaiimK7ZnN6JWEX4Sp4t7tXCCuzZY8SgRS/EuxjgWlMAcCxRHdPkfDGD/VEZgitwVguig+IEgd8Y/P66Q== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197)(163750095850); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(823301075)(10201501046)(93006095)(93001095)(3231311)(944501410)(52105095)(3002001)(6055026)(149027)(150027)(6041310)(20161123564045)(20161123560045)(20161123562045)(20161123558120)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(201708071742011)(7699016); SRVR:VI1PR04MB1390; BCL:0; PCL:0; RULEID:; SRVR:VI1PR04MB1390; X-Forefront-PRVS: 077884B8B5 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(39860400002)(346002)(136003)(376002)(366004)(396003)(189003)(199004)(5009440100003)(8676002)(55236004)(97736004)(316002)(186003)(26005)(6506007)(386003)(50466002)(50226002)(51416003)(16526019)(16586007)(48376002)(76176011)(8936002)(478600001)(52116002)(33896004)(53936002)(25786009)(956004)(47776003)(2351001)(6666003)(7736002)(14444005)(36756003)(85782001)(1076002)(5660300001)(2361001)(11346002)(105586002)(9686003)(66066001)(6512007)(446003)(2906002)(106356001)(305945005)(486006)(4326008)(81156014)(81166006)(68736007)(6486002)(2616005)(476003)(6916009)(86362001)(6116002)(3846002)(110426005)(85772001); DIR:OUT; SFP:1101; SCL:1; SRVR:VI1PR04MB1390; H:GDB1.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; VI1PR04MB1390; 23:SV7sTUDdWXScUqOkaGHyMoxBhiuv6+vYdBciKV7S3?= b0dhFCAau074fLUu5xNiO1dt4jA655GfRvfErWXguLy3muTdMkAIbglx+lTI9yDGEbnHhEyufNNjWNWAQf1Iy8eGj5lOCUKBaY9DfSz4qRFy6rbBk2RI72UDz5IQMnVSCwDRFTbpBHBdF2vRmhXDu2li905mXaJMweeKnKzsU325DVQlP/GigGbKlIujmCc9JUPksvX/tb00kGfUgMwMNVoLyJHYUV0sHhO3p1wTt2AlE/n21ZVzQneFSsLTl/5zSDonmmhPtXQuL5ds4Gssb3oI9NzD/Gt8QxCilqSYL+VXNTyhhWBvepL5cLtzzuYrM/3/Xt1cx/vpv1cf4eZTpvsZWMSUfQioaT8+5DXsZddPZtvls2n21sEi96afYSAAdsgLRob6AJnKrRh1Y8rcgpE27U0hCBi2Y96uJBhZszdVbGEGk4jj9QLWSw55p004uQPuZKzL4oFN0gD1K7XGlzCmgo8BTw8Z+0WACZGyZXD9zPgYkh03IPwJtpWZ3mphiFrYLFCUiueGlcUfajPHJHZBd955qOaLAuhz5Kpg5kSB76g0imQYhYBWbInSwUl2BRMHaUmtePpt2lsrTGFlzQoXDJgpeCpjGADPnJvrojG3ThQSgjr8DnpU7U8SNVQQSx5kRaTCN5XIF1fwbiwLUXZ0WUQJG0LAYbciuuCGG9bZspzOWWvK1JOFgp+kHk9rxa/lJeE96ifFeDbDs0Wnx5q5AlGEV4zK//IUXpBbWUz0HRuyHBcCHObbuflW/wYAAdKZjf6mYAsnffnB/BYojjqqzTk20HZ+AkjjN0MFQ6VmqDPNuN8mok9Mo2SKvH7tp53xiEUdeVeDh7VP7at2S8dJJFDgBP76/y74m7leSxylbekaHzev+cXUXBN5tz4pPUejD+YB686gHnQAYrN5rCjv19ssXR89n2jCOMzig2p8OmHqopSdBbLi02U2z0rFXbtQGoj2DN62K22LmWAz26nkVv8fSB8aO3CZKRQBsB9CJg8BhIkoQgYF+Ree0Ik46NQnmKVFfgrb5lpeSTtfYidnu1hnDuj7iXQtEdk9QVnek8LsNE9+JB7y7V4f1ntXql+t4lqTXjRJl+81prZZeP13DsYozYZlrw5MdOz0Jr1YPSJBgTPGqqVhqbT336c8nr+XFNWWcBoFXAjpQ84MGqVn3kMpfOExMOXpzMWvIk5DOle8NJ7loehmnNQ4ABwBGM0eOzbrv9fj9F1YqMG8QY0yITJyOmDR5YAbbeUa5zpWOtniTRLvO7MsfrovtSBPDqdksvEdsp22wjmbFlU//4H68fUfY+tiuUOl4LLLJreCoNC7aEHh29ahavf69A03xAy6tySd9p/3xfxsqunXcoA X-Microsoft-Antispam-Message-Info: 3heX1V0haPevR9mWCzsZGShMKNStySDvKMvIagBfnEr+yZUooY7PE5QmDnERLzZfB+KZX6SA/+LpUngWDKlYJ0FHDvPdS3cBTb5jmy++vY8MXNR0NgW4vzmN1NtxfffxJUVHJzEeFCaC6BWUZAUQYEyX6Hb7ICFtq8m2kfAso92Ldf9HWwHGbXwTpSC6ETcNB2R7m/0fRH3/T+EZW0MB58AnmKFu4GmGeyGirUwth62G+u61Vn7c4KXrLGBLRpU0MNgX0Sbh18vmxawyjCMu6BLjEcfH6RXAdr15NTmHmTBIE+nlNnhVbSIdrpIQF5n6VCX6xnJK1UIE/KfwaTh2cnM6m4/KxzNXhv29d4MRfg4= X-Microsoft-Exchange-Diagnostics: 1; VI1PR04MB1390; 6:Gxi1kAeiEUYK87cNm3/JEOxgn5imfVO3PaPtPRYhvpDUoSrKCVfGHZRszauoNbbWO6zA5i24YR4iQs9x3UCARvaqWSK9ELlttDwyWI9Bq0WzJQbGAH+j39bX+DEmpu9UqxhZhwFKk9c4vCs+219fsANJWsPD9BT6KgFX19T8orCM/TI92H+Z+wOyEyk3yy/NmLZCPpbtQKIHNkkTqkkSHPUtcqzHG8IslZ2qiCTd+h5C423ZTd/tL/wpPIJwWAkL9SSdwJhhIeixhB6JcT+S3dayAHIDPWMHhWotzmsQ+fXypNe/PaVx8NMDMAFkg6K80sW69/Uqlo3VVLUH3xigeXqwg6rxyv1N/0LEmMxcPmW56Ch9et/2DBARhv3Ne1pZEan3ccMKIpMDWNC/vxaFaxhcvQ8hhk3LnnaeIuyLmJs1peKYRavCfyRMR5cnl0FV4as7yz8EHPdWE/Ntwue8Lw==; 5:l03p6LLmVI0WwHQWUK4/pwxwYGg/vuOT7JBq5yQvu3n8jrUY03y2Czvf9up39oWKs91GJrkIEbnzwqITsQ7u8R8HcUZUT2BxOIbHcQnqfCuS8Q5n5oFV53dOtekhh23v5DCl6aeuB/ts/D9MNx77EC8xAXxKkUIW4SjyZ3tkURI=; 7:GkIXAGKf8goIS0UWH6y18mzrUxgm3sIUYDDIH+nSZO5h5QXptCaS/Js4E6UXBj5aGd/LU9h/zqoyLJEqsd0q+Ld0VbfZawrfSvcIaeLEOtHEksnWpaSSRj3v3Ox22XpmpBa8Y00xjYBPpHyxq8de5HKN2fClpeSnKY9sPZhpPueGjNvsF/NivvMsTxgDD79GnenQJAMzS5ChzQKQ/Zp34odXib9slGCNLIRUZbR8qCACELUd+Y5kq4qGiXWIJtwy SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 28 Aug 2018 13:04:18.4043 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 3418fc5d-39fc-4ca4-652c-08d60ce6c439 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR04MB1390 Subject: [dpdk-dev] [PATCH 3/3] crypto/dpaa2_sec: support pdcp offload X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Akhil Goyal Signed-off-by: Hemant Agrawal Signed-off-by: Akhil Goyal --- drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c | 294 ++++++++++++++++++++ drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h | 172 ++++++++++++ 2 files changed, 466 insertions(+) diff --git a/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c b/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c index 2a3c61c66..ef4e1ab37 100644 --- a/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c +++ b/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c @@ -35,6 +35,7 @@ typedef uint64_t dma_addr_t; /* RTA header files */ #include +#include #include /* Minimum job descriptor consists of a oneword job descriptor HEADER and @@ -61,6 +62,70 @@ static uint8_t cryptodev_driver_id; int dpaa2_logtype_sec; +static inline int +build_proto_compound_fd(dpaa2_sec_session *sess, + struct rte_crypto_op *op, + struct qbman_fd *fd, uint16_t bpid) +{ + struct rte_crypto_sym_op *sym_op = op->sym; + struct ctxt_priv *priv = sess->ctxt; + struct qbman_fle *fle, *ip_fle, *op_fle; + struct sec_flow_context *flc; + struct rte_mbuf *src_mbuf = sym_op->m_src; + struct rte_mbuf *dst_mbuf = sym_op->m_dst; + int retval; + + if (!dst_mbuf) + dst_mbuf = src_mbuf; + + /* Save the shared descriptor */ + flc = &priv->flc_desc[0].flc; + + /* we are using the first FLE entry to store Mbuf */ + retval = rte_mempool_get(priv->fle_pool, (void **)(&fle)); + if (retval) { + DPAA2_SEC_ERR("Memory alloc failed"); + return -1; + } + memset(fle, 0, FLE_POOL_BUF_SIZE); + DPAA2_SET_FLE_ADDR(fle, (size_t)op); + DPAA2_FLE_SAVE_CTXT(fle, (ptrdiff_t)priv); + + op_fle = fle + 1; + ip_fle = fle + 2; + + if (likely(bpid < MAX_BPID)) { + DPAA2_SET_FD_BPID(fd, bpid); + DPAA2_SET_FLE_BPID(op_fle, bpid); + DPAA2_SET_FLE_BPID(ip_fle, bpid); + } else { + DPAA2_SET_FD_IVP(fd); + DPAA2_SET_FLE_IVP(op_fle); + DPAA2_SET_FLE_IVP(ip_fle); + } + + /* Configure FD as a FRAME LIST */ + DPAA2_SET_FD_ADDR(fd, DPAA2_VADDR_TO_IOVA(op_fle)); + DPAA2_SET_FD_COMPOUND_FMT(fd); + DPAA2_SET_FD_FLC(fd, (ptrdiff_t)flc); + + /* Configure Output FLE with dst mbuf data */ + DPAA2_SET_FLE_ADDR(op_fle, DPAA2_MBUF_VADDR_TO_IOVA(dst_mbuf)); + DPAA2_SET_FLE_OFFSET(op_fle, dst_mbuf->data_off); + DPAA2_SET_FLE_LEN(op_fle, dst_mbuf->buf_len); + + /* Configure Input FLE with src mbuf data */ + DPAA2_SET_FLE_ADDR(ip_fle, DPAA2_MBUF_VADDR_TO_IOVA(src_mbuf)); + DPAA2_SET_FLE_OFFSET(ip_fle, src_mbuf->data_off); + DPAA2_SET_FLE_LEN(ip_fle, src_mbuf->pkt_len); + + DPAA2_SET_FD_LEN(fd, ip_fle->length); + DPAA2_SET_FLE_FIN(ip_fle); + + return 0; + +} + static inline int build_proto_fd(dpaa2_sec_session *sess, struct rte_crypto_op *op, @@ -1124,6 +1189,9 @@ build_sec_fd(struct rte_crypto_op *op, case DPAA2_SEC_IPSEC: ret = build_proto_fd(sess, op, fd, bpid); break; + case DPAA2_SEC_PDCP: + ret = build_proto_compound_fd(sess, op, fd, bpid); + break; case DPAA2_SEC_HASH_CIPHER: default: DPAA2_SEC_ERR("error: Unsupported session"); @@ -2375,6 +2443,228 @@ dpaa2_sec_set_ipsec_session(struct rte_cryptodev *dev, return -1; } +static int +dpaa2_sec_set_pdcp_session(struct rte_cryptodev *dev, + struct rte_security_session_conf *conf, + void *sess) +{ + struct rte_security_pdcp_xform *pdcp_xform = &conf->pdcp; + struct rte_crypto_sym_xform *xform = conf->crypto_xform; + struct rte_crypto_auth_xform *auth_xform = NULL; + struct rte_crypto_cipher_xform *cipher_xform; + dpaa2_sec_session *session = (dpaa2_sec_session *)sess; + struct ctxt_priv *priv; + struct dpaa2_sec_dev_private *dev_priv = dev->data->dev_private; + struct alginfo authdata, cipherdata; + int bufsize = -1; + struct sec_flow_context *flc; + + PMD_INIT_FUNC_TRACE(); + + memset(session, 0, sizeof(dpaa2_sec_session)); + + priv = (struct ctxt_priv *)rte_zmalloc(NULL, + sizeof(struct ctxt_priv) + + sizeof(struct sec_flc_desc), + RTE_CACHE_LINE_SIZE); + + if (priv == NULL) { + DPAA2_SEC_ERR("No memory for priv CTXT"); + return -ENOMEM; + } + + priv->fle_pool = dev_priv->fle_pool; + flc = &priv->flc_desc[0].flc; + + /* find xfrm types */ + if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER && xform->next == NULL) { + cipher_xform = &xform->cipher; + } else if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER && + xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH) { + session->ext_params.aead_ctxt.auth_cipher_text = true; + cipher_xform = &xform->cipher; + auth_xform = &xform->next->auth; + } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH && + xform->next->type == RTE_CRYPTO_SYM_XFORM_CIPHER) { + session->ext_params.aead_ctxt.auth_cipher_text = false; + cipher_xform = &xform->next->cipher; + auth_xform = &xform->auth; + } else { + DPAA2_SEC_ERR("Invalid crypto type"); + return -EINVAL; + } + + session->ctxt_type = DPAA2_SEC_PDCP; + if (cipher_xform) { + session->cipher_key.data = rte_zmalloc(NULL, + cipher_xform->key.length, + RTE_CACHE_LINE_SIZE); + if (session->cipher_key.data == NULL && + cipher_xform->key.length > 0) { + DPAA2_SEC_ERR("No Memory for cipher key"); + rte_free(priv); + return -ENOMEM; + } + session->cipher_key.length = cipher_xform->key.length; + memcpy(session->cipher_key.data, cipher_xform->key.data, + cipher_xform->key.length); + session->dir = (cipher_xform->op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ? + DIR_ENC : DIR_DEC; + session->cipher_alg = cipher_xform->algo; + } else { + session->cipher_key.data = NULL; + session->cipher_key.length = 0; + session->cipher_alg = RTE_CRYPTO_CIPHER_NULL; + session->dir = DIR_ENC; + } + + cipherdata.key = (size_t)session->cipher_key.data; + cipherdata.keylen = session->cipher_key.length; + cipherdata.key_enc_flags = 0; + cipherdata.key_type = RTA_DATA_IMM; + + switch (session->cipher_alg) { + case RTE_CRYPTO_CIPHER_SNOW3G_UEA2: + cipherdata.algtype = PDCP_CIPHER_TYPE_SNOW; + break; + case RTE_CRYPTO_CIPHER_ZUC_EEA3: + cipherdata.algtype = PDCP_CIPHER_TYPE_ZUC; + break; + case RTE_CRYPTO_CIPHER_AES_CTR: + cipherdata.algtype = PDCP_CIPHER_TYPE_AES; + break; + case RTE_CRYPTO_CIPHER_NULL: + cipherdata.algtype = PDCP_CIPHER_TYPE_NULL; + break; + default: + DPAA2_SEC_ERR("Crypto: Undefined Cipher specified %u", + session->cipher_alg); + goto out; + } + + /* Auth is only applicable for control mode operation. */ + if (pdcp_xform->domain == RTE_SECURITY_PDCP_MODE_CONTROL) { + if (pdcp_xform->sn_size != RTE_SECURITY_PDCP_SN_SIZE_5) { + DPAA2_SEC_ERR( + "PDCP Seq Num size should be 5 bits for cmode"); + goto out; + } + if (auth_xform) { + session->auth_key.data = rte_zmalloc(NULL, + auth_xform->key.length, + RTE_CACHE_LINE_SIZE); + if (session->auth_key.data == NULL && + auth_xform->key.length > 0) { + DPAA2_SEC_ERR("No Memory for auth key"); + rte_free(session->cipher_key.data); + rte_free(priv); + return -ENOMEM; + } + session->auth_key.length = auth_xform->key.length; + memcpy(session->auth_key.data, auth_xform->key.data, + auth_xform->key.length); + session->auth_alg = auth_xform->algo; + } else { + session->auth_key.data = NULL; + session->auth_key.length = 0; + session->auth_alg = RTE_CRYPTO_AUTH_NULL; + } + authdata.key = (size_t)session->auth_key.data; + authdata.keylen = session->auth_key.length; + authdata.key_enc_flags = 0; + authdata.key_type = RTA_DATA_IMM; + + switch (session->auth_alg) { + case RTE_CRYPTO_AUTH_SNOW3G_UIA2: + authdata.algtype = PDCP_AUTH_TYPE_SNOW; + break; + case RTE_CRYPTO_AUTH_ZUC_EIA3: + authdata.algtype = PDCP_AUTH_TYPE_ZUC; + break; + case RTE_CRYPTO_AUTH_AES_CMAC: + authdata.algtype = PDCP_AUTH_TYPE_AES; + break; + case RTE_CRYPTO_AUTH_NULL: + authdata.algtype = PDCP_AUTH_TYPE_NULL; + break; + default: + DPAA2_SEC_ERR("Crypto: Unsupported auth alg %u", + session->auth_alg); + goto out; + } + + if (session->dir == DIR_ENC) + bufsize = cnstr_shdsc_pdcp_c_plane_encap( + priv->flc_desc[0].desc, 1, 0, + pdcp_xform->hfn, + pdcp_xform->bearer, + pdcp_xform->pkt_dir, + pdcp_xform->hfn_threshold, + &cipherdata, &authdata, + 0); + else if (session->dir == DIR_DEC) + bufsize = cnstr_shdsc_pdcp_c_plane_decap( + priv->flc_desc[0].desc, 1, 0, + pdcp_xform->hfn, + pdcp_xform->bearer, + pdcp_xform->pkt_dir, + pdcp_xform->hfn_threshold, + &cipherdata, &authdata, + 0); + } else { + if (session->dir == DIR_ENC) + bufsize = cnstr_shdsc_pdcp_u_plane_encap( + priv->flc_desc[0].desc, 1, 0, + pdcp_xform->sn_size, + pdcp_xform->hfn, + pdcp_xform->bearer, + pdcp_xform->pkt_dir, + pdcp_xform->hfn_threshold, + &cipherdata, 0); + else if (session->dir == DIR_DEC) + bufsize = cnstr_shdsc_pdcp_u_plane_decap( + priv->flc_desc[0].desc, 1, 0, + pdcp_xform->sn_size, + pdcp_xform->hfn, + pdcp_xform->bearer, + pdcp_xform->pkt_dir, + pdcp_xform->hfn_threshold, + &cipherdata, 0); + } + + if (bufsize < 0) { + DPAA2_SEC_ERR("Crypto: Invalid buffer length"); + goto out; + } + + /* Enable the stashing control bit */ + DPAA2_SET_FLC_RSC(flc); + flc->word2_rflc_31_0 = lower_32_bits( + (size_t)&(((struct dpaa2_sec_qp *) + dev->data->queue_pairs[0])->rx_vq) | 0x14); + flc->word3_rflc_63_32 = upper_32_bits( + (size_t)&(((struct dpaa2_sec_qp *) + dev->data->queue_pairs[0])->rx_vq)); + + flc->word1_sdl = (uint8_t)bufsize; + + /* Set EWS bit i.e. enable write-safe */ + DPAA2_SET_FLC_EWS(flc); + /* Set BS = 1 i.e reuse input buffers as output buffers */ + DPAA2_SET_FLC_REUSE_BS(flc); + /* Set FF = 10; reuse input buffers if they provide sufficient space */ + DPAA2_SET_FLC_REUSE_FF(flc); + + session->ctxt = priv; + + return 0; +out: + rte_free(session->auth_key.data); + rte_free(session->cipher_key.data); + rte_free(priv); + return -1; +} + static int dpaa2_sec_security_session_create(void *dev, struct rte_security_session_conf *conf, @@ -2397,6 +2687,10 @@ dpaa2_sec_security_session_create(void *dev, break; case RTE_SECURITY_PROTOCOL_MACSEC: return -ENOTSUP; + case RTE_SECURITY_PROTOCOL_PDCP: + ret = dpaa2_sec_set_pdcp_session(cdev, conf, + sess_private_data); + break; default: return -EINVAL; } diff --git a/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h b/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h index d015be1e9..907374346 100644 --- a/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h +++ b/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h @@ -390,6 +390,162 @@ static const struct rte_cryptodev_capabilities dpaa2_sec_capabilities[] = { RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST() }; +static const struct rte_cryptodev_capabilities dpaa2_pdcp_capabilities[] = { + { /* SNOW 3G (UIA2) */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2, + .block_size = 16, + .key_size = { + .min = 16, + .max = 16, + .increment = 0 + }, + .digest_size = { + .min = 4, + .max = 4, + .increment = 0 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + { /* SNOW 3G (UEA2) */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + .block_size = 16, + .key_size = { + .min = 16, + .max = 16, + .increment = 0 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + { /* AES CTR */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_AES_CTR, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + { /* NULL (AUTH) */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_NULL, + .block_size = 1, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .digest_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .iv_size = { 0 } + }, }, + }, }, + }, + { /* NULL (CIPHER) */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_NULL, + .block_size = 1, + .key_size = { + .min = 0, + .max = 0, + .increment = 0 + }, + .iv_size = { + .min = 0, + .max = 0, + .increment = 0 + } + }, }, + }, } + }, + { /* ZUC (EEA3) */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3, + .block_size = 16, + .key_size = { + .min = 16, + .max = 16, + .increment = 0 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + { /* ZUC (EIA3) */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_ZUC_EIA3, + .block_size = 16, + .key_size = { + .min = 16, + .max = 16, + .increment = 0 + }, + .digest_size = { + .min = 4, + .max = 4, + .increment = 0 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + + RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST() +}; + static const struct rte_security_capability dpaa2_sec_security_cap[] = { { /* IPsec Lookaside Protocol offload ESP Transport Egress */ .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, @@ -413,6 +569,22 @@ static const struct rte_security_capability dpaa2_sec_security_cap[] = { }, .crypto_capabilities = dpaa2_sec_capabilities }, + { /* PDCP Lookaside Protocol offload Data */ + .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_PDCP, + .pdcp = { + .domain = RTE_SECURITY_PDCP_MODE_DATA, + }, + .crypto_capabilities = dpaa2_pdcp_capabilities + }, + { /* PDCP Lookaside Protocol offload Control */ + .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_PDCP, + .pdcp = { + .domain = RTE_SECURITY_PDCP_MODE_CONTROL, + }, + .crypto_capabilities = dpaa2_pdcp_capabilities + }, { .action = RTE_SECURITY_ACTION_TYPE_NONE }