From patchwork Sat Sep 8 20:31:02 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Mody, Rasesh" X-Patchwork-Id: 44456 X-Patchwork-Delegate: ferruh.yigit@amd.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 839675F57; Sat, 8 Sep 2018 22:32:10 +0200 (CEST) Received: from NAM04-BN3-obe.outbound.protection.outlook.com (mail-eopbgr680074.outbound.protection.outlook.com [40.107.68.74]) by dpdk.org (Postfix) with ESMTP id 6258A5681 for ; Sat, 8 Sep 2018 22:31:56 +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=vYOLyNq7fnv0qc3KYghC6ZIpETLtroQCqajsKv3ZYWA=; b=JVSs9UNHdABYANxhsXPd3mdjiLI+ikLCmZQLesevLNaNe9dhX4M475nTS+MHor0apEfrPMJLqNTrbXEdAl3bYbxXChMZSTFNMu0YeQc9IlrQ0W7gDJCjbTPggIm+b77uP7YUj3eIGHSw7pOlOac1adSnBpktiP8iXVRwqdnFzeA= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Rasesh.Mody@cavium.com; Received: from cavium.com (198.186.1.5) by DM6PR07MB5372.namprd07.prod.outlook.com (2603:10b6:5:44::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1101.18; Sat, 8 Sep 2018 20:31:54 +0000 From: Rasesh Mody To: dev@dpdk.org Cc: Shahed Shaikh , ferruh.yigit@intel.com, Dept-EngDPDKDev@cavium.com Date: Sat, 8 Sep 2018 13:31:02 -0700 Message-Id: <1536438666-22184-14-git-send-email-rasesh.mody@cavium.com> X-Mailer: git-send-email 1.7.10.3 In-Reply-To: <1536438666-22184-1-git-send-email-rasesh.mody@cavium.com> References: <1536438666-22184-1-git-send-email-rasesh.mody@cavium.com> MIME-Version: 1.0 X-Originating-IP: [198.186.1.5] X-ClientProxiedBy: BYAPR02CA0031.namprd02.prod.outlook.com (2603:10b6:a02:ee::44) To DM6PR07MB5372.namprd07.prod.outlook.com (2603:10b6:5:44::17) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 8573ffb0-aeb7-411e-dd04-08d615ca1df5 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(2017052603328)(7153060)(7193020); SRVR:DM6PR07MB5372; X-Microsoft-Exchange-Diagnostics: 1; DM6PR07MB5372; 3:eDLjoXW02ANKSYu2sZIYaLBxo3Oh8eQpVwoWYpl24m2D+VFZ4TzCKd+DnVlIJoYMIeqIHNb09c0cig0JpH9ScPqVZeDls/AI0fNUJFD5VWFGX+6/cJQau0bQAB6Hh2CmIyE/6CKj9NQB8bWqOrwJ86Ng3kSFP9vjD1FZIvQNnpG8dEsVeO2/uh2nNcSD4OoyroFeBrl/aqkdcOUjO93pExNJZqUBT2OCQKyjOVkezZyJcce8e9/QZUnb+BXdqz+H; 25:02E18aTfbh64ZI+x67s8BvOgwR47VyxJ88j1aPBgWoBj2Hm3ujKEO530b4cx0rdgcbiKBjVx8+51ppzbptIOOhtMSTUDQ1hp31yRXUuuEdSklaIRlv4e9bHSASSYLLLVUe8UV8K/k9PBg+PbwIROvBnGMBQD56PCJSGacIy0s9GgOZjiGQrt7xGkZ/OI5o7MTTp+Y6FRWx27a7XUVX7gucT0IYVJKsnTqs5cWWi7J54TiDKA74Iz/xBEMRzCaTbvUIVRy06/V6cnMQmcA9PIjPqKrky6UAnsGXfnj/PzXbcmqRMdjieF+hDHYlPvQGcO448Stsfl6gEu49xfXrTY+g==; 31:U0AV84O05CEiv/QwBZzacbWIW/zwlOpTB2ySaEtlzBiwMZTefx6bwe92rJ0gLSDI5xzENqRtHu+Tsk3FOdM9Edn7c+ulssXPZvIsqOKirSzea2s1q42t4XpWwMO1C8xRIjMHFaUN8OinDEjDSuDfLyXAhZQHMn0/IQENu0N43WmhWE6JpxLDXqwGpuP0lN2ZPThbYYLI3o6vkKfhbS43yzWtZSu9N+RHSVvALFsXw/g= X-MS-TrafficTypeDiagnostic: DM6PR07MB5372: X-Microsoft-Exchange-Diagnostics: 1; DM6PR07MB5372; 20:L3WMfcb9q+rOp6A86QU+snJwLWPjhHy6oGzw9+cAR6nvJcpyJXV2TlQJLBYSA9aeRe48JfIeysllibMbUzskjRmIGwatPO1HPyxr3WIa7Z7MuLqyIWDv5GGCAoglIldODFKF9VcHM30hCSWEtg/z4qEHBjolthc5/RDMIH6025oyGFfThL2OXrTkQboeBZCPt0oRM6K0gxh7q5nvSU8FRpWmZgrHmtGeBrxU+9OGHSELAihA2J6XlMrl4R0/vAFNO6jTVTJxU1HxS0LjVogkp9/CbirqyQ0m0bIIa93C3som5Y/oxgjA447+0PGZ1fJuEtyuxDdviuEQ11vbJS7jLxIMSf88VwZwu4/b0gpx0AM+PAI4FOYXE2PKvo+A6FKnTsVBKIheSg5f1A1biVKELaZxel4rT86Dgsa7cOaM2NeJvmJH4CGozYuoJang+yb6U3YpqglaLMwoqaSRzXMg0gshwhA7GnSF/FKAcKhXYn+dHkhQ69ksmGyr88GFsJZe; 4:Zznkmjki+v6mxbet/gR2zjmE7tFPbjyygYxpqBa22kdFquHNbx/ZIYHm+b+1PuRfzOGZWcVL8idIxIty4MwvufOPthQ/dzhI6dyYcR1OGEb95Mx7ZBxvDh/hXoG+/UOoFkg5RsTJEz5NKwVBf3GKgGgCD0ZQ7Nh4VU1pqeDehOMNogn6oOXB9VKUw4XAmcSDW8H44KaqpDW12x4O6NOSXyRo6DV4QN+/nYMac9gx+9shXrzQmRKTxU/Jymc87SF2qu6KzDCbmZBz1QLR/GnS9Q== 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)(823301075)(3002001)(10201501046)(3231311)(944501410)(52105095)(93006095)(93001095)(149027)(150027)(6041310)(20161123562045)(20161123564045)(20161123558120)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(201708071742011)(7699050); SRVR:DM6PR07MB5372; BCL:0; PCL:0; RULEID:; SRVR:DM6PR07MB5372; X-Forefront-PRVS: 07891BF289 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(396003)(366004)(136003)(346002)(376002)(39860400002)(199004)(189003)(51234002)(4720700003)(97736004)(2351001)(106356001)(105586002)(72206003)(66066001)(47776003)(4326008)(50466002)(48376002)(25786009)(305945005)(7736002)(2361001)(8676002)(478600001)(316002)(52116002)(69596002)(107886003)(186003)(50226002)(44832011)(16526019)(486006)(21086003)(2906002)(55016002)(26005)(8936002)(476003)(956004)(81156014)(81166006)(86362001)(5660300001)(6666003)(36756003)(16586007)(11346002)(446003)(2616005)(76176011)(3846002)(6116002)(6916009)(68736007)(14444005)(386003)(51416003)(53936002)(7696005)(41533002); DIR:OUT; SFP:1101; SCL:1; SRVR:DM6PR07MB5372; H:cavium.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; DM6PR07MB5372; 23:6YWVss/oX8L3SxvVrQsNDQXyWNMSlvujU9sr3MFYl?= M8bvt0PrSKYnMirDGDVP0610czWxZYNFK9wrDcd++CrQZD36MND38Tz7/zYW88kaec/l7W6sUdJfElvfzpmxgJLKexV+aFRF1HIT+49XjqKtzBKXAkmQ1q8JHDcm2F/VQLPQ5S66CmmEyv/CgjVIv29GHOAu2zV84JX1dnB9X9ZcTpiv2rIGZJqSQv7IFZdrmoChbJGQvHdhLT34kr2UGjBBjBSKnw6033LEKemxJy6s6SNBjF7fGt0CZ4KTOafmbaS2U8yMtwS0u8+AkYWx0a/QYcw/QFFS8x5DzENBftP51BzPOXroqkPMaPhXZFMt7nl7R/+Yw1TIW9bL3zS/YpBlmJPtWwJsQYtyivvUXVzatINviyF6dVB82Vjkf+PRbyW2CU+pDE+G+JyDALXPGMdTZZRjmgtQGrwlTnrMRA9uqL4667anx2IIawn/mcfQWqEhO+D48r1JLp0l3J5Znq4P6dJlQcXHjAy3sPxGIProQscp6qZpM96B9iezWx44mhPoiMmu0gM3cmjl934mNnrYcjifGAcBA6g0Gcakcx1VSqiymBrdG2EI0LCPd4rP1iaN+J8aDznhJ8exVdnTPwHrXPZmwI7SZZOTxAf+2Bo811qxOEslIU22Hir9yOaRrKt94wl/3BAM2tgLIfX3ZhTLrvKHGouayOsiVLdeUSTWtzi+DTIpoudOKSwKvlR+nbbCnq3E1hSuYtyXaHYyvXc5RVlGrwCzTsvYBdBS/oLcBr9ldxRsLgsw6x3mL2f3/4eb+pFfUpHzjb8ac3KabC6YNk2DJxa3HllJ+sQ1P4PlqcuFE7qK0yaW8PDQiNGCm5gWhxJCipk0AROvMFzlnc9v29oHbferz4zuvVukjdLXZE+QYIdfRNOndlbA7LyA2Wsif4hbqDc1Yi6LVhYErUZ1spiXZQpcFA8t0uoqp7Nd86ItSettiLejqUOJqRoX7seEDyXxEaNdyXbIeQA72SEpnc+r7mlHw5O8LsdSKsIgHbxlzBuW+YnoIn5fuvw4HwV4bMzrL1GmueqoEErTlzazqVcmJFSSvum8O8gezgYDEleCuD8ACosa6oeqf3lnf4daDxPdTQdZJX9n7tUOaV5jQZcx6UoGbpa+uzlJWPIkJPXbleUVlOHWtKvLpW21oZwVj4rvg7FaK4GAxyPGO66nImX6E9NNSInOGbTD53I249OB/ghOSJr1ZLGS6cgkah1mxPcbnefgqGl4bmfBdpN+w0JrBIMTgcJB1ovNYjEr+U0ybvsUYryxhFSjeh3hhBB+oZNuYnSktmlGGZzW+ehr+KCg/GSzIiIUXmBHFgumUQyRE+uAMO+GOhHv4E5qN8= X-Microsoft-Antispam-Message-Info: DCQ6v/EsTHGtBPSlZnTflE8Y+cJJLsplHsU0eVa9WlSUnLZR89xUwpF2JqSjh1zq4rG3rkuNi0Gki1ky/+Iz2zmBVFS5bu9AnSgXXW/bjjyRo+ecrjafzpl2S6VMHk8Kry/+kgYlhzI6kB7WV4KdgFlQK3jXbacOcfj/zDRPEDYIit4wZ3fM7ELSrS+72Fpt60bcKBp5+SCb+OoZYmJV6lnaTZKsnxQyCWFBKWJGjyXAMcaCSmiFn0A8b5HdaxUUU2Vcv/duGdRHLKjvC4uYzwaq2oefMaOYgaF268FC/9SmoylfTBG0e/gSmmhXI1pGZXHKZI343oTFR2LE1JKR4Edx3sNOU19lU5kDnxevI6E= X-Microsoft-Exchange-Diagnostics: 1; DM6PR07MB5372; 6:s+S7sG52+c/sHPq+f7mEWTDNhg5MU2ns4236xYrD4EyU5LDZNfKnfXDtXyhe9ag+MjuwG4XXrKvBFEW4DTkLbpmy4ZAT/5ER9Oc70oH05Cgpw2MhYDrqJXmi397hD6fKHtejiHEkWC+tWo6cOD5Jb5WQ2MiGNAf+uVaKPKzgqThTfWj4WcOxMkGTJQTQkBaJLAgikLnf25Hwx0wcwbEWfXhr02d3vkk9s0dmUiJB28Z4AomulYtxvQ54sZL4qSD+vzLOKtnpoFADVYkLcI5VhG3eAODdUnhuGc2RePw8KtGoh5j+CDhFaGbF2LDuObwDKQ7uxpvfaRQKsLWUTLxVAX8i0qPDXRJ1kbZO43FJSoFUcmoN7PO2K+8fW3a3K2CoyAMLJsiELvWmQHVJ6aNMECSL/ohZoA6NgI+KCR3Cm8bumZwnUUuXFy2aHYlyZe1sgGKiuzqV6mUHfwCdPTMtRw==; 5:BwbRGD0oZ+Im+XjFqcK2pCOKsaLB/FuRtbvpx/QQ6DNLCdBWQujguFa7rYI7J5IM3T5G/P33WBO1hIrl8yhtrOypw/WoyfqjQTeq98iElJQXCwIXSNvBmplXsxO1gjkRWYdbqC0d3MzR0G4uFGGsNs6eCEEfS0TBzF7yJwI3/eo=; 7:A23LLI0CbocNKj5IaHpZJajVOHr+KqQ5tDQoQfM9NEfekn8fX4wi62UBRIUC+aFBOC63bFeh7RbMVMOlQIpeuX+gkhHIPdrZnc6gZeP5iEYqoEeYY+mWzS6+Eb1gHNeCGby/RWsYgfeD8orvEql3Q/lIHJs347KzzQ4vMVCVs1HuoCtZltMG39z0F1QzqQKeewn+U/yixD4xmFy5flu/6TxgTleDNalxj/vKIt0ZQwXHxKBiUcEWiTczOIoRyhzd SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: cavium.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Sep 2018 20:31:54.6608 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 8573ffb0-aeb7-411e-dd04-08d615ca1df5 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 711e4ccf-2e9b-4bcf-a551-4094005b6194 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM6PR07MB5372 Subject: [dpdk-dev] [PATCH 13/17] net/qede: add support for generic flow API 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: Shahed Shaikh - Add support for rte_flow_validate(), rte_flow_create() and rte_flow_destroy() APIs - This patch adds limited support for the flow items because of the limited filter profiles supported by HW. - Only 4 tuples - src and dst IP (v4 or v6) addresses and src and dst port IDs of TCP or UDP. - also, only redirect to queue action is supported. Signed-off-by: Shahed Shaikh --- drivers/net/qede/qede_ethdev.h | 5 + drivers/net/qede/qede_filter.c | 334 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 338 insertions(+), 1 deletion(-) diff --git a/drivers/net/qede/qede_ethdev.h b/drivers/net/qede/qede_ethdev.h index 59828f8..8a9df98 100644 --- a/drivers/net/qede/qede_ethdev.h +++ b/drivers/net/qede/qede_ethdev.h @@ -184,6 +184,11 @@ struct qede_arfs_entry { SLIST_ENTRY(qede_arfs_entry) list; }; +/* Opaque handle for rte flow managed by PMD */ +struct rte_flow { + struct qede_arfs_entry entry; +}; + struct qede_arfs_info { struct ecore_arfs_config_params arfs; uint16_t filter_count; diff --git a/drivers/net/qede/qede_filter.c b/drivers/net/qede/qede_filter.c index bdf2885..5e6571c 100644 --- a/drivers/net/qede/qede_filter.c +++ b/drivers/net/qede/qede_filter.c @@ -8,6 +8,7 @@ #include #include #include +#include #include "qede_ethdev.h" @@ -1159,6 +1160,327 @@ static void qede_get_ecore_tunn_params(uint32_t filter, uint32_t *type, return 0; } +static int +qede_flow_validate_attr(__attribute__((unused))struct rte_eth_dev *dev, + const struct rte_flow_attr *attr, + struct rte_flow_error *error) +{ + if (attr == NULL) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ATTR, NULL, + "NULL attribute"); + return -rte_errno; + } + + if (attr->group != 0) { + rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_GROUP, attr, + "Groups are not supported"); + return -rte_errno; + } + + if (attr->priority != 0) { + rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, attr, + "Priorities are not supported"); + return -rte_errno; + } + + if (attr->egress != 0) { + rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, attr, + "Egress is not supported"); + return -rte_errno; + } + + if (attr->transfer != 0) { + rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER, attr, + "Transfer is not supported"); + return -rte_errno; + } + + if (attr->ingress == 0) { + rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, attr, + "Only ingress is supported"); + return -rte_errno; + } + + return 0; +} + +static int +qede_flow_parse_pattern(__attribute__((unused))struct rte_eth_dev *dev, + const struct rte_flow_item pattern[], + struct rte_flow_error *error, + struct rte_flow *flow) +{ + bool l3 = false, l4 = false; + + if (pattern == NULL) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM_NUM, NULL, + "NULL pattern"); + return -rte_errno; + } + + for (; pattern->type != RTE_FLOW_ITEM_TYPE_END; pattern++) { + if (!pattern->spec) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + pattern, + "Item spec not defined"); + return -rte_errno; + } + + if (pattern->last) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + pattern, + "Item last not supported"); + return -rte_errno; + } + + if (pattern->mask) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + pattern, + "Item mask not supported"); + return -rte_errno; + } + + /* Below validation is only for 4 tuple flow + * (GFT_PROFILE_TYPE_4_TUPLE) + * - src and dst L3 address (IPv4 or IPv6) + * - src and dst L4 port (TCP or UDP) + */ + + switch (pattern->type) { + case RTE_FLOW_ITEM_TYPE_IPV4: + l3 = true; + + if (flow) { + const struct rte_flow_item_ipv4 *spec; + + spec = pattern->spec; + flow->entry.tuple.src_ipv4 = spec->hdr.src_addr; + flow->entry.tuple.dst_ipv4 = spec->hdr.dst_addr; + flow->entry.tuple.eth_proto = ETHER_TYPE_IPv4; + } + break; + + case RTE_FLOW_ITEM_TYPE_IPV6: + l3 = true; + + if (flow) { + const struct rte_flow_item_ipv6 *spec; + + spec = pattern->spec; + rte_memcpy(flow->entry.tuple.src_ipv6, + spec->hdr.src_addr, + IPV6_ADDR_LEN); + rte_memcpy(flow->entry.tuple.dst_ipv6, + spec->hdr.dst_addr, + IPV6_ADDR_LEN); + flow->entry.tuple.eth_proto = ETHER_TYPE_IPv6; + } + break; + + case RTE_FLOW_ITEM_TYPE_UDP: + l4 = true; + + if (flow) { + const struct rte_flow_item_udp *spec; + + spec = pattern->spec; + flow->entry.tuple.src_port = + spec->hdr.src_port; + flow->entry.tuple.dst_port = + spec->hdr.dst_port; + flow->entry.tuple.ip_proto = IPPROTO_UDP; + } + break; + + case RTE_FLOW_ITEM_TYPE_TCP: + l4 = true; + + if (flow) { + const struct rte_flow_item_tcp *spec; + + spec = pattern->spec; + flow->entry.tuple.src_port = + spec->hdr.src_port; + flow->entry.tuple.dst_port = + spec->hdr.dst_port; + flow->entry.tuple.ip_proto = IPPROTO_TCP; + } + + break; + default: + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + pattern, + "Only 4 tuple (IPV4, IPV6, UDP and TCP) item types supported"); + return -rte_errno; + } + } + + if (!(l3 && l4)) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + pattern, + "Item types need to have both L3 and L4 protocols"); + return -rte_errno; + } + + return 0; +} + +static int +qede_flow_parse_actions(struct rte_eth_dev *dev, + const struct rte_flow_action actions[], + struct rte_flow_error *error, + struct rte_flow *flow) +{ + struct qede_dev *qdev = QEDE_INIT_QDEV(dev); + const struct rte_flow_action_queue *queue; + + if (actions == NULL) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_NUM, NULL, + "NULL actions"); + return -rte_errno; + } + + for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) { + switch (actions->type) { + case RTE_FLOW_ACTION_TYPE_QUEUE: + queue = actions->conf; + + if (queue->index >= QEDE_RSS_COUNT(qdev)) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION, + actions, + "Bad QUEUE action"); + return -rte_errno; + } + + if (flow) + flow->entry.rx_queue = queue->index; + + break; + + default: + rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, + actions, + "Action is not supported - only ACTION_TYPE_QUEUE supported"); + return -rte_errno; + } + } + + return 0; +} + +static int +qede_flow_parse(struct rte_eth_dev *dev, + const struct rte_flow_attr *attr, + const struct rte_flow_item patterns[], + const struct rte_flow_action actions[], + struct rte_flow_error *error, + struct rte_flow *flow) + +{ + int rc = 0; + + rc = qede_flow_validate_attr(dev, attr, error); + if (rc) + return rc; + + /* parse and validate item pattern and actions. + * Given item list and actions will be translate to qede PMD + * specific arfs structure. + */ + rc = qede_flow_parse_pattern(dev, patterns, error, flow); + if (rc) + return rc; + + rc = qede_flow_parse_actions(dev, actions, error, flow); + + return rc; +} + +static int +qede_flow_validate(struct rte_eth_dev *dev, + const struct rte_flow_attr *attr, + const struct rte_flow_item patterns[], + const struct rte_flow_action actions[], + struct rte_flow_error *error) +{ + return qede_flow_parse(dev, attr, patterns, actions, error, NULL); +} + +static struct rte_flow * +qede_flow_create(struct rte_eth_dev *dev, + const struct rte_flow_attr *attr, + const struct rte_flow_item pattern[], + const struct rte_flow_action actions[], + struct rte_flow_error *error) +{ + struct rte_flow *flow = NULL; + int rc; + + flow = rte_zmalloc("qede_rte_flow", sizeof(*flow), 0); + if (flow == NULL) { + rte_flow_error_set(error, ENOMEM, + RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL, + "Failed to allocate memory"); + return NULL; + } + + rc = qede_flow_parse(dev, attr, pattern, actions, error, flow); + if (rc < 0) { + rte_free(flow); + return NULL; + } + + rc = qede_config_arfs_filter(dev, &flow->entry, true); + if (rc < 0) { + rte_flow_error_set(error, rc, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "Failed to configure flow filter"); + rte_free(flow); + return NULL; + } + + return flow; +} + +static int +qede_flow_destroy(struct rte_eth_dev *eth_dev, + struct rte_flow *flow, + struct rte_flow_error *error) +{ + int rc = 0; + + rc = qede_config_arfs_filter(eth_dev, &flow->entry, false); + if (rc < 0) { + rte_flow_error_set(error, rc, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "Failed to delete flow filter"); + rte_free(flow); + } + + return rc; +} + +const struct rte_flow_ops qede_flow_ops = { + .validate = qede_flow_validate, + .create = qede_flow_create, + .destroy = qede_flow_destroy, +}; + int qede_dev_filter_ctrl(struct rte_eth_dev *eth_dev, enum rte_filter_type filter_type, enum rte_filter_op filter_op, @@ -1195,6 +1517,17 @@ int qede_dev_filter_ctrl(struct rte_eth_dev *eth_dev, return qede_fdir_filter_conf(eth_dev, filter_op, arg); case RTE_ETH_FILTER_NTUPLE: return qede_ntuple_filter_conf(eth_dev, filter_op, arg); + case RTE_ETH_FILTER_GENERIC: + if (ECORE_IS_CMT(edev)) { + DP_ERR(edev, "flowdir is not supported in 100G mode\n"); + return -ENOTSUP; + } + + if (filter_op != RTE_ETH_FILTER_GET) + return -EINVAL; + + *(const void **)arg = &qede_flow_ops; + return 0; case RTE_ETH_FILTER_MACVLAN: case RTE_ETH_FILTER_ETHERTYPE: case RTE_ETH_FILTER_FLEXIBLE: @@ -1211,4 +1544,3 @@ int qede_dev_filter_ctrl(struct rte_eth_dev *eth_dev, return 0; } -/* RTE_FLOW */