From patchwork Thu Jun 29 20:49:02 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Akhil Goyal X-Patchwork-Id: 26044 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id 331F14C57; Thu, 29 Jun 2017 22:50:31 +0200 (CEST) Received: from NAM01-SN1-obe.outbound.protection.outlook.com (mail-sn1nam01on0042.outbound.protection.outlook.com [104.47.32.42]) by dpdk.org (Postfix) with ESMTP id 9F7DE532C for ; Thu, 29 Jun 2017 22:50:27 +0200 (CEST) Received: from DM5PR03CA0059.namprd03.prod.outlook.com (10.174.189.176) by DM5PR03MB3273.namprd03.prod.outlook.com (10.174.241.32) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1199.15; Thu, 29 Jun 2017 20:50:25 +0000 Received: from BN1AFFO11FD007.protection.gbl (2a01:111:f400:7c10::187) by DM5PR03CA0059.outlook.office365.com (2603:10b6:4:3b::48) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1178.14 via Frontend Transport; Thu, 29 Jun 2017 20:50:25 +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 BN1AFFO11FD007.mail.protection.outlook.com (10.58.52.67) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1199.9 via Frontend Transport; Thu, 29 Jun 2017 20:50:25 +0000 Received: from netperf2.ap.freescale.net ([10.232.133.164]) by tx30smr01.am.freescale.net (8.14.3/8.14.0) with ESMTP id v5TKoFPS005297; Thu, 29 Jun 2017 13:50:23 -0700 From: To: CC: , , , Akhil Goyal Date: Fri, 30 Jun 2017 02:19:02 +0530 Message-ID: <20170629204904.23684-4-akhil.goyal@nxp.com> X-Mailer: git-send-email 2.9.3 In-Reply-To: <20170629204904.23684-1-akhil.goyal@nxp.com> References: <20170629204904.23684-1-akhil.goyal@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131432430253196939; (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)(39860400002)(39400400002)(39450400003)(39840400002)(39380400002)(39850400002)(39410400002)(2980300002)(1109001)(1110001)(339900001)(199003)(189002)(9170700003)(48376002)(1076002)(76176999)(2876002)(53936002)(2906002)(50466002)(8676002)(50986999)(8936002)(356003)(106466001)(47776003)(86152003)(189998001)(81166006)(33646002)(38730400002)(8656002)(110136004)(2351001)(5003940100001)(50226002)(4326008)(105606002)(86362001)(54906002)(85426001)(6666003)(498600001)(5660300001)(36756003)(77096006)(104016004)(2950100002)(6916009)(305945005); DIR:OUT; SFP:1101; SCL:1; SRVR:DM5PR03MB3273; H:tx30smr01.am.freescale.net; FPR:; SPF:Fail; MLV:ovrnspm; A:1; MX:1; PTR:InfoDomainNonexistent; LANG:en; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BN1AFFO11FD007; 1:CNXe+A18WIjDjgHRTMWqBdVc6e4ZN7FCmTJJBWxZZ?= 4OaS7iywkvULI3coVM3fDaO/Ed5B03HzledeDFpnkEse/isZuoTMGOaNtmrR7VQn7lgBXZm9SqTAvV+4Ohhw5iQs8I18+QIYz2AdMv3H4T7CQ/3+q9vAlikuLBu6gtnupeumVDOrBd7sVxLU/m1gtrE2vsZil+5Cl5dKXC9Q2TMIEhThDLbVB+kc61dheGP8Adf4ciyu1ZjqVZclStZrPeotQliPd01KAWLYblPwAduJ3wMrkYrYdYPbBV6B/MNIbUecwDs22eQKBHrivfmZ5A8xkxnbnk+4veKJXB/otK2aNoGgs85bwDDWjYRNsmYWnwn7aftgBgioZQJ8BnamAty4l6cQBkCCtcwC8aU5zqVjAWJA3elBckVYHJfTJiwpqgE4KZxjmoz0e9vB4YlP/fU92i2mp68kAnMLU0IW4nSyOcchTEBHX6nrnZZozOWceMDGAQlCksQvXLKLT7LHyteRTNxKCAJBBuD5bndR8pUPOny0oG1+2itm8Ii+uMaEfa9/oS7mGPBK8kg9GyqVb58wQzvSb+A9tlNcpSezg77ox/cgF7BTLanxRBaHq0VKGS08LT3SczOPXdjfKtmGLI4yHKuD2cANEWIRawhIdgajRm0inM6zu/dJPs644G3fqABUOhGuDo968NnuC/WO9pYfFMiIOL3cYYwSPCLhsukvTn2cuva4dOZOlsxYkEsUj5s6US2HKm2QBFQXqH4cCFcVP2Sk8CsFmpaS39i+RaMiFOiS9TbSLwyqoJMhAaL8mkHKHoT5zPkH+Y1GHgGbjASUhmUHgjT6G95mb35bVKZ0z6SeHfO3MtORNPIj0DuVGRL75vUBXrcqJMAmyqkPksWlZ2mLzGd1XHqFrgepkJ0fSRs32jhEI4FqWvIrPg+YH1wYx//ByTS7udOMd66tlA2Z/mvpEFVM8RjISeMD2qNihdapM2QENBkzfXhJ5DoXGjxMR0XXSZzRLDKNttKdLtEw7L/WpcsumB6/5sUJuHY/vrlV/M1NXQi93LQL/gBEaBlO5O42XJyByFazALkqv0e20zE/1i7ZLlcdKTIpxSQiQ== MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 7f4166b9-8e79-48c6-468b-08d4bf3077ac X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(22001)(300000502095)(300135100095)(300000503095)(300135400095)(2017052603031)(201703131430075)(201703131517081)(300000504095)(300135200095)(300000505095)(300135600095)(300000506095)(300135500095); SRVR:DM5PR03MB3273; X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3273; 3:rBu5TlKUkP+gYHc1eTyqC53AhDLCCVQwi8vJe4qfFOtf6ZTM+CkVajlhLbq5hGsuc/f9KpGjcb+WsXdmyImvOWdAg1OtpNeUcsRjrCBhTLl+8jWw6TchfnJZ/0hOm023OBLEKLS0IWibxp9gPu98XGtOHDNBIVHP8v2kafjIRwDbo7V1/9fvyTLE9/D5uUkKaJWtqJJlu0aN6G/Vi8iwcEe8emF0E0WeYNxyKZE+WtJ6PH2jNxnUihhKxQquCbFo8lfNpa8H4eTF0MH6gARAYWGXvHdyH5iNcOT1byRPGCNI+rU5jaVPhcz0GgmMXwg1UDFNgZ5cQtb7bnRa8V3cbbQO+JQfowlpQisR/kdemAcajDaEBUM93dITQQjrzZ50T8U1sDgfTTarEDOE//cs6BTGgBz96GwY1YAJ/w/fbTHszut/XA0XX3L3c4ZMt9yZX4EihFzFNOYMlF2PutmNOAflOEYaHmYRIZOFA3jzGnzhy1tsUZlfCjw/P8OgHuJX3fEvDkSgz7zZRPIcEkI44V32HwJ++ufP/tUD8Izxatn67bRIwio0j9I7M1HJli/x0qHaStQBe+zrncaF6omhYh3+txelniMHJ5Q5OruzP0qujcHiEE2iWDXVI2DoK9wkTRDOql/+0EbXr8rCa8h3p2TBEUztzkqfJLhjZtT5e3DGItvuoTRudSZWlKlPYBfpOpol+EXH6zvBAZlMxYqfeNOrzjS3tFb4aL7kCoa2QqRZAbM+nfmgQyUId2byenP64JzM1UPc9+VPuMvrC+I+p/CF7yQIgyykpeBbExZ6l1BChspdiDLZnnXXN4c7k2nI4PHXSFu6OxSWDMe+L6ffi4bTeXtTO7kI8OggucOIY+RWrBmTIqPS0s0sWFq72Fqy X-MS-TrafficTypeDiagnostic: DM5PR03MB3273: X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3273; 25:Kr/edL3pTur1T+Dc/Wr83o1bmrR5pnsVjvr97smVOQLG1nYHn6015kiQcCOBrGyJHAoI+x/grA90JAAnPq64MRA4NffjxLjD7gyFmEUISYU+AKnKl/szpQWogCqG4wgM1PDSKKnt6J2iVE/ipHSsPtgZbap96AsW1d2z9HLrJ/jBDiFTKhklBJtZSXOyuiuQfcG1t3p82o/mwWD7noECmG3S6yOgdCFuZTELgopaGPz90N0KUPgsgP/CRmScq8fs/dDJqUiQUGuEJvF9VSA9ujjMBhoJkaaeampnK3eUrlAljNzugJ+33UEay5AYM/55JELdM+GWBlq67PJNiSUJoRC3kBkL5yTq4Cu+ci5IncFEtD7Z0fZDS3ZTzaEKBS+uzOXG98m7tIJcL35Im6Ty7T7kFQ5KRJdpH6LvFobv2qBRY3OmisfWdbi3h2gzkThtbFan6ZiIKlWWhhRcNIelg9UCjbTo3y4spNQyAqN4JFBr/fEUEqFytOhpWjYTQXaJplVAWIj5abbd7XygExoufloPxjOv6WCXMPjN70c+a0PHFcvfxRVB0UdrNLnwRjMkmQCIu0BNmUqcpEszibeMMvkAdrxwmGnhB9ets21XMsPEKmIQCV8rVHmqN5Q5cMTDE6+PXDo3eaWaUOb8L5W8GDg7Mjc4oHR52r/n6BWqLFKAolzrFVd/CGpZv0L8fqEOtxdpYAfL0xV40VEZYBpUPpG79n2JkEc+BV6D9AkRfNboqEz6ieG7yI5VU9wtRNo2EA8icsq5HpKSCes77iX3senfnPyJLjZbn+4riYWzo7X5lT4h7I8G9ZgMKHpADEVGaOgrUKI+1QbDrNQaKxztd0r6vZLoYT7rnn0+Gs3vps4kGugWCsHM8xawGV4khny5mD+glShebp6dc09dUgj+CQrdSaQE4hNP+3kyHv+vcDQ= X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3273; 31:EO2hCIR8NqnjsEVqyKV8D9smR4R+QvpI2sxVdqyWsu5JNb55Uly2sAmmr79ORtwqPks6OqfxssvwpwRB3yLSgoVpfchTL23xENKKc6GlrOKONCSWif8/jQ0Vvazmk/xzODQzr7uwN3S4JvFEaCp5ChAFM1hP7lYZoDzUu8qw2fHxZ0UIQ/ueV3h4hBG2dHmfa1SLYC7fcjUI4ScSrO4sUBGM/mZnCEX9XetHTn+T6BVevlNxJKQTbBq+FZwIU8+rCcDyCrkbGzdM0MicN6kYGnZIvYZ+JZDF8sOoZmlSM5X8eyulBnJUX6QQ8jQz+TvKbJl7YRlTAhF3mmrGjPZMlbEkMWioOmnsSt1PNIQwYWZUnNpgpcPoujfne0DCW3ZwbymXKKvto3JmPGOmhRGTAFJdv3cP4Q8Lc5Cys3JhL+6JRK76jwk1Xa0YzBj6ma8PDWRFNkJUDPnJy/efnT68hvaAf9WUT11++ovm0jYbRLxCVldBl9+U0bpIa3vyZs4aOZb5NhWThHM5McMi/cMowqd1AQyU2us0Lff+G14r3+zNC5Z6ZwaE/RUnFXHygOy7Kxf0wM11seSbJ4tSRcYzFvXYOKUdVzcJq/bAIQj7O/Z0srQbR3gCEvZEDLDby7wk1KMNXaSKhW7PIrrMHm11n1Cqdd4kWH7pjXs0IuyE4fJ8yZ6766Vex6cx4xRCq7HI+js1OY2AFa6tDTN2IIO8Xw== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(133145235818549)(236129657087228)(185117386973197)(247924648384137); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6095135)(601004)(2401047)(5005006)(13016025)(13018025)(8121501046)(3002001)(93006095)(93001095)(100000703101)(100105400095)(10201501046)(6055026)(6096035)(201703131430075)(201703131433075)(201703131441075)(201703131448075)(201703161259150)(20161123559100)(20161123565025)(20161123563025)(20161123556025)(20161123561025)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:DM5PR03MB3273; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(400006)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:DM5PR03MB3273; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM5PR03MB3273; 4:ErcCD2/Rtz/EaZdEqjabQCuDHHke1KHGQltpHnR2fy?= Jz8nWSYqY0uIPOg+z+Waf+61i+1hFCRctbLvvFJ0z0QQPu3hJyDVxl8aSTPn+NfuvTVkOwFbfKJYUB44RhllXbrptmvJIFRy/yxaQf8BNo9xNB0RR+qyGpg9qYO44xkZM7RtPj8PVfhsACguA6SVs49MtZKzdJfpuCvSznZDK2sHlwcZ6Akk6TUxO3HNBFvG4BuPHCGzMNtA8kLOLmIObFJjYiEnPPh+F/FgdWqNkYtqacrKWgXZp5CHe6+eRHCBy3Dyir/28IHwvVs1tKj0BDfxs+Ib5sWK/wmgJA3WXH0EFDOhkry3LjXemH/7ig+GMHmkS9wKvGQB0M9Xp73JbX8FgqBFFYkcpKXlW3inkuleRJMDsozOel7D/7BOoodnci78sSCjrxI+ctrAA8nkadwQwtGwDV+FttgMdUer0cJWXxWcyBnTZIA+2yGiXdQibkwZKN8h8QEyiQoI3zdEkSBZKk2mT4AvAlyU9NphFGwD/1dwSrLA5eepIkR/L7h4fBIE1O0eOlXWZKR1iS+HOboKL0z572yOcBPcrr5blA5A3SbonYdZj2AG0aywsRZbrS/wMXKaa+o3NLnhdkAdWjw9fIv+eZ560Aw4QQYpUS0RVFBxYOThZaZz3cJ3SIQmHEnkJMJymysKSfuEwqXY3eanda+0lftatBol8Oo7D+k+ndzaJqhfBkTrT99VKZw5ZxnKzgzDWGAJETs3OOC+pjOxE9jdANGvR9Q2BabNHOcqFcv2gStY5EQ4WMvkPGj7HCt4uJN3L3lGsSa+8pgZyCTHaoIq/IFHTeneGoDIp9j9bwEcOAboPGoqxjbjTGHlv3sI5wiHzbsgiwEnEHF1CM8V5qND/xWBKG+tWTKTaR5gwz+CIfMmKH/Y/tWMBel9zhVO6L6zIRnmrjpw4CECRcFCLgQo2pGBFS/Bd8BT8adIpWKa99ZkylXR7zM2p5nHs94SJN0g1rCRm1lalrG3HX2GT633AIk1jO2gEG5+OnUqdkJqsPOJkye5hsQqQ21bjgSRxyPrZFlDdRKXLmRIMO/I2YBcMFVxgCDqZf7jmJNyoYvw6cV7iM01HESpWdhmGjnMKJ7lv167oO5v5opu0N3+LSTJIrQCcEMnyjdsJuhng5S5G96lZ042Jq/0FoHgWiAP86BRIeYcqCXgRsegkV6fIfBjNtPupCW58ph9aIC1dcy+F5gMaD5PCc6JlNPM1+EzuiNj6d1H6Lg3DUR4iLM2PfhUj89uJu1V20twAGQHuCVddxbpz6xpFVMzu6+LpwPbI7Qzd41+ri/5yN75HQwb0AfLDCeEvne4YZV3k2QsXwy6ALHyrLW0qY35lQX1g= X-Forefront-PRVS: 0353563E2B X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM5PR03MB3273; 23:S7QlgrdLKGWVAhMz4eZJB8WWjQXZq98utLObkn5NT?= tuXY2+x/qD3ZbLbj+JbPTiFtaQ+cnhHg3WxV9S1ojIOObTMpc/ULnDvqqIWBMx/PLzHcfmGVoCF978Aobg1Z0BDx7/MkaEnpSlrt9snGJWBkQsh6TtC1qDbDlOLyjlWAUb2WTGtlJ5bqIMIVng09443tGxpntmR6nqrkB+IehmzPXV0sdMdwbqbWIt7KNoe0egcJX9uc3fNJCgAQJ9eHeG7Rl0ifeGpqlpu0LdwMbwDFLg4zzcsUTUEDvnaxyc3JD/PVhyEPBMOO5uMf0zJ3vN66ylN0WSIDC4K67s80pgexs48lYibShQOcSoeMirWyJAiFh/+vkFd3WURwerJFbOrov1QSmtCER/Q6nwjdrrbUIgR6IkE6dQnsD+Mbzhs2Y9zOAeNXjpLDjb4nVXdIecLoiUVs6UAXdwQ/0exLnzAHy9Dn4xqG3/3GAPMnxuurqtBim9oKgozVQ+m3E+KEi3sKdEE81xoIDkEUuVI/xnd9PoqxdKyfVj+0+dF9oCaQvXSo+Dat+/QfWMFjI7ug+gNk9hWtWUhtpv+cqcw4MHRKuH930PZDaCLypzvOVcr6fQR0oOLjgnW5DaBBhaz69tKcxU6GnAMJEC9B0PTrWY9Dqbmq+XxTFIA9HZVMG4Q3GMydhvCSfcs9PUbenaYzyL7lkLmHfEBWYU7886bgdVGDa7L+oL19LKXhGt+CHCI4AcKWnlzbiaHFYt55AsXCt0k0UOTCttC+lv+6qkhhSDJTq00V722UKeJPKhlma9Wv2WiktzqvpAXJNYKMLHP5WdiL4vGR8VY0w4Ajt/4mB7L58PAWv571zirCpMErRZPXAp46PPXvKFcRhBLindt1LnTU0VnovV+0jTwhAOmAijvsU3uS1TbuYUfT1SDaeif9K9f2cjHZhGha/1LJDN4KSRi/nS+/MBk53TEplipyNQqS6kp4N5uhTqk7PMEnOcmabZcDyTmZKsXLn+pA0Mq1DZ7gsNu7AYJ1mZHy4I+LPspUbmOrxsDPcTBwM665GZ3f2r/TBB4CFDa7HvRlSFM9A2O4EnqnGC3XjyQWCI3MaA03e10kBOgnq8XqerilddOw3MANMy7FT/oIs4JnSEMQkiw0XGAJeOy65qlpxpe+CSzr6ffC6TNs19dmmYvQHHHUUZDjdS+aIQRw1ujE+Ud+xA1nesYaLxhdwyVzzb15a+pjci/pEjAsam6+gwnfq0slmefBzY++cm28RJm7hyGZdBJdgk+iBmj5voxaOfc9WmWPA== X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM5PR03MB3273; 6:Gro9rLofRikyEu9fMf+6TqpsuXx0vaW3X0t/DyuI6q?= EfYWFoE0XM9MNrQ/MU+YVm47G94pYBVVeRpTv4JytFI6QiZNGRLaj1LwKFxrY9xQdS1u+8tqKBp90FJb8a4Aq26qwDSPZcw8wVrtRJYbpevBkvFMG+FoOwCWfBAGZmxMqkYMh9lbSbVRb/zcpkZXGZ+EJoPSyft/zu1f/KNSe5u6hhphAtht+F1hz5GvqjnJdVFVU6L7XM2uL7XgDC8ziKEdtU/sjQAX/BBVRQYlaMceywN3VTKtGdfTZOEh+LnZ25IvUcwHlX8A8+tp5T1cwu4Mbaa9AJzNsk8IyspJMUYBsfXqzWbG67KIjHWT/ZM6rDNU/D4LiWwAoC6aCTjF9EBDj+alSPSR4s46EZUDCdkUAbIggj4JunT311cZH5SB8WpbzZI44zYjY1O0/D7vuqV173V8ZeD3pKUS8yv/NqhVfQbkKTFCQHRRpROJiMUMVQ35BHYPO2PqekTap0rXUoptp1/J6TxAdFDJiJZUDbo1vbk06y0QoxFPjqOg0OWmpz/pgXjbBpNBfAGwxJhbO8Jvw5Mxwn1CTTSt3ZvEO3pSnSoZqKl6chRsf25MDDjsuRAt1u7b3ns1sPTO/PMD6vAgOl73LEt47UtAO1y7IZ/3Ko6m4ZB0bdIiW4ISaekWnBBTfcXpvWorzqNCZZqIw5Uk009hIx96FmGwxwwnbG19jqlJBTI4K3feZw4/E5jdCqjr/OzVmKkSF2cQ0bv9WZte4Dk1MytdseeMcO7Tn7mNAHibkikuztTqyTSRBYHrJ8jfOfuBs/sHkD1AgcI5t6CRs7nxdyd/g9LwGUkjGRIli545tlBdVAP4canDPeJBIpHM/S5spAPnOYK1T8ocJ7N3oJBghtB4/Tc2rhK1QAWj0jYIUQ5HvM3NKxBb7/3K8eD2jXXVagQAy7Uwmm1l72hB4XLjT395sYypawHhGb6Q== X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3273; 5:UoZElEdGsVBJw5YCPVzMvgnHenkFib8CP/ZhJOCiaBbWksjdtHccZTSSxlNi/w0shc5pePHkm4I5fomZTbDYBvPdx/yC6RVRVB21uBmOhW7fRawDQ6SfGizT1fkVpc08MVD4/WwyUzj84LTMB3dH1IKocKu9dHBuQmXom/0grybWOtjJlikRqLwlbYN/7ReYJc9c2ot7uqbsqUxql6oq/q6Fa8syIt8Ba7sfRk8DqoNQdKECI6pb2m4tGWDuh44NTtC08+FqdH0t0xmGH4vhzb+a1KMIJaaQjwOWknTXf+KRRVCQD1/03zBB0Hs2cnp72pZZf6keH0l0OeunuFPxqveFHM498EBqZxS2HrQReKCWmS2t5TQ3d5Yqr3DjQi8DncyPUI/JEu4OwAZoacQTZMK+4QQAUo8QmObatJ4iFy/lS3vm7y+Gwg+BAf5xD6b+Zh+ECCy/d4V3keuxW1+9Bv1PQEU/l9DM9OIHA6DrIzslCiNVTAdYQtvnmV5NDpjvMgIqxk0erZ/kM5/Lgwy25A==; 24:U/oit9OaGueMDPJWfmtVzp39zjDqh3YYpcL9bGXCG2qSlaR9ys8auC2ROKzolJSPUvnDDw0BzPDqHrwCQo9v2NOxtdIW/ua7tnZTaUgJLZQ= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3273; 7:dZjIRehFiJ9eMOCLYApAC7bV7Rzii4V8gVYPGv0LOuX6xwDDxdTfGo+sMKLurp+DDDE/+ay+sYHC5uFuldx06e3vW2Q6ztyd3JInndPvULe4Qbv0LzGbeSew99OlLJe9d2eIwmiF92iDuSeuDD2XUQ17ttvzFaFPFtesxMextqJN9jbUT3k7X9fsYP8p7DCikyd2/3Bm/DMoI2Dq9552N/vhLF8JQxcvBgr80ffqjYLijAWUuS8feFv+0mWJACZTp4Loc9Y5s55GE5GJWpiO7DQrHdw1C8q+lcGbUJC7Cm2oDgStj3AXsV/3uJiM4v3EixmeAq8ZtmJW3K1wiE9WoUnEEWIIcaWo6EUslgVtbon3UfuX9HS3YcXbf91uScndzHHd1tne86FF0eQH2Tm3iXRXB2eTkzxhe2KHiHm7KBD3PgG3qmTaOJKzB7JJ4uEHnow4UqHtFV18rhgS47dVZ14ZBGG66Ps1pAlXIzy8xmNZzv4qPlox8I3SpfZ6SSkGOPsRA2WwlQIg4Ss4Nh8WRynbbsHh5dLsJrl68R/JXQMew/gn/DsQzj80Bl2WOw+YhPImtl+d0StAXbLcR7CpS0wMcQKM2QRDl25sAHp7GD5EUzHdcrlY03MiY5yg7gFV105ZGC35+xZpa0mtGq5ukYtqeTqFK45Xa3eVethsxS/XdagV1Gf2Mum6ZBLoFBh0bu4LDruokOdrgpzX35UmqVQPf886e9afv6e1gd857XlTqmf5UwoG8OYYepDZXgafvLOQqh32sLr5JlqoUWTmKciGTv0VxMQxwtWp+tgAhxo= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 29 Jun 2017 20:50:25.1480 (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: DM5PR03MB3273 Subject: [dpdk-dev] [PATCH 3/5] crypto/dpaa2_sec: add support for AES-GCM and CTR 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: Akhil Goyal AES-GCM support is added as per the AEAD type of crypto operations. Support for AES-CTR is also added. Signed-off-by: Akhil Goyal --- drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c | 315 ++++++++++++++++++++++++++-- drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h | 98 ++++++--- 2 files changed, 359 insertions(+), 54 deletions(-) diff --git a/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c b/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c index dbdaf46..997956f 100644 --- a/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c +++ b/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c @@ -69,10 +69,6 @@ #define FSL_MC_DPSECI_DEVID 3 #define NO_PREFETCH 0 -#define TDES_CBC_IV_LEN 8 -#define AES_CBC_IV_LEN 16 -#define AES_CTR_IV_LEN 16 -#define AES_GCM_IV_LEN 12 /* FLE_POOL_NUM_BUFS is set as per the ipsec-secgw application */ #define FLE_POOL_NUM_BUFS 32000 #define FLE_POOL_BUF_SIZE 256 @@ -81,6 +77,148 @@ enum rta_sec_era rta_sec_era = RTA_SEC_ERA_8; static inline int +build_authenc_gcm_fd(dpaa2_sec_session *sess, + struct rte_crypto_op *op, + struct qbman_fd *fd, uint16_t bpid) +{ + struct rte_crypto_sym_op *sym_op = op->sym; + struct ctxt_priv *priv = sess->ctxt; + struct qbman_fle *fle, *sge; + struct sec_flow_context *flc; + uint32_t auth_only_len = sess->ext_params.aead_ctxt.auth_only_len; + int icv_len = sess->digest_length, retval; + uint8_t *old_icv; + uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *, + sess->iv.offset); + + PMD_INIT_FUNC_TRACE(); + + /* TODO we are using the first FLE entry to store Mbuf and session ctxt. + Currently we donot know which FLE has the mbuf stored. + So while retreiving we can go back 1 FLE from the FD -ADDR + to get the MBUF Addr from the previous FLE. + We can have a better approach to use the inline Mbuf*/ + retval = rte_mempool_get(priv->fle_pool, (void **)(&fle)); + if (retval) { + RTE_LOG(ERR, PMD, "Memory alloc failed for SGE\n"); + return -1; + } + memset(fle, 0, FLE_POOL_BUF_SIZE); + DPAA2_SET_FLE_ADDR(fle, DPAA2_OP_VADDR_TO_IOVA(op)); + DPAA2_FLE_SAVE_CTXT(fle, priv); + fle = fle + 1; + sge = fle + 2; + if (likely(bpid < MAX_BPID)) { + DPAA2_SET_FD_BPID(fd, bpid); + DPAA2_SET_FLE_BPID(fle, bpid); + DPAA2_SET_FLE_BPID(fle + 1, bpid); + DPAA2_SET_FLE_BPID(sge, bpid); + DPAA2_SET_FLE_BPID(sge + 1, bpid); + DPAA2_SET_FLE_BPID(sge + 2, bpid); + DPAA2_SET_FLE_BPID(sge + 3, bpid); + } else { + DPAA2_SET_FD_IVP(fd); + DPAA2_SET_FLE_IVP(fle); + DPAA2_SET_FLE_IVP((fle + 1)); + DPAA2_SET_FLE_IVP(sge); + DPAA2_SET_FLE_IVP((sge + 1)); + DPAA2_SET_FLE_IVP((sge + 2)); + DPAA2_SET_FLE_IVP((sge + 3)); + } + + /* Save the shared descriptor */ + flc = &priv->flc_desc[0].flc; + /* Configure FD as a FRAME LIST */ + DPAA2_SET_FD_ADDR(fd, DPAA2_VADDR_TO_IOVA(fle)); + DPAA2_SET_FD_COMPOUND_FMT(fd); + DPAA2_SET_FD_FLC(fd, DPAA2_VADDR_TO_IOVA(flc)); + + PMD_TX_LOG(DEBUG, "auth_off: 0x%x/length %d, digest-len=%d\n" + "iv-len=%d data_off: 0x%x\n", + sym_op->aead.data.offset, + sym_op->aead.data.length, + sym_op->aead.digest.length, + sess->iv.length, + sym_op->m_src->data_off); + + /* Configure Output FLE with Scatter/Gather Entry */ + DPAA2_SET_FLE_ADDR(fle, DPAA2_VADDR_TO_IOVA(sge)); + if (auth_only_len) + DPAA2_SET_FLE_INTERNAL_JD(fle, auth_only_len); + fle->length = (sess->dir == DIR_ENC) ? + (sym_op->aead.data.length + icv_len + auth_only_len) : + sym_op->aead.data.length + auth_only_len; + + DPAA2_SET_FLE_SG_EXT(fle); + + /* Configure Output SGE for Encap/Decap */ + DPAA2_SET_FLE_ADDR(sge, DPAA2_MBUF_VADDR_TO_IOVA(sym_op->m_src)); + DPAA2_SET_FLE_OFFSET(sge, sym_op->aead.data.offset + + sym_op->m_src->data_off - auth_only_len); + sge->length = sym_op->aead.data.length + auth_only_len; + + if (sess->dir == DIR_ENC) { + sge++; + DPAA2_SET_FLE_ADDR(sge, + DPAA2_VADDR_TO_IOVA(sym_op->aead.digest.data)); + sge->length = sess->digest_length; + DPAA2_SET_FD_LEN(fd, (sym_op->aead.data.length + + sess->iv.length + auth_only_len)); + } + DPAA2_SET_FLE_FIN(sge); + + sge++; + fle++; + + /* Configure Input FLE with Scatter/Gather Entry */ + DPAA2_SET_FLE_ADDR(fle, DPAA2_VADDR_TO_IOVA(sge)); + DPAA2_SET_FLE_SG_EXT(fle); + DPAA2_SET_FLE_FIN(fle); + fle->length = (sess->dir == DIR_ENC) ? + (sym_op->aead.data.length + sess->iv.length + auth_only_len) : + (sym_op->aead.data.length + sess->iv.length + auth_only_len + + sess->digest_length); + + /* Configure Input SGE for Encap/Decap */ + DPAA2_SET_FLE_ADDR(sge, DPAA2_VADDR_TO_IOVA(IV_ptr)); + sge->length = sess->iv.length; + sge++; + if (auth_only_len) { + DPAA2_SET_FLE_ADDR(sge, + DPAA2_VADDR_TO_IOVA(sym_op->aead.aad.data)); + sge->length = auth_only_len; + DPAA2_SET_FLE_BPID(sge, bpid); + sge++; + } + + DPAA2_SET_FLE_ADDR(sge, DPAA2_MBUF_VADDR_TO_IOVA(sym_op->m_src)); + DPAA2_SET_FLE_OFFSET(sge, sym_op->aead.data.offset + + sym_op->m_src->data_off); + sge->length = sym_op->aead.data.length; + if (sess->dir == DIR_DEC) { + sge++; + old_icv = (uint8_t *)(sge + 1); + memcpy(old_icv, sym_op->aead.digest.data, + sess->digest_length); + memset(sym_op->aead.digest.data, 0, sess->digest_length); + DPAA2_SET_FLE_ADDR(sge, DPAA2_VADDR_TO_IOVA(old_icv)); + sge->length = sess->digest_length; + DPAA2_SET_FD_LEN(fd, (sym_op->aead.data.length + + sess->digest_length + + sess->iv.length + + auth_only_len)); + } + DPAA2_SET_FLE_FIN(sge); + + if (auth_only_len) { + DPAA2_SET_FLE_INTERNAL_JD(fle, auth_only_len); + DPAA2_SET_FD_INTERNAL_JD(fd, auth_only_len); + } + + return 0; +} + +static inline int build_authenc_fd(dpaa2_sec_session *sess, struct rte_crypto_op *op, struct qbman_fd *fd, uint16_t bpid) @@ -418,6 +556,9 @@ build_sec_fd(dpaa2_sec_session *sess, struct rte_crypto_op *op, case DPAA2_SEC_AUTH: ret = build_auth_fd(sess, op, fd, bpid); break; + case DPAA2_SEC_AEAD: + ret = build_authenc_gcm_fd(sess, op, fd, bpid); + break; case DPAA2_SEC_CIPHER_HASH: ret = build_authenc_fd(sess, op, fd, bpid); break; @@ -773,7 +914,6 @@ dpaa2_sec_cipher_init(struct rte_cryptodev *dev, struct rte_crypto_sym_xform *xform, dpaa2_sec_session *session) { - struct dpaa2_sec_cipher_ctxt *ctxt = &session->ext_params.cipher_ctxt; struct dpaa2_sec_dev_private *dev_priv = dev->data->dev_private; struct alginfo cipherdata; int bufsize, i; @@ -820,15 +960,17 @@ dpaa2_sec_cipher_init(struct rte_cryptodev *dev, cipherdata.algtype = OP_ALG_ALGSEL_AES; cipherdata.algmode = OP_ALG_AAI_CBC; session->cipher_alg = RTE_CRYPTO_CIPHER_AES_CBC; - ctxt->iv.length = AES_CBC_IV_LEN; break; case RTE_CRYPTO_CIPHER_3DES_CBC: cipherdata.algtype = OP_ALG_ALGSEL_3DES; cipherdata.algmode = OP_ALG_AAI_CBC; session->cipher_alg = RTE_CRYPTO_CIPHER_3DES_CBC; - ctxt->iv.length = TDES_CBC_IV_LEN; break; case RTE_CRYPTO_CIPHER_AES_CTR: + cipherdata.algtype = OP_ALG_ALGSEL_AES; + cipherdata.algmode = OP_ALG_AAI_CTR; + session->cipher_alg = RTE_CRYPTO_CIPHER_AES_CTR; + break; case RTE_CRYPTO_CIPHER_3DES_CTR: case RTE_CRYPTO_CIPHER_AES_ECB: case RTE_CRYPTO_CIPHER_3DES_ECB: @@ -851,8 +993,8 @@ dpaa2_sec_cipher_init(struct rte_cryptodev *dev, DIR_ENC : DIR_DEC; bufsize = cnstr_shdsc_blkcipher(priv->flc_desc[0].desc, 1, 0, - &cipherdata, NULL, ctxt->iv.length, - session->dir); + &cipherdata, NULL, session->iv.length, + session->dir); if (bufsize < 0) { RTE_LOG(ERR, PMD, "Crypto: Descriptor build failed\n"); goto error_out; @@ -887,7 +1029,6 @@ dpaa2_sec_auth_init(struct rte_cryptodev *dev, struct rte_crypto_sym_xform *xform, dpaa2_sec_session *session) { - struct dpaa2_sec_auth_ctxt *ctxt = &session->ext_params.auth_ctxt; struct dpaa2_sec_dev_private *dev_priv = dev->data->dev_private; struct alginfo authdata; unsigned int bufsize, i; @@ -985,7 +1126,7 @@ dpaa2_sec_auth_init(struct rte_cryptodev *dev, bufsize = cnstr_shdsc_hmac(priv->flc_desc[DESC_INITFINAL].desc, 1, 0, &authdata, !session->dir, - ctxt->trunc_len); + session->digest_length); flc->word1_sdl = (uint8_t)bufsize; flc->word2_rflc_31_0 = lower_32_bits( @@ -997,7 +1138,8 @@ dpaa2_sec_auth_init(struct rte_cryptodev *dev, session->ctxt = priv; for (i = 0; i < bufsize; i++) PMD_DRV_LOG(DEBUG, "DESC[%d]:0x%x\n", - i, priv->flc_desc[0].desc[i]); + i, priv->flc_desc[DESC_INITFINAL].desc[i]); + return 0; @@ -1014,6 +1156,126 @@ dpaa2_sec_aead_init(struct rte_cryptodev *dev, { struct dpaa2_sec_aead_ctxt *ctxt = &session->ext_params.aead_ctxt; struct dpaa2_sec_dev_private *dev_priv = dev->data->dev_private; + struct alginfo aeaddata; + unsigned int bufsize, i; + struct ctxt_priv *priv; + struct sec_flow_context *flc; + struct rte_crypto_aead_xform *aead_xform = &xform->aead; + int err; + + PMD_INIT_FUNC_TRACE(); + + /* Set IV parameters */ + session->iv.offset = aead_xform->iv.offset; + session->iv.length = aead_xform->iv.length; + session->ctxt_type = DPAA2_SEC_AEAD; + + /* For SEC AEAD only one descriptor is required */ + priv = (struct ctxt_priv *)rte_zmalloc(NULL, + sizeof(struct ctxt_priv) + sizeof(struct sec_flc_desc), + RTE_CACHE_LINE_SIZE); + if (priv == NULL) { + RTE_LOG(ERR, PMD, "No Memory for priv CTXT"); + return -1; + } + + priv->fle_pool = dev_priv->fle_pool; + flc = &priv->flc_desc[0].flc; + + session->aead_key.data = rte_zmalloc(NULL, aead_xform->key.length, + RTE_CACHE_LINE_SIZE); + if (session->aead_key.data == NULL && aead_xform->key.length > 0) { + RTE_LOG(ERR, PMD, "No Memory for aead key"); + rte_free(priv); + return -1; + } + memcpy(session->aead_key.data, aead_xform->key.data, + aead_xform->key.length); + + session->digest_length = aead_xform->digest_length; + session->aead_key.length = aead_xform->key.length; + ctxt->auth_only_len = aead_xform->add_auth_data_length; + + aeaddata.key = (uint64_t)session->aead_key.data; + aeaddata.keylen = session->aead_key.length; + aeaddata.key_enc_flags = 0; + aeaddata.key_type = RTA_DATA_IMM; + + switch (aead_xform->algo) { + case RTE_CRYPTO_AEAD_AES_GCM: + aeaddata.algtype = OP_ALG_ALGSEL_AES; + aeaddata.algmode = OP_ALG_AAI_GCM; + session->cipher_alg = RTE_CRYPTO_AEAD_AES_GCM; + break; + case RTE_CRYPTO_AEAD_AES_CCM: + RTE_LOG(ERR, PMD, "Crypto: Unsupported AEAD alg %u", + aead_xform->algo); + goto error_out; + default: + RTE_LOG(ERR, PMD, "Crypto: Undefined AEAD specified %u\n", + aead_xform->algo); + goto error_out; + } + session->dir = (aead_xform->op == RTE_CRYPTO_AEAD_OP_ENCRYPT) ? + DIR_ENC : DIR_DEC; + + priv->flc_desc[0].desc[0] = aeaddata.keylen; + err = rta_inline_query(IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN, + MIN_JOB_DESC_SIZE, + (unsigned int *)priv->flc_desc[0].desc, + &priv->flc_desc[0].desc[1], 1); + + if (err < 0) { + PMD_DRV_LOG(ERR, "Crypto: Incorrect key lengths"); + goto error_out; + } + if (priv->flc_desc[0].desc[1] & 1) { + aeaddata.key_type = RTA_DATA_IMM; + } else { + aeaddata.key = DPAA2_VADDR_TO_IOVA(aeaddata.key); + aeaddata.key_type = RTA_DATA_PTR; + } + priv->flc_desc[0].desc[0] = 0; + priv->flc_desc[0].desc[1] = 0; + + if (session->dir == DIR_ENC) + bufsize = cnstr_shdsc_gcm_encap( + priv->flc_desc[0].desc, 1, 0, + &aeaddata, session->iv.length, + session->digest_length); + else + bufsize = cnstr_shdsc_gcm_decap( + priv->flc_desc[0].desc, 1, 0, + &aeaddata, session->iv.length, + session->digest_length); + flc->word1_sdl = (uint8_t)bufsize; + flc->word2_rflc_31_0 = lower_32_bits( + (uint64_t)&(((struct dpaa2_sec_qp *) + dev->data->queue_pairs[0])->rx_vq)); + flc->word3_rflc_63_32 = upper_32_bits( + (uint64_t)&(((struct dpaa2_sec_qp *) + dev->data->queue_pairs[0])->rx_vq)); + session->ctxt = priv; + for (i = 0; i < bufsize; i++) + PMD_DRV_LOG(DEBUG, "DESC[%d]:0x%x\n", + i, priv->flc_desc[0].desc[i]); + + return 0; + +error_out: + rte_free(session->aead_key.data); + rte_free(priv); + return -1; +} + + +static int +dpaa2_sec_aead_chain_init(struct rte_cryptodev *dev, + struct rte_crypto_sym_xform *xform, + dpaa2_sec_session *session) +{ + struct dpaa2_sec_aead_ctxt *ctxt = &session->ext_params.aead_ctxt; + struct dpaa2_sec_dev_private *dev_priv = dev->data->dev_private; struct alginfo authdata, cipherdata; unsigned int bufsize, i; struct ctxt_priv *priv; @@ -1076,7 +1338,6 @@ dpaa2_sec_aead_init(struct rte_cryptodev *dev, memcpy(session->auth_key.data, auth_xform->key.data, auth_xform->key.length); - ctxt->trunc_len = auth_xform->digest_length; authdata.key = (uint64_t)session->auth_key.data; authdata.keylen = session->auth_key.length; authdata.key_enc_flags = 0; @@ -1147,19 +1408,21 @@ dpaa2_sec_aead_init(struct rte_cryptodev *dev, cipherdata.algtype = OP_ALG_ALGSEL_AES; cipherdata.algmode = OP_ALG_AAI_CBC; session->cipher_alg = RTE_CRYPTO_CIPHER_AES_CBC; - ctxt->iv.length = AES_CBC_IV_LEN; break; case RTE_CRYPTO_CIPHER_3DES_CBC: cipherdata.algtype = OP_ALG_ALGSEL_3DES; cipherdata.algmode = OP_ALG_AAI_CBC; session->cipher_alg = RTE_CRYPTO_CIPHER_3DES_CBC; - ctxt->iv.length = TDES_CBC_IV_LEN; + break; + case RTE_CRYPTO_CIPHER_AES_CTR: + cipherdata.algtype = OP_ALG_ALGSEL_AES; + cipherdata.algmode = OP_ALG_AAI_CTR; + session->cipher_alg = RTE_CRYPTO_CIPHER_AES_CTR; break; case RTE_CRYPTO_CIPHER_SNOW3G_UEA2: case RTE_CRYPTO_CIPHER_NULL: case RTE_CRYPTO_CIPHER_3DES_ECB: case RTE_CRYPTO_CIPHER_AES_ECB: - case RTE_CRYPTO_CIPHER_AES_CTR: case RTE_CRYPTO_CIPHER_KASUMI_F8: RTE_LOG(ERR, PMD, "Crypto: Unsupported Cipher alg %u", cipher_xform->algo); @@ -1202,9 +1465,9 @@ dpaa2_sec_aead_init(struct rte_cryptodev *dev, if (session->ctxt_type == DPAA2_SEC_CIPHER_HASH) { bufsize = cnstr_shdsc_authenc(priv->flc_desc[0].desc, 1, 0, &cipherdata, &authdata, - ctxt->iv.length, + session->iv.length, ctxt->auth_only_len, - ctxt->trunc_len, + session->digest_length, session->dir); } else { RTE_LOG(ERR, PMD, "Hash before cipher not supported"); @@ -1221,8 +1484,7 @@ dpaa2_sec_aead_init(struct rte_cryptodev *dev, session->ctxt = priv; for (i = 0; i < bufsize; i++) PMD_DRV_LOG(DEBUG, "DESC[%d]:0x%x\n", - i, priv->flc_desc[DESC_INITFINAL].desc[i]); - + i, priv->flc_desc[0].desc[i]); return 0; @@ -1264,13 +1526,19 @@ dpaa2_sec_session_configure(struct rte_cryptodev *dev, } else if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER && xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH) { session->ext_params.aead_ctxt.auth_cipher_text = true; - dpaa2_sec_aead_init(dev, xform, session); + dpaa2_sec_aead_chain_init(dev, xform, session); /* Authenticate then Cipher */ } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH && xform->next->type == RTE_CRYPTO_SYM_XFORM_CIPHER) { session->ext_params.aead_ctxt.auth_cipher_text = false; + dpaa2_sec_aead_chain_init(dev, xform, session); + + /* AEAD operation for AES-GCM kind of Algorithms */ + } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD && + xform->next == NULL) { dpaa2_sec_aead_init(dev, xform, session); + } else { RTE_LOG(ERR, PMD, "Invalid crypto type"); return NULL; @@ -1300,7 +1568,7 @@ dpaa2_sec_dev_configure(struct rte_cryptodev *dev __rte_unused, { PMD_INIT_FUNC_TRACE(); - return -ENOTSUP; + return 0; } static int @@ -1626,7 +1894,7 @@ dpaa2_sec_dev_init(struct rte_cryptodev *cryptodev) } static int -cryptodev_dpaa2_sec_probe(struct rte_dpaa2_driver *dpaa2_drv __rte_unused, +cryptodev_dpaa2_sec_probe(struct rte_dpaa2_driver *dpaa2_drv, struct rte_dpaa2_device *dpaa2_dev) { struct rte_cryptodev *cryptodev; @@ -1654,6 +1922,7 @@ cryptodev_dpaa2_sec_probe(struct rte_dpaa2_driver *dpaa2_drv __rte_unused, dpaa2_dev->cryptodev = cryptodev; cryptodev->device = &dpaa2_dev->device; + cryptodev->device->driver = &dpaa2_drv->driver; /* init user callbacks */ TAILQ_INIT(&(cryptodev->link_intr_cbs)); diff --git a/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h b/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h index b4dfe24..a477404 100644 --- a/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h +++ b/drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h @@ -137,6 +137,7 @@ enum dpaa2_sec_op_type { DPAA2_SEC_NONE, /*!< No Cipher operations*/ DPAA2_SEC_CIPHER,/*!< CIPHER operations */ DPAA2_SEC_AUTH, /*!< Authentication Operations */ + DPAA2_SEC_AEAD, /*!< AEAD (AES-GCM/CCM) type operations */ DPAA2_SEC_CIPHER_HASH, /*!< Authenticated Encryption with * associated data */ @@ -149,30 +150,9 @@ enum dpaa2_sec_op_type { DPAA2_SEC_MAX }; -struct dpaa2_sec_cipher_ctxt { - struct { - uint8_t *data; - uint16_t length; - } iv; /**< Initialisation vector parameters */ - uint8_t *init_counter; /*!< Set initial counter for CTR mode */ -}; - -struct dpaa2_sec_auth_ctxt { - uint8_t trunc_len; /*!< Length for output ICV, should - * be 0 if no truncation required - */ -}; - struct dpaa2_sec_aead_ctxt { - struct { - uint8_t *data; - uint16_t length; - } iv; /**< Initialisation vector parameters */ uint16_t auth_only_len; /*!< Length of data for Auth only */ uint8_t auth_cipher_text; /**< Authenticate/cipher ordering */ - uint8_t trunc_len; /*!< Length for output ICV, should - * be 0 if no truncation required - */ }; typedef struct dpaa2_sec_session_entry { @@ -181,14 +161,22 @@ typedef struct dpaa2_sec_session_entry { uint8_t dir; /*!< Operation Direction */ enum rte_crypto_cipher_algorithm cipher_alg; /*!< Cipher Algorithm*/ enum rte_crypto_auth_algorithm auth_alg; /*!< Authentication Algorithm*/ - struct { - uint8_t *data; /**< pointer to key data */ - size_t length; /**< key length in bytes */ - } cipher_key; - struct { - uint8_t *data; /**< pointer to key data */ - size_t length; /**< key length in bytes */ - } auth_key; + union { + struct { + uint8_t *data; /**< pointer to key data */ + size_t length; /**< key length in bytes */ + } aead_key; + struct { + struct { + uint8_t *data; /**< pointer to key data */ + size_t length; /**< key length in bytes */ + } cipher_key; + struct { + uint8_t *data; /**< pointer to key data */ + size_t length; /**< key length in bytes */ + } auth_key; + }; + }; struct { uint16_t length; /**< IV length in bytes */ uint16_t offset; /**< IV offset in bytes */ @@ -196,8 +184,6 @@ typedef struct dpaa2_sec_session_entry { uint16_t digest_length; uint8_t status; union { - struct dpaa2_sec_cipher_ctxt cipher_ctxt; - struct dpaa2_sec_auth_ctxt auth_ctxt; struct dpaa2_sec_aead_ctxt aead_ctxt; } ext_params; } dpaa2_sec_session; @@ -335,6 +321,36 @@ static const struct rte_cryptodev_capabilities dpaa2_sec_capabilities[] = { }, } }, } }, + { /* AES GCM */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD, + {.aead = { + .algo = RTE_CRYPTO_AEAD_AES_GCM, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .digest_size = { + .min = 8, + .max = 16, + .increment = 4 + }, + .aad_size = { + .min = 0, + .max = 240, + .increment = 1 + }, + .iv_size = { + .min = 12, + .max = 12, + .increment = 0 + }, + }, } + }, } + }, { /* AES CBC */ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, {.sym = { @@ -355,6 +371,26 @@ static const struct rte_cryptodev_capabilities dpaa2_sec_capabilities[] = { }, } }, } }, + { /* AES CTR */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_AES_CTR, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + }, + }, } + }, } + }, { /* 3DES CBC */ .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, {.sym = {