From patchwork Fri Jun 30 07:43:21 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Akhil Goyal X-Patchwork-Id: 26055 X-Patchwork-Delegate: pablo.de.lara.guarch@intel.com 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 F409E5A6A; Fri, 30 Jun 2017 09:44:55 +0200 (CEST) Received: from NAM02-SN1-obe.outbound.protection.outlook.com (mail-sn1nam02on0051.outbound.protection.outlook.com [104.47.36.51]) by dpdk.org (Postfix) with ESMTP id 6FB7C5699 for ; Fri, 30 Jun 2017 09:44:48 +0200 (CEST) Received: from MWHPR03CA0049.namprd03.prod.outlook.com (10.174.173.166) by BLUPR03MB469.namprd03.prod.outlook.com (10.141.78.141) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1199.15; Fri, 30 Jun 2017 07:44:46 +0000 Received: from BN1AFFO11FD028.protection.gbl (2a01:111:f400:7c10::156) by MWHPR03CA0049.outlook.office365.com (2603:10b6:301:3b::38) 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; Fri, 30 Jun 2017 07:44:46 +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 BN1AFFO11FD028.mail.protection.outlook.com (10.58.52.88) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1199.9 via Frontend Transport; Fri, 30 Jun 2017 07:44:45 +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 v5U7iWIX022821; Fri, 30 Jun 2017 00:44:43 -0700 From: To: CC: , , , Akhil Goyal Date: Fri, 30 Jun 2017 13:13:21 +0530 Message-ID: <20170630074322.30661-5-akhil.goyal@nxp.com> X-Mailer: git-send-email 2.9.3 In-Reply-To: <20170630074322.30661-1-akhil.goyal@nxp.com> References: <20170629204904.23684-1-akhil.goyal@nxp.com> <20170630074322.30661-1-akhil.goyal@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131432822859959234; (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)(39400400002)(39380400002)(39850400002)(39840400002)(39860400002)(39410400002)(39450400003)(2980300002)(1109001)(1110001)(339900001)(199003)(189002)(9170700003)(356003)(189998001)(48376002)(4326008)(50466002)(85426001)(498600001)(81166006)(2351001)(33646002)(305945005)(105606002)(77096006)(104016004)(106466001)(8676002)(8936002)(8656002)(50226002)(36756003)(1076002)(86152003)(50986999)(5660300001)(5003940100001)(2876002)(53936002)(38730400002)(110136004)(2906002)(86362001)(575784001)(54906002)(76176999)(2950100002)(6666003)(6916009)(47776003); DIR:OUT; SFP:1101; SCL:1; SRVR:BLUPR03MB469; 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; BN1AFFO11FD028; 1:LKRURsH+Mz4pwc7cWOwWdjuoJypA9PFE7ThB37oxW?= LX6G6qE+rZYIPivZSUzurcGdiTXcQLaRIVTVs+FX/Xf3sJunJUAMoDg3W6fdpp+vTz44LSqnF+gBkM4mzspkvgH24jgXNPilcvLA5wVN++GFHFAbe/KhWLiSgYah+qC7qNct6oRFhnNQqSbvKXmDa5z7sYlAs+WxCaUgQwe3vulC0aOYdgR1x3bj+5K1A/76sFY8NM1eyEmix0IwXDLJ/fYXdSslJBhbElLt2vYX317g1pidmW42II34CCSImtJlyQwGauA0JCQ3TigZPwgtliLQPe00uftBXVEAIMHp3kHZLjhsW9uc8YfmALjlJ5zDdIVoCif9pNVBq8WwG0Q0WhSpAHlsJb8arTrrA6LhTxHYiWL57LPbUkT7dLGeen1w8aUAWBjl7G77tRy+j3L0sQ/dpGqUtlyTlp0wEO+e7znv3o7Nw10oLmaoyA6lE/5F5kQ2mBEdKRoQRgIO8VGz3OBrYtLYz68fdxS3RmtyEqfVVBvmpdgw4EMz2kCBcpFpyCAcJsBmzw0tn6q/zaSjIUo3TugNx2ui8ya1gXafK+a5g+fsG7EEtaHWplSMw7Vrd5ne8qvjp23MMb8ekHBSiullZQ+9/arzi4cPVsa0soQNCzUUPNHQBEy1S0h4llveSx+xsJWI3F8vKzcCYglkWXvabt9st+P/yyFjSoBreVzEkVeuXjVwZP6UsPcsk+pjEGlBtwRneyTmrnHG3qSvvxEoXDsdtrnkpSbAGivVkcrokpCku0cSQn5fcm345vJco1bDbctckHLJvkB9WARmiMODlNdHytGz2tZQXOBHTAItAv6EKbhNHjNmq5pbZ7Z0YR/F7lUZes1RAr+dqF/YaPw2mu/3Dh+cjHY9mgsMcUToAJKOlZ87unfdYltM0T6/Z1ff6C8Yr6WiJ3L6fgtiPLCt3SWPcXUDwQ/FGdiBV6NS1+mE5ZHH8i57hkceJGCt9BKiMpV6LRfQo1crjJGZ8590G1RBYR4XHcPME1UeVnmC1m++XX0+ErnV9g4t3sZnC0G5rRJDCd3xeu/Xxe3FsKHRQd9I03rsW6tSr3JvKDyjA== MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 62304ca3-17c2-4e5f-00ba-08d4bf8be0c9 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:BLUPR03MB469; X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB469; 3:VZxZSA3pQz3S9sLTHb9T21HeeICa2aweV6GwwDTHVBOHk7dEbWscIQKTyhmQbiGnmCO6432YPh0Qr8HCsWr51O4uB5J0ikWpkAS9+GlOjcifpLFigGacV4JMLsXgBCsdiufS5MCBxgJgYiobwf6sr4jezwpooyxGlo+XLrzdmmR2elFzN6+2W6nc99eVEE3vsbEO2+Ft/JiYPyQwFKV+lNUDYinTN8VzObdkMG8AU6IPPWWEG3R5iQmfXesL3szb1NKa2alP84KY3EtohaMfWNPsMv7G/iwv4VXO7clgQuiJhVU2IkzFWYEFMVnDzspWpx/5V6kkZM1eziNSxpxe+Z44OIFKe+btN1UcYluOBH0BpAIsruzV9Vdbr9schx7zhjzUBZLbHYPK6Z/7rbHsH7jWrbzcvJ3ZEdd++zZwoy+iiCEgxVhRHIJ8MXZpmEFIQ1+F6nUiu4FxAAzbcr0H2/9l7wJPcFEIgARnRH3P+6jaoDWY3FAwX3f2tzGtF9eduTC1lKGbv4ZDZftTXJELpAJmxBNPlYb1R5KW3hD/r/sXxYJ7vRdksVkdBk5x0KVihk693fKqCRSup17UAHF8n4VBEsEPuikMCLWt5NIpYdHXh2jZUy7LPLNp948AFOoqESb3SKiy1NZuy1aWRCdRKXVvvbMbQ43yTbYbfeGE2rtJ1Kv0HJzYAgRpGOK365kPO3j6I5ia87s6WIGX7SEMrc+T2k8OEx+mHVqYXjDSjRcihQv24MYUFNs/n4/x370cMRPk+Rac25M4tub3xvVHsvUOn6LiiyVgNIycUUdoSPkO7ZWGa31MiQaMhyQBvQTTjHgE7rylLsCgKDvnBxTtVfl9fTAsvol12sE3r4iaWN9Wdye2kymGS3A0CMfw2v4A X-MS-TrafficTypeDiagnostic: BLUPR03MB469: X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB469; 25:MOwflLuV6q0pcYVCAixBvmHPwRrkOKR3CfUlpgNOieHtUL7q2A4kQeBAG2WNRf3SzFDdJ2UhPxzXjERn34qUzDIPjwdik6GAwZK8BoVB7QLugCCbxCsblyknTbWKS2GqyRzUwufj71nkfEh73IOUdeSZmQiJbuigxMn3v40ydq+slNJ582mcoNJeCe2fTFTmzcyIQv8Vei3iYaK65LeZEJ+bmT63GTwfqtRHzejEQKcDwbo+NMe1gME+fIKRMWUy+8mmxFBdlr66kHuhF/R5fWRdvI6xh2nS1wXCuBNzaMAKbzp3pGmAlrFF7seQSrnMv2kZdgTgH8kz9pEfyOvkyxlXIABtzx+h9Av8Em/JuyJ4Whm7BbZ0KUpWMFcT6NTDqtHimz28GQAN/R+tmaEd93LRo/7IwwB9XudBEpImShQduYGXM21nHhy0TiZaUfjgNhMDD7ai+fusfblUt1KioX6bUeDC1hzNecTfYJIrQXcWnu36HkoOmFfaQXNF75mrizR8LNc7ivOjUnAaeO4YaYfw7ONDqyQ99UiHhZ7bEofQjL0uoZpzdmEvWK+N3ut73PBJrz1l250WGC1ARUF5jjWQfqzE/ung3Ji2MphFkXxoIg7YkRdkp9j8GJXlsd8kAU1iV/WMPnwObf51BTWT9w1w+RItaGBQqacU1nljIzXiqr3XEC9GOpYLc59BLnq+2eYTrCSvLDgslk+yzpfGSwit+PR7trlCzf2wgRzQU2nTfc/OGgsBOFP2CQMm5Lo1f6F5ulYIzQkUr7YJxvMYSC2g0rqVwX9of2OQRxPiAdcuedlrP8uvmQh/rfrQtF6h6pZa34qvnpY/VGLmRhrChIq5z11m3AT0pMkukv8zTkJb9/sj1ka6c0U1tsGtbMwz1sH9Egb5QW3R//DRJJhfV105gAtPJCmYNpf+/lF5i7c= X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB469; 31:JjY55YTARqsdFOs5/a3fK1Fo+/9+RkeoSUP5Z+PzGmhBrG17o8KUrlNI3LvNTqwSYNL1+6/7+qLpKizYEnFc5eH9KWDxFplP24xBOmyqbD7GDxmUw9+OmLbJbhlIDpXFq/rVfLWHMaLTScyLOWO8MfJnslKzghcLwVU+py5TquUI8yc4zS1Ac0z5GSUoK3jkt0/y4mIb9EYDRCU79RY2Kq/+L9K8oqJ6jmgIBFb5xlu1tIrouPO2uBY6JvaW4fLMD+8rwAB5ZWk1/x1Nwqvld81NI9vubQKkpW/PqB7M+zFLBGCXfc54fLHrNd+JpwTWjcxsPr5FXRlCNHAbewZWZa8N3HWtqf+Z5IKwxdgcQ7OpG1szzCyJXJklWCXsDl9261ihp+0uKwJ/W6EdkaDO/zpM+91xLnTpT2WmIV9HQB1o4KmQkYKVLMGp48ovUsCS4Vm7hdehK5KuLnoPE8cgF7nXT/iMzu7FlQ7Jy7JpBl4DY8+2Joj/7jhGJjgV7nLN/t1e8ek0SkdaPE7qecK6+Bi57dHy/9eQ0BWqrtVEF/IaIuilwj9Bju/8OqYaZdi3cyUdo5VF56pITvpg6I820KuHR3lL2CTQLGt3/MZBKQVZzsDW9vNOyrzSt+4EqkQr+z9+enh3twPuoiDRhjh/eNfnCMeUjlgZrfUFW5+BXEq0ZLYbV2eqIy1HZjhRWkt0aftTiZ8yJi1eek0Yh9sHjw== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(133145235818549)(236129657087228)(185117386973197)(148574349560750)(247924648384137); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6095135)(601004)(2401047)(8121501046)(13016025)(5005006)(13018025)(3002001)(93006095)(93001095)(10201501046)(100000703101)(100105400095)(6055026)(6096035)(20161123563025)(20161123561025)(20161123559100)(20161123565025)(20161123556025)(201703131430075)(201703131433075)(201703131441075)(201703131448075)(201703161259150)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:BLUPR03MB469; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(400006)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:BLUPR03MB469; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BLUPR03MB469; 4:U4wyBiCw+VQo12Z0iUklpKDVPXfDOmUNR9iQ2uQmQOc?= MFCpUTBkEEOLMJ8SlT3jm/LW+L0/+Mke/0hLuwvrHX4fPhBaLmcRCYfw9mSNKBHyxdgWXOnhcqgCFxqQXd7o2YWUL3UgkM/pFX2T4iJ5eIV2VeFHxYxGh9IYCxMjZxUg3S1G78oKDT83TcHjyoagh47RZlsJ9Ju/8ixxVafLDgFZ9XDUZ2Og748qeP0tQrgb5b+EuQlQCynFUl6wzeT/rCTMj3F/h9Hp9jf8++ouR2hVLMhAI4VVZapKo0QyacbG2NP+2iqlrfyc4GByJAcD/nSlZtZKLPY1VxQ1tdkIV4gIGgAx6jtCtcj/VP86GyLs8rq7S0vzXB3yTJ33027Szskw8OeX1qExAhsUwrSIiGzM2xAidIxOy/pb0PUx/7uu0JkDTQupYt1BxPESgFJNkhDBhc0zhhUU7QTOAR9H1fEQuRGlstax+k7dnPuxUMhu1TB4lX+701SFrMcVsIQvillqkivj2DN5qa5nkvTIr3hztcQIopkc1oujPjW0bkzWU0P/fE+/gegLERaQ59YOHeoUK6XqKrC8eH5OckW37CUPIFGvaQRRWYC+O2h6XnFSwEEDI3HuAF/gL7sc5GSBfGUKJI7W+KD9jjccsfLSlp9e5gAl/oVxOEz9iszLu/iFCQemcLSyia/jak8qgKt/L/G+UxGT0pbvoJv5loGIn1ivkh0nSFvriP/+fRewJTeNn82BI5VXSBUvpIfxPTgdewiQdV/uVuvmaQUWoGQaQlAAwTiJnwim8enKITTMia5K8Y8XCXQYRLwY8E0pGb9tke6erm1ffjThV+NoyWPiDaGQuCXE2FGufm4zeQ0dQK/KGAmUjeg+Qz+BNrD5/wKoOGn3TBgy4rqm8xechYaZOQfQPtj/6D3C7hb3gXFx/ygRUIdceEbA8YCtFlbvR77ep/3l3wBONPT6ArbF8ONjPQ3mpJ3cKhS45XNtfd4vGEZC4/OAZYiCwYQ0PFR2HoXN6aOBSyTgoRQ4vGPp5HOWrb1VwPnMNntC27renp7+aCoxsDT4HTlE4m7NZYS10+c04angizKW0d4PNiPnMxHbTgZHvcwP6SCTPVqdNrYM0v+G6UvxtLhfyKu5g3KxYszZG8KHVyiI+fkhN5PU5Z8guqoT7b7bZL5XRsuJc+DxbF3A0PLhe46HvqxDje7vMFqkRYZnS8YK5zvLoKtcfUcp6d7rBSo6wNpNeBL+Z//6PSuGzw3d0pjH6Seyp5wxRChY9vNVV6nIj3QZ09JVqpQKHQjcp8ehwvqb5loPgS7IkT3f0mOv4FFb6c+1krhE96sFaKs328eePEsGqI3+hRIej3OraPaaDXYMqwg7ta0kBojN5Ef7lNrSiaYUL4pWVmThU X-Forefront-PRVS: 0354B4BED2 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BLUPR03MB469; 23:2v5jZZ0aGuTW61NCj8KAAPHA7Fl8QZ+qXR1iqu8lOm?= LtV/nmVJWJRAjBwQlnfRXebIbABl3YBpEeQB3d5v43wSOyS0cvj+EFQDB5oT7wen1ZDmOJ6xbF+zNFYXts5BxC8gFW6IB8MIJ62BcHhF4dTuGDsjd9kLUz01yh4+Jgb0SyRq3XSUOetal4b8qOHGKK/XGu9Dw6sEL45psxcJqC0BDLLFhWnMCPRRf09mBHB5CtghDJvpexoNMs7F5GbCVMNChDpmtxaTDMXX27GhnBLs9rKzy59A21LZeIozZeEjQ9KOu0zacufXwvipcNk6oxpyRMbWSICYDjcFDoZsKdPI1Oel7p7P+2hXcEy2c99EuGhGwlIm7+gFiiKtAWhePhpsbCijee8P+tU9GC1mylB283WmCTBBaF06Vsi/4mtiq55NYRgEOFWdIqatLWFgrTrflqgkBAOHXX9bGWqcmbZK/v4me2Jiv3WAeRx0tJ0NnpzcPq1GOZuFZOeKiR3KhKuGhUwYdNh0+GOaRAmG5Po18q0pOR8yej3EifwVYWtE3RXJIPRpzbLnBcwD80FPlzMrOcPasn81olG/R8bFYMmamPgjnKLEcNqXtK2qRkpQucncFvEV90IXVmBgszT0M+tljlEViHlia4xHLhc7ioR8R9JF1nCTfrkhM3m45O4Cy2vsZ4+xJWaqw8GviypaFoMUlrKLVEGQFu26WCmEewpR3vDGJl9DYSVSX4VlOhU1mcK0CDFiW7aI599WzpxcvS4+LUHt72FDRADUEUFTboVH5yQhVeIU18PGYNxe45zGGtYHLR/380m7fJinPoZEFGEfkEFlum2e/IGUp5U9U1ZoCuDstTd9AMs+kpf8BjucdXQ1/Mo+cOlUaB/aKmmbPDY/94saICLmXfIvB+yr3bWSzZ0Kqy32vJu7tvOF1oX2wXWAJlgmKVHR0/WTnsKZZW5ZKSa3Fb5+V7pwX0/kBAxqrldYq9DQX9iUUHHI+ybfpOtFsf52x/HYXvhFocBRqyGRudoDZ8dOQrOvW36DohWowYdnmImnSS9kNDHlmXRydKfybx6d6RQMT/DKbkpMyIDd5HE8EtnSDK3ELa/HrH+r0Yyrq/tVvvnqfmwOIFk1A6c4YgIoCjIekBv6grHJHZ9cWyjb+5hdV/zQOQvm6wxtZgWgRQi1m7AQOURUXX0GDzUhZEhcOM1GXyF1fso6q8cpSkm8hAt85U/h6ACKR11XpQrRWR2Lf+PiHKQ9Ntqi+McHi86p7Qr/5PVjnpoUUjCd18OB9+eF8T030T2uh8ku6RLgV+jBNEz6sm0oGEA0E= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BLUPR03MB469; 6:Pi07T3IyOnuFpNVU01hzrOYKBp6dmet2ymOqUpVxlWl?= 6kO4tYoSYXbjZy6KbH0KWxXuI0nTirpWrk+PJYdxl4TtWmuxv8JuHO0uA0ssFhSYPq7xOgWm1zDKO680hmGghk/4xCumNBdrGIBHy152K9Mu4t/+Us4y2C81Yuo5zsXQ2MAz3QavXo+TGH+20+pgZcvzMW8mA+U05q0p08q5MgkUkkfm1x+B5vP6Bm4Dn0GDDGdQi37YO4vs6rftdxd5M85GItnWqLvS+tX1p4cUT/Eo45fByWPX4yqscWqZhPrmb1VHrKs+VSuDMw0P9yOWAbiS3GE3ksJGFciK0+pIVHhzwCNMdEMOJ3vdlbwJB3+JJRIrgfBBZLPb5+KukzS99KX0nNLUKfwyN0lDvZftW0ym2BbQOgULoqt0H+wpAAfjJj8L3EI0IZiOy250p2fJyBOZ1iNbSLuQaLvMMvo8gdrma3mh6bIpEzA4tnPcdBnf9kWXOaSiKOOGwBYdHzI50vkpQpLFbNO9fcsKHczRCOdbViH/M7n1c9GWDvdgiKDnCTFziP34Vb7iajq0BK7In4LVOSsHn18b01d+pQJTIwxwFz3XPQzBJfazliiVatjrznme/Jv+PcqBjIdbjHctG6+f1pdqA3cgrDYI6DAsbp7bFO+1Aj4zcUmdWxTCjTsm2KUWHebw+eDvMsEx3rMvZmG6NZfGbOVtxJ4MiNTXRtAJwPlQRFz8+a23zc8Sg9jZB2ZrgsUXZvZP+yPWjYJyY2dFbQ0S8XqDuZ8RSBaJFtUc1muo6Tfurj37G0LFobN6tyEpo8TsKUwoFUo/BRHDev0D9yFnu32faZtW54W9pn0mF2viwRYrE0PN0qTrULAY2Ne2vYW5xpXVOeleRjloZMYx0h5AxvfhJ0+6B5BLuo3kfJGor3/RDuRQJtM1Aw/TZN2ftfzO5xWGKvaFveCmh6OGphQeZIEAZ8i2Tg7zOgQ== X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB469; 5:CeTDV2xlL3erOWoAEY8UFu+Da50BLsD/SSm2yC3avtZXJYBxX2t7gXxuXU0L1Zkl9cTuzU15tu25/GwFfrsIa3efWhB5XW5Gv0Y4xSQqIg6+VWrUJgmu5dU+x7eXdYF83NPlHeu20eEv/QIMfpO2VK0xsBWjJzExIBNghG0lyWd15zyIufEdO1hBWTr3ctEBqMPn/tqIV58lgTJ2tjunISIb1WI1ww8LcrdcnTIXWNhDOwWpbRj0TENQUQ5owUYN3zrLcD6SfgSq4nZtpHDIG66iV+Dql4FeKC03mtcoR5mBTqsiczSXRC0ayI298fJvw19K45RysyZsUVqKIl1GyZqKPMAUJyytYUPj7XvZii+SAU0p+fPfExaXJPuI0Kj6g6tzRB3Zt9NgxiPHzOhfSHSxJDQEPR5qIHIKzJHBRx2clmCK2Oeb7ZJbY5Qif8P9jgJSKss62VLWba/DMuKfIvzI7QgHSPM6SGFWZ1FAUJ6PDehHAPmbHGqCne9ZKZvWpidt1UEJShV1rQ6pyXBXdg==; 24:aVA78HUY7mwB1Z2xCCqhEn2jOnbCHI+dI4RWheQzz5QIZ9PBlQ3WkryEPYkKB8jXkTqfvppTRwibTvAQpHEadlIr+RTCffncQiFRa584k0o= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB469; 7:NJ2kLm8u5E+wsqLpLqja0pboBm+aFWs1dHL/h1HvP0abdFq66tmB3ZgF58luuK8TFGGnCHaHHbUN6ZOzBPI48d36SvWFMIu6rt1y4mrJlr3nn4GuYAEHGts3d0ZAOSHEd14HbTNIRUhu2s2RLAGmmUQkGTzYFO9N1CZHLQ9ZEHmOeIOHy8glAdsAGghxYEpXA/YAGVThwSfQjuDijLwcPyXUo0YDoDJrCV2LTBB2IO2SPc5O1yZ1I84kr9Hn8/hrZ/cGLGgUeNdWmwC7Yyj7OM6OH0XbsjiX3x7ER49eqLgdTDu39AXH0XoYnq1qLXxD5VaLBmkt/cOGyCEReDtwqrQyWttrWg8eX+XepMRSiRXGIXJAQoonM5fDu8fVFCK3Ong9mhCdxtCJa44FkPUibyg/XPRdvyvhgQD6ZUdt8IYzOc5mk23Gb1SatYdMWsARf3psfPEoD39srHwbjyGF+XyC0w+xqHqp7QonUCdaRbbZgCQ+H9HqiAx4+U9qZLJE4eUzaS86nUc5I8o479UNWMJG8FNtPjeopA4XwuNhWjTx4dXFQRicCaQWloaWxYiklv1XMg2iH70mzgQLsrBSVeG4pKOEQXUgfi6cKscrLGowW9DxmFHqjeKD38XkC3ahJPXh9V7zCzPbCGPUu+R96AGpKqBZ0qWL6rlGsWxcw1+QkQrH1auDfuqfjXIh8RnpzuF1z5KZKgSG+pBV8Q1VBS3Un/u18bJi4g+pA2Rqd1PyOA6T0TMd20oBfIOhRI1mJdIkAWF3Av5fTBrHUM+dDJezxbmZ+30gbzDTk7322ak= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 30 Jun 2017 07:44:45.7151 (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: BLUPR03MB469 Subject: [dpdk-dev] [PATCH v2 4/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 --- doc/guides/cryptodevs/dpaa2_sec.rst | 9 +- doc/guides/cryptodevs/features/dpaa2_sec.ini | 8 +- doc/guides/rel_notes/release_17_08.rst | 4 + drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c | 316 +++++++++++++++++++++++++-- drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h | 98 ++++++--- 5 files changed, 379 insertions(+), 56 deletions(-) diff --git a/doc/guides/cryptodevs/dpaa2_sec.rst b/doc/guides/cryptodevs/dpaa2_sec.rst index becb910..1444a91 100644 --- a/doc/guides/cryptodevs/dpaa2_sec.rst +++ b/doc/guides/cryptodevs/dpaa2_sec.rst @@ -126,7 +126,7 @@ fits in the DPAA2 Bus model Features -------- -The DPAA2 PMD has support for: +The DPAA2_SEC PMD has support for: Cipher algorithms: @@ -134,6 +134,9 @@ Cipher algorithms: * ``RTE_CRYPTO_CIPHER_AES128_CBC`` * ``RTE_CRYPTO_CIPHER_AES192_CBC`` * ``RTE_CRYPTO_CIPHER_AES256_CBC`` +* ``RTE_CRYPTO_CIPHER_AES128_CTR`` +* ``RTE_CRYPTO_CIPHER_AES192_CTR`` +* ``RTE_CRYPTO_CIPHER_AES256_CTR`` Hash algorithms: @@ -144,6 +147,10 @@ Hash algorithms: * ``RTE_CRYPTO_AUTH_SHA512_HMAC`` * ``RTE_CRYPTO_AUTH_MD5_HMAC`` +AEAD algorithms: + +* ``RTE_CRYPTO_AEAD_AES_GCM`` + Supported DPAA2 SoCs -------------------- diff --git a/doc/guides/cryptodevs/features/dpaa2_sec.ini b/doc/guides/cryptodevs/features/dpaa2_sec.ini index db0ea4f..c3bb3dd 100644 --- a/doc/guides/cryptodevs/features/dpaa2_sec.ini +++ b/doc/guides/cryptodevs/features/dpaa2_sec.ini @@ -15,6 +15,9 @@ HW Accelerated = Y AES CBC (128) = Y AES CBC (192) = Y AES CBC (256) = Y +AES CTR (128) = Y +AES CTR (192) = Y +AES CTR (256) = Y 3DES CBC = Y ; @@ -29,6 +32,9 @@ SHA384 HMAC = Y SHA512 HMAC = Y ; -; Supported AEAD algorithms of the 'openssl' crypto driver. +; Supported AEAD algorithms of the 'dpaa2_sec' crypto driver. ; [AEAD] +AES GCM (128) = Y +AES GCM (192) = Y +AES GCM (256) = Y diff --git a/doc/guides/rel_notes/release_17_08.rst b/doc/guides/rel_notes/release_17_08.rst index d29b203..c21e878 100644 --- a/doc/guides/rel_notes/release_17_08.rst +++ b/doc/guides/rel_notes/release_17_08.rst @@ -81,6 +81,10 @@ New Features necessary to use a combination of cipher and authentication structures anymore. +* **Updated dpaa2_sec crypto PMD.** + + Added support for AES-GCM and AES-CTR + Resolved Issues --------------- diff --git a/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c b/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c index dbdaf46..b1eede9 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,149 @@ 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 +557,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 +915,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 +961,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 +994,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 +1030,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 +1127,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 +1139,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 +1157,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 +1339,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 +1409,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 +1466,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 +1485,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 +1527,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 +1569,7 @@ dpaa2_sec_dev_configure(struct rte_cryptodev *dev __rte_unused, { PMD_INIT_FUNC_TRACE(); - return -ENOTSUP; + return 0; } static int @@ -1626,7 +1895,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 +1923,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 = {