From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM03-DM3-obe.outbound.protection.outlook.com (mail-dm3nam03on0071.outbound.protection.outlook.com [104.47.41.71]) by dpdk.org (Postfix) with ESMTP id 794027CC4 for ; Tue, 4 Jul 2017 16:35:41 +0200 (CEST) Received: from BN3PR03CA0112.namprd03.prod.outlook.com (2603:10b6:400:4::30) by DM2PR03MB480.namprd03.prod.outlook.com (2a01:111:e400:2420::26) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1199.15; Tue, 4 Jul 2017 14:35:39 +0000 Received: from BN1BFFO11FD047.protection.gbl (2a01:111:f400:7c10::1:161) by BN3PR03CA0112.outlook.office365.com (2603:10b6:400:4::30) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1220.11 via Frontend Transport; Tue, 4 Jul 2017 14:35:38 +0000 Authentication-Results: spf=fail (sender IP is 192.88.158.2) 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.158.2 as permitted sender) receiver=protection.outlook.com; client-ip=192.88.158.2; helo=az84smr01.freescale.net; Received: from az84smr01.freescale.net (192.88.158.2) 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.1199.9 via Frontend Transport; Tue, 4 Jul 2017 14:35:38 +0000 Received: from Tophie.ap.freescale.net ([10.232.14.39]) by az84smr01.freescale.net (8.14.3/8.14.0) with ESMTP id v64EZM6o016426; Tue, 4 Jul 2017 07:35:36 -0700 From: Shreyansh Jain To: CC: , Date: Tue, 4 Jul 2017 20:13:57 +0530 Message-ID: <1499179471-19145-7-git-send-email-shreyansh.jain@nxp.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1499179471-19145-1-git-send-email-shreyansh.jain@nxp.com> References: <1497591668-3320-1-git-send-email-shreyansh.jain@nxp.com> <1499179471-19145-1-git-send-email-shreyansh.jain@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131436525388931708; (91ab9b29-cfa4-454e-5278-08d120cd25b8); () X-Forefront-Antispam-Report: CIP:192.88.158.2; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(336005)(39450400003)(39850400002)(39400400002)(39410400002)(39860400002)(39380400002)(39840400002)(2980300002)(1110001)(1109001)(339900001)(199003)(189002)(9170700003)(105606002)(48376002)(50466002)(626005)(104016004)(68736007)(4326008)(47776003)(5003940100001)(33646002)(2906002)(2351001)(85426001)(498600001)(106466001)(305945005)(5660300001)(50226002)(81166006)(53936002)(69596002)(189998001)(53946003)(8676002)(356003)(86362001)(8936002)(575784001)(54906002)(77096006)(8656002)(50986999)(110136004)(38730400002)(36756003)(6666003)(76176999)(2950100002)(6916009)(2004002); DIR:OUT; SFP:1101; SCL:1; SRVR:DM2PR03MB480; H:az84smr01.freescale.net; FPR:; SPF:Fail; MLV:ovrnspm; A:1; MX:1; PTR:InfoDomainNonexistent; LANG:en; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BN1BFFO11FD047; 1:LAxEK04B0wpiGWOoCBBPnjrSZHsKPrC6O2ud7h2gl?= =?us-ascii?Q?6FDoPOO/OOP/3meUQwQLbMMisgk5pG+cHbvadrS6chgPK1fGJMtBMzOB8s9Y?= =?us-ascii?Q?S8WaE+cN3j2NJh0dmXgcFQ8/SV+p5jB2IZBAOQOOYDpXvZzBQrKd2aFIcJsb?= =?us-ascii?Q?3v2HoX1wXWttKMQVrulvJUGFtSgTMQsr7Ulpp7cQMUApV0WrYgVhoXpNgees?= =?us-ascii?Q?MmNolO/U3tniGxjrNLnCXKwSro0IIqVwmnsxx6iMwP2qnER9Ukc4oBIlGkCo?= =?us-ascii?Q?8GtiDFJfMUNxWSKqQmuo9V20H5QImzP1Z3TUlJ1cYmSwMf+TCEYj5h1ijahP?= =?us-ascii?Q?j0Lh5TN2xvbVyJccX/nztCjBX453ebIHfgXsPgGFfqSbWCYCEQ94Uh8J+9Yx?= =?us-ascii?Q?GvZ8mqs2Lsgkd9H4lHiDiJegtuEbesWFBpASVMDye62zk66DlsaZPi60j60E?= =?us-ascii?Q?IM+vDZWE7Lb6QatiAv/qGm2yI+DwjVhcxFs1ZDrYzs8B1DyyWX81DLgsZau1?= =?us-ascii?Q?hpd+0I0mkLxLLHcvI+gSQR9Zsc0+UrODjiGY5Yco8gHh3u8Z71VM40z/+1WQ?= =?us-ascii?Q?szK/D2/klet2OW245Zfze3+lf4A0cD405xuAxzQTK0IiRXMI0L/sFN4nWcYc?= =?us-ascii?Q?1zigVPfMG6owCCY4siuBMICDMnoibyGbM1GhKTJ/J6TbzDkQpEcgeg7ivyEv?= =?us-ascii?Q?8MZ0DsLE+SFxgn/oNN/YOepZCHCSxLhdVJ9KokiD2Al2cOPHphH5tujTLn85?= =?us-ascii?Q?n+RirIB2rw4YIo7FQgT05pRoMjtdVje6rDOddmSlbndq/QtfivvZ319T85op?= =?us-ascii?Q?P5YiQPHsmyOqrD0DDNYdyQP2/idCUJhDgktjM/60gCylmRM6+BfETQBWUbWT?= =?us-ascii?Q?vrHaRqvbAU/kme1A/jcH2qL6LVZlvdWMJEmr3RQwhwkMBmEeckDpjg62NFzT?= =?us-ascii?Q?jGapUaC8TmSuSDLMGh8rZE9PJ6vi8SylCV2RCMNYh0D1eU30doVwCZd4cHit?= =?us-ascii?Q?Jw06jVrypJNh1uSTk0/NzDjIuXcIKIP+7LTI7wr57GeM25vjM6eYvckhF30d?= =?us-ascii?Q?4QUA/tImjjJNqtXe1+jDTr2yyeaZJTHXlneXjKZ+7FhLSkmuw=3D=3D?= MIME-Version: 1.0 Content-Type: text/plain X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: db496780-8e83-43ec-411e-08d4c2e9f0c6 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:DM2PR03MB480; X-Microsoft-Exchange-Diagnostics: 1; DM2PR03MB480; 3:iXm5oyWds8ejYIMhJ0P+fuFu8L45j9rilc55h7XTkAvrBBzyqjGTEeXGJMBHrj9hVqxxgXHUd2RL577DqukB1l25/FtXLB15XUSXYeP8bw3RWC32Vi+EEZHXFMqCXl7Utep9Rgdr0rS1BitRf02L9uSXPfy/5g9Vcw7YhQ6D8MtaYqUYmucgphITcYQ4aYBO4kMLFx0vPaDA+GkQf55Sv4cOPb6gbYZYQSd5dXMCT2mSTzcNeVIVlNfbrlaJ76lqBXQXmVq8643QWngbDXaDNXliaLT+81gWjO42uBdnLINyuREUBxTpOMy7CZkY+PngppU96KtLl9dwwzP7Tn+45rZZeNla63eTE+3lrSgR6czHIypFlyYC1mHSHs4h0BWzH1Rd/iiX/qVRgtJ3L/qFoYl19KlQTIae2Dkn71y64RGimtGlW8tO3rQJrA3lhUsOOd4acDcO61kdliJFk+ChN/kN6QELqysOF+/ore6kpfu9wteRPKUhVceLxTfLkWgDGpJWXW2TxekBGvYTnBgFy01UtokCXxylQ2GK46CLJ0LiQp8QKGI8jrkWb5r2Hf8N5xOUhQbkOJ2Yfw5TcVjqUM2FK4tI044Rd0FP5BIuQt+oVWh8rmupE9Ehz/jusndJPl56DttPVLKuCMYQsHRnq+P4qpy8z2de5gpKRky3/Ku99LTpKvW7Lt9Sc/tq/EaZCYvj20+BxJqiHIK173EMN0zaimrt8WAks8zSFCXYBZPlzHePKKP6Gp8SG3B8Uu6L0CUC5Xz1WlgOtQA79yaN1xMCEbEdOiHzBLXnm7Bet5nwXlhC4uJrsSZHIMzLFdUUv5C/6uDYB38WCqj/rF7V8sJguYbmuyUcGRAiLEft7RF8N/oItLaw5NJ1u88kBgxd X-MS-TrafficTypeDiagnostic: DM2PR03MB480: X-Microsoft-Exchange-Diagnostics: 1; DM2PR03MB480; 25:StIyFT1n9cmvQBznPgyVlDfP+LWRuTfznbUIKxUosHUKjuAOa8sDgibxBCEjCO61Pos6/ByqvMJVDClmnl4KPiPzUi36cZuk71t8GDKrpRMcqyXWDOvSiEaFus8sMZJHtMPJoGDqtM/spJGYtSoB7sqxV4bqdxfk30LbM5U2uFmLvb+d+ZUv0QiodJLsfitsHzDpCAKknDMQ0RByZOqD/5QFpOOaBq5s1qrPp7KL3V4jIHvBMc4sKu7P1B8VBrG/LkwsOTPr2+EINrBsSGg4FM8tdjaB/uUS/CqGTWSk7HeZ1ubspBZ2Cxdp5lVifcVzUrqzVhtKTIQbj45ksC5fN1L6/aaXGRLs5HGjqpPj5QFq3tfpLJoVQAjRhzChtBPzT6lWGBds5XhP6M4+dp2i89HK5KxmqqVtTp2mjFQcIt3vk5OsKnG3NKSWpm8h+mrjFTBcLhKLPZN02SdreumxeLJkumLHa1wMwIqYwzK+T5mwNkE+ghyzeXErn/whLjCGbUgxlCQmIksilPlpHBe4oMwGbqJ/hSWFSkNZR2FljyqGIpwrdOtmZgL/rsUZ2JsPXdV8oksv3APDfhnrF+mI1Lv/OjXD3S5qpxU3gorSd9kt7Iz2aEsLDge/24GoPw2Ba/7waI5qIPbOsG4r1WdzkfnWBoLCA5RihseW62KWd79yYTGaz/K/ISCBlhY6iH33uGSZgyova/zMEqxm0BnNxUgAO0xJjLLIGgtgSm6b/4rigb6oXAiTsBSmqOctuBxTj6JJeyxUUyEawGK5owCwvFzAHIiLwyYBDx+azYo/pzJhxrXyGVDQ+kuGIgBig8HfdfxuIF3TVBg+/3PlvU94uofXq6H6qjqacPMAA69LzXYmLcGxvOx+Yh9QJxOQJ+0Oiqq1Fvv7VAvhNFdRhJ3ytXMBIR+dsidN+OamqYWY/MA= X-Microsoft-Exchange-Diagnostics: 1; DM2PR03MB480; 31:HL20dznreBdlCXn+pLgk+/SwV+HdcZPezVf0Cb/gsHRNB1B6xkhqjUl33QB9G0WKXpwSk6sDU/ayhPthtWT0biA/mFjMw0tDCCCzA+RmLnrcrAhessi20YeXTVjf6YeRVBAjhYAFmHZuN4UVS6yDGH4GdWS6I2KyHyL14UxU1gpf6fRagSgxwiCtF9Eu4L0JWALg4mHQgoFEWeIV7y4qmZDGNkR1Ivj9j5oWp8NhVsB8X0MnbqO4dXiT/igx4a/woDPo3uhmrtZgSPBiQS5WciQGqJDZJcLUc4DoC2Zhf6izYJJqAfQQaiPmaONvt1k4IWKghUOru33375i7jUb7UkQ5vnqZszIR13ZPdIni7+cDGTTPLkcmfMthAc7L9v0K1l5es4FtTYs1mZJRxO58j9rRvh1+cavMlpn/byGFFE07r6Di/qG553lwuhbJ3oZ+mLOslIn1wx2fjKuqV4U4EQspM44hRAEVabKRGH9u6kRwHR3pJgEctfIsDZKUrfQZmE3Z/1ifcu1sV8FnmjC1DDzaunY0Ow0Tt6sita/TYoMqdmRP5iinwMaG6AdvAezzK0VrJQe9WNVl5f04cgTqP+yUB7qrhfM0MEKK2WyiCT2TBWM0OHFwinTn71P+fpLaquNquAmqYDyl7f3da6quloR+90Hk65hunAgiK5cPv/WQKphTUywrcVyq75e/bYS6Ct9z0iBDyFSfenzrzJuPtg== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(236129657087228)(185117386973197)(48057245064654)(148574349560750)(158140799945019)(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)(10201501046)(3002001)(93006095)(93001095)(100000703101)(100105400095)(6055026)(6096035)(201703131430075)(201703131433075)(201703131441075)(201703131448075)(201703161259150)(20161123559100)(20161123565025)(20161123561025)(20161123563025)(20161123556025)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:DM2PR03MB480; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(400006)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:DM2PR03MB480; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM2PR03MB480; 4:IySPYeAISvwyOYNAQ+X2NQkwsa+g/hJ1n+No8iW+Irg?= =?us-ascii?Q?Sbq3rbLyEiHf1JU3tY2cmi4+pl90zJwlywTUZSUfrTfYBTq0VCCWkPjvPxAw?= =?us-ascii?Q?wG0O/dtP8Arov8l1ji9v7zRuoxUb3X2dne6FJvFzS3EXCXqy+2aKGyKGY/Es?= =?us-ascii?Q?ZperZZTqC704AR+dD/6SukroTcFgObc+3lA0DHIfVa/gytweQGgj3ts8X40R?= =?us-ascii?Q?1ajmkOt6RfGfN86TgGMJjtPu2flYJm3OQhf2zBAtxIPpsctt39KqDZA95Kjn?= =?us-ascii?Q?XeQQa94Y9TbtUVC0doUFpDOAEkG8AFqmU4L/pVL1RkkUZdD4drQWD1MQWD6K?= =?us-ascii?Q?oGfadEBl+uEGeR8E3Yn7nrOD745z+eRFE8ZE7sDBMmJuKKEAq85SdP6GBH5G?= =?us-ascii?Q?CsJIdE+xphLlU8/7vNW2FmDb8pmuhuLR6iaFoHtWz/B5oh+0EEWkHzEIbV+s?= =?us-ascii?Q?3Ow5/6D54N4NpZDNlZZLG5EIg9PFWQXFRy0oInp1dYX1FtjF6q97gYYqtsKY?= =?us-ascii?Q?+a566Xon1uIIOj9uWIKhM47JXslDy3nuBRL6/0tG37jDvwg1iZnl96AGstGg?= =?us-ascii?Q?FyFQz10Yy01XIoVgppda30A7cUrLvRNDQSDKN6c/13dznIRR6cwDFn+X1VfS?= =?us-ascii?Q?KnSOE1sPlTmNRBtNuPz60+sS9/XMffLq0o+Axeytfxg6iyg5zOeecql/I3uQ?= =?us-ascii?Q?R0QYSG6zjdDze2W6H7vLNnhs8LwHSkaeN3CaCg3xLLYLqqL+9JmAl8KmFLjY?= =?us-ascii?Q?xhRxGUUbVSbNQmbBzCL7N7ztaDv4byzK0buLbUjxkrrB3qAOGDStiempIq+W?= =?us-ascii?Q?teJodTtNHcNpTBCvaq1B8n/4igufQfkAe/H/+mKNperfYmNDFvfUqx+Im9WT?= =?us-ascii?Q?/sG67DCxTHGw+s1PelmX9aShFVN/2r1yd2axwZId2mlecYuHaxmpf0dQpVCK?= =?us-ascii?Q?ScrNXGCl1mvbCCtp4S4ymRMnzFHXn9aXoQSsfdzG05rsO84yST3oHX4ZCY9j?= =?us-ascii?Q?uWmqQLpEZpwiqsXyEg9hUOO+c+JF8yBTqRDJewpDJ1OsUVxYKs18pS66FLUF?= =?us-ascii?Q?XVXbK1SY+DL2trbi8vjEvBdv2CzmFHpQSwVrioSEhSIiAeSYmti7qyQo006Y?= =?us-ascii?Q?LK+N1DiWJnzEQdi29CBdrtKFn60wdp3pWP/VENOAcqFMZrJn+Txs2DD9Lk+M?= =?us-ascii?Q?DQvLMDNKi/+PqbtrMV+MRp7ioEjr7VILhj/yLku1cNtAaJqjwryv4DgKlDPN?= =?us-ascii?Q?bTLGPZRAwGvtJSISqDtKACKUwaXQAsWdEuTaWUSE6CVvt5BhPgdNHSmUUdvD?= =?us-ascii?Q?LZowkreiZhd8RAFSfZ+D6TSFSytPBn4pAaxUzgR6pTjUW0oVj/BIdTQbQ5xt?= =?us-ascii?Q?uSu5K02VZvbGes8Cur2YkvGrMrSrg4Z4/1bUE3FnaCXvo9jVa+CxVEzGmnBw?= =?us-ascii?Q?f+Odv/oA+LGKS4Zttem+7vvwnEiA=3D?= X-Forefront-PRVS: 0358535363 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM2PR03MB480; 23:aGyNDXlP0oTc+jeA6IymGd4dlCwtMg0IIwb71tcKqy?= =?us-ascii?Q?Xp6DbQl5XRC2WcLz70xQo+EtH1sU1Oiz8b40UPBcyQka224q+D1z/JCC9nQZ?= =?us-ascii?Q?pekRgJ49FMem+KkwdmiACUgN2i2KWnJQ5Ocpe99FpQR53ZueiNJaGX5DfmOq?= =?us-ascii?Q?wOnRkwztyDNIluqd+7H5ic57KTGCZMnIvgb6N6y/hwVEiVWTrJB0g6wk5f4z?= =?us-ascii?Q?PZcPdZweoC+LmJMIo24pj9decweaa7xbKJ/G1/LCjXL6Ec9Q7ndn2vCJfKwW?= =?us-ascii?Q?OjoPuav7BACiKXmLGz2CbJpJxGyeJKi62gfgd6upsyFx6K1M8Wj6lejXKJG+?= =?us-ascii?Q?DBouvC++Jrvc2KYjsH/Vty4a0pEmJtd6mQ2EgVV+MTa8vtsihqQ4faWz2ldy?= =?us-ascii?Q?T0n/wTArJBGBHCaxHmsgtSeUhq/YfxgTZpW/rjllGOMjYfWrDSZMXynaaAaU?= =?us-ascii?Q?sb4ebTDSor/5nBS+j1KFi0NCmsA8tNAZVgUMCjhIUo8bxpNm7+SLb+tn+bCY?= =?us-ascii?Q?McNhwCzTjh/8dnqlOlsRn+8jzrIcJn4wRg2P4KPmC2fr7+j2fEUoSXQQd4kk?= =?us-ascii?Q?ToDaMaGhC+UaUacDLreoi8pz+q19G0D08zrzQp7hAqnIkLEZkedRUdyAUPb/?= =?us-ascii?Q?eSWx7yzLfzsMtKSalJGWY1/tKDkG1BgFKaPPUKfA1tgFZzXshd2g+R2BuEg4?= =?us-ascii?Q?lKCLVclMtVXpGL33wSuPke0Iq5mSzXzyzqZxdGixMKLugRqoW0PhFgLAYxjX?= =?us-ascii?Q?jtUqtxAOtNtgHG3XXRia8+wG4oDY1UBycY0oyhdU5bOxc82UPE13Fw/nQhzk?= =?us-ascii?Q?/xhuwdYCHhtb3DPmSekRRsWyoiR+eEgbHp2LSdJaDgHpPMQ3JLFEE61tc85u?= =?us-ascii?Q?ucSsqKSEpXemNGUi8tA049xoCHSyNucY9BIX5vnBfRcQDo+LGvwyr33DPJ0q?= =?us-ascii?Q?hmfLEAuAJN2kXYAG8fxJ0spXd2P9CtrxSUT8B/DH2blLuAAmel1nWlrzoOqR?= =?us-ascii?Q?TIJ+nivG53dzano30xikLwBycYbAczY2bS3qtEVy1EHyWCjTisqw6zGJxRsd?= =?us-ascii?Q?ejy89U3hRetxd3Jd4TWsVXbz6D/Gh9pNnQ7tiSwyXQPiwc4OMtPM2bV8xRAg?= =?us-ascii?Q?/GQEfFTxMB5ehvgO+RpY57VdO6utwLlGZUfPHcqrROvvGpUXkSkeTDnvym8d?= =?us-ascii?Q?upfUVCFpwhwfsM0TOSOpwboeurN7mrsU/KyI0MLlctiFitz7wVudKC1Ksrvy?= =?us-ascii?Q?Y4Ly6ScMmDKexJlDbXZkTz6M9DZnS8gfDIJJ73wxEYfbDso6jM+6yp38bIbh?= =?us-ascii?Q?39puC2ndtZCzVLO4o5gMoAANx3iO3d7yhWVpdaBfsbn4u/d9sPgVYFqWgoTC?= =?us-ascii?Q?OjCA=3D=3D?= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM2PR03MB480; 6:/YeorMCfIOgU33fp8a7io3G64zc++w+SfAiHiABR1c/?= =?us-ascii?Q?a2jbnvzRSJCEaMv/OCJpo1LWm3aDPzOI6h+Ndngr65UMiIE9RheZNJ7w1R2X?= =?us-ascii?Q?xMbD2ev37Sf9URSyTGNzekxGXoxl2IEjCqO88MeuPd9NwrcnoP8WBCFjZLq9?= =?us-ascii?Q?L0vSF/yBbMJt9sY9yOMXWoRF8nkJ9zBs8yVWFrE5a7p9F0lZrQDJ6BwM3VmN?= =?us-ascii?Q?JllZqD2HXDEj1DwAS3TLiAhm8d4sKHrX9vIoETu0pMqOfP8RoLE5jEm1C8a3?= =?us-ascii?Q?TidaLAzH4pzccaqJU1SiTZUvwhVJRSS+UTW2b70Ebp6Nxvq0/dFB9qlfXdAA?= =?us-ascii?Q?JpNZ0eXBTll8rUVtq9qglYBUI78KXnjLNNE92Kcg1KQg72KSbtrdnGz/wlnW?= =?us-ascii?Q?82B8d9bm5+7aCGIP3526LNSDCnu+CQ+BSp0IrxeapZ0nmj7m3f49QiVGHZ1E?= =?us-ascii?Q?z/WBH/5K1aJIfSCGTbyr5unN7ksQ4ZlkXl2njB0Wh7Ps/01qd6MJraeN2IA5?= =?us-ascii?Q?k8MjWR3GC5EDDpbD1wl3Sj3joF1/e71nWLqJJdawvTOcLrdEiGawWJj7xWn2?= =?us-ascii?Q?S9Hmr1DEJ7OjAK/MKlbQP7PYDArIiWTwNcX7VYiYMkHynx7uJtcliLW/RzTU?= =?us-ascii?Q?/7Ja9v8A80eOmfqtD1UvwyZmEaemK/UmDzpZKD9nzbiibv3HgfAd9emLxhe7?= =?us-ascii?Q?aMc4ZttiYpMO33aQDVaJQYTcq1daFHr1cpX1doyCWNpaZt79btOaYxTmp5F4?= =?us-ascii?Q?VvIBkJ4FqR6WLS5B4QVeMpgs2D/a6ZDUIo58p0T/bCxDqoF4d5UN1kBE6/4p?= =?us-ascii?Q?h2m/O61xJ+nw9psXU++tBJw7QG72szaATSMTO13ySuJ3awYBr6geljp8sdDC?= =?us-ascii?Q?k8pI0WiflBM6mhkj+InWAB4cm78vlx0AAMTayU2Y1qWe22lAHmIahWm4eetn?= =?us-ascii?Q?KH6iAZYauFmPAmTE8PP2og7zD6SkaodH/E4Ocb1OUhX3yiDrZF/61ry8nkjc?= =?us-ascii?Q?=3D?= X-Microsoft-Exchange-Diagnostics: 1; DM2PR03MB480; 5:o4SfD50gcMP/HkFUgSHK/zGde0XADHhwbkFrbARl5wJ1wWFGm6wS9yVnyfNWdkCzTt1tNJI8pyr6aqAnrkDIoL0EA3PQr92kF4H1r8rZttCwk596jvgwq9t/elQ49M87AShEujoFndY8onst+nlxHmeZUnGRNvkQjIuvDkbwgr0CTF/mFSTgCj8RTMGwlHw9m55IYMpeROC7VS5ZZ4VZF+ikLiB0bvTtQfPmjFALq58p5Qa0ppOvyKY9ef1TTP2C49WZl+PJEWAjhAkNVqFAMgptYd9VVykyKq8heZhpqIZKUZAdGhu23mMOIgw0/+7U4A9ZYMfiFEu9FAHC+IbFgVm2O47BHMX+MUry+DlDzHOOnjF2OnpaAtc55gDNIniJZtjajq1PE4xLb7BvlqDkP4AZK8soeEBY7axWygtYifwvxXTPhw+jeJVtHLYKVeSRMEvIArTDaGmpdCCJdTNb6XSOevh7eDZKw5JuiT0yC0VZvYIvEGaeEz3IQQGXlzeuqPb/O/hBf+Fg9ibieEqZug==; 24:DBFCv4UHwmS2a9d2jLfn6fINP3Tk5T6HwudeAWq/txpjEr4sdwCmOxu/5FqUvuz8cu7BXP1k6pez8aQkr/B/FWiiuLAoSz0XLlRy5d4xNUc= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; DM2PR03MB480; 7:9OEDvslnYLVxoY2cR5SKoHUB1Ll4GH2luh+KVqPB6NJMXob3wUsdpEpbBNOsqML3Jww3rPvp2kAfiW86ROxr75fBNbLaYz7m7WlXAR0fiYPlB7tYL98Z9+UbaYOCUFdOB4+5SE+87oJqHwoyfZXjqyZw8YRLtFOS9xw24szYKVa5AKtM/ZzcJLU1Z8h7NYP8xERuiC8+JfZ47mLsY7E88svHZz7P/qJS8My6Uz5xvidC91/BOLgLURJB193Xnd29N4TBzWRttaYVOPaF86zSFpI4pCsT3ejHXS7GQy01BqavxXVI3O5yYV3FUIS4dsL9KG6kriXMkNVzdPcN00+Js1gEjFG/PbCJogBcgXVvIhCurKog1hsT/cTE/RlWdSLnxNihSn+o9AZUdgWJExhcaKsfRf4EsmfQRReI8tUDMrfS4O6oEIJpGNGOsAGMJcdpoquXbJGCg75vkAialn4l3RzKm4okCqUzFu3GWnmL2OIHOqrFK52nOFJr4hjmsRnSDRaME77WmwVPelHsfSymVopQyy2JmFFtUavDf3NL2mB+qwo1fGMeR/sRAykUJ5TD2jv/iPplOATK+NS5bGhDKF0xbCvbXN2X1zT1sUOSuK9IgJv4NFOQfGcK8se7rfFzi+OseX3o4QSGAN2FIMUduTWbM09eILJBJYiteseyKI9fIzfl/EzJj2b7kZqBsS+SSmU5GrBRRS40KejEyGcYBnCOdQOPAuF13hfSF7kPAvWXJYBXowUdMyCq1bPykLUmTcd2snlRL0Ud7nwIiNNCz3rdMnoR+0XMV3tbs7stNTU= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jul 2017 14:35:38.6435 (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.158.2]; Helo=[az84smr01.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM2PR03MB480 Subject: [dpdk-dev] [PATCH v2 06/40] bus/dpaa: add FMan hardware operations 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: Tue, 04 Jul 2017 14:35:42 -0000 Signed-off-by: Geoff Thorpe Signed-off-by: Hemant Agrawal Signed-off-by: Shreyansh Jain --- drivers/bus/dpaa/Makefile | 1 + drivers/bus/dpaa/base/fman/fman_hw.c | 606 ++++++++++++++++++++++++++++++ drivers/bus/dpaa/include/fman.h | 2 + drivers/bus/dpaa/include/fsl_fman.h | 182 +++++++++ drivers/bus/dpaa/include/fsl_fman_crc64.h | 263 +++++++++++++ 5 files changed, 1054 insertions(+) create mode 100644 drivers/bus/dpaa/base/fman/fman_hw.c create mode 100644 drivers/bus/dpaa/include/fsl_fman.h create mode 100644 drivers/bus/dpaa/include/fsl_fman_crc64.h diff --git a/drivers/bus/dpaa/Makefile b/drivers/bus/dpaa/Makefile index 49abdc7..94849b8 100644 --- a/drivers/bus/dpaa/Makefile +++ b/drivers/bus/dpaa/Makefile @@ -66,6 +66,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_DPAA_BUS) += \ SRCS-$(CONFIG_RTE_LIBRTE_DPAA_BUS) += \ base/fman/fman.c \ + base/fman/fman_hw.c \ base/fman/of.c \ base/fman/netcfg_layer.c diff --git a/drivers/bus/dpaa/base/fman/fman_hw.c b/drivers/bus/dpaa/base/fman/fman_hw.c new file mode 100644 index 0000000..77908ec --- /dev/null +++ b/drivers/bus/dpaa/base/fman/fman_hw.c @@ -0,0 +1,606 @@ +/*- + * BSD LICENSE + * + * Copyright 2017 NXP. + * + * 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 the above-listed copyright holders nor the + * names of any 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 HOLDERS 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. + */ + +#include +#include +#include +#include +/* This header declares things about Fman hardware itself (the format of status + * words and an inline implementation of CRC64). We include it only in order to + * instantiate the one global variable it depends on. + */ +#include +#include + +/* Instantiate the global variable that the inline CRC64 implementation (in + * ) depends on. + */ +DECLARE_FMAN_CRC64_TABLE(); + +#define ETH_ADDR_TO_UINT64(eth_addr) \ + (uint64_t)(((uint64_t)(eth_addr)[0] << 40) | \ + ((uint64_t)(eth_addr)[1] << 32) | \ + ((uint64_t)(eth_addr)[2] << 24) | \ + ((uint64_t)(eth_addr)[3] << 16) | \ + ((uint64_t)(eth_addr)[4] << 8) | \ + ((uint64_t)(eth_addr)[5])) + +void +fman_if_set_mcast_filter_table(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + void *hashtable_ctrl; + uint32_t i; + + hashtable_ctrl = &((struct memac_regs *)__if->ccsr_map)->hashtable_ctrl; + for (i = 0; i < 64; i++) + out_be32(hashtable_ctrl, i|HASH_CTRL_MCAST_EN); +} + +void +fman_if_reset_mcast_filter_table(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + void *hashtable_ctrl; + uint32_t i; + + hashtable_ctrl = &((struct memac_regs *)__if->ccsr_map)->hashtable_ctrl; + for (i = 0; i < 64; i++) + out_be32(hashtable_ctrl, i & ~HASH_CTRL_MCAST_EN); +} + +static +uint32_t get_mac_hash_code(uint64_t eth_addr) +{ + uint64_t mask1, mask2; + uint32_t xorVal = 0; + uint8_t i, j; + + for (i = 0; i < 6; i++) { + mask1 = eth_addr & (uint64_t)0x01; + eth_addr >>= 1; + + for (j = 0; j < 7; j++) { + mask2 = eth_addr & (uint64_t)0x01; + mask1 ^= mask2; + eth_addr >>= 1; + } + + xorVal |= (mask1 << (5 - i)); + } + + return xorVal; +} + +int +fman_memac_add_hash_mac_addr(struct fman_if *p, uint8_t *eth) +{ + uint64_t eth_addr; + void *hashtable_ctrl; + uint32_t hash; + + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + + eth_addr = ETH_ADDR_TO_UINT64(eth); + + if (!(eth_addr & GROUP_ADDRESS)) + return -1; + + hash = get_mac_hash_code(eth_addr) & HASH_CTRL_ADDR_MASK; + hash = hash | HASH_CTRL_MCAST_EN; + + hashtable_ctrl = &((struct memac_regs *)__if->ccsr_map)->hashtable_ctrl; + out_be32(hashtable_ctrl, hash); + + return 0; +} + +int +fman_memac_get_primary_mac_addr(struct fman_if *p, uint8_t *eth) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + void *mac_reg = + &((struct memac_regs *)__if->ccsr_map)->mac_addr0.mac_addr_l; + u32 val = in_be32(mac_reg); + + eth[0] = (val & 0x000000ff) >> 0; + eth[1] = (val & 0x0000ff00) >> 8; + eth[2] = (val & 0x00ff0000) >> 16; + eth[3] = (val & 0xff000000) >> 24; + + mac_reg = &((struct memac_regs *)__if->ccsr_map)->mac_addr0.mac_addr_u; + val = in_be32(mac_reg); + + eth[4] = (val & 0x000000ff) >> 0; + eth[5] = (val & 0x0000ff00) >> 8; + + return 0; +} + +static void +fman_memac_clear_mac_addr(struct fman_if *p, uint8_t addr_num) +{ + struct __fman_if *m = container_of(p, struct __fman_if, __if); + void *reg; + + if (addr_num) { + reg = &((struct memac_regs *)m->ccsr_map)-> + mac_addr[addr_num-1].mac_addr_l; + out_be32(reg, 0x0); + reg = &((struct memac_regs *)m->ccsr_map)-> + mac_addr[addr_num-1].mac_addr_u; + out_be32(reg, 0x0); + } else { + reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_l; + out_be32(reg, 0x0); + reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_u; + out_be32(reg, 0x0); + } +} + +static int +fman_memac_add_mac_addr(struct fman_if *p, uint8_t *eth, + uint8_t addr_num) +{ + struct __fman_if *m = container_of(p, struct __fman_if, __if); + + void *reg; + u32 val; + + memcpy(&m->__if.mac_addr, eth, ETHER_ADDR_LEN); + + if (addr_num) + reg = &((struct memac_regs *)m->ccsr_map)-> + mac_addr[addr_num-1].mac_addr_l; + else + reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_l; + + val = (m->__if.mac_addr.addr_bytes[0] | + (m->__if.mac_addr.addr_bytes[1] << 8) | + (m->__if.mac_addr.addr_bytes[2] << 16) | + (m->__if.mac_addr.addr_bytes[3] << 24)); + out_be32(reg, val); + + if (addr_num) + reg = &((struct memac_regs *)m->ccsr_map)-> + mac_addr[addr_num-1].mac_addr_u; + else + reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_u; + + val = ((m->__if.mac_addr.addr_bytes[4] << 0) | + (m->__if.mac_addr.addr_bytes[5] << 8)); + out_be32(reg, val); + + return 0; +} + + +static void +fman_memac_stats_get(struct fman_if *p, + struct rte_eth_stats *stats) +{ + struct __fman_if *m = container_of(p, struct __fman_if, __if); + struct memac_regs *regs = m->ccsr_map; + + /* read recved packet count */ + stats->ipackets = ((u64)in_be32(®s->rfrm_u)) << 32 | + in_be32(®s->rfrm_l); + stats->ibytes = ((u64)in_be32(®s->roct_u)) << 32 | + in_be32(®s->roct_l); + stats->ierrors = ((u64)in_be32(®s->rerr_u)) << 32 | + in_be32(®s->rerr_l); + + /* read xmited packet count */ + stats->opackets = ((u64)in_be32(®s->tfrm_u)) << 32 | + in_be32(®s->tfrm_l); + stats->obytes = ((u64)in_be32(®s->toct_u)) << 32 | + in_be32(®s->toct_l); + stats->oerrors = ((u64)in_be32(®s->terr_u)) << 32 | + in_be32(®s->terr_l); +} + +static void +fman_memac_reset_stat(struct fman_if *p) +{ + struct __fman_if *m = container_of(p, struct __fman_if, __if); + struct memac_regs *regs = m->ccsr_map; + uint32_t tmp; + + tmp = in_be32(®s->statn_config); + + tmp |= STATS_CFG_CLR; + + out_be32(®s->statn_config, tmp); + + while (in_be32(®s->statn_config) & STATS_CFG_CLR) + ; +} + +int +fm_mac_add_exact_match_mac_addr(struct fman_if *p, uint8_t *eth, + uint8_t addr_num) +{ + assert(fman_ccsr_map_fd != -1); + + return fman_memac_add_mac_addr(p, eth, addr_num); +} + +int +fm_mac_rem_exact_match_mac_addr(struct fman_if *p, int8_t addr_num) +{ + assert(fman_ccsr_map_fd != -1); + + fman_memac_clear_mac_addr(p, addr_num); + return 0; +} + +int +fm_mac_config(struct fman_if *p, uint8_t *eth) +{ + assert(fman_ccsr_map_fd != -1); + + return fman_memac_get_primary_mac_addr(p, eth); +} + +void +fm_mac_set_rx_ignore_pause_frames(struct fman_if *p, bool enable) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + u32 value = 0; + void *cmdcfg; + + assert(fman_ccsr_map_fd != -1); + + /* Set Rx Ignore Pause Frames */ + cmdcfg = &((struct memac_regs *)__if->ccsr_map)->command_config; + if (enable) + value = in_be32(cmdcfg) | CMD_CFG_PAUSE_IGNORE; + else + value = in_be32(cmdcfg) & ~CMD_CFG_PAUSE_IGNORE; + + out_be32(cmdcfg, value); +} + +void +fm_mac_config_loopback(struct fman_if *p, bool enable) +{ + if (enable) + /* Enable loopback mode */ + fman_if_loopback_enable(p); + else + /* Disable loopback mode */ + fman_if_loopback_disable(p); +} + +void +fm_mac_conf_max_frame_len(struct fman_if *p, + unsigned int max_frame_len) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + unsigned int *maxfrm; + + assert(fman_ccsr_map_fd != -1); + + /* Set Max frame length */ + maxfrm = &((struct memac_regs *)__if->ccsr_map)->maxfrm; + out_be32(maxfrm, (MAXFRM_RX_MASK & max_frame_len)); +} + +void +fman_if_stats_get(struct fman_if *p, struct rte_eth_stats *stats) +{ + fman_memac_stats_get(p, stats); +} + +void +fman_if_stats_reset(struct fman_if *p) +{ + fman_memac_reset_stat(p); +} + +void +fm_mac_set_promiscuous(struct fman_if *p) +{ + fman_if_promiscuous_enable(p); +} + +void +fman_if_promiscuous_enable(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + void *cmdcfg; + + assert(fman_ccsr_map_fd != -1); + + /* Enable Rx promiscuous mode */ + cmdcfg = &((struct memac_regs *)__if->ccsr_map)->command_config; + out_be32(cmdcfg, in_be32(cmdcfg) | CMD_CFG_PROMIS_EN); +} + +void +fman_if_promiscuous_disable(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + void *cmdcfg; + + assert(fman_ccsr_map_fd != -1); + + /* Disable Rx promiscuous mode */ + cmdcfg = &((struct memac_regs *)__if->ccsr_map)->command_config; + out_be32(cmdcfg, in_be32(cmdcfg) & (~CMD_CFG_PROMIS_EN)); +} + +void +fman_if_enable_rx(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + /* enable Rx and Tx */ + out_be32(__if->ccsr_map + 8, in_be32(__if->ccsr_map + 8) | 3); +} + +void +fman_if_disable_rx(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + /* only disable Rx, not Tx */ + out_be32(__if->ccsr_map + 8, in_be32(__if->ccsr_map + 8) & ~(u32)2); +} + +void +fman_if_loopback_enable(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + /* Enable loopback mode */ + if ((__if->__if.is_memac) && (__if->__if.is_rgmii)) { + unsigned int *ifmode = + &((struct memac_regs *)__if->ccsr_map)->if_mode; + out_be32(ifmode, in_be32(ifmode) | IF_MODE_RLP); + } else{ + unsigned int *cmdcfg = + &((struct memac_regs *)__if->ccsr_map)->command_config; + out_be32(cmdcfg, in_be32(cmdcfg) | CMD_CFG_LOOPBACK_EN); + } +} + +void +fman_if_loopback_disable(struct fman_if *p) +{ + struct __fman_if *__if = container_of(p, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + /* Disable loopback mode */ + if ((__if->__if.is_memac) && (__if->__if.is_rgmii)) { + unsigned int *ifmode = + &((struct memac_regs *)__if->ccsr_map)->if_mode; + out_be32(ifmode, in_be32(ifmode) & ~IF_MODE_RLP); + } else { + unsigned int *cmdcfg = + &((struct memac_regs *)__if->ccsr_map)->command_config; + out_be32(cmdcfg, in_be32(cmdcfg) & ~CMD_CFG_LOOPBACK_EN); + } +} + +void +fman_if_set_bp(struct fman_if *fm_if, unsigned num __always_unused, + int bpid, size_t bufsize) +{ + u32 fmbm_ebmpi; + u32 ebmpi_val_ace = 0xc0000000; + u32 ebmpi_mask = 0xffc00000; + + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + fmbm_ebmpi = + in_be32(&((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ebmpi[0]); + fmbm_ebmpi = ebmpi_val_ace | (fmbm_ebmpi & ebmpi_mask) | (bpid << 16) | + (bufsize); + + out_be32(&((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ebmpi[0], + fmbm_ebmpi); +} + +int +fman_if_get_fc_quanta(struct fman_if *fm_if) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + return in_be32(&((struct memac_regs *)__if->ccsr_map)->pause_quanta[0]); +} + +int +fman_if_set_fc_quanta(struct fman_if *fm_if, u16 pause_quanta) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + out_be32(&((struct memac_regs *)__if->ccsr_map)->pause_quanta[0], + pause_quanta); + return 0; +} + +int +fman_if_get_fdoff(struct fman_if *fm_if) +{ + u32 fmbm_ricp; + int fdoff; + int iceof_mask = 0x001f0000; + int icsz_mask = 0x0000001f; + + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + fmbm_ricp = + in_be32(&((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ricp); + /*iceof + icsz*/ + fdoff = ((fmbm_ricp & iceof_mask) >> 16) * 16 + + (fmbm_ricp & icsz_mask) * 16; + + return fdoff; +} + +void +fman_if_set_err_fqid(struct fman_if *fm_if, uint32_t err_fqid) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + + assert(fman_ccsr_map_fd != -1); + + unsigned int *fmbm_refqid = + &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_refqid; + out_be32(fmbm_refqid, err_fqid); +} + +int +fman_if_get_ic_params(struct fman_if *fm_if, struct fman_if_ic_params *icp) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + int val = 0; + int iceof_mask = 0x001f0000; + int icsz_mask = 0x0000001f; + int iciof_mask = 0x00000f00; + + assert(fman_ccsr_map_fd != -1); + + unsigned int *fmbm_ricp = + &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ricp; + val = in_be32(fmbm_ricp); + + icp->iceof = (val & iceof_mask) >> 12; + icp->iciof = (val & iciof_mask) >> 4; + icp->icsz = (val & icsz_mask) << 4; + + return 0; +} + +int +fman_if_set_ic_params(struct fman_if *fm_if, + const struct fman_if_ic_params *icp) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + int val = 0; + int iceof_mask = 0x001f0000; + int icsz_mask = 0x0000001f; + int iciof_mask = 0x00000f00; + + assert(fman_ccsr_map_fd != -1); + + val |= (icp->iceof << 12) & iceof_mask; + val |= (icp->iciof << 4) & iciof_mask; + val |= (icp->icsz >> 4) & icsz_mask; + + unsigned int *fmbm_ricp = + &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ricp; + out_be32(fmbm_ricp, val); + + return 0; +} + +void +fman_if_set_fdoff(struct fman_if *fm_if, uint32_t fd_offset) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + unsigned int *fmbm_rebm; + + assert(fman_ccsr_map_fd != -1); + + fmbm_rebm = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rebm; + + out_be32(fmbm_rebm, in_be32(fmbm_rebm) | (fd_offset << 16)); +} + +void +fman_if_set_maxfrm(struct fman_if *fm_if, uint16_t max_frm) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + unsigned int *reg_maxfrm; + + assert(fman_ccsr_map_fd != -1); + + reg_maxfrm = &((struct memac_regs *)__if->ccsr_map)->maxfrm; + + out_be32(reg_maxfrm, (in_be32(reg_maxfrm) & 0xFFFF0000) | max_frm); +} + +uint16_t +fman_if_get_maxfrm(struct fman_if *fm_if) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + unsigned int *reg_maxfrm; + + assert(fman_ccsr_map_fd != -1); + + reg_maxfrm = &((struct memac_regs *)__if->ccsr_map)->maxfrm; + + return (in_be32(reg_maxfrm) | 0x0000FFFF); +} + +void +fman_if_set_dnia(struct fman_if *fm_if, uint32_t nia) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + unsigned int *fmqm_pndn; + + assert(fman_ccsr_map_fd != -1); + + fmqm_pndn = &((struct fman_port_qmi_regs *)__if->qmi_map)->fmqm_pndn; + + out_be32(fmqm_pndn, nia); +} + +void +fman_if_discard_rx_errors(struct fman_if *fm_if) +{ + struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); + unsigned int *fmbm_rfsdm, *fmbm_rfsem; + + fmbm_rfsem = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rfsem; + out_be32(fmbm_rfsem, 0); + + /* Configure the discard mask to discard the error packets which have + * DMA errors, Frame size error, Header error etc. The mask 0x010CE3F0 + * is to configured discard all the errors which come in the FD[STATUS] + */ + fmbm_rfsdm = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rfsdm; + out_be32(fmbm_rfsdm, 0x010CE3F0); +} diff --git a/drivers/bus/dpaa/include/fman.h b/drivers/bus/dpaa/include/fman.h index 19105bb..aeb707b 100644 --- a/drivers/bus/dpaa/include/fman.h +++ b/drivers/bus/dpaa/include/fman.h @@ -406,6 +406,8 @@ struct __fman_if { */ extern const struct list_head *fman_if_list; +extern int fman_ccsr_map_fd; + /* To display MAC addresses (of type "struct ether_addr") via printf()-style * interfaces, these macros may come in handy. Eg; * struct fman_if *p = get_ptr_to_some_interface(); diff --git a/drivers/bus/dpaa/include/fsl_fman.h b/drivers/bus/dpaa/include/fsl_fman.h new file mode 100644 index 0000000..0aff22c --- /dev/null +++ b/drivers/bus/dpaa/include/fsl_fman.h @@ -0,0 +1,182 @@ +/*- + * This file is provided under a dual BSD/GPLv2 license. When using or + * redistributing this file, you may do so under either license. + * + * BSD LICENSE + * + * Copyright 2017 NXP. + * + * 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 the above-listed copyright holders nor the + * names of any contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * GPL LICENSE SUMMARY + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * 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 HOLDERS 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 __FSL_FMAN_H +#define __FSL_FMAN_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* Status field in FD is updated on Rx side by FMAN with following information. + * Refer to field description in FM BG. + */ +struct fm_status_t { + unsigned int reserved0:3; + unsigned int dcl4c:1; /* Don't Check L4 Checksum */ + unsigned int reserved1:1; + unsigned int ufd:1; /* Unsupported Format */ + unsigned int lge:1; /* Length Error */ + unsigned int dme:1; /* DMA Error */ + + unsigned int reserved2:4; + unsigned int fpe:1; /* Frame physical Error */ + unsigned int fse:1; /* Frame Size Error */ + unsigned int dis:1; /* Discard by Classification */ + unsigned int reserved3:1; + + unsigned int eof:1; /* Key Extraction goes out of frame */ + unsigned int nss:1; /* No Scheme selected */ + unsigned int kso:1; /* Key Size Overflow */ + unsigned int reserved4:1; + unsigned int fcl:2; /* Frame Color */ + unsigned int ipp:1; /* Illegal Policer Profile Selected */ + unsigned int flm:1; /* Frame Length Mismatch */ + unsigned int pte:1; /* Parser Timeout */ + unsigned int isp:1; /* Invalid Soft Parser Instruction */ + unsigned int phe:1; /* Header Error during parsing */ + unsigned int frdr:1; /* Frame Dropped by disabled port */ + unsigned int reserved5:4; +} __attribute__ ((__packed__)); + +/* Set promiscuous mode on an interface */ +void fm_mac_set_promiscuous(struct fman_if *p); + +/* Get mac config*/ +int fm_mac_config(struct fman_if *p, uint8_t *eth); + +/* Set MAC address for a particular interface */ +int fm_mac_add_exact_match_mac_addr(struct fman_if *p, uint8_t *eth, + uint8_t addr_num); + +/* Remove a MAC address for a particular interface */ +int fm_mac_rem_exact_match_mac_addr(struct fman_if *p, int8_t addr_num); + +/* Get the FMAN statistics */ +void fman_if_stats_get(struct fman_if *p, struct rte_eth_stats *stats); + +/* Reset the FMAN statistics */ +void fman_if_stats_reset(struct fman_if *p); + +/* Set ignore pause option for a specific interface */ +void fm_mac_set_rx_ignore_pause_frames(struct fman_if *p, bool enable); + +/* Enable Loopback mode */ +void fm_mac_config_loopback(struct fman_if *p, bool enable); + +/* Set max frame length */ +void fm_mac_conf_max_frame_len(struct fman_if *p, + unsigned int max_frame_len); + +/* Enable/disable Rx promiscuous mode on specified interface */ +void fman_if_promiscuous_enable(struct fman_if *); +void fman_if_promiscuous_disable(struct fman_if *); + +/* Enable/disable Rx on specific interfaces */ +void fman_if_enable_rx(struct fman_if *); +void fman_if_disable_rx(struct fman_if *); + +/* Enable/disable loopback on specific interfaces */ +void fman_if_loopback_enable(struct fman_if *); +void fman_if_loopback_disable(struct fman_if *); + +/* Set buffer pool on specific interface */ +void fman_if_set_bp(struct fman_if *fm_if, unsigned int num, int bpid, + size_t bufsize); + +/* Get Flow Control pause quanta on specific interface */ +int fman_if_get_fc_quanta(struct fman_if *fm_if); + +/* Set Flow Control pause quanta on specific interface */ +int fman_if_set_fc_quanta(struct fman_if *fm_if, u16 pause_quanta); + +/* Set default error fqid on specific interface */ +void fman_if_set_err_fqid(struct fman_if *fm_if, uint32_t err_fqid); + +/* Get IC transfer params */ +int fman_if_get_ic_params(struct fman_if *fm_if, struct fman_if_ic_params *icp); + +/* Set IC transfer params */ +int fman_if_set_ic_params(struct fman_if *fm_if, + const struct fman_if_ic_params *icp); + +/* Get interface fd->offset value */ +int fman_if_get_fdoff(struct fman_if *fm_if); + +/* Set interface fd->offset value */ +void fman_if_set_fdoff(struct fman_if *fm_if, uint32_t fd_offset); + +/* Get interface Max Frame length (MTU) */ +uint16_t fman_if_get_maxfrm(struct fman_if *fm_if); + +/* Set interface Max Frame length (MTU) */ +void fman_if_set_maxfrm(struct fman_if *fm_if, uint16_t max_frm); + +/* Set interface next invoked action for dequeue operation */ +void fman_if_set_dnia(struct fman_if *fm_if, uint32_t nia); + +/* discard error packets on rx */ +void fman_if_discard_rx_errors(struct fman_if *fm_if); + +void fman_if_set_mcast_filter_table(struct fman_if *p); + +void fman_if_reset_mcast_filter_table(struct fman_if *p); + +int fman_memac_add_hash_mac_addr(struct fman_if *p, uint8_t *eth); + +int fman_memac_get_primary_mac_addr(struct fman_if *p, uint8_t *eth); + + +/* Enable/disable Rx on all interfaces */ +static inline void fman_if_enable_all_rx(void) +{ + struct fman_if *__if; + + list_for_each_entry(__if, fman_if_list, node) + fman_if_enable_rx(__if); +} + +static inline void fman_if_disable_all_rx(void) +{ + struct fman_if *__if; + + list_for_each_entry(__if, fman_if_list, node) + fman_if_disable_rx(__if); +} +#endif /* __FSL_FMAN_H */ diff --git a/drivers/bus/dpaa/include/fsl_fman_crc64.h b/drivers/bus/dpaa/include/fsl_fman_crc64.h new file mode 100644 index 0000000..af5803f --- /dev/null +++ b/drivers/bus/dpaa/include/fsl_fman_crc64.h @@ -0,0 +1,263 @@ +/*- + * This file is provided under a dual BSD/GPLv2 license. When using or + * redistributing this file, you may do so under either license. + * + * BSD LICENSE + * + * Copyright 2011 Freescale Semiconductor, Inc. + * + * 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 the above-listed copyright holders nor the + * names of any contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * GPL LICENSE SUMMARY + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * 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 HOLDERS 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 __FSL_FMAN_CRC64_H +#define __FSL_FMAN_CRC64_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * This following definitions provide a software implementation of the CRC64 + * algorithm implemented within Fman. + * + * The following example shows how to compute a CRC64 hash value based on + * SRC_IP, DST_IP and ESP_SPI values + * + * #define compute_hash(saddr,daddr,spi) \ + * do { \ + * uint64_t result; \ + * result = fman_crc64_init(); \ + * result = fman_crc64_compute_32bit(saddr, result); \ + * result = fman_crc64_compute_32bit(daddr, result); \ + * result = fman_crc64_compute_32bit(spi, result); \ + * return (uint32_t) result & RC_HASH_MASK; \ + * } while (0); + * + * If hashing over a different number of fields (or of different types) is + * required, this can be implemented using the following primitives. + */ + +/* The following table provides the constants used by the Fman CRC64 + * implementation. The table is instantiated within the DPAA fman driver. + * However if the application is not going to be linked against the DPAA fman + * driver but will use this Fman CRC64 implementation, then it will need to + * instantiate this table by using the DECLARE_FMAN_CRC64_TABLE() macro. + */ +struct fman_crc64_t { + uint64_t initial; + uint64_t table[1 << 8]; +}; +extern struct fman_crc64_t FMAN_CRC64_ECMA_182; +#define DECLARE_FMAN_CRC64_TABLE() \ +struct fman_crc64_t FMAN_CRC64_ECMA_182 = { \ + 0xFFFFFFFFFFFFFFFFULL, \ + { \ + 0x0000000000000000ULL, 0xb32e4cbe03a75f6fULL, \ + 0xf4843657a840a05bULL, 0x47aa7ae9abe7ff34ULL, \ + 0x7bd0c384ff8f5e33ULL, 0xc8fe8f3afc28015cULL, \ + 0x8f54f5d357cffe68ULL, 0x3c7ab96d5468a107ULL, \ + 0xf7a18709ff1ebc66ULL, 0x448fcbb7fcb9e309ULL, \ + 0x0325b15e575e1c3dULL, 0xb00bfde054f94352ULL, \ + 0x8c71448d0091e255ULL, 0x3f5f08330336bd3aULL, \ + 0x78f572daa8d1420eULL, 0xcbdb3e64ab761d61ULL, \ + 0x7d9ba13851336649ULL, 0xceb5ed8652943926ULL, \ + 0x891f976ff973c612ULL, 0x3a31dbd1fad4997dULL, \ + 0x064b62bcaebc387aULL, 0xb5652e02ad1b6715ULL, \ + 0xf2cf54eb06fc9821ULL, 0x41e11855055bc74eULL, \ + 0x8a3a2631ae2dda2fULL, 0x39146a8fad8a8540ULL, \ + 0x7ebe1066066d7a74ULL, 0xcd905cd805ca251bULL, \ + 0xf1eae5b551a2841cULL, 0x42c4a90b5205db73ULL, \ + 0x056ed3e2f9e22447ULL, 0xb6409f5cfa457b28ULL, \ + 0xfb374270a266cc92ULL, 0x48190ecea1c193fdULL, \ + 0x0fb374270a266cc9ULL, 0xbc9d3899098133a6ULL, \ + 0x80e781f45de992a1ULL, 0x33c9cd4a5e4ecdceULL, \ + 0x7463b7a3f5a932faULL, 0xc74dfb1df60e6d95ULL, \ + 0x0c96c5795d7870f4ULL, 0xbfb889c75edf2f9bULL, \ + 0xf812f32ef538d0afULL, 0x4b3cbf90f69f8fc0ULL, \ + 0x774606fda2f72ec7ULL, 0xc4684a43a15071a8ULL, \ + 0x83c230aa0ab78e9cULL, 0x30ec7c140910d1f3ULL, \ + 0x86ace348f355aadbULL, 0x3582aff6f0f2f5b4ULL, \ + 0x7228d51f5b150a80ULL, 0xc10699a158b255efULL, \ + 0xfd7c20cc0cdaf4e8ULL, 0x4e526c720f7dab87ULL, \ + 0x09f8169ba49a54b3ULL, 0xbad65a25a73d0bdcULL, \ + 0x710d64410c4b16bdULL, 0xc22328ff0fec49d2ULL, \ + 0x85895216a40bb6e6ULL, 0x36a71ea8a7ace989ULL, \ + 0x0adda7c5f3c4488eULL, 0xb9f3eb7bf06317e1ULL, \ + 0xfe5991925b84e8d5ULL, 0x4d77dd2c5823b7baULL, \ + 0x64b62bcaebc387a1ULL, 0xd7986774e864d8ceULL, \ + 0x90321d9d438327faULL, 0x231c512340247895ULL, \ + 0x1f66e84e144cd992ULL, 0xac48a4f017eb86fdULL, \ + 0xebe2de19bc0c79c9ULL, 0x58cc92a7bfab26a6ULL, \ + 0x9317acc314dd3bc7ULL, 0x2039e07d177a64a8ULL, \ + 0x67939a94bc9d9b9cULL, 0xd4bdd62abf3ac4f3ULL, \ + 0xe8c76f47eb5265f4ULL, 0x5be923f9e8f53a9bULL, \ + 0x1c4359104312c5afULL, 0xaf6d15ae40b59ac0ULL, \ + 0x192d8af2baf0e1e8ULL, 0xaa03c64cb957be87ULL, \ + 0xeda9bca512b041b3ULL, 0x5e87f01b11171edcULL, \ + 0x62fd4976457fbfdbULL, 0xd1d305c846d8e0b4ULL, \ + 0x96797f21ed3f1f80ULL, 0x2557339fee9840efULL, \ + 0xee8c0dfb45ee5d8eULL, 0x5da24145464902e1ULL, \ + 0x1a083bacedaefdd5ULL, 0xa9267712ee09a2baULL, \ + 0x955cce7fba6103bdULL, 0x267282c1b9c65cd2ULL, \ + 0x61d8f8281221a3e6ULL, 0xd2f6b4961186fc89ULL, \ + 0x9f8169ba49a54b33ULL, 0x2caf25044a02145cULL, \ + 0x6b055fede1e5eb68ULL, 0xd82b1353e242b407ULL, \ + 0xe451aa3eb62a1500ULL, 0x577fe680b58d4a6fULL, \ + 0x10d59c691e6ab55bULL, 0xa3fbd0d71dcdea34ULL, \ + 0x6820eeb3b6bbf755ULL, 0xdb0ea20db51ca83aULL, \ + 0x9ca4d8e41efb570eULL, 0x2f8a945a1d5c0861ULL, \ + 0x13f02d374934a966ULL, 0xa0de61894a93f609ULL, \ + 0xe7741b60e174093dULL, 0x545a57dee2d35652ULL, \ + 0xe21ac88218962d7aULL, 0x5134843c1b317215ULL, \ + 0x169efed5b0d68d21ULL, 0xa5b0b26bb371d24eULL, \ + 0x99ca0b06e7197349ULL, 0x2ae447b8e4be2c26ULL, \ + 0x6d4e3d514f59d312ULL, 0xde6071ef4cfe8c7dULL, \ + 0x15bb4f8be788911cULL, 0xa6950335e42fce73ULL, \ + 0xe13f79dc4fc83147ULL, 0x521135624c6f6e28ULL, \ + 0x6e6b8c0f1807cf2fULL, 0xdd45c0b11ba09040ULL, \ + 0x9aefba58b0476f74ULL, 0x29c1f6e6b3e0301bULL, \ + 0xc96c5795d7870f42ULL, 0x7a421b2bd420502dULL, \ + 0x3de861c27fc7af19ULL, 0x8ec62d7c7c60f076ULL, \ + 0xb2bc941128085171ULL, 0x0192d8af2baf0e1eULL, \ + 0x4638a2468048f12aULL, 0xf516eef883efae45ULL, \ + 0x3ecdd09c2899b324ULL, 0x8de39c222b3eec4bULL, \ + 0xca49e6cb80d9137fULL, 0x7967aa75837e4c10ULL, \ + 0x451d1318d716ed17ULL, 0xf6335fa6d4b1b278ULL, \ + 0xb199254f7f564d4cULL, 0x02b769f17cf11223ULL, \ + 0xb4f7f6ad86b4690bULL, 0x07d9ba1385133664ULL, \ + 0x4073c0fa2ef4c950ULL, 0xf35d8c442d53963fULL, \ + 0xcf273529793b3738ULL, 0x7c0979977a9c6857ULL, \ + 0x3ba3037ed17b9763ULL, 0x888d4fc0d2dcc80cULL, \ + 0x435671a479aad56dULL, 0xf0783d1a7a0d8a02ULL, \ + 0xb7d247f3d1ea7536ULL, 0x04fc0b4dd24d2a59ULL, \ + 0x3886b22086258b5eULL, 0x8ba8fe9e8582d431ULL, \ + 0xcc0284772e652b05ULL, 0x7f2cc8c92dc2746aULL, \ + 0x325b15e575e1c3d0ULL, 0x8175595b76469cbfULL, \ + 0xc6df23b2dda1638bULL, 0x75f16f0cde063ce4ULL, \ + 0x498bd6618a6e9de3ULL, 0xfaa59adf89c9c28cULL, \ + 0xbd0fe036222e3db8ULL, 0x0e21ac88218962d7ULL, \ + 0xc5fa92ec8aff7fb6ULL, 0x76d4de52895820d9ULL, \ + 0x317ea4bb22bfdfedULL, 0x8250e80521188082ULL, \ + 0xbe2a516875702185ULL, 0x0d041dd676d77eeaULL, \ + 0x4aae673fdd3081deULL, 0xf9802b81de97deb1ULL, \ + 0x4fc0b4dd24d2a599ULL, 0xfceef8632775faf6ULL, \ + 0xbb44828a8c9205c2ULL, 0x086ace348f355aadULL, \ + 0x34107759db5dfbaaULL, 0x873e3be7d8faa4c5ULL, \ + 0xc094410e731d5bf1ULL, 0x73ba0db070ba049eULL, \ + 0xb86133d4dbcc19ffULL, 0x0b4f7f6ad86b4690ULL, \ + 0x4ce50583738cb9a4ULL, 0xffcb493d702be6cbULL, \ + 0xc3b1f050244347ccULL, 0x709fbcee27e418a3ULL, \ + 0x3735c6078c03e797ULL, 0x841b8ab98fa4b8f8ULL, \ + 0xadda7c5f3c4488e3ULL, 0x1ef430e13fe3d78cULL, \ + 0x595e4a08940428b8ULL, 0xea7006b697a377d7ULL, \ + 0xd60abfdbc3cbd6d0ULL, 0x6524f365c06c89bfULL, \ + 0x228e898c6b8b768bULL, 0x91a0c532682c29e4ULL, \ + 0x5a7bfb56c35a3485ULL, 0xe955b7e8c0fd6beaULL, \ + 0xaeffcd016b1a94deULL, 0x1dd181bf68bdcbb1ULL, \ + 0x21ab38d23cd56ab6ULL, 0x9285746c3f7235d9ULL, \ + 0xd52f0e859495caedULL, 0x6601423b97329582ULL, \ + 0xd041dd676d77eeaaULL, 0x636f91d96ed0b1c5ULL, \ + 0x24c5eb30c5374ef1ULL, 0x97eba78ec690119eULL, \ + 0xab911ee392f8b099ULL, 0x18bf525d915feff6ULL, \ + 0x5f1528b43ab810c2ULL, 0xec3b640a391f4fadULL, \ + 0x27e05a6e926952ccULL, 0x94ce16d091ce0da3ULL, \ + 0xd3646c393a29f297ULL, 0x604a2087398eadf8ULL, \ + 0x5c3099ea6de60cffULL, 0xef1ed5546e415390ULL, \ + 0xa8b4afbdc5a6aca4ULL, 0x1b9ae303c601f3cbULL, \ + 0x56ed3e2f9e224471ULL, 0xe5c372919d851b1eULL, \ + 0xa26908783662e42aULL, 0x114744c635c5bb45ULL, \ + 0x2d3dfdab61ad1a42ULL, 0x9e13b115620a452dULL, \ + 0xd9b9cbfcc9edba19ULL, 0x6a978742ca4ae576ULL, \ + 0xa14cb926613cf817ULL, 0x1262f598629ba778ULL, \ + 0x55c88f71c97c584cULL, 0xe6e6c3cfcadb0723ULL, \ + 0xda9c7aa29eb3a624ULL, 0x69b2361c9d14f94bULL, \ + 0x2e184cf536f3067fULL, 0x9d36004b35545910ULL, \ + 0x2b769f17cf112238ULL, 0x9858d3a9ccb67d57ULL, \ + 0xdff2a94067518263ULL, 0x6cdce5fe64f6dd0cULL, \ + 0x50a65c93309e7c0bULL, 0xe388102d33392364ULL, \ + 0xa4226ac498dedc50ULL, 0x170c267a9b79833fULL, \ + 0xdcd7181e300f9e5eULL, 0x6ff954a033a8c131ULL, \ + 0x28532e49984f3e05ULL, 0x9b7d62f79be8616aULL, \ + 0xa707db9acf80c06dULL, 0x14299724cc279f02ULL, \ + 0x5383edcd67c06036ULL, 0xe0ada17364673f59ULL} \ +} + +/* + * Return the initial CRC seed. Use the value returned from this API as the + * "crc" parameter to the first call to add data. + */ +static inline uint64_t fman_crc64_init(void) +{ + return FMAN_CRC64_ECMA_182.initial; +} + +/* Updates the CRC with arbitrary data */ +static inline uint64_t fman_crc64_update(uint64_t crc, + void *data, unsigned int len) +{ + uint8_t *p = data; + while (len--) + crc = FMAN_CRC64_ECMA_182.table[(crc ^ *(p++)) & 0xff] ^ + (crc >> 8); + return crc; +} + +/* Shorthands for updating the CRC with 8/16/32 bits of data. + * IMPORTANT NOTE: the typed "data" arguments should not be mistaken for + * host-endian numerical values, the assumption is that these values contain + * big-endian (ie. network byte order) data. + */ +static inline uint64_t fman_crc64_compute_32bit(uint32_t data, uint64_t crc) +{ + return fman_crc64_update(crc, &data, sizeof(data)); +} +static inline uint64_t fman_crc64_compute_16bit(uint16_t data, uint64_t crc) +{ + return fman_crc64_update(crc, &data, sizeof(data)); +} +static inline uint64_t fman_crc64_compute_8bit(uint8_t data, uint64_t crc) +{ + return fman_crc64_update(crc, &data, sizeof(data)); +} + +/* + * Finalise the CRC (using 2's complement) + */ +static inline uint64_t fman_crc64_finish(uint64_t seed) +{ + return ~seed; +} + +#ifdef __cplusplus +} +#endif + +#endif /* __FSL_FMAN_CRC64_H */ -- 2.7.4