From patchwork Wed Jul 25 17:04:54 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ashish Gupta X-Patchwork-Id: 43362 X-Patchwork-Delegate: pablo.de.lara.guarch@intel.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 07FBC4C88; Wed, 25 Jul 2018 18:43:13 +0200 (CEST) Received: from NAM01-BN3-obe.outbound.protection.outlook.com (mail-bn3nam01on0079.outbound.protection.outlook.com [104.47.33.79]) by dpdk.org (Postfix) with ESMTP id 59BC049E1 for ; Wed, 25 Jul 2018 18:43:10 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=CAVIUMNETWORKS.onmicrosoft.com; s=selector1-cavium-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=OK+jHJFXV63TlxYPOIPzmCN7gOcxYTUo1eW7BmHl2RM=; b=iCfaxQRZ2pWYo96G9U7P2HNZKyh8H36RrN82mkh/RER1jUL8lAutbfbbqI1JemeBMPutptgz8Qa+3OOMCp5goGx64dp2PxcQH47A8QjqHbav0uRxodc6ZCwJxHKLODZTb7f2TzeY3YrMc0BDsqvdgFic8uNASw627thbDFXjIz4= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Ashish.Gupta@cavium.com; Received: from hyd1agupta-dt.caveonetworks.com (115.113.156.2) by CY4PR07MB3062.namprd07.prod.outlook.com (2603:10b6:903:d1::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.973.21; Wed, 25 Jul 2018 16:43:06 +0000 From: Ashish Gupta To: pablo.de.lara.guarch@intel.com Cc: dev@dpdk.org, narayanaprasad.athreya@cavium.com, mahipal.challa@cavium.com, fiona.trahe@intel.com, Ashish Gupta , Shally Verma , Sunila Sahu Date: Wed, 25 Jul 2018 22:34:54 +0530 Message-Id: <20180725170456.3319-5-Ashish.Gupta@caviumnetworks.com> X-Mailer: git-send-email 2.14.3 In-Reply-To: <20180725170456.3319-1-Ashish.Gupta@caviumnetworks.com> References: <20180725170456.3319-1-Ashish.Gupta@caviumnetworks.com> MIME-Version: 1.0 X-Originating-IP: [115.113.156.2] X-ClientProxiedBy: MA1PR01CA0106.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00:1::22) To CY4PR07MB3062.namprd07.prod.outlook.com (2603:10b6:903:d1::15) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: b99c4b67-49ff-44e9-6c4f-08d5f24db3f0 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989117)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600073)(711020)(2017052603328)(7153060)(7193020); SRVR:CY4PR07MB3062; X-Microsoft-Exchange-Diagnostics: 1; CY4PR07MB3062; 3:ECigK/CDBHmBluY95fsFsfv55en8PZGBbAZAgxDPEHStQkQViy1cg15lRvTvxdVDoKxUEDnVg2ZwcYK9D4U9CqvKXKwKZ/QIfcDd3bi2IoNpJb2kOf1voYzmyhYoGcAJaKsdLVWdB05FM1t5KvFCq42KYhVIC/IiMVSqEVzxo9Ho9sJouaitVMC7NRn5QFymDd0XDZ2q6vdA4cBDlkYKPoxjWlV+eEawkaYNa4qC3h0+7k5PFWAebXQSa1B48FWK; 25:7nWALGOH+iPnCfBPcgvcuE1WQ9eBsDrzEXQAXEzN5rTlx/O/aaYHRx97SXT+8zAS9Nm2gSVmm9m5cJYrOLKR2rExiNXWNKKVjuOST1rUyynKT6sHUzoUB+2xZuF8f0QsmRgQm/Vi+lSRY+7waDyBtil1pkKKa0y2nU9gq4S60eaNbcQLW4g6JgGGxmd5j/fDdjMJtLlOREGwc79Zn7dxlXtQxICXo+PTnO2Oc5kzqUOMneXKyR97z86ual4+enOmfF+4oHI2Ue9HE2JWb4URcRsUonq67+G5nIvePhTkTysnfVvpB/5zKx6snbj2en0su6hG4koeeum3EXaWkoSa/Q==; 31:7vJuVqpTkSHifFdZ3EUNig0A30xMMAy6oExwzafyM27xzrvSC+AtPpAs+FNppWpASOu39NJ6p1topNTEAWvbt1XnqVfUXBu9mBq/LHfceCsNyst/yLWlWp4TnLE/HTTI3+11cIiJJnf8fnkT+2lMn0Mm3XxFTc8RabhhQjxfoDVlKbns/l8tNY2Hm5d6OdlEuWOvvyXHHRd1XuzJ2KOXIWgD5fbhz5EejN6bgNxwRq4= X-MS-TrafficTypeDiagnostic: CY4PR07MB3062: X-Microsoft-Exchange-Diagnostics: 1; CY4PR07MB3062; 20:p7pQh8qpptkHOyx4cn4g5gYudgwoDih9/5JHl3tOR3wK5tYYwovKRB5bsGx23ldospF57YYiwVaW2MCt6InzLKwFayoBFosFoSJRkV2R+hyDo3CXF2GXCVp29H0e88YZeI9uMLwiu73vIT4KKpO4fxMpcgEkPfYfCxYCac7IWG874sh7lbqSW6vxtUWWseGjPNt+PCZggZffYGBGj9MQFXduFrRW2Unbxa78c2M1SeblrFziMszQX95P9UBOqKgzgQOW623lH0zhGcYxaqlE5pU6KAVuvpvez+4UA3HwWiy6vuRvE/CHmwMzE878jYkV51u+xxeDEO2s+Zx4LHUyvDjJtolu6yMdqE1U5rbb5mbcOhTe26YGl4w6EgbryZhpnONy+KMFMz0FiJSl4rC52CGFa+xf8vggbxZoB3v9+7vRRJ5Lhwy54Klb3p2hD0HV0/0wWocgdflFs0Ox9yIa5Srym0m7BZvWJA+uJy5rXvW/YsBiP8MSLdh5Y9X37AZ40TQEzujlDf7jWMdX2IIxVYY9az11MQ8Uok8d1soaLYDMOK3w/4/L7HtTynwNH3pZ9P4AaTRNue924cnMVgc1Tqpih99sVbqKFRntwoXGfG4=; 4:J4um4jDwHW17G0wrxNMiCOmw+KYzgv4oQ2j6i5Ijll2gMRDdW+53/kvBIDrC+bkChn2TBBDTuHrQnDsZe66ZHvGlrgM0veGzaDDQ57+jBMcFZXmHXqx2RQZZrL/Wxvp2pcRvR/lqVhWj7uSe7/0HnFxRZ8XAD7P/YHVN5ZqqyfQM5zKk/qMrWFwADD7CZKSiBUmsYA4VxhDyiv40jP5wgsL8+Bfu1lDwkiTgGs+L9IuBacokQ04qN1dKkB4Eqg6IPCRCKG6/zrtLg4MKFv5kzQ== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(10201501046)(3002001)(93006095)(3231311)(944501410)(52105095)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123564045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(6072148)(201708071742011)(7699016); SRVR:CY4PR07MB3062; BCL:0; PCL:0; RULEID:; SRVR:CY4PR07MB3062; X-Forefront-PRVS: 0744CFB5E8 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(396003)(376002)(346002)(136003)(366004)(39860400002)(189003)(199004)(2616005)(956004)(446003)(25786009)(69596002)(6486002)(2351001)(53416004)(81156014)(8676002)(11346002)(47776003)(105586002)(4326008)(66066001)(81166006)(486006)(8936002)(476003)(2361001)(26005)(186003)(16526019)(42882007)(7736002)(106356001)(68736007)(386003)(305945005)(6506007)(50226002)(107886003)(6512007)(51416003)(48376002)(52116002)(54906003)(72206003)(14444005)(50466002)(6666003)(97736004)(6916009)(5660300001)(478600001)(76176011)(16586007)(53936002)(3846002)(36756003)(2906002)(6116002)(55236004)(1076002)(316002); DIR:OUT; SFP:1101; SCL:1; SRVR:CY4PR07MB3062; H:hyd1agupta-dt.caveonetworks.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: cavium.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; CY4PR07MB3062; 23:/voOwR1GQnE7iyjMCtNHLpNjaJzjgSm/4MAdskH1N?= NyX29ymEnnLYhelXtb1oqKqlHmEpX+G/DGkKTecop12aW88OtLlSFI/6az71JTFp88U/6hkIECYkryfYX0ju/dEl6ylCOOoOasbxtTIiUvTDPn2KxufHk9Srw1SHpQTHcnENBeBjQgJ1bp9cUfJvh4NBV9KXjqRuD8SDjI6l/1YEChO9qpBFaW6LpSxc++b9fJkYxuiQivxmXjpMDYWiiU3dIrJeCBMqSy58MvLJTeH2teLhEWz0DGAsau3Q+xpARLvDZL6CXeeOVmN1DosfXzqP8GCDBMRy0EXKr3vdbKCrxYghtsbdkczsvo4LtnRWnYwGt01fyoob7282NO6Gm3Z767ml8Xv60hGri8GZ0Wl3L+7xD2bug+drxf/w2FfjetGFtQ9TooTOgElQGAMGuUAERf/lpZCFqcmrkrIAydfAnNRJdkvyr8efglTjwHiwYAeoPrahVclY05H0bBQ7ObQPP5csu/dWmuSjg2yqTnucBN7POKK2A5D4DKju1x94a+m6MWORxB+qjKw0N7EWEzFf1biuiLtVDdmXuOLEnxpGU0gVdAl8yIHed9Xik7zaYILQFD6Z5OtS27xnWOUe19Ggma1hD7bhD+GqYFFKnTqLnDlaE58zQo/o1nobGrvvD0iUtE/qLPuX6d+mimQxej6hwnlvlYqCL3768Qx5qgC66JFxXhjSWfyHItyupORGUrw9Lj8HDCSGyJoulXcMQtcUmT6QUoHOmuEOCGjPvQjjIXHprAJSm3383+qi1PU0UCn+zCHbkwv0ISP734hwses4l5jCgyXlq2UIdJcGqytybXWvgngyZyl7EH8lqHavOM7zh3E23RHQ5DjV8j03kqAzJ3TbMvj5y3KN9pTtQfnk9gXe3fBWwrcmlqsegdAvjKJeTya3O95OpGhzexA/6Rs3x+cuyvJAt7XrtrJ2+rxCddASc0CbtlRsMmGBZMU4TI9nAYEbmBWIKD6ibSe3dQgVwh8PMh0ge3NaQMcuVcrco+ls/jtP/uSXyZ1lFFKKAzrjn7+zj1N5leMuK9ORkEUub3yh/LboNKQOL4dERXJQmGOkxXP8cnDjTKmV/R07sxwwsO1r9Lb9Z3MheOcFTZbpTGSGhg2iLrFcEwwEWSGfsSC9DV+3pPeTHyXFXdITyE9o7JH95xHq2dDTgDdAnsWDo1wkRteYw6deAEtOJzRgU1BjX6G+mh6BoryYhxfpA5U3kSo02Df1eacpyBbUiPqSGH4/9HcIhqMWTjQFtLsvSk+93tnC/CLwl6uT7TXsrGwg7NZ7kDpO1Xgu/4/SspN6FpVHASzg8hbcmsmMT2cn3jLmkdptdgF23RO/SUa5Bk= X-Microsoft-Antispam-Message-Info: 4oxAcSEb9XQNVYE2SWZGKovtjbfV7kTlyWhnYhGJhCywYEdmGXflM2QLSuDSxVmGgIOp9hHJjPDH65VwwK2y3Uf9e+HMhvG8tgpPBeUm25oRQKEDKgPqzdAwJ4bTH0pzLUD0ZiO7zV+6qsMrjrmycjPlpt5qlaJmmCoubKz62e47XpMpQ97jf2Gs5P+KSKXvKiyuQeeOkOL6WKfYS9VXdBr4P8iuW55sZmjbmwa8uSk82reH+kVltRcQjw33CSdRJ5BSW7M9KFiHJDirVm55UeCFeNA+ldLQrdRgCzQ0RoQOgUja7OrzKkVdVRF/FewL/uMBdKKnYBiYGayYHv1pp3qqeQnvjNr6WmDRWf9Mnaw= X-Microsoft-Exchange-Diagnostics: 1; CY4PR07MB3062; 6:JRfGrcByCFJkmSTQwPHuPw+e/XvJxueIbCMrrvFmfHTQIOF6Omb6LpOzNlENyp2+Axl/Pmgut/Jy/kXhn04WjLM5+XQKZzj3I5xWua82HphlnQYUDBcgX1qYZZknVlyKYkw1O4Lis0rmZyu+YxtSpyGSSUZNkJOveQjPABwPV17DqfemlY5VwFAZM06CRyyI84p+ooSV/n1Zcn91hTBzxddrqLVpOqEG8asdfDHiEmCEp7nTXCppS1tk/KQ/rW6ppBHDX+RD3hNNdxMTu50Pu/PFqmkX4d6GCgqChBT1Pz3sYcQNBr/Csxvx+XJ7iVzS1+tIL+evg5Me1bZTuOSTX35hwBaQfg/Bb9KGUlO5nTQsc+OIZ0rs96T8NC1l0DZhQhmY8efruWILYYdIIYF3tXiliD0mYvsBKhny5P4hdZ9D1c5ODZoJi1DleYGt3zey9xN2HnPg4U8QCUDRzDRD/A==; 5:GprvuZfygBLDhNk0ATM9/VXXerqaGr1aeQw/DXBBfzC1m445FGnHroYyA3hFnwf9t5ZHmHBRllwSlpS6FQGvp/VvCz6M+Z7tk9h6OTGdu/M1zFr1FY73LQv5/apebVZolV6UJgcuyAL2m9JDlnVcmESSgT4bdaqB2YfbqRgnNsA=; 7:IU89sim3Hkjm9Ny9wpnTsvl1QoRl7DQ4s47WdULQT/QnSNj68Xn6Ul2x+NvoDsoRpGjrg6tDR4hRrHkHQjf85lYbWPGzA3rYbdpM38nmWvkA1UtHEBvH2pR7usW7MHDsWMR1a+8846+eL+vYMAf3n1OgXDGe8Km6H6HBlXKrF+/hfls/amK37lydCaVyII4AkOR25XtKao24EBH0BzthoNOo3P58ic7oP22Q9g07efKCAbT9lvGDBUH2d9zOgPBp SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: caviumnetworks.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 25 Jul 2018 16:43:06.3093 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: b99c4b67-49ff-44e9-6c4f-08d5f24db3f0 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 711e4ccf-2e9b-4bcf-a551-4094005b6194 X-MS-Exchange-Transport-CrossTenantHeadersStamped: CY4PR07MB3062 Subject: [dpdk-dev] [PATCH v4 4/6] compress/octeontx: support burst enqueue/dequeue 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" Implement enqueue/dequeue APIs to perform compression/decompression operations Signed-off-by: Ashish Gupta Signed-off-by: Shally Verma Signed-off-by: Sunila Sahu --- drivers/compress/octeontx/otx_zip.c | 47 +++++++++++ drivers/compress/octeontx/otx_zip.h | 96 +++++++++++++++++++++- drivers/compress/octeontx/otx_zip_pmd.c | 136 ++++++++++++++++++++++++++++++++ 3 files changed, 278 insertions(+), 1 deletion(-) diff --git a/drivers/compress/octeontx/otx_zip.c b/drivers/compress/octeontx/otx_zip.c index 7c81db1..a9046ff 100644 --- a/drivers/compress/octeontx/otx_zip.c +++ b/drivers/compress/octeontx/otx_zip.c @@ -88,6 +88,53 @@ zipvf_q_term(struct zipvf_qp *qp) return 0; } +void +zipvf_push_command(struct zipvf_qp *qp, union zip_inst_s *cmd) +{ + zip_quex_doorbell_t dbell; + union zip_nptr_s ncp; + uint64_t *ncb_ptr; + struct zipvf_cmdq *cmdq = &qp->cmdq; + void *reg_base = qp->vf->vbar0; + + /*Held queue lock*/ + rte_spinlock_lock(&(cmdq->qlock)); + + /* Check space availability in zip cmd queue */ + if ((((cmdq->sw_head - (uint64_t *)cmdq->va) * sizeof(uint64_t *)) + + ZIP_CMD_SIZE) == (ZIP_MAX_CMDQ_SIZE - ZIP_MAX_NCBP_SIZE)) { + /*Last buffer of the command queue*/ + memcpy((uint8_t *)cmdq->sw_head, + (uint8_t *)cmd, + sizeof(union zip_inst_s)); + /* move pointer to next loc in unit of 64-bit word */ + cmdq->sw_head += ZIP_CMD_SIZE_WORDS; + + /* now, point the "Next-Chunk Buffer Ptr" to sw_head */ + ncb_ptr = cmdq->sw_head; + /* Pointing head again to cmdqueue base*/ + cmdq->sw_head = (uint64_t *)cmdq->va; + + ncp.u = 0ull; + ncp.s.addr = cmdq->iova; + *ncb_ptr = ncp.u; + } else { + /*Enough buffers available in the command queue*/ + memcpy((uint8_t *)cmdq->sw_head, + (uint8_t *)cmd, + sizeof(union zip_inst_s)); + cmdq->sw_head += ZIP_CMD_SIZE_WORDS; + } + + rte_wmb(); + + /* Ringing ZIP VF doorbell */ + dbell.u = 0ull; + dbell.s.dbell_cnt = 1; + zip_reg_write64(reg_base, ZIP_VQ_DOORBELL, dbell.u); + + rte_spinlock_unlock(&(cmdq->qlock)); +} int zipvf_create(struct rte_compressdev *compressdev) diff --git a/drivers/compress/octeontx/otx_zip.h b/drivers/compress/octeontx/otx_zip.h index 3fcd86a..fc2dfe4 100644 --- a/drivers/compress/octeontx/otx_zip.h +++ b/drivers/compress/octeontx/otx_zip.h @@ -159,6 +159,95 @@ struct zip_vf { /* pointer to pools */ } __rte_cache_aligned; + +static inline void +zipvf_prepare_in_buf(struct zip_stream *zstrm, struct rte_comp_op *op) +{ + uint32_t offset, inlen; + struct rte_mbuf *m_src; + union zip_inst_s *inst = zstrm->inst; + + inlen = op->src.length; + offset = op->src.offset; + m_src = op->m_src; + + /* Prepare direct input data pointer */ + inst->s.dg = 0; + inst->s.inp_ptr_addr.s.addr = + rte_pktmbuf_iova_offset(m_src, offset); + inst->s.inp_ptr_ctl.s.length = inlen; +} + +static inline void +zipvf_prepare_out_buf(struct zip_stream *zstrm, struct rte_comp_op *op) +{ + uint32_t offset; + struct rte_mbuf *m_dst; + union zip_inst_s *inst = zstrm->inst; + + offset = op->dst.offset; + m_dst = op->m_dst; + + /* Prepare direct input data pointer */ + inst->s.ds = 0; + inst->s.out_ptr_addr.s.addr = + rte_pktmbuf_iova_offset(m_dst, offset); + inst->s.totaloutputlength = rte_pktmbuf_pkt_len(m_dst) - + op->dst.offset; + inst->s.out_ptr_ctl.s.length = inst->s.totaloutputlength; +} + +static inline void +zipvf_prepare_cmd_stateless(struct rte_comp_op *op, struct zip_stream *zstrm) +{ + union zip_inst_s *inst = zstrm->inst; + + /* set flush flag to always 1*/ + inst->s.ef = 1; + + if (inst->s.op == ZIP_OP_E_DECOMP) + inst->s.sf = 1; + else + inst->s.sf = 0; + + /* Set input checksum */ + inst->s.adlercrc32 = op->input_chksum; + + /* Prepare gather buffers */ + zipvf_prepare_in_buf(zstrm, op); + zipvf_prepare_out_buf(zstrm, op); +} + +#ifdef ZIP_DBG +static inline void +zip_dump_instruction(void *inst) +{ + union zip_inst_s *cmd83 = (union zip_inst_s *)inst; + printf("####### START ########\n"); + printf("doneint:%d totaloutputlength:%d\n", cmd83->s.doneint, + cmd83->s.totaloutputlength); + printf("exnum:%d iv:%d exbits:%d hmif:%d halg:%d\n", cmd83->s.exn, + cmd83->s.iv, cmd83->s.exbits, cmd83->s.hmif, cmd83->s.halg); + printf("flush:%d speed:%d cc:%d\n", cmd83->s.sf, + cmd83->s.ss, cmd83->s.cc); + printf("eof:%d bof:%d op:%d dscatter:%d dgather:%d hgather:%d\n", + cmd83->s.ef, cmd83->s.bf, cmd83->s.op, cmd83->s.ds, + cmd83->s.dg, cmd83->s.hg); + printf("historylength:%d adler32:%d\n", cmd83->s.historylength, + cmd83->s.adlercrc32); + printf("ctx_ptr.addr:0x%lx\n", cmd83->s.ctx_ptr_addr.s.addr); + printf("ctx_ptr.len:%d\n", cmd83->s.ctx_ptr_ctl.s.length); + printf("history_ptr.addr:0x%lx\n", cmd83->s.his_ptr_addr.s.addr); + printf("history_ptr.len:%d\n", cmd83->s.his_ptr_ctl.s.length); + printf("inp_ptr.addr:0x%lx\n", cmd83->s.inp_ptr_addr.s.addr); + printf("inp_ptr.len:%d\n", cmd83->s.inp_ptr_ctl.s.length); + printf("out_ptr.addr:0x%lx\n", cmd83->s.out_ptr_addr.s.addr); + printf("out_ptr.len:%d\n", cmd83->s.out_ptr_ctl.s.length); + printf("result_ptr.len:%d\n", cmd83->s.res_ptr_ctl.s.length); + printf("####### END ########\n"); +} +#endif + int zipvf_create(struct rte_compressdev *compressdev); @@ -171,9 +260,14 @@ zipvf_q_init(struct zipvf_qp *qp); int zipvf_q_term(struct zipvf_qp *qp); -int +void zipvf_push_command(struct zipvf_qp *qp, union zip_inst_s *zcmd); +int +zip_process_op(struct rte_comp_op *op, + struct zipvf_qp *qp, + struct zip_stream *zstrm); + uint64_t zip_reg_read64(uint8_t *hw_addr, uint64_t offset); diff --git a/drivers/compress/octeontx/otx_zip_pmd.c b/drivers/compress/octeontx/otx_zip_pmd.c index 16f581b..e211af0 100644 --- a/drivers/compress/octeontx/otx_zip_pmd.c +++ b/drivers/compress/octeontx/otx_zip_pmd.c @@ -28,6 +28,85 @@ static const struct rte_compressdev_capabilities RTE_COMP_END_OF_CAPABILITIES_LIST() }; +/* + * Reset session to default state for next set of stateless operation + */ +static inline void +reset_stream(struct zip_stream *z_stream) +{ + union zip_inst_s *inst = (union zip_inst_s *)(z_stream->inst); + + inst->s.bf = 1; + inst->s.ef = 0; +} + +int +zip_process_op(struct rte_comp_op *op, + struct zipvf_qp *qp, + struct zip_stream *zstrm) +{ + union zip_inst_s *inst = zstrm->inst; + volatile union zip_zres_s *zresult = NULL; + + + if ((op->m_src->nb_segs > 1) || (op->m_dst->nb_segs > 1) || + (op->src.offset > rte_pktmbuf_pkt_len(op->m_src)) || + (op->dst.offset > rte_pktmbuf_pkt_len(op->m_dst))) { + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + ZIP_PMD_ERR("Segmented packet is not supported\n"); + return 0; + } + + zipvf_prepare_cmd_stateless(op, zstrm); + + zresult = (union zip_zres_s *)zstrm->bufs[RES_BUF]; + zresult->s.compcode = 0; + +#ifdef ZIP_DBG + zip_dump_instruction(inst); +#endif + + /* Submit zip command */ + zipvf_push_command(qp, (void *)inst); + + /* Check and Process results in sync mode */ + do { + } while (!zresult->s.compcode); + + if (zresult->s.compcode == ZIP_COMP_E_SUCCESS) { + op->status = RTE_COMP_OP_STATUS_SUCCESS; + } else { + /* FATAL error cannot do anything */ + ZIP_PMD_ERR("operation failed with error code:%d\n", + zresult->s.compcode); + if (zresult->s.compcode == ZIP_COMP_E_DSTOP) + op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED; + else + op->status = RTE_COMP_OP_STATUS_ERROR; + } + + ZIP_PMD_INFO("written %d\n", zresult->s.totalbyteswritten); + + /* Update op stats */ + switch (op->status) { + case RTE_COMP_OP_STATUS_SUCCESS: + op->consumed = zresult->s.totalbytesread; + /* Fall-through */ + case RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED: + op->produced = zresult->s.totalbyteswritten; + break; + default: + ZIP_PMD_ERR("stats not updated for status:%d\n", + op->status); + break; + } + /* zstream is reset irrespective of result */ + reset_stream(zstrm); + + zresult->s.compcode = ZIP_COMP_E_NOTDONE; + return 0; +} + /** Parse xform parameters and setup a stream */ static int zip_set_stream_parameters(struct rte_compressdev *dev, @@ -114,6 +193,7 @@ zip_set_stream_parameters(struct rte_compressdev *dev, inst->s.res_ptr_ctl.s.length = 0; z_stream->inst = inst; + z_stream->func = zip_process_op; return 0; @@ -397,6 +477,60 @@ zip_pmd_stream_free(struct rte_compressdev *dev, void *stream) } +static uint16_t +zip_pmd_enqueue_burst_sync(void *queue_pair, + struct rte_comp_op **ops, uint16_t nb_ops) +{ + struct zipvf_qp *qp = queue_pair; + struct rte_comp_op *op; + struct zip_stream *zstrm; + int i, ret = 0; + uint16_t enqd = 0; + + for (i = 0; i < nb_ops; i++) { + + op = ops[i]; + + if ((op->op_type == RTE_COMP_OP_STATEFUL) || (zstrm == NULL)) { + op->status = RTE_COMP_OP_STATUS_INVALID_ARGS; + } else { + /* process stateless ops */ + zstrm = (struct zip_stream *)op->private_xform; + ret = zstrm->func(op, qp, zstrm); + } + + /* Whatever is out of op, put it into completion queue with + * its status + */ + if (!ret) + ret = rte_ring_enqueue(qp->processed_pkts, (void *)op); + + if (unlikely(ret < 0)) { + /* increment count if failed to enqueue op*/ + qp->qp_stats.enqueue_err_count++; + } else { + qp->qp_stats.enqueued_count++; + enqd++; + } + } + return enqd; +} + +static uint16_t +zip_pmd_dequeue_burst_sync(void *queue_pair, + struct rte_comp_op **ops, uint16_t nb_ops) +{ + struct zipvf_qp *qp = queue_pair; + + unsigned int nb_dequeued = 0; + + nb_dequeued = rte_ring_dequeue_burst(qp->processed_pkts, + (void **)ops, nb_ops, NULL); + qp->qp_stats.dequeued_count += nb_dequeued; + + return nb_dequeued; +} + struct rte_compressdev_ops octtx_zip_pmd_ops = { .dev_configure = zip_pmd_config, .dev_start = zip_pmd_start, @@ -458,6 +592,8 @@ zip_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, compressdev->dev_ops = &octtx_zip_pmd_ops; /* register rx/tx burst functions for data path */ + compressdev->dequeue_burst = zip_pmd_dequeue_burst_sync; + compressdev->enqueue_burst = zip_pmd_enqueue_burst_sync; compressdev->feature_flags = RTE_COMPDEV_FF_HW_ACCELERATED; return ret; }