From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM01-BY2-obe.outbound.protection.outlook.com (mail-by2nam01on0065.outbound.protection.outlook.com [104.47.34.65]) by dpdk.org (Postfix) with ESMTP id C13DB56A1 for ; Wed, 28 Jun 2017 17:17:15 +0200 (CEST) Received: from DM5PR03CA0043.namprd03.prod.outlook.com (10.174.189.160) by DM5PR03MB3275.namprd03.prod.outlook.com (10.174.241.34) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1199.15; Wed, 28 Jun 2017 15:17:14 +0000 Received: from BN1AFFO11OLC001.protection.gbl (2a01:111:f400:7c10::125) by DM5PR03CA0043.outlook.office365.com (2603:10b6:4:3b::32) 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; Wed, 28 Jun 2017 15:17:13 +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 BN1AFFO11OLC001.mail.protection.outlook.com (10.58.53.72) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1199.9 via Frontend Transport; Wed, 28 Jun 2017 15:17:13 +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 v5SFGaPn032734; Wed, 28 Jun 2017 08:17:09 -0700 From: Nipun Gupta To: CC: , , , , , , Nipun Gupta Date: Wed, 28 Jun 2017 20:45:48 +0530 Message-ID: <1498662964-11251-6-git-send-email-nipun.gupta@nxp.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1498662964-11251-1-git-send-email-nipun.gupta@nxp.com> References: <1495735361-4840-1-git-send-email-nipun.gupta@nxp.com> <1498662964-11251-1-git-send-email-nipun.gupta@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131431366336843764; (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)(39380400002)(39450400003)(39840400002)(39850400002)(39410400002)(39400400002)(39860400002)(2980300002)(1109001)(1110001)(339900001)(189002)(199003)(9170700003)(104016004)(53936002)(50466002)(189998001)(110136004)(4326008)(2351001)(305945005)(54906002)(76176999)(8936002)(8656002)(50226002)(38730400002)(48376002)(105606002)(50986999)(106466001)(47776003)(356003)(5003940100001)(77096006)(2906002)(85426001)(2950100002)(8676002)(6916009)(33646002)(6666003)(36756003)(81166006)(86362001)(498600001)(81156014)(5660300001)(2004002); DIR:OUT; SFP:1101; SCL:1; SRVR:DM5PR03MB3275; 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; BN1AFFO11OLC001; 1:QoDG6mPtGulDFsG0WE+QyuNqJfsnfNJ8xlfqS/O5?= =?us-ascii?Q?WTxb5PX5BGRfbOjVxpazaHseUHUY0e9WEep0C90eyn15ulpE8QP1LbaYAMkr?= =?us-ascii?Q?B5KNxFCcEVx+m4Z/LSVRZ79c+SF50UeUAPWau0stAewr8k/hSSWnFidVZat2?= =?us-ascii?Q?C4rAAPF8Jq8enSKPGwfOk8K62G7PoshEDH/CXR3EF8YkdvwB+Pwv58mwJBTB?= =?us-ascii?Q?dCVQrVNTqO0OZJBV8BWu0QR/xkHGRgMENoGql8UgM5du/7M9Qjwq9vIJPGNR?= =?us-ascii?Q?egiYX4gXLtaKk6qX2yuM2bqycn37WkQfN6tpvzpzz1FRLKfkQpF4Ocd6yON7?= =?us-ascii?Q?IaXE6Pcly2r7WvULLJlYQPuAKuD+bgTDtAQ1S4TZr+MZy9x+JgtschHcG8LP?= =?us-ascii?Q?BUtFIYbgqjHef6TGnNwaoYAqYVP6Km0BMtJOrLgwjTPr0u+SEedBHu4ugAyb?= =?us-ascii?Q?szA381fXQUsF1x8nWzqFy26EJp5aDoCqQ+PQkXC+0zaNh7zR49GOHFGXcsJM?= =?us-ascii?Q?SZ8qC2RGlPriSAb7GtsFw77vf0y5st/TBqD1H5IA73RYg1SmGq2qTkz7lxQu?= =?us-ascii?Q?TT3ZTgNqiUug74Zg3xLo6M23K2z+XqkI2jb4rk6CQtosHp575M1tFaYmQAt8?= =?us-ascii?Q?2jSTm7Hsz2rZubbW8syzsiHaqPACrc+3g9M5mPUPWx1Hnue0PomxLmebjwXU?= =?us-ascii?Q?YtnLKOYuI3rnIpaDy9w2Isxs9w6lJvp1Im6Z+n33EfH92C3wECUvGgyi9OVW?= =?us-ascii?Q?0Vg8QRl6Ct6puR1BOkbtULTHoAzk1c9/17oYkqLtd2VrT8L4z6lOl0HQoG63?= =?us-ascii?Q?BI6uR4Q6I+sjerM8XDtKZqGkrVjuaBnk0HT3pXf0/1NW2SFpOozgrl5pJAWE?= =?us-ascii?Q?DMPCzr96AW+h5WGcfRJvvedDRomlesb3+0l75iyp34EkjHUQ5oElWResHxNr?= =?us-ascii?Q?SmLP/eei66C7QAox47bVSjvssZqCEccDbOHDs2PSjljG8IE0P7FbWEf2M/nz?= =?us-ascii?Q?zyyVnUI+UEc0z1HXzgsooLy6Bp6OOwGD+39GfmL5faEYdqjbuRPPU8htFPpr?= =?us-ascii?Q?x76oSjQhsxXCDHHR7C0OovtYBpxJzgaMBeVPnunqNOBgqFLIiw=3D=3D?= MIME-Version: 1.0 Content-Type: text/plain X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 256c8b74-561b-4328-0ff4-08d4be38c151 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(22001)(300000502095)(300135100095)(300000503095)(300135400095)(201703131430075)(201703131517081)(300000504095)(300135200095)(300000505095)(300135600095)(300000506095)(300135500095); SRVR:DM5PR03MB3275; X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3275; 3:Ui8UvuoI/905VqaIKx0f//nvTw+v0kJdTNQMFrJiN3OjWOdlJfuAZRMeLhF9FHajL01hvpYGEcVycAGnnpXIR0tfUIbjOjJeZb+T8+QZMK5GccACV3Pa8Z/L7oT3mkC9z4kkx3qog1qX9PMMp3D/rKCVybF5KeFmcRTgA62FCztBC4wGPtYmhNF2GuJUIi9OMg8ABcT+m9oMDi7cT/wFzzfVI/V6mIhVujYnbWS5wYZc0MIn9w3eLQrpe4eI1rCrMMmcUKieTHojOC6ugsI84JEHRionKhnVAFUGEM9+aGq5qO18SUr56Kd6C87boIS5jXgXOUnqV69c62nablAFa2j1I1J7D3jUFjfomcxqqp3UnjiYEXd2sbLar19TeJwwjMmqiVhIJgHim7bQ1La6lWNPW/vkiZe6W9+EYN+py/ZgNpiViG9EDoU6uO5WcH3KqhdoAEXxS4bj5fU9PmkKSBvAjdcY8BeyLZO4zqG2J2lZSBY3urhZrzx6rVHvYwqN0TXtngJoIaDeKbSTTD1Wvb1UDsB0PBvdW5Ed2YmdiM7p7TB2J9qaQgBJ0DyxsYOwK2JzaKUsWsypfyYThNN14EHtSbJzQRKWz9klPnlI9cpfsj6brIg8B9nq0+gASIV3MpV1IFHDnTWgCFWkcZX5K+F5kLfZq6TFLEa3urAbN2uSwNLO0bH4HHALHEBZWjNFtX08nZOL47GTVWwtpPfhXgNUw/hKeiQDtTTeGamkoxmNHOa/yBgZp0Li+A1uf9mQA0TAaGjZ43F5hzP3Yq6CzyfMWu+MYAXw9WZBSZJgdLAyXxJoK+CAiAJETLP72+LsTOAT1vd6LOjl/W8yAnYunw== X-MS-TrafficTypeDiagnostic: DM5PR03MB3275: X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3275; 25:BrI2Dg1xkzAgzmLWFsk2sUE1hbz+BPzNBTid7sgLQSU9p8PQ7iiP97kYkXKOQKyxI6ZVDE74Pp39DZG7vH6A+G+uw17NyVwt2Rqhx7h9UynWhvzg8nwjEgzWt7DzrpuwPwCDezdLYKgFfhklvAANVRBFw2jC8MMLuLbwSOCSR8C01O21Xxw1aHfyvvnNuoFWZn7ZDYGeJ1TrCZ48ucmeUQ3vVoGAfXxOc+W2zfjlg+dhnIodwHAChKCSfx4I/aY0/Q59D3u4R77RnhaCk2mMU5umhkF8gnxxPWeHSz7vjJMSQ0Ii5jlJrkghqQdbiTe95/+SlXzES7Cxk7yB5nas/bK9rtmeIiFN6LnaCkoSSeIsOgM2JGYs6OOBQHWu201Z/rIwmVz432minvOS5i1lEi4Z0As+uW/Gf/gcpXg9YfJ1zAPlskgOhr+xmfzEQKO46my4k+1Va3WDnWQigxC+0q+RAAXAyI8TgA6FilqlzzZEL1GyuffHR7+81BK7fZ00AYUY0cP45z1qG12GmMpV/CQ4RnOKQtzfeuld24NUQUnKYtZE4LfT2TrXhbGKmQ3qIEYk+GAFRHDrpxrF7MBa0rs0CPJ+5kXaLWkCDlEy9yCThtNC21AYu+gsiSXX+GUGtVA1bjpAlgyFgG0T29KJXZpyZ5aC658jZVc/Jz2wWhX/bXrWNijtpOCnkATCyPkHSxq/f20xsNoW3ufHPkTEm6qDy6nxp5dTxUW66T9mSITS/1RQppxvYFv81Uxe4D3TYYzGIx4dtPTnKW2xiV0/xf/hlCgnaNdLWot5KBY8yJChcn+2fSFBAJw0z7+/1euGYVb+LO8xyXFAhIsg9A8YdGRKdvO5BSeIADeJk/px5epqze+RRgSMEMn8pzAD3uEaIE7eQBdjPp46QXGBSM/ZI2OpzMmXIO6Mt23K5r4hXFo= X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3275; 31:8eqj5aTV2KJ/JvjU6Ao0mECPNgj0XFI8bHiOF/AUYSbdjy3FQx8KqSD9bWYoUw8lIRTUkWPRuHv2Ehq7bmVG710pBe72GjLEdg9n7NhNoTUpiuab9H3/YfdGY3PWEjrjUf3BFnTQfjdJfJPQwa1f5DWvxbD9HqOukogsWNEzhVRZOip0vBm03J6SJ1yHTNdSB7D65hluP175axeA76ELJwRbtMzk0ER57ve5TAnTmj8XnNBxMBoOV5ppPIwehk7WmkMFFom9BaV1rOpw0FlHHCF0mL9M46B1DUPE+Uio0V0GpIMyUn1dpBqBSuKD1hOLYSlPNQFSH9IFcKAVbXaRWkipnGV7jVaSrKBhXZ3Hw/AeOrFICMf6ViqRWgVKkvZVVgPVk9NyBly3UKXwwGYFLCZ+WfUoY+UjrI+Cl96Fu/N4EdOk9rZBUzWxM9hOX9rsynJZLZpAcyuW6WPWTZBvEHSwKpG/BxsRm88tDtnACthogYaZD62eRBhV8F5oPCKrhg+KNtq4U1Sds9W+AFZtsaOtICIVWNMNvONNsar9kYJKQvQ+3ysSnIq0DGjHwi16J5Vlzw82NnKLaB/l46FyfAy66txdca2QF5gJNk6mk7ueDHPGfZCVEY9DGwvEOnpqcElPJAmV6SZcw53ZJLd/9OZzMNVS4c7UMPftgXgy62Sv6SVw/xmWh2ZoZKLZK65LC9vh6lIXIi9uhb5+V0lyqQ== 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)(8121501046)(5005006)(13016025)(13018025)(93006095)(93001095)(10201501046)(3002001)(100000703101)(100105400095)(6055026)(6096035)(20161123565025)(20161123559100)(20161123556025)(20161123561025)(201703131430075)(201703131441075)(201703131448075)(201703131433075)(201703161259150)(20161123563025)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:DM5PR03MB3275; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(400006)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:DM5PR03MB3275; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM5PR03MB3275; 4:hQhdV//+tyJz86E8EV5dzD/ZZkidR+twVXKnb5Bqjw?= =?us-ascii?Q?6RJhxOetHRCXQ0GR+eOFGZiaJRxHYXFgbYfqX6fEiMCQcL64fxSoHPXHbMTQ?= =?us-ascii?Q?MNsJEOQwVAkED19atRreZ3QrgAvKcenHC9rx/MP970WCEMdoAYcchDdU9oC3?= =?us-ascii?Q?sJE3d8L8WoMMgGGMZqp72Sw3eAuoGuCpy1X4r0s5PNWAP7nDv9VPAU3Ih4b/?= =?us-ascii?Q?35hb9Bgzro9U2zi09iK79AaSt78DQGikRN4N4F0jkc71C7lVa6LNsiUtG8Sm?= =?us-ascii?Q?R1EH9IM3Sn0+NDBqWnCPDJWE0N3sZCGEgKWoYBIS0DFpqhf4kAOnwWgDCpiA?= =?us-ascii?Q?XxBQOg6uU9C72oD6uK98amTJFjQ65+Odb7mZFgMJMQoz6G8hMAvguCKHrpUd?= =?us-ascii?Q?859J0BfrQNi3iPWc1DfB9c8RtO/Ai2j6QEv1aztlSsGJuc1qLnT1y+LNGgdm?= =?us-ascii?Q?viFwATr/J0t841QfQLUB9Rvdnc4VP9oA3ylkWuGy91Mwfxj62lOKP45Czscz?= =?us-ascii?Q?HkViU3lRLrwQeAHLmpT18Bn1alUGFNA9jQy5WuT2iW56zt8lShpe9gHewwz0?= =?us-ascii?Q?20RCLZ6SY8CHfGWnW3rieCNnODHQaO3vpp/44tVCzvi/UgB1bVQeQVhAUg1e?= =?us-ascii?Q?X/N+0XEcbinH96XiHgqHWr+BSq5zyqyoA/ZiRzi6EINXOVqzcfJLvFV70gVv?= =?us-ascii?Q?Y6tcnSH/k86SpOnFvhcgxmerJ7vGT35csOP/OL7np9Xla7GmLgpu9tQB1KJw?= =?us-ascii?Q?j6wGR/808c0TE1lMIBe3mr80ZpG076/m+g9VilpKHDWybUxLqX67JcD3U3k7?= =?us-ascii?Q?CDRb9Zk6kfgMWerK9tSIYNU+XJ1zunl4NQwGCgtNJ0OQOTSqYaKaeuIco7vX?= =?us-ascii?Q?xjJIkjwXFAFXkRuK8c+zSJislqq4Mwn/ZUAu05+V5lIFgXPxWMDq3ksddXTz?= =?us-ascii?Q?ag1OKoToR+ynErc/7HrLCCYV2Rahen1mlU+VILG72C8dlR8czGXSkUzaNwKr?= =?us-ascii?Q?ud75emT/DN1TM2DDuRY+4xifi+l1Rz6rQ/qQbIQEYpkRpC9haZxXUtU+A/9R?= =?us-ascii?Q?L1hR8PwtBRGaB0uGLWwkPVUVslzUdznLqP8kP1WDlgFYK7jZVE+hqZmysxs/?= =?us-ascii?Q?4VnrwHUawtj5xd9g0yCszT1JD9N0IaApRRpRjS2FYQOMM6/MijzjfCFynpz2?= =?us-ascii?Q?e2lmw6ggrS4wr1YAKGl7hThUTIKnkCUHlm3yBMAX58YNgzW0Ch+rm8z7490y?= =?us-ascii?Q?aWF9Hg62djtH5UqmhwK1ZDQ4FGb31k+zlQ/RkWOE2+bUDvh1/t/ZOB5Tbx87?= =?us-ascii?Q?RuLzs3qsn3DhpUuKG/b1Au0v13orWgqxMHCToD+K5jvYqDUCY7bEJrnAjG2x?= =?us-ascii?Q?wE0Gfl6roNaka8PqzTD9iFEt8latx92jc5ukWH17qPb6LfDjOIKTAVZtk0tA?= =?us-ascii?Q?VpmoZ5nt9jYE4ZCdkmKcBctqxeDxPYNSMagKCazybrTVFJ7eM7BDNmIWEUbs?= =?us-ascii?Q?n10T4l2mPE1b/mQaS/jGe7yb9s4OroXys=3D?= X-Forefront-PRVS: 03524FBD26 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM5PR03MB3275; 23:K7OLk7mZn9ENvMcjtaP6f6wMJBZ9kUHLM5bG42NGN?= =?us-ascii?Q?5NWRqzSvyLEIA24+WBWAXtAC9TULSdTgmEP3YxdfKl5/HNOS19KClG/8c0nR?= =?us-ascii?Q?fpkerFCWJ34g9g2XxkyTdzd1Yu9xH7Fw1dpDpG2BmXvrLdcHrMt5Xwpe3qee?= =?us-ascii?Q?qVbwlrT2uE94R785t/bRfVTzehuW4r4tsg/rQ9Zsoq4lqZO8IZ2IqCGtTxoM?= =?us-ascii?Q?p5R+o6cha7VP4P1Va+2JQp+wiHKgoTMxjwCV5/LKb1Wh2NNdm0tuvL1hoxS9?= =?us-ascii?Q?g/Ihbugc9RvzWUElfBkdTufFGQwYxHaMbsCd7AcSg4A9AF5jEO2Mt1y+eMql?= =?us-ascii?Q?z2wE71lo9O/cMvj3X2eQoWnJcOKYINNdMBLKysgq5xIlshm1k0RL4qqNhc9m?= =?us-ascii?Q?re0URkqn6qCo050WKSDL+1K3Ucl7l2LgbYhL6rhcQ3u/ly8PYRM85lmHso7q?= =?us-ascii?Q?32i8I1r7Hi4AcpXMw+QH/G0rIvsAgFK0V+Tm7FD6n7HVSD0W8DTYiquYL54V?= =?us-ascii?Q?EilMy12vkZ3qpXQOPn6MIaFfYeV+R+kJEsBoJOTHh3rJdA0YW4qDaAXtcer5?= =?us-ascii?Q?XJIStqRA+MVIQS9MayZ0qPycI5xAM8Zcb6C7FzKGq7bmvXY9W5FOmoFv7ddJ?= =?us-ascii?Q?BS+17nApfHIQA2fgZDN1uRVASzjuGX4e01dZtUQPc/mKd5A27Rr/HGQEldUn?= =?us-ascii?Q?3hRoIgnWeGgVdswjRm3uJEH/B9GCFrf1gF2ctb9X9CiRK3UWvqCWdW36tNyP?= =?us-ascii?Q?BW2cf1S+b1PI6MBEnQLt2q7c9yVLMBO25Ibly/LBvHaKTwR6R8TY1fJAMi/B?= =?us-ascii?Q?utHpFMulV9E8Ai1KaQGj+jDfq3nexNSvbyCtKGdknf/Hc52E8ckIo39LGZ8I?= =?us-ascii?Q?9jNxLoH92vJcHygu//yq78QVyhBrW+qLwDPc/k+BAsW/r8QOCzNgupASAXL5?= =?us-ascii?Q?DNEN/oR4bkS2OP1fT4WlH48m/2iB4ojhBNqyOiE3TMx59VHRU/Q/bGZTUuxK?= =?us-ascii?Q?BG39NHn2s0riWCu/oqzWee8cRFZDBYn1yy51d6U/Tc7EcyX+pNuhJ8pTEXCM?= =?us-ascii?Q?P0hQTF8TauUnehq5fPxGyWbd+Y1jOreZxzv7jeRgIcSHuDXdzJTZAIwupIT1?= =?us-ascii?Q?IvjjTjjqD7PX7PpLlIqxduHhuARDdGcdp9ZVkYkE/F6/KhcTwtUHTk7DkRB5?= =?us-ascii?Q?52mifc2Gx6AXp/ETYK5DziF9B2/QL/pknvGQjGW9bNAEIJECd/H2Urih+6BV?= =?us-ascii?Q?L8mevTdkpeV/BJWk7e+g7Lo7RIrVfJs0xPOsPSK?= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM5PR03MB3275; 6:OlCnpDwXsGBpYaNcpCNE4TMThwpuVwPA6i88nequ2I?= =?us-ascii?Q?4b1JnkH3zX90j3PAG7qM0OGYZHrlYc8Ayb74bdabENXVFxSUGkkmaxKKXW7q?= =?us-ascii?Q?0clDnC3BzDeanQrBhNxQ7EAeZmKf82enb0QKOuua5cUyOQIjdc5p3z7H574F?= =?us-ascii?Q?gD5gRD4q1881BteCIQjWQW99d0eOTKdVjhUTPTAW9Me0OvAMHe/7iqmbZ+Be?= =?us-ascii?Q?tnPTr4JkGSAEQzz6YypC1onp2eBaMoxFSKM4XcsYJN9LHbnRpzkEE8k/caOy?= =?us-ascii?Q?bsalmrkqWlIrPAI5rPUQSWxZNin0+VCXKKA9aiyV/VIVYk9OSYVGF+/3rBy6?= =?us-ascii?Q?XznQTWP4ammk88mvJzY51AgVlLOC20odnL7U1koeVQviPrJsNhClbHeWOTAi?= =?us-ascii?Q?WH4NLfaZI+2Z1etxrqiP8RcT9ZNHyTLal6fxR7SBHeJ9a3UVrW54LJVZf3fr?= =?us-ascii?Q?zmHR2YG4/pKryNOPokrw7UYELktE3msoeCR7xcJX033PUUT/9Z8DITGJARtJ?= =?us-ascii?Q?bRmPQETBNhdY7gqYtCXTJZ7j4IqzSaOkv4Mwege6vsK5+xBRFAKaeXOThV/5?= =?us-ascii?Q?4rqGZvmrcTicVKkysjycKdAqaIeRPQhnYPqxwjYn7eXI3L3FRQSFE0e25N1f?= =?us-ascii?Q?VjslBcLWA+M8+aIVy7B+x4w6jPlFGZlJgYpmTLo+CcYsBwLYO6jWovWQm7ki?= =?us-ascii?Q?m3mcmS7Lfu+619VKbUSBiIgYzl6nNhc5EWlZFZiNpV1YUzkwJGxH5iO1Sh3L?= =?us-ascii?Q?GRZDK2zkfqw/G1gaLxFnaU8YgJKabTyxH7Gq3X9vbnlE19G7zEqngJnQ7fgB?= =?us-ascii?Q?fKKnUv/TF0nreHtqNi1grBGd/Jw+yMm5sVedlsGDMha6g/hmhBrlSqqwXZ1d?= =?us-ascii?Q?F87UaTtruFO0GVGHHgcoHzfInqNDk6mVG7XiwbmKIOIugQJaTanGfAP7Crta?= =?us-ascii?Q?ieHc6RFZ3e2Dh1aM3DSa1vhXqg08DJzozyA+K1vw=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3275; 5:q69OZu6OBwFaZdo+Un67wYJ8XTPRmK2+iCA16fc7Z1OTxJXKFpi3bnt5lTEphuHb3KseHz1+EMIi/IrAJ3sOPRsp0X2ZQOiIZSpbosk4cGBjWDT3DAYwtmkFS4BJCE5myGWPM9SigmS9c4sY02yWUloYalsKsBZKpurtwvOqJcpl/UPKPekEc6g7RJXpoE3kWwrSSmQ0oUa83FnvJt3XxqG3rQLw+lBRdCBC+DvI4fBtImMOWT+gcPy7N7rdA+3OwULGD4Omz4hFYzFfA0sDY7VFc1PBdBQ6qjRBoWwJKRw3+B4Bcg5cutEoXfLgc90pL94ZIc88UYtK2yqII4rrLQeIgmJQsJSvbRtxf2fUcAK6YJCbCw284lJ/vP3meeTDoELfCTcEL8p1TLDMZOfeN+hx1MU7YclBKxq3zEQQcrA3ByiZgGfZzjifCY4YdL+U+fnJz3UU7GL7Jg2D/gewXlPznws8Q27at3lN1p57rWssu8G9RpN74BcI7R/aMOGUsD7Y5YSnTn+kPm7Vn5C86w==; 24:TOU3roMSJsuuOnJm9I2I8lW5OfY04ZifYkpV4SVKKqFBfJJodNgPHkXNPpuMPyeeYQvub9y1Z6l49x5fuDLxwri3yRhODMknZYvt2+qz6zo= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; DM5PR03MB3275; 7:dhb16+aqtF2wV7np/Vcy7ZizHzly8oL2+hzjaaoz8M04w7HX/lJol2Fo4c+Zq68wLOy69mTiuwXG2CxQtyYSOG7Z5qxLnZ5i5Mq3nuQsbSNfdt9hpu/HuTI2N27mIhNpvjWcpcKMX8qIAa53UWKlWCowOS7gw8BLoEQI9hf1x1O3mcd22Ko9tv6307E2Rckd0MRM5X7hZBfc1oK+MGQ40+zVwlFjHmGRAiIQjtXDHplEECyDmHF/oK2idxrcDlIG7B6pP9Btwn0tC+Eodi+ze9bpWWFBq6gOyHRftyJckGKvTaPvmJw281NmwLDZXahN7dRaeoTt1uAVcnsHfvacgBAT+R/WAlnOtwM7wj80XTLJOMi/zBYVpuib4Qy6UkrO+dLZeuDnQQTbi87TSImMC5RVXDN5TIW1PC6vX3numGBJdnS4DoeN/D/IOl4Z12PWBn661HvMvAJNXoY+MDAJ/ve7EqbklgGITjMWY9yPnOg7Sdr4/+pTDZeRLjlvMUyOQbVtksLC5Zhe3wKMkZ3QKy28FWWPCioN6ImUwLHyQbc9iS15GP1xfHiYRRnyfjDFNMuIJVYs40YnkN2yEPAEUpIwhdmXlenWvJkdGgDNCOCvlyQVVTlzzDxmLn6O0MxaabcUGrJ6130JlP90vGH5s2YkqxUzoeE8mIf2YRldRqbaXcsTms+FKHNb4Dac18sb2nOt0MWPruaWk+h8MDLZewDIb4KGuCjOXdJE3QNcwg9WvROvinTkMXVMdMNFTRbKx3KW/amZA5JGBeX0CKZnBpkiOcf/2eM51agHiIVJspw= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 28 Jun 2017 15:17:13.5127 (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: DM5PR03MB3275 Subject: [dpdk-dev] [PATCH 05/21 v3] 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: , X-List-Received-Date: Wed, 28 Jun 2017 15:17:16 -0000 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; -- 1.9.1