From patchwork Mon Jan 23 18:09:00 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Raghava Aditya Renukunta X-Patchwork-Id: 9533777 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 AB96D6042F for ; Tue, 24 Jan 2017 00:47:06 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 9022827C05 for ; Tue, 24 Jan 2017 00:47:06 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 7385527E33; Tue, 24 Jan 2017 00:47:06 +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=-5.2 required=2.0 tests=BAYES_00, DATE_IN_PAST_06_12, 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 1FE6327C05 for ; Tue, 24 Jan 2017 00:47:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751938AbdAXArD (ORCPT ); Mon, 23 Jan 2017 19:47:03 -0500 Received: from mail-by2nam01on0070.outbound.protection.outlook.com ([104.47.34.70]:47168 "EHLO NAM01-BY2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751880AbdAXArB (ORCPT ); Mon, 23 Jan 2017 19:47:01 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mscc365.onmicrosoft.com; s=selector1-microsemi-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=h2wYwRT0Z6LceFuX+P+wPWq6B/CAR5b0I4RwOhM2uqc=; b=jwVqta7pASWK3bII2M/nqlmqyyzsepvXBGoEUt1SyHS44cnsZapTK2/ZGxKM9iMJ3lI0c4L9ESfJrR7pm18/ZpRJzozO1PMV5i9UDswbianBefewnOG/KDZqEN0/s5mSFINqQcr7cgYE8Nf7ZafB4Yc1pi4RBCVm0Aain8bwFGU= Received: from BY2PR02CA0041.namprd02.prod.outlook.com (10.141.216.31) by BY2PR0201MB0805.namprd02.prod.outlook.com (10.160.125.146) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.845.12; Tue, 24 Jan 2017 00:46:06 +0000 Received: from BL2FFO11FD046.protection.gbl (2a01:111:f400:7c09::139) by BY2PR02CA0041.outlook.office365.com (2a01:111:e400:2c40::31) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.860.13 via Frontend Transport; Tue, 24 Jan 2017 00:46:06 +0000 Authentication-Results: spf=none (sender IP is 208.19.100.21) smtp.mailfrom=microsemi.com; vger.kernel.org; dkim=none (message not signed) header.d=none;vger.kernel.org; dmarc=none action=none header.from=microsemi.com; Received-SPF: None (protection.outlook.com: microsemi.com does not designate permitted sender hosts) Received: from avsrvexchhts1.microsemi.net (208.19.100.21) by BL2FFO11FD046.mail.protection.outlook.com (10.173.161.208) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA_P384) id 15.1.803.8 via Frontend Transport; Tue, 24 Jan 2017 00:46:05 +0000 Received: from localhost (10.181.116.230) by avsrvexchhts1.microsemi.net (10.100.34.105) with Microsoft SMTP Server (TLS) id 14.3.339.0; Mon, 23 Jan 2017 16:45:51 -0800 From: Raghava Aditya Renukunta To: , , CC: , , , Subject: [PATCH 16/24] aacraid: Add task management functionality Date: Mon, 23 Jan 2017 10:09:00 -0800 Message-ID: <20170123180908.3465-17-RaghavaAditya.Renukunta@microsemi.com> X-Mailer: git-send-email 2.9.0 In-Reply-To: <20170123180908.3465-1-RaghavaAditya.Renukunta@microsemi.com> References: <20170123180908.3465-1-RaghavaAditya.Renukunta@microsemi.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-Office365-Filtering-HT: Tenant X-Forefront-Antispam-Report: CIP:208.19.100.21; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(7916002)(39850400002)(39450400003)(39410400002)(39840400002)(39860400002)(2980300002)(428002)(189002)(199003)(101416001)(2906002)(356003)(6666003)(4326007)(104016004)(76176999)(81166006)(81156014)(8676002)(107886002)(53936002)(106466001)(5001770100001)(76506005)(57986006)(97736004)(4001430100002)(189998001)(105586002)(50986999)(5003940100001)(86362001)(2201001)(50226002)(77096006)(68736007)(305945005)(5660300001)(50466002)(2950100002)(626004)(48376002)(8936002)(69596002)(92566002)(1076002)(36756003)(47776003)(38730400001)(54906002); DIR:OUT; SFP:1101; SCL:1; SRVR:BY2PR0201MB0805; H:avsrvexchhts1.microsemi.net; FPR:; SPF:None; PTR:InfoDomainNonexistent; MX:1; A:1; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BL2FFO11FD046; 1:tCHy1R2vg3v0YGSxbkOTLJza6BxqGauytnqOdqdOUC7Ng3CiZhZHZlzj8xNGVnfvSfjedOOJPkwny+mxYKEqdbdvqqG3MBZRZxc6yZjORgw87DvMc34no/tWbkwOIfO4VJxu0YT+BI+4eiYsIeBLzoCA47yjsJBKcqFC1bfJjTTT2UfLakx9A2H2Cvlvd1qFCIBBK1TIntL2zOFVD1njSM1/lbdk9a0QN5ews1OGeJ2C5oqyb/KKQ+by18s3gCtnFT1zu7Miik/IDqA/i8gx/CkggjvNlCCh4kx3ZQ6D3bObIf5z15qzCxHlFnUnBhgkBnDp6yBFsH15bN9CWaa74czfciK0Tv4sht9Ri+JPIZ3clDR1vfYycWHwzdiIdyPgOHm0IbJ5KtWvZHgaGbQ39ympw+3b0eqQBrmaxGFZjAQd4ba2RNeIGWxtBXh+3mkVatPWg+XPlI5O710Ihu7OM5AV9vm0zfcX87BIQscHSkvikbynJWM7vGphbsAgvYs+ir8kp15pXi5Qo9UAp7DhZVIEP9CtVzAo2zQWEEzXniujgNL/g2DCrRbQSJziF0wh X-MS-Office365-Filtering-Correlation-Id: 2191de7c-66fe-4f53-ef64-08d443f26164 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(22001); SRVR:BY2PR0201MB0805; X-Microsoft-Exchange-Diagnostics: 1; BY2PR0201MB0805; 3:WJNI87czId72a11VlxXWqbyr4uLj02xoGBk9W3YS9iP3l5r3Hj2M4/imawTnLIW3z8cLQSZM7cGY2xvu+e+OzjISFhdIfMqBVJy1PbI4vgClHxVAhOFQ2JWEoZw3y++tbPYegeAMlBSCSqcdwufGsggiYM7KhNFw+WWH8VM7B/7gDqEquWa2nhJaBYqVEhfrOZXUT4tHu7o050PJcfLbyezJKuamP8ZzxFbpigtN3ll3jpmRjBIG29m7FMmhy+z/CClSw3UfuWLdfmgj0xk43MGzKVHnCgbNu4dU5u59nr4F9s+qLhlHd2k6ymdh+dUgF4VFG2KpCT+hOLttH6IBQHkV2a/AVS7e5IDZAWTpOZlVrqq1LZSPbvdxmEsmQzZw X-Microsoft-Exchange-Diagnostics: 1; BY2PR0201MB0805; 25:Hl8twS86UT7z16UynfBn4D5RlwJpms/2qH2r7hKUI4gCK/SUu04XBpu4sOei3m0XYlUh0/8HoiqZFuL9IyYeuGe52MWVDyXJMMjm20LHigGT2WB6itNxNiA+P4Qy8C2k5BCDmReNKAI0XR8snjAJHEyK/euNW5QF5edqGJVQiOpHkiIeprXSQiEt0y2UBJlcUKfyR/KzfEzAhhF7Uih4A57kVxtGzUDM0StSN+e5D1H8rsih8v75bulfuDu8jdn5yIuRbP665wvICOWtMf+JADXXVbJufH8aDodB1nhXdNewLcmX+Z6U9PImgH4QL2pJBLRJquotzpZtdv6CYT5WDzAhjOz5NW1LwMTJ6RvgFQ5hwZbIogHwJWXhRTs4952ClB7wdXPtAnwg5oc7Go5j1pxSDawhziLLz54GwU8dk5w5CnzpQtu+7gvjl/tsJXOYmJWJvgkGi2xe0XB0fJZSveO8VTdaRwT46dMcICSDKsa3I5KJjtB3AZEvjQRPO/ic/jx9KBN+7wzmsIpmwnUMK2Agi/ayVEJolhAtMDLE2O34vPhvMIiqNNd5Vjkyow2OkLVddMBcYC3MllV8MD2aaJCa5IcCkEWQMBqr5PFES7HOSSzi6fLDrmCAOQB1J9vHnlkwtS4KJxFbJ7LTglY3q4Lmf1oDuSBg0WBKGbgAvGO20jSnPsmORjL8HvTTly7gQW5/xqTATcsLQFu/CvGFcaTKxV3ycEr5QYpU0ZQWAlHFqKowEqy4ti/oUedLWELYtNMQyhg0v20fZT8oyh0ySsH+64lb6cG14pT80YkVWimnBKyibpB1FxyFqLcN2R3dcm89ZLwMTjZLqYmQLVt7Y4tAcUHjA1H3LYXBR7dIRic= X-Microsoft-Exchange-Diagnostics: 1; BY2PR0201MB0805; 31:F8GOwRH+o3+u4QEfaZME7KkM5ADFSgBRvX/EdyhdLkQfrVBzwxrXkp5fXHsFYr+eXG1cK8AgZwIbFLlQyH8jpnHtFa6u5ZC8/J4UGzHjPOk35YjTgcqO6pYq1M4p4ZClX6bJZ8lEaE6QLggHY6FPc6PxVYjXCUtGhm7ce1f6RaEAANfx5OJBL9AsEZ6ZS0KKI/1f6rtx9uE6XROnte98HMvRqecaokhZz9LMIxC+47oFbN3qxi2Gptq72lAzbeh+JnbEqNFuER7SB6DykdCvicAr1vfk0fBzl3AZSobbVVI=; 20:70OfDavPi8s+nL8/SRuKpKGALdkpC2hFQjIg3n1wXKewMNQKm1qdv6r1mDS/UAW8GydVEVHGjclyydayWeswmM4w4fNrg9eEE9+C4jKWJsYFCouAAlFNDym6jYEYmbP3k9I2UulRs6oA15QGC/LmG0zfJibCZ/kTPExgMfExgh1woH63kDxaIXMD0R5r/oz6RvvyTttA4yEt3tgjRyNAYGH1exKAJf2nUjrdCZzYq3feiuMqezqD7J9mu5eRFMmUzYxvDkiiZzgEB/WUpRfJl+D7sSwOTtJMudi1H+BSnRjVCswy95CAv1EHmvmHKid3TJ/QPBVqizVFRUALM8FWNo2qw2tKbEEqfBAd1ivYiP2NJ9ZZ8R4SukTeIx9Bcc2G33IQW03eGPvWgYdZ0yNMyo7mSoysiEJI5zF/BWXz8Qe4FbHCZZdUXr1ux06OYVONlxWm9cpVQ2BPyQ9LgWWldbOquzihxtemzwVps3iItv1AKd/W9Cm9Mrjkapp/uDnT X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(72170198267865); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040375)(601004)(2401047)(8121501046)(5005006)(13024025)(13015025)(13023025)(13018025)(13017025)(10201501046)(3002001)(6055026)(6041248)(20161123560025)(20161123562025)(20161123564025)(20161123555025)(6072148); SRVR:BY2PR0201MB0805; BCL:0; PCL:0; RULEID:; SRVR:BY2PR0201MB0805; X-Microsoft-Exchange-Diagnostics: 1; BY2PR0201MB0805; 4:TF97VWJM+ggNQLl5pzcCgc6nwNwM7rbqmJxfNyEJ3qttPV1gcz7/qc+u5UIwBgNwxW06IaupSIL1qqMDv/smDEFdWcpvl9ReYhPAwjUltIjVJWWGJ8nmQuaGChWyy9DmxevIJnh52hS4+Ow7XwRRdzOg5jFmbqjl4m93wGsNCxo7a/MQ+ae6It7PTaMKSfOpTKvPbaLqMbr6MDMg9NhFAJrzw0d4a8cngIie1kUtq+goI6NDsAancyeEXTfDcPRegshJHuEIz6RNBMca4nLYKwpqhfbT3RmpZqAylLJDMB3shE3+rysrwM31mGvpk4ShjQa4rmsoFpZmQa+w1odltaC+jqrZmrDFL5HWW3PgTzXKPmfJHcwAsp9l2GEW3c+siwd6loUpffiam88hF8QCE9c7abO9PRMGAUqR6KH8GE15IHQHzZ0hrQ/UmMT0g7d2B/g+N1hJTHth09zXvygeeKVhD3/wfw2LHdxwR8C+N+IQ6KA6ojBFaedmBH7JmzY8BZh0+5ttZaYzlgw84ezLqADRYFmm71LC0k+uemwW+VLIlc2I9i+DBd04Q4W4cH9sfKfAZd4If4+bKi0RTmiUpIxLMlfeEBhKsRtbOmmC+OESQPnkxZf5nkNjbquWbUPBE5h923Fo4dtyXHP/Cbr9LYjWVFPErFgqiPsiuh0Bp99VD/A237v7PgbCTWJRN7ZUuA3cJw8P071Rz7odwDIsrSinW24w0iMLHPD44V4WtpM= X-Forefront-PRVS: 0197AFBD92 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BY2PR0201MB0805; 23:oYCi21LDRfS/baiZ39Q7G1P4Dobl7wiVcQSD3J/?= =?us-ascii?Q?NzT4UCl2srqzfNrlUc1qvenNcBLEoB2ydfDZg/ztz2qhAyHOF1RJqRSc6GIJ?= =?us-ascii?Q?iJdBjxQCImDR5EvpKDpu6Oc18NFYDfg/2/iGtQIQiIwjZQT0FAxICq9XA2xI?= =?us-ascii?Q?/rhHbnVypJ/knuzUxlqPe0RF9njr3lFvI0bM19kdHrhwTw4ZEcXFBnTpo+27?= =?us-ascii?Q?JgSt4OpzrIyaUoFS/tSyDEHuEVheyOfJMqs2lEhX7w6devQXgvtxw64GGkNc?= =?us-ascii?Q?G0ti6qrnkpWjplOYTv5hP8O3jCCCAG3KAeiuBjur7BImWBqAknAjb5bqOyu3?= =?us-ascii?Q?KtaGw0B/2PKvNWVmu1sYK/JVuxs37BnQ/UPattwLKV2gotkBnZSXkbjWOvYg?= =?us-ascii?Q?SzI81E0XKk+JQ0XpyX35tdLH/1es6L8+5TZT7oPzuIEJDXI5zAs2coK97PZ+?= =?us-ascii?Q?0Lh1SYCJuhugIefkCCNjyQs7Hh1OTm/VI6VrBD95jeQl0RJ/8tDExv8ylWaL?= =?us-ascii?Q?O7Dd6jupoGrmyPLbYhnNITmKotF1YruIvp+ubg/WFmz+Vpyx/UwexC9NkkbF?= =?us-ascii?Q?MV0rWlbeHNks1ZfbfYBfcoZAMT7dGi5pkdGvblJFbfsHB5csMT9qKznW2vFV?= =?us-ascii?Q?pWZxyvxyH0B5MqTQHugZyX/oztbq+k+Gpx+Py/yP/KeZTHk3otGQFqndzh+3?= =?us-ascii?Q?GdrGZYgHBcpHh6zuXSnn2Az3wI9dwY6z+IZAkUcPNlFYir+fkY48WxQ8RSg2?= =?us-ascii?Q?mtrvxYc2htbc3T9yddfVN3wG0Fp47/AOReC0vYXJCIoqK3MtZ6pIPMzW51FP?= =?us-ascii?Q?JN3bJuvogI5F/vPE/8zxT0nFYCAWiEdteClSx10HGDGsVQ7bPz/Fv397e2PW?= =?us-ascii?Q?h4sRMNxN2wwDwqxSY3I7WjsmeifhzVReYEQL2dE5AZUT6vOA8ThpsBIXaksa?= =?us-ascii?Q?VvCjdz6/UF2CQNWoutuso89uqNyvZouM2BacOC7d0Z6nOIZsE0ekkK+fCAvj?= =?us-ascii?Q?2N+aOkJRsD189oCPHAC8TZ0GKcbcmQxc+EOXeazZjUSmtQQW1E8vb9OBx3et?= =?us-ascii?Q?2NOqm24C/b8gke0kIe9hj2vbHu4eqM0nC7oceC6wjSw+NxRWjWiiaF8UkS+3?= =?us-ascii?Q?1xcipKBJL7kNa8NuH3fVxyZyGMiZO0+QGV33VmoE7z2IPFTDEqmhmH8VgZwS?= =?us-ascii?Q?Ri97b4CA1XDEnCihH7Z2Bva6P49zOtmEaXpP/wuhVl5czTg5f7BAPDDKP5gd?= =?us-ascii?Q?vJYz3meziDDPWFu7Mp8/97fqclYzlpWzUebaxCPrRE1KGiZdXhFrsc3LThyY?= =?us-ascii?Q?QYA=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; BY2PR0201MB0805; 6:50RnzWTy9KTvx0r2bNR0cV9VfMZSqXsUxPZ3X2dPM/b7Xwz8lPlsRnFlwRn8suS5VsDF3oNvml2raxNFwwfkFXA+KaQr+LKYNrpZjUtDtHn6uC13DaGIjw1S2DqBUXld8NP5SzXWnWxYkc3UNEOY7zzbELrfWlwJSVb1rFfXY6tqOqVBiusG+kghNt7LcZ9fBDxkzpiUVRNuwp0yUPJfoyoNa0HmIhSEnayggSnkfCwcAo5uWgqJU+Er7kw+Eas2OBo1lBGQaytuo9cJ5Q31T2FYnoNKjj7zoBFyci7tXh5Nlk0lTZ8AjiM64hnTjtUHTCn1uv5/93nj5AnMM8LcU+rr67XIrdn2oiYz9hNDz9UwGE6MQ/I+xWwhtahefjhAvgbwXbkMJ83+Uuekxx+YYxmb8PWBD2efQttSawILaTGt4fA3Uc8XzG8eXp+YNQrpfKSTujL27xKrwQu/t8f/Dg==; 5:+zDHOmHUif0t1gLI90AFGWvlX2yoMBGmnDlYl/pFYNjXpUDoy6W4UhThHoIb0y981swTGjXDVEV1w3ifg574G5geRLrv2oIqd6NQf5q4coy68es2G1Iy/chtAYWIc6JLPBlYeockkmOrYusJF3kt7A==; 24:0bQXk3DWycirWNYlAR2Rd7KzZSx4MOFXi0bKbFz5bHmz+scVnBGKF/XD4goXqNOHZhw3mk5ZUW+IHQsxWy709DkQekJUK+uLD0aTPwZBUHs= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BY2PR0201MB0805; 7:IA5qI0yWN2wCKSjDc9M9tCYnF7SMmcn1rbbQByaFkM9JYDSOxNjI1IkYSon4MKRQpHu2KAtmvSKhpZeVzjZESghlLr+L8p7L0qf0qXmtKr7zfirdK0N9rQgeMwXj4AII3PCiIf2Ew3aDLL73M6fwki2iVQCzLNM5LoTN78Ac6Q94WFt0HPoLIiCG9qLiE9aE61ZPLpXaI8x9ulROkk/fsdLnW016+a6/XfucWKNNIYtftqCizl57bWuBmEt+/AoQ5/qTC05OrhtivRKn+nzPMBvH0GIosH+TZi8Yoxn7BGBvyD51BGPT2BiYRPTOzB3ufZ8s5exevz74uoeeiAI+hnMFnun4K72L90hWcqDMQbD69hKqBUbEgd0n7WaViSdDfgBw9K7CEPt9RXxN1+iJ772XD2/Xdo6vzCku/B/jQK3epk/sGNwchkhCC3kl8O8Rn4icbaaH30DZghMEkt1mQw== X-OriginatorOrg: microsemi.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jan 2017 00:46:05.7802 (UTC) X-MS-Exchange-CrossTenant-Id: f267a5c8-86d8-4cc9-af71-1fd2c67c8fad X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=f267a5c8-86d8-4cc9-af71-1fd2c67c8fad; Ip=[208.19.100.21]; Helo=[avsrvexchhts1.microsemi.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BY2PR0201MB0805 Sender: linux-scsi-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-scsi@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Added support to send out task management commands. Signed-off-by: Raghava Aditya Renukunta Signed-off-by: Dave Carroll --- drivers/scsi/aacraid/aachba.c | 364 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 360 insertions(+), 4 deletions(-) diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c index 237d68c..0cb4dab 100644 --- a/drivers/scsi/aacraid/aachba.c +++ b/drivers/scsi/aacraid/aachba.c @@ -217,9 +217,13 @@ static long aac_build_sg64(struct scsi_cmnd *scsicmd, struct sgmap64 *psg); static long aac_build_sgraw(struct scsi_cmnd *scsicmd, struct sgmapraw *psg); static long aac_build_sgraw2(struct scsi_cmnd *scsicmd, struct aac_raw_io2 *rio2, int sg_max); +static long aac_build_sghba(struct scsi_cmnd *scsicmd, + struct aac_hba_cmd_req *hbacmd, + int sg_max, u64 sg_address); static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, int pages, int nseg, int nseg_new); static int aac_send_srb_fib(struct scsi_cmnd* scsicmd); +static int aac_send_hba_fib(struct scsi_cmnd *scsicmd); #ifdef AAC_DETAILED_STATUS_INFO static char *aac_get_status_string(u32 status); #endif @@ -1446,6 +1450,52 @@ static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd return srbcmd; } +static struct aac_hba_cmd_req *aac_construct_hbacmd(struct fib *fib, + struct scsi_cmnd *cmd) +{ + struct aac_hba_cmd_req *hbacmd; + struct aac_dev *dev; + int bus, target; + u64 address; + + dev = (struct aac_dev *)cmd->device->host->hostdata; + + hbacmd = (struct aac_hba_cmd_req *)fib->hw_fib_va; + memset(hbacmd, 0, 96); /* sizeof(*hbacmd) is not necessary */ + /* iu_type is a parameter of aac_hba_send */ + switch (cmd->sc_data_direction) { + case DMA_TO_DEVICE: + hbacmd->byte1 = 2; + break; + case DMA_FROM_DEVICE: + case DMA_BIDIRECTIONAL: + hbacmd->byte1 = 1; + break; + case DMA_NONE: + default: + break; + } + hbacmd->lun[1] = cpu_to_le32(cmd->device->lun); + + bus = aac_logical_to_phys(scmd_channel(cmd)); + target = scmd_id(cmd); + hbacmd->it_nexus = dev->hba_map[bus][target].rmw_nexus; + + /* we fill in reply_qid later in aac_src_deliver_message */ + /* we fill in iu_type, request_id later in aac_hba_send */ + /* we fill in emb_data_desc_count later in aac_build_sghba */ + + memcpy(hbacmd->cdb, cmd->cmnd, cmd->cmd_len); + hbacmd->data_length = cpu_to_le32(scsi_bufflen(cmd)); + + address = (u64)fib->hw_error_pa; + hbacmd->error_ptr_hi = cpu_to_le32((u32)(address >> 32)); + hbacmd->error_ptr_lo = cpu_to_le32((u32)(address & 0xffffffff)); + hbacmd->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE); + + return hbacmd; +} + static void aac_srb_callback(void *context, struct fib * fibptr); static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd) @@ -1516,6 +1566,31 @@ static int aac_scsi_32_64(struct fib * fib, struct scsi_cmnd * cmd) return aac_scsi_32(fib, cmd); } +static int aac_adapter_hba(struct fib *fib, struct scsi_cmnd *cmd) +{ + struct aac_hba_cmd_req *hbacmd = aac_construct_hbacmd(fib, cmd); + struct aac_dev *dev; + // u16 fibsize; + long ret; + + dev = (struct aac_dev *)cmd->device->host->hostdata; + + ret = aac_build_sghba(cmd, hbacmd, + dev->scsi_host_ptr->sg_tablesize, (u64)fib->hw_sgl_pa); + if (ret < 0) + return ret; + + /* + * Now send the HBA command to the adapter + */ + fib->hbacmd_size = 64 + le32_to_cpu(hbacmd->emb_data_desc_count) * + sizeof(struct aac_hba_sgl); + + return aac_hba_send(HBA_IU_TYPE_SCSI_CMD_REQ, fib, + (fib_callback) aac_hba_callback, + (void *) cmd); +} + int aac_issue_bmic_identify(struct aac_dev *dev, u32 bus, u32 target) { struct fib *fibptr; @@ -1528,6 +1603,7 @@ int aac_issue_bmic_identify(struct aac_dev *dev, u32 bus, u32 target) u32 vbus, vid; u16 temp; + fibptr = aac_fib_alloc(dev); if (!fibptr) return -ENOMEM; @@ -2000,6 +2076,11 @@ int aac_get_adapter_info(struct aac_dev* dev) (dev->scsi_host_ptr->sg_tablesize * 8) + 112; } } + if (!dev->sync_mode && dev->sa_firmware && + dev->scsi_host_ptr->sg_tablesize > HBA_MAX_SG_SEPARATE) + dev->scsi_host_ptr->sg_tablesize = dev->sg_tablesize = + HBA_MAX_SG_SEPARATE; + /* FIB should be freed only after getting the response from the F/W */ if (rcode != -ERESTARTSYS) { aac_fib_complete(fibptr); @@ -2556,7 +2637,7 @@ static int aac_start_stop(struct scsi_cmnd *scsicmd) int aac_scsi_cmd(struct scsi_cmnd * scsicmd) { - u32 cid; + u32 cid, bus; struct Scsi_Host *host = scsicmd->device->host; struct aac_dev *dev = (struct aac_dev *)host->hostdata; struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; @@ -2602,8 +2683,24 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd) } } } else { /* check for physical non-dasd devices */ - if (dev->nondasd_support || expose_physicals || - dev->jbod) { + bus = aac_logical_to_phys(scmd_channel(scsicmd)); + if (bus < AAC_MAX_BUSES && cid < AAC_MAX_TARGETS && + (dev->hba_map[bus][cid].expose + == AAC_HIDE_DISK)){ + if (scsicmd->cmnd[0] == INQUIRY) { + scsicmd->result = DID_NO_CONNECT << 16; + goto scsi_done_ret; + } + } + + if (bus < AAC_MAX_BUSES && cid < AAC_MAX_TARGETS && + dev->hba_map[bus][cid].devtype + == AAC_DEVTYPE_NATIVE_RAW) { + if (dev->in_reset) + return -1; + return aac_send_hba_fib(scsicmd); + } else if (dev->nondasd_support || expose_physicals || + dev->jbod) { if (dev->in_reset) return -1; return aac_send_srb_fib(scsicmd); @@ -3362,7 +3459,151 @@ static void aac_srb_callback(void *context, struct fib * fibptr) /** * - * aac_send_scb_fib + * aac_hba_callback + * @context: the context set in the fib - here it is scsi cmd + * @fibptr: pointer to the fib + * + * Handles the completion of a native HBA scsi command + * + */ +void aac_hba_callback(void *context, struct fib *fibptr) +{ + struct aac_dev *dev; + struct scsi_cmnd *scsicmd; + + scsicmd = (struct scsi_cmnd *) context; + + if (!aac_valid_context(scsicmd, fibptr)) + return; + + WARN_ON(fibptr == NULL); + dev = fibptr->dev; + + if (!(fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA_TMF)) + scsi_dma_unmap(scsicmd); + + if (fibptr->flags & FIB_CONTEXT_FLAG_FASTRESP) { + /* fast response */ + scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; + } else { + struct aac_hba_resp *err = + &((struct aac_native_hba *)fibptr->hw_fib_va)->resp.err; + + // BUG_ON(err->iu_type != HBA_IU_TYPE_RESP); + if (err->service_response == HBA_RESP_SVCRES_TASK_COMPLETE) { + scsicmd->result = err->status; + /* set residual count */ + scsi_set_resid(scsicmd, + le32_to_cpu(err->residual_count)); + + switch (err->status) { + case SAM_STAT_GOOD: + scsicmd->result |= DID_OK << 16 | + COMMAND_COMPLETE << 8; + break; + case SAM_STAT_CHECK_CONDITION: + { + int len; + + len = min_t(u8, err->sense_response_data_len, + SCSI_SENSE_BUFFERSIZE); + if (len) + memcpy(scsicmd->sense_buffer, + err->sense_response_buf, len); + scsicmd->result |= DID_OK << 16 | + COMMAND_COMPLETE << 8; + break; + } + case SAM_STAT_BUSY: + scsicmd->result |= DID_BUS_BUSY << 16 | + COMMAND_COMPLETE << 8; + break; + case SAM_STAT_TASK_ABORTED: + scsicmd->result |= DID_ABORT << 16 | + ABORT << 8; + break; + case SAM_STAT_RESERVATION_CONFLICT: + case SAM_STAT_TASK_SET_FULL: + default: + scsicmd->result |= DID_ERROR << 16 | + COMMAND_COMPLETE << 8; + break; + } + } else if (err->service_response == HBA_RESP_SVCRES_FAILURE) { + switch (err->status) { + case HBA_RESP_STAT_HBAMODE_DISABLED: + { + u32 bus, cid; + + bus = aac_logical_to_phys( + scmd_channel(scsicmd)); + cid = scmd_id(scsicmd); + if (dev->hba_map[bus][cid].devtype == + AAC_DEVTYPE_NATIVE_RAW) { + dev->hba_map[bus][cid].devtype = + AAC_DEVTYPE_ARC_RAW; + dev->hba_map[bus][cid].rmw_nexus = + 0xffffffff; + } + scsicmd->result = DID_NO_CONNECT << 16 | + COMMAND_COMPLETE << 8; + break; + } + case HBA_RESP_STAT_IO_ERROR: + case HBA_RESP_STAT_NO_PATH_TO_DEVICE: + scsicmd->result = DID_OK << 16 | + COMMAND_COMPLETE << 8 | SAM_STAT_BUSY; + break; + case HBA_RESP_STAT_IO_ABORTED: + scsicmd->result = DID_ABORT << 16 | + ABORT << 8; + break; + case HBA_RESP_STAT_INVALID_DEVICE: + scsicmd->result = DID_NO_CONNECT << 16 | + COMMAND_COMPLETE << 8; + break; + case HBA_RESP_STAT_UNDERRUN: + /* UNDERRUN is OK */ + scsicmd->result = DID_OK << 16 | + COMMAND_COMPLETE << 8; + break; + case HBA_RESP_STAT_OVERRUN: + default: + scsicmd->result = DID_ERROR << 16 | + COMMAND_COMPLETE << 8; + break; + } + } else if (err->service_response == + HBA_RESP_SVCRES_TMF_REJECTED) { + scsicmd->result = + DID_ERROR << 16 | MESSAGE_REJECT << 8; + } else if (err->service_response == + HBA_RESP_SVCRES_TMF_LUN_INVALID) { + scsicmd->result = + DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; + } else if ((err->service_response == + HBA_RESP_SVCRES_TMF_COMPLETE) || + (err->service_response == + HBA_RESP_SVCRES_TMF_SUCCEEDED)) { + scsicmd->result = + DID_OK << 16 | COMMAND_COMPLETE << 8; + } else { + scsicmd->result = + DID_ERROR << 16 | COMMAND_COMPLETE << 8; + } + } + + aac_fib_complete(fibptr); + + if (fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA_TMF) + scsicmd->SCp.sent_command = 1; + else + scsicmd->scsi_done(scsicmd); +} + +/** + * + * aac_send_srb_fib * @scsicmd: the scsi command block * * This routine will form a FIB and fill in the aac_srb from the @@ -3405,6 +3646,54 @@ static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) return -1; } +/** + * + * aac_send_hba_fib + * @scsicmd: the scsi command block + * + * This routine will form a FIB and fill in the aac_hba_cmd_req from the + * scsicmd passed in. + */ +static int aac_send_hba_fib(struct scsi_cmnd *scsicmd) +{ + struct fib *cmd_fibcontext; + struct aac_dev *dev; + int status; + + dev = (struct aac_dev *)scsicmd->device->host->hostdata; + if (scmd_id(scsicmd) >= dev->maximum_num_physicals || + scsicmd->device->lun > AAC_MAX_LUN - 1) { + scsicmd->result = DID_NO_CONNECT << 16; + scsicmd->scsi_done(scsicmd); + return 0; + } + + /* + * Allocate and initialize a Fib then setup a BlockWrite command + */ + cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); + if (!cmd_fibcontext) + return -1; + + status = aac_adapter_hba(cmd_fibcontext, scsicmd); + + /* + * Check that the command queued to the controller + */ + if (status == -EINPROGRESS) { + scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; + return 0; + } + + pr_warn("aac_hba_cmd_req: aac_fib_send failed with status: %d\n", + status); + aac_fib_complete(cmd_fibcontext); + aac_fib_free(cmd_fibcontext); + + return -1; +} + + static long aac_build_sg(struct scsi_cmnd *scsicmd, struct sgmap *psg) { struct aac_dev *dev; @@ -3657,6 +3946,73 @@ static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, int pages, int nseg, int return 0; } +static long aac_build_sghba(struct scsi_cmnd *scsicmd, + struct aac_hba_cmd_req *hbacmd, + int sg_max, + u64 sg_address) +{ + unsigned long byte_count = 0; + int nseg; + + nseg = scsi_dma_map(scsicmd); + if (nseg < 0) + return nseg; + if (nseg) { + struct scatterlist *sg; + int i; + u32 cur_size; + struct aac_hba_sgl *sge; + + if (nseg > HBA_MAX_SG_EMBEDDED) + sge = &hbacmd->sge[2]; + else + sge = &hbacmd->sge[0]; + + scsi_for_each_sg(scsicmd, sg, nseg, i) { + int count = sg_dma_len(sg); + u64 addr = sg_dma_address(sg); + + WARN_ON(i >= sg_max); + sge->addr_hi = cpu_to_le32((u32)(addr>>32)); + sge->addr_lo = cpu_to_le32((u32)(addr & 0xffffffff)); + cur_size = cpu_to_le32(count); + sge->len = cur_size; + sge->flags = 0; + byte_count += count; + sge++; + } + + sge--; + /* hba wants the size to be exact */ + if (byte_count > scsi_bufflen(scsicmd)) { + u32 temp = le32_to_cpu(sge->len) - + (byte_count - scsi_bufflen(scsicmd)); + sge->len = cpu_to_le32(temp); + byte_count = scsi_bufflen(scsicmd); + } + + if (nseg <= HBA_MAX_SG_EMBEDDED) { + hbacmd->emb_data_desc_count = cpu_to_le32(nseg); + sge->flags = cpu_to_le32(0x40000000); + } else { + /* not embedded */ + hbacmd->sge[0].flags = cpu_to_le32(0x80000000); + hbacmd->emb_data_desc_count = cpu_to_le32(1); + hbacmd->sge[0].addr_hi = + cpu_to_le32((u32)(sg_address >> 32)); + hbacmd->sge[0].addr_lo = + cpu_to_le32((u32)(sg_address & 0xffffffff)); + } + + /* Check for command underflow */ + if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { + pr_warn("aacraid: cmd len %08lX cmd underflow %08X\n", + byte_count, scsicmd->underflow); + } + } + return byte_count; +} + #ifdef AAC_DETAILED_STATUS_INFO struct aac_srb_status_info {