From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR01-HE1-obe.outbound.protection.outlook.com (mail-he1eur01on0067.outbound.protection.outlook.com [104.47.0.67]) by dpdk.org (Postfix) with ESMTP id EC0B41B160 for ; Fri, 28 Sep 2018 09:46:38 +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=CLiTOIzudkAFis0bdniyk+u56x5YgT3qiiLntKLa080=; b=ZIcVVRGwEgCjPSJv6mhRqK2Bf+MlKDQK7VCWNR8v/laZjrB2Y0ZwaZzv9t9iLy2CyhP8VXYi6qCxmJoW5LDLIUT43DGHWqWBUltVj5idd64wwLo5e8lH8V8151KiCXaFj/bCBCNwI5afAjPTLzAd6dT0L0FCUFGDSUSls+zHGgs= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by DB5PR04MB1528.eurprd04.prod.outlook.com (2a01:111:e400:5993::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1185.20; Fri, 28 Sep 2018 07:46:35 +0000 From: Gagandeep Singh To: dev@dpdk.org, ferruh.yigit@intel.com Cc: pankaj.chauhan@nxp.com, Gagandeep Singh Date: Fri, 28 Sep 2018 13:15:59 +0530 Message-Id: <20180928074601.4287-3-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180928074601.4287-1-g.singh@nxp.com> References: <20180928051647.32341-1-g.singh@nxp.com> <20180928074601.4287-1-g.singh@nxp.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR0101CA0037.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00:1a::23) To DB5PR04MB1528.eurprd04.prod.outlook.com (2a01:111:e400:5993::22) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: ce0ab77f-bfac-47eb-16f4-08d6251684bc X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989299)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990200)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:DB5PR04MB1528; X-Microsoft-Exchange-Diagnostics: 1; DB5PR04MB1528; 3:ATp8RclLcMtsKkvIVw6X2oIjuMPBCSGhqdaP6xogzDikJxtVkQAqcOnbEGqTWvAMT2KCytCbLB6hvhQsS4NdYzIf0gn+XM92wGiHrukJCo9hE5Zs4htvfWFCPpwOD1vLakDTFnotbkXglhJ0Dow70OflP6HPBqpTnBmz5GA9Au6nm1tb0P6yR0FOiMINFOnKAbmeYR1BR/HlYiN8nDk/wwN2XRFyKE0uSWUwOV37TiyfmKQY4KEbUTqX4EZorLy3; 25:9hy+t1cdGE51SqLJeXuI6R8X88WPNQFS45xQzDPW3lD/FcN2YLubdHNEGBQkLKffuB8C4e6nh6283Q3Rd6JpvrMWbLcO4M7RIGmiXevQNm1IguIgnlSUrgcbBRAf/u3D2BX5dmcdumegA12znpl0MOQ3p9Ob9GSr1FaB0Jc8hMnu2StfRYRoTmARh2J11PbAfhiVpV+0UANshM3j4gPTIOCU8tGRKXWVDuV2ukEaPf1syrTMrAjatLIU9ZKbYV/Y2RgQupMvRLEDQTz7h6GacqTxUZZ3B4hG8Bgg7OS/8jtBMnfTaLf0U/bcqgzQ2rexcIQ/QxWJCJ9PVIrcYqU2OQ==; 31:zsgoLdpEMaFaw442NDynDbhuZHTl8/rtcqvJP7IqCXsn2rxWtHM+jrAb85QZxouHxQ7t31HlcuaBpm68pqaME2Qq7ao7Dwea4x5GCW+hyhg9/EMm+4KmGN4+1/fDecUdtmYTFWQ0u6EnRrZ2Btz4RL6kJmrkjZGBXw+g2Utvtp46vB5jOEh8NQ1LNnDr+2R0qbaptG4TPHQqmzdw7qYNPLYlOf8nVV5vWUZqRHWPkUQ= X-MS-TrafficTypeDiagnostic: DB5PR04MB1528: X-Microsoft-Exchange-Diagnostics: 1; DB5PR04MB1528; 20:frXeyQ4Hdb41ttTDZoh5CjtEDQZVKJfdxCknfWLG5HFSVlHxA5XGMW6v+Adla2SykFsMGk98E7Bvv0iGg8LlD9PbwfrK8l5h6GiUmvNs2oOD/UZ9ZROf8O4M3Fw6yPIMdEeUURjhVxfeQNgpvpnebzSsPRrL0/pfAQzcZHfmbVKp0Mti5qcZgovGSa3hnC52Nib4CbXvSpCNe0Zcdu1dRpKzqkHK883sWI/BU8aThxFcdbMzzLgVc/OJXP+IhuyMYliJBRTi2jgqY6gVB6jji/BASySHMOYg1NY8dVYp4NnFDmR82FhlFW6xrgGl2SMjEmbM14MpivGSJvk7PeDUvAnjk2WwSniiML1oYfwph97GBRWfXYyJUhHkQs8qdOzmtlgyCEOqQwRsXkhyW5cqBhrdYTmYLRFxBue5QwDwDdKlT4kyBS6ulEL/p/UdpO5xfMgt7yKUa2g9jgz2sfg/2TiO8mw8o4yvFM67bZzjKumSjUWetRn8EdFuGLMdBQ/z; 4:r1AB5a8895ON+p0nxsFhiHqLJLK65cWDBHmxDtXjHwzu/06Ksn2iYnbpoi1sn0jOGMKloXimTYLlin+V+SbxErBPVoXrmPaNR3aXln/ZPsTD1fNicvZqkT8iKyOvGa8+Gtd2DFlApadNzM1JyZHbj4lQkoyWQFy5mESErq2+kETTd8TWLpKJXGvv2mzJIRE2Ybd7A7ry9hzYh0rCaoH7G7Irenn6jHhB9eRDu/rGvOuSVzm43Ar+k+MgxI6cioD2FSxWLwgogRwHBvAgfsvr50aTTcIiAPCaw7Ttz4Vk7h7imkKm8+ak6Y6EF9cAckd6 X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(3231355)(944501410)(52105095)(3002001)(10201501046)(93006095)(93001095)(6055026)(149066)(150057)(6041310)(20161123560045)(20161123564045)(20161123562045)(20161123558120)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(201708071742011)(7699051); SRVR:DB5PR04MB1528; BCL:0; PCL:0; RULEID:; SRVR:DB5PR04MB1528; X-Forefront-PRVS: 0809C12563 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(136003)(376002)(39860400002)(346002)(396003)(366004)(22813001)(189003)(199004)(386003)(6506007)(7736002)(186003)(6512007)(305945005)(36756003)(11346002)(97736004)(6486002)(956004)(52116002)(76176011)(51416003)(5660300001)(34290500001)(68736007)(50466002)(81166006)(81156014)(446003)(8676002)(50226002)(8936002)(47776003)(105586002)(48376002)(6116002)(3846002)(26005)(16526019)(106356001)(53936002)(66066001)(316002)(55236004)(1076002)(4326008)(2616005)(575784001)(72206003)(478600001)(25786009)(14444005)(476003)(86362001)(5009440100003)(16586007)(6666003)(486006)(2906002)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:DB5PR04MB1528; H:Tophie.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; DB5PR04MB1528; 23:hCdDNdbI4VFXD6a6vysBwC3rZCNBQuwy860pQYC+m?= =?us-ascii?Q?f6dEQeCuEa3fMERIqddh+cq93q/RQyQqsvoKMlJ4XFbdEqNdEZlHsq+AXfEl?= =?us-ascii?Q?n3ysvGlQL6s+YSSgYDLCUN4Itwt+wZ7SbQ66+0AYMSmJTjOY8634F4Qx2WUB?= =?us-ascii?Q?HxcXNtfW+7BqIv7mBqXASU7LVMG+KnY6EWrfSGJ+zvPpN4uyLShReoPyv3fy?= =?us-ascii?Q?cHuvHxBYLkCGYXFpI/zZtx66vuBQJzhgY+fyYXlohQyaw9z3o+ETE1ie9Sf6?= =?us-ascii?Q?9pPB1d6ujCBi6pMOtNgw/34vfq3qpVNjz9Dmjb0q9nrXQtPgot+hdb64VB7Q?= =?us-ascii?Q?oucAw/ehjHQDq4fko0v5ytSwJwGn3X4lI93IJ2+VWTWaVjzvcGt96pu24qch?= =?us-ascii?Q?YEINNR2/L2YLJRd0rCVXufWoIaNzwL+ljYbfYki7m5Uc/7wJpHdLg7DyiQNK?= =?us-ascii?Q?AoaASNYtH0jyyNknQiXHbzXtZ3VukoGGXGL6e6E85r260qXLuK7a1EqV0dPU?= =?us-ascii?Q?RAjd7hObR3R2ZYBOOUFiL8aEAXy82mnRD6SIxEP29nHsoU0gaWarG+tbon5I?= =?us-ascii?Q?ua30kQhxM7CfEUaYsk1Ms8DWDUGNMzbQCeMmdGkympYwhH+BYwZl3+ylfk9R?= =?us-ascii?Q?ZO6atjpGMDTjia42+BWZT7meROILQaLDNsJmCwSLszmVOdXyTYgGVXFi3T6V?= =?us-ascii?Q?qOkSuYH+S99AP/bFb4HDqRwXxQtwdihq/byoFwNCgwEvO42QDrrrm0IcsDjA?= =?us-ascii?Q?CpUD9wfhP1PdWd6FOcc07t2ZV1TnQp0cXfxEBdapMz2tEDivApFWnMrTsR+H?= =?us-ascii?Q?lQDkHXH0ceqyjGHKBFGhMVeQ/oi//IaJ/s/CAwQe5k6SO+6P6pp5ATUxNGzI?= =?us-ascii?Q?WqvuZRK2QwPV9VZyDq36ISpN6vLPyr7aRQKWloLfspk7ZVoWV74ub+bJp2Ga?= =?us-ascii?Q?CKhZgvWenk8OD0lrmtQRrmqoDJ6+6uKjCeDRpTBOsvJHC81Czbx+TWDu05Hf?= =?us-ascii?Q?V1WxZXxYPQlH/7zG6TGf6bARYrKqQ2SO6YQ1pekH0Za4RIeBB53mgDXqsRVC?= =?us-ascii?Q?aE80I/YeLAryX3PxNAfQZtjPWHfjrPF/7U8JueB+kWQewJERsI0xrCpoG7wC?= =?us-ascii?Q?diZleCh1t/pkzmdgE6ihEhPfMKif9lwfpYwaHFb3sax5faxnzsh54W1W7nzn?= =?us-ascii?Q?Y/+bNKj89tJLfnq4QRqrpMCup5S0z62M5X7gD4rNEUW8ONjRGIpkiJjad/dE?= =?us-ascii?Q?oeu00VlSJa9yZ2UnWf2BF3FMtJjpkpDxXK+sIskR9k7W9JaV9elSvuSpbqP8?= =?us-ascii?Q?ZsF5MJqCP46xsv7BsnKyV1/I50Lyp5b3LypNPDCjZxUJjV84TF6lla/eSSyT?= =?us-ascii?Q?tUxqg=3D=3D?= X-Microsoft-Antispam-Message-Info: Irknk2H5j3Hr6S9VSpNzTmjMqNMQhlg/Rnk7f0bjZJxk3ojYxKhA8mcaTxbNeWGDjgtt9LcRtFMXqZoRsrXIQOJVKvK5gdsoP/qgyHrj29KsBqrmgtR3ghpUbpk99OFh7VDhXZoCp4NsxxaJSqHExobIxTHPGHsWdfHGoPPKN6PNZxfNk9RYoO1LBEftdRvZYQ4VD0dF3H2Gc5S4zhdq2hbBEyd1uzmA74V8QKZ9U21LGVdi6rPfbhTJKPAmdq99Ml/vZtYJ94djcz/V8QS/rxIwWKVdqPrSucyDcJ4fTrF+DmZYfSai7Gjs4BwEoXmesItuxstRoNZrTinDwkCcIvry8hqssYMCx/eSveQ43YA= X-Microsoft-Exchange-Diagnostics: 1; DB5PR04MB1528; 6:euzNkKCDEBL9Ik07QhUQqwrn6OgjwpjV14GXNCzyW3nijdlkPSu29Bgcj9zpXLDFqLKuVcFw0IlRr+xAJBamZMP9emMNUqoeypZGejFpe6nbhSzvq2yB6556NKWiCPtftoNA/K6v5VTgVibhERF4BW1fGAdpzLA1pA6Dg3uVg/qaxFX80tqdOdWoMIIen4Qxc876JpvP+zA0g3RHqwitIhqnLEeLM/hSZDeMXACV9TDHtR0h1F1ZisLqeWVRwDlNqRPQ+zwKwZ7joODkr4RkgBOkRwwaGmAd1Uh4FamjuqODQ8DLs/+V7nKHIL8uVr7KiIsBb+NYwaCBZ/dgZp+S/VpGcwmgGqY1qEA90MJo4KI/AjyGfbs8TnqNN6toiy4jR9B/yuOcI8kgKy+x+RAyDfFM3SCBlUmK6+kNifw/NYVjVLT42v9Sd01S5MmdRX51iul7m+6UBxXKcbwOVtoJLQ==; 5:UZgbZGw1hU5xA/S7jm5Vfh8PmT+c8hrlC/7LnFcd2517Sj6zhCC1IWptGH8VXme5237JnOhZ8xHyP7ARGZ1BjLms4btmeAVYDFx/sos5NQbrP5m9zapHIqEGqD9lesrE8UShrQbcqN7Wg5YAf6xtGxK5jW7ysX/E4+CLfdmDOQ0=; 7:34sUQtnaG6czlwGycgIT/OSQFZkFG4MGk0m6ww8W1yUWrcMjc5m/IylE6jNmXgOiHtrFAA1O4BE9FBkJRxniiBTplZYptz18B0KtJ2SWqiU8hSKA/1uqM2bXogxo5gUJg/2cetdH6bpRcFOnd1NiQOb6ac+jZZk30oLIcYVU7uevCgRG2+WkX126ACSGTEHVszkkbYdy/QslCDA+L7EePW4WOu6QQWRWdV1EnY9+rgB3KZNoFR8T5tx30ypEXcrh SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 28 Sep 2018 07:46:35.4802 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: ce0ab77f-bfac-47eb-16f4-08d6251684bc X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB5PR04MB1528 Subject: [dpdk-dev] [PATCH v4 2/4] net/enetc: enable Rx and Tx 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, 28 Sep 2018 07:46:39 -0000 Add RX and TX queue setup, datapath functions Signed-off-by: Gagandeep Singh --- drivers/net/enetc/Makefile | 3 +- drivers/net/enetc/base/enetc_hw.h | 19 +- drivers/net/enetc/enetc.h | 25 ++- drivers/net/enetc/enetc_ethdev.c | 326 +++++++++++++++++++++++++++++- drivers/net/enetc/enetc_rxtx.c | 239 ++++++++++++++++++++++ drivers/net/enetc/meson.build | 3 +- 6 files changed, 602 insertions(+), 13 deletions(-) create mode 100644 drivers/net/enetc/enetc_rxtx.c diff --git a/drivers/net/enetc/Makefile b/drivers/net/enetc/Makefile index 519153868..9895501db 100644 --- a/drivers/net/enetc/Makefile +++ b/drivers/net/enetc/Makefile @@ -14,8 +14,9 @@ EXPORT_MAP := rte_pmd_enetc_version.map LIBABIVER := 1 SRCS-$(CONFIG_RTE_LIBRTE_ENETC_PMD) += enetc_ethdev.c +SRCS-$(CONFIG_RTE_LIBRTE_ENETC_PMD) += enetc_rxtx.c -LDLIBS += -lrte_eal +LDLIBS += -lrte_eal -lrte_mbuf -lrte_mempool LDLIBS += -lrte_ethdev LDLIBS += -lrte_bus_pci diff --git a/drivers/net/enetc/base/enetc_hw.h b/drivers/net/enetc/base/enetc_hw.h index c962b9ca1..c74c94875 100644 --- a/drivers/net/enetc/base/enetc_hw.h +++ b/drivers/net/enetc/base/enetc_hw.h @@ -104,16 +104,19 @@ enum enetc_bdr_type {TX, RX}; #define ETH_ADDR_LEN 6 /* general register accessors */ -#define enetc_rd_reg(reg) rte_read32((reg)) -#define enetc_wr_reg(reg, val) rte_write32((val), (reg)) -#define enetc_rd(hw, off) enetc_rd_reg((hw)->reg + (off)) -#define enetc_wr(hw, off, val) enetc_wr_reg((hw)->reg + (off), val) +#define enetc_rd_reg(reg) rte_read32((void *)(reg)) +#define enetc_wr_reg(reg, val) rte_write32((val), (void *)(reg)) +#define enetc_rd(hw, off) enetc_rd_reg((size_t)(hw)->reg + (off)) +#define enetc_wr(hw, off, val) enetc_wr_reg((size_t)(hw)->reg + (off), val) /* port register accessors - PF only */ -#define enetc_port_rd(hw, off) enetc_rd_reg((hw)->port + (off)) -#define enetc_port_wr(hw, off, val) enetc_wr_reg((hw)->port + (off), val) +#define enetc_port_rd(hw, off) enetc_rd_reg((size_t)(hw)->port + (off)) +#define enetc_port_wr(hw, off, val) \ + enetc_wr_reg((size_t)(hw)->port + (off), val) /* global register accessors - PF only */ -#define enetc_global_rd(hw, off) enetc_rd_reg((hw)->global + (off)) -#define enetc_global_wr(hw, off, val) enetc_wr_reg((hw)->global + (off), val) +#define enetc_global_rd(hw, off) \ + enetc_rd_reg((size_t)(hw)->global + (off)) +#define enetc_global_wr(hw, off, val) \ + enetc_wr_reg((size_t)(hw)->global + (off), val) /* BDR register accessors, see ENETC_BDR() */ #define enetc_bdr_rd(hw, t, n, off) \ enetc_rd(hw, ENETC_BDR(t, n, off)) diff --git a/drivers/net/enetc/enetc.h b/drivers/net/enetc/enetc.h index 9fa7c726c..140daf0dd 100644 --- a/drivers/net/enetc/enetc.h +++ b/drivers/net/enetc/enetc.h @@ -18,7 +18,11 @@ #define MAX_RX_RINGS 1 /* Max BD counts per Ring. */ -#define MAX_BD_COUNT 256 +#define MAX_BD_COUNT 64000 +/* Min BD counts per Ring. */ +#define MIN_BD_COUNT 32 +/* BD ALIGN */ +#define BD_ALIGN 8 /* * upper_32_bits - return bits 32-63 of a number @@ -87,4 +91,23 @@ struct enetc_eth_adapter { #define ENETC_REG_WRITE(addr, val) (*(uint32_t *)addr = val) #define ENETC_REG_WRITE_RELAXED(addr, val) (*(uint32_t *)addr = val) +/* + * RX/TX ENETC function prototypes + */ +uint16_t enetc_xmit_pkts(void *txq, struct rte_mbuf **tx_pkts, + uint16_t nb_pkts); +uint16_t enetc_recv_pkts(void *rxq, struct rte_mbuf **rx_pkts, + uint16_t nb_pkts); + + +int enetc_refill_rx_ring(struct enetc_bdr *rx_ring, const int buff_cnt); + +static inline int +enetc_bd_unused(struct enetc_bdr *bdr) +{ + if (bdr->next_to_clean > bdr->next_to_use) + return bdr->next_to_clean - bdr->next_to_use - 1; + + return bdr->bd_count + bdr->next_to_clean - bdr->next_to_use - 1; +} #endif /* _ENETC_H_ */ diff --git a/drivers/net/enetc/enetc_ethdev.c b/drivers/net/enetc/enetc_ethdev.c index 47e2a8ebf..2d90d8fd5 100644 --- a/drivers/net/enetc/enetc_ethdev.c +++ b/drivers/net/enetc/enetc_ethdev.c @@ -19,6 +19,15 @@ static void enetc_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info); static int enetc_link_update(struct rte_eth_dev *dev, int wait_to_complete); static int enetc_hardware_init(struct enetc_eth_hw *hw); +static int enetc_rx_queue_setup(struct rte_eth_dev *dev, uint16_t rx_queue_id, + uint16_t nb_rx_desc, unsigned int socket_id, + const struct rte_eth_rxconf *rx_conf, + struct rte_mempool *mb_pool); +static void enetc_rx_queue_release(void *rxq); +static int enetc_tx_queue_setup(struct rte_eth_dev *dev, uint16_t tx_queue_id, + uint16_t nb_tx_desc, unsigned int socket_id, + const struct rte_eth_txconf *tx_conf); +static void enetc_tx_queue_release(void *txq); /* * The set of PCI devices this driver supports @@ -37,6 +46,10 @@ static const struct eth_dev_ops enetc_ops = { .dev_close = enetc_dev_close, .link_update = enetc_link_update, .dev_infos_get = enetc_dev_infos_get, + .rx_queue_setup = enetc_rx_queue_setup, + .rx_queue_release = enetc_rx_queue_release, + .tx_queue_setup = enetc_tx_queue_setup, + .tx_queue_release = enetc_tx_queue_release, }; /** @@ -59,8 +72,8 @@ enetc_dev_init(struct rte_eth_dev *eth_dev) PMD_INIT_FUNC_TRACE(); eth_dev->dev_ops = &enetc_ops; - eth_dev->rx_pkt_burst = NULL; - eth_dev->tx_pkt_burst = NULL; + eth_dev->rx_pkt_burst = &enetc_recv_pkts; + eth_dev->tx_pkt_burst = &enetc_xmit_pkts; /* Retrieving and storing the HW base address of device */ hw->hw.reg = (void *)pci_dev->mem_resource[0].addr; @@ -212,11 +225,320 @@ enetc_dev_infos_get(struct rte_eth_dev *dev __rte_unused, struct rte_eth_dev_info *dev_info) { PMD_INIT_FUNC_TRACE(); + dev_info->rx_desc_lim = (struct rte_eth_desc_lim) { + .nb_max = MAX_BD_COUNT, + .nb_min = MIN_BD_COUNT, + .nb_align = BD_ALIGN, + }; + dev_info->tx_desc_lim = (struct rte_eth_desc_lim) { + .nb_max = MAX_BD_COUNT, + .nb_min = MIN_BD_COUNT, + .nb_align = BD_ALIGN, + }; dev_info->max_rx_queues = MAX_RX_RINGS; dev_info->max_tx_queues = MAX_TX_RINGS; dev_info->max_rx_pktlen = 1500; } +static int +enetc_alloc_txbdr(struct enetc_bdr *txr, uint16_t nb_desc) +{ + int size; + + size = nb_desc * sizeof(struct enetc_swbd); + txr->q_swbd = rte_malloc(NULL, size, RTE_CACHE_LINE_SIZE); + if (txr->q_swbd == NULL) + return -ENOMEM; + + size = nb_desc * sizeof(struct enetc_tx_bd); + txr->bd_base = rte_malloc(NULL, size, RTE_CACHE_LINE_SIZE); + if (txr->bd_base == NULL) { + rte_free(txr->q_swbd); + txr->q_swbd = NULL; + return -ENOMEM; + } + + txr->bd_count = nb_desc; + txr->next_to_clean = 0; + txr->next_to_use = 0; + + return 0; +} + +static void +enetc_free_bdr(struct enetc_bdr *rxr) +{ + rte_free(rxr->q_swbd); + rte_free(rxr->bd_base); + rxr->q_swbd = NULL; + rxr->bd_base = NULL; +} + +static void +enetc_setup_txbdr(struct enetc_hw *hw, struct enetc_bdr *tx_ring) +{ + int idx = tx_ring->index; + uintptr_t base_addr; + uint32_t tbmr; + + base_addr = (uintptr_t)tx_ring->bd_base; + enetc_txbdr_wr(hw, idx, ENETC_TBBAR0, + lower_32_bits((uint64_t)base_addr)); + enetc_txbdr_wr(hw, idx, ENETC_TBBAR1, + upper_32_bits((uint64_t)base_addr)); + enetc_txbdr_wr(hw, idx, ENETC_TBLENR, + ENETC_RTBLENR_LEN(tx_ring->bd_count)); + + tbmr = ENETC_TBMR_EN; + /* enable ring */ + enetc_txbdr_wr(hw, idx, ENETC_TBMR, tbmr); + enetc_txbdr_wr(hw, idx, ENETC_TBCIR, 0); + enetc_txbdr_wr(hw, idx, ENETC_TBCISR, 0); + tx_ring->tcir = (void *)((size_t)hw->reg + + ENETC_BDR(TX, idx, ENETC_TBCIR)); + tx_ring->tcisr = (void *)((size_t)hw->reg + + ENETC_BDR(TX, idx, ENETC_TBCISR)); +} + +static int +enetc_alloc_tx_resources(struct rte_eth_dev *dev, + uint16_t queue_idx, + uint16_t nb_desc) +{ + int err; + struct enetc_bdr *tx_ring; + struct rte_eth_dev_data *data = dev->data; + struct enetc_eth_adapter *priv = + ENETC_DEV_PRIVATE(data->dev_private); + + tx_ring = rte_zmalloc(NULL, sizeof(struct enetc_bdr), 0); + if (tx_ring == NULL) { + ENETC_PMD_ERR("Failed to allocate TX ring memory"); + err = -ENOMEM; + return -1; + } + + err = enetc_alloc_txbdr(tx_ring, nb_desc); + if (err) + goto fail; + + tx_ring->index = queue_idx; + tx_ring->ndev = dev; + enetc_setup_txbdr(&priv->hw.hw, tx_ring); + data->tx_queues[queue_idx] = tx_ring; + + return 0; +fail: + rte_free(tx_ring); + + return err; +} + +static int +enetc_tx_queue_setup(struct rte_eth_dev *dev, + uint16_t queue_idx, + uint16_t nb_desc, + unsigned int socket_id __rte_unused, + const struct rte_eth_txconf *tx_conf __rte_unused) +{ + int err = 0; + + PMD_INIT_FUNC_TRACE(); + if (nb_desc > MAX_BD_COUNT) + return -1; + + err = enetc_alloc_tx_resources(dev, queue_idx, nb_desc); + + return err; +} + +static void +enetc_tx_queue_release(void *txq) +{ + if (txq == NULL) + return; + + struct enetc_bdr *tx_ring = (struct enetc_bdr *)txq; + struct enetc_eth_hw *eth_hw = + ENETC_DEV_PRIVATE_TO_HW(tx_ring->ndev->data->dev_private); + struct enetc_hw *hw; + struct enetc_swbd *tx_swbd; + int i; + uint32_t val; + + /* Disable the ring */ + hw = ð_hw->hw; + val = enetc_txbdr_rd(hw, tx_ring->index, ENETC_TBMR); + val &= (~ENETC_TBMR_EN); + enetc_txbdr_wr(hw, tx_ring->index, ENETC_TBMR, val); + + /* clean the ring*/ + i = tx_ring->next_to_clean; + tx_swbd = &tx_ring->q_swbd[i]; + while (tx_swbd->buffer_addr != NULL) { + rte_pktmbuf_free(tx_swbd->buffer_addr); + tx_swbd->buffer_addr = NULL; + tx_swbd++; + i++; + if (unlikely(i == tx_ring->bd_count)) { + i = 0; + tx_swbd = &tx_ring->q_swbd[i]; + } + } + + enetc_free_bdr(tx_ring); + rte_free(tx_ring); +} + +static int +enetc_alloc_rxbdr(struct enetc_bdr *rxr, + uint16_t nb_rx_desc) +{ + int size; + + size = nb_rx_desc * sizeof(struct enetc_swbd); + rxr->q_swbd = rte_malloc(NULL, size, RTE_CACHE_LINE_SIZE); + if (rxr->q_swbd == NULL) + return -ENOMEM; + + size = nb_rx_desc * sizeof(union enetc_rx_bd); + rxr->bd_base = rte_malloc(NULL, size, RTE_CACHE_LINE_SIZE); + if (rxr->bd_base == NULL) { + rte_free(rxr->q_swbd); + rxr->q_swbd = NULL; + return -ENOMEM; + } + + rxr->bd_count = nb_rx_desc; + rxr->next_to_clean = 0; + rxr->next_to_use = 0; + rxr->next_to_alloc = 0; + + return 0; +} + +static void +enetc_setup_rxbdr(struct enetc_hw *hw, struct enetc_bdr *rx_ring, + struct rte_mempool *mb_pool) +{ + int idx = rx_ring->index; + uintptr_t base_addr; + uint16_t buf_size; + + base_addr = (uintptr_t)rx_ring->bd_base; + enetc_rxbdr_wr(hw, idx, ENETC_RBBAR0, + lower_32_bits((uint64_t)base_addr)); + enetc_rxbdr_wr(hw, idx, ENETC_RBBAR1, + upper_32_bits((uint64_t)base_addr)); + enetc_rxbdr_wr(hw, idx, ENETC_RBLENR, + ENETC_RTBLENR_LEN(rx_ring->bd_count)); + + rx_ring->mb_pool = mb_pool; + /* enable ring */ + enetc_rxbdr_wr(hw, idx, ENETC_RBMR, ENETC_RBMR_EN); + enetc_rxbdr_wr(hw, idx, ENETC_RBPIR, 0); + rx_ring->rcir = (void *)((size_t)hw->reg + + ENETC_BDR(RX, idx, ENETC_RBCIR)); + enetc_refill_rx_ring(rx_ring, (enetc_bd_unused(rx_ring))); + buf_size = (uint16_t)(rte_pktmbuf_data_room_size(rx_ring->mb_pool) - + RTE_PKTMBUF_HEADROOM); + enetc_rxbdr_wr(hw, idx, ENETC_RBBSR, buf_size); +} + +static int +enetc_alloc_rx_resources(struct rte_eth_dev *dev, + uint16_t rx_queue_id, + uint16_t nb_rx_desc, + struct rte_mempool *mb_pool) +{ + int err; + struct enetc_bdr *rx_ring; + struct rte_eth_dev_data *data = dev->data; + struct enetc_eth_adapter *adapter = + ENETC_DEV_PRIVATE(data->dev_private); + + rx_ring = rte_zmalloc(NULL, sizeof(struct enetc_bdr), 0); + if (rx_ring == NULL) { + ENETC_PMD_ERR("Failed to allocate RX ring memory"); + err = -ENOMEM; + return err; + } + + err = enetc_alloc_rxbdr(rx_ring, nb_rx_desc); + if (err) + goto fail; + + rx_ring->index = rx_queue_id; + rx_ring->ndev = dev; + enetc_setup_rxbdr(&adapter->hw.hw, rx_ring, mb_pool); + data->rx_queues[rx_queue_id] = rx_ring; + + return 0; +fail: + rte_free(rx_ring); + + return err; +} + +static int +enetc_rx_queue_setup(struct rte_eth_dev *dev, + uint16_t rx_queue_id, + uint16_t nb_rx_desc, + unsigned int socket_id __rte_unused, + const struct rte_eth_rxconf *rx_conf __rte_unused, + struct rte_mempool *mb_pool) +{ + int err = 0; + + PMD_INIT_FUNC_TRACE(); + if (nb_rx_desc > MAX_BD_COUNT) + return -1; + + err = enetc_alloc_rx_resources(dev, rx_queue_id, + nb_rx_desc, + mb_pool); + + return err; +} + +static void +enetc_rx_queue_release(void *rxq) +{ + if (rxq == NULL) + return; + + struct enetc_bdr *rx_ring = (struct enetc_bdr *)rxq; + struct enetc_eth_hw *eth_hw = + ENETC_DEV_PRIVATE_TO_HW(rx_ring->ndev->data->dev_private); + struct enetc_swbd *q_swbd; + struct enetc_hw *hw; + uint32_t val; + int i; + + /* Disable the ring */ + hw = ð_hw->hw; + val = enetc_rxbdr_rd(hw, rx_ring->index, ENETC_RBMR); + val &= (~ENETC_RBMR_EN); + enetc_rxbdr_wr(hw, rx_ring->index, ENETC_RBMR, val); + + /* Clean the ring */ + i = rx_ring->next_to_clean; + q_swbd = &rx_ring->q_swbd[i]; + while (i != rx_ring->next_to_use) { + rte_pktmbuf_free(q_swbd->buffer_addr); + q_swbd->buffer_addr = NULL; + q_swbd++; + i++; + if (unlikely(i == rx_ring->bd_count)) { + i = 0; + q_swbd = &rx_ring->q_swbd[i]; + } + } + + enetc_free_bdr(rx_ring); + rte_free(rx_ring); +} + static int enetc_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, struct rte_pci_device *pci_dev) diff --git a/drivers/net/enetc/enetc_rxtx.c b/drivers/net/enetc/enetc_rxtx.c new file mode 100644 index 000000000..631e2430d --- /dev/null +++ b/drivers/net/enetc/enetc_rxtx.c @@ -0,0 +1,239 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2018 NXP + */ + +#include +#include +#include + +#include "rte_ethdev.h" +#include "rte_malloc.h" +#include "rte_memzone.h" + +#include "base/enetc_hw.h" +#include "enetc.h" +#include "enetc_logs.h" + +#define ENETC_RXBD_BUNDLE 8 /* Number of BDs to update at once */ + +static int +enetc_clean_tx_ring(struct enetc_bdr *tx_ring) +{ + int tx_frm_cnt = 0; + struct enetc_swbd *tx_swbd; + int i; + + i = tx_ring->next_to_clean; + tx_swbd = &tx_ring->q_swbd[i]; + while ((int)(enetc_rd_reg(tx_ring->tcisr) & + ENETC_TBCISR_IDX_MASK) != i) { + rte_pktmbuf_free(tx_swbd->buffer_addr); + tx_swbd->buffer_addr = NULL; + tx_swbd++; + i++; + if (unlikely(i == tx_ring->bd_count)) { + i = 0; + tx_swbd = &tx_ring->q_swbd[0]; + } + + tx_frm_cnt++; + } + + tx_ring->next_to_clean = i; + return tx_frm_cnt++; +} + +uint16_t +enetc_xmit_pkts(void *tx_queue, + struct rte_mbuf **tx_pkts, + uint16_t nb_pkts) +{ + struct enetc_swbd *tx_swbd; + int i, start; + struct enetc_tx_bd *txbd; + struct enetc_bdr *tx_ring = (struct enetc_bdr *)tx_queue; + + i = tx_ring->next_to_use; + start = 0; + while (nb_pkts--) { + enetc_clean_tx_ring(tx_ring); + tx_ring->q_swbd[i].buffer_addr = tx_pkts[start]; + txbd = ENETC_TXBD(*tx_ring, i); + tx_swbd = &tx_ring->q_swbd[i]; + txbd->frm_len = tx_pkts[start]->pkt_len; + txbd->buf_len = txbd->frm_len; + txbd->flags = rte_cpu_to_le_16(ENETC_TXBD_FLAGS_F); + txbd->addr = (uint64_t)(uintptr_t) + rte_cpu_to_le_64((size_t)tx_swbd->buffer_addr->buf_addr + + tx_swbd->buffer_addr->data_off); + i++; + start++; + if (unlikely(i == tx_ring->bd_count)) + i = 0; + } + + tx_ring->next_to_use = i; + enetc_wr_reg(tx_ring->tcir, i); + return start; +} + +int +enetc_refill_rx_ring(struct enetc_bdr *rx_ring, const int buff_cnt) +{ + struct enetc_swbd *rx_swbd; + union enetc_rx_bd *rxbd; + int i, j; + + i = rx_ring->next_to_use; + rx_swbd = &rx_ring->q_swbd[i]; + rxbd = ENETC_RXBD(*rx_ring, i); + for (j = 0; j < buff_cnt; j++) { + rx_swbd->buffer_addr = + rte_cpu_to_le_64(rte_mbuf_raw_alloc(rx_ring->mb_pool)); + rxbd->w.addr = (uint64_t)(uintptr_t) + rx_swbd->buffer_addr->buf_addr + + rx_swbd->buffer_addr->data_off; + /* clear 'R" as well */ + rxbd->r.lstatus = 0; + rx_swbd++; + rxbd++; + i++; + if (unlikely(i == rx_ring->bd_count)) { + i = 0; + rxbd = ENETC_RXBD(*rx_ring, 0); + rx_swbd = &rx_ring->q_swbd[i]; + } + } + + if (likely(j)) { + rx_ring->next_to_alloc = i; + rx_ring->next_to_use = i; + enetc_wr_reg(rx_ring->rcir, i); + } + + return j; +} + + +static inline void __attribute__((hot)) +enetc_dev_rx_parse(struct rte_mbuf *m, uint16_t parse_results) +{ + ENETC_PMD_DP_DEBUG("parse summary = 0x%x ", parse_results); + + m->packet_type = RTE_PTYPE_UNKNOWN; + switch (parse_results) { + case ENETC_PKT_TYPE_ETHER: + m->packet_type = RTE_PTYPE_L2_ETHER; + break; + case ENETC_PKT_TYPE_IPV4: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV4; + break; + case ENETC_PKT_TYPE_IPV6: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV6; + break; + case ENETC_PKT_TYPE_IPV4_TCP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV4 | + RTE_PTYPE_L4_TCP; + break; + case ENETC_PKT_TYPE_IPV6_TCP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV6 | + RTE_PTYPE_L4_TCP; + break; + case ENETC_PKT_TYPE_IPV4_UDP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV4 | + RTE_PTYPE_L4_UDP; + break; + case ENETC_PKT_TYPE_IPV6_UDP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV6 | + RTE_PTYPE_L4_UDP; + break; + case ENETC_PKT_TYPE_IPV4_SCTP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV4 | + RTE_PTYPE_L4_SCTP; + break; + case ENETC_PKT_TYPE_IPV6_SCTP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV6 | + RTE_PTYPE_L4_SCTP; + break; + case ENETC_PKT_TYPE_IPV4_ICMP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV4 | + RTE_PTYPE_L4_ICMP; + break; + case ENETC_PKT_TYPE_IPV6_ICMP: + m->packet_type = RTE_PTYPE_L2_ETHER | + RTE_PTYPE_L3_IPV6 | + RTE_PTYPE_L4_ICMP; + break; + /* More switch cases can be added */ + default: + m->packet_type = RTE_PTYPE_UNKNOWN; + } +} + +static int +enetc_clean_rx_ring(struct enetc_bdr *rx_ring, + struct rte_mbuf **rx_pkts, + int work_limit) +{ + int rx_frm_cnt = 0; + int cleaned_cnt, i; + struct enetc_swbd *rx_swbd; + + cleaned_cnt = enetc_bd_unused(rx_ring); + /* next descriptor to process */ + i = rx_ring->next_to_clean; + rx_swbd = &rx_ring->q_swbd[i]; + while (likely(rx_frm_cnt < work_limit)) { + union enetc_rx_bd *rxbd; + uint32_t bd_status; + + if (cleaned_cnt >= ENETC_RXBD_BUNDLE) { + int count = enetc_refill_rx_ring(rx_ring, cleaned_cnt); + + cleaned_cnt -= count; + } + + rxbd = ENETC_RXBD(*rx_ring, i); + bd_status = rte_le_to_cpu_32(rxbd->r.lstatus); + if (!bd_status) + break; + + rx_swbd->buffer_addr->pkt_len = rxbd->r.buf_len; + rx_swbd->buffer_addr->data_len = rxbd->r.buf_len; + rx_swbd->buffer_addr->hash.rss = rxbd->r.rss_hash; + rx_swbd->buffer_addr->ol_flags = 0; + enetc_dev_rx_parse(rx_swbd->buffer_addr, + rxbd->r.parse_summary); + rx_pkts[rx_frm_cnt] = rx_swbd->buffer_addr; + cleaned_cnt++; + rx_swbd++; + i++; + if (unlikely(i == rx_ring->bd_count)) { + i = 0; + rx_swbd = &rx_ring->q_swbd[i]; + } + + rx_ring->next_to_clean = i; + rx_frm_cnt++; + } + + return rx_frm_cnt; +} + +uint16_t +enetc_recv_pkts(void *rxq, struct rte_mbuf **rx_pkts, + uint16_t nb_pkts) +{ + struct enetc_bdr *rx_ring = (struct enetc_bdr *)rxq; + + return enetc_clean_rx_ring(rx_ring, rx_pkts, nb_pkts); +} diff --git a/drivers/net/enetc/meson.build b/drivers/net/enetc/meson.build index 506b174ed..733156bbf 100644 --- a/drivers/net/enetc/meson.build +++ b/drivers/net/enetc/meson.build @@ -5,6 +5,7 @@ if host_machine.system() != 'linux' build = false endif -sources = files('enetc_ethdev.c') +sources = files('enetc_ethdev.c', + 'enetc_rxtx.c') includes += include_directories('base') -- 2.17.1