From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM01-BN3-obe.outbound.protection.outlook.com (mail-bn3nam01on0083.outbound.protection.outlook.com [104.47.33.83]) by dpdk.org (Postfix) with ESMTP id 0A8E35F51 for ; Fri, 5 Oct 2018 15:00:40 +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=+ZokKmbSMoAOOKoKBsXB/Z7L27h6smLaRf2GjNUNpjA=; b=HIDlAbRCwcEMBpf1f1WYU1BtSDJFp/0CBHInIuyB5zVMSvKWTbHHGvSPcxtM6rYzTriKZF+x30kJRIm+E1o69rZTH/vI0uKKnWFwyv4oCoWcy2j5R//h/Wl/qaRlQsEf8uiTmfz6Tc3hUFynRGOLNygFhQ2jI6B8uTIc1g1lZmk= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Anoob.Joseph@cavium.com; Received: from ajoseph83.caveonetworks.com.com (115.113.156.2) by SN6PR07MB4910.namprd07.prod.outlook.com (2603:10b6:805:39::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1207.21; Fri, 5 Oct 2018 13:00:34 +0000 From: Anoob Joseph To: Akhil Goyal , Pablo de Lara , Thomas Monjalon Cc: Anoob Joseph , Jerin Jacob , Narayana Prasad , dev@dpdk.org, Ankur Dwivedi , Murthy NSSR , Nithin Dabilpuram , Ragothaman Jayaraman , Srisivasubramanian S , Tejasree Kondoj Date: Fri, 5 Oct 2018 18:28:57 +0530 Message-Id: <1538744363-30340-7-git-send-email-anoob.joseph@caviumnetworks.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1538744363-30340-1-git-send-email-anoob.joseph@caviumnetworks.com> References: <1536033560-21541-1-git-send-email-ajoseph@caviumnetworks.com> <1538744363-30340-1-git-send-email-anoob.joseph@caviumnetworks.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [115.113.156.2] X-ClientProxiedBy: MA1PR0101CA0036.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00:22::22) To SN6PR07MB4910.namprd07.prod.outlook.com (2603:10b6:805:39::16) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 6a9e9140-d869-4668-733f-08d62ac28c56 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989299)(4534185)(7168020)(4627221)(201703031133081)(201702281549075)(8990200)(5600074)(711020)(2017052603328)(7153060)(7193020); SRVR:SN6PR07MB4910; X-Microsoft-Exchange-Diagnostics: 1; SN6PR07MB4910; 3:oRrcYVYTwJn5vSH1C4KrFrQJgVkpqbrC1C5ANbcp/qw+v9hLhmuuvCwrb0f3XMxRiPOreaCXeg1VdkCQvmYUhyxvPnNEC2biFMt9VAwvr8GZfCav4ub/FFVN/C+qiehG2j6Jzvkie7ol5yABJm2jCU7WljkTvYNBNNWfHe58Ys/18xswQqi9rKnmJ5abCpET2Povf3H5s+UsPxMTrFGQHSBZhkn6PLVKbQjfQrwWIpSgNDhvmTzkoy91iDsQcY8T; 25:rv0o+KuNzwL4FBIc5iJpPzrTvyLAHOjEdlI/Rmdwl2Z/ESeG6n27z3xT32OofI4WMNYwAE5af7bf1VnfcwFZGEuOIdTFQjLlCysqsmEzo/YB5fH9pyCcWrn9Ic3zrbwnYkFzi91yxKON4opxI5sY65WPzlzIoNFI4vuo8ldpgqIPoxT1/UsIQvholRQSrbO635m9skHmo2OOW5px7RfoICFoJte9CARw4WyAqnKgQh9m53m0oZ/C8AX3jqXSTkFxz74eg8GJAFjmMXAPJug3tfBd8+C2/JQjcdWR2bIsdqGQOvm9Z9EkoCQeb+kr9MCE5LIlxHc1RfF0TIA/0GsPUQ==; 31:BkYpnXL8vV6NxPWM3SzlvvMlgZWNqILSo83tpvzzpKh+sfAH8CzeLz5Sl+qTL8Xb5YK6PjFye9OBqhWSmpaFtiBOUQsY4HbMgGEu6RVPIicnY400EdExYE+L6h/98ypGNqmxlSmUnPnU9pRgk+klkaK0Btmj721MrK3hI+9gn6i4SnjCywEYWiOewkup5naA8XXUe4StC2ByqM4VP5wBCdSoSPJBV+nrUAY3mA1F5lU= X-MS-TrafficTypeDiagnostic: SN6PR07MB4910: X-Microsoft-Exchange-Diagnostics: 1; SN6PR07MB4910; 20:T/BE9NMYFRu6C2pL8fDJdiFbPvAkWJvV1aaTtrjBTJi+OAyUG4BX7E+J9Sd3Fnb6oNhxHe/sl9RVaI3bw4VhOc15hCvSA+2tTiMBzc65M37fk1ulIvcP9CdwjOm4VbAtSSnQBITcE2xoZKgUcGGkErTq6cijnfw7fBVCuS3xdjhz/eogctAas3uLHI7YxbDQ0Ol93UnD4uJETcx+Xg1fUYx1e0NVvczD6IVbrahLV+qxVkE6z2ptVXV/NyRCzRVaxY/xRkV3oD+5VNxbiRvI2Dgk+qUZCbg0rGfNfBO0xW4hipfSJAvUFmd2NBRvREXXwRgFu23Nr4L+cuveF97WLZN/yRv8bJxQcZWBphfdEUd6Rrhk6yadFAKX5to0i/Vw3ulN8glDQsohu1joyNH7bNreKqJkETw3hY47m8dd9PBxfvPk8Br7q4H6X5/UCf6vijrigcqa4/YkNLzJmOK2ydDp55jwZLXOskZmsHxRaabFOJIv+X0rW35qNuI9HMUmfyF5OiQ45uQuHfNOy5gFD0RhwCAca8sVfrdHh0dlFM9Wnb2MD/sgPTPV3vMhSzakjm25iJorIFDq8rilC2avO97TRNREsB5LXQFPsvILuog=; 4:6hmIBV0xLSKFZO3P9xj/nZDoRQTVT9C53qI8RUXNium4VofPn2CiH3HPzUiVO5t53HnOKs9Z4kRD0iHGQT5ZPbzCWSrEy884OzzMZD8MmR7aKoKazevZRtd3r/L8FNVeKmTQHMMz4yEPFsV29jFeSSrQOtawmWxeTQbEV+wyTqO/quGE0vVFBrUGzVbabcBAYkCzsAUP5N9Y4Lgdrmfyv0ZWOw7nvC3N8zU3B5MtxbxuZMOLLxVU5wohUgzATaa7TiaRqc5AGg7Ky9HloBdKoA== 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)(8121501046)(5005006)(3002001)(3231355)(944501410)(52105095)(10201501046)(93006095)(149066)(150057)(6041310)(20161123564045)(20161123558120)(20161123560045)(20161123562045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(201708071742011)(7699051); SRVR:SN6PR07MB4910; BCL:0; PCL:0; RULEID:; SRVR:SN6PR07MB4910; X-Forefront-PRVS: 0816F1D86E X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(376002)(39860400002)(346002)(136003)(396003)(366004)(199004)(189003)(51416003)(76176011)(11346002)(50226002)(25786009)(8936002)(48376002)(305945005)(186003)(16526019)(110136005)(6486002)(3846002)(446003)(52116002)(6116002)(81156014)(8676002)(97736004)(5660300001)(50466002)(4326008)(956004)(42882007)(2616005)(68736007)(478600001)(54906003)(7736002)(81166006)(6666003)(16586007)(107886003)(26005)(55236004)(66066001)(386003)(47776003)(6512007)(72206003)(44832011)(476003)(316002)(14444005)(36756003)(4744004)(105586002)(106356001)(486006)(6506007)(2906002)(53936002); DIR:OUT; SFP:1101; SCL:1; SRVR:SN6PR07MB4910; H:ajoseph83.caveonetworks.com.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; A:1; MX:1; Received-SPF: None (protection.outlook.com: cavium.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; SN6PR07MB4910; 23:fx6DJ7nhLdH2fAtJs0MY4vUpcaCx6kRrID8HlNMmf?= =?us-ascii?Q?1INzBz/aSt4PZD/yn9qHG0NkOX/sjxI+kURRR8PrHI+90WjydHUR1WzchfCH?= =?us-ascii?Q?qSl50VXDC3z0c3X6YRonbzs9LliGc3CRYmwX1nmkFeSBgZaP3Q/TKFolLUUv?= =?us-ascii?Q?if7IrqHF+HMiOYhiwIvKg/xJf5/Hh8Z49CpKgaKeB4lQyykFMOwqHzY9r3ZR?= =?us-ascii?Q?cutWwQWjn0o0H3KEs6cdVtJtoFQ1XFvpOxvwmhxeqr/CCQPVf+cG7cntodn7?= =?us-ascii?Q?Pp9E+rPOfEbUZw+YVKCKa7lJKHNovcij7Wt34tRGsINaWVcvCDZ+SNf5IbKr?= =?us-ascii?Q?Xdn+ZxGy0uOy+n2+CC/s24by3ZOh/5Uv8M1uQyxRhKwwLK6dRR8uGdeFCD4v?= =?us-ascii?Q?x82rVb2pXNfw/IaXblntTaugIrqaABmLnuy12AIpOJoDAsde8LGuJ+t0qD9u?= =?us-ascii?Q?iGPqph0TqEWRuIahRfZE9/axlzdaaaa30ssfziPjgnfD9Y/1Q360YQB5d2Dm?= =?us-ascii?Q?lvaqM/6+2K6/ppbFmGM4sbRrfuExPZnwv1eJ16gOnLGLs7Byo5Bhlm/Q5DHi?= =?us-ascii?Q?90ptUEqo7Ng2cqhqzABAHpy6sphON/IhTN89ad+rBvq1+8qRVoYgLnbBbMHK?= =?us-ascii?Q?/gBq5c9QtKM9rBdLoByHv3iQ37lzgkkEhM8ytvLA8zJFdkddedPF6/j06Wua?= =?us-ascii?Q?m9YVuIXfusvKtpODUuP2CQflifHgDKUIoTvc2OtLrWEPnb3qXA0Hi878QXL1?= =?us-ascii?Q?4P4csx8mYX6UtVOxZT9rjsRR/Hx7QAAO3tm0DHwoTZIbPvZ6AA4LfIqkQ7R0?= =?us-ascii?Q?G2POtJj9z5Nuw52+K58N4HS2T95eCtvYej617mZaFJ8AIL2YUoi3VLMZ6rrr?= =?us-ascii?Q?NDab7+JsS1KY7QgE68KZrM4rT22zVeK3LV5GvgEkyfOfAOgPhbbNl3W5Ewik?= =?us-ascii?Q?kOvPqlW2hAegIcd5jyxP20A6edLV8N/l6lgoXj9srwC7vaQ+J/gI3nhMLyq5?= =?us-ascii?Q?oihmuaNmSGdwbcSzOyP8HU1CSwMZmLMqiWrJKLi146m227UTgPamoW6a8AER?= =?us-ascii?Q?8E5NvfYxU6O6n9tlqB/aMPYFVAjNQ7SgMpJSlPT0y0MVuNB1Vo7aL5MQVQag?= =?us-ascii?Q?G3Y5Gq7WEPgKYNG/E2Rlco4jnvnHZG1raLvAZdlIH9zVz9Ac87MbU73G1E/3?= =?us-ascii?Q?1DwNTASW1IM8r5JOrSL0vGFLGlraR96VFgGmcF7qDdXeZNtnl+a1Q27/foO8?= =?us-ascii?Q?TeBa4AaWgLoHfePDMvBslBGpG9QsLlIYmN2A62AnAThVEj4/PV8Lve9+QNty?= =?us-ascii?Q?MfchKtvYXisGtzhV9e5kkw=3D?= X-Microsoft-Antispam-Message-Info: gSP34Lo7TP3adFIHISVdv6Dbm4reMOytRPS1C6zC+sOUC2Lvybrp+gsopym8+gWgF9bf9cU2rqOIXw5GRWzunwaYEy6LqTlv81mqPNBxiY3B7rQgetQVIETQh5kArLZBtR5ph/La3pyB/XTKjliXP/yHnDmN0AVxgY68DhcQMRU90mX0P3wu9503W1n6zfZ8dbLI/VScLUYb7jcgXYJ0SrUvDnCONykMa9Ebbuns1KYfpAyN2QAvzYVTXO4qKaxKQsF4mdCwkloj/bOHgBR9iqyKhUJDB+7ZyWBQexMZlsthrQ8KGPIX79yV1Wuv7aW2xHPXlA+skfiI7MxpToQu+WILHtiM+8dUnttSYWer4bE= X-Microsoft-Exchange-Diagnostics: 1; SN6PR07MB4910; 6:bGXMVYYBrwCNIg+irOZVcNR3lwx68Z4xIsq+I+NhUcWc/KomXInMX1fORTfTNcqFPjiA+4FQo7ZQb1kuej/9+9QFYSmAIy/ZLa2flxFfsgBm1GlwbCtUZNTZC4oMCllcclycoDV1MIlf/LLME3qDI0K5PlH9ZhHhBoR71VaRBCjTfBZZlKXY6TQaxy2LA2s5dAyMfYZ4AdRtoc/5QoIjaao1Mx/Z/+evX5HRp6mUu2AdRYCC8OLkSbKgYbXE+vr//lE8qa2VQhECOCHqiJM3LtA3CD/pQsyITTjnxWYf+GDt6nC0fR/+uVzo+txt27vUd2Ar6yWPjQvqJOnVwhxyTHHmAq3oHAkmkAfBziEQnrQksK7+lTkaCmcQA6INeGS6UhocnBLQWKX7/oCwqIyE4JwReytioPKi91F/XVusXVysGG/DcLyPp7JP9/avNo4mDg4mH5NQNizjlRrcvfJPHw==; 5:k+17t+II1ZZ0m0LqSdD5R6A1/PFWE5nS2bKGmCpG1WLojbokUenjN16dvOb9uL0b/dogXZ6N8seJzPaMWjagKEIETB0sXnyTc9RKa6NND0jdDQkNABTl+L4lr1E74RaV6ewPNtMRsMqpKvgHtGMY02+WM5v4gyaIAg3BCj6qdoM=; 7:IGXxExl7SwXyDV4P26LhJmaV37FL6UhrFKmmwGjuA0ag70XgURVERyqP/GmxQ2abX54ApRvdqgG/H2T/cBPmkpmcwbO/yaSwAI7xDPoJmnkzeY1DhM1SZkgWdjI5a6qAf2qP1Y8Ok5RjIUvpNvqPVGP6mlXtcqy+ExNEs3IzdCrlzgKSiIgUVgZCmnjncEd6SGbw7E9dJXNgRpEFkrl3AaibRbY1e13wIwjqfLXY2ICENpgFnJtwpaGSLIKDPeDF SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: caviumnetworks.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 05 Oct 2018 13:00:34.6272 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 6a9e9140-d869-4668-733f-08d62ac28c56 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 711e4ccf-2e9b-4bcf-a551-4094005b6194 X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN6PR07MB4910 Subject: [dpdk-dev] [PATCH v3 06/32] common/cpt: add hardware register defines 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: , X-List-Received-Date: Fri, 05 Oct 2018 13:00:40 -0000 Signed-off-by: Ankur Dwivedi Signed-off-by: Anoob Joseph Signed-off-by: Murthy NSSR Signed-off-by: Nithin Dabilpuram Signed-off-by: Ragothaman Jayaraman Signed-off-by: Srisivasubramanian S Signed-off-by: Tejasree Kondoj --- drivers/common/cpt/cpt_hw_types.h | 519 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 519 insertions(+) create mode 100644 drivers/common/cpt/cpt_hw_types.h diff --git a/drivers/common/cpt/cpt_hw_types.h b/drivers/common/cpt/cpt_hw_types.h new file mode 100644 index 0000000..0a98621 --- /dev/null +++ b/drivers/common/cpt/cpt_hw_types.h @@ -0,0 +1,519 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Cavium, Inc + */ + +#ifndef _CPT_HW_TYPES_H_ +#define _CPT_HW_TYPES_H_ + +#include + +/* + * This file defines HRM specific structs. + * + */ + +#define CPT_VF_INTR_MBOX_MASK (1<<0) +#define CPT_VF_INTR_DOVF_MASK (1<<1) +#define CPT_VF_INTR_IRDE_MASK (1<<2) +#define CPT_VF_INTR_NWRP_MASK (1<<3) +#define CPT_VF_INTR_SWERR_MASK (1<<4) +#define CPT_VF_INTR_HWERR_MASK (1<<5) +#define CPT_VF_INTR_FAULT_MASK (1<<6) + +/* + * CPT_INST_S software command definitions + * Words EI (0-3) + */ +typedef union { + uint64_t u64; + struct { + uint16_t opcode; + uint16_t param1; + uint16_t param2; + uint16_t dlen; + } s; +} vq_cmd_word0_t; + +typedef union { + uint64_t u64; + struct { +#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN + uint64_t grp : 3; + uint64_t cptr : 61; +#else + uint64_t cptr : 61; + uint64_t grp : 3; +#endif + } s; +} vq_cmd_word3_t; + +typedef struct cpt_vq_command { + vq_cmd_word0_t cmd; + uint64_t dptr; + uint64_t rptr; + vq_cmd_word3_t cptr; +} cpt_vq_cmd_t; + +/** + * Structure cpt_inst_s + * + * CPT Instruction Structure + * This structure specifies the instruction layout. + * Instructions are stored in memory as little-endian unless + * CPT()_PF_Q()_CTL[INST_BE] is set. + */ +typedef union cpt_inst_s { + uint64_t u[8]; + struct cpt_inst_s_8s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_17_63 : 47; + /* [ 16: 16] Done interrupt. + * 0 = No interrupts related to this instruction. + * 1 = When the instruction completes,CPT()_VQ()_DONE[DONE] + * will be incremented, and based on the rules described + * there an interrupt may occur. + */ + uint64_t doneint : 1; + uint64_t reserved_0_15 : 16; +#else /* Word 0 - Little Endian */ + uint64_t reserved_0_15 : 16; + uint64_t doneint : 1; + uint64_t reserved_17_63 : 47; +#endif /* Word 0 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 1 - Big Endian */ + /* [127: 64] Result IOVA. + * If nonzero, specifies where to write CPT_RES_S. + * If zero, no result structure will be written. + * Address must be 16-byte aligned. + * + * Bits <63:49> are ignored by hardware; software should + * use a sign-extended bit <48> for forward compatibility. + */ + uint64_t res_addr : 64; +#else /* Word 1 - Little Endian */ + uint64_t res_addr : 64; +#endif /* Word 1 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 2 - Big Endian */ + uint64_t reserved_172_191 : 20; + /* [171:162] If [WQ_PTR] is nonzero, the SSO guest-group to + * use when CPT submits work to SSO. + * For the SSO to not discard the add-work request, FPA_PF_MAP() + * must map [GRP] and CPT()_PF_Q()_GMCTL[GMID] as valid. + */ + uint64_t grp : 10; + /* [161:160] If [WQ_PTR] is nonzero, the SSO tag type to use + * when CPT submits work to SSO. + */ + uint64_t tt : 2; + /* [159:128] If [WQ_PTR] is nonzero, the SSO tag to use when + * CPT submits work to SSO. + */ + uint64_t tag : 32; +#else /* Word 2 - Little Endian */ + uint64_t tag : 32; + uint64_t tt : 2; + uint64_t grp : 10; + uint64_t reserved_172_191 : 20; +#endif /* Word 2 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 3 - Big Endian */ + /** [255:192] If [WQ_PTR] is nonzero, it is a pointer to a + * work-queue entry that CPT submits work to SSO after all + * context, output data, and result write operations are + * visible to other CNXXXX units and the cores. + * Bits <2:0> must be zero. + * Bits <63:49> are ignored by hardware; software should use a + * sign-extended bit <48> for forward compatibility. + * Internal:Bits <63:49>, <2:0> are ignored by hardware, + * treated as always 0x0. + **/ + uint64_t wq_ptr : 64; +#else /* Word 3 - Little Endian */ + uint64_t wq_ptr : 64; +#endif /* Word 3 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 4 - Big Endian */ + union { + /** [319:256] Engine instruction word 0. Passed to the + * AE/SE. + **/ + uint64_t ei0 : 64; + vq_cmd_word0_t vq_cmd_w0; + }; +#else /* Word 4 - Little Endian */ + union { + uint64_t ei0 : 64; + vq_cmd_word0_t vq_cmd_w0; + }; +#endif /* Word 4 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 5 - Big Endian */ + union { + /** [383:320] Engine instruction word 1. Passed to the + * AE/SE. + **/ + uint64_t ei1 : 64; + uint64_t dptr; + }; +#else /* Word 5 - Little Endian */ + union { + uint64_t ei1 : 64; + uint64_t dptr; + }; +#endif /* Word 5 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 6 - Big Endian */ + union { + /** [447:384] Engine instruction word 2. Passed to the + * AE/SE. + **/ + uint64_t ei2 : 64; + uint64_t rptr; + }; +#else /* Word 6 - Little Endian */ + union { + uint64_t ei2 : 64; + uint64_t rptr; + }; +#endif /* Word 6 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 7 - Big Endian */ + union { + /** [511:448] Engine instruction word 3. Passed to the + * AE/SE. + **/ + uint64_t ei3 : 64; + vq_cmd_word3_t vq_cmd_w3; + }; +#else /* Word 7 - Little Endian */ + union { + uint64_t ei3 : 64; + vq_cmd_word3_t vq_cmd_w3; + }; +#endif /* Word 7 - End */ + } s8x; +} cpt_inst_s_t; + +/** + * Structure cpt_res_s + * + * CPT Result Structure + * The CPT coprocessor writes the result structure after it completes a + * CPT_INST_S instruction. The result structure is exactly 16 bytes, and each + * instruction completion produces exactly one result structure. + * + * This structure is stored in memory as little-endian unless + * CPT()_PF_Q()_CTL[INST_BE] is set. + */ +typedef union cpt_res_s { + uint64_t u[2]; + struct cpt_res_s_8s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_17_63 : 47; + /** [ 16: 16] Done interrupt. This bit is copied from the + * corresponding instruction's CPT_INST_S[DONEINT]. + **/ + uint64_t doneint : 1; + uint64_t reserved_8_15 : 8; + /** [ 7: 0] Indicates completion/error status of the CPT + * coprocessor for the associated instruction, as enumerated by + * CPT_COMP_E. Core software may write the memory location + * containing [COMPCODE] to 0x0 before ringing the doorbell, and + * then poll for completion by checking for a nonzero value. + * + * Once the core observes a nonzero [COMPCODE] value in this + * case, the CPT coprocessor will have also completed L2/DRAM + * write operations. + **/ + uint64_t compcode : 8; +#else /* Word 0 - Little Endian */ + uint64_t compcode : 8; + uint64_t reserved_8_15 : 8; + uint64_t doneint : 1; + uint64_t reserved_17_63 : 47; +#endif /* Word 0 - End */ +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 1 - Big Endian */ + uint64_t reserved_64_127 : 64; +#else /* Word 1 - Little Endian */ + uint64_t reserved_64_127 : 64; +#endif /* Word 1 - End */ + } s8x; +} cpt_res_s_t; + +/** + * Register (NCB) cpt#_vq#_ctl + * + * CPT VF Queue Control Registers + * This register configures queues. This register should be changed (other than + * clearing [ENA]) only when quiescent (see CPT()_VQ()_INPROG[INFLIGHT]). + */ +typedef union { + uint64_t u; + struct cptx_vqx_ctl_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_1_63 : 63; + /** [ 0: 0](R/W/H) Enables the logical instruction queue. + * See also CPT()_PF_Q()_CTL[CONT_ERR] and + * CPT()_VQ()_INPROG[INFLIGHT]. + * 1 = Queue is enabled. + * 0 = Queue is disabled. + **/ + uint64_t ena : 1; +#else /* Word 0 - Little Endian */ + uint64_t ena : 1; + uint64_t reserved_1_63 : 63; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_ctl_t; + +/** + * Register (NCB) cpt#_vq#_done + * + * CPT Queue Done Count Registers + * These registers contain the per-queue instruction done count. + */ +typedef union { + uint64_t u; + struct cptx_vqx_done_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_20_63 : 44; + /** [ 19: 0](R/W/H) Done count. When CPT_INST_S[DONEINT] set + * and that instruction completes,CPT()_VQ()_DONE[DONE] is + * incremented when the instruction finishes. Write to this + * field are for diagnostic use only; instead software writes + * CPT()_VQ()_DONE_ACK with the number of decrements for this + * field. + * + * Interrupts are sent as follows: + * + * When CPT()_VQ()_DONE[DONE] = 0, then no results are pending, + * the interrupt coalescing timer is held to zero, and an + * interrupt is not sent. + * + * When CPT()_VQ()_DONE[DONE] != 0, then the interrupt + * coalescing timer counts. If the counter is >= CPT()_VQ()_DONE + * _WAIT[TIME_WAIT]*1024, or CPT()_VQ()_DONE[DONE] >= CPT()_VQ() + * _DONE_WAIT[NUM_WAIT], i.e. enough time has passed or enough + * results have arrived, then the interrupt is sent. Otherwise, + * it is not sent due to coalescing. + * + * When CPT()_VQ()_DONE_ACK is written (or CPT()_VQ()_DONE is + * written but this is not typical), the interrupt coalescing + * timer restarts. Note after decrementing this interrupt + * equation is recomputed, for example if CPT()_VQ()_DONE[DONE] + * >= CPT()_VQ()_DONE_WAIT[NUM_WAIT] and because the timer is + * zero, the interrupt will be resent immediately. (This covers + * the race case between software acknowledging an interrupt and + * a result returning.) + * + * When CPT()_VQ()_DONE_ENA_W1S[DONE] = 0, interrupts are not + * sent, but the counting described above still occurs. + * + * Since CPT instructions complete out-of-order, if software is + * using completion interrupts the suggested scheme is to + * request a DONEINT on each request, and when an interrupt + * arrives perform a "greedy" scan for completions; even if a + * later command is acknowledged first this will not result in + * missing a completion. + * + * Software is responsible for making sure [DONE] does not + * overflow; for example by insuring there are not more than + * 2^20-1 instructions in flight that may request interrupts. + **/ + uint64_t done : 20; +#else /* Word 0 - Little Endian */ + uint64_t done : 20; + uint64_t reserved_20_63 : 44; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_done_t; + +/** + * Register (NCB) cpt#_vq#_done_ack + * + * CPT Queue Done Count Ack Registers + * This register is written by software to acknowledge interrupts. + */ +typedef union { + uint64_t u; + struct cptx_vqx_done_ack_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_20_63 : 44; + /** [ 19: 0](R/W/H) Number of decrements to CPT()_VQ()_DONE + * [DONE]. Reads CPT()_VQ()_DONE[DONE]. + * + * Written by software to acknowledge interrupts. If CPT()_VQ()_ + * DONE[DONE] is still nonzero the interrupt will be re-sent if + * the conditions described in CPT()_VQ()_DONE[DONE] are + * satisfied. + **/ + uint64_t done_ack : 20; +#else /* Word 0 - Little Endian */ + uint64_t done_ack : 20; + uint64_t reserved_20_63 : 44; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_done_ack_t; + +/** + * Register (NCB) cpt#_vq#_done_wait + * + * CPT Queue Done Interrupt Coalescing Wait Registers + * Specifies the per queue interrupt coalescing settings. + */ +typedef union { + uint64_t u; + struct cptx_vqx_done_wait_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_48_63 : 16; + /** [ 47: 32](R/W) Time hold-off. When CPT()_VQ()_DONE[DONE] = + * 0, or CPT()_VQ()_DONE_ACK is written a timer is cleared. When + * the timer reaches [TIME_WAIT]*1024 then interrupt coalescing + * ends; see CPT()_VQ()_DONE[DONE]. If 0x0, time coalescing is + * disabled. + **/ + uint64_t time_wait : 16; + uint64_t reserved_20_31 : 12; + /** [ 19: 0](R/W) Number of messages hold-off. When + * CPT()_VQ()_DONE[DONE] >= [NUM_WAIT] then interrupt coalescing + * ends; see CPT()_VQ()_DONE[DONE]. If 0x0, same behavior as + * 0x1. + **/ + uint64_t num_wait : 20; +#else /* Word 0 - Little Endian */ + uint64_t num_wait : 20; + uint64_t reserved_20_31 : 12; + uint64_t time_wait : 16; + uint64_t reserved_48_63 : 16; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_done_wait_t; + +/** + * Register (NCB) cpt#_vq#_doorbell + * + * CPT Queue Doorbell Registers + * Doorbells for the CPT instruction queues. + */ +typedef union { + uint64_t u; + struct cptx_vqx_doorbell_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_20_63 : 44; + uint64_t dbell_cnt : 20; + /** [ 19: 0](R/W/H) Number of instruction queue 64-bit words + * to add to the CPT instruction doorbell count. Readback value + * is the the current number of pending doorbell requests. + * + * If counter overflows CPT()_VQ()_MISC_INT[DBELL_DOVF] is set. + * + * To reset the count back to zero, write one to clear + * CPT()_VQ()_MISC_INT_ENA_W1C[DBELL_DOVF], then write a value + * of 2^20 minus the read [DBELL_CNT], then write one to + * CPT()_VQ()_MISC_INT_W1C[DBELL_DOVF] and + * CPT()_VQ()_MISC_INT_ENA_W1S[DBELL_DOVF]. + * + * Must be a multiple of 8. All CPT instructions are 8 words + * and require a doorbell count of multiple of 8. + **/ +#else /* Word 0 - Little Endian */ + uint64_t dbell_cnt : 20; + uint64_t reserved_20_63 : 44; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_doorbell_t; + +/** + * Register (NCB) cpt#_vq#_inprog + * + * CPT Queue In Progress Count Registers + * These registers contain the per-queue instruction in flight registers. + */ +typedef union { + uint64_t u; + struct cptx_vqx_inprog_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_8_63 : 56; + /** [ 7: 0](RO/H) Inflight count. Counts the number of + * instructions for the VF for which CPT is fetching, executing + * or responding to instructions. However this does not include + * any interrupts that are awaiting software handling + * (CPT()_VQ()_DONE[DONE] != 0x0). + * + * A queue may not be reconfigured until: + * 1. CPT()_VQ()_CTL[ENA] is cleared by software. + * 2. [INFLIGHT] is polled until equals to zero. + **/ + uint64_t inflight : 8; +#else /* Word 0 - Little Endian */ + uint64_t inflight : 8; + uint64_t reserved_8_63 : 56; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_inprog_t; + +/** + * Register (NCB) cpt#_vq#_misc_int + * + * CPT Queue Misc Interrupt Register + * These registers contain the per-queue miscellaneous interrupts. + */ +typedef union { + uint64_t u; + struct cptx_vqx_misc_int_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_7_63 : 57; + /** [ 6: 6](R/W1C/H) Translation fault detected. */ + uint64_t fault : 1; + /** [ 5: 5](R/W1C/H) Hardware error from engines. */ + uint64_t hwerr : 1; + /** [ 4: 4](R/W1C/H) Software error from engines. */ + uint64_t swerr : 1; + /** [ 3: 3](R/W1C/H) NCB result write response error. */ + uint64_t nwrp : 1; + /** [ 2: 2](R/W1C/H) Instruction NCB read response error. */ + uint64_t irde : 1; + /** [ 1: 1](R/W1C/H) Doorbell overflow. */ + uint64_t dovf : 1; + /** [ 0: 0](R/W1C/H) PF to VF mailbox interrupt. Set when + * CPT()_VF()_PF_MBOX(0) is written. + **/ + uint64_t mbox : 1; +#else /* Word 0 - Little Endian */ + uint64_t mbox : 1; + uint64_t dovf : 1; + uint64_t irde : 1; + uint64_t nwrp : 1; + uint64_t swerr : 1; + uint64_t hwerr : 1; + uint64_t fault : 1; + uint64_t reserved_5_63 : 59; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_misc_int_t; + +/** + * Register (NCB) cpt#_vq#_saddr + * + * CPT Queue Starting Buffer Address Registers + * These registers set the instruction buffer starting address. + */ +typedef union { + uint64_t u; + struct cptx_vqx_saddr_s { +#if (RTE_BYTE_ORDER == RTE_BIG_ENDIAN) /* Word 0 - Big Endian */ + uint64_t reserved_49_63 : 15; + /** [ 48: 6](R/W/H) Instruction buffer IOVA <48:6> + * (64-byte aligned). When written, it is the initial buffer + * starting address; when read, it is the next read pointer to + * be requested from L2C. The PTR field is overwritten with the + * next pointer each time that the command buffer segment is + * exhausted. New commands will then be read from the newly + * specified command buffer pointer. + **/ + uint64_t ptr : 43; + uint64_t reserved_0_5 : 6; +#else /* Word 0 - Little Endian */ + uint64_t reserved_0_5 : 6; + uint64_t ptr : 43; + uint64_t reserved_49_63 : 15; +#endif /* Word 0 - End */ + } s; +} cptx_vqx_saddr_t; + +#endif /*_CPT_HW_TYPES_H_ */ -- 2.7.4