From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM01-BN3-obe.outbound.protection.outlook.com (mail-bn3nam01on0074.outbound.protection.outlook.com [104.47.33.74]) by dpdk.org (Postfix) with ESMTP id 6BF4C7D21 for ; Fri, 16 Jun 2017 07:33:13 +0200 (CEST) Received: from MWHPR03CA0023.namprd03.prod.outlook.com (10.175.133.161) by BN3PR0301MB1186.namprd03.prod.outlook.com (10.160.156.148) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1178.14; Fri, 16 Jun 2017 05:33:11 +0000 Received: from BN1BFFO11FD047.protection.gbl (2a01:111:f400:7c10::1:158) by MWHPR03CA0023.outlook.office365.com (2603:10b6:300:117::33) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1157.12 via Frontend Transport; Fri, 16 Jun 2017 05:33:11 +0000 Authentication-Results: spf=fail (sender IP is 192.88.168.50) smtp.mailfrom=nxp.com; nxp.com; dkim=none (message not signed) header.d=none;nxp.com; dmarc=fail action=none header.from=nxp.com; Received-SPF: Fail (protection.outlook.com: domain of nxp.com does not designate 192.88.168.50 as permitted sender) receiver=protection.outlook.com; client-ip=192.88.168.50; helo=tx30smr01.am.freescale.net; Received: from tx30smr01.am.freescale.net (192.88.168.50) by BN1BFFO11FD047.mail.protection.outlook.com (10.58.145.2) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1157.12 via Frontend Transport; Fri, 16 Jun 2017 05:33:10 +0000 Received: from Tophie.ap.freescale.net ([10.232.14.39]) by tx30smr01.am.freescale.net (8.14.3/8.14.0) with ESMTP id v5G5WNFN001003; Thu, 15 Jun 2017 22:33:09 -0700 From: Shreyansh Jain To: CC: , Date: Fri, 16 Jun 2017 11:10:54 +0530 Message-ID: <1497591668-3320-25-git-send-email-shreyansh.jain@nxp.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1497591668-3320-1-git-send-email-shreyansh.jain@nxp.com> References: <1497591668-3320-1-git-send-email-shreyansh.jain@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131420647910612237; (91ab9b29-cfa4-454e-5278-08d120cd25b8); () X-Forefront-Antispam-Report: CIP:192.88.168.50; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(336005)(39840400002)(39410400002)(39400400002)(39850400002)(39860400002)(39380400002)(39450400003)(2980300002)(1109001)(1110001)(339900001)(51234002)(199003)(189002)(9170700003)(85426001)(6916009)(48376002)(36756003)(33646002)(5660300001)(2950100002)(2906002)(104016004)(356003)(5003940100001)(6666003)(38730400002)(105606002)(8936002)(4326008)(86362001)(81166006)(106466001)(189998001)(50226002)(77096006)(50986999)(110136004)(76176999)(47776003)(2351001)(8676002)(54906002)(50466002)(53936002)(305945005)(498600001)(8656002); DIR:OUT; SFP:1101; SCL:1; SRVR:BN3PR0301MB1186; H:tx30smr01.am.freescale.net; FPR:; SPF:Fail; MLV:ovrnspm; A:1; MX:1; PTR:InfoDomainNonexistent; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BN1BFFO11FD047; 1:ND00ti9NPem3yTlEBA30e8qK119NkHz9g3HIXnIz5jA72F8OJo6Zi02ZrWJOWqmFl/xjlIE9b8v56t4dseML5PawP6jO6Rfk3Jc79Ik6z4hHwH+83nz5awOl5pD8NUDy6JkvxjHqInF6uzjJQCYYzXGJfctz4Mf/0uZqJqwQQZT7RTuRBtZdy58OEvP11qApPSy4iOAGVPB3nI2nw+PEIrkOT9NURCYRjCncsoEG4N+0H4KcLmiINYjPUoRFCwLVxIBmGDCt+EXJscDnYaQ4nH8Wh6WgjtazKVD7ModrLb1C/l5xccWEkT9dHUuqTpjIn329cS5PaoOiWj9UinbZxXkyd9g8N57MY5p+dwTByfe2LLaqPw5IsEpNLfx30Uw1Dls86nLlvtwdGSmHuxJtE5eBF0dn9uwgVfCNHXq8v61WAXT90TgXFCZnwlKFos3CaZlAMTnjID+aDlOBdorbVQHcWY4zGlvRQL4V3b4rcMEojX4H5Eb/+Ym6f3ilIYD1LCwngTzzPFZrMJHLZAg7W2Wg5ylpEORSB/q7LYQXhQNFjOlvprdRtYaC1wBojEaiZTdTpAnXrlylGGCdy/7IyxVGr9KwlVTwmpxnEpRj6THx61BZ19niUX03Lww34ZfMkpFhLKizvjZPJ+KDXkJBKnfNDzCDbv+/Jrn9XiNg5p4fPzByvhO5jzxwgzn97BAo2hTZ7rAw7ZanG9Xey86PcnHhI641gw2ygxKTCLD0bhw= MIME-Version: 1.0 Content-Type: text/plain X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 961a866a-91ed-4d2f-bbb0-08d4b4792d51 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(22001)(201703131430075)(201703131517081); SRVR:BN3PR0301MB1186; X-Microsoft-Exchange-Diagnostics: 1; BN3PR0301MB1186; 3:YoIeOUplzDK3EyDhAu3Y2iqCI1JU6GnzaybgR9g5PrB0RjaHlhWK+qrwaz6IcFAqCDfngBDZ6v3dSnjb7Q/+hANcErD2rB96FxYG/+2G3oV7VyVRPxHFY6QoO5BEEt2AwehH4K2OEsRUlNFLrTxMZn0GSxFEzuMOLjCSramkXL8eOCFIHhZun16Ki2vZ4oUAPfPOQcYoTSjAmXHNIvSTs9HskpF3XrBx3bC/DAy0YilWpgclMbc1Gw7Pzb6U5ymN3MBQMJXHuFLkaZHtClYONQX8sKzRjWLgO9qMy9fk6/9hfakcfjVThML5YnV09U7EEOu9D4XyeIcqsVosBjbGMXBgSu4vuxzO03EUk85oUObjGo5C1uv65IKO6DoOWenc+kbuY0O1MLYLa6vC//1cJKFA+VcZBcjoe9xZ/0YMEzHdAtUt0+EWR267dCRu01vM; 25:c5DZNoz8cOeu0QFyLvzTCulMj8Av23xWardgSbtK82EmXPSs8z18ULPOsY940N2VwJREHC9xygnUh4yq1qb2D/Ip+3K6rR0xEdNOeH3hdJQpK5046tX3K2wsuQjgjx6QJv6IQkcqiDJzrw/CpUkZdTPfCuyRNXqVMVJ+lPotT+5mKsdpw/qiLRHySB+hRDR7odADA3245MDntziMQ6Q+/Xs9N+I2W0F+vJn3MTaOsy/E0sfZ+6Tn39GlcKBX1knRxlG0BR5en9sXx9YtBcb31IthPQTh3KwqMUGmCZn54r4mXi/veOXu4QsWIPblOVsvkHHWYFrYWDteUrkS98yhRYEPfligQfet4yO8JgQoch35oc/hIU7rWlxNXTJj0sPgb1Yx8r7muIHkk5waLsTV9LzAhYUUaNNlpPHpnI9Wq0QzxGBNI8jiNtH8ZLaIUJBt2XtXVmw24TduxzUl0IwKuqZn8CAYaauoF4vGo8EJDK8= X-MS-TrafficTypeDiagnostic: BN3PR0301MB1186: X-Microsoft-Exchange-Diagnostics: 1; BN3PR0301MB1186; 31:3oUV1jTyZwhKhxjosvBaNDGbdprTiN4ZnouMMTCIRM/y2aJmfLeRpIc5OWwC/un4UD5WOOPaPtzdOIGKlmbgYsnqYQU+BeVi5d714mKn1De5dj4hRhGAkZ1avbNNBRlu4TpCfGwK0A+dF66xyvTcAyN+3ij0tR+Y8ZKPDpmJb4WkO+DkIGkeEHu+H8AbbU03HwNKQ003pZMMlwzfDW7rWc6t7WKuDMA2IMKoSTwy5GzgS8sFvfnYGuFtyjD7RaUf X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197)(275809806118684); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6095135)(601004)(2401047)(5005006)(13016025)(8121501046)(13018025)(3002001)(10201501046)(100000703101)(100105400095)(93006095)(93001095)(6055026)(6096035)(20161123565025)(20161123556025)(20161123559100)(20161123563025)(201703131430075)(201703131448075)(201703131433075)(201703161259150)(201703151042153)(20161123561025)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:BN3PR0301MB1186; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(400006)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:BN3PR0301MB1186; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BN3PR0301MB1186; 4:UkRAdACyk68odQghWnBesgWNaQwsBQpj1g3/sw+m?= =?us-ascii?Q?WJbYxmE4ConB02QIQpnqPe0IRnk7Q4b8tVBZ3mkExE/zeRQvrxMp2YKKVzuk?= =?us-ascii?Q?44uv+3AL9VeaNCTlF/3d2HgNM/+taef+DPnfnngkzC2VJE9h4pOjNVWvrXR9?= =?us-ascii?Q?8algv6lFbovd8COeod6nAMgXNRQ44WVqHQO4ZGJOGKRkndsP7rYmEbMPKwF1?= =?us-ascii?Q?+EPnW8l+Ykc6/f6KD9IjH4eU3IB8Pv/UjnieaQm3W2nJmq7+1+ViCqP8D8If?= =?us-ascii?Q?B9LvmzjshJTYePD1iGF2dvIrXbg56nBmiOLTW91+CNtgrSJG20gGPkHj+Q+6?= =?us-ascii?Q?CzR6Gg+0TYmkagICHjxs5kvL+znSK5RdlQDuRv7mHrmGah4ZzB6uXBY2Nuo3?= =?us-ascii?Q?juyx8360Sj0MzicjWFS8J+Meym5/lVh98weoSoCEk9Bl3w1C/bJhQCw3Egmp?= =?us-ascii?Q?j/bSYB2qQozJ+pJKJN3WbGDKln6PW1mEG6OkBgfIaNQgL78cK8Q91x+4zX5N?= =?us-ascii?Q?U3VwyYbRpi8nqBnTlbeHj6j/MbSNoQaLVKgoqHd+VsZ1W/fl3XnSsjNrkkHN?= =?us-ascii?Q?mS6GzBpJoR8vsYfnBbg3KaIkIOMc3SMZ4KjOE1A0M354kL3f+h6myEyxawE3?= =?us-ascii?Q?Ib7IEDYZVqeqoKlblCsyPLdfTYyMqeqkKBVynf/15rMWCEU04SKdF8wzR717?= =?us-ascii?Q?95QXWB27fZghGytx26A1MJo0Wk7Y/o2wKH99473AdTehqMgk2wd9FXZ6fk1E?= =?us-ascii?Q?1kwFN8fkjOHCSgMBrCWBW9O8DmLWR7MFliDxMccr6lFGpJiAZgSHZUkpS3xr?= =?us-ascii?Q?mobgFYgO4SqaLSDGS9b3YnC6ez9GxXGsxWO6O/Eh9zwLWaxIN7C/k8RexMD1?= =?us-ascii?Q?/syLb8qt7wyoHbMdhIH+HrZZChVUwOQcSGF2K8XMyml54LNELLSIrzkgeX8p?= =?us-ascii?Q?zoaIVDv7DAsAWy1OudRzZanGb5wl65Ws6V6wmHC/8ZppMBwY9Ux+xHb0TDWm?= =?us-ascii?Q?d6KkcTxg7fTlzzjWfOiZ4cnu+KvfVGlQ5g2oQ9EUEITY7ZsEoUBXnfLUnXQq?= =?us-ascii?Q?haOrA9Nzz4+wnATu1DEpmzb5e8VUBAPtfhy8t1cK7DuOEViD8JrcCLT1YUD7?= =?us-ascii?Q?xdkOblDEaYxj1Elg+IpJvHjvjudRr9qzSSAos9rjyDWjglfr8jrNG29Thn30?= =?us-ascii?Q?9b22lrI6Hd52/tT28Uy5SlPv39A2HOmTVnfAZP1l5ua9Wb9ymAxZrqGTsRdK?= =?us-ascii?Q?lvbCB3bymiKhHaxpzmH3/QMY7TJOHJ6QOCz3c5JZNovLo4ek8utYL0R9Xa2L?= =?us-ascii?Q?Ow=3D=3D?= X-Forefront-PRVS: 0340850FCD X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BN3PR0301MB1186; 23:hOgKrt6XbXdvVQIF/fb2HVjNCSnEk3p/k3wrV3k?= =?us-ascii?Q?G9zkwA3pJIGllqP0XMK+O//18YwH6Y1aNITDP9vOT3tiQRo34xYEbSq37S8r?= =?us-ascii?Q?6TRara5gYO3MoCU/FisRB4npZeW7DZKkBrfCfgT0mzN97s6hVfm8ykrHA4XO?= =?us-ascii?Q?TIiMlEbjCaQSP70MeQdVP3XqcXSN3ddi6SZDLxCl9Zx+xrLXjexbnGA0WzAq?= =?us-ascii?Q?ejDHqnFGWGB7qsR6xuEwN7xJDqnbGOzZLJc1+rWUSQki7tj1J+QaMfuk9PzM?= =?us-ascii?Q?37s6FK3k3NNn41yI58wWmUhGpDFtIDUhyt6YgBVhz42WthhD4+vqTocIq4ND?= =?us-ascii?Q?FRJxWG2sV8wpW+w8O4oXMgZvgnZIjm2FAssPnjmS2PYOCbIZxFwm47UxbE6L?= =?us-ascii?Q?pH6Rt4l74dT5hgvzPsTzse0FvYv8m1AflNVKg9I99A3tt1hqlSNfUZVZ5OpG?= =?us-ascii?Q?t8d/gdyLuy529qsxL89nm120rZDyFxoSiKhOMH+qMlJ2EIiUkldAFWC8WeTW?= =?us-ascii?Q?A011oZsjq0AWHpJzVpQfb5wdn/4CLrAWdKZdynTUODtUDONueDHTbsHf1gh6?= =?us-ascii?Q?qQmn+tTopK7XdFGF1Vfvk8PyXWZsvKnTfP+DdBWWpOUoTLP9L0hhfgvffHVn?= =?us-ascii?Q?bvgqvuN46HwjeU8hdzno6+GEY3eDZPxyHMOlJfV1Gv8Pq3KLTS317eG1LNf8?= =?us-ascii?Q?hHDRhOu29T0ZjKsZjvJJSZS28anWHB7gFIG/XhDTEEIhznt4WgVJpVy0EPIs?= =?us-ascii?Q?v8NJ5rhhEoUd9sXDotf38hPKkWlpgzVvyLS844aW+jMhvcXOKBuKPSwCrEjq?= =?us-ascii?Q?oOmDfex7h/uwvhKti4+Gsd4CttiDJ1GUK/9sb4kHE41+KNhHZ/IlwijQ2b2P?= =?us-ascii?Q?x4iIrEfE+Zgiaz1j4C9TGpSxX3sf/pcsjrxl8mSIiCkZCeIwQ4yMXyZ8tCGE?= =?us-ascii?Q?zyFTft6jLo+VG1eeLEkIIAnKHS0mjBEOJNb6AI8b4HT2sPtcAYE4c2yl1NvO?= =?us-ascii?Q?bVeYNt0aYIEmLDnzjC9iN9sJ5CgIhXMzK9lf3H/55Pr+pObI2LykNUWwH0aA?= =?us-ascii?Q?Na0GbXWvJTj9JpAJRT+4wEvFtb1DQ7YvWFwh3NLLjpNF1AA2PBfNgjYyndOB?= =?us-ascii?Q?3ExHhEz/8kr4/jI5QwP/7tgvFqRZT3buP5YzAAGkgtB5a1qNhl/P+LsDsxK2?= =?us-ascii?Q?qvZWbCf+zdD0jH0iEzOzOhA51X/KevioqIGXsWRFJllKHYeUoKOVaRwkkaFI?= =?us-ascii?Q?34yP/Nw7ug73pRpyUBou0yxW3ZiIY+QNZqc+kC720?= X-Microsoft-Exchange-Diagnostics: 1; BN3PR0301MB1186; 6:Il1rl5zEcziudCLVlcRi8BZ/fik4QdY6gkgUvxKfTFeEF98PY6VwIwN9on1DgO3Pje60yNa1S9p2j3Y1F0fUrx16SqtpiiZ64CeLRHMGhpnxKLw3wqE8sXpSnGJIVi2cZFt/IktSDmvNrglmVE4lsjMlE73x9amBy+lo9ETW6EyyJSYFbsgmo6B/e5ODn8FUaerlTLJS+TxZryFRzwfEmTXzl/Eja03YVfZZDpLlQXWR0C3Yw5nyuTaSXtZiBvmC+llDANgkUqdeE4DuIZlmMeSpTidLk1gKWSA+aq2vdSy4zs7roUo6/5DOtJy/oM3sAV3Az5aywHQyf+DyecFwnD0XSwk/Ah9ghsqzRwSWhOLniECIGSxI+hw0u6AO2WkOhcOmXOu0nN14rwOUVs9cVFRJqZcOBg8axPIBPmjpmL/4WvUU5rhpZQyTYWOqD/H30NVq74EvLFXFJfpciG9F2ZTjECfqN1l0atug65bANQB/XkCFoPuJhSKzhoqFGepU1x08SzG/Kv7VWaqHyngesQ== X-Microsoft-Exchange-Diagnostics: 1; BN3PR0301MB1186; 5:ecbqRNEM20+3gu3ZFZCffGQeX5DHmMa0b4/LRQ0MF+lfKh3CPvgPAZvPuT07EhuPMnvWm2cT9DctVMiOUc/XxAdXo8pZbnj8wQwXN+5gSfsni/smA/34ss4/9lPyag42Kpda6Ab5c8VNqyE0jyFPI0pR1qsU6HnuNZeyE09EH1/FpxGyf99+/Ik/jn6RkY9iwejUj7gOdCll/wRSRP1BxZxlSOqCQXZyfmg34iGuU3DwXOz3UIBDerN2S6yHuon8xpk66Ddz/BG+bgCoRG/D8UpjRKzgpOuIiXDUwKWTrDrXcAJXAP/8jPsWwQUrNqynLZF4Xge22KOpoNO5LEEdcxnJfiHYJuZh43JCNhmMqdtHpEV3ZWj9yLna+22O8jcrcR8DMAtoFuNH6BTiXz7eNfv4ytS7DbrGgtn1dQi7fawAwnJ5eCRuJ7DO9yutbJfNJZSez5MR0P49iXL0vSCGzPq+EoX7QmSxnJMrwJZkgwFU46PAZlnay9eympirH1okU3VGd84aCt8sbSmAM+p1Nw==; 24:PEOtiqwTYoRY97xGBHaw1zCi498l9986tjkFU5uK1qJUBo7YmD/fGTzrBqSLaK7+ZrUWDTL1fcBCmwlEnQlDlxO/0K8EtAC7hAAHt7cvaes= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BN3PR0301MB1186; 7:0uaJfbdHSYnUs5liHPiBYxuii938u4xvmbMXkgaH0VkuNs7MWYywKo/P/0su4p1NhGhQHQdUr1k+3wgsDMaKHJIY+s86ABgNu7ECqKDjmZTD9kaLPY4KpHQkP3i2Lc9IoKWiMYpbB2y1pVBUWpETjbDfNKYb1cuO+Umyq6J5K/dBOZkyK7kVUXL1rfA8M4DtT47USzc51KjOG0+yIAnMrkS62e8+TY/CtzXLZsse+t9OrLCXCP9ZYDcTT0Nf32feXyuLXfIFS2HSKaWRTxK7B9jhSwqb+UP2Vg26HWhdl7YNKAwv3v7qe3yURrVNOwG+zVsDpc2/NIZ/J/wHqsdBKQ== X-MS-Exchange-CrossTenant-OriginalArrivalTime: 16 Jun 2017 05:33:10.8584 (UTC) X-MS-Exchange-CrossTenant-Id: 5afe0b00-7697-4969-b663-5eab37d5f47e X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=5afe0b00-7697-4969-b663-5eab37d5f47e; Ip=[192.88.168.50]; Helo=[tx30smr01.am.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BN3PR0301MB1186 Subject: [dpdk-dev] [PATCH 24/38] net/dpaa: add support for Tx and Rx queue setup 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, 16 Jun 2017 05:33:14 -0000 Signed-off-by: Hemant Agrawal Signed-off-by: Shreyansh Jain --- doc/guides/nics/features/dpaa.ini | 1 + drivers/net/dpaa/Makefile | 4 + drivers/net/dpaa/dpaa_ethdev.c | 279 ++++++++++++++++++++++++++++++++- drivers/net/dpaa/dpaa_ethdev.h | 6 + drivers/net/dpaa/dpaa_rxtx.c | 313 ++++++++++++++++++++++++++++++++++++++ drivers/net/dpaa/dpaa_rxtx.h | 61 ++++++++ mk/rte.app.mk | 1 + 7 files changed, 660 insertions(+), 5 deletions(-) create mode 100644 drivers/net/dpaa/dpaa_rxtx.c create mode 100644 drivers/net/dpaa/dpaa_rxtx.h diff --git a/doc/guides/nics/features/dpaa.ini b/doc/guides/nics/features/dpaa.ini index 9e8befc..29ba47e 100644 --- a/doc/guides/nics/features/dpaa.ini +++ b/doc/guides/nics/features/dpaa.ini @@ -4,5 +4,6 @@ ; Refer to default.ini for the full list of available PMD features. ; [Features] +Queue start/stop = Y ARMv8 = Y Usage doc = Y diff --git a/drivers/net/dpaa/Makefile b/drivers/net/dpaa/Makefile index 8fcde26..06b63fc 100644 --- a/drivers/net/dpaa/Makefile +++ b/drivers/net/dpaa/Makefile @@ -44,11 +44,13 @@ else CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) endif +CFLAGS +=-Wno-pointer-arith CFLAGS += -I$(RTE_SDK_DPAA)/ CFLAGS += -I$(RTE_SDK_DPAA)/include CFLAGS += -I$(RTE_SDK)/drivers/bus/dpaa CFLAGS += -I$(RTE_SDK)/drivers/bus/dpaa/include/ +CFLAGS += -I$(RTE_SDK)/drivers/mempool/dpaa CFLAGS += -I$(RTE_SDK)/lib/librte_eal/common/include CFLAGS += -I$(RTE_SDK)/lib/librte_eal/linuxapp/eal/include @@ -58,7 +60,9 @@ LIBABIVER := 1 # Interfaces with DPDK SRCS-$(CONFIG_RTE_LIBRTE_DPAA_PMD) += dpaa_ethdev.c +SRCS-$(CONFIG_RTE_LIBRTE_DPAA_PMD) += dpaa_rxtx.c LDLIBS += -lrte_bus_dpaa +LDLIBS += -lrte_mempool_dpaa include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/net/dpaa/dpaa_ethdev.c b/drivers/net/dpaa/dpaa_ethdev.c index 2401058..5a8d8af 100644 --- a/drivers/net/dpaa/dpaa_ethdev.c +++ b/drivers/net/dpaa/dpaa_ethdev.c @@ -62,8 +62,15 @@ #include #include +#include #include +#include + +#include +#include +#include +#include /* Keep track of whether QMAN and BMAN have been globally initialized */ static int is_global_init; @@ -79,20 +86,104 @@ dpaa_eth_dev_configure(struct rte_eth_dev *dev __rte_unused) static int dpaa_eth_dev_start(struct rte_eth_dev *dev) { + struct dpaa_if *dpaa_intf = dev->data->dev_private; + PMD_INIT_FUNC_TRACE(); /* Change tx callback to the real one */ - dev->tx_pkt_burst = NULL; + dev->tx_pkt_burst = dpaa_eth_queue_tx; + fman_if_enable_rx(dpaa_intf->fif); return 0; } static void dpaa_eth_dev_stop(struct rte_eth_dev *dev) { - dev->tx_pkt_burst = NULL; + struct dpaa_if *dpaa_intf = dev->data->dev_private; + + PMD_INIT_FUNC_TRACE(); + + fman_if_disable_rx(dpaa_intf->fif); + dev->tx_pkt_burst = dpaa_eth_tx_drop_all; +} + +static void dpaa_eth_dev_close(struct rte_eth_dev *dev) +{ + PMD_INIT_FUNC_TRACE(); + + dpaa_eth_dev_stop(dev); +} + +static +int dpaa_eth_rx_queue_setup(struct rte_eth_dev *dev, uint16_t queue_idx, + uint16_t nb_desc __rte_unused, + unsigned int socket_id __rte_unused, + const struct rte_eth_rxconf *rx_conf __rte_unused, + struct rte_mempool *mp) +{ + struct dpaa_if *dpaa_intf = dev->data->dev_private; + + PMD_INIT_FUNC_TRACE(); + + PMD_DRV_LOG(INFO, "Rx queue setup for queue index: %d", queue_idx); + + if (!dpaa_intf->bp_info || dpaa_intf->bp_info->mp != mp) { + struct fman_if_ic_params icp; + uint32_t fd_offset; + uint32_t bp_size; + + if (!mp->pool_data) { + PMD_DRV_LOG(ERR, "not an offloaded buffer pool"); + return -1; + } + dpaa_intf->bp_info = DPAA_MEMPOOL_TO_POOL_INFO(mp); + + memset(&icp, 0, sizeof(icp)); + /* set ICEOF for to the default value , which is 0*/ + icp.iciof = DEFAULT_ICIOF; + icp.iceof = DEFAULT_RX_ICEOF; + icp.icsz = DEFAULT_ICSZ; + fman_if_set_ic_params(dpaa_intf->fif, &icp); + + fd_offset = RTE_PKTMBUF_HEADROOM + DPAA_HW_BUF_RESERVE; + fman_if_set_fdoff(dpaa_intf->fif, fd_offset); + + /* Buffer pool size should be equal to Dataroom Size*/ + bp_size = rte_pktmbuf_data_room_size(mp); + fman_if_set_bp(dpaa_intf->fif, mp->size, + dpaa_intf->bp_info->bpid, bp_size); + dpaa_intf->valid = 1; + PMD_DRV_LOG(INFO, "if =%s - fd_offset = %d offset = %d", + dpaa_intf->name, fd_offset, + fman_if_get_fdoff(dpaa_intf->fif)); + } + dev->data->rx_queues[queue_idx] = &dpaa_intf->rx_queues[queue_idx]; + + return 0; +} + +static +void dpaa_eth_rx_queue_release(void *rxq __rte_unused) +{ + PMD_INIT_FUNC_TRACE(); } -static void dpaa_eth_dev_close(struct rte_eth_dev *dev __rte_unused) +static +int dpaa_eth_tx_queue_setup(struct rte_eth_dev *dev, uint16_t queue_idx, + uint16_t nb_desc __rte_unused, + unsigned int socket_id __rte_unused, + const struct rte_eth_txconf *tx_conf __rte_unused) +{ + struct dpaa_if *dpaa_intf = dev->data->dev_private; + + PMD_INIT_FUNC_TRACE(); + + PMD_DRV_LOG(INFO, "Tx queue setup for queue index: %d", queue_idx); + dev->data->tx_queues[queue_idx] = &dpaa_intf->tx_queues[queue_idx]; + return 0; +} + +static void dpaa_eth_tx_queue_release(void *txq __rte_unused) { PMD_INIT_FUNC_TRACE(); } @@ -102,28 +193,206 @@ static struct eth_dev_ops dpaa_devops = { .dev_start = dpaa_eth_dev_start, .dev_stop = dpaa_eth_dev_stop, .dev_close = dpaa_eth_dev_close, + + .rx_queue_setup = dpaa_eth_rx_queue_setup, + .tx_queue_setup = dpaa_eth_tx_queue_setup, + .rx_queue_release = dpaa_eth_rx_queue_release, + .tx_queue_release = dpaa_eth_tx_queue_release, }; +/* Initialise an Rx FQ */ +static int dpaa_rx_queue_init(struct qman_fq *fq, + uint32_t fqid) +{ + struct qm_mcc_initfq opts; + int ret; + + PMD_INIT_FUNC_TRACE(); + + ret = qman_reserve_fqid(fqid); + if (ret) { + PMD_DRV_LOG(ERR, "reserve rx fqid %d failed with ret: %d", + fqid, ret); + return -EINVAL; + } + PMD_DRV_LOG(DEBUG, "creating rx fq %p, fqid %d", fq, fqid); + ret = qman_create_fq(fqid, QMAN_FQ_FLAG_NO_ENQUEUE, fq); + if (ret) { + PMD_DRV_LOG(ERR, "create rx fqid %d failed with ret: %d", + fqid, ret); + return ret; + } + + opts.we_mask = QM_INITFQ_WE_DESTWQ | QM_INITFQ_WE_FQCTRL | + QM_INITFQ_WE_CONTEXTA; + + opts.fqd.dest.wq = DPAA_IF_RX_PRIORITY; + opts.fqd.fq_ctrl = QM_FQCTRL_AVOIDBLOCK | QM_FQCTRL_CTXASTASHING | + QM_FQCTRL_PREFERINCACHE; + opts.fqd.context_a.stashing.exclusive = 0; + opts.fqd.context_a.stashing.annotation_cl = DPAA_IF_RX_ANNOTATION_STASH; + opts.fqd.context_a.stashing.data_cl = DPAA_IF_RX_DATA_STASH; + opts.fqd.context_a.stashing.context_cl = DPAA_IF_RX_CONTEXT_STASH; + + /*Enable tail drop */ + opts.we_mask = opts.we_mask | QM_INITFQ_WE_TDTHRESH; + opts.fqd.fq_ctrl = opts.fqd.fq_ctrl | QM_FQCTRL_TDE; + qm_fqd_taildrop_set(&opts.fqd.td, CONG_THRESHOLD_RX_Q, 1); + + ret = qman_init_fq(fq, 0, &opts); + if (ret) + PMD_DRV_LOG(ERR, "init rx fqid %d failed with ret: %d", + fqid, ret); + return ret; +} + +/* Initialise a Tx FQ */ +static int dpaa_tx_queue_init(struct qman_fq *fq, + struct fman_if *fman_intf) +{ + struct qm_mcc_initfq opts; + int ret; + + PMD_INIT_FUNC_TRACE(); + + ret = qman_create_fq(0, QMAN_FQ_FLAG_DYNAMIC_FQID | + QMAN_FQ_FLAG_TO_DCPORTAL, fq); + if (ret) { + PMD_DRV_LOG(ERR, "create tx fq failed with ret: %d", ret); + return ret; + } + opts.we_mask = QM_INITFQ_WE_DESTWQ | QM_INITFQ_WE_FQCTRL | + QM_INITFQ_WE_CONTEXTB | QM_INITFQ_WE_CONTEXTA; + opts.fqd.dest.channel = fman_intf->tx_channel_id; + opts.fqd.dest.wq = DPAA_IF_TX_PRIORITY; + opts.fqd.fq_ctrl = QM_FQCTRL_PREFERINCACHE; + opts.fqd.context_b = 0; + /* no tx-confirmation */ + opts.fqd.context_a.hi = 0x80000000 | fman_dealloc_bufs_mask_hi; + opts.fqd.context_a.lo = 0 | fman_dealloc_bufs_mask_lo; + PMD_DRV_LOG(DEBUG, "init tx fq %p, fqid %d", fq, fq->fqid); + ret = qman_init_fq(fq, QMAN_INITFQ_FLAG_SCHED, &opts); + if (ret) + PMD_DRV_LOG(ERR, "init tx fqid %d failed %d", fq->fqid, ret); + return ret; +} + /* Initialise a network interface */ -static int dpaa_eth_dev_init(struct rte_eth_dev *eth_dev __rte_unused) +static int dpaa_eth_dev_init(struct rte_eth_dev *eth_dev) { + int num_cores, num_rx_fqs, fqid; + int loop, ret = 0; int dev_id; struct rte_dpaa_device *dpaa_device; struct dpaa_if *dpaa_intf; + struct fm_eth_port_cfg *cfg; + struct fman_if *fman_intf; + struct fman_if_bpool *bp, *tmp_bp; PMD_INIT_FUNC_TRACE(); dpaa_device = DEV_TO_DPAA_DEVICE(eth_dev->device); dev_id = dpaa_device->id.dev_id; dpaa_intf = eth_dev->data->dev_private; + cfg = &dpaa_netcfg->port_cfg[dev_id]; + fman_intf = cfg->fman_if; dpaa_intf->name = dpaa_device->name; + /* save fman_if & cfg in the interface struture */ + dpaa_intf->fif = fman_intf; dpaa_intf->ifid = dev_id; + dpaa_intf->cfg = cfg; + + /* Initialize Rx FQ's */ + if (getenv("DPAA_NUM_RX_QUEUES")) + num_rx_fqs = atoi(getenv("DPAA_NUM_RX_QUEUES")); + else + num_rx_fqs = DPAA_DEFAULT_NUM_PCD_QUEUES; + + /* Each device can not have more than DPAA_PCD_FQID_MULTIPLIER RX queues */ + if (num_rx_fqs <= 0 || num_rx_fqs > DPAA_PCD_FQID_MULTIPLIER) { + PMD_INIT_LOG(ERR, "Invalid number of RX queues\n"); + return -EINVAL; + } + + dpaa_intf->rx_queues = rte_zmalloc(NULL, + sizeof(struct qman_fq) * num_rx_fqs, MAX_CACHELINE); + for (loop = 0; loop < num_rx_fqs; loop++) { + fqid = DPAA_PCD_FQID_START + dpaa_intf->ifid * + DPAA_PCD_FQID_MULTIPLIER + loop; + ret = dpaa_rx_queue_init(&dpaa_intf->rx_queues[loop], fqid); + if (ret) + return ret; + dpaa_intf->rx_queues[loop].dpaa_intf = dpaa_intf; + } + dpaa_intf->nb_rx_queues = num_rx_fqs; + + /* Initialise Tx FQs. Have as many Tx FQ's as number of cores */ + num_cores = rte_lcore_count(); + dpaa_intf->tx_queues = rte_zmalloc(NULL, sizeof(struct qman_fq) * + num_cores, MAX_CACHELINE); + if (!dpaa_intf->tx_queues) + return -ENOMEM; + + for (loop = 0; loop < num_cores; loop++) { + ret = dpaa_tx_queue_init(&dpaa_intf->tx_queues[loop], + fman_intf); + if (ret) + return ret; + dpaa_intf->tx_queues[loop].dpaa_intf = dpaa_intf; + } + dpaa_intf->nb_tx_queues = num_cores; + PMD_DRV_LOG(DEBUG, "all fqs created"); + + /* reset bpool list, initialize bpool dynamically */ + list_for_each_entry_safe(bp, tmp_bp, &cfg->fman_if->bpool_list, node) { + list_del(&bp->node); + rte_free(bp); + } + + /* Populate ethdev structure */ eth_dev->dev_ops = &dpaa_devops; + eth_dev->data->nb_rx_queues = dpaa_intf->nb_rx_queues; + eth_dev->data->nb_tx_queues = dpaa_intf->nb_tx_queues; + eth_dev->rx_pkt_burst = dpaa_eth_queue_rx; + eth_dev->tx_pkt_burst = dpaa_eth_tx_drop_all; + + /* Allocate memory for storing MAC addresses */ + eth_dev->data->mac_addrs = rte_zmalloc("mac_addr", + ETHER_ADDR_LEN * DPAA_MAX_MAC_FILTER, 0); + if (eth_dev->data->mac_addrs == NULL) { + PMD_INIT_LOG(ERR, "Failed to allocate %d bytes needed to " + "store MAC addresses", + ETHER_ADDR_LEN * DPAA_MAX_MAC_FILTER); + return -ENOMEM; + } - return -1; + /* copy the primary mac address */ + memcpy(eth_dev->data->mac_addrs[0].addr_bytes, + fman_intf->mac_addr.addr_bytes, + ETHER_ADDR_LEN); + + PMD_DRV_LOG(DEBUG, "interface %s macaddr:", dpaa_device->name); + for (loop = 0; loop < ETHER_ADDR_LEN; loop++) { + if (loop != (ETHER_ADDR_LEN - 1)) + printf("%02x:", fman_intf->mac_addr.addr_bytes[loop]); + else + printf("%02x\n", fman_intf->mac_addr.addr_bytes[loop]); + } + + /* Disable RX mode */ + fman_if_discard_rx_errors(fman_intf); + fman_if_disable_rx(fman_intf); + /* Disable promiscuous mode */ + fman_if_promiscuous_disable(fman_intf); + /* Disable multicast */ + fman_if_reset_mcast_filter_table(fman_intf); + /* Reset interface statistics */ + fman_if_stats_reset(fman_intf); + + return 0; } static int diff --git a/drivers/net/dpaa/dpaa_ethdev.h b/drivers/net/dpaa/dpaa_ethdev.h index 8aeaebf..da7f3be 100644 --- a/drivers/net/dpaa/dpaa_ethdev.h +++ b/drivers/net/dpaa/dpaa_ethdev.h @@ -38,7 +38,13 @@ #include #include +#include +#include +#include +#include +#include +#include #define DPAA_MBUF_HW_ANNOTATION 64 #define DPAA_FD_PTA_SIZE 64 diff --git a/drivers/net/dpaa/dpaa_rxtx.c b/drivers/net/dpaa/dpaa_rxtx.c new file mode 100644 index 0000000..d2ef513 --- /dev/null +++ b/drivers/net/dpaa/dpaa_rxtx.c @@ -0,0 +1,313 @@ +/*- + * BSD LICENSE + * + * Copyright 2016 Freescale Semiconductor, Inc. All rights reserved. + * Copyright 2017 NXP. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Freescale Semiconductor, Inc nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* System headers */ +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "dpaa_ethdev.h" +#include "dpaa_rxtx.h" +#include +#include + +#include +#include +#include +#include +#include + +#define DPAA_MBUF_TO_CONTIG_FD(_mbuf, _fd, _bpid) \ + do { \ + (_fd)->cmd = 0; \ + (_fd)->opaque_addr = 0; \ + (_fd)->opaque = QM_FD_CONTIG << DPAA_FD_FORMAT_SHIFT; \ + (_fd)->opaque |= ((_mbuf)->data_off) << DPAA_FD_OFFSET_SHIFT; \ + (_fd)->opaque |= (_mbuf)->pkt_len; \ + (_fd)->addr = (_mbuf)->buf_physaddr; \ + (_fd)->bpid = _bpid; \ + } while (0) + +static inline struct rte_mbuf *dpaa_eth_fd_to_mbuf(struct qm_fd *fd, + uint32_t ifid) +{ + struct pool_info_entry *bp_info = DPAA_BPID_TO_POOL_INFO(fd->bpid); + struct rte_mbuf *mbuf; + void *ptr; + uint16_t offset = + (fd->opaque & DPAA_FD_OFFSET_MASK) >> DPAA_FD_OFFSET_SHIFT; + uint32_t length = fd->opaque & DPAA_FD_LENGTH_MASK; + + PMD_RX_LOG(DEBUG, " FD--->MBUF"); + + /* Ignoring case when format != qm_fd_contig */ + ptr = rte_dpaa_mem_ptov(fd->addr); + /* Ignoring case when ptr would be NULL. That is only possible incase + * of a corrupted packet + */ + + mbuf = (struct rte_mbuf *)((char *)ptr - bp_info->meta_data_size); + /* Prefetch the Parse results and packet data to L1 */ + rte_prefetch0((void *)((uint8_t *)ptr + DEFAULT_RX_ICEOF)); + rte_prefetch0((void *)((uint8_t *)ptr + offset)); + + mbuf->data_off = offset; + mbuf->data_len = length; + mbuf->pkt_len = length; + + mbuf->port = ifid; + mbuf->nb_segs = 1; + mbuf->ol_flags = 0; + mbuf->next = NULL; + rte_mbuf_refcnt_set(mbuf, 1); + + return mbuf; +} + +uint16_t dpaa_eth_queue_rx(void *q, + struct rte_mbuf **bufs, + uint16_t nb_bufs) +{ + struct qman_fq *fq = q; + struct qm_dqrr_entry *dq; + uint32_t num_rx = 0, ifid = ((struct dpaa_if *)fq->dpaa_intf)->ifid; + int ret; + + ret = rte_dpaa_portal_init((void *)0); + if (ret) { + PMD_DRV_LOG(ERR, "Failure in affining portal"); + return 0; + } + + ret = qman_set_vdq(fq, (nb_bufs > DPAA_MAX_DEQUEUE_NUM_FRAMES) ? + DPAA_MAX_DEQUEUE_NUM_FRAMES : nb_bufs); + if (ret) + return 0; + + do { + dq = qman_dequeue(fq); + if (!dq) + continue; + bufs[num_rx++] = dpaa_eth_fd_to_mbuf(&dq->fd, ifid); + qman_dqrr_consume(fq, dq); + } while (fq->flags & QMAN_FQ_STATE_VDQCR); + + return num_rx; +} + +static void *dpaa_get_pktbuf(struct pool_info_entry *bp_info) +{ + int ret; + uint64_t buf = 0; + struct bm_buffer bufs; + + ret = bman_acquire(bp_info->bp, &bufs, 1, 0); + if (ret <= 0) { + PMD_DRV_LOG(WARNING, "Failed to allocate buffers %d", ret); + return (void *)buf; + } + + PMD_RX_LOG(DEBUG, "got buffer 0x%llx from pool %d", + bufs.addr, bufs.bpid); + + buf = (uint64_t)rte_dpaa_mem_ptov(bufs.addr) - bp_info->meta_data_size; + if (!buf) + goto out; + +out: + return (void *)buf; +} + +static struct rte_mbuf *dpaa_get_dmable_mbuf(struct rte_mbuf *mbuf, + struct dpaa_if *dpaa_intf) +{ + struct rte_mbuf *dpaa_mbuf; + + /* allocate pktbuffer on bpid for dpaa port */ + dpaa_mbuf = dpaa_get_pktbuf(dpaa_intf->bp_info); + if (!dpaa_mbuf) + return NULL; + + memcpy((uint8_t *)(dpaa_mbuf->buf_addr) + mbuf->data_off, (void *) + ((uint8_t *)(mbuf->buf_addr) + mbuf->data_off), mbuf->pkt_len); + + /* Copy only the required fields */ + dpaa_mbuf->data_off = mbuf->data_off; + dpaa_mbuf->pkt_len = mbuf->pkt_len; + dpaa_mbuf->ol_flags = mbuf->ol_flags; + dpaa_mbuf->packet_type = mbuf->packet_type; + dpaa_mbuf->tx_offload = mbuf->tx_offload; + rte_pktmbuf_free(mbuf); + return dpaa_mbuf; +} + +uint16_t +dpaa_eth_queue_tx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs) +{ + struct rte_mbuf *mbuf, *mi = NULL; + struct rte_mempool *mp; + struct pool_info_entry *bp_info; + struct qm_fd fd_arr[MAX_TX_RING_SLOTS]; + uint32_t frames_to_send, loop, i = 0; + int ret; + + ret = rte_dpaa_portal_init((void *)0); + if (ret) { + PMD_DRV_LOG(ERR, "Failure in affining portal"); + return 0; + } + + PMD_TX_LOG(DEBUG, "Transmitting %d buffers on queue: %p", nb_bufs, q); + + while (nb_bufs) { + frames_to_send = (nb_bufs >> 3) ? MAX_TX_RING_SLOTS : nb_bufs; + for (loop = 0; loop < frames_to_send; loop++, i++) { + mbuf = bufs[i]; + if (RTE_MBUF_DIRECT(mbuf)) { + mp = mbuf->pool; + } else { + mi = rte_mbuf_from_indirect(mbuf); + mp = mi->pool; + } + + bp_info = DPAA_MEMPOOL_TO_POOL_INFO(mp); + if (mp->ops_index == bp_info->dpaa_ops_index) { + PMD_TX_LOG(DEBUG, "BMAN offloaded buffer, " + "mbuf: %p", mbuf); + if (mbuf->nb_segs == 1) { + if (RTE_MBUF_DIRECT(mbuf)) { + if (rte_mbuf_refcnt_read(mbuf) > 1) { + DPAA_MBUF_TO_CONTIG_FD(mbuf, + &fd_arr[loop], 0xff); + rte_mbuf_refcnt_update(mbuf, -1); + } else { + DPAA_MBUF_TO_CONTIG_FD(mbuf, + &fd_arr[loop], bp_info->bpid); + } + } else { + if (rte_mbuf_refcnt_read(mi) > 1) { + DPAA_MBUF_TO_CONTIG_FD(mbuf, + &fd_arr[loop], 0xff); + } else { + rte_mbuf_refcnt_update(mi, 1); + DPAA_MBUF_TO_CONTIG_FD(mbuf, + &fd_arr[loop], bp_info->bpid); + } + rte_pktmbuf_free(mbuf); + } + } else { + PMD_DRV_LOG(DEBUG, "Number of Segments not supported"); + /* Set frames_to_send & nb_bufs so that + * packets are transmitted till + * previous frame. + */ + frames_to_send = loop; + nb_bufs = loop; + goto send_pkts; + } + } else { + struct qman_fq *txq = q; + struct dpaa_if *dpaa_intf = txq->dpaa_intf; + + PMD_TX_LOG(DEBUG, "Non-BMAN offloaded buffer." + "Allocating an offloaded buffer"); + mbuf = dpaa_get_dmable_mbuf(mbuf, dpaa_intf); + if (!mbuf) { + PMD_DRV_LOG(DEBUG, "no dpaa buffers."); + /* Set frames_to_send & nb_bufs so that + * packets are transmitted till + * previous frame. + */ + frames_to_send = loop; + nb_bufs = loop; + goto send_pkts; + } + + DPAA_MBUF_TO_CONTIG_FD(mbuf, &fd_arr[loop], + dpaa_intf->bp_info->bpid); + } + } + +send_pkts: + loop = 0; + while (loop < frames_to_send) { + loop += qman_enqueue_multi(q, &fd_arr[loop], + frames_to_send - loop); + } + nb_bufs -= frames_to_send; + } + + PMD_TX_LOG(DEBUG, "Transmitted %d buffers on queue: %p", i, q); + + return i; +} + +uint16_t dpaa_eth_tx_drop_all(void *q __rte_unused, + struct rte_mbuf **bufs __rte_unused, + uint16_t nb_bufs __rte_unused) +{ + PMD_TX_LOG(DEBUG, "Drop all packets"); + + /* Drop all incoming packets. No need to free packets here + * because the rte_eth f/w frees up the packets through tx_buffer + * callback in case this functions returns count less than nb_bufs + */ + return 0; +} diff --git a/drivers/net/dpaa/dpaa_rxtx.h b/drivers/net/dpaa/dpaa_rxtx.h new file mode 100644 index 0000000..09f1aa4 --- /dev/null +++ b/drivers/net/dpaa/dpaa_rxtx.h @@ -0,0 +1,61 @@ +/*- + * BSD LICENSE + * + * Copyright 2016 Freescale Semiconductor, Inc. All rights reserved. + * Copyright 2017 NXP. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Freescale Semiconductor, Inc nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DPDK_RXTX_H__ +#define __DPDK_RXTX_H__ + +/* internal offset from where IC is copied to packet buffer*/ +#define DEFAULT_ICIOF 32 +/* IC transfer size */ +#define DEFAULT_ICSZ 48 + +/* IC offsets from buffer header address */ +#define DEFAULT_RX_ICEOF 16 + +#define DPAA_MAX_DEQUEUE_NUM_FRAMES 63 + /**