From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 381A0A046B for ; Fri, 23 Aug 2019 12:43:52 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 235A01BFF5; Fri, 23 Aug 2019 12:42:39 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by dpdk.org (Postfix) with ESMTP id 6844B1BFD9 for ; Fri, 23 Aug 2019 12:42:30 +0200 (CEST) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id x7NAeZx6004055; Fri, 23 Aug 2019 03:42:29 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : references : in-reply-to : content-type : content-transfer-encoding : mime-version; s=pfpt0818; bh=51942rlzYaEBI0/tZI8dgLQiRPtIMhxiKL6eM9cXQmg=; b=x4OfNscnXaWVpJlgTOUDDsFwrjCgxAX+FHcIIfjNxU+vzoeG7o/dnz9eTeURytfO4pPI k7vlxUs+dh8f61NJqATZbBOYWvIZr/JjYJRK9ByPx5FnkiOEP/3oggS5Rwk7zxeTMo7b K8PqsatpUJYgIWpzqRjQnXXwN+jyYsfoWvi5KB2WVW6Ry9WY64y/S4oKS318yD6j7h6L ER9/ve1M3mzoeH6DTxAwXmx7VloMl6plLdnWqEsE7kzJpW7D2/zmvdb7PJBV7sOo5bHb 7VSFXGlzH6B2ciFNM1xGksW4unTqYjCwzMYt5kE3rQ48ZmcmYxTBf01QEQ7sUqnggbKc ig== Received: from sc-exch04.marvell.com ([199.233.58.184]) by mx0a-0016f401.pphosted.com with ESMTP id 2uhad40cgp-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Fri, 23 Aug 2019 03:42:29 -0700 Received: from SC-EXCH03.marvell.com (10.93.176.83) by SC-EXCH04.marvell.com (10.93.176.84) with Microsoft SMTP Server (TLS) id 15.0.1367.3; Fri, 23 Aug 2019 03:42:28 -0700 Received: from NAM02-SN1-obe.outbound.protection.outlook.com (104.47.36.52) by SC-EXCH03.marvell.com (10.93.176.83) with Microsoft SMTP Server (TLS) id 15.0.1367.3 via Frontend Transport; Fri, 23 Aug 2019 03:42:28 -0700 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=KxouhbbEKov9sKr/PNwjTubknIvo7h0lzaozIHV3J52vIhZpgn34rcRAF8ev4DSQQsLJB9xnSTWwJaFZ/V+UftK1xEbJ14OMyEFQhlv9s+R1w4LAVptt28XDpUHy560H0SiMaDhXZ1RoyVh3uC6xyImLyiD8aa2wpkc+vu2dd4iXCKlI3ZidrgBCUlOZaOV+hJ7UaDK5QFiw8sQdkR2cu6yKd2/fKePDKmgCQhyZuPs6s9LfnQ1Nx7W7sltQ5TkpmXO88ZDEq34jDJ2/Aun54XQMRx77aXY8QubKcZkoC8mYsUl5XV0QQCATKJKKY+MKw6K9HefIMo19f0VNlgMMyA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=51942rlzYaEBI0/tZI8dgLQiRPtIMhxiKL6eM9cXQmg=; b=JxJLRp/E4Cf0COR5iX3GAwulYhHdeCJBdQWHMWLd1Y9NHBcRDrp6I6/8ORiECJEC8IBusfIcFv0gD3hV8vFZTUWDwYfSeQg7L4KtgTLLAuxOni1TGmgYWb5JfTYZ+NQdg8jOpoBnymTXzBEcojkZqca9SZCvHZEqQ6fnLSl9SxIti1r9pHGH6ihWL3+Ca99aGEWDDqmoMAKtAYO9boKrbi1IQ1+mJ1ucJrA0Bvi2qbl+LctzkU9gbbbhhTHx6TmHBfjrCfCuzR4dHtuZSZ7oNwg/gAxh08wh1/oYJ2Id0M0ho+UUSoYTjPkOAByYPO2zf6y7C+BZ+XMamqlt7ll9mg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=marvell.com; dmarc=pass action=none header.from=marvell.com; dkim=pass header.d=marvell.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.onmicrosoft.com; s=selector2-marvell-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=51942rlzYaEBI0/tZI8dgLQiRPtIMhxiKL6eM9cXQmg=; b=pds8BVfIpuqWIMQ/INQ1Tz46aex3HAf4ZJ2h2Sf870xZKr6kC1R5FiAyecwl0dXBILv7V73EHLficknE3o1e4lBYjgSIQmqoIlF/OJcPF7Daugk8fD4Flw8ZIH98e4tyJ4Rzga2UetljRvLsOB4rZMHNXLiHKVr3sn/9WMzEaj4= Received: from MN2PR18MB2797.namprd18.prod.outlook.com (20.179.22.16) by MN2PR18MB2830.namprd18.prod.outlook.com (20.179.23.157) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2178.18; Fri, 23 Aug 2019 10:42:24 +0000 Received: from MN2PR18MB2797.namprd18.prod.outlook.com ([fe80::28ff:b1d2:ef69:5e84]) by MN2PR18MB2797.namprd18.prod.outlook.com ([fe80::28ff:b1d2:ef69:5e84%5]) with mapi id 15.20.2178.018; Fri, 23 Aug 2019 10:42:24 +0000 From: Nagadheeraj Rottela To: "akhil.goyal@nxp.com" , "pablo.de.lara.guarch@intel.com" CC: "dev@dpdk.org" , Srikanth Jampala , Nagadheeraj Rottela Thread-Topic: [PATCH v3 09/11] crypto/nitrox: add cipher auth crypto chain processing Thread-Index: AQHVWZ9ywkz2QvduLEWbUMSG4TpF2A== Date: Fri, 23 Aug 2019 10:42:23 +0000 Message-ID: <20190823104144.19300-10-rnagadheeraj@marvell.com> References: <20190717052837.647-1-rnagadheeraj@marvell.com> <20190823104144.19300-1-rnagadheeraj@marvell.com> In-Reply-To: <20190823104144.19300-1-rnagadheeraj@marvell.com> Accept-Language: en-IN, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: PN1PR01CA0110.INDPRD01.PROD.OUTLOOK.COM (2603:1096:c00::26) To MN2PR18MB2797.namprd18.prod.outlook.com (2603:10b6:208:a0::16) x-ms-exchange-messagesentrepresentingtype: 1 x-mailer: git-send-email 2.13.6 x-originating-ip: [115.113.156.2] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: ee0c3ed1-4a59-466b-a7c6-08d727b6951c x-microsoft-antispam: BCL:0; PCL:0; RULEID:(2390118)(7020095)(4652040)(8989299)(4534185)(7168020)(4627221)(201703031133081)(201702281549075)(8990200)(5600166)(711020)(4605104)(1401327)(2017052603328)(7193020); SRVR:MN2PR18MB2830; x-ms-traffictypediagnostic: MN2PR18MB2830: x-ms-exchange-transport-forked: True x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:2657; x-forefront-prvs: 0138CD935C x-forefront-antispam-report: SFV:NSPM; SFS:(10009020)(4636009)(39860400002)(366004)(396003)(376002)(136003)(346002)(25214002)(189003)(199004)(26005)(81166006)(14454004)(2616005)(476003)(5660300002)(86362001)(71190400001)(71200400001)(316002)(486006)(36756003)(25786009)(66066001)(53936002)(11346002)(446003)(305945005)(7736002)(54906003)(110136005)(256004)(14444005)(6486002)(99286004)(3846002)(6436002)(6116002)(478600001)(2906002)(186003)(30864003)(8936002)(6512007)(50226002)(81156014)(55236004)(102836004)(1076003)(107886003)(4326008)(64756008)(66946007)(66446008)(8676002)(66556008)(66476007)(2501003)(6506007)(386003)(52116002)(76176011); DIR:OUT; SFP:1101; SCL:1; SRVR:MN2PR18MB2830; H:MN2PR18MB2797.namprd18.prod.outlook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; received-spf: None (protection.outlook.com: marvell.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam-message-info: BaBIPqyCbyCLW3y21w2g4P+1RoB4mmpsmdO0IfFG1hrrnBqwNDbo6mEi0wxfHHEcmaNqaByZxkQnCVddMDSQtix2Mzxw0CMwgTDkHTW//Tpl9juHwbBfHYO7VQ7Nni++CITpeQkwRkhHa7/OPd2HIclaHANiDZzjdFBI52Ps8NLjH6wtfHoi0ckdDx3i7oM+T0vDKMG6iILVyftLDtRaoKKwBfviCL6wTL+ow1ciyh4ynkuxz5yTrZMu21ePps1SBrfQHd88TFSUjJWtQbACM4xFhbl9m/KSq6jFBdelKFfny1KaPmuE8d76NYZqpL64G01Je8yvKSQ/JcekGv5DgjjSNp/nHBGP+BeTvWKViSAdexs2aW4lZgyMJx0tn1t3WXacBpIyIcZX2+BZF3Rx0b2vtabjZeSpg0oWsYvlKkE= Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-MS-Exchange-CrossTenant-Network-Message-Id: ee0c3ed1-4a59-466b-a7c6-08d727b6951c X-MS-Exchange-CrossTenant-originalarrivaltime: 23 Aug 2019 10:42:23.9356 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 70e1fb47-1155-421d-87fc-2e58f638b6e0 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: AKdHWVc+tukrs4Fq0Tt20k/Xu4ACstlSjPlXCkl/oA97wz4D/obwbkwAy+zg5M/rfyiPIlgK/rZSx+C5ha2EkmP7pv2gItso6fZTfhEl3ms= X-MS-Exchange-Transport-CrossTenantHeadersStamped: MN2PR18MB2830 X-OriginatorOrg: marvell.com X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:5.22.84,1.0.8 definitions=2019-08-23_04:2019-08-21,2019-08-23 signatures=0 Subject: [dpdk-dev] [PATCH v3 09/11] crypto/nitrox: add cipher auth crypto chain processing 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" Add cipher auth crypto chain processing functionality in symmetric request manager. Signed-off-by: Nagadheeraj Rottela --- drivers/crypto/nitrox/nitrox_sym_reqmgr.c | 427 ++++++++++++++++++++++++++= +++- 1 file changed, 425 insertions(+), 2 deletions(-) diff --git a/drivers/crypto/nitrox/nitrox_sym_reqmgr.c b/drivers/crypto/nit= rox/nitrox_sym_reqmgr.c index a37b754f2..968e74fbe 100644 --- a/drivers/crypto/nitrox/nitrox_sym_reqmgr.c +++ b/drivers/crypto/nitrox/nitrox_sym_reqmgr.c @@ -10,9 +10,24 @@ #include "nitrox_sym_reqmgr.h" #include "nitrox_logs.h" =20 +#define MAX_SGBUF_CNT 16 +#define MAX_SGCOMP_CNT 5 +/* SLC_STORE_INFO */ +#define MIN_UDD_LEN 16 +/* PKT_IN_HDR + SLC_STORE_INFO */ +#define FDATA_SIZE 32 +/* Base destination port for the solicited requests */ +#define SOLICIT_BASE_DPORT 256 #define PENDING_SIG 0xFFFFFFFFFFFFFFFFUL #define CMD_TIMEOUT 2 =20 +struct gphdr { + uint16_t param0; + uint16_t param1; + uint16_t param2; + uint16_t param3; +}; + union pkt_instr_hdr { uint64_t value; struct { @@ -105,12 +120,46 @@ struct resp_hdr { uint64_t completion; }; =20 +struct nitrox_sglist { + uint16_t len; + uint16_t raz0; + uint32_t raz1; + rte_iova_t iova; + void *virt; +}; + +struct nitrox_sgcomp { + uint16_t len[4]; + uint64_t iova[4]; +}; + +struct nitrox_sgtable { + uint8_t map_bufs_cnt; + uint8_t nr_sgcomp; + uint16_t total_bytes; + + struct nitrox_sglist sglist[MAX_SGBUF_CNT]; + struct nitrox_sgcomp sgcomp[MAX_SGCOMP_CNT]; +}; + +struct iv { + uint8_t *virt; + rte_iova_t iova; + uint16_t len; +}; + struct nitrox_softreq { struct nitrox_crypto_ctx *ctx; struct rte_crypto_op *op; + struct gphdr gph; struct nps_pkt_instr instr; struct resp_hdr resp; + struct nitrox_sgtable in; + struct nitrox_sgtable out; + struct iv iv; uint64_t timeout; + rte_iova_t dptr; + rte_iova_t rptr; rte_iova_t iova; }; =20 @@ -121,10 +170,383 @@ softreq_init(struct nitrox_softreq *sr, rte_iova_t i= ova) sr->iova =3D iova; } =20 +/* + * 64-Byte Instruction Format + * + * ---------------------- + * | DPTR0 | 8 bytes + * ---------------------- + * | PKT_IN_INSTR_HDR | 8 bytes + * ---------------------- + * | PKT_IN_HDR | 16 bytes + * ---------------------- + * | SLC_INFO | 16 bytes + * ---------------------- + * | Front data | 16 bytes + * ---------------------- + */ +static void +create_se_instr(struct nitrox_softreq *sr, uint8_t qno) +{ + struct nitrox_crypto_ctx *ctx =3D sr->ctx; + rte_iova_t ctx_handle; + + /* fill the packet instruction */ + /* word 0 */ + sr->instr.dptr0 =3D rte_cpu_to_be_64(sr->dptr); + + /* word 1 */ + sr->instr.ih.value =3D 0; + sr->instr.ih.s.g =3D 1; + sr->instr.ih.s.gsz =3D sr->in.map_bufs_cnt; + sr->instr.ih.s.ssz =3D sr->out.map_bufs_cnt; + sr->instr.ih.s.fsz =3D FDATA_SIZE + sizeof(struct gphdr); + sr->instr.ih.s.tlen =3D sr->instr.ih.s.fsz + sr->in.total_bytes; + sr->instr.ih.value =3D rte_cpu_to_be_64(sr->instr.ih.value); + + /* word 2 */ + sr->instr.irh.value[0] =3D 0; + sr->instr.irh.s.uddl =3D MIN_UDD_LEN; + /* context length in 64-bit words */ + sr->instr.irh.s.ctxl =3D RTE_ALIGN_MUL_CEIL(sizeof(ctx->fctx), 8) / 8; + /* offset from solicit base port 256 */ + sr->instr.irh.s.destport =3D SOLICIT_BASE_DPORT + qno; + /* Invalid context cache */ + sr->instr.irh.s.ctxc =3D 0x3; + sr->instr.irh.s.arg =3D ctx->req_op; + sr->instr.irh.s.opcode =3D ctx->opcode; + sr->instr.irh.value[0] =3D rte_cpu_to_be_64(sr->instr.irh.value[0]); + + /* word 3 */ + ctx_handle =3D ctx->iova + offsetof(struct nitrox_crypto_ctx, fctx); + sr->instr.irh.s.ctxp =3D rte_cpu_to_be_64(ctx_handle); + + /* word 4 */ + sr->instr.slc.value[0] =3D 0; + sr->instr.slc.s.ssz =3D sr->out.map_bufs_cnt; + sr->instr.slc.value[0] =3D rte_cpu_to_be_64(sr->instr.slc.value[0]); + + /* word 5 */ + sr->instr.slc.s.rptr =3D rte_cpu_to_be_64(sr->rptr); + /* + * No conversion for front data, + * It goes into payload + * put GP Header in front data + */ + memcpy(&sr->instr.fdata[0], &sr->gph, sizeof(sr->instr.fdata[0])); + sr->instr.fdata[1] =3D 0; + /* flush the soft_req changes before posting the cmd */ + rte_wmb(); +} + +static void +softreq_copy_iv(struct nitrox_softreq *sr) +{ + sr->iv.virt =3D rte_crypto_op_ctod_offset(sr->op, uint8_t *, + sr->ctx->iv.offset); + sr->iv.iova =3D rte_crypto_op_ctophys_offset(sr->op, sr->ctx->iv.offset); + sr->iv.len =3D sr->ctx->iv.length; +} + +static int +extract_cipher_auth_digest(struct nitrox_softreq *sr, + struct nitrox_sglist *digest) +{ + struct rte_crypto_op *op =3D sr->op; + struct rte_mbuf *mdst =3D op->sym->m_dst ? op->sym->m_dst : + op->sym->m_src; + + if (sr->ctx->auth_op =3D=3D RTE_CRYPTO_AUTH_OP_VERIFY && + unlikely(!op->sym->auth.digest.data)) + return -EINVAL; + + digest->len =3D sr->ctx->digest_length; + if (op->sym->auth.digest.data) { + digest->iova =3D op->sym->auth.digest.phys_addr; + digest->virt =3D op->sym->auth.digest.data; + + return 0; + } + + if (unlikely(rte_pktmbuf_data_len(mdst) < op->sym->auth.data.offset + + op->sym->auth.data.length + digest->len)) + return -EINVAL; + + digest->iova =3D rte_pktmbuf_mtophys_offset(mdst, + op->sym->auth.data.offset + + op->sym->auth.data.length); + digest->virt =3D rte_pktmbuf_mtod_offset(mdst, uint8_t *, + op->sym->auth.data.offset + + op->sym->auth.data.length); + + return 0; +} + +static void +fill_sglist(struct nitrox_sgtable *sgtbl, uint16_t len, rte_iova_t iova, + void *virt) +{ + struct nitrox_sglist *sglist =3D sgtbl->sglist; + uint8_t cnt =3D sgtbl->map_bufs_cnt; + + if (unlikely(!len)) + return; + + sglist[cnt].len =3D len; + sglist[cnt].iova =3D iova; + sglist[cnt].virt =3D virt; + sgtbl->total_bytes +=3D len; + cnt++; + + sgtbl->map_bufs_cnt =3D cnt; +} + +static int +create_sglist_from_mbuf(struct nitrox_sgtable *sgtbl, struct rte_mbuf *mbu= f, + uint32_t off, int datalen) +{ + struct nitrox_sglist *sglist =3D sgtbl->sglist; + uint8_t cnt =3D sgtbl->map_bufs_cnt; + struct rte_mbuf *m; + int mlen; + + if (unlikely(datalen <=3D 0)) + return 0; + + for (m =3D mbuf; m && off > rte_pktmbuf_data_len(m); m =3D m->next) + off -=3D rte_pktmbuf_data_len(m); + + if (unlikely(!m)) + return -EIO; + + mlen =3D rte_pktmbuf_data_len(m) - off; + if (datalen <=3D mlen) + mlen =3D datalen; + sglist[cnt].len =3D mlen; + sglist[cnt].iova =3D rte_pktmbuf_mtophys_offset(m, off); + sglist[cnt].virt =3D rte_pktmbuf_mtod_offset(m, uint8_t *, off); + sgtbl->total_bytes +=3D mlen; + cnt++; + datalen -=3D mlen; + + for (m =3D m->next; m && datalen; m =3D m->next) { + mlen =3D rte_pktmbuf_data_len(m) < datalen ? + rte_pktmbuf_data_len(m) : datalen; + sglist[cnt].len =3D mlen; + sglist[cnt].iova =3D rte_pktmbuf_mtophys(m); + sglist[cnt].virt =3D rte_pktmbuf_mtod(m, uint8_t *); + sgtbl->total_bytes +=3D mlen; + cnt++; + datalen -=3D mlen; + } + + RTE_VERIFY(cnt <=3D MAX_SGBUF_CNT); + sgtbl->map_bufs_cnt =3D cnt; + + return 0; +} + +static int +create_cipher_auth_sglist(struct nitrox_softreq *sr, + struct nitrox_sgtable *sgtbl, struct rte_mbuf *mbuf) +{ + struct rte_crypto_op *op =3D sr->op; + int auth_only_len; + int err; + + fill_sglist(sgtbl, sr->iv.len, sr->iv.iova, sr->iv.virt); + + auth_only_len =3D op->sym->auth.data.length - op->sym->cipher.data.length= ; + if (unlikely(auth_only_len < 0)) + return -EINVAL; + + err =3D create_sglist_from_mbuf(sgtbl, mbuf, op->sym->auth.data.offset, + auth_only_len); + if (unlikely(err)) + return err; + + err =3D create_sglist_from_mbuf(sgtbl, mbuf, op->sym->cipher.data.offset, + op->sym->cipher.data.length); + if (unlikely(err)) + return err; + + return 0; +} + +static void +create_sgcomp(struct nitrox_sgtable *sgtbl) +{ + int i, j, nr_sgcomp; + struct nitrox_sgcomp *sgcomp =3D sgtbl->sgcomp; + struct nitrox_sglist *sglist =3D sgtbl->sglist; + + nr_sgcomp =3D RTE_ALIGN_MUL_CEIL(sgtbl->map_bufs_cnt, 4) / 4; + sgtbl->nr_sgcomp =3D nr_sgcomp; + + for (i =3D 0; i < nr_sgcomp; i++, sgcomp++) { + for (j =3D 0; j < 4; j++, sglist++) { + sgcomp->len[j] =3D rte_cpu_to_be_16(sglist->len); + sgcomp->iova[j] =3D rte_cpu_to_be_64(sglist->iova); + } + } +} + +static int +create_cipher_auth_inbuf(struct nitrox_softreq *sr, + struct nitrox_sglist *digest) +{ + int err; + struct nitrox_crypto_ctx *ctx =3D sr->ctx; + + err =3D create_cipher_auth_sglist(sr, &sr->in, sr->op->sym->m_src); + + if (unlikely(err)) + return err; + + if (ctx->auth_op =3D=3D RTE_CRYPTO_AUTH_OP_VERIFY) + fill_sglist(&sr->in, digest->len, digest->iova, digest->virt); + + create_sgcomp(&sr->in); + sr->dptr =3D sr->iova + offsetof(struct nitrox_softreq, in.sgcomp); + + return 0; +} + +static int +create_cipher_auth_oop_outbuf(struct nitrox_softreq *sr, + struct nitrox_sglist *digest) +{ + int err; + struct nitrox_crypto_ctx *ctx =3D sr->ctx; + + err =3D create_cipher_auth_sglist(sr, &sr->out, sr->op->sym->m_dst); + if (unlikely(err)) + return err; + + if (ctx->auth_op =3D=3D RTE_CRYPTO_AUTH_OP_GENERATE) + fill_sglist(&sr->out, digest->len, digest->iova, digest->virt); + + return 0; +} + +static void +create_cipher_auth_inplace_outbuf(struct nitrox_softreq *sr, + struct nitrox_sglist *digest) +{ + int i, cnt; + struct nitrox_crypto_ctx *ctx =3D sr->ctx; + + cnt =3D sr->out.map_bufs_cnt; + for (i =3D 0; i < sr->in.map_bufs_cnt; i++, cnt++) { + sr->out.sglist[cnt].len =3D sr->in.sglist[i].len; + sr->out.sglist[cnt].iova =3D sr->in.sglist[i].iova; + sr->out.sglist[cnt].virt =3D sr->in.sglist[i].virt; + } + + sr->out.map_bufs_cnt =3D cnt; + if (ctx->auth_op =3D=3D RTE_CRYPTO_AUTH_OP_GENERATE) { + fill_sglist(&sr->out, digest->len, digest->iova, + digest->virt); + } else if (ctx->auth_op =3D=3D RTE_CRYPTO_AUTH_OP_VERIFY) { + sr->out.map_bufs_cnt--; + } +} + +static int +create_cipher_auth_outbuf(struct nitrox_softreq *sr, + struct nitrox_sglist *digest) +{ + struct rte_crypto_op *op =3D sr->op; + int cnt =3D 0; + + sr->resp.orh =3D PENDING_SIG; + sr->out.sglist[cnt].len =3D sizeof(sr->resp.orh); + sr->out.sglist[cnt].iova =3D sr->iova + offsetof(struct nitrox_softreq, + resp.orh); + sr->out.sglist[cnt].virt =3D &sr->resp.orh; + cnt++; + + sr->out.map_bufs_cnt =3D cnt; + if (op->sym->m_dst) { + int err; + + err =3D create_cipher_auth_oop_outbuf(sr, digest); + if (unlikely(err)) + return err; + } else { + create_cipher_auth_inplace_outbuf(sr, digest); + } + + cnt =3D sr->out.map_bufs_cnt; + sr->resp.completion =3D PENDING_SIG; + sr->out.sglist[cnt].len =3D sizeof(sr->resp.completion); + sr->out.sglist[cnt].iova =3D sr->iova + offsetof(struct nitrox_softreq, + resp.completion); + sr->out.sglist[cnt].virt =3D &sr->resp.completion; + cnt++; + + RTE_VERIFY(cnt <=3D MAX_SGBUF_CNT); + sr->out.map_bufs_cnt =3D cnt; + + create_sgcomp(&sr->out); + sr->rptr =3D sr->iova + offsetof(struct nitrox_softreq, out.sgcomp); + + return 0; +} + +static void +create_aead_gph(uint32_t cryptlen, uint16_t ivlen, uint32_t authlen, + struct gphdr *gph) +{ + int auth_only_len; + union { + struct { +#if RTE_BYTE_ORDER =3D=3D RTE_BIG_ENDIAN + uint16_t iv_offset : 8; + uint16_t auth_offset : 8; +#else + uint16_t auth_offset : 8; + uint16_t iv_offset : 8; +#endif + }; + uint16_t value; + } param3; + + gph->param0 =3D rte_cpu_to_be_16(cryptlen); + gph->param1 =3D rte_cpu_to_be_16(authlen); + + auth_only_len =3D authlen - cryptlen; + gph->param2 =3D rte_cpu_to_be_16(ivlen + auth_only_len); + + param3.iv_offset =3D 0; + param3.auth_offset =3D ivlen; + gph->param3 =3D rte_cpu_to_be_16(param3.value); + +} + static int process_cipher_auth_data(struct nitrox_softreq *sr) { - RTE_SET_USED(sr); + struct rte_crypto_op *op =3D sr->op; + int err; + struct nitrox_sglist digest; + + softreq_copy_iv(sr); + err =3D extract_cipher_auth_digest(sr, &digest); + if (unlikely(err)) + return err; + + err =3D create_cipher_auth_inbuf(sr, &digest); + if (unlikely(err)) + return err; + + err =3D create_cipher_auth_outbuf(sr, &digest); + if (unlikely(err)) + return err; + + create_aead_gph(op->sym->cipher.data.length, sr->iv.len, + op->sym->auth.data.length, &sr->gph); + return 0; } =20 @@ -135,6 +557,7 @@ process_softreq(struct nitrox_softreq *sr) int err =3D 0; =20 switch (ctx->nitrox_chain) { + break; case NITROX_CHAIN_CIPHER_AUTH: case NITROX_CHAIN_AUTH_CIPHER: err =3D process_cipher_auth_data(sr); @@ -152,11 +575,11 @@ nitrox_process_se_req(uint16_t qno, struct rte_crypto= _op *op, struct nitrox_crypto_ctx *ctx, struct nitrox_softreq *sr) { - RTE_SET_USED(qno); softreq_init(sr, sr->iova); sr->ctx =3D ctx; sr->op =3D op; process_softreq(sr); + create_se_instr(sr, qno); sr->timeout =3D rte_get_timer_cycles() + CMD_TIMEOUT * rte_get_timer_hz()= ; return 0; } --=20 2.13.6