From patchwork Mon Jun 26 18:06:52 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Kalderon, Michal" X-Patchwork-Id: 9810155 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 81B4960209 for ; Mon, 26 Jun 2017 18:10:01 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id BA6AB2851D for ; Mon, 26 Jun 2017 18:09:41 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id AB640285D2; Mon, 26 Jun 2017 18:09:41 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_HI,T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id BF9A52851D for ; Mon, 26 Jun 2017 18:09:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751424AbdFZSJh (ORCPT ); Mon, 26 Jun 2017 14:09:37 -0400 Received: from mail-sn1nam02on0050.outbound.protection.outlook.com ([104.47.36.50]:19456 "EHLO NAM02-SN1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751376AbdFZSJf (ORCPT ); Mon, 26 Jun 2017 14:09:35 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=CAVIUMNETWORKS.onmicrosoft.com; s=selector1-cavium-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=NhaEpPMbbLdTUFcs+VFVyajC7EuRvTgO/Z94Te+lt48=; b=VHFDQZm8ioZ2ynzxkmuQES9OAzMCXTgQOfeMg3NKr38bzy8I4Ux5ymmNb5HfToKrX++Nf1oCnFBrJJoZTpOcqnv0SpaWKtjvqYX+sXB9VDXW6b7/zpWL2VpNsMzT/yTVqE7kZ9Xp/kHToZZP/eRt6jFuLPG8lodvzTI6Cr1b6F4= Received: from CY1PR07CA0009.namprd07.prod.outlook.com (2a01:111:e400:c60a::19) by CO1PR07MB426.namprd07.prod.outlook.com (2a01:111:e400:103d::23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1199.15; Mon, 26 Jun 2017 18:09:32 +0000 Received: from BN1AFFO11FD024.protection.gbl (2a01:111:f400:7c10::183) by CY1PR07CA0009.outlook.office365.com (2a01:111:e400:c60a::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1199.15 via Frontend Transport; Mon, 26 Jun 2017 18:09:32 +0000 Authentication-Results: spf=none (sender IP is 50.232.66.26) smtp.mailfrom=cavium.com; vger.kernel.org; dkim=none (message not signed) header.d=none; vger.kernel.org; dmarc=none action=none header.from=cavium.com; Received-SPF: None (protection.outlook.com: cavium.com does not designate permitted sender hosts) Received: from CAEXCH02.caveonetworks.com (50.232.66.26) by BN1AFFO11FD024.mail.protection.outlook.com (10.58.52.84) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA_P384) id 15.1.1199.9 via Frontend Transport; Mon, 26 Jun 2017 18:09:31 +0000 Received: from lb-tlvb-michal.il.qlogic.com.com (10.185.6.89) by CAEXCH02.caveonetworks.com (10.17.4.29) with Microsoft SMTP Server id 14.2.347.0; Mon, 26 Jun 2017 11:09:13 -0700 From: Michal Kalderon To: , , , , , , , CC: Michal Kalderon , Yuval Mintz , Ariel Elior Subject: [RFC 02/19] qed: Implement iWARP initialization, teardown and qp operations Date: Mon, 26 Jun 2017 21:06:52 +0300 Message-ID: <1498500429-22557-3-git-send-email-Michal.Kalderon@cavium.com> X-Mailer: git-send-email 1.9.3 In-Reply-To: <1498500429-22557-1-git-send-email-Michal.Kalderon@cavium.com> References: <1498500429-22557-1-git-send-email-Michal.Kalderon@cavium.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-Forefront-Antispam-Report: CIP:50.232.66.26; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(39450400003)(39840400002)(39850400002)(39400400002)(39410400002)(2980300002)(428002)(189002)(199003)(9170700003)(6666003)(2950100002)(104016004)(5003940100001)(38730400002)(8936002)(107886003)(5660300001)(47776003)(2906002)(53946003)(356003)(50226002)(8676002)(54906002)(81166006)(86362001)(575784001)(77096006)(2201001)(105586002)(478600001)(36756003)(101416001)(50466002)(76176999)(50986999)(189998001)(305945005)(4326008)(72206003)(106466001)(48376002); DIR:OUT; SFP:1101; SCL:1; SRVR:CO1PR07MB426; H:CAEXCH02.caveonetworks.com; FPR:; SPF:None; MLV:sfv; MX:1; A:1; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BN1AFFO11FD024; 1:w63yVDMEoSltRpmyQpwWoPL/hCsL8QFBsy3IcyNAY4oce1g3DYN2h6ScXz4LpIbST7Az7EGDzGoo5J4eCYgE5+nTeswcqCjKIlGJ7sAfiPHm1OESYJqP9exChaJ7HVVQjHXm5r6eN0XkCODJ/YR7iH3bGKLSOgoxPcsZjGB2SLffAbEWkseFNgd6q7qHwJq0rWufDUo63mgp6C5UZZTtKzfCxV96isebbqfgjMKEAMjvX3ATWU457lM8GoyXpHVXzeRU2HQO9cVTh8TfoIFxbLnOVJSaaXz18drZVvLpS4kal9RGtGsm6ocIPYfQ0KYJtds/kYmeqKys15U5twZO2MggE+uzQlinLK6Nzl475vM8vFmN4WRxOQO5C14N9f5OLmrzslTwypotrIMs9b209Z9mmdNy6cmz+HLYCQXWKBOIBOzynH43lgJ+uJGv/8J6ohpcqyBQ9NTKroTiAn7O7J76ymYL0hQsTv0hAMALFazrjoZaGFBnkpsKgOfZzEHYfbKakAOl++DxTPy/tTIhbmgbnQetuD5pLSX3aTfe68iERcGbZ57m6+GtwqLmGVpr2FiiewgerYV6j5k+IJPrBEymVxWYJxENF5UN0rhGRGPggSXkDsVyOohdsPKji8Cat1DidvKjgojjDNadVygcAIb0JN4nLutB4F9NVk1uL7BklYovgwSYp0iuLaaW0PyA42ZDe7iMdsTsNmnR3vasDLp9xh0DY/5AWlTXKPki/M9FzEn/9EI6zvsLHAGYasLmOp4ArYdR/VA2B2Z8AFAZylaOzaxXIv1Aq/qYmZy8DCzkO3R0AuaiL+5d54ljRdPybrs2BRHnIaDQPqO53Oc/nx6/j05PkdVg41Ck9zEeemQ= X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 3795d0b9-6ecc-4d64-2edf-08d4bcbe7e77 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(22001)(300000502095)(300135100095)(2017030254075)(300000503095)(300135400095)(201703131423075)(201703031133081)(300000504095)(300135200095)(300000505095)(300135600095)(300000506067)(300135500095); SRVR:CO1PR07MB426; X-Microsoft-Exchange-Diagnostics: 1; CO1PR07MB426; 3:yr1Y1lkvOK853t3wTd3Hc6zDw2zAlbcsaZkvsXwH3X9QQeF/7j+QColYSW38LdRX7CrBdEHgGwwNlNyZ2mdAqqSllN8ouy8w5yTQfcc/3R0zP5TKqFVjYun3Af/NNtv5FD+3yzQ55eDxOYXKXbpszsQnm1O+oyVluamVk/8HXM10NOkTtGy2vBpguy2PJsVcYSRZkV2KJart8fcd0pEkPAgJ9ovStaCCaFaL9EYqExlUJ/6Hnpf3fDYkb6uIFIoMHW48mwVnbdKLdoMMAbFoZQTtfaOyMEfv8VsQ1O1EobySigTYuWVM+emcYwMcYHteoqTMV+Zjei2s44Na+rU/juVzth6HEMjhKUt2z/iME1X0dwvP6/y4STB+/v59OQr4xeQMmxTsvTok30dEUyi18lc7a8m4IRkEsMZXgGiFn/+1utIHNBczX9rFCozfxcIh4HNT7T8nSucxlKcwW1krLV7uoyunOMHhhzMN4J56PM0QmSkZGzQGasK1K0BTmOyRa7VKixi6lDP6420hZc4sNvt7GDw5Z/hyAIpXBVwfa5xthWoTIr4CokfcOy3CFaDVgGNEZQxC27Z3jwuDAd/kbN6T3OCl7DG+L7b+5GzeksHes5CpXOppkx3JB2ActX9NtV/zFUxK6QVOU6i54PiO6QhkOL08x4XSeii77SO59hbs7L5Qs9Q8zp23ZidNJa2xdYWTc9HZcxwlH5XB5vwp+4Q73MRWHW2MZ0BS+qLkGNTQLvnJ7s8uZ/oz/U3z9Kz+RTwLpx3XM/ip6fmJPEioqSlN2yKFwNMDtF8o8m8+VEypSXqNVGfKkp8XrXmsbO8PnOYXd+8uzYlo6aMaeba5P0GMRrX1sxCMgImr86TLMoext/iTWL1sotW4gb7u3dgq X-MS-TrafficTypeDiagnostic: CO1PR07MB426: X-Microsoft-Exchange-Diagnostics: 1; CO1PR07MB426; 25:zmd7Oetbm8LZk1DEsEiIS7LyiBvEc5nsS+2Lz6QE4pez76O/KfS2jSAO8a66v2WH5psxcXzFL4nHR3oyFSTQEHLaUeEUtcQknky5tR3GbbASgT06fdQDjoR8OdY+9SdnjsJKWFZpejOWOf02cPeCPffaRKNScp0ucz2zc6+NndO3mStSNTCVV6gLhQCg9o2Y2I6KjV31ZR+2eS35+Zg4XyoME1XeOjnAG7MbE0VxXVqeUkt6iXI4RPkG2ZiaGDxGpj/RZzseyUrM8nGQCvvOyiggiFl52w34UllV2enXE+kSjw2OEcIeX7rh+DegA0HAZwsAAI3wJHUTIeODxCNBkE58euVhSg0uABPa+utL7ExH+QhInbKUE7pGcaLQijMuNNcxyTskTsEbKhi61fwWhn/vjXmJE2recinRI7fdUJ12c+/nu2I3/6ZokuJdFWDYqWJxxWwuVVyQ3a+7a1VeLvruzTmE8ZbAlfIt7XVYJutt0/QaQNlHm04HEwKDIuzPp68gL9RN/qwKbbfyJ5kjz7YYGFKrMsbVC+7SlzZg5rkb13EF7441hQu/l8q24bVgdNnsD3XYCOhn/EYsU9HlZTA9swaYIB7CNJY92VyoCRQXs9uKIXooyfWBiBka2rwWLxayze29wZI5DmAWGD6XaJMYSjiiaE/uH6lV9dDiOGfghZK5vPHORZP/EhCX6MMUCzE/TvXNL9/KOIh8LuTAEZT5ma2tWM4WWrqK6N7FjCRAHhiCvwI/80qM0r5CitDwSZhrBH1I3O0Jb/K36kRsG6W7z2rllxstXF7jP6k61NvumfP8haqPboGWAMyBx1uYYrsEnFn/RutybG7kyk8+qPxGk+Hcsy0uDawJ/8S6HWyMhjUiTpNnBi/ls+5V8asm8ZiPCjXpOvqAwSNsodC0qLI1Awz5lPhd3AxScwxtGA I= X-Microsoft-Exchange-Diagnostics: 1; CO1PR07MB426; 31:bDZ9SZiUJP6k//8WlhCqx/Ep+9tbFCspbC8h9tLPxYaNGiHg5JOnB/hv0XWoKA3ndBAvAMMW2b1EhXZCIXIrPQyWouBLdMNMFQ4ZK9xNhnFE+KOOtPJbaHH11ydrSo8ehkVuCMMGpQKaiTP15rWx0K/eicT4LveF6/iY4zPxrIIwmofqUrv3KltbH9srLQqA/nvXPQ5qi9PS1nrCLQ0F02dqQ9EFIOx0czbw15OclZZOcweAgo6c5SDUG0nLQzofnwIcfbol9FktKYEtB/pmcbFGcHKa7RB+0r6Ez/bpFaEKbI37eHoD4kg4TgLclgTk3DHTFwjY16LEEa7+PZSkEES4l+47uHQZdjtSw21S7JXn35vik4/zFaW4kkABv1hsw7RLUM5leW8O9Ayxz3ZMdNT0ld120SA1ZTu00CRXYJNE4MUHMsrebnRUoTSbU2Xi8l9Wm6XTo4tnXOLlDCWs4FEUD9YesQUzloZxQ9tqZNDzQO0colwFrPW72Ky3lbUFED55Dc70xsHbEze5KxH2XiKLq3HKfXNYwntziiehdkx7qGtqfoEjettOnPBsqH/tSP82GZGUcH9MSY4Pfp1xbb5twDOpIBzpgEBjr6BAFZ/dKNnIFjEXu+M0CDdtOUfYnxm8BcvCehKOUAA8pUa0qr884ASMQA5xLpMfSE6G8a0chiEMJ5/ZY9SMgSqHp5JRU/HsdBmXRuQyjRDLs20XdQ== X-Microsoft-Exchange-Diagnostics: 1; CO1PR07MB426; 20:0zzQJAyAWyiF5I2CeiEqlu/qLUp6F6687F4lAindChPZByRlG0PHzm5JBiTRZdxCDWYlV4nJ898LBmCEAqOjMb4GHsfr1CtyPqqPU0Hq7NDUpM+HyI2ru3j9F2vkk9PX349OUe2bUCsmUug9OcdIKoy8xlQf8gm8BrRfzf46Vi7Q7Rz/PemK3AdAIoOEp0SeoN87HTY+xo+s/JJXWYE6AIE/7y3J6bTEwFlXhwJ7D/efNOHJ0BPLgamrDauigRJMK43+evkmqVBz4xmdjBi1N/mx77N6xW70Ht1dVKcl21C3j1I6AbZZr9pbRgmF8lGCgtIZdal8jkSNeWJTNx/PK7uyQd3O5RySC5gD0kJjf5w5SHQF6tgvurzkO4nY1s5QWWoU8mSGEFrXJq1a8zCQPitRRO5EL+06xqNWPbY3i3JDR6OncOsXpc7N2Ut0QLq/0oi4UTt2iv638dwCjFsYGHGbm8wEQCNIKKABRTXUTvSXoV7UnzsEM9RtSoJ7J+EA X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(133145235818549)(236129657087228)(148574349560750)(247924648384137); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(601004)(2401047)(13016025)(13018025)(5005006)(8121501046)(100000703101)(100105400095)(10201501046)(93006095)(93001095)(3002001)(6041248)(20161123562025)(20161123558100)(20161123555025)(20161123564025)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123560025)(6072148)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:CO1PR07MB426; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:CO1PR07MB426; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; CO1PR07MB426; 4:CR4O6HYj8RVj8AKmUCG/VUtlGpnaIaHfJfOeCIeWmcQ?= =?us-ascii?Q?Ga5/iEs5RZApqxziz2eujkYnS6bvDO7HsHQMi3k3N7P1N6SUlaJrqdq25kMW?= =?us-ascii?Q?xAgRZosc7lVMfddQTCPegnEwKbmb5+tIF+lBRS+GKagrG5HMlDZAeGnMg4ci?= =?us-ascii?Q?6NUGtyOh5L8F2C19qkBOpqmTzEypQbLBxtTy4C/HIRHEYSj3gyKPWTcA8VKT?= =?us-ascii?Q?bDwgZtiv4v7PRcCYmCr6AmLsiBmr1nRqw+Z8ruaL3D5l4sD8m3J3MxMsTeZz?= =?us-ascii?Q?1DziYuTq6LrQ0XqkKkcG/AJSaGDeAaHMOnytTjBUqsZM4t+sXbONoVHHcTdo?= =?us-ascii?Q?93uCuBiK3VNCvhYhrRMNwDtkaLQuRGOhu6AJLuwCM2E1s//SQw+1H8FzCcH2?= =?us-ascii?Q?JYK4Pwmp4hmFstVLSxQFlxncN6QGczOHP3/Xpt4sndF9WyOzYCXihPcrasZL?= =?us-ascii?Q?Xv6AkH3HnPl2C6qabj7TX6oY1sdNc+i/bXOljCS9QxBkftrzTmEJMxv/NKE5?= =?us-ascii?Q?pKmcvnGMrV/p/jNY4ZapFhwOT+f2kSbzF1t3Zf+dxx9gEgfEDiXz56hwU7MJ?= =?us-ascii?Q?4id0N97ax8H0rGDRTAzItnNwi54nWkxrF+LWza43XCLAw5InxiTiRNNxIZJ7?= =?us-ascii?Q?CWw+HK0FLLQPztWEdT/5gYmVw2jSjrTr0xM+YjvMVfz2un4AGX3rK5eiWt7r?= =?us-ascii?Q?yMGeF+7duN00mDgdl6LlmmqYlFq0vbNa9zjnefrKU92V584TwTxFk7QAnz9y?= =?us-ascii?Q?uN2jC465VZuJVNIu+2W/4U5KPEtuR5Y02S/PW+g30P96C36nGfeXgQzcFUHA?= =?us-ascii?Q?KJmTc/yqQHYi2Ra5G4YDrUVAsx6cA+f5ZpAOa6XblU73xBF3Do2NjtbEBRJ5?= =?us-ascii?Q?bzwgP06+I9WxfxqHqSM3CLWefG4KzL43nEf2+EXEa9FhqGvWJYBTf925Om/E?= =?us-ascii?Q?SHYjhvbu8wf8M7fukjbjn60bPh+jd/kN66q20avkr/xDBFB4ciFamnTtvVFm?= =?us-ascii?Q?6HTqOIJ/l6ro/iOF1hC3iAl2D/zzHekV+ntV21QMx+H8YjVB5EOA2vda2Vl8?= =?us-ascii?Q?gl0VlYLYi+j7Dv5QN67QI8SehwzH3NWtEp6/xJJLYk+if0qYmIR7hHJwdICW?= =?us-ascii?Q?RLwVIeLMoUWA4OIZ6EM4eeFM0bw05m6eVbKMRHPBlV7ZG5pGj5lpLEroloO9?= =?us-ascii?Q?Js1iLWoQdRpfPRjxYG5ti8sWMoBx0W9nzabnIodbapDxZDrFSfZYi1tCAbIR?= =?us-ascii?Q?cDMca4DExiWfcz59USZcykQjjRz6ptsGck/Cot9A15YjOMzy72btRzV36xcX?= =?us-ascii?Q?p5tmvDtrcveOICIiMTAGzjizevEo/7ePskOdZjsDf?= X-Forefront-PRVS: 0350D7A55D X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; CO1PR07MB426; 23:4kV5cwPuo524STzzQq/bdOQW+pyiWnY9ZKCCoCDEwX?= =?us-ascii?Q?+S18MOzIC6xzTA/6VzwY4tgqi+aFCGz4z5HqQIIgbqQ4PLmPpPcNJsGSdA+x?= =?us-ascii?Q?YFEBOCzOc0/JzUpOmfQKTMPwqTnarDCGlDzQNCTWt0Zv1wTPfvCpLWu2Iwdd?= =?us-ascii?Q?VL3WrkA+NTZXvv16w5rFqtI712iby30wrUy/dM3xgSmdX0lql31UBLOPMf9w?= =?us-ascii?Q?5OXFeBjRvSbIb1+K8GCdMHIKdgk923t8Gv3O82H77OE7eZKuA+4n0yU2WACg?= =?us-ascii?Q?rgxqTF6T+tzqbggpjmsT/Cr5qEpBc2sNW+z5sLwRxMpwWTpwpGf6nLhPKWRp?= =?us-ascii?Q?FsuGvuqCjR7+xTC5VJnKoXrnwen/HX7Ymk1pBl1PUgy/0cMyo2R5W1HYkIKA?= =?us-ascii?Q?VrceIafM9NtMQjqXuEIO0uFfor/4TVm+GkoG01XWJ0bgxX7ySrmZClh91oab?= =?us-ascii?Q?xx1AeEhZz3zyEkTxnaGUI7YD0C3+RmEzIAPjuJPyKSKsux38RfuUaA2FhwLU?= =?us-ascii?Q?SF5fwGb/Hqs7avpc1BbMAjUtIyiQaInqo/dVok4KSc5GBhiqaif1H5A41dYF?= =?us-ascii?Q?8JvIUg7AbQcUXMoVUkheEmwf8l3jLr4P9OtJxVtgEhx02ouZODgMJFwDfeq5?= =?us-ascii?Q?QnISJrDD0Naaf6421HI9aggNBwvxoA1SQxxSLeY0hn8C93jaor384E1TBtN6?= =?us-ascii?Q?hS6qmJf2quuo5vMOJv0l6rsDiwcG09KOiAG5m9xmmYhqUpVP4/G5I/+bzX/U?= =?us-ascii?Q?F5hQT5thnOKYmA+7+9oJ76KNk5SdNwez3qHsveiGm67NN4F4hYiW0aApwuBH?= =?us-ascii?Q?r3vp9a7pz/8zWFwMUeEeeOKU+2nt3kgGQPxMF/WFjrJ0vpUQirWXArtehxGm?= =?us-ascii?Q?XJxqlJeYjz4xD3OtbuU7zM6CB55WuKSilJ1JyD4j6WHtIIM4WP7TXY+7Enx9?= =?us-ascii?Q?xSVYo1ADbh3x4O9DFvhEp72ePz6DG5K6mOztfusSsOpwoFxLmU7/lktRuAUd?= =?us-ascii?Q?TXOb+Q24z18d6wmkrCcoljo2M+6C6q7o83i3yY7/W0LpMMtZq5OltdKbHZaY?= =?us-ascii?Q?WfqLpUjSkfTviokeHtfzEOGSs4wpGVvKwNMrwfUM0YMf+n94OIyxp46632n0?= =?us-ascii?Q?VX8xfm01M=3D?= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; CO1PR07MB426; 6:bKumcSKNv89FUcaUD0oQoRRUoY7tJ+IEB6AFYmOvS+v?= =?us-ascii?Q?2RucR9FYDgftSld0qm9+wWjyoFCjSTiwhu5OblhKvh7xjn9uRy42sdUIxhML?= =?us-ascii?Q?824ie6WI/QF/cBgc3DRrOir82PQzAqqsL0F5xILF+dDTEBGADFdtbmWR8/eI?= =?us-ascii?Q?w4nSAxwS2rbIdXlleuviUBZsdhC5fqAwChqd/wfImH6jCxNv9r6RQB7ZPTS2?= =?us-ascii?Q?19/5ModQOmkiFxN5fawTG0NR5ZN3OILxd6QBacQoIcwchLih7DT006XDn6Sj?= =?us-ascii?Q?dHmzVCfJyPE9qLpBfsK1s/h7syk0AT55j+Qk2DDO18W4jYT/SXpeD8os5/Mc?= =?us-ascii?Q?R2fZ/t3GdGJqDHtnybaUH+ZaMS1rAtjlPHds7KJn9FYVJXhp2i5pxC3PsCbd?= =?us-ascii?Q?BLhWTg5S27PCALeE8icAZuO3b3h+vL1IRs/5RFgk3PFoCVFVZa9iV4W+ftcv?= =?us-ascii?Q?Gq6PltuvH82xguMOnFWspq09OTwaAgojLLxXw8hXswkpL7SRdLP0hC2MaFrQ?= =?us-ascii?Q?W51bzJUFDeFs1G9sSYlQHafEBzF4WP/fQqd07sUqnaHeYULWPYHjDk74i0wo?= =?us-ascii?Q?gngxhFArh+Mu7cK0/UYpw8bua6m7pkN8+AevqjJ9nlTKd87hW+Vpf7jsGzIb?= =?us-ascii?Q?j2JKB4fT6Cw/aemwUY0s/WF++9blb634a4fvXB0UL6aqBA/CCyy22Rgo2zI0?= =?us-ascii?Q?KDRO7ZVtcJ2kLntOyg/VAX4ev+CFOYkqnscq1CwZvmHCeCZ0w9PnEJbOXctf?= =?us-ascii?Q?jKdfcfMcSgoxN37AfhsWsO0q+biIefxgguMEGNnXMJ/sdap7iDQQBEeI0k1a?= =?us-ascii?Q?+TePx3UJlotGEV2N4srTJIuFJSAjDVwx7mJYXYaS/1AwoFufWwlkg3fbUiYF?= =?us-ascii?Q?QWrEwflG3EYgjcB5BYXoE+caxtcBlnO6IU2RtBfgOrdaZhlMVhOy3CAuAO0O?= =?us-ascii?Q?/RAtLgF4pKgoXeNl23mKYGeG5xI6pkoGC5GbIjoLfiD68r87lE/B4zl0ZTcM?= =?us-ascii?Q?=3D?= X-Microsoft-Exchange-Diagnostics: 1; CO1PR07MB426; 5:rqhMFFpu9MgDob2mfkKsSXoW2h9cfq2sg9U9fU0PgxZgZz4G+twzsEDjJyttmzP4qFq3OYha9nYoc+nLOrkkScKMR4M9SmYUWGQQcKB8ELH+pOdiRMK2W/+HGBov2nGuVCVc2c1gyVIty1tj+DjOw9QC+CZydacpp40cVW/x943hUVj5qY4Wh6ybtdtlqUCKw49do7QuvjB8ClODrd0OzlfChyLmKHhKFblpigBcs5A1BJHYfSXiWkAuvbjo/sjsbjznaXhqEEGMCHjJ5sjwjyWLUa1ho5W/3Zbud6jeBelVw1jOwLdOHigFcqb5OmJ+Z0k5I+HSFD0X4AA42KJ+W+CwbYHJDp7SacA5HgQ2ViUHIfOFCm20yKAYgkUzTqo90awLllEXR2dkSFROgXlBxw50vUjASzLBcGmVvwUVffVYOIispKjp+GSBEUFsG1GS7o+uoNERZOERYRsectnCkCcOJURkXe/ZNAtGI0ihmRN4MXzYr//zjGl+FtjY+/Py; 24:gX3kyO1/YzQAS7kHwTI+njuwb/sWqursLQGlzSEOkws5mMXVC5ouiogl/+wKiTRPM5VC8reEADVKl6+YweTk10eO8wLf2sGS1dMDJZeu2pE= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; CO1PR07MB426; 7:6D+llW+W94HT0WC+24bZXLhkeVycaDMeG94z5jEx4sqW/wvVALdN6FuW5lyylC3RDPXYfOt7aSE+eUnHVTc57VgGfUVBQAbIrK6QzgRPn5I/lw+3hcZskzyxgUIMmPqbNXxIDe4m890cyXoHM5xKIznPJNY9I6vGWjp8QKJ/q35Are6Td35GPjhoWmJH7SPwFefz4edWP1NbT/gkl4RUYbZx6wduqRf3wJKu7ez3Cj5QIorEoUUocGlisTpQSIe3x5fq2lDYdf1+ag52hCSACqbiezUZYSrwrJCc8URnb36Eycr2Iw8G5fDjLgj8c/QmGHQe1EtH4nQLaOLAkJ+C3xsOVfhVxlTCABmG9W0KdJFVq/5XK2K4038RfpBbtQnhZwanqFdO/0TCBVQeqX7zw40vbX2tgz9SxT9BDIFfB5l/SAQ2lH3ol2Kahu1gKzhfzcE25GM7aeZmlA5bJxKwPFcwAXFv/k583RZtk8AosLbvjmUzCHYvGl3/tcBMvPlxfuBm7sBatFZagRbErfvv0pUsTZm2ExvyQrF8WWNhsJZmeJZ0/vHbJm9K+WIEMSsW48XkiHuEboA1e89zCPrw7kFFajgxyR7tv+uhdR0YqsB7+xqo+kZ9vOIXHFOLLyzGrW1xwwZeNLtfZdoAJMTuWw77SLqUnVpJyT1sU8aZWEa7wHBNiq+aan88VWjzxAlSBRk6JSMbMskfrq9Bf7PwK63ztpOsVPB/yhl+UPP6jMewpT1bbnePGhwgsyZ3DeRa1cycVkKu8B8ek1vCEepg9b8agsbOf0SFbVmFAQP/EPM= X-OriginatorOrg: cavium.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 26 Jun 2017 18:09:31.2794 (UTC) X-MS-Exchange-CrossTenant-Id: 711e4ccf-2e9b-4bcf-a551-4094005b6194 X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=711e4ccf-2e9b-4bcf-a551-4094005b6194; Ip=[50.232.66.26]; Helo=[CAEXCH02.caveonetworks.com] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: CO1PR07MB426 Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP This patch adds iWARP support for flows that have common code between RoCE and iWARP, such as initialization, teardown and qp setup verbs: create, destroy, modify, query. It introduces the iWARP specific files qed_iwarp.[ch] and iwarp_common.h Signed-off-by: Michal Kalderon Signed-off-by: Yuval Mintz Signed-off-by: Ariel Elior --- drivers/net/ethernet/qlogic/qed/Makefile | 2 +- drivers/net/ethernet/qlogic/qed/qed_dev.c | 9 +- drivers/net/ethernet/qlogic/qed/qed_hsi.h | 1 + drivers/net/ethernet/qlogic/qed/qed_iwarp.c | 531 ++++++++++++++++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_iwarp.h | 85 +++++ drivers/net/ethernet/qlogic/qed/qed_rdma.c | 133 +++++-- drivers/net/ethernet/qlogic/qed/qed_rdma.h | 3 + drivers/net/ethernet/qlogic/qed/qed_roce.c | 20 ++ drivers/net/ethernet/qlogic/qed/qed_sp.h | 5 +- include/linux/qed/iwarp_common.h | 53 +++ include/linux/qed/qed_rdma_if.h | 1 + 11 files changed, 803 insertions(+), 40 deletions(-) create mode 100644 drivers/net/ethernet/qlogic/qed/qed_iwarp.c create mode 100644 drivers/net/ethernet/qlogic/qed/qed_iwarp.h create mode 100644 include/linux/qed/iwarp_common.h diff --git a/drivers/net/ethernet/qlogic/qed/Makefile b/drivers/net/ethernet/qlogic/qed/Makefile index 6745238..82dd470 100644 --- a/drivers/net/ethernet/qlogic/qed/Makefile +++ b/drivers/net/ethernet/qlogic/qed/Makefile @@ -5,6 +5,6 @@ qed-y := qed_cxt.o qed_dev.o qed_hw.o qed_init_fw_funcs.o qed_init_ops.o \ qed_selftest.o qed_dcbx.o qed_debug.o qed_ptp.o qed-$(CONFIG_QED_SRIOV) += qed_sriov.o qed_vf.o qed-$(CONFIG_QED_LL2) += qed_ll2.o -qed-$(CONFIG_QED_RDMA) += qed_roce.o qed_rdma.o +qed-$(CONFIG_QED_RDMA) += qed_roce.o qed_rdma.o qed_iwarp.o qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o qed_ooo.o qed-$(CONFIG_QED_FCOE) += qed_fcoe.o diff --git a/drivers/net/ethernet/qlogic/qed/qed_dev.c b/drivers/net/ethernet/qlogic/qed/qed_dev.c index 68e6182..6c8505d 100644 --- a/drivers/net/ethernet/qlogic/qed/qed_dev.c +++ b/drivers/net/ethernet/qlogic/qed/qed_dev.c @@ -937,8 +937,15 @@ int qed_resc_alloc(struct qed_dev *cdev) /* EQ */ n_eqes = qed_chain_get_capacity(&p_hwfn->p_spq->chain); if (QED_IS_RDMA_PERSONALITY(p_hwfn)) { + enum protocol_type rdma_proto; + + if (QED_IS_ROCE_PERSONALITY(p_hwfn)) + rdma_proto = PROTOCOLID_ROCE; + else + rdma_proto = PROTOCOLID_IWARP; + num_cons = qed_cxt_get_proto_cid_count(p_hwfn, - PROTOCOLID_ROCE, + rdma_proto, NULL) * 2; n_eqes += num_cons + 2 * MAX_NUM_VFS_BB; } else if (p_hwfn->hw_info.personality == QED_PCI_ISCSI) { diff --git a/drivers/net/ethernet/qlogic/qed/qed_hsi.h b/drivers/net/ethernet/qlogic/qed/qed_hsi.h index 3bf3614..31fb0bf 100644 --- a/drivers/net/ethernet/qlogic/qed/qed_hsi.h +++ b/drivers/net/ethernet/qlogic/qed/qed_hsi.h @@ -46,6 +46,7 @@ #include #include #include +#include #include #include #include diff --git a/drivers/net/ethernet/qlogic/qed/qed_iwarp.c b/drivers/net/ethernet/qlogic/qed/qed_iwarp.c new file mode 100644 index 0000000..a8bd5f8 --- /dev/null +++ b/drivers/net/ethernet/qlogic/qed/qed_iwarp.c @@ -0,0 +1,531 @@ +/* QLogic qed NIC Driver + * Copyright (c) 2015-2017 QLogic Corporation + * + * This software is available to you under a choice of one of two + * licenses. You may choose to be licensed under the terms of the GNU + * General Public License (GPL) Version 2, available from the file + * COPYING in the main directory of this source tree, or the + * OpenIB.org BSD license below: + * + * 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. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include "qed_cxt.h" +#include "qed_hw.h" +#include "qed_rdma.h" +#include "qed_reg_addr.h" +#include "qed_sp.h" + +#define QED_IWARP_ORD_DEFAULT 32 +#define QED_IWARP_IRD_DEFAULT 32 +#define QED_IWARP_RCV_WND_SIZE_DEF (256 * 1024) +#define QED_IWARP_RCV_WND_SIZE_MIN (64 * 1024) +#define QED_IWARP_TS_EN BIT(0) +#define QED_IWARP_PARAM_CRC_NEEDED (1) +#define QED_IWARP_PARAM_P2P (1) + +static int qed_iwarp_async_event(struct qed_hwfn *p_hwfn, + u8 fw_event_code, u16 echo, + union event_ring_data *data, + u8 fw_return_code); + +/* Override devinfo with iWARP specific values */ +void qed_iwarp_init_devinfo(struct qed_hwfn *p_hwfn) +{ + struct qed_rdma_device *dev = p_hwfn->p_rdma_info->dev; + + dev->max_inline = IWARP_REQ_MAX_INLINE_DATA_SIZE; + dev->max_qp = min_t(u32, + IWARP_MAX_QPS, + p_hwfn->p_rdma_info->num_qps); + + dev->max_cq = dev->max_qp; + + dev->max_qp_resp_rd_atomic_resc = QED_IWARP_IRD_DEFAULT; + dev->max_qp_req_rd_atomic_resc = QED_IWARP_ORD_DEFAULT; +} + +void qed_iwarp_init_hw(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) +{ + p_hwfn->rdma_prs_search_reg = PRS_REG_SEARCH_TCP; + qed_wr(p_hwfn, p_ptt, p_hwfn->rdma_prs_search_reg, 1); + p_hwfn->b_rdma_enabled_in_prs = true; +} + +static void qed_iwarp_cid_cleaned(struct qed_hwfn *p_hwfn, u32 cid) +{ + cid -= qed_cxt_get_proto_cid_start(p_hwfn, p_hwfn->p_rdma_info->proto); + + spin_lock_bh(&p_hwfn->p_rdma_info->lock); + qed_bmap_release_id(p_hwfn, &p_hwfn->p_rdma_info->cid_map, cid); + spin_unlock_bh(&p_hwfn->p_rdma_info->lock); +} + +static int qed_iwarp_alloc_cid(struct qed_hwfn *p_hwfn, u32 *cid) +{ + int rc; + + spin_lock_bh(&p_hwfn->p_rdma_info->lock); + rc = qed_rdma_bmap_alloc_id(p_hwfn, &p_hwfn->p_rdma_info->cid_map, cid); + spin_unlock_bh(&p_hwfn->p_rdma_info->lock); + if (rc) { + DP_NOTICE(p_hwfn, "Failed in allocating iwarp cid\n"); + return rc; + } + *cid += qed_cxt_get_proto_cid_start(p_hwfn, p_hwfn->p_rdma_info->proto); + + rc = qed_cxt_dynamic_ilt_alloc(p_hwfn, QED_ELEM_CXT, *cid); + if (rc) + qed_iwarp_cid_cleaned(p_hwfn, *cid); + + return rc; +} + +int qed_iwarp_create_qp(struct qed_hwfn *p_hwfn, + struct qed_rdma_qp *qp, + struct qed_rdma_create_qp_out_params *out_params) +{ + struct iwarp_create_qp_ramrod_data *p_ramrod; + struct qed_sp_init_data init_data; + struct qed_spq_entry *p_ent; + u16 physical_queue; + u32 cid; + int rc; + + qp->shared_queue = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, + IWARP_SHARED_QUEUE_PAGE_SIZE, + &qp->shared_queue_phys_addr, + GFP_KERNEL); + if (!qp->shared_queue) + return -ENOMEM; + + out_params->sq_pbl_virt = (u8 *)qp->shared_queue + + IWARP_SHARED_QUEUE_PAGE_SQ_PBL_OFFSET; + out_params->sq_pbl_phys = qp->shared_queue_phys_addr + + IWARP_SHARED_QUEUE_PAGE_SQ_PBL_OFFSET; + out_params->rq_pbl_virt = (u8 *)qp->shared_queue + + IWARP_SHARED_QUEUE_PAGE_RQ_PBL_OFFSET; + out_params->rq_pbl_phys = qp->shared_queue_phys_addr + + IWARP_SHARED_QUEUE_PAGE_RQ_PBL_OFFSET; + + rc = qed_iwarp_alloc_cid(p_hwfn, &cid); + if (rc) + goto err1; + + qp->icid = (u16)cid; + + memset(&init_data, 0, sizeof(init_data)); + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.cid = qp->icid; + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; + + rc = qed_sp_init_request(p_hwfn, &p_ent, + IWARP_RAMROD_CMD_ID_CREATE_QP, + PROTOCOLID_IWARP, &init_data); + if (rc) + goto err2; + + p_ramrod = &p_ent->ramrod.iwarp_create_qp; + + SET_FIELD(p_ramrod->flags, + IWARP_CREATE_QP_RAMROD_DATA_FMR_AND_RESERVED_EN, + qp->fmr_and_reserved_lkey); + + SET_FIELD(p_ramrod->flags, + IWARP_CREATE_QP_RAMROD_DATA_SIGNALED_COMP, qp->signal_all); + + SET_FIELD(p_ramrod->flags, + IWARP_CREATE_QP_RAMROD_DATA_RDMA_RD_EN, + qp->incoming_rdma_read_en); + + SET_FIELD(p_ramrod->flags, + IWARP_CREATE_QP_RAMROD_DATA_RDMA_WR_EN, + qp->incoming_rdma_write_en); + + SET_FIELD(p_ramrod->flags, + IWARP_CREATE_QP_RAMROD_DATA_ATOMIC_EN, + qp->incoming_atomic_en); + + SET_FIELD(p_ramrod->flags, + IWARP_CREATE_QP_RAMROD_DATA_SRQ_FLG, qp->use_srq); + + p_ramrod->pd = qp->pd; + p_ramrod->sq_num_pages = qp->sq_num_pages; + p_ramrod->rq_num_pages = qp->rq_num_pages; + + p_ramrod->qp_handle_for_cqe.hi = cpu_to_le32(qp->qp_handle.hi); + p_ramrod->qp_handle_for_cqe.lo = cpu_to_le32(qp->qp_handle.lo); + + p_ramrod->cq_cid_for_sq = + cpu_to_le32((p_hwfn->hw_info.opaque_fid << 16) | qp->sq_cq_id); + p_ramrod->cq_cid_for_rq = + cpu_to_le32((p_hwfn->hw_info.opaque_fid << 16) | qp->rq_cq_id); + + p_ramrod->dpi = cpu_to_le16(qp->dpi); + + physical_queue = qed_get_cm_pq_idx(p_hwfn, PQ_FLAGS_OFLD); + p_ramrod->physical_q0 = cpu_to_le16(physical_queue); + physical_queue = qed_get_cm_pq_idx(p_hwfn, PQ_FLAGS_ACK); + p_ramrod->physical_q1 = cpu_to_le16(physical_queue); + + rc = qed_spq_post(p_hwfn, p_ent, NULL); + if (rc) + goto err2; + + return rc; + +err2: + qed_iwarp_cid_cleaned(p_hwfn, cid); +err1: + dma_free_coherent(&p_hwfn->cdev->pdev->dev, + IWARP_SHARED_QUEUE_PAGE_SIZE, + qp->shared_queue, qp->shared_queue_phys_addr); + + return rc; +} + +static int qed_iwarp_modify_fw(struct qed_hwfn *p_hwfn, struct qed_rdma_qp *qp) +{ + struct iwarp_modify_qp_ramrod_data *p_ramrod; + struct qed_sp_init_data init_data; + struct qed_spq_entry *p_ent; + int rc; + + /* Get SPQ entry */ + memset(&init_data, 0, sizeof(init_data)); + init_data.cid = qp->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; + + rc = qed_sp_init_request(p_hwfn, &p_ent, + IWARP_RAMROD_CMD_ID_MODIFY_QP, + p_hwfn->p_rdma_info->proto, &init_data); + if (rc) + return rc; + + p_ramrod = &p_ent->ramrod.iwarp_modify_qp; + SET_FIELD(p_ramrod->flags, IWARP_MODIFY_QP_RAMROD_DATA_STATE_TRANS_EN, + 0x1); + if (qp->iwarp_state == QED_IWARP_QP_STATE_CLOSING) + p_ramrod->transition_to_state = IWARP_MODIFY_QP_STATE_CLOSING; + else + p_ramrod->transition_to_state = IWARP_MODIFY_QP_STATE_ERROR; + + rc = qed_spq_post(p_hwfn, p_ent, NULL); + + DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "QP(0x%x)rc=%d\n", qp->icid, rc); + + return rc; +} + +enum qed_iwarp_qp_state qed_roce2iwarp_state(enum qed_roce_qp_state state) +{ + switch (state) { + case QED_ROCE_QP_STATE_RESET: + case QED_ROCE_QP_STATE_INIT: + case QED_ROCE_QP_STATE_RTR: + return QED_IWARP_QP_STATE_IDLE; + case QED_ROCE_QP_STATE_RTS: + return QED_IWARP_QP_STATE_RTS; + case QED_ROCE_QP_STATE_SQD: + return QED_IWARP_QP_STATE_CLOSING; + case QED_ROCE_QP_STATE_ERR: + return QED_IWARP_QP_STATE_ERROR; + case QED_ROCE_QP_STATE_SQE: + return QED_IWARP_QP_STATE_TERMINATE; + default: + return QED_IWARP_QP_STATE_ERROR; + } +} + +static enum qed_roce_qp_state +qed_iwarp2roce_state(enum qed_iwarp_qp_state state) +{ + switch (state) { + case QED_IWARP_QP_STATE_IDLE: + return QED_ROCE_QP_STATE_INIT; + case QED_IWARP_QP_STATE_RTS: + return QED_ROCE_QP_STATE_RTS; + case QED_IWARP_QP_STATE_TERMINATE: + return QED_ROCE_QP_STATE_SQE; + case QED_IWARP_QP_STATE_CLOSING: + return QED_ROCE_QP_STATE_SQD; + case QED_IWARP_QP_STATE_ERROR: + return QED_ROCE_QP_STATE_ERR; + default: + return QED_ROCE_QP_STATE_ERR; + } +} + +const char *iwarp_state_names[] = { + "IDLE", + "RTS", + "TERMINATE", + "CLOSING", + "ERROR", +}; + +int +qed_iwarp_modify_qp(struct qed_hwfn *p_hwfn, + struct qed_rdma_qp *qp, + enum qed_iwarp_qp_state new_state, bool internal) +{ + enum qed_iwarp_qp_state prev_iw_state; + bool modify_fw = false; + int rc = 0; + + /* modify QP can be called from upper-layer or as a result of async + * RST/FIN... therefore need to protect + */ + spin_lock_bh(&p_hwfn->p_rdma_info->iwarp.qp_lock); + prev_iw_state = qp->iwarp_state; + + if (prev_iw_state == new_state) { + spin_unlock_bh(&p_hwfn->p_rdma_info->iwarp.qp_lock); + return 0; + } + + switch (prev_iw_state) { + case QED_IWARP_QP_STATE_IDLE: + switch (new_state) { + case QED_IWARP_QP_STATE_RTS: + qp->iwarp_state = QED_IWARP_QP_STATE_RTS; + break; + case QED_IWARP_QP_STATE_ERROR: + qp->iwarp_state = QED_IWARP_QP_STATE_ERROR; + if (!internal) + modify_fw = true; + break; + default: + break; + } + break; + case QED_IWARP_QP_STATE_RTS: + switch (new_state) { + case QED_IWARP_QP_STATE_CLOSING: + if (!internal) + modify_fw = true; + + qp->iwarp_state = QED_IWARP_QP_STATE_CLOSING; + break; + case QED_IWARP_QP_STATE_ERROR: + if (!internal) + modify_fw = true; + qp->iwarp_state = QED_IWARP_QP_STATE_ERROR; + break; + default: + break; + } + break; + case QED_IWARP_QP_STATE_ERROR: + switch (new_state) { + case QED_IWARP_QP_STATE_IDLE: + + qp->iwarp_state = new_state; + break; + case QED_IWARP_QP_STATE_CLOSING: + /* could happen due to race... do nothing.... */ + break; + default: + rc = -EINVAL; + } + break; + case QED_IWARP_QP_STATE_TERMINATE: + case QED_IWARP_QP_STATE_CLOSING: + qp->iwarp_state = new_state; + break; + default: + break; + } + + DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "QP(0x%x) %s --> %s%s\n", + qp->icid, + iwarp_state_names[prev_iw_state], + iwarp_state_names[qp->iwarp_state], + internal ? "internal" : ""); + + spin_unlock_bh(&p_hwfn->p_rdma_info->iwarp.qp_lock); + + if (modify_fw) + rc = qed_iwarp_modify_fw(p_hwfn, qp); + + return rc; +} + +int qed_iwarp_fw_destroy(struct qed_hwfn *p_hwfn, struct qed_rdma_qp *qp) +{ + struct qed_sp_init_data init_data; + struct qed_spq_entry *p_ent; + int rc; + + /* Get SPQ entry */ + memset(&init_data, 0, sizeof(init_data)); + init_data.cid = qp->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = QED_SPQ_MODE_EBLOCK; + + rc = qed_sp_init_request(p_hwfn, &p_ent, + IWARP_RAMROD_CMD_ID_DESTROY_QP, + p_hwfn->p_rdma_info->proto, &init_data); + if (rc) + return rc; + + rc = qed_spq_post(p_hwfn, p_ent, NULL); + + DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "QP(0x%x) rc = %d\n", qp->icid, rc); + + return rc; +} + +int qed_iwarp_destroy_qp(struct qed_hwfn *p_hwfn, struct qed_rdma_qp *qp) +{ + int rc = 0; + + if (qp->iwarp_state != QED_IWARP_QP_STATE_ERROR) { + rc = qed_iwarp_modify_qp(p_hwfn, qp, + QED_IWARP_QP_STATE_ERROR, false); + if (rc) + return rc; + } + + rc = qed_iwarp_fw_destroy(p_hwfn, qp); + + if (qp->shared_queue) + dma_free_coherent(&p_hwfn->cdev->pdev->dev, + IWARP_SHARED_QUEUE_PAGE_SIZE, + qp->shared_queue, qp->shared_queue_phys_addr); + + return rc; +} + +#define QED_IWARP_MAX_CID_CLEAN_TIME 100 +#define QED_IWARP_MAX_NO_PROGRESS_CNT 5 + +/* This function waits for all the bits of a bmap to be cleared, as long as + * there is progress ( i.e. the number of bits left to be cleared decreases ) + * the function continues. + */ +static int +qed_iwarp_wait_cid_map_cleared(struct qed_hwfn *p_hwfn, struct qed_bmap *bmap) +{ + int prev_weight = 0; + int wait_count = 0; + int weight = 0; + + weight = bitmap_weight(bmap->bitmap, bmap->max_count); + prev_weight = weight; + + while (weight) { + msleep(QED_IWARP_MAX_CID_CLEAN_TIME); + + weight = bitmap_weight(bmap->bitmap, bmap->max_count); + + if (prev_weight == weight) { + wait_count++; + } else { + prev_weight = weight; + wait_count = 0; + } + + if (wait_count > QED_IWARP_MAX_NO_PROGRESS_CNT) { + DP_NOTICE(p_hwfn, + "%s bitmap wait timed out (%d cids pending)\n", + bmap->name, weight); + return -EBUSY; + } + } + return 0; +} + +static int qed_iwarp_wait_for_all_cids(struct qed_hwfn *p_hwfn) +{ + /* Now wait for all cids to be completed */ + return qed_iwarp_wait_cid_map_cleared(p_hwfn, + &p_hwfn->p_rdma_info->cid_map); +} + +int qed_iwarp_alloc(struct qed_hwfn *p_hwfn) +{ + spin_lock_init(&p_hwfn->p_rdma_info->iwarp.iw_lock); + + return 0; +} + +void qed_iwarp_resc_free(struct qed_hwfn *p_hwfn) +{ +} + +int qed_iwarp_setup(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + struct qed_rdma_start_in_params *params) +{ + struct qed_iwarp_info *iwarp_info; + u32 rcv_wnd_size; + int rc = 0; + + iwarp_info = &p_hwfn->p_rdma_info->iwarp; + + iwarp_info->tcp_flags = QED_IWARP_TS_EN; + rcv_wnd_size = QED_IWARP_RCV_WND_SIZE_DEF; + + /* value 0 is used for ilog2(QED_IWARP_RCV_WND_SIZE_MIN) */ + iwarp_info->rcv_wnd_scale = ilog2(rcv_wnd_size) - + ilog2(QED_IWARP_RCV_WND_SIZE_MIN); + iwarp_info->crc_needed = QED_IWARP_PARAM_CRC_NEEDED; + iwarp_info->mpa_rev = MPA_NEGOTIATION_TYPE_ENHANCED; + + iwarp_info->peer2peer = QED_IWARP_PARAM_P2P; + + spin_lock_init(&p_hwfn->p_rdma_info->iwarp.qp_lock); + + qed_spq_register_async_cb(p_hwfn, PROTOCOLID_IWARP, + qed_iwarp_async_event); + + return rc; +} + +int qed_iwarp_stop(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) +{ + int rc; + + rc = qed_iwarp_wait_for_all_cids(p_hwfn); + if (rc) + return rc; + + qed_spq_unregister_async_cb(p_hwfn, PROTOCOLID_IWARP); + + return 0; +} + +static int qed_iwarp_async_event(struct qed_hwfn *p_hwfn, + u8 fw_event_code, u16 echo, + union event_ring_data *data, + u8 fw_return_code) +{ + return 0; +} + +void +qed_iwarp_query_qp(struct qed_rdma_qp *qp, + struct qed_rdma_query_qp_out_params *out_params) +{ + out_params->state = qed_iwarp2roce_state(qp->iwarp_state); +} diff --git a/drivers/net/ethernet/qlogic/qed/qed_iwarp.h b/drivers/net/ethernet/qlogic/qed/qed_iwarp.h new file mode 100644 index 0000000..05e5e45 --- /dev/null +++ b/drivers/net/ethernet/qlogic/qed/qed_iwarp.h @@ -0,0 +1,85 @@ +/* QLogic qed NIC Driver + * Copyright (c) 2015-2017 QLogic Corporation + * + * This software is available to you under a choice of one of two + * licenses. You may choose to be licensed under the terms of the GNU + * General Public License (GPL) Version 2, available from the file + * COPYING in the main directory of this source tree, or the + * OpenIB.org BSD license below: + * + * 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. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef _QED_IWARP_H +#define _QED_IWARP_H + +enum qed_iwarp_qp_state { + QED_IWARP_QP_STATE_IDLE, + QED_IWARP_QP_STATE_RTS, + QED_IWARP_QP_STATE_TERMINATE, + QED_IWARP_QP_STATE_CLOSING, + QED_IWARP_QP_STATE_ERROR, +}; + +enum qed_iwarp_qp_state qed_roce2iwarp_state(enum qed_roce_qp_state state); + +struct qed_iwarp_info { + spinlock_t iw_lock; /* for iwarp resources */ + spinlock_t qp_lock; /* for teardown races */ + u32 rcv_wnd_scale; + u16 max_mtu; + u8 mac_addr[ETH_ALEN]; + u8 crc_needed; + u8 tcp_flags; + u8 peer2peer; + enum mpa_negotiation_mode mpa_rev; + enum mpa_rtr_type rtr_type; +}; + +int qed_iwarp_alloc(struct qed_hwfn *p_hwfn); + +int qed_iwarp_setup(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + struct qed_rdma_start_in_params *params); + +int qed_iwarp_stop(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + +void qed_iwarp_resc_free(struct qed_hwfn *p_hwfn); + +void qed_iwarp_init_devinfo(struct qed_hwfn *p_hwfn); + +void qed_iwarp_init_hw(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt); + +int qed_iwarp_create_qp(struct qed_hwfn *p_hwfn, + struct qed_rdma_qp *qp, + struct qed_rdma_create_qp_out_params *out_params); + +int qed_iwarp_modify_qp(struct qed_hwfn *p_hwfn, struct qed_rdma_qp *qp, + enum qed_iwarp_qp_state new_state, bool internal); + +int qed_iwarp_destroy_qp(struct qed_hwfn *p_hwfn, struct qed_rdma_qp *qp); + +int qed_iwarp_fw_destroy(struct qed_hwfn *p_hwfn, struct qed_rdma_qp *qp); + +void qed_iwarp_query_qp(struct qed_rdma_qp *qp, + struct qed_rdma_query_qp_out_params *out_params); + +#endif diff --git a/drivers/net/ethernet/qlogic/qed/qed_rdma.c b/drivers/net/ethernet/qlogic/qed/qed_rdma.c index df76e21..ee6887f 100644 --- a/drivers/net/ethernet/qlogic/qed/qed_rdma.c +++ b/drivers/net/ethernet/qlogic/qed/qed_rdma.c @@ -161,7 +161,10 @@ static int qed_rdma_alloc(struct qed_hwfn *p_hwfn, num_cons = qed_cxt_get_proto_cid_count(p_hwfn, p_rdma_info->proto, NULL); - p_rdma_info->num_qps = num_cons / 2; + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + p_rdma_info->num_qps = num_cons; + else + p_rdma_info->num_qps = num_cons / 2; /* 2 cids per qp */ num_tasks = qed_cxt_get_proto_tid_count(p_hwfn, PROTOCOLID_ROCE); @@ -252,6 +255,13 @@ static int qed_rdma_alloc(struct qed_hwfn *p_hwfn, "Failed to allocate real cid bitmap, rc = %d\n", rc); goto free_cid_map; } + + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + rc = qed_iwarp_alloc(p_hwfn); + + if (rc) + goto free_cid_map; + DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Allocation successful\n"); return 0; @@ -329,6 +339,9 @@ static void qed_rdma_resc_free(struct qed_hwfn *p_hwfn) { struct qed_rdma_info *p_rdma_info = p_hwfn->p_rdma_info; + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + qed_iwarp_resc_free(p_hwfn); + qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->cid_map, 1); qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->pd_map, 1); qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->dpi_map, 1); @@ -470,6 +483,9 @@ static void qed_rdma_init_devinfo(struct qed_hwfn *p_hwfn, if (pci_status_control & PCI_EXP_DEVCTL2_LTR_EN) SET_FIELD(dev->dev_caps, QED_RDMA_DEV_CAP_ATOMIC_OP, 1); + + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + qed_iwarp_init_devinfo(p_hwfn); } static void qed_rdma_init_port(struct qed_hwfn *p_hwfn) @@ -490,29 +506,17 @@ static void qed_rdma_init_port(struct qed_hwfn *p_hwfn) static int qed_rdma_init_hw(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) { - u32 ll2_ethertype_en; + int rc = 0; DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Initializing HW\n"); p_hwfn->b_rdma_enabled_in_prs = false; - qed_wr(p_hwfn, p_ptt, PRS_REG_ROCE_DEST_QP_MAX_PF, 0); + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + qed_iwarp_init_hw(p_hwfn, p_ptt); + else + rc = qed_roce_init_hw(p_hwfn, p_ptt); - p_hwfn->rdma_prs_search_reg = PRS_REG_SEARCH_ROCE; - - /* We delay writing to this reg until first cid is allocated. See - * qed_cxt_dynamic_ilt_alloc function for more details - */ - ll2_ethertype_en = qed_rd(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN); - qed_wr(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN, - (ll2_ethertype_en | 0x01)); - - if (qed_cxt_get_proto_cid_start(p_hwfn, PROTOCOLID_ROCE) % 2) { - DP_NOTICE(p_hwfn, "The first RoCE's cid should be even\n"); - return -EINVAL; - } - - DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Initializing HW - Done\n"); - return 0; + return rc; } static int qed_rdma_start_fw(struct qed_hwfn *p_hwfn, @@ -544,7 +548,10 @@ static int qed_rdma_start_fw(struct qed_hwfn *p_hwfn, if (rc) return rc; - p_ramrod = &p_ent->ramrod.roce_init_func.rdma; + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + p_ramrod = &p_ent->ramrod.iwarp_init_func.rdma; + else + p_ramrod = &p_ent->ramrod.roce_init_func.rdma; p_params_header = &p_ramrod->params_header; p_params_header->cnq_start_offset = (u8)RESC_START(p_hwfn, @@ -641,7 +648,15 @@ static int qed_rdma_setup(struct qed_hwfn *p_hwfn, if (rc) return rc; - qed_roce_setup(p_hwfn); + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) { + rc = qed_iwarp_setup(p_hwfn, p_ptt, params); + if (rc) + return rc; + } else { + rc = qed_roce_setup(p_hwfn); + if (rc) + return rc; + } return qed_rdma_start_fw(p_hwfn, params, p_ptt); } @@ -675,7 +690,16 @@ int qed_rdma_stop(void *rdma_cxt) qed_wr(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN, (ll2_ethertype_en & 0xFFFE)); - qed_roce_stop(p_hwfn); + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) { + rc = qed_iwarp_stop(p_hwfn, p_ptt); + if (rc) { + qed_ptt_release(p_hwfn, p_ptt); + return rc; + } + } else { + qed_roce_stop(p_hwfn); + } + qed_ptt_release(p_hwfn, p_ptt); /* Get SPQ entry */ @@ -810,7 +834,9 @@ static int qed_fill_rdma_dev_info(struct qed_dev *cdev, memset(info, 0, sizeof(*info)); - info->rdma_type = QED_RDMA_TYPE_ROCE; + info->rdma_type = QED_IS_ROCE_PERSONALITY(p_hwfn) ? + QED_RDMA_TYPE_ROCE : QED_RDMA_TYPE_IWARP; + info->user_dpm_enabled = (p_hwfn->db_bar_no_edpm == 0); qed_fill_dev_info(cdev, &info->common); @@ -1112,7 +1138,7 @@ static int qed_rdma_query_qp(void *rdma_cxt, struct qed_rdma_query_qp_out_params *out_params) { struct qed_hwfn *p_hwfn = (struct qed_hwfn *)rdma_cxt; - int rc; + int rc = 0; DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "icid = %08x\n", qp->icid); @@ -1138,7 +1164,10 @@ static int qed_rdma_query_qp(void *rdma_cxt, out_params->max_dest_rd_atomic = qp->max_rd_atomic_resp; out_params->sqd_async = qp->sqd_async; - rc = qed_roce_query_qp(p_hwfn, qp, out_params); + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + qed_iwarp_query_qp(qp, out_params); + else + rc = qed_roce_query_qp(p_hwfn, qp, out_params); DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Query QP, rc = %d\n", rc); return rc; @@ -1151,7 +1180,10 @@ static int qed_rdma_destroy_qp(void *rdma_cxt, struct qed_rdma_qp *qp) DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "icid = %08x\n", qp->icid); - rc = qed_roce_destroy_qp(p_hwfn, qp); + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) + rc = qed_iwarp_destroy_qp(p_hwfn, qp); + else + rc = qed_roce_destroy_qp(p_hwfn, qp); /* free qp params struct */ kfree(qp); @@ -1190,20 +1222,27 @@ static int qed_rdma_destroy_qp(void *rdma_cxt, struct qed_rdma_qp *qp) return NULL; } + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) { + if (in_params->sq_num_pages * sizeof(struct regpair) > + IWARP_SHARED_QUEUE_PAGE_SQ_PBL_MAX_SIZE) { + DP_NOTICE(p_hwfn->cdev, + "Sq num pages: %d exceeds maximum\n", + in_params->sq_num_pages); + return NULL; + } + if (in_params->rq_num_pages * sizeof(struct regpair) > + IWARP_SHARED_QUEUE_PAGE_RQ_PBL_MAX_SIZE) { + DP_NOTICE(p_hwfn->cdev, + "Rq num pages: %d exceeds maximum\n", + in_params->rq_num_pages); + return NULL; + } + } + qp = kzalloc(sizeof(*qp), GFP_KERNEL); if (!qp) return NULL; - rc = qed_roce_alloc_cid(p_hwfn, &qp->icid); - qp->qpid = ((0xFF << 16) | qp->icid); - - DP_INFO(p_hwfn, "ROCE qpid=%x\n", qp->qpid); - - if (rc) { - kfree(qp); - return NULL; - } - qp->cur_state = QED_ROCE_QP_STATE_RESET; qp->qp_handle.hi = cpu_to_le32(in_params->qp_handle_hi); qp->qp_handle.lo = cpu_to_le32(in_params->qp_handle_lo); @@ -1226,6 +1265,19 @@ static int qed_rdma_destroy_qp(void *rdma_cxt, struct qed_rdma_qp *qp) qp->e2e_flow_control_en = qp->use_srq ? false : true; qp->stats_queue = in_params->stats_queue; + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) { + rc = qed_iwarp_create_qp(p_hwfn, qp, out_params); + qp->qpid = qp->icid; + } else { + rc = qed_roce_alloc_cid(p_hwfn, &qp->icid); + qp->qpid = ((0xFF << 16) | qp->icid); + } + + if (rc) { + kfree(qp); + return NULL; + } + out_params->icid = qp->icid; out_params->qp_id = qp->qpid; @@ -1324,7 +1376,14 @@ static int qed_rdma_modify_qp(void *rdma_cxt, qp->cur_state); } - rc = qed_roce_modify_qp(p_hwfn, qp, prev_state, params); + if (QED_IS_IWARP_PERSONALITY(p_hwfn)) { + enum qed_iwarp_qp_state new_state = + qed_roce2iwarp_state(qp->cur_state); + + rc = qed_iwarp_modify_qp(p_hwfn, qp, new_state, 0); + } else { + rc = qed_roce_modify_qp(p_hwfn, qp, prev_state, params); + } DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Modify QP, rc = %d\n", rc); return rc; diff --git a/drivers/net/ethernet/qlogic/qed/qed_rdma.h b/drivers/net/ethernet/qlogic/qed/qed_rdma.h index d91e5c4..90e4e0f 100644 --- a/drivers/net/ethernet/qlogic/qed/qed_rdma.h +++ b/drivers/net/ethernet/qlogic/qed/qed_rdma.h @@ -42,6 +42,7 @@ #include "qed.h" #include "qed_dev_api.h" #include "qed_hsi.h" +#include "qed_iwarp.h" #include "qed_roce.h" #define QED_RDMA_MAX_FMR (RDMA_MAX_TIDS) @@ -97,6 +98,7 @@ struct qed_rdma_info { u16 queue_zone_base; u16 max_queue_zones; enum protocol_type proto; + struct qed_iwarp_info iwarp; }; struct qed_rdma_qp { @@ -105,6 +107,7 @@ struct qed_rdma_qp { u32 qpid; u16 icid; enum qed_roce_qp_state cur_state; + enum qed_iwarp_qp_state iwarp_state; bool use_srq; bool signal_all; bool fmr_and_reserved_lkey; diff --git a/drivers/net/ethernet/qlogic/qed/qed_roce.c b/drivers/net/ethernet/qlogic/qed/qed_roce.c index e53adc3..fb7c2d1 100644 --- a/drivers/net/ethernet/qlogic/qed/qed_roce.c +++ b/drivers/net/ethernet/qlogic/qed/qed_roce.c @@ -1149,3 +1149,23 @@ int qed_roce_setup(struct qed_hwfn *p_hwfn) qed_roce_async_event); } +int qed_roce_init_hw(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) +{ + u32 ll2_ethertype_en; + + qed_wr(p_hwfn, p_ptt, PRS_REG_ROCE_DEST_QP_MAX_PF, 0); + + p_hwfn->rdma_prs_search_reg = PRS_REG_SEARCH_ROCE; + + ll2_ethertype_en = qed_rd(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN); + qed_wr(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN, + (ll2_ethertype_en | 0x01)); + + if (qed_cxt_get_proto_cid_start(p_hwfn, PROTOCOLID_ROCE) % 2) { + DP_NOTICE(p_hwfn, "The first RoCE's cid should be even\n"); + return -EINVAL; + } + + DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Initializing HW - Done\n"); + return 0; +} diff --git a/drivers/net/ethernet/qlogic/qed/qed_sp.h b/drivers/net/ethernet/qlogic/qed/qed_sp.h index 56c95fb..c3752c5 100644 --- a/drivers/net/ethernet/qlogic/qed/qed_sp.h +++ b/drivers/net/ethernet/qlogic/qed/qed_sp.h @@ -104,12 +104,15 @@ int qed_eth_cqe_completion(struct qed_hwfn *p_hwfn, struct roce_query_qp_req_ramrod_data roce_query_qp_req; struct roce_destroy_qp_resp_ramrod_data roce_destroy_qp_resp; struct roce_destroy_qp_req_ramrod_data roce_destroy_qp_req; + struct roce_init_func_ramrod_data roce_init_func; struct rdma_create_cq_ramrod_data rdma_create_cq; struct rdma_destroy_cq_ramrod_data rdma_destroy_cq; struct rdma_srq_create_ramrod_data rdma_create_srq; struct rdma_srq_destroy_ramrod_data rdma_destroy_srq; struct rdma_srq_modify_ramrod_data rdma_modify_srq; - struct roce_init_func_ramrod_data roce_init_func; + struct iwarp_create_qp_ramrod_data iwarp_create_qp; + struct iwarp_modify_qp_ramrod_data iwarp_modify_qp; + struct iwarp_init_func_ramrod_data iwarp_init_func; struct fcoe_init_ramrod_params fcoe_init; struct fcoe_conn_offload_ramrod_params fcoe_conn_ofld; struct fcoe_conn_terminate_ramrod_params fcoe_conn_terminate; diff --git a/include/linux/qed/iwarp_common.h b/include/linux/qed/iwarp_common.h new file mode 100644 index 0000000..b8b3e1c --- /dev/null +++ b/include/linux/qed/iwarp_common.h @@ -0,0 +1,53 @@ +/* QLogic qed NIC Driver + * Copyright (c) 2015-2017 QLogic Corporation + * + * This software is available to you under a choice of one of two + * licenses. You may choose to be licensed under the terms of the GNU + * General Public License (GPL) Version 2, available from the file + * COPYING in the main directory of this source tree, or the + * OpenIB.org BSD license below: + * + * 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. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef __IWARP_COMMON__ +#define __IWARP_COMMON__ +#include +/************************/ +/* IWARP FW CONSTANTS */ +/************************/ + +#define IWARP_ACTIVE_MODE 0 +#define IWARP_PASSIVE_MODE 1 + +#define IWARP_SHARED_QUEUE_PAGE_SIZE (0x8000) +#define IWARP_SHARED_QUEUE_PAGE_RQ_PBL_OFFSET (0x4000) +#define IWARP_SHARED_QUEUE_PAGE_RQ_PBL_MAX_SIZE (0x1000) +#define IWARP_SHARED_QUEUE_PAGE_SQ_PBL_OFFSET (0x5000) +#define IWARP_SHARED_QUEUE_PAGE_SQ_PBL_MAX_SIZE (0x3000) + +#define IWARP_REQ_MAX_INLINE_DATA_SIZE (128) +#define IWARP_REQ_MAX_SINGLE_SQ_WQE_SIZE (176) + +#define IWARP_MAX_QPS (64 * 1024) + +#endif /* __IWARP_COMMON__ */ diff --git a/include/linux/qed/qed_rdma_if.h b/include/linux/qed/qed_rdma_if.h index ff9be01..5b4bb09 100644 --- a/include/linux/qed/qed_rdma_if.h +++ b/include/linux/qed/qed_rdma_if.h @@ -491,6 +491,7 @@ struct qed_roce_ll2_packet { enum qed_rdma_type { QED_RDMA_TYPE_ROCE, + QED_RDMA_TYPE_IWARP }; struct qed_dev_rdma_info {