From patchwork Fri Jun 30 08:54:19 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nipun Gupta X-Patchwork-Id: 26067 X-Patchwork-Delegate: jerinj@marvell.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 834D97CAE; Fri, 30 Jun 2017 10:55:12 +0200 (CEST) Received: from NAM01-BY2-obe.outbound.protection.outlook.com (mail-by2nam01on0078.outbound.protection.outlook.com [104.47.34.78]) by dpdk.org (Postfix) with ESMTP id A0C9F7CAA for ; Fri, 30 Jun 2017 10:55:04 +0200 (CEST) Received: from BN6PR03CA0029.namprd03.prod.outlook.com (2603:10b6:404:10c::15) by BL2PR03MB465.namprd03.prod.outlook.com (2a01:111:e400:c27::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1220.11; Fri, 30 Jun 2017 08:55:02 +0000 Received: from BY2FFO11FD032.protection.gbl (2a01:111:f400:7c0c::146) by BN6PR03CA0029.outlook.office365.com (2603:10b6:404:10c::15) 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; Fri, 30 Jun 2017 08:55:01 +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 BY2FFO11FD032.mail.protection.outlook.com (10.1.14.210) 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 08:55:01 +0000 Received: from b27504-OptiPlex-790.ap.freescale.net (b27504-OptiPlex-790.ap.freescale.net [10.232.132.60]) by tx30smr01.am.freescale.net (8.14.3/8.14.0) with ESMTP id v5U8sfJx032271; Fri, 30 Jun 2017 01:54:58 -0700 From: Nipun Gupta To: CC: , , , , , , Nipun Gupta Date: Fri, 30 Jun 2017 14:24:19 +0530 Message-ID: <1498812875-6945-6-git-send-email-nipun.gupta@nxp.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1498812875-6945-1-git-send-email-nipun.gupta@nxp.com> References: <1495735361-4840-1-git-send-email-nipun.gupta@nxp.com> <1498812875-6945-1-git-send-email-nipun.gupta@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131432865017705822; (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)(39840400002)(39850400002)(39410400002)(39400400002)(39380400002)(39450400003)(2980300002)(1109001)(1110001)(339900001)(189002)(199003)(9170700003)(4326008)(6916009)(106466001)(189998001)(105606002)(50986999)(76176999)(81166006)(305945005)(54906002)(8676002)(77096006)(47776003)(110136004)(498600001)(48376002)(356003)(33646002)(53936002)(5660300001)(104016004)(2351001)(50466002)(38730400002)(36756003)(2906002)(6666003)(8936002)(8656002)(50226002)(5003940100001)(86362001)(85426001)(2950100002)(2004002); DIR:OUT; SFP:1101; SCL:1; SRVR:BL2PR03MB465; H:tx30smr01.am.freescale.net; FPR:; SPF:Fail; MLV:ovrnspm; MX:1; A:1; PTR:InfoDomainNonexistent; LANG:en; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BY2FFO11FD032; 1:HaC0vmEYzmb8NqwJUTFqBq+hzZDJewipUVDtF/1mZ4?= xbrO2z+l9HmUFrSeD+0aFLJZgeJjGz4u9CrtN6sQstjz0HerJU5M8alc3Vhzerp3ynNL+6fE3ufkSMJ/cvnS0qZTSItAPXdP7hyLKjkST49DmQqjWFaRB4bdVXgUXrShi5Zg/DWbzkcGrrpGBCe9puRsVRm2oP4Al9GRWtRfa5LNPzhDqmMIBP7VTsEyZscb4j6+IqC2BUe57fKrkoi59s3Q6/X+op4Y5aoTwgjtWX9ewuWZgpTexVD3PF5hv9N1pwN2/HKNp6vE07FarbttRU1gEy1HsrIwTmany0HgDzS+3S9594DoalmbCJ65gLAGLyGiTs2uA6i698tG9UFUAoHSm++6o1wxVdzCdmnSc3WIm3YwlvyeedXSmGf7eWXa2+zlty/P/63dxg5P3krlxudlWxLzf70WDGPGCyUJnHEfYlViCD6+cqhUP2PICR3Rc9x58NWLRrUGd4vSNxG+Z5gaTUoLLAZDwDUxO+f9Rz2kwtm9z/J+Qpa1CpFTUVuqYRTzP6QFG6ICZEdv0/FLDIJz8oi1/QhbrDyQ4TVBz28CKkDGciB9DmI0MAcWRd9YS7VqbeP5shl9IztnGE1HU0hm8dd/2knWrU319ytx+aN47+xTPK1uuFi5n9xHNt5i3mFZ1F54paZnUOZVdpYw4DoM22jDY3V41Dk4KVcgy228Tta4u0adMMil3YP8S06YNWmou0OgPhafTfd4j+j50jmrZK3/ehhpjMZeBRBq4emQRAXGHQWuYu04o438YqeyrPMa+LlE3MY0fKBM42Hg87agms5id98dJO5byt7eGhZgF5GUdY4ACREajj3dlGsAJUb/ssz6gQot4+Jbp5Un2r8wlU2rbInCnRqypv45phw23n/Ly+Mr8RV0lOdt/ZzZ2QnRdLrRpHSnP+312VPkBPDohPepaMTQeusauiEmJhRPO6NR9diPoyBxD9nwjWP8nsoRLxe+eF6Bos9emNMbrGlbS1/obfaP4rVIrCRBoYXeiADtKRhN86WN70BC8MI/5MQQLu9iphRN3IRCErUJnzjoMtIrBgsirYj5iBg3x/Ng== MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: cf7574b4-cc79-453b-d3fe-08d4bf95b1a5 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:BL2PR03MB465; X-Microsoft-Exchange-Diagnostics: 1; BL2PR03MB465; 3:4m6tCHObLkCnUgS8dzMbGuqA2vyarkIJ0QKlzcpEOudWBqk5jBfxUm1rw6P/+60WkYSw191x4RziopTDCHhPYAAjO7X/ishYMzZzzEj8bHhH+d9BfKnhSHCPYtkzkXcZA9FcFo8akvyNcBRJBEsW5W6n/rMzL9teZjZ0uJVJ4GvTDmTjaZBf9xbn2IpQZfL7xeVBpiOZMxtyupN8THWKGYtE8fLV0BCVkF546qj+JF/JyvtdtFztDRWsnpql5VVPBm6hjsShuQyOqBlP5RevEbcgvAGWRYBz8p0LFpH0lw9+IOxUhRdwI+l6BwDqqUqIFDgMRzmfZenPheoyVDGZIDd7eUE89L8edBGd+glminIv86oDEiRP+GLi2fuQ1YN5QuSShmeu5gLqcv+2Mo9JdWElktmL54HFLH8kfBPOn1ZZvcNeWcAyylzrIxYCPGsAXDEhD0f7TCO1FLFVf6riBCcNsnh8anrcUhrpC4s1pt9WE+b6K70xQ+1frMYTPdDva+DZJh7apQ1YkNdAnHV3VrOASujVrQO8gGgvsvRzIFmPe27ycAbtStgR5NdvuMMJoZpBU4afXcuc4xC0GcI0t5RQMIc1qWmllCZTKb/nq/j3V76kJDZIfXW480ENDA6F+G3bsfM4+vsSyVFOLyecmTJkH3U66d/lCfSBVaCrCSDGnfAg8zvSAMxyIkBqMYyFc53tIobxKTHqXou0og99ReP62rZzkqy0wF7NX5jTondywBzo1iMpadDUhEYK+JUK9Z08WKOO9pzKQjkF1BFNDLakLLiiZeoaZmoWmTeU9oSkFwBP3qn9Q+dEJJJ1trvH1iAtUlgXClk71S5gmx/LBQitEsn/vQCigrYqJEg3BW1b62Wp8jfuXp56LVrnAYaM X-MS-TrafficTypeDiagnostic: BL2PR03MB465: X-Microsoft-Exchange-Diagnostics: 1; BL2PR03MB465; 25:f28S+gLlPxjlykMQmb7tkXwvlgCC3btZzyDgPC+fOoPcAyxhZNztHHVEcuU9xVJp1v6OaT/5OIwx4SIqbBH39ikTAdTNa9ZLB2AMRAoiOl9H/g2XmbcQ/lU+FIj2WRRDINIeVfSuGBh3o3aPmtdc8r8c/3ckmoqF0ll8APBJVWW+MJTPAc4CDE8JGmOdTighUZbMfEJ8rW4n6hMyuxQnE/Fvk+l19SAOL/xYSTt4fKhHDWszKIXZr4kbqf0NkpyJsQRG8+djwYEnFJWDdtFWw/x5j55/PlOx3aauKgw7rdeUX149Dv7Ah2G1Tlx7aImSRFlvI3qb8MPW4WoAbwP8SHDlcLFwDePxqxM0aQzd4UFF+TDjdZ3xay5/KTmfCxAg48zlwa6D+isA6Il1pXYjJYucYoFi1QmeGjavzlB/vJHMNbcPjaMqjugh0qZJInMoLElQ3929V3k3yMwXh7zW6A9qyXXLKcyn+p7v8JPuL4M9/FzXU9YBxgEta7ugWb2jvpkkddlQo0sht/JAu2Pa6qAJLv3xhWTlhyWQei5X9Vhb9LZatN0lG9rrXrerwt1QCSa6fe5AEPdRqmt3aUnQXYGhwC0oYBqQhnAztM2o9QHWNsoqAakSH7EtxXJLygSbQusvQBKwPiHwO53XUIv+RTsVi5OzszG0awa6Hjfj/1BPDqt5HQO0xab9lAksACch+E8+rDSfpOJl8EkYMu9ch/SZYifLoCr01fd3oj7nzzN/bJVQUPqoS9IwKSEA3RgZia+tfmMSfLTSFnNAAS2nCxjq/dsXN45NlDmMRLV7z/R1XR8AfBR7wgPCD+0rFHOvEChl4+4rl+R4yibxm8mV/H34KBe5sasKk2Q6gNeV6XC4wWKKufoBtxYJfEfdjPJ9Sz+MDCNudMZSLUVDH7vtT4OZ8qbVDiMtVF06R3lJPrw= X-Microsoft-Exchange-Diagnostics: 1; BL2PR03MB465; 31:Oyes9shShLGhVNpWz/bvSQr+kigCF/sTrr/lNqRbESL235Rc55O4MyX//4qz3u2Tr6K0Kb1WR8juOtJc8do1y4MnsMVvvT6os2QX02IFExx9OzWitnbY7FQR5XApGoaVCBPuF08u0r0lReXtLw0/h7iHsF7DweD+Uzkol8biVy2UEhLoYdT2X+puYuUyuaYlgie0QSg61uhnEYC/DKw0ZGGi42I4UM/EBaIUvtp7AuTq0GXFUCv8IgQKW3lZFxeo8KaF/JkS12Sy8s0iro5wz55LJr4ULeLaqCfQsDVVuay4SOLXC4mvUVJmghFNpQiRb8wWpJRL3mN/B0ti2ayFOBxeVbXyyjWaVZzmNHSMPsA8kijeZnqdZ4exFTULdI/4kLBDkm9ipUidqKkd8zpyB2PvHpfhLX0C2IY8WYKWigRQQk72SixQ4OUw4qoWXhlq7ELNXRRW2Y+2tPf7ASIn6H45azJ0a8MzM8s99BeSWGJqNrQqgls+xKd9H7/HcNIyiaYSyhe7X4k8lP8Cd3sFNLt/vwcQmupK8AtNwEMS7n3K/nWotIOrGKT5SYMNfGnRCLuUpZWudF3OdXGEadJPj1yCTsfcYvEJpdmpykWbcSeuUw795QCunjSiMHWlqoOvhbEA+6rBbGPUF2RcGBfiMj6NUqFuyNKeqKxqJiJHmkfgoPCg17K8nIzeh3ZPWaCCnYFbV9VvMzB67dI82IEOMg== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(133145235818549)(236129657087228)(185117386973197)(48057245064654)(148574349560750)(275809806118684)(158140799945019)(247924648384137); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6095135)(601004)(2401047)(13018025)(8121501046)(5005006)(13016025)(100000703101)(100105400095)(10201501046)(93006095)(93001095)(3002001)(6055026)(6096035)(201703131430075)(201703131433075)(201703131441075)(201703131448075)(201703161259150)(20161123559100)(20161123556025)(20161123561025)(20161123563025)(20161123565025)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:BL2PR03MB465; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(400006)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:BL2PR03MB465; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BL2PR03MB465; 4:RRjaoNJuJC0kiai91JlnC4R+VYy3CTee6yha/od2WO0?= dxo+6dm8Om0899Hq49BWl41wUKJa9+juAp3E9dPNNRmYHeNJgsyR1GrRRbKqWNj3lhiJ1/bsV8Jw3ItzB5KhL9Hz40d9XIGQa+EKzWFFd8bdLibjmyKORySiwpOrQSN6RnLeDjzrcl7HildJYFpMji+SFq3T8YXpCAEBZEgzviVTcqu3YZWSRAidgX16cQ+hzFInqdFbAfYHGnjXJvzfRfbYvfz9DsXz4by7wnIcyRmL8j2axe9IuC4YWD1MhNQ45sFkIaBk0W1li5oBqG1L7w+XaKO7XmB9Gu4bnXuB9S0radxa0yQzzeXQJ7JbYjqh9fH6yZTnKFxm89IIGt42gJXwj7dL+aNcApOJ7px4mdcoCkhs5zQ2sFDarSiIoqFz/0Zc7aJNYED8Uq2rb7jE3BgI8vvK2ClgCYbune2BVooORNPHkV/JC1WygDjs7nlaXzDlwm7IY3f0sOgzv8W06SQqam7fjKL67lNAVtEKdZQSuikpU1w+mKeXIUm2xbNcoX7cUYGwTz0LZ+6PyUshgoWjrAQKZcA57e2TWIwDWSRMfSRsKlkq3MqTGOBj8SFfO5FwwvdVwICJqAxugr+VwMOe/TNlepaNRstMWC7uzgGih/7sxmKtRT7ovywoEPOry568r9nXQtY1QpSMrmpRMJeZtewjAK99L/PLhN8lT0DPXFNGOnJm6HdeglftDvXRfeokhBW/Q9OaQyA7q5NAGhjOPUlbli/u4M+M98RHYhGg2ryXn0le6igL7UXz2Z8bNIvk/0oykoL5OWKq7jotAIWt/iyGox8Nq1wP9882MHrkI0OUd0Z7Qjbi+6xA7RGwtQ+HnsVIr3Vk2Jkh+KTNSVwOUQ0NrlLuRS8g1xQHBT8mJ6VwEosWVcPPc1VrapQDJDxdERX92J7f2AUUKDEhNhzt7rly3zulQahqtMeZbDO64pGC7WsMTAvTr4mdH7Pb/symgfjV/HwjFt7OE6eSxkMlXg+rdVNfpTbdDv29iPbuAgH5QHclou8AJon3+L39v+VvZ+SucNBxLUAlbHtKmeT+8HoP2qEgKGvUbUNu44Uq23Js0tEqlxigslwbPUN6L8dtKwMPLXdYVxL5H/bpzXjfzZRR4Ot90/WpnPtzFf76WSVEDpu0sLRSFL7i54DzLHTwvTC9pU9Yu9Nam9zWTBJ1u9OPBVykogKbSVMQl5Nw15+x3IMBLDpOKkoe8EpVaBPKdMy+IUHsvjezEcAmpcgmGMmkH8jQ3fTTQhqrN4+5gvtSlBTkZSVsiRz07IotcOjEavcrN/HnnRaxB/2+Pzj0wr+3Iw2sqR3KZ2fbMVaX18FXSAoS7ULZ9Cikb6Ua4PtEUOF5jzibbFgvWcOjakvxqUrHQEd4rG9ODc7pZkmmweoX2hpJXW4Dg0cuYZBPSIMTFSetBQBs6sWK1MzP+bp6skg2CM8k1L+8x2K0XV2vdprRkpGsQxfdydh88qQI= X-Forefront-PRVS: 0354B4BED2 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BL2PR03MB465; 23:y6N1Ah36xiTMoe2UrxqO6hIcw5fOgGgJn5tL2icp+Q?= /aRND3oCCZDMcC114WvULGTA72b0cGvWJu9hpm6sPodWdcNK8H5omufhME5M40eNrOV8vsdjrwvZV7H1QEoqntovKLI0aWy/EWZZcFHMMclHuVmkJ3F3dp6sZIWQlzB2XKlmUtr7onpIcySjj7qMkMnoDAO04ZxaabyN86cdzZhO+AFKaZ1qKEhWYRHKGx6mvPdZvcV80UuDBFHXlDWyvvGXU95KF1TLudWMr3Jyf1QaDOVLPIM3dsHcu7LEX3f0kWO6lLsS1vGMjxifmM7QlmuNZ3af4xAlSbxDZcSaNg7z8R55qG2bmXddp8cDxSUaafiQJ0yMNvhGoBdZAJ+3fTtYtSy0JqGKg2OktKZTEc6PuYCEdtwPYrx6XQbsF2n9LddnwL0nW/3ZSyeuT9CgYyiQEKZnd0GH1mYf7n6xvzG2tORW+2kvsqwNjk8A43m4rYnpJyM7cp2XjS20qbYQp1yTwdVF3Qs4UQ23S++rCpusAH3fyshjruzmjs3bHisazyS0zyinAg1PBE/mKLnzdFOxMRgbmkeLpwc4l4ry8vig2aBo+qY8j7cY7G9FFPcLccQZ9DosTiTVEV/JUGoaVnDQ2UO7iRjQKbVraikWSBYuTafDGplR2XlQLHsm+8G1w5bioGckrOpNdJ/ABF+nZboShGn/7XIKxpUx3v4/z3UhZV/tsW1YHsUSNYzIjTJDasWOuED/kjiOAlB2LlHv/CH7ts6WDbo7VPGuvuiWMqbGuT3U8RVgWCQz/O99x+n+yo8ITAgP6FB1KMbbtr36RHlqKiAHYDk5CcN07AgfOllxHfZ5FypuOyt0qAhtKQzRDzB4YS4QMK6wdls0AjWYBdGH22Yvl5t7riYCf0rqUiI2mp6YYcP8NGqhAT7skM5kHrTMYjK/UgS1GQTQeJHO4pbbrso3g0kGFGbDkaZczSd6CfsQ2dhzqFG0e5EKK+cMZUZHEMSdIYuxAC3Mr9Ta5sxuumM3INRj7uoumvq7/CM0U1Ln42RlXZYATXGdzdOcXiS4L0AKJQKaGbEvODkBWRs9ST7xsojvhd+fFnQrf8ERslR1cTi3YLqVAtnWuNnU1WYYaXEoCQRrf5eZsrbjUNIFv+xB9fWGdxhagJ1mvmZxD4xT2O3H8h/1arKgnixnms68ZcPVVe7i/27H2X+HgWxzfxNv+J2LQdOz8o+imvH+ueDsYgBFyzLkMR2aC7fPc= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BL2PR03MB465; 6:eH+cbDNly1QXNfppAhwr9p7dfZgCQ4Aegpz2VTjLPRf?= NFIwhPsGDwWpY4O/+z6tBsn8MRtRJ/fUsnPhxaPr5MTpyYsFNZDZ3ahVPEptF0efn/T1cnOMffW9baSgnSNfqxkUODVEILwdJYq9DNZV9D8FC+X6JwkTtJsYkNL0RAULs8wOQtldswblbn5HkSZIWXWHnCGmmrUmUC45xypt1uXPpiCxt+tLIqYd4zy2ux2g1GPKF/8fniDWf/cmHlzBHglcdw67fYYqgMtiH4su+w0ohUAepMvQxKMHJxGsbrkP9lcwSBCjAdWX3oxkkdYqufINCQo9g8+Hb+2ZgyospkFz4WQAcXN6V7hfzVWS0VbRjPh2V1+Vgh5ybSrqeUrL9pjajw+vU5N+M9/84/yM+tlShP7VqslWQ36s/oxVUfh2c96BrCBYQ6CM6qBv/q4Jr5DPoUwrFGohn2pQ/kHWRcaSFHQRXg7tZFEDYFG28DoV6QOGuslsaW+nXd/+Vxjw/7dpsXXnOF1Wh6WpZic+kdW2qmAhK9PyuH0sFQl8+6sfIppN2O+wIKUFNsDdx2aTsb5sEvLRrJ2Q8iBpTZhC2uZdINmKxg3dLtsbIPkDse0A6ZXpMZOonixqy5xprgkvr7b0TrFYSRPkFeOskkLKXCi3cM42CUPaNLYPA2C3Bxspk8DVFbZj/zLsCTQIcD+uXE99xgHSabdhRdKD8C6F6I//XjhBbKsgMntmL95dePYVlObbMsxE5NgoS413meZbvNlnndJULUsNCHl7x3SWC7wEOdd6oiXSQjHfblYOt8mev8vNyXo5c2Xfh5XjRUgAQnRhIAb4aNOUOIpqG0UYxCD3N5wMCZc9PsB+H1H0oEHYWkSOe6qWfztnkjP3PwHyMoiVkKeHqeHyZ+0qM3r3J8Ar3tHdeCe2SR/ajoLF9/OHG/GnZ8Q6Le15nbBWdV7NUGTrRmLj3raldMWvY504Geg== X-Microsoft-Exchange-Diagnostics: 1; BL2PR03MB465; 5:HFAD5qf4YRwyUNpg0njJBqwfINS/BhVYqQKY+pqLo5qAMHO9LHOil1xvjuXwajZpYKc/+nkiQnEru9vrgeCr+bgdBnn/QCsxpOMa741vUf/TDHkrnpvaUdjYNVjdQXi4KQspUr5YQVxVMv8MSbowNFmYm2KMpM3Px4WG3aN4gKFzI0kjz32i5KsfsxCUCNyZoNUSD0Qsh2QhLllt7yICAS4lvlx9dOS4exzElFxplFhIr46kgFiHGwA5NBrCf/EERx8xPS7pwiyTuOJ73PfLUBZYmDeOtImIunsUJnG9UjMWzAeQYYxabBC2F5sSkUDw3uqZpIsDxXSKGdqLOyf9DDWp6n5oJFabKHKEV4imJP5Ra2MAt3mMAwaTzFCLz7zDb9pc/g/5jWU5+H1bF7RxOveAVkRv6hFM5yYwNlqE8vFIlBXjLXsPzXlErGl98fpe3Qhw/JmRpI089bvLskg9bDj/lSz9AwwRsxjje1JBO6hEPEMHQsuNAmkefQQIOzQnO8Qv+XBdeSviSmAGRsOxuA==; 24:4CKpfdyE/Ic8MrEO2xtdpnM3Fdmh4F4zQr9+Uq9ly/Zx5dLIoRBpnNfnXYveyIj/stoo2kj+GFYvYJNqOpDJ73RJHdsDr3QfA/IszVcONdI= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BL2PR03MB465; 7:Kidg/Bbcz6I/I6dlMlLzxo/C5TZRLZU3Qj/mpAdzRaD4DpLDYWLFaWcdqvjwXFCJ4nWQ45EnVmeEB+hcK9D3nOCJedd2ir4pv8H27dQWvT6lraQPd7RDpvwBg6RvlXDzAyyq3MTCIb47ZUrbsXbf1NtTgXpCORDTZuDeEFw84uWqCRkBzXqqRIw+yLdqWTlXKy+ScP4ur3Qsy6VJSeg/SOJKveAPOxDt7OirLUwohQdqUnxM4YkJvCVHucE8DY4st1vVebJlf5XZFuFMik5eIpiNp/O2meF3K20jIoUCDzsyKrD6FvOUrEV/T59mmCSA4qh4+n69+kqd0SYiSQkarIZtvWepbqtMbFSwKFa9ZA0YwPYSZAx8phYQWPmdJ9TC4IkMeq/e+Cqkv113zK0hTcxgtBrr8SzW9ftR0gugdyqUgOWgBW5BDX/buJoNxsqyf1A+E/NFSVLFdtHfERf5akHYle6zxsoNlUxjSqAL1SjmUwB0Qe/FEaDZmC4iIsGKGmCgiapTXpDZay7upncMhNBu8C62Ig6XJR3aqa48vBFVgj1Og2S6KQLzCpDQtyv49d0wA5AhHdGlCJ0WXcF0kN0flPvgo9Ut2A/bOL34gLBAaUuRQzy30WGdoB6thCmQfnX6fNfFSjQcg2I7d8LguFtMSA7POS02on/5+Fg6zwV2wwBJ/GrvLl/bhmFcpkjekyA4WPzhsxoEtQ/fK6y4w9y1i/z7eznEaEVPUXeGdorA+OdUj/rao0ZTGu2y/WEfOrjWd3XUOCVHrhsSRjJpvymnT6388rcbnE+L5U0DXpU= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 30 Jun 2017 08:55:01.5053 (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: BL2PR03MB465 Subject: [dpdk-dev] [PATCH 05/21 v5] bus/fslmc: adding basic dpcon support 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" Signed-off-by: Nipun Gupta --- drivers/bus/fslmc/Makefile | 3 +- drivers/bus/fslmc/fslmc_vfio.h | 1 + drivers/bus/fslmc/mc/dpcon.c | 230 +++++++++++++++++++++++++++ drivers/bus/fslmc/mc/fsl_dpcon.h | 238 ++++++++++++++++++++++++++++ drivers/bus/fslmc/mc/fsl_dpcon_cmd.h | 175 ++++++++++++++++++++ drivers/bus/fslmc/rte_bus_fslmc_version.map | 2 + 6 files changed, 648 insertions(+), 1 deletion(-) create mode 100644 drivers/bus/fslmc/mc/dpcon.c create mode 100644 drivers/bus/fslmc/mc/fsl_dpcon.h create mode 100644 drivers/bus/fslmc/mc/fsl_dpcon_cmd.h diff --git a/drivers/bus/fslmc/Makefile b/drivers/bus/fslmc/Makefile index 7d9f4b6..38d884e 100644 --- a/drivers/bus/fslmc/Makefile +++ b/drivers/bus/fslmc/Makefile @@ -66,7 +66,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += \ mc/dpmng.c \ mc/dpbp.c \ mc/dpio.c \ - mc/mc_sys.c + mc/mc_sys.c \ + mc/dpcon.c \ SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += portal/dpaa2_hw_dpio.c SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += portal/dpaa2_hw_dpbp.c diff --git a/drivers/bus/fslmc/fslmc_vfio.h b/drivers/bus/fslmc/fslmc_vfio.h index ffed62e..eddce31 100644 --- a/drivers/bus/fslmc/fslmc_vfio.h +++ b/drivers/bus/fslmc/fslmc_vfio.h @@ -39,6 +39,7 @@ #define DPAA2_VENDOR_ID 0x1957 #define DPAA2_MC_DPNI_DEVID 7 #define DPAA2_MC_DPSECI_DEVID 3 +#define DPAA2_MC_DPCON_DEVID 5 #define DPAA2_MC_DPIO_DEVID 9 #define DPAA2_MC_DPBP_DEVID 10 diff --git a/drivers/bus/fslmc/mc/dpcon.c b/drivers/bus/fslmc/mc/dpcon.c new file mode 100644 index 0000000..b078dff --- /dev/null +++ b/drivers/bus/fslmc/mc/dpcon.c @@ -0,0 +1,230 @@ +/* Copyright 2013-2016 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. + * + * + * 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. + */ +#include +#include +#include +#include + +int dpcon_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int dpcon_id, + uint16_t *token) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_OPEN, + cmd_flags, + 0); + DPCON_CMD_OPEN(cmd, dpcon_id); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + *token = MC_CMD_HDR_READ_TOKEN(cmd.header); + + return 0; +} + +int dpcon_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_CLOSE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_create(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + const struct dpcon_cfg *cfg, + uint32_t *obj_id) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_CREATE, + cmd_flags, + dprc_token); + DPCON_CMD_CREATE(cmd, cfg); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + CMD_CREATE_RSP_GET_OBJ_ID_PARAM0(cmd, *obj_id); + + return 0; +} + +int dpcon_destroy(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + uint32_t object_id) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_DESTROY, + cmd_flags, + dprc_token); + /* set object id to destroy */ + CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, object_id); + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_ENABLE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_disable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_DISABLE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_is_enabled(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + int *en) +{ + struct mc_command cmd = { 0 }; + int err; + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_IS_ENABLED, + cmd_flags, + token); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPCON_RSP_IS_ENABLED(cmd, *en); + + return 0; +} + +int dpcon_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_RESET, + cmd_flags, token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + struct dpcon_attr *attr) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_GET_ATTR, + cmd_flags, + token); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPCON_RSP_GET_ATTR(cmd, attr); + + return 0; +} + +int dpcon_get_api_version(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t *major_ver, + uint16_t *minor_ver) +{ + struct mc_command cmd = { 0 }; + int err; + + cmd.header = mc_encode_cmd_header(DPCON_CMDID_GET_API_VERSION, + cmd_flags, + 0); + + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + DPCON_RSP_GET_API_VERSION(cmd, *major_ver, *minor_ver); + + return 0; +} diff --git a/drivers/bus/fslmc/mc/fsl_dpcon.h b/drivers/bus/fslmc/mc/fsl_dpcon.h new file mode 100644 index 0000000..0ed9db5 --- /dev/null +++ b/drivers/bus/fslmc/mc/fsl_dpcon.h @@ -0,0 +1,238 @@ +/*- + * 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 2013-2016 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_DPCON_H +#define __FSL_DPCON_H + +/* Data Path Concentrator API + * Contains initialization APIs and runtime control APIs for DPCON + */ + +struct fsl_mc_io; + +/** General DPCON macros */ + +/** + * Use it to disable notifications; see dpcon_set_notification() + */ +#define DPCON_INVALID_DPIO_ID (int)(-1) + +/** + * dpcon_open() - Open a control session for the specified object + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @dpcon_id: DPCON unique ID + * @token: Returned token; use in subsequent API calls + * + * This function can be used to open a control session for an + * already created object; an object may have been declared in + * the DPL or by calling the dpcon_create() function. + * This function returns a unique authentication token, + * associated with the specific object ID and the specific MC + * portal; this token must be used in all subsequent commands for + * this specific object. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int dpcon_id, + uint16_t *token); + +/** + * dpcon_close() - Close the control session of the object + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * After this function is called, no further operations are + * allowed on the object without opening a new control session. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * struct dpcon_cfg - Structure representing DPCON configuration + * @num_priorities: Number of priorities for the DPCON channel (1-8) + */ +struct dpcon_cfg { + uint8_t num_priorities; +}; + +/** + * dpcon_create() - Create the DPCON object. + * @mc_io: Pointer to MC portal's I/O object + * @dprc_token: Parent container token; '0' for default container + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @cfg: Configuration structure + * @obj_id: returned object id + * + * Create the DPCON object, allocate required resources and + * perform required initialization. + * + * The object can be created either by declaring it in the + * DPL file, or by calling this function. + * + * The function accepts an authentication token of a parent + * container that this object should be assigned to. The token + * can be '0' so the object will be assigned to the default container. + * The newly created object can be opened with the returned + * object id and using the container's associated tokens and MC portals. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_create(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + const struct dpcon_cfg *cfg, + uint32_t *obj_id); + +/** + * dpcon_destroy() - Destroy the DPCON object and release all its resources. + * @mc_io: Pointer to MC portal's I/O object + * @dprc_token: Parent container token; '0' for default container + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @object_id: The object id; it must be a valid id within the container that + * created this object; + * + * The function accepts the authentication token of the parent container that + * created the object (not the one that currently owns the object). The object + * is searched within parent using the provided 'object_id'. + * All tokens to the object must be closed before calling destroy. + * + * Return: '0' on Success; error code otherwise. + */ +int dpcon_destroy(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + uint32_t object_id); + +/** + * dpcon_enable() - Enable the DPCON + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * Return: '0' on Success; Error code otherwise + */ +int dpcon_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * dpcon_disable() - Disable the DPCON + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * Return: '0' on Success; Error code otherwise + */ +int dpcon_disable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * dpcon_is_enabled() - Check if the DPCON is enabled. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * @en: Returns '1' if object is enabled; '0' otherwise + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_is_enabled(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + int *en); + +/** + * dpcon_reset() - Reset the DPCON, returns the object to initial state. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * struct dpcon_attr - Structure representing DPCON attributes + * @id: DPCON object ID + * @qbman_ch_id: Channel ID to be used by dequeue operation + * @num_priorities: Number of priorities for the DPCON channel (1-8) + */ +struct dpcon_attr { + int id; + uint16_t qbman_ch_id; + uint8_t num_priorities; +}; + +/** + * dpcon_get_attributes() - Retrieve DPCON attributes. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * @attr: Object's attributes + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + struct dpcon_attr *attr); + +/** + * dpcon_get_api_version() - Get Data Path Concentrator API version + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @major_ver: Major version of data path concentrator API + * @minor_ver: Minor version of data path concentrator API + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_get_api_version(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t *major_ver, + uint16_t *minor_ver); + +#endif /* __FSL_DPCON_H */ diff --git a/drivers/bus/fslmc/mc/fsl_dpcon_cmd.h b/drivers/bus/fslmc/mc/fsl_dpcon_cmd.h new file mode 100644 index 0000000..f7f7690 --- /dev/null +++ b/drivers/bus/fslmc/mc/fsl_dpcon_cmd.h @@ -0,0 +1,175 @@ +/*- + * 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 2013-2016 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_DPCON_CMD_H +#define _FSL_DPCON_CMD_H + +/* DPCON Version */ +#define DPCON_VER_MAJOR 3 +#define DPCON_VER_MINOR 2 + +/* Command IDs */ +#define DPCON_CMDID_CLOSE ((0x800 << 4) | (0x1)) +#define DPCON_CMDID_OPEN ((0x808 << 4) | (0x1)) +#define DPCON_CMDID_CREATE ((0x908 << 4) | (0x1)) +#define DPCON_CMDID_DESTROY ((0x988 << 4) | (0x1)) +#define DPCON_CMDID_GET_API_VERSION ((0xa08 << 4) | (0x1)) + +#define DPCON_CMDID_ENABLE ((0x002 << 4) | (0x1)) +#define DPCON_CMDID_DISABLE ((0x003 << 4) | (0x1)) +#define DPCON_CMDID_GET_ATTR ((0x004 << 4) | (0x1)) +#define DPCON_CMDID_RESET ((0x005 << 4) | (0x1)) +#define DPCON_CMDID_IS_ENABLED ((0x006 << 4) | (0x1)) + +#define DPCON_CMDID_SET_IRQ ((0x010 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ ((0x011 << 4) | (0x1)) +#define DPCON_CMDID_SET_IRQ_ENABLE ((0x012 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ_ENABLE ((0x013 << 4) | (0x1)) +#define DPCON_CMDID_SET_IRQ_MASK ((0x014 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ_MASK ((0x015 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ_STATUS ((0x016 << 4) | (0x1)) +#define DPCON_CMDID_CLEAR_IRQ_STATUS ((0x017 << 4) | (0x1)) + +#define DPCON_CMDID_SET_NOTIFICATION ((0x100 << 4) | (0x1)) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_OPEN(cmd, dpcon_id) \ + MC_CMD_OP(cmd, 0, 0, 32, int, dpcon_id) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_CREATE(cmd, cfg) \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, cfg->num_priorities) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_IS_ENABLED(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 1, int, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_IRQ(cmd, irq_index, irq_cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, irq_index);\ + MC_CMD_OP(cmd, 0, 32, 32, uint32_t, irq_cfg->val);\ + MC_CMD_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr);\ + MC_CMD_OP(cmd, 2, 0, 32, int, irq_cfg->irq_num); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ(cmd, type, irq_cfg) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, irq_cfg->val);\ + MC_RSP_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr);\ + MC_RSP_OP(cmd, 2, 0, 32, int, irq_cfg->irq_num); \ + MC_RSP_OP(cmd, 2, 32, 32, int, type);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_IRQ_ENABLE(cmd, irq_index, en) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, en); \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ_ENABLE(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ_ENABLE(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 8, uint8_t, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_IRQ_MASK(cmd, irq_index, mask) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, uint32_t, mask); \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ_MASK(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ_MASK(cmd, mask) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, mask) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ_STATUS(cmd, irq_index, status) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, uint32_t, status);\ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ_STATUS(cmd, status) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, status) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_CLEAR_IRQ_STATUS(cmd, irq_index, status) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, uint32_t, status); \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_ATTR(cmd, attr) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, int, attr->id);\ + MC_RSP_OP(cmd, 0, 32, 16, uint16_t, attr->qbman_ch_id);\ + MC_RSP_OP(cmd, 0, 48, 8, uint8_t, attr->num_priorities);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_NOTIFICATION(cmd, cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, int, cfg->dpio_id);\ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, cfg->priority);\ + MC_CMD_OP(cmd, 1, 0, 64, uint64_t, cfg->user_ctx);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_API_VERSION(cmd, major, minor) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 16, uint16_t, major);\ + MC_RSP_OP(cmd, 0, 16, 16, uint16_t, minor);\ +} while (0) + +#endif /* _FSL_DPCON_CMD_H */ diff --git a/drivers/bus/fslmc/rte_bus_fslmc_version.map b/drivers/bus/fslmc/rte_bus_fslmc_version.map index 90db78c..783c3e5 100644 --- a/drivers/bus/fslmc/rte_bus_fslmc_version.map +++ b/drivers/bus/fslmc/rte_bus_fslmc_version.map @@ -53,6 +53,8 @@ DPDK_17.05 { DPDK_17.08 { global: + dpcon_open; + dpcon_get_attributes; mc_get_soc_version; mc_get_version; qbman_result_SCN_state_in_mem;