blob: 276084ed04a699f81b4b0bcf9b62674ea7b6ff42 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/message/fusion/mptscsih.c
Prakash, Sathyaf36789e2007-08-14 16:22:54 +05303 * For use with LSI PCI chip/adapter(s)
4 * running LSI Fusion MPT (Message Passing Technology) firmware.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
Prakash, Sathyacddc0ab2008-05-21 00:56:41 +05306 * Copyright (c) 1999-2008 LSI Corporation
Eric Moore16d20102007-06-13 16:31:07 -06007 * (mailto:DL-MPTFusionLinux@lsi.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11/*
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; version 2 of the License.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 NO WARRANTY
22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26 solely responsible for determining the appropriateness of using and
27 distributing the Program and assumes all risks associated with its
28 exercise of rights under this Agreement, including but not limited to
29 the risks and costs of program errors, damage to or loss of data,
30 programs or equipment, and unavailability or interruption of operations.
31
32 DISCLAIMER OF LIABILITY
33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40
41 You should have received a copy of the GNU General Public License
42 along with this program; if not, write to the Free Software
43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
44*/
45/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/module.h>
48#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090049#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/init.h>
51#include <linux/errno.h>
52#include <linux/kdev_t.h>
53#include <linux/blkdev.h>
54#include <linux/delay.h> /* for mdelay */
Thomas Gleixnerb8a51442020-11-26 14:29:51 +010055#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <linux/reboot.h> /* notifier code */
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <linux/workqueue.h>
58
59#include <scsi/scsi.h>
60#include <scsi/scsi_cmnd.h>
61#include <scsi/scsi_device.h>
62#include <scsi/scsi_host.h>
63#include <scsi/scsi_tcq.h>
Moore, Eric Deane0fc15b2005-09-15 13:17:14 -060064#include <scsi/scsi_dbg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66#include "mptbase.h"
67#include "mptscsih.h"
Eric Moorebf451522006-07-11 17:25:35 -060068#include "lsi/mpi_log_sas.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
71#define my_NAME "Fusion MPT SCSI Host driver"
72#define my_VERSION MPT_LINUX_VERSION_COMMON
73#define MYNAM "mptscsih"
74
75MODULE_AUTHOR(MODULEAUTHOR);
76MODULE_DESCRIPTION(my_NAME);
77MODULE_LICENSE("GPL");
Eric Moore9f4203b2007-01-04 20:47:47 -070078MODULE_VERSION(my_VERSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Linus Torvalds1da177e2005-04-16 15:20:36 -070080/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linus Torvalds1da177e2005-04-16 15:20:36 -070081/*
82 * Other private/forward protos...
83 */
Kashyap, Desaidb7051b2009-05-29 16:56:59 +053084struct scsi_cmnd *mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
Eric Mooree8206382007-09-29 10:16:53 -060085static struct scsi_cmnd * mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i);
86static void mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd);
87static int SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *scmd);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -040088int mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089static void mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -040090int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92static int mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
93 SCSIIORequest_t *pReq, int req_idx);
94static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -040095static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +053097int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id,
Hannes Reinecke9cb78c12014-06-25 15:27:36 +020098 u64 lun, int ctx2abort, ulong timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400100int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
101int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Kashyap, Desaie7deff32009-05-29 16:46:07 +0530103void
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +0530104mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code);
Kashyap, Desai37c60f32009-05-29 16:44:06 +0530105static int mptscsih_get_completion_code(MPT_ADAPTER *ioc,
106 MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400107int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -0700109static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +0530111static int
112mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
113 SCSITaskMgmtReply_t *pScsiTmReply);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400114void mptscsih_remove(struct pci_dev *);
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -0700115void mptscsih_shutdown(struct pci_dev *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116#ifdef CONFIG_PM
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400117int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
118int mptscsih_resume(struct pci_dev *pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119#endif
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
122/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
123/*
124 * mptscsih_getFreeChainBuffer - Function to get a free chain
125 * from the MPT_SCSI_HOST FreeChainQ.
126 * @ioc: Pointer to MPT_ADAPTER structure
127 * @req_idx: Index of the SCSI IO request frame. (output)
128 *
129 * return SUCCESS or FAILED
130 */
131static inline int
132mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
133{
134 MPT_FRAME_HDR *chainBuf;
135 unsigned long flags;
136 int rc;
137 int chain_idx;
138
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530139 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n",
Eric Moore29dd3602007-09-14 18:46:51 -0600140 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 spin_lock_irqsave(&ioc->FreeQlock, flags);
142 if (!list_empty(&ioc->FreeChainQ)) {
143 int offset;
144
145 chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR,
146 u.frame.linkage.list);
147 list_del(&chainBuf->u.frame.linkage.list);
148 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
149 chain_idx = offset / ioc->req_sz;
150 rc = SUCCESS;
Eric Moore29dd3602007-09-14 18:46:51 -0600151 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
152 "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
153 ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 } else {
155 rc = FAILED;
156 chain_idx = MPT_HOST_NO_CHAIN;
Eric Moore29dd3602007-09-14 18:46:51 -0600157 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n",
158 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 }
160 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
161
162 *retIndex = chain_idx;
163 return rc;
164} /* mptscsih_getFreeChainBuffer() */
165
166/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
167/*
168 * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
169 * SCSIIORequest_t Message Frame.
170 * @ioc: Pointer to MPT_ADAPTER structure
171 * @SCpnt: Pointer to scsi_cmnd structure
172 * @pReq: Pointer to SCSIIORequest_t structure
173 *
174 * Returns ...
175 */
176static int
177mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
178 SCSIIORequest_t *pReq, int req_idx)
179{
180 char *psge;
181 char *chainSge;
182 struct scatterlist *sg;
183 int frm_sz;
184 int sges_left, sg_done;
185 int chain_idx = MPT_HOST_NO_CHAIN;
186 int sgeOffset;
187 int numSgeSlots, numSgeThisFrame;
188 u32 sgflags, sgdir, thisxfer = 0;
189 int chain_dma_off = 0;
190 int newIndex;
191 int ii;
192 dma_addr_t v2;
193 u32 RequestNB;
194
195 sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK;
196 if (sgdir == MPI_SCSIIO_CONTROL_WRITE) {
197 sgdir = MPT_TRANSFER_HOST_TO_IOC;
198 } else {
199 sgdir = MPT_TRANSFER_IOC_TO_HOST;
200 }
201
202 psge = (char *) &pReq->SGL;
203 frm_sz = ioc->req_sz;
204
205 /* Map the data portion, if any.
206 * sges_left = 0 if no data transfer.
207 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900208 sges_left = scsi_dma_map(SCpnt);
209 if (sges_left < 0)
210 return FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212 /* Handle the SG case.
213 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900214 sg = scsi_sglist(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 sg_done = 0;
216 sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION);
217 chainSge = NULL;
218
219 /* Prior to entering this loop - the following must be set
220 * current MF: sgeOffset (bytes)
221 * chainSge (Null if original MF is not a chain buffer)
222 * sg_done (num SGE done for this MF)
223 */
224
225nextSGEset:
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530226 numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
228
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530229 sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 /* Get first (num - 1) SG elements
232 * Skip any SG entries with a length of 0
233 * NOTE: at finish, sg and psge pointed to NEXT data/location positions
234 */
235 for (ii=0; ii < (numSgeThisFrame-1); ii++) {
236 thisxfer = sg_dma_len(sg);
237 if (thisxfer == 0) {
Kashyap, Desai2f187862009-05-29 16:52:37 +0530238 /* Get next SG element from the OS */
239 sg = sg_next(sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 sg_done++;
241 continue;
242 }
243
244 v2 = sg_dma_address(sg);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530245 ioc->add_sge(psge, sgflags | thisxfer, v2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Kashyap, Desai2f187862009-05-29 16:52:37 +0530247 /* Get next SG element from the OS */
248 sg = sg_next(sg);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530249 psge += ioc->SGE_size;
250 sgeOffset += ioc->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 sg_done++;
252 }
253
254 if (numSgeThisFrame == sges_left) {
255 /* Add last element, end of buffer and end of list flags.
256 */
257 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT |
258 MPT_SGE_FLAGS_END_OF_BUFFER |
259 MPT_SGE_FLAGS_END_OF_LIST;
260
261 /* Add last SGE and set termination flags.
262 * Note: Last SGE may have a length of 0 - which should be ok.
263 */
264 thisxfer = sg_dma_len(sg);
265
266 v2 = sg_dma_address(sg);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530267 ioc->add_sge(psge, sgflags | thisxfer, v2);
268 sgeOffset += ioc->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 sg_done++;
270
271 if (chainSge) {
272 /* The current buffer is a chain buffer,
273 * but there is not another one.
274 * Update the chain element
275 * Offset and Length fields.
276 */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530277 ioc->add_chain((char *)chainSge, 0, sgeOffset,
278 ioc->ChainBufferDMA + chain_dma_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 } else {
280 /* The current buffer is the original MF
281 * and there is no Chain buffer.
282 */
283 pReq->ChainOffset = 0;
284 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530285 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
287 ioc->RequestNB[req_idx] = RequestNB;
288 }
289 } else {
290 /* At least one chain buffer is needed.
291 * Complete the first MF
292 * - last SGE element, set the LastElement bit
293 * - set ChainOffset (words) for orig MF
294 * (OR finish previous MF chain buffer)
295 * - update MFStructPtr ChainIndex
296 * - Populate chain element
297 * Also
298 * Loop until done.
299 */
300
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530301 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SG: Chain Required! sg done %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 ioc->name, sg_done));
303
304 /* Set LAST_ELEMENT flag for last non-chain element
305 * in the buffer. Since psge points at the NEXT
306 * SGE element, go back one SGE element, update the flags
307 * and reset the pointer. (Note: sgflags & thisxfer are already
308 * set properly).
309 */
310 if (sg_done) {
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530311 u32 *ptmp = (u32 *) (psge - ioc->SGE_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 sgflags = le32_to_cpu(*ptmp);
313 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
314 *ptmp = cpu_to_le32(sgflags);
315 }
316
317 if (chainSge) {
318 /* The current buffer is a chain buffer.
319 * chainSge points to the previous Chain Element.
320 * Update its chain element Offset and Length (must
321 * include chain element size) fields.
322 * Old chain element is now complete.
323 */
324 u8 nextChain = (u8) (sgeOffset >> 2);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530325 sgeOffset += ioc->SGE_size;
326 ioc->add_chain((char *)chainSge, nextChain, sgeOffset,
327 ioc->ChainBufferDMA + chain_dma_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 } else {
329 /* The original MF buffer requires a chain buffer -
330 * set the offset.
331 * Last element in this MF is a chain element.
332 */
333 pReq->ChainOffset = (u8) (sgeOffset >> 2);
334 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530335 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 ioc->RequestNB[req_idx] = RequestNB;
337 }
338
339 sges_left -= sg_done;
340
341
342 /* NOTE: psge points to the beginning of the chain element
343 * in current buffer. Get a chain buffer.
344 */
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200345 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) {
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530346 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200347 "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n",
348 ioc->name, pReq->CDB[0], SCpnt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return FAILED;
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200350 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 /* Update the tracking arrays.
353 * If chainSge == NULL, update ReqToChain, else ChainToChain
354 */
355 if (chainSge) {
356 ioc->ChainToChain[chain_idx] = newIndex;
357 } else {
358 ioc->ReqToChain[req_idx] = newIndex;
359 }
360 chain_idx = newIndex;
361 chain_dma_off = ioc->req_sz * chain_idx;
362
363 /* Populate the chainSGE for the current buffer.
364 * - Set chain buffer pointer to psge and fill
365 * out the Address and Flags fields.
366 */
367 chainSge = (char *) psge;
Eric Moore29dd3602007-09-14 18:46:51 -0600368 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Current buff @ %p (index 0x%x)",
369 ioc->name, psge, req_idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371 /* Start the SGE for the next buffer
372 */
373 psge = (char *) (ioc->ChainBuffer + chain_dma_off);
374 sgeOffset = 0;
375 sg_done = 0;
376
Eric Moore29dd3602007-09-14 18:46:51 -0600377 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Chain buff @ %p (index 0x%x)\n",
378 ioc->name, psge, chain_idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 /* Start the SGE for the next buffer
381 */
382
383 goto nextSGEset;
384 }
385
386 return SUCCESS;
387} /* mptscsih_AddSGE() */
388
Eric Moore786899b2006-07-11 17:22:22 -0600389static void
390mptscsih_issue_sep_command(MPT_ADAPTER *ioc, VirtTarget *vtarget,
391 U32 SlotStatus)
392{
393 MPT_FRAME_HDR *mf;
394 SEPRequest_t *SEPMsg;
395
Eric Moorecc78d302007-06-15 17:27:21 -0600396 if (ioc->bus_type != SAS)
397 return;
398
399 /* Not supported for hidden raid components
400 */
401 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
Eric Moore786899b2006-07-11 17:22:22 -0600402 return;
403
404 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530405 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -0700406 ioc->name,__func__));
Eric Moore786899b2006-07-11 17:22:22 -0600407 return;
408 }
409
410 SEPMsg = (SEPRequest_t *)mf;
411 SEPMsg->Function = MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
Eric Moore793955f2007-01-29 09:42:20 -0700412 SEPMsg->Bus = vtarget->channel;
413 SEPMsg->TargetID = vtarget->id;
Eric Moore786899b2006-07-11 17:22:22 -0600414 SEPMsg->Action = MPI_SEP_REQ_ACTION_WRITE_STATUS;
415 SEPMsg->SlotStatus = SlotStatus;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530416 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Eric Moore793955f2007-01-29 09:42:20 -0700417 "Sending SEP cmd=%x channel=%d id=%d\n",
418 ioc->name, SlotStatus, SEPMsg->Bus, SEPMsg->TargetID));
Eric Moore786899b2006-07-11 17:22:22 -0600419 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
420}
421
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530422#ifdef CONFIG_FUSION_LOGGING
Eric Moorec6c727a2007-01-29 09:44:54 -0700423/**
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530424 * mptscsih_info_scsiio - debug print info on reply frame
Eric Moorec6c727a2007-01-29 09:44:54 -0700425 * @ioc: Pointer to MPT_ADAPTER structure
Eric Moorec6c727a2007-01-29 09:44:54 -0700426 * @sc: original scsi cmnd pointer
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530427 * @pScsiReply: Pointer to MPT reply frame
428 *
429 * MPT_DEBUG_REPLY needs to be enabled to obtain this info
Eric Moorec6c727a2007-01-29 09:44:54 -0700430 *
431 * Refer to lsi/mpi.h.
432 **/
433static void
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530434mptscsih_info_scsiio(MPT_ADAPTER *ioc, struct scsi_cmnd *sc, SCSIIOReply_t * pScsiReply)
Eric Moorec6c727a2007-01-29 09:44:54 -0700435{
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530436 char *desc = NULL;
437 char *desc1 = NULL;
438 u16 ioc_status;
439 u8 skey, asc, ascq;
440
441 ioc_status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
Eric Moorec6c727a2007-01-29 09:44:54 -0700442
443 switch (ioc_status) {
444
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530445 case MPI_IOCSTATUS_SUCCESS:
446 desc = "success";
Eric Moorec6c727a2007-01-29 09:44:54 -0700447 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530448 case MPI_IOCSTATUS_SCSI_INVALID_BUS:
449 desc = "invalid bus";
Eric Moorec6c727a2007-01-29 09:44:54 -0700450 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530451 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID:
452 desc = "invalid target_id";
Eric Moorec6c727a2007-01-29 09:44:54 -0700453 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530454 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
455 desc = "device not there";
Eric Moorec6c727a2007-01-29 09:44:54 -0700456 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530457 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN:
458 desc = "data overrun";
Eric Moorec6c727a2007-01-29 09:44:54 -0700459 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530460 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:
461 desc = "data underrun";
Eric Moorec6c727a2007-01-29 09:44:54 -0700462 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530463 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:
464 desc = "I/O data error";
Eric Moorec6c727a2007-01-29 09:44:54 -0700465 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530466 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:
467 desc = "protocol error";
Eric Moorec6c727a2007-01-29 09:44:54 -0700468 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530469 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:
470 desc = "task terminated";
Eric Moorec6c727a2007-01-29 09:44:54 -0700471 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530472 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
473 desc = "residual mismatch";
Eric Moorec6c727a2007-01-29 09:44:54 -0700474 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530475 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
476 desc = "task management failed";
477 break;
478 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:
479 desc = "IOC terminated";
480 break;
481 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:
482 desc = "ext terminated";
483 break;
484 default:
485 desc = "";
Eric Moorec6c727a2007-01-29 09:44:54 -0700486 break;
487 }
488
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530489 switch (pScsiReply->SCSIStatus)
490 {
Eric Moorec6c727a2007-01-29 09:44:54 -0700491
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530492 case MPI_SCSI_STATUS_SUCCESS:
493 desc1 = "success";
494 break;
495 case MPI_SCSI_STATUS_CHECK_CONDITION:
496 desc1 = "check condition";
497 break;
498 case MPI_SCSI_STATUS_CONDITION_MET:
499 desc1 = "condition met";
500 break;
501 case MPI_SCSI_STATUS_BUSY:
502 desc1 = "busy";
503 break;
504 case MPI_SCSI_STATUS_INTERMEDIATE:
505 desc1 = "intermediate";
506 break;
507 case MPI_SCSI_STATUS_INTERMEDIATE_CONDMET:
508 desc1 = "intermediate condmet";
509 break;
510 case MPI_SCSI_STATUS_RESERVATION_CONFLICT:
511 desc1 = "reservation conflict";
512 break;
513 case MPI_SCSI_STATUS_COMMAND_TERMINATED:
514 desc1 = "command terminated";
515 break;
516 case MPI_SCSI_STATUS_TASK_SET_FULL:
517 desc1 = "task set full";
518 break;
519 case MPI_SCSI_STATUS_ACA_ACTIVE:
520 desc1 = "aca active";
521 break;
522 case MPI_SCSI_STATUS_FCPEXT_DEVICE_LOGGED_OUT:
523 desc1 = "fcpext device logged out";
524 break;
525 case MPI_SCSI_STATUS_FCPEXT_NO_LINK:
526 desc1 = "fcpext no link";
527 break;
528 case MPI_SCSI_STATUS_FCPEXT_UNASSIGNED:
529 desc1 = "fcpext unassigned";
530 break;
531 default:
532 desc1 = "";
533 break;
534 }
Eric Moorec6c727a2007-01-29 09:44:54 -0700535
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530536 scsi_print_command(sc);
Hannes Reinecke9cb78c12014-06-25 15:27:36 +0200537 printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %llu\n",
Kashyap, Desai2f187862009-05-29 16:52:37 +0530538 ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun);
Eric Moore29dd3602007-09-14 18:46:51 -0600539 printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, "
540 "resid = %d\n", ioc->name, scsi_bufflen(sc), sc->underflow,
541 scsi_get_resid(sc));
542 printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, "
543 "sc->result = %08X\n", ioc->name, le16_to_cpu(pScsiReply->TaskTag),
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530544 le32_to_cpu(pScsiReply->TransferCount), sc->result);
Kashyap, Desai2f187862009-05-29 16:52:37 +0530545
Eric Moore29dd3602007-09-14 18:46:51 -0600546 printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), "
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530547 "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n",
Eric Moore29dd3602007-09-14 18:46:51 -0600548 ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus,
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530549 pScsiReply->SCSIState);
550
551 if (pScsiReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
552 skey = sc->sense_buffer[2] & 0x0F;
553 asc = sc->sense_buffer[12];
554 ascq = sc->sense_buffer[13];
555
Eric Moore29dd3602007-09-14 18:46:51 -0600556 printk(MYIOC_s_DEBUG_FMT "\t[sense_key,asc,ascq]: "
557 "[0x%02x,0x%02x,0x%02x]\n", ioc->name, skey, asc, ascq);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530558 }
559
560 /*
561 * Look for + dump FCP ResponseInfo[]!
562 */
563 if (pScsiReply->SCSIState & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
564 pScsiReply->ResponseInfo)
Eric Moore29dd3602007-09-14 18:46:51 -0600565 printk(MYIOC_s_DEBUG_FMT "response_info = %08xh\n",
566 ioc->name, le32_to_cpu(pScsiReply->ResponseInfo));
Eric Moorec6c727a2007-01-29 09:44:54 -0700567}
568#endif
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
571/*
572 * mptscsih_io_done - Main SCSI IO callback routine registered to
573 * Fusion MPT (base) driver
574 * @ioc: Pointer to MPT_ADAPTER structure
575 * @mf: Pointer to original MPT request frame
576 * @r: Pointer to MPT reply frame (NULL if TurboReply)
577 *
578 * This routine is called from mpt.c::mpt_interrupt() at the completion
579 * of any SCSI IO request.
580 * This routine is registered with the Fusion MPT (base) driver at driver
581 * load/init time via the mpt_register() API call.
582 *
583 * Returns 1 indicating alloc'd request frame ptr should be freed.
584 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400585int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
587{
588 struct scsi_cmnd *sc;
589 MPT_SCSI_HOST *hd;
590 SCSIIORequest_t *pScsiReq;
591 SCSIIOReply_t *pScsiReply;
Moore, Eric2254c862006-01-17 17:06:29 -0700592 u16 req_idx, req_idx_MR;
Eric Moorea69de502007-09-14 18:48:19 -0600593 VirtDevice *vdevice;
Eric Moore786899b2006-07-11 17:22:22 -0600594 VirtTarget *vtarget;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Eric Mooree7eae9f2007-09-29 10:15:59 -0600596 hd = shost_priv(ioc->sh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
Moore, Eric2254c862006-01-17 17:06:29 -0700598 req_idx_MR = (mr != NULL) ?
599 le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
Kashyap, Desai2f187862009-05-29 16:52:37 +0530600
601 /* Special case, where already freed message frame is received from
602 * Firmware. It happens with Resetting IOC.
603 * Return immediately. Do not care
604 */
Moore, Eric2254c862006-01-17 17:06:29 -0700605 if ((req_idx != req_idx_MR) ||
Kashyap, Desai2f187862009-05-29 16:52:37 +0530606 (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf))
Moore, Eric2254c862006-01-17 17:06:29 -0700607 return 0;
Moore, Eric2254c862006-01-17 17:06:29 -0700608
Eric Mooree8206382007-09-29 10:16:53 -0600609 sc = mptscsih_getclear_scsi_lookup(ioc, req_idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 if (sc == NULL) {
611 MPIHeader_t *hdr = (MPIHeader_t *)mf;
612
613 /* Remark: writeSDP1 will use the ScsiDoneCtx
614 * If a SCSI I/O cmd, device disabled by OS and
615 * completion done. Cannot touch sc struct. Just free mem.
616 */
617 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST)
618 printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n",
619 ioc->name);
620
621 mptscsih_freeChainBuffers(ioc, req_idx);
622 return 1;
623 }
624
Eric Moore3dc0b032006-07-11 17:32:33 -0600625 if ((unsigned char *)mf != sc->host_scribble) {
626 mptscsih_freeChainBuffers(ioc, req_idx);
627 return 1;
628 }
629
Kashyap, Desaifea98402009-09-02 11:45:53 +0530630 if (ioc->bus_type == SAS) {
631 VirtDevice *vdevice = sc->device->hostdata;
632
633 if (!vdevice || !vdevice->vtarget ||
634 vdevice->vtarget->deleted) {
635 sc->result = DID_NO_CONNECT << 16;
636 goto out;
637 }
638 }
639
Eric Moore3dc0b032006-07-11 17:32:33 -0600640 sc->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 sc->result = DID_OK << 16; /* Set default reply as OK */
642 pScsiReq = (SCSIIORequest_t *) mf;
643 pScsiReply = (SCSIIOReply_t *) mr;
644
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200645 if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530646 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200647 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
648 ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
649 }else{
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530650 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200651 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n",
652 ioc->name, mf, mr, sc, req_idx));
653 }
654
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 if (pScsiReply == NULL) {
656 /* special context reply handling */
657 ;
658 } else {
659 u32 xfer_cnt;
660 u16 status;
661 u8 scsi_state, scsi_status;
Eric Moorec6c727a2007-01-29 09:44:54 -0700662 u32 log_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
664 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
Kashyap, Desaic9de7dc2010-07-26 18:56:21 +0530665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 scsi_state = pScsiReply->SCSIState;
667 scsi_status = pScsiReply->SCSIStatus;
668 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900669 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
Eric Moorec6c727a2007-01-29 09:44:54 -0700670 log_info = le32_to_cpu(pScsiReply->IOCLogInfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600672 /*
673 * if we get a data underrun indication, yet no data was
674 * transferred and the SCSI status indicates that the
675 * command was never started, change the data underrun
676 * to success
677 */
678 if (status == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
679 (scsi_status == MPI_SCSI_STATUS_BUSY ||
680 scsi_status == MPI_SCSI_STATUS_RESERVATION_CONFLICT ||
681 scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)) {
682 status = MPI_IOCSTATUS_SUCCESS;
683 }
684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400686 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
687
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 /*
689 * Look for + dump FCP ResponseInfo[]!
690 */
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600691 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
692 pScsiReply->ResponseInfo) {
Hannes Reinecke9cb78c12014-06-25 15:27:36 +0200693 printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%llu] "
Eric Moore29dd3602007-09-14 18:46:51 -0600694 "FCP_ResponseInfo=%08xh\n", ioc->name,
Eric Moorec6c727a2007-01-29 09:44:54 -0700695 sc->device->host->host_no, sc->device->channel,
696 sc->device->id, sc->device->lun,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 le32_to_cpu(pScsiReply->ResponseInfo));
698 }
699
700 switch(status) {
701 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
Kashyap, Desaid23321b2009-08-05 12:51:25 +0530702 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 /* CHECKME!
704 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
705 * But not: DID_BUS_BUSY lest one risk
706 * killing interrupt handler:-(
707 */
708 sc->result = SAM_STAT_BUSY;
709 break;
710
711 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
712 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
713 sc->result = DID_BAD_TARGET << 16;
714 break;
715
716 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
717 /* Spoof to SCSI Selection Timeout! */
Moore, Eric65207fe2006-04-21 16:14:35 -0600718 if (ioc->bus_type != FC)
719 sc->result = DID_NO_CONNECT << 16;
720 /* else fibre, just stall until rescan event */
721 else
722 sc->result = DID_REQUEUE << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
725 hd->sel_timeout[pScsiReq->TargetID]++;
Eric Moore786899b2006-07-11 17:22:22 -0600726
Eric Moorea69de502007-09-14 18:48:19 -0600727 vdevice = sc->device->hostdata;
728 if (!vdevice)
Eric Moore786899b2006-07-11 17:22:22 -0600729 break;
Eric Moorea69de502007-09-14 18:48:19 -0600730 vtarget = vdevice->vtarget;
Eric Moore786899b2006-07-11 17:22:22 -0600731 if (vtarget->tflags & MPT_TARGET_FLAGS_LED_ON) {
732 mptscsih_issue_sep_command(ioc, vtarget,
733 MPI_SEP_REQ_SLOTSTATUS_UNCONFIGURED);
734 vtarget->tflags &= ~MPT_TARGET_FLAGS_LED_ON;
735 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 break;
737
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
Eric Moorebf451522006-07-11 17:25:35 -0600739 if ( ioc->bus_type == SAS ) {
Kashyap, Desaic9de7dc2010-07-26 18:56:21 +0530740 u16 ioc_status =
741 le16_to_cpu(pScsiReply->IOCStatus);
742 if ((ioc_status &
743 MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)
744 &&
745 ((log_info & SAS_LOGINFO_MASK) ==
746 SAS_LOGINFO_NEXUS_LOSS)) {
747 VirtDevice *vdevice =
748 sc->device->hostdata;
749
750 /* flag the device as being in
751 * device removal delay so we can
752 * notify the midlayer to hold off
753 * on timeout eh */
754 if (vdevice && vdevice->
755 vtarget &&
756 vdevice->vtarget->
757 raidVolume)
758 printk(KERN_INFO
759 "Skipping Raid Volume"
760 "for inDMD\n");
761 else if (vdevice &&
762 vdevice->vtarget)
763 vdevice->vtarget->
764 inDMD = 1;
765
766 sc->result =
767 (DID_TRANSPORT_DISRUPTED
768 << 16);
769 break;
Eric Moorebf451522006-07-11 17:25:35 -0600770 }
Eric Moore86dd4242007-01-04 20:44:01 -0700771 } else if (ioc->bus_type == FC) {
772 /*
773 * The FC IOC may kill a request for variety of
774 * reasons, some of which may be recovered by a
775 * retry, some which are unlikely to be
776 * recovered. Return DID_ERROR instead of
777 * DID_RESET to permit retry of the command,
778 * just not an infinite number of them
779 */
780 sc->result = DID_ERROR << 16;
781 break;
Eric Moorebf451522006-07-11 17:25:35 -0600782 }
783
784 /*
785 * Allow non-SAS & non-NEXUS_LOSS to drop into below code
786 */
Gustavo A. R. Silvadf561f662020-08-23 17:36:59 -0500787 fallthrough;
Eric Moorebf451522006-07-11 17:25:35 -0600788
789 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 /* Linux handles an unsolicited DID_RESET better
791 * than an unsolicited DID_ABORT.
792 */
793 sc->result = DID_RESET << 16;
Alan Cox3012d602012-12-18 14:21:30 -0800794 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Kashyap, Desai2f187862009-05-29 16:52:37 +0530796 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
797 if (ioc->bus_type == FC)
798 sc->result = DID_ERROR << 16;
799 else
800 sc->result = DID_RESET << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 break;
802
803 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900804 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600805 if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
806 sc->result=DID_SOFT_ERROR << 16;
807 else /* Sufficient data transfer occurred */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 sc->result = (DID_OK << 16) | scsi_status;
Eric Moore29dd3602007-09-14 18:46:51 -0600809 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Eric Moorec6c727a2007-01-29 09:44:54 -0700810 "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
Eric Moore29dd3602007-09-14 18:46:51 -0600811 ioc->name, sc->result, sc->device->channel, sc->device->id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 break;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
815 /*
816 * Do upfront check for valid SenseData and give it
817 * precedence!
818 */
819 sc->result = (DID_OK << 16) | scsi_status;
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530820 if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
821
822 /*
823 * For an Errata on LSI53C1030
824 * When the length of request data
825 * and transfer data are different
826 * with result of command (READ or VERIFY),
827 * DID_SOFT_ERROR is set.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 */
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530829 if (ioc->bus_type == SPI) {
Kashyap, Desaie466e1c2011-07-20 21:28:03 +0530830 if ((pScsiReq->CDB[0] == READ_6 && ((pScsiReq->CDB[1] & 0x02) == 0)) ||
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530831 pScsiReq->CDB[0] == READ_10 ||
832 pScsiReq->CDB[0] == READ_12 ||
nagalakshmi.nandigama@lsi.com513382c2011-09-19 10:27:20 +0530833 (pScsiReq->CDB[0] == READ_16 &&
834 ((pScsiReq->CDB[1] & 0x02) == 0)) ||
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530835 pScsiReq->CDB[0] == VERIFY ||
836 pScsiReq->CDB[0] == VERIFY_16) {
837 if (scsi_bufflen(sc) !=
838 xfer_cnt) {
839 sc->result =
840 DID_SOFT_ERROR << 16;
841 printk(KERN_WARNING "Errata"
842 "on LSI53C1030 occurred."
843 "sc->req_bufflen=0x%02x,"
844 "xfer_cnt=0x%02x\n",
845 scsi_bufflen(sc),
846 xfer_cnt);
847 }
848 }
849 }
850
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 if (xfer_cnt < sc->underflow) {
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600852 if (scsi_status == SAM_STAT_BUSY)
853 sc->result = SAM_STAT_BUSY;
854 else
855 sc->result = DID_SOFT_ERROR << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 }
857 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
858 /* What to do?
859 */
860 sc->result = DID_SOFT_ERROR << 16;
861 }
862 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
863 /* Not real sure here either... */
864 sc->result = DID_RESET << 16;
865 }
866 }
867
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530868
Eric Moore29dd3602007-09-14 18:46:51 -0600869 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
870 " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
871 ioc->name, sc->underflow));
872 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
873 " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530874
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 /* Report Queue Full
876 */
877 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
878 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 break;
881
Moore, Eric7e551472006-01-16 18:53:21 -0700882 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900883 scsi_set_resid(sc, 0);
Gustavo A. R. Silvadf561f662020-08-23 17:36:59 -0500884 fallthrough;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
886 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
Eric Mooread8c31b2007-03-19 10:31:51 -0600887 sc->result = (DID_OK << 16) | scsi_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 if (scsi_state == 0) {
889 ;
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530890 } else if (scsi_state &
891 MPI_SCSI_STATE_AUTOSENSE_VALID) {
892
893 /*
894 * For potential trouble on LSI53C1030.
895 * (date:2007.xx.)
896 * It is checked whether the length of
897 * request data is equal to
898 * the length of transfer and residual.
899 * MEDIUM_ERROR is set by incorrect data.
900 */
901 if ((ioc->bus_type == SPI) &&
902 (sc->sense_buffer[2] & 0x20)) {
903 u32 difftransfer;
904 difftransfer =
905 sc->sense_buffer[3] << 24 |
906 sc->sense_buffer[4] << 16 |
907 sc->sense_buffer[5] << 8 |
908 sc->sense_buffer[6];
909 if (((sc->sense_buffer[3] & 0x80) ==
910 0x80) && (scsi_bufflen(sc)
911 != xfer_cnt)) {
912 sc->sense_buffer[2] =
913 MEDIUM_ERROR;
914 sc->sense_buffer[12] = 0xff;
915 sc->sense_buffer[13] = 0xff;
916 printk(KERN_WARNING"Errata"
917 "on LSI53C1030 occurred."
918 "sc->req_bufflen=0x%02x,"
919 "xfer_cnt=0x%02x\n" ,
920 scsi_bufflen(sc),
921 xfer_cnt);
922 }
923 if (((sc->sense_buffer[3] & 0x80)
924 != 0x80) &&
925 (scsi_bufflen(sc) !=
926 xfer_cnt + difftransfer)) {
927 sc->sense_buffer[2] =
928 MEDIUM_ERROR;
929 sc->sense_buffer[12] = 0xff;
930 sc->sense_buffer[13] = 0xff;
931 printk(KERN_WARNING
932 "Errata on LSI53C1030 occurred"
933 "sc->req_bufflen=0x%02x,"
934 " xfer_cnt=0x%02x,"
935 "difftransfer=0x%02x\n",
936 scsi_bufflen(sc),
937 xfer_cnt,
938 difftransfer);
939 }
940 }
941
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 /*
943 * If running against circa 200003dd 909 MPT f/w,
944 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
945 * (QUEUE_FULL) returned from device! --> get 0x0000?128
946 * and with SenseBytes set to 0.
947 */
948 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
949 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
950
951 }
952 else if (scsi_state &
953 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
954 ) {
955 /*
956 * What to do?
957 */
958 sc->result = DID_SOFT_ERROR << 16;
959 }
960 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
961 /* Not real sure here either... */
962 sc->result = DID_RESET << 16;
963 }
964 else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) {
965 /* Device Inq. data indicates that it supports
966 * QTags, but rejects QTag messages.
967 * This command completed OK.
968 *
969 * Not real sure here either so do nothing... */
970 }
971
972 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
973 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
974
975 /* Add handling of:
976 * Reservation Conflict, Busy,
977 * Command Terminated, CHECK
978 */
979 break;
980
981 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
982 sc->result = DID_SOFT_ERROR << 16;
983 break;
984
985 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
986 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
987 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
988 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
990 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
992 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
993 default:
994 /*
995 * What to do?
996 */
997 sc->result = DID_SOFT_ERROR << 16;
998 break;
999
1000 } /* switch(status) */
1001
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301002#ifdef CONFIG_FUSION_LOGGING
1003 if (sc->result && (ioc->debug_level & MPT_DEBUG_REPLY))
1004 mptscsih_info_scsiio(ioc, sc, pScsiReply);
Eric Moorec6c727a2007-01-29 09:44:54 -07001005#endif
1006
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 } /* end of address reply case */
Kashyap, Desaifea98402009-09-02 11:45:53 +05301008out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 /* Unmap the DMA buffers, if any. */
FUJITA Tomonori1928d732007-05-26 00:37:15 +09001010 scsi_dma_unmap(sc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
Bart Van Assche1ae6d162021-10-07 13:28:01 -07001012 scsi_done(sc); /* Issue the command callback */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
1014 /* Free Chain buffers */
1015 mptscsih_freeChainBuffers(ioc, req_idx);
1016 return 1;
1017}
1018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019/*
1020 * mptscsih_flush_running_cmds - For each command found, search
1021 * Scsi_Host instance taskQ and reply to OS.
1022 * Called only if recovering from a FW reload.
1023 * @hd: Pointer to a SCSI HOST structure
1024 *
1025 * Returns: None.
1026 *
1027 * Must be called while new I/Os are being queued.
1028 */
kashyap.desai@lsi.come62cca12011-08-04 16:42:15 +05301029void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
1031{
1032 MPT_ADAPTER *ioc = hd->ioc;
Eric Mooree8206382007-09-29 10:16:53 -06001033 struct scsi_cmnd *sc;
1034 SCSIIORequest_t *mf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 int ii;
Eric Mooree8206382007-09-29 10:16:53 -06001036 int channel, id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
Eric Mooree8206382007-09-29 10:16:53 -06001038 for (ii= 0; ii < ioc->req_depth; ii++) {
1039 sc = mptscsih_getclear_scsi_lookup(ioc, ii);
1040 if (!sc)
1041 continue;
1042 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1043 if (!mf)
1044 continue;
1045 channel = mf->Bus;
1046 id = mf->TargetID;
1047 mptscsih_freeChainBuffers(ioc, ii);
1048 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
1049 if ((unsigned char *)mf != sc->host_scribble)
1050 continue;
1051 scsi_dma_unmap(sc);
1052 sc->result = DID_RESET << 16;
1053 sc->host_scribble = NULL;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301054 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
1055 "completing cmds: fw_channel %d, fw_id %d, sc=%p, mf = %p, "
1056 "idx=%x\n", ioc->name, channel, id, sc, mf, ii));
Bart Van Assche1ae6d162021-10-07 13:28:01 -07001057 scsi_done(sc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059}
kashyap.desai@lsi.come62cca12011-08-04 16:42:15 +05301060EXPORT_SYMBOL(mptscsih_flush_running_cmds);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
1062/*
1063 * mptscsih_search_running_cmds - Delete any commands associated
1064 * with the specified target and lun. Function called only
1065 * when a lun is disable by mid-layer.
1066 * Do NOT access the referenced scsi_cmnd structure or
1067 * members. Will cause either a paging or NULL ptr error.
Michael Reed05e8ec12006-01-13 14:31:54 -06001068 * (BUT, BUT, BUT, the code does reference it! - mdr)
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07001069 * @hd: Pointer to a SCSI HOST structure
1070 * @vdevice: per device private data
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 *
1072 * Returns: None.
1073 *
1074 * Called from slave_destroy.
1075 */
1076static void
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07001077mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078{
1079 SCSIIORequest_t *mf = NULL;
1080 int ii;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001081 struct scsi_cmnd *sc;
Eric Moore793955f2007-01-29 09:42:20 -07001082 struct scsi_lun lun;
Eric Mooree80b0022007-09-14 18:49:03 -06001083 MPT_ADAPTER *ioc = hd->ioc;
Eric Mooree8206382007-09-29 10:16:53 -06001084 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
Eric Mooree8206382007-09-29 10:16:53 -06001086 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1087 for (ii = 0; ii < ioc->req_depth; ii++) {
1088 if ((sc = ioc->ScsiLookup[ii]) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
Eric Mooree80b0022007-09-14 18:49:03 -06001090 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
Eric Moore3dc0b032006-07-11 17:32:33 -06001091 if (mf == NULL)
1092 continue;
Eric Moorecc78d302007-06-15 17:27:21 -06001093 /* If the device is a hidden raid component, then its
1094 * expected that the mf->function will be RAID_SCSI_IO
1095 */
1096 if (vdevice->vtarget->tflags &
1097 MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function !=
1098 MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
1099 continue;
1100
Eric Moore793955f2007-01-29 09:42:20 -07001101 int_to_scsilun(vdevice->lun, &lun);
1102 if ((mf->Bus != vdevice->vtarget->channel) ||
1103 (mf->TargetID != vdevice->vtarget->id) ||
1104 memcmp(lun.scsi_lun, mf->LUN, 8))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 continue;
1106
Eric Moore3dc0b032006-07-11 17:32:33 -06001107 if ((unsigned char *)mf != sc->host_scribble)
1108 continue;
Eric Mooree8206382007-09-29 10:16:53 -06001109 ioc->ScsiLookup[ii] = NULL;
1110 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1111 mptscsih_freeChainBuffers(ioc, ii);
1112 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
FUJITA Tomonori1928d732007-05-26 00:37:15 +09001113 scsi_dma_unmap(sc);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001114 sc->host_scribble = NULL;
1115 sc->result = DID_NO_CONNECT << 16;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301116 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device,
1117 MYIOC_s_FMT "completing cmds: fw_channel %d, "
1118 "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name,
1119 vdevice->vtarget->channel, vdevice->vtarget->id,
1120 sc, mf, ii));
Bart Van Assche1ae6d162021-10-07 13:28:01 -07001121 scsi_done(sc);
Eric Mooree8206382007-09-29 10:16:53 -06001122 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 }
1124 }
Eric Mooree8206382007-09-29 10:16:53 -06001125 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 return;
1127}
1128
1129/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
1131/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1132/*
1133 * mptscsih_report_queue_full - Report QUEUE_FULL status returned
1134 * from a SCSI target device.
1135 * @sc: Pointer to scsi_cmnd structure
1136 * @pScsiReply: Pointer to SCSIIOReply_t
1137 * @pScsiReq: Pointer to original SCSI request
1138 *
1139 * This routine periodically reports QUEUE_FULL status returned from a
1140 * SCSI target device. It reports this to the console via kernel
1141 * printk() API call, not more than once every 10 seconds.
1142 */
1143static void
1144mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
1145{
1146 long time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 MPT_SCSI_HOST *hd;
Eric Mooree80b0022007-09-14 18:49:03 -06001148 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001150 if (sc->device == NULL)
1151 return;
1152 if (sc->device->host == NULL)
1153 return;
Eric Mooree7eae9f2007-09-29 10:15:59 -06001154 if ((hd = shost_priv(sc->device->host)) == NULL)
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001155 return;
Eric Mooree80b0022007-09-14 18:49:03 -06001156 ioc = hd->ioc;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001157 if (time - hd->last_queue_full > 10 * HZ) {
Hannes Reinecke9cb78c12014-06-25 15:27:36 +02001158 dprintk(ioc, printk(MYIOC_s_WARN_FMT "Device (%d:%d:%llu) reported QUEUE_FULL!\n",
Eric Mooree80b0022007-09-14 18:49:03 -06001159 ioc->name, 0, sc->device->id, sc->device->lun));
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001160 hd->last_queue_full = time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162}
1163
1164/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1165/*
1166 * mptscsih_remove - Removed scsi devices
1167 * @pdev: Pointer to pci_dev structure
1168 *
1169 *
1170 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001171void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172mptscsih_remove(struct pci_dev *pdev)
1173{
1174 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1175 struct Scsi_Host *host = ioc->sh;
1176 MPT_SCSI_HOST *hd;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001177 int sz1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
Helge Deller2f4843b2020-10-22 11:00:05 +02001179 if (host == NULL)
1180 hd = NULL;
1181 else
1182 hd = shost_priv(host);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001183
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001184 mptscsih_shutdown(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001186 sz1=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
Eric Mooree8206382007-09-29 10:16:53 -06001188 if (ioc->ScsiLookup != NULL) {
Eric Mooree80b0022007-09-14 18:49:03 -06001189 sz1 = ioc->req_depth * sizeof(void *);
Eric Mooree8206382007-09-29 10:16:53 -06001190 kfree(ioc->ScsiLookup);
1191 ioc->ScsiLookup = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 }
1193
Eric Mooree80b0022007-09-14 18:49:03 -06001194 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001195 "Free'd ScsiLookup (%d) memory\n",
Eric Mooree80b0022007-09-14 18:49:03 -06001196 ioc->name, sz1));
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001197
Helge Deller2f4843b2020-10-22 11:00:05 +02001198 if (hd)
1199 kfree(hd->info_kbuf);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001200
1201 /* NULL the Scsi_Host pointer
1202 */
Eric Mooree80b0022007-09-14 18:49:03 -06001203 ioc->sh = NULL;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001204
Helge Deller2f4843b2020-10-22 11:00:05 +02001205 if (host)
1206 scsi_host_put(host);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001207 mpt_detach(pdev);
Christoph Hellwigc6678e02005-08-18 16:24:53 +02001208
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209}
1210
1211/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1212/*
1213 * mptscsih_shutdown - reboot notifier
1214 *
1215 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001216void
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001217mptscsih_shutdown(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219}
1220
1221#ifdef CONFIG_PM
1222/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1223/*
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001224 * mptscsih_suspend - Fusion MPT scsi driver suspend routine.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 *
1226 *
1227 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001228int
Pavel Machek8d189f72005-04-16 15:25:28 -07001229mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
Prakash, Sathya4d4109d2008-03-07 16:19:50 +05301231 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1232
1233 scsi_block_requests(ioc->sh);
1234 flush_scheduled_work();
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001235 mptscsih_shutdown(pdev);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001236 return mpt_suspend(pdev,state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237}
1238
1239/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1240/*
1241 * mptscsih_resume - Fusion MPT scsi driver resume routine.
1242 *
1243 *
1244 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001245int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246mptscsih_resume(struct pci_dev *pdev)
1247{
Prakash, Sathya4d4109d2008-03-07 16:19:50 +05301248 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1249 int rc;
1250
1251 rc = mpt_resume(pdev);
1252 scsi_unblock_requests(ioc->sh);
1253 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254}
1255
1256#endif
1257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1259/**
1260 * mptscsih_info - Return information about MPT adapter
1261 * @SChost: Pointer to Scsi_Host structure
1262 *
1263 * (linux scsi_host_template.info routine)
1264 *
1265 * Returns pointer to buffer where information was written.
1266 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001267const char *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268mptscsih_info(struct Scsi_Host *SChost)
1269{
1270 MPT_SCSI_HOST *h;
1271 int size = 0;
1272
Eric Mooree7eae9f2007-09-29 10:15:59 -06001273 h = shost_priv(SChost);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001274
Joe Lawrence9f213162014-06-25 17:06:54 -04001275 if (h->info_kbuf == NULL)
1276 if ((h->info_kbuf = kmalloc(0x1000 /* 4Kb */, GFP_KERNEL)) == NULL)
1277 return h->info_kbuf;
1278 h->info_kbuf[0] = '\0';
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001279
Joe Lawrence9f213162014-06-25 17:06:54 -04001280 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0);
1281 h->info_kbuf[size-1] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001283 return h->info_kbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284}
1285
Al Virocac19702013-03-31 01:42:38 -04001286int mptscsih_show_info(struct seq_file *m, struct Scsi_Host *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287{
Eric Mooree7eae9f2007-09-29 10:15:59 -06001288 MPT_SCSI_HOST *hd = shost_priv(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 MPT_ADAPTER *ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
Al Virocac19702013-03-31 01:42:38 -04001291 seq_printf(m, "%s: %s, ", ioc->name, ioc->prod_name);
1292 seq_printf(m, "%s%08xh, ", MPT_FW_REV_MAGIC_ID_STRING, ioc->facts.FWVersion.Word);
1293 seq_printf(m, "Ports=%d, ", ioc->facts.NumberOfPorts);
1294 seq_printf(m, "MaxQ=%d\n", ioc->req_depth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
Al Virocac19702013-03-31 01:42:38 -04001296 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297}
1298
1299/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1300#define ADD_INDEX_LOG(req_ent) do { } while(0)
1301
1302/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1303/**
1304 * mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine.
1305 * @SCpnt: Pointer to scsi_cmnd structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 *
1307 * (linux scsi_host_template.queuecommand routine)
1308 * This is the primary SCSI IO start routine. Create a MPI SCSIIORequest
1309 * from a linux scsi_cmnd request and send it to the IOC.
1310 *
1311 * Returns 0. (rtn value discarded by linux scsi mid-layer)
1312 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001313int
Matthew Wilcoxa48ac9e2014-03-27 16:40:36 -04001314mptscsih_qcmd(struct scsi_cmnd *SCpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315{
1316 MPT_SCSI_HOST *hd;
1317 MPT_FRAME_HDR *mf;
1318 SCSIIORequest_t *pScsiReq;
Eric Moorea69de502007-09-14 18:48:19 -06001319 VirtDevice *vdevice = SCpnt->device->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 u32 datalen;
1321 u32 scsictl;
1322 u32 scsidir;
1323 u32 cmd_len;
1324 int my_idx;
1325 int ii;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301326 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
Eric Mooree7eae9f2007-09-29 10:15:59 -06001328 hd = shost_priv(SCpnt->device->host);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301329 ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
Matthew Wilcoxa48ac9e2014-03-27 16:40:36 -04001331 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p\n",
1332 ioc->name, SCpnt));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
Kashyap, Desai56cee8d2011-04-26 12:09:15 +05301334 if (ioc->taskmgmt_quiesce_io)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 return SCSI_MLQUEUE_HOST_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
1337 /*
1338 * Put together a MPT SCSI request...
1339 */
Eric Mooree80b0022007-09-14 18:49:03 -06001340 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301341 dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
1342 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 return SCSI_MLQUEUE_HOST_BUSY;
1344 }
1345
1346 pScsiReq = (SCSIIORequest_t *) mf;
1347
1348 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1349
1350 ADD_INDEX_LOG(my_idx);
1351
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001352 /* TUR's being issued with scsictl=0x02000000 (DATA_IN)!
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 * Seems we may receive a buffer (datalen>0) even when there
1354 * will be no data transfer! GRRRRR...
1355 */
1356 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
FUJITA Tomonori1928d732007-05-26 00:37:15 +09001357 datalen = scsi_bufflen(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 scsidir = MPI_SCSIIO_CONTROL_READ; /* DATA IN (host<--ioc<--dev) */
1359 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
FUJITA Tomonori1928d732007-05-26 00:37:15 +09001360 datalen = scsi_bufflen(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 scsidir = MPI_SCSIIO_CONTROL_WRITE; /* DATA OUT (host-->ioc-->dev) */
1362 } else {
1363 datalen = 0;
1364 scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER;
1365 }
1366
1367 /* Default to untagged. Once a target structure has been allocated,
1368 * use the Inquiry data to determine if device supports tagged.
1369 */
Christoph Hellwig4e6f7672016-10-13 10:46:41 +02001370 if ((vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES) &&
1371 SCpnt->device->tagged_supported)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
Christoph Hellwig4e6f7672016-10-13 10:46:41 +02001373 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
Kashyap, Desai65f89c22009-12-16 19:01:13 +05301375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 /* Use the above information to set up the message frame
1378 */
Eric Moorea69de502007-09-14 18:48:19 -06001379 pScsiReq->TargetID = (u8) vdevice->vtarget->id;
1380 pScsiReq->Bus = vdevice->vtarget->channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 pScsiReq->ChainOffset = 0;
Eric Moorea69de502007-09-14 18:48:19 -06001382 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
James Bottomleyc92f2222006-03-01 09:02:49 -06001383 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
1384 else
1385 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 pScsiReq->CDBLength = SCpnt->cmd_len;
1387 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1388 pScsiReq->Reserved = 0;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301389 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
Eric Moore793955f2007-01-29 09:42:20 -07001390 int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 pScsiReq->Control = cpu_to_le32(scsictl);
1392
1393 /*
1394 * Write SCSI CDB into the message
1395 */
1396 cmd_len = SCpnt->cmd_len;
1397 for (ii=0; ii < cmd_len; ii++)
1398 pScsiReq->CDB[ii] = SCpnt->cmnd[ii];
1399
1400 for (ii=cmd_len; ii < 16; ii++)
1401 pScsiReq->CDB[ii] = 0;
1402
1403 /* DataLength */
1404 pScsiReq->DataLength = cpu_to_le32(datalen);
1405
1406 /* SenseBuffer low address */
Eric Mooree80b0022007-09-14 18:49:03 -06001407 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
1409
1410 /* Now add the SG list
1411 * Always have a SGE even if null length.
1412 */
1413 if (datalen == 0) {
1414 /* Add a NULL SGE */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301415 ioc->add_sge((char *)&pScsiReq->SGL,
1416 MPT_SGE_FLAGS_SSIMPLE_READ | 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 (dma_addr_t) -1);
1418 } else {
1419 /* Add a 32 or 64 bit SGE */
Eric Mooree80b0022007-09-14 18:49:03 -06001420 if (mptscsih_AddSGE(ioc, SCpnt, pScsiReq, my_idx) != SUCCESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 goto fail;
1422 }
1423
Eric Moore3dc0b032006-07-11 17:32:33 -06001424 SCpnt->host_scribble = (unsigned char *)mf;
Eric Mooree8206382007-09-29 10:16:53 -06001425 mptscsih_set_scsi_lookup(ioc, my_idx, SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
Eric Mooree80b0022007-09-14 18:49:03 -06001427 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301428 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n",
1429 ioc->name, SCpnt, mf, my_idx));
Eric Moore29dd3602007-09-14 18:46:51 -06001430 DBG_DUMP_REQUEST_FRAME(ioc, (u32 *)mf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 return 0;
1432
1433 fail:
Eric Mooree80b0022007-09-14 18:49:03 -06001434 mptscsih_freeChainBuffers(ioc, my_idx);
1435 mpt_free_msg_frame(ioc, mf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 return SCSI_MLQUEUE_HOST_BUSY;
1437}
1438
1439/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1440/*
1441 * mptscsih_freeChainBuffers - Function to free chain buffers associated
1442 * with a SCSI IO request
1443 * @hd: Pointer to the MPT_SCSI_HOST instance
1444 * @req_idx: Index of the SCSI IO request frame.
1445 *
1446 * Called if SG chain buffer allocation fails and mptscsih callbacks.
1447 * No return.
1448 */
1449static void
1450mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
1451{
1452 MPT_FRAME_HDR *chain;
1453 unsigned long flags;
1454 int chain_idx;
1455 int next;
1456
1457 /* Get the first chain index and reset
1458 * tracker state.
1459 */
1460 chain_idx = ioc->ReqToChain[req_idx];
1461 ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN;
1462
1463 while (chain_idx != MPT_HOST_NO_CHAIN) {
1464
1465 /* Save the next chain buffer index */
1466 next = ioc->ChainToChain[chain_idx];
1467
1468 /* Free this chain buffer and reset
1469 * tracker
1470 */
1471 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN;
1472
1473 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer
1474 + (chain_idx * ioc->req_sz));
1475
1476 spin_lock_irqsave(&ioc->FreeQlock, flags);
1477 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);
1478 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1479
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301480 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FreeChainBuffers (index %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 ioc->name, chain_idx));
1482
1483 /* handle next */
1484 chain_idx = next;
1485 }
1486 return;
1487}
1488
1489/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1490/*
1491 * Reset Handling
1492 */
1493
1494/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Eric Moorecd2c6192007-01-29 09:47:47 -07001495/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 * mptscsih_IssueTaskMgmt - Generic send Task Management function.
1497 * @hd: Pointer to MPT_SCSI_HOST structure
1498 * @type: Task Management type
Randy Dunlap1544d672007-02-20 11:17:03 -08001499 * @channel: channel number for task management
Eric Moore793955f2007-01-29 09:42:20 -07001500 * @id: Logical Target ID for reset (if appropriate)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 * @lun: Logical Unit for reset (if appropriate)
1502 * @ctx2abort: Context for the task to be aborted (if appropriate)
Randy Dunlap1544d672007-02-20 11:17:03 -08001503 * @timeout: timeout for task management control
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 *
1505 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
1506 * or a non-interrupt thread. In the former, must not call schedule().
1507 *
1508 * Not all fields are meaningfull for all task types.
1509 *
Eric Moorecd2c6192007-01-29 09:47:47 -07001510 * Returns 0 for SUCCESS, or FAILED.
1511 *
1512 **/
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301513int
Hannes Reinecke9cb78c12014-06-25 15:27:36 +02001514mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, u64 lun,
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301515 int ctx2abort, ulong timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516{
1517 MPT_FRAME_HDR *mf;
1518 SCSITaskMgmt_t *pScsiTm;
1519 int ii;
1520 int retval;
Eric Mooree80b0022007-09-14 18:49:03 -06001521 MPT_ADAPTER *ioc = hd->ioc;
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301522 u8 issue_hard_reset;
1523 u32 ioc_raw_state;
1524 unsigned long time_count;
1525
1526 issue_hard_reset = 0;
1527 ioc_raw_state = mpt_GetIocState(ioc, 0);
1528
1529 if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
1530 printk(MYIOC_s_WARN_FMT
1531 "TaskMgmt type=%x: IOC Not operational (0x%x)!\n",
1532 ioc->name, type, ioc_raw_state);
1533 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
1534 ioc->name, __func__);
1535 if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
1536 printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset "
1537 "FAILED!!\n", ioc->name);
1538 return 0;
1539 }
1540
kashyap.desai@lsi.com98cbe3712011-08-05 11:04:37 +05301541 /* DOORBELL ACTIVE check is not required if
1542 * MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q is supported.
1543 */
1544
1545 if (!((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q)
1546 && (ioc->facts.MsgVersion >= MPI_VERSION_01_05)) &&
1547 (ioc_raw_state & MPI_DOORBELL_ACTIVE)) {
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301548 printk(MYIOC_s_WARN_FMT
1549 "TaskMgmt type=%x: ioc_state: "
1550 "DOORBELL_ACTIVE (0x%x)!\n",
1551 ioc->name, type, ioc_raw_state);
1552 return FAILED;
1553 }
1554
1555 mutex_lock(&ioc->taskmgmt_cmds.mutex);
1556 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
1557 mf = NULL;
1558 retval = FAILED;
1559 goto out;
1560 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
1562 /* Return Fail to calling function if no message frames available.
1563 */
Eric Mooree80b0022007-09-14 18:49:03 -06001564 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301565 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1566 "TaskMgmt no msg frames!!\n", ioc->name));
1567 retval = FAILED;
1568 mpt_clear_taskmgmt_in_progress_flag(ioc);
1569 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 }
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301571 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
Eric Mooree80b0022007-09-14 18:49:03 -06001572 ioc->name, mf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
1574 /* Format the Request
1575 */
1576 pScsiTm = (SCSITaskMgmt_t *) mf;
Eric Moore793955f2007-01-29 09:42:20 -07001577 pScsiTm->TargetID = id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 pScsiTm->Bus = channel;
1579 pScsiTm->ChainOffset = 0;
1580 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1581
1582 pScsiTm->Reserved = 0;
1583 pScsiTm->TaskType = type;
1584 pScsiTm->Reserved1 = 0;
1585 pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
1586 ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
1587
Eric Moore793955f2007-01-29 09:42:20 -07001588 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
1590 for (ii=0; ii < 7; ii++)
1591 pScsiTm->Reserved2[ii] = 0;
1592
1593 pScsiTm->TaskMsgContext = ctx2abort;
1594
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301595 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) "
1596 "task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort,
1597 type, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301599 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301601 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1602 time_count = jiffies;
Eric Mooree80b0022007-09-14 18:49:03 -06001603 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
1604 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
1605 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
Prakash, Sathya7a195f42007-08-14 16:08:40 +05301606 else {
Eric Mooree80b0022007-09-14 18:49:03 -06001607 retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
Prakash, Sathya7a195f42007-08-14 16:08:40 +05301608 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
1609 if (retval) {
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301610 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1611 "TaskMgmt handshake FAILED!(mf=%p, rc=%d) \n",
1612 ioc->name, mf, retval));
1613 mpt_free_msg_frame(ioc, mf);
1614 mpt_clear_taskmgmt_in_progress_flag(ioc);
1615 goto out;
Prakash, Sathya7a195f42007-08-14 16:08:40 +05301616 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 }
1618
Jason Yanbef7afb2020-08-27 20:59:25 +08001619 wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301620 timeout*HZ);
1621 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
1622 retval = FAILED;
1623 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
1624 "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf));
1625 mpt_clear_taskmgmt_in_progress_flag(ioc);
1626 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
1627 goto out;
1628 issue_hard_reset = 1;
1629 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 }
1631
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301632 retval = mptscsih_taskmgmt_reply(ioc, type,
1633 (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply);
Eric Moorecd2c6192007-01-29 09:47:47 -07001634
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301635 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1636 "TaskMgmt completed (%d seconds)\n",
1637 ioc->name, jiffies_to_msecs(jiffies - time_count)/1000));
1638
1639 out:
1640
1641 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1642 if (issue_hard_reset) {
Kei Tokunaga97009a22010-06-22 19:01:51 +09001643 printk(MYIOC_s_WARN_FMT
1644 "Issuing Reset from %s!! doorbell=0x%08x\n",
1645 ioc->name, __func__, mpt_GetIocState(ioc, 0));
kashyap.desai@lsi.com98cbe3712011-08-05 11:04:37 +05301646 retval = (ioc->bus_type == SAS) ?
1647 mpt_HardResetHandler(ioc, CAN_SLEEP) :
1648 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301649 mpt_free_msg_frame(ioc, mf);
1650 }
1651
1652 retval = (retval == 0) ? 0 : FAILED;
1653 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 return retval;
1655}
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301656EXPORT_SYMBOL(mptscsih_IssueTaskMgmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
Christoph Hellwigd66c7a02006-01-17 13:43:14 +00001658static int
1659mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
1660{
1661 switch (ioc->bus_type) {
1662 case FC:
1663 return 40;
1664 case SAS:
Kashyap, Desai69b2e9b2010-03-18 19:23:19 +05301665 return 30;
Christoph Hellwigd66c7a02006-01-17 13:43:14 +00001666 case SPI:
1667 default:
Bernd Schubert22ab0192008-09-23 15:28:58 +02001668 return 10;
Christoph Hellwigd66c7a02006-01-17 13:43:14 +00001669 }
1670}
1671
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1673/**
1674 * mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant
1675 * @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted
1676 *
1677 * (linux scsi_host_template.eh_abort_handler routine)
1678 *
1679 * Returns SUCCESS or FAILED.
Eric Moorecd2c6192007-01-29 09:47:47 -07001680 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001681int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682mptscsih_abort(struct scsi_cmnd * SCpnt)
1683{
1684 MPT_SCSI_HOST *hd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 MPT_FRAME_HDR *mf;
1686 u32 ctx2abort;
1687 int scpnt_idx;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001688 int retval;
Eric Moore958d4a32007-06-15 17:24:14 -06001689 VirtDevice *vdevice;
Eric Moore958d4a32007-06-15 17:24:14 -06001690 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691
1692 /* If we can't locate our host adapter structure, return FAILED status.
1693 */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001694 if ((hd = shost_priv(SCpnt->device->host)) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 SCpnt->result = DID_RESET << 16;
Bart Van Assche1ae6d162021-10-07 13:28:01 -07001696 scsi_done(SCpnt);
Eric Moore29dd3602007-09-14 18:46:51 -06001697 printk(KERN_ERR MYNAM ": task abort: "
1698 "can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 return FAILED;
1700 }
1701
Eric Moore958d4a32007-06-15 17:24:14 -06001702 ioc = hd->ioc;
1703 printk(MYIOC_s_INFO_FMT "attempting task abort! (sc=%p)\n",
1704 ioc->name, SCpnt);
1705 scsi_print_command(SCpnt);
1706
1707 vdevice = SCpnt->device->hostdata;
1708 if (!vdevice || !vdevice->vtarget) {
Eric Moore29dd3602007-09-14 18:46:51 -06001709 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1710 "task abort: device has been deleted (sc=%p)\n",
1711 ioc->name, SCpnt));
Eric Moore958d4a32007-06-15 17:24:14 -06001712 SCpnt->result = DID_NO_CONNECT << 16;
Bart Van Assche1ae6d162021-10-07 13:28:01 -07001713 scsi_done(SCpnt);
Kashyap, Desai69b2e9b2010-03-18 19:23:19 +05301714 retval = SUCCESS;
Eric Moore958d4a32007-06-15 17:24:14 -06001715 goto out;
1716 }
1717
Eric Moorecc78d302007-06-15 17:27:21 -06001718 /* Task aborts are not supported for hidden raid components.
1719 */
1720 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
Eric Moore29dd3602007-09-14 18:46:51 -06001721 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1722 "task abort: hidden raid component (sc=%p)\n",
1723 ioc->name, SCpnt));
Eric Moorecc78d302007-06-15 17:27:21 -06001724 SCpnt->result = DID_RESET << 16;
1725 retval = FAILED;
1726 goto out;
1727 }
1728
Kashyap, Desai69b2e9b2010-03-18 19:23:19 +05301729 /* Task aborts are not supported for volumes.
1730 */
1731 if (vdevice->vtarget->raidVolume) {
1732 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1733 "task abort: raid volume (sc=%p)\n",
1734 ioc->name, SCpnt));
1735 SCpnt->result = DID_RESET << 16;
1736 retval = FAILED;
1737 goto out;
1738 }
1739
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 /* Find this command
1741 */
Eric Mooree8206382007-09-29 10:16:53 -06001742 if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001743 /* Cmd not found in ScsiLookup.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 * Do OS callback.
1745 */
1746 SCpnt->result = DID_RESET << 16;
Eric Moore29dd3602007-09-14 18:46:51 -06001747 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
Eric Moore958d4a32007-06-15 17:24:14 -06001748 "Command not in the active list! (sc=%p)\n", ioc->name,
1749 SCpnt));
Kashyap, Desai9858ae32010-01-25 16:20:52 +05301750 retval = SUCCESS;
Eric Moore958d4a32007-06-15 17:24:14 -06001751 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 }
1753
Kashyap, Desai2f187862009-05-29 16:52:37 +05301754 if (ioc->timeouts < -1)
1755 ioc->timeouts++;
Moore, Eric65207fe2006-04-21 16:14:35 -06001756
Kashyap, Desai2f4c7822009-01-06 15:03:37 +05301757 if (mpt_fwfault_debug)
1758 mpt_halt_firmware(ioc);
1759
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 /* Most important! Set TaskMsgContext to SCpnt's MsgContext!
1761 * (the IO to be ABORT'd)
1762 *
1763 * NOTE: Since we do not byteswap MsgContext, we do not
1764 * swap it here either. It is an opaque cookie to
1765 * the controller, so it does not matter. -DaveM
1766 */
Eric Mooree80b0022007-09-14 18:49:03 -06001767 mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301769 retval = mptscsih_IssueTaskMgmt(hd,
1770 MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1771 vdevice->vtarget->channel,
1772 vdevice->vtarget->id, vdevice->lun,
1773 ctx2abort, mptscsih_get_tm_timeout(ioc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774
Christoph Hellwigaeaeb5c2011-04-04 09:42:41 -04001775 if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx) {
Kashyap, Desai2f187862009-05-29 16:52:37 +05301776 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1777 "task abort: command still in active list! (sc=%p)\n",
1778 ioc->name, SCpnt));
Eric Moore3dc0b032006-07-11 17:32:33 -06001779 retval = FAILED;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301780 } else {
1781 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1782 "task abort: command cleared from active list! (sc=%p)\n",
1783 ioc->name, SCpnt));
1784 retval = SUCCESS;
1785 }
Eric Moore3dc0b032006-07-11 17:32:33 -06001786
Eric Moore958d4a32007-06-15 17:24:14 -06001787 out:
Christoph Hellwigaeaeb5c2011-04-04 09:42:41 -04001788 printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p)\n",
Kashyap, Desaibcfe42e2011-02-10 11:53:44 +05301789 ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), retval,
Christoph Hellwigaeaeb5c2011-04-04 09:42:41 -04001790 SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
Kashyap, Desai2f187862009-05-29 16:52:37 +05301792 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793}
1794
1795/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1796/**
1797 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant
1798 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1799 *
1800 * (linux scsi_host_template.eh_dev_reset_handler routine)
1801 *
1802 * Returns SUCCESS or FAILED.
Eric Moorecd2c6192007-01-29 09:47:47 -07001803 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001804int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1806{
1807 MPT_SCSI_HOST *hd;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001808 int retval;
Eric Moore958d4a32007-06-15 17:24:14 -06001809 VirtDevice *vdevice;
1810 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811
1812 /* If we can't locate our host adapter structure, return FAILED status.
1813 */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001814 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
Eric Moore29dd3602007-09-14 18:46:51 -06001815 printk(KERN_ERR MYNAM ": target reset: "
1816 "Can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 return FAILED;
1818 }
1819
Eric Moore958d4a32007-06-15 17:24:14 -06001820 ioc = hd->ioc;
1821 printk(MYIOC_s_INFO_FMT "attempting target reset! (sc=%p)\n",
1822 ioc->name, SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001823 scsi_print_command(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824
Eric Moore958d4a32007-06-15 17:24:14 -06001825 vdevice = SCpnt->device->hostdata;
1826 if (!vdevice || !vdevice->vtarget) {
Kashyap, Desaibcfe42e2011-02-10 11:53:44 +05301827 retval = 0;
Eric Moore958d4a32007-06-15 17:24:14 -06001828 goto out;
1829 }
1830
Eric Moorecc78d302007-06-15 17:27:21 -06001831 /* Target reset to hidden raid component is not supported
1832 */
1833 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1834 retval = FAILED;
1835 goto out;
1836 }
1837
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301838 retval = mptscsih_IssueTaskMgmt(hd,
1839 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1840 vdevice->vtarget->channel,
1841 vdevice->vtarget->id, 0, 0,
1842 mptscsih_get_tm_timeout(ioc));
Eric Moore958d4a32007-06-15 17:24:14 -06001843
1844 out:
1845 printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
1846 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001847
1848 if (retval == 0)
1849 return SUCCESS;
Eric Moorecd2c6192007-01-29 09:47:47 -07001850 else
1851 return FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852}
1853
Eric Moorecd2c6192007-01-29 09:47:47 -07001854
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1856/**
1857 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant
1858 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1859 *
1860 * (linux scsi_host_template.eh_bus_reset_handler routine)
1861 *
1862 * Returns SUCCESS or FAILED.
Eric Moorecd2c6192007-01-29 09:47:47 -07001863 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001864int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1866{
1867 MPT_SCSI_HOST *hd;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001868 int retval;
Eric Moorea69de502007-09-14 18:48:19 -06001869 VirtDevice *vdevice;
Eric Moore958d4a32007-06-15 17:24:14 -06001870 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
1872 /* If we can't locate our host adapter structure, return FAILED status.
1873 */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001874 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
Eric Moore29dd3602007-09-14 18:46:51 -06001875 printk(KERN_ERR MYNAM ": bus reset: "
1876 "Can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 return FAILED;
1878 }
1879
Eric Moore958d4a32007-06-15 17:24:14 -06001880 ioc = hd->ioc;
1881 printk(MYIOC_s_INFO_FMT "attempting bus reset! (sc=%p)\n",
1882 ioc->name, SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001883 scsi_print_command(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884
Kashyap, Desai2f187862009-05-29 16:52:37 +05301885 if (ioc->timeouts < -1)
1886 ioc->timeouts++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
Eric Moorea69de502007-09-14 18:48:19 -06001888 vdevice = SCpnt->device->hostdata;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301889 if (!vdevice || !vdevice->vtarget)
1890 return SUCCESS;
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301891 retval = mptscsih_IssueTaskMgmt(hd,
1892 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1893 vdevice->vtarget->channel, 0, 0, 0,
1894 mptscsih_get_tm_timeout(ioc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
Eric Moore958d4a32007-06-15 17:24:14 -06001896 printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
1897 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001898
1899 if (retval == 0)
1900 return SUCCESS;
Eric Moorecd2c6192007-01-29 09:47:47 -07001901 else
1902 return FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903}
1904
1905/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1906/**
Randy Dunlapd9489fb2006-12-06 20:38:43 -08001907 * mptscsih_host_reset - Perform a SCSI host adapter RESET (new_eh variant)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1909 *
1910 * (linux scsi_host_template.eh_host_reset_handler routine)
1911 *
1912 * Returns SUCCESS or FAILED.
1913 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001914int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1916{
1917 MPT_SCSI_HOST * hd;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301918 int status = SUCCESS;
Eric Moore958d4a32007-06-15 17:24:14 -06001919 MPT_ADAPTER *ioc;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301920 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
1922 /* If we can't locate the host to reset, then we failed. */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001923 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
Eric Moore29dd3602007-09-14 18:46:51 -06001924 printk(KERN_ERR MYNAM ": host reset: "
1925 "Can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 return FAILED;
1927 }
1928
James Bottomleya6da74c2008-12-15 14:13:27 -06001929 /* make sure we have no outstanding commands at this stage */
1930 mptscsih_flush_running_cmds(hd);
1931
Eric Moore958d4a32007-06-15 17:24:14 -06001932 ioc = hd->ioc;
1933 printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
1934 ioc->name, SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935
1936 /* If our attempts to reset the host failed, then return a failed
1937 * status. The host will be taken off line by the SCSI mid-layer.
1938 */
Colin Ian King244830a2019-02-07 12:44:07 +00001939 retval = mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
Kashyap, Desai2f187862009-05-29 16:52:37 +05301940 if (retval < 0)
1941 status = FAILED;
1942 else
1943 status = SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944
Eric Moore958d4a32007-06-15 17:24:14 -06001945 printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
1946 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Kashyap, Desai2f187862009-05-29 16:52:37 +05301948 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949}
1950
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951static int
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301952mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
1953 SCSITaskMgmtReply_t *pScsiTmReply)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954{
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301955 u16 iocstatus;
1956 u32 termination_count;
1957 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301959 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
1960 retval = FAILED;
1961 goto out;
1962 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301964 DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301966 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
1967 termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301969 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1970 "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
1971 "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
1972 "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
1973 pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
1974 le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
1975 termination_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301977 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
1978 pScsiTmReply->ResponseCode)
1979 mptscsih_taskmgmt_response_code(ioc,
1980 pScsiTmReply->ResponseCode);
1981
1982 if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
1983 retval = 0;
1984 goto out;
1985 }
1986
1987 retval = FAILED;
1988 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1989 if (termination_count == 1)
1990 retval = 0;
1991 goto out;
1992 }
1993
1994 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
1995 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
1996 retval = 0;
1997
1998 out:
1999 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000}
2001
2002/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Kashyap, Desaie7deff32009-05-29 16:46:07 +05302003void
Moore, Eric9f63bb72006-01-16 18:53:26 -07002004mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
2005{
2006 char *desc;
2007
2008 switch (response_code) {
2009 case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
2010 desc = "The task completed.";
2011 break;
2012 case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
2013 desc = "The IOC received an invalid frame status.";
2014 break;
2015 case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2016 desc = "The task type is not supported.";
2017 break;
2018 case MPI_SCSITASKMGMT_RSP_TM_FAILED:
2019 desc = "The requested task failed.";
2020 break;
2021 case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2022 desc = "The task completed successfully.";
2023 break;
2024 case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2025 desc = "The LUN request is invalid.";
2026 break;
2027 case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2028 desc = "The task is in the IOC queue and has not been sent to target.";
2029 break;
2030 default:
2031 desc = "unknown";
2032 break;
2033 }
2034 printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
2035 ioc->name, response_code, desc);
2036}
Kashyap, Desaie7deff32009-05-29 16:46:07 +05302037EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
Moore, Eric9f63bb72006-01-16 18:53:26 -07002038
2039/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040/**
2041 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2042 * @ioc: Pointer to MPT_ADAPTER structure
2043 * @mf: Pointer to SCSI task mgmt request frame
2044 * @mr: Pointer to SCSI task mgmt reply frame
2045 *
2046 * This routine is called from mptbase.c::mpt_interrupt() at the completion
2047 * of any SCSI task management request.
2048 * This routine is registered with the MPT (base) driver at driver
2049 * load/init time via the mpt_register() API call.
2050 *
2051 * Returns 1 indicating alloc'd request frame ptr should be freed.
Eric Moorecd2c6192007-01-29 09:47:47 -07002052 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002053int
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302054mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
2055 MPT_FRAME_HDR *mr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056{
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302057 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2058 "TaskMgmt completed (mf=%p, mr=%p)\n", ioc->name, mf, mr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302060 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302062 if (!mr)
Eric Moorecd2c6192007-01-29 09:47:47 -07002063 goto out;
Eric Moorecd2c6192007-01-29 09:47:47 -07002064
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302065 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2066 memcpy(ioc->taskmgmt_cmds.reply, mr,
2067 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
Eric Moorecd2c6192007-01-29 09:47:47 -07002068 out:
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302069 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
2070 mpt_clear_taskmgmt_in_progress_flag(ioc);
2071 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2072 complete(&ioc->taskmgmt_cmds.done);
Kashyap, Desaib68bf092010-06-17 14:40:56 +05302073 if (ioc->bus_type == SAS)
2074 ioc->schedule_target_reset(ioc);
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302075 return 1;
2076 }
2077 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078}
2079
2080/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2081/*
2082 * This is anyones guess quite frankly.
2083 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002084int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2086 sector_t capacity, int geom[])
2087{
2088 int heads;
2089 int sectors;
2090 sector_t cylinders;
2091 ulong dummy;
2092
2093 heads = 64;
2094 sectors = 32;
2095
2096 dummy = heads * sectors;
2097 cylinders = capacity;
2098 sector_div(cylinders,dummy);
2099
2100 /*
2101 * Handle extended translation size for logical drives
2102 * > 1Gb
2103 */
2104 if ((ulong)capacity >= 0x200000) {
2105 heads = 255;
2106 sectors = 63;
2107 dummy = heads * sectors;
2108 cylinders = capacity;
2109 sector_div(cylinders,dummy);
2110 }
2111
2112 /* return result */
2113 geom[0] = heads;
2114 geom[1] = sectors;
2115 geom[2] = cylinders;
2116
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 return 0;
2118}
2119
Moore, Ericf44e5462006-03-14 09:14:21 -07002120/* Search IOC page 3 to determine if this is hidden physical disk
2121 *
2122 */
2123int
Eric Moore793955f2007-01-29 09:42:20 -07002124mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
Moore, Ericf44e5462006-03-14 09:14:21 -07002125{
Eric Mooreb506ade2007-01-29 09:45:37 -07002126 struct inactive_raid_component_info *component_info;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302127 int i, j;
2128 RaidPhysDiskPage1_t *phys_disk;
Eric Moore793955f2007-01-29 09:42:20 -07002129 int rc = 0;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302130 int num_paths;
Moore, Ericf44e5462006-03-14 09:14:21 -07002131
Eric Moore793955f2007-01-29 09:42:20 -07002132 if (!ioc->raid_data.pIocPg3)
2133 goto out;
Moore, Ericf44e5462006-03-14 09:14:21 -07002134 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
Eric Moore793955f2007-01-29 09:42:20 -07002135 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2136 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2137 rc = 1;
2138 goto out;
2139 }
2140 }
2141
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302142 if (ioc->bus_type != SAS)
2143 goto out;
2144
2145 /*
2146 * Check if dual path
2147 */
2148 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2149 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2150 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2151 if (num_paths < 2)
2152 continue;
2153 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2154 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2155 if (!phys_disk)
2156 continue;
2157 if ((mpt_raid_phys_disk_pg1(ioc,
2158 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2159 phys_disk))) {
2160 kfree(phys_disk);
2161 continue;
2162 }
2163 for (j = 0; j < num_paths; j++) {
2164 if ((phys_disk->Path[j].Flags &
2165 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2166 continue;
2167 if ((phys_disk->Path[j].Flags &
2168 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2169 continue;
2170 if ((id == phys_disk->Path[j].PhysDiskID) &&
2171 (channel == phys_disk->Path[j].PhysDiskBus)) {
2172 rc = 1;
2173 kfree(phys_disk);
2174 goto out;
2175 }
2176 }
2177 kfree(phys_disk);
2178 }
2179
2180
Eric Mooreb506ade2007-01-29 09:45:37 -07002181 /*
2182 * Check inactive list for matching phys disks
2183 */
2184 if (list_empty(&ioc->raid_data.inactive_list))
2185 goto out;
2186
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002187 mutex_lock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002188 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2189 list) {
2190 if ((component_info->d.PhysDiskID == id) &&
2191 (component_info->d.PhysDiskBus == channel))
2192 rc = 1;
2193 }
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002194 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002195
Eric Moore793955f2007-01-29 09:42:20 -07002196 out:
2197 return rc;
Moore, Ericf44e5462006-03-14 09:14:21 -07002198}
2199EXPORT_SYMBOL(mptscsih_is_phys_disk);
2200
Eric Moore793955f2007-01-29 09:42:20 -07002201u8
2202mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
James Bottomleyc92f2222006-03-01 09:02:49 -06002203{
Eric Mooreb506ade2007-01-29 09:45:37 -07002204 struct inactive_raid_component_info *component_info;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302205 int i, j;
2206 RaidPhysDiskPage1_t *phys_disk;
Eric Moore793955f2007-01-29 09:42:20 -07002207 int rc = -ENXIO;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302208 int num_paths;
James Bottomleyc92f2222006-03-01 09:02:49 -06002209
Eric Moore793955f2007-01-29 09:42:20 -07002210 if (!ioc->raid_data.pIocPg3)
2211 goto out;
2212 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2213 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2214 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2215 rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
2216 goto out;
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002217 }
2218 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302220 if (ioc->bus_type != SAS)
2221 goto out;
2222
2223 /*
2224 * Check if dual path
2225 */
2226 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2227 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2228 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2229 if (num_paths < 2)
2230 continue;
2231 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2232 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2233 if (!phys_disk)
2234 continue;
2235 if ((mpt_raid_phys_disk_pg1(ioc,
2236 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2237 phys_disk))) {
2238 kfree(phys_disk);
2239 continue;
2240 }
2241 for (j = 0; j < num_paths; j++) {
2242 if ((phys_disk->Path[j].Flags &
2243 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2244 continue;
2245 if ((phys_disk->Path[j].Flags &
2246 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2247 continue;
2248 if ((id == phys_disk->Path[j].PhysDiskID) &&
2249 (channel == phys_disk->Path[j].PhysDiskBus)) {
2250 rc = phys_disk->PhysDiskNum;
2251 kfree(phys_disk);
2252 goto out;
2253 }
2254 }
2255 kfree(phys_disk);
2256 }
2257
Eric Mooreb506ade2007-01-29 09:45:37 -07002258 /*
2259 * Check inactive list for matching phys disks
2260 */
2261 if (list_empty(&ioc->raid_data.inactive_list))
2262 goto out;
2263
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002264 mutex_lock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002265 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2266 list) {
2267 if ((component_info->d.PhysDiskID == id) &&
2268 (component_info->d.PhysDiskBus == channel))
2269 rc = component_info->d.PhysDiskNum;
2270 }
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002271 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002272
Eric Moore793955f2007-01-29 09:42:20 -07002273 out:
2274 return rc;
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002275}
Eric Moore793955f2007-01-29 09:42:20 -07002276EXPORT_SYMBOL(mptscsih_raid_id_to_num);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002277
2278/*
2279 * OS entry point to allow for host driver to free allocated memory
2280 * Called if no device present or device being unloaded
2281 */
2282void
2283mptscsih_slave_destroy(struct scsi_device *sdev)
2284{
2285 struct Scsi_Host *host = sdev->host;
Eric Mooree7eae9f2007-09-29 10:15:59 -06002286 MPT_SCSI_HOST *hd = shost_priv(host);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002287 VirtTarget *vtarget;
2288 VirtDevice *vdevice;
2289 struct scsi_target *starget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002291 starget = scsi_target(sdev);
2292 vtarget = starget->hostdata;
2293 vdevice = sdev->hostdata;
Kashyap, Desai08f5c5c2010-03-18 19:22:45 +05302294 if (!vdevice)
2295 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002297 mptscsih_search_running_cmds(hd, vdevice);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002298 vtarget->num_luns--;
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002299 mptscsih_synchronize_cache(hd, vdevice);
2300 kfree(vdevice);
2301 sdev->hostdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302}
2303
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06002304/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2305/*
2306 * mptscsih_change_queue_depth - This function will set a devices queue depth
2307 * @sdev: per scsi_device pointer
2308 * @qdepth: requested queue depth
2309 *
2310 * Adding support for new 'change_queue_depth' api.
2311*/
2312int
Christoph Hellwigdb5ed4d2014-11-13 15:08:42 +01002313mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314{
Eric Mooree7eae9f2007-09-29 10:15:59 -06002315 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002316 VirtTarget *vtarget;
2317 struct scsi_target *starget;
2318 int max_depth;
Eric Mooree80b0022007-09-14 18:49:03 -06002319 MPT_ADAPTER *ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002321 starget = scsi_target(sdev);
2322 vtarget = starget->hostdata;
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06002323
Eric Mooree80b0022007-09-14 18:49:03 -06002324 if (ioc->bus_type == SPI) {
James Bottomleyc92f2222006-03-01 09:02:49 -06002325 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 max_depth = 1;
James Bottomleyc92f2222006-03-01 09:02:49 -06002327 else if (sdev->type == TYPE_DISK &&
2328 vtarget->minSyncFactor <= MPT_ULTRA160)
2329 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2330 else
2331 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 } else
Kashyap, Desai79a3ec12009-08-05 12:52:58 +05302333 max_depth = ioc->sh->can_queue;
2334
2335 if (!sdev->tagged_supported)
2336 max_depth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
2338 if (qdepth > max_depth)
2339 qdepth = max_depth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340
Christoph Hellwigdb5ed4d2014-11-13 15:08:42 +01002341 return scsi_change_queue_depth(sdev, qdepth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342}
2343
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344/*
2345 * OS entry point to adjust the queue_depths on a per-device basis.
2346 * Called once per device the bus scan. Use it to force the queue_depth
2347 * member to 1 if a device does not support Q tags.
2348 * Return non-zero if fails.
2349 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002350int
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002351mptscsih_slave_configure(struct scsi_device *sdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352{
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002353 struct Scsi_Host *sh = sdev->host;
2354 VirtTarget *vtarget;
2355 VirtDevice *vdevice;
2356 struct scsi_target *starget;
Eric Mooree7eae9f2007-09-29 10:15:59 -06002357 MPT_SCSI_HOST *hd = shost_priv(sh);
Eric Mooree80b0022007-09-14 18:49:03 -06002358 MPT_ADAPTER *ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002360 starget = scsi_target(sdev);
2361 vtarget = starget->hostdata;
2362 vdevice = sdev->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363
Eric Mooree80b0022007-09-14 18:49:03 -06002364 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Hannes Reinecke9cb78c12014-06-25 15:27:36 +02002365 "device @ %p, channel=%d, id=%d, lun=%llu\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002366 ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
2367 if (ioc->bus_type == SPI)
2368 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002369 "sdtr %d wdtr %d ppr %d inq length=%d\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002370 ioc->name, sdev->sdtr, sdev->wdtr,
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002371 sdev->ppr, sdev->inquiry_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372
Eric Moore793955f2007-01-29 09:42:20 -07002373 vdevice->configured_lun = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374
Eric Mooree80b0022007-09-14 18:49:03 -06002375 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 "Queue depth=%d, tflags=%x\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002377 ioc->name, sdev->queue_depth, vtarget->tflags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378
Eric Mooree80b0022007-09-14 18:49:03 -06002379 if (ioc->bus_type == SPI)
2380 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002381 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002382 ioc->name, vtarget->negoFlags, vtarget->maxOffset,
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002383 vtarget->minSyncFactor));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384
Christoph Hellwigdb5ed4d2014-11-13 15:08:42 +01002385 mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
Eric Mooree80b0022007-09-14 18:49:03 -06002386 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Christoph Hellwig609aa222014-10-30 11:54:58 +01002387 "tagged %d, simple %d\n",
2388 ioc->name,sdev->tagged_supported, sdev->simple_tags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389
Ryan Kuester2a1b7e52010-04-26 18:11:54 -05002390 blk_queue_dma_alignment (sdev->request_queue, 512 - 1);
2391
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 return 0;
2393}
2394
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2396/*
2397 * Private routines...
2398 */
2399
2400/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2401/* Utility function to copy sense data from the scsi_cmnd buffer
2402 * to the FC and SCSI target structures.
2403 *
2404 */
2405static void
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002406mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407{
Eric Moorea69de502007-09-14 18:48:19 -06002408 VirtDevice *vdevice;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 SCSIIORequest_t *pReq;
2410 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount);
Eric Mooree80b0022007-09-14 18:49:03 -06002411 MPT_ADAPTER *ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412
2413 /* Get target structure
2414 */
2415 pReq = (SCSIIORequest_t *) mf;
Eric Moorea69de502007-09-14 18:48:19 -06002416 vdevice = sc->device->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417
2418 if (sense_count) {
2419 u8 *sense_data;
2420 int req_index;
2421
2422 /* Copy the sense received into the scsi command block. */
2423 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
Eric Mooree80b0022007-09-14 18:49:03 -06002424 sense_data = ((u8 *)ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
Tomas Henzlafe89f12020-06-16 17:04:46 +02002425 memcpy(sc->sense_buffer, sense_data, MPT_SENSE_BUFFER_ALLOC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426
2427 /* Log SMART data (asc = 0x5D, non-IM case only) if required.
2428 */
Eric Mooree80b0022007-09-14 18:49:03 -06002429 if ((ioc->events) && (ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
Eric Moorea69de502007-09-14 18:48:19 -06002430 if ((sense_data[12] == 0x5D) && (vdevice->vtarget->raidVolume == 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432
Moore, Eric5b5ef4f2006-02-02 17:19:40 -07002433 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2435 ioc->events[idx].eventContext = ioc->eventContext;
2436
Dave Jones3d9780b2007-05-21 20:59:47 -04002437 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) |
2438 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) |
2439 (sc->device->channel << 8) | sc->device->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440
Dave Jones3d9780b2007-05-21 20:59:47 -04002441 ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442
2443 ioc->eventContext++;
Eric Mooree80b0022007-09-14 18:49:03 -06002444 if (ioc->pcidev->vendor ==
Eric Moore786899b2006-07-11 17:22:22 -06002445 PCI_VENDOR_ID_IBM) {
Eric Mooree80b0022007-09-14 18:49:03 -06002446 mptscsih_issue_sep_command(ioc,
Eric Moorea69de502007-09-14 18:48:19 -06002447 vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
2448 vdevice->vtarget->tflags |=
Eric Moore786899b2006-07-11 17:22:22 -06002449 MPT_TARGET_FLAGS_LED_ON;
2450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451 }
2452 }
2453 } else {
Eric Mooree80b0022007-09-14 18:49:03 -06002454 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
2455 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 }
2457}
2458
Kashyap, Desaidb7051b2009-05-29 16:56:59 +05302459/**
2460 * mptscsih_get_scsi_lookup - retrieves scmd entry
2461 * @ioc: Pointer to MPT_ADAPTER structure
2462 * @i: index into the array
2463 *
2464 * Returns the scsi_cmd pointer
2465 */
2466struct scsi_cmnd *
2467mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
2468{
2469 unsigned long flags;
2470 struct scsi_cmnd *scmd;
2471
2472 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2473 scmd = ioc->ScsiLookup[i];
2474 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2475
2476 return scmd;
2477}
2478EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
Eric Mooree8206382007-09-29 10:16:53 -06002479
2480/**
James Bottomleyfc847ab2009-06-09 23:01:01 +00002481 * mptscsih_getclear_scsi_lookup - retrieves and clears scmd entry from ScsiLookup[] array list
Kashyap, Desai2f187862009-05-29 16:52:37 +05302482 * @ioc: Pointer to MPT_ADAPTER structure
2483 * @i: index into the array
2484 *
Randy Dunlap7105a382008-02-29 22:03:27 -08002485 * Returns the scsi_cmd pointer
Kashyap, Desai2f187862009-05-29 16:52:37 +05302486 *
Eric Mooree8206382007-09-29 10:16:53 -06002487 **/
2488static struct scsi_cmnd *
2489mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
2490{
2491 unsigned long flags;
2492 struct scsi_cmnd *scmd;
2493
2494 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2495 scmd = ioc->ScsiLookup[i];
2496 ioc->ScsiLookup[i] = NULL;
2497 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2498
2499 return scmd;
2500}
2501
2502/**
Ben Hutchings9b8f77a2010-05-23 17:02:30 -07002503 * mptscsih_set_scsi_lookup - write a scmd entry into the ScsiLookup[] array list
Eric Mooree8206382007-09-29 10:16:53 -06002504 *
2505 * @ioc: Pointer to MPT_ADAPTER structure
2506 * @i: index into the array
2507 * @scmd: scsi_cmnd pointer
2508 *
2509 **/
2510static void
2511mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd)
2512{
2513 unsigned long flags;
2514
2515 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2516 ioc->ScsiLookup[i] = scmd;
2517 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2518}
2519
2520/**
Randy Dunlap23f9b752007-10-15 17:29:33 -07002521 * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
Eric Mooree8206382007-09-29 10:16:53 -06002522 * @ioc: Pointer to MPT_ADAPTER structure
Randy Dunlap23f9b752007-10-15 17:29:33 -07002523 * @sc: scsi_cmnd pointer
2524 */
Eric Mooree8206382007-09-29 10:16:53 -06002525static int
2526SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
2527{
2528 unsigned long flags;
2529 int i, index=-1;
2530
2531 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2532 for (i = 0; i < ioc->req_depth; i++) {
2533 if (ioc->ScsiLookup[i] == sc) {
2534 index = i;
2535 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 }
2537 }
2538
Eric Mooree8206382007-09-29 10:16:53 -06002539 out:
2540 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2541 return index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542}
2543
2544/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002545int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2547{
2548 MPT_SCSI_HOST *hd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549
Eric Mooree7eae9f2007-09-29 10:15:59 -06002550 if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302553 hd = shost_priv(ioc->sh);
2554 switch (reset_phase) {
2555 case MPT_IOC_SETUP_RESET:
2556 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2557 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302558 break;
2559 case MPT_IOC_PRE_RESET:
2560 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2561 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302562 mptscsih_flush_running_cmds(hd);
2563 break;
2564 case MPT_IOC_POST_RESET:
2565 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2566 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
2567 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
2568 ioc->internal_cmds.status |=
2569 MPT_MGMT_STATUS_DID_IOCRESET;
2570 complete(&ioc->internal_cmds.done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 }
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302572 break;
2573 default:
2574 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 return 1; /* currently means nothing really */
2577}
2578
2579/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002580int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2582{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2584
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302585 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2586 "MPT event (=%02Xh) routed to SCSI host driver!\n",
2587 ioc->name, event));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588
Kashyap, Desai2f187862009-05-29 16:52:37 +05302589 if ((event == MPI_EVENT_IOC_BUS_RESET ||
2590 event == MPI_EVENT_EXT_BUS_RESET) &&
2591 (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
2592 ioc->soft_resets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593
2594 return 1; /* currently means nothing really */
2595}
2596
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2598/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599 * Bus Scan and Domain Validation functionality ...
2600 */
2601
2602/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2603/*
2604 * mptscsih_scandv_complete - Scan and DV callback routine registered
2605 * to Fustion MPT (base) driver.
2606 *
2607 * @ioc: Pointer to MPT_ADAPTER structure
2608 * @mf: Pointer to original MPT request frame
2609 * @mr: Pointer to MPT reply frame (NULL if TurboReply)
2610 *
2611 * This routine is called from mpt.c::mpt_interrupt() at the completion
2612 * of any SCSI IO request.
2613 * This routine is registered with the Fusion MPT (base) driver at driver
2614 * load/init time via the mpt_register() API call.
2615 *
2616 * Returns 1 indicating alloc'd request frame ptr should be freed.
2617 *
2618 * Remark: Sets a completion code and (possibly) saves sense data
2619 * in the IOC member localReply structure.
2620 * Used ONLY for DV and other internal commands.
2621 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002622int
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302623mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2624 MPT_FRAME_HDR *reply)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 SCSIIORequest_t *pReq;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302627 SCSIIOReply_t *pReply;
2628 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 u16 req_idx;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302630 u8 *sense_data;
2631 int sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302633 ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2634 ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
2635 if (!reply)
2636 goto out;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002637
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302638 pReply = (SCSIIOReply_t *) reply;
2639 pReq = (SCSIIORequest_t *) req;
2640 ioc->internal_cmds.completion_code =
2641 mptscsih_get_completion_code(ioc, req, reply);
2642 ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2643 memcpy(ioc->internal_cmds.reply, reply,
2644 min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
2645 cmd = reply->u.hdr.Function;
2646 if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
2647 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
2648 (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
2649 req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
2650 sense_data = ((u8 *)ioc->sense_buf_pool +
2651 (req_idx * MPT_SENSE_BUFFER_ALLOC));
2652 sz = min_t(int, pReq->SenseBufferLength,
2653 MPT_SENSE_BUFFER_ALLOC);
2654 memcpy(ioc->internal_cmds.sense, sense_data, sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 }
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302656 out:
2657 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
2658 return 0;
2659 ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2660 complete(&ioc->internal_cmds.done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 return 1;
2662}
2663
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302665/**
Ben Hutchings9b8f77a2010-05-23 17:02:30 -07002666 * mptscsih_get_completion_code - get completion code from MPT request
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302667 * @ioc: Pointer to MPT_ADAPTER structure
Randy Dunlap9cf46a32009-06-13 19:37:18 -07002668 * @req: Pointer to original MPT request frame
2669 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302670 *
2671 **/
2672static int
2673mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2674 MPT_FRAME_HDR *reply)
2675{
2676 SCSIIOReply_t *pReply;
2677 MpiRaidActionReply_t *pr;
2678 u8 scsi_status;
2679 u16 status;
2680 int completion_code;
2681
2682 pReply = (SCSIIOReply_t *)reply;
2683 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2684 scsi_status = pReply->SCSIStatus;
2685
2686 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2687 "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh,"
2688 "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState,
2689 scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
2690
2691 switch (status) {
2692
2693 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
2694 completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
2695 break;
2696
2697 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
2698 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
2699 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
2700 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
2701 completion_code = MPT_SCANDV_DID_RESET;
2702 break;
2703
2704 case MPI_IOCSTATUS_BUSY:
2705 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
2706 completion_code = MPT_SCANDV_BUSY;
2707 break;
2708
2709 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
2710 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
2711 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
2712 if (pReply->Function == MPI_FUNCTION_CONFIG) {
2713 completion_code = MPT_SCANDV_GOOD;
2714 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2715 pr = (MpiRaidActionReply_t *)reply;
2716 if (le16_to_cpu(pr->ActionStatus) ==
2717 MPI_RAID_ACTION_ASTATUS_SUCCESS)
2718 completion_code = MPT_SCANDV_GOOD;
2719 else
2720 completion_code = MPT_SCANDV_SOME_ERROR;
2721 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
2722 completion_code = MPT_SCANDV_SENSE;
2723 else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2724 if (req->u.scsireq.CDB[0] == INQUIRY)
2725 completion_code = MPT_SCANDV_ISSUE_SENSE;
2726 else
2727 completion_code = MPT_SCANDV_DID_RESET;
2728 } else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
2729 completion_code = MPT_SCANDV_DID_RESET;
2730 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2731 completion_code = MPT_SCANDV_DID_RESET;
2732 else if (scsi_status == MPI_SCSI_STATUS_BUSY)
2733 completion_code = MPT_SCANDV_BUSY;
2734 else
2735 completion_code = MPT_SCANDV_GOOD;
2736 break;
2737
2738 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
2739 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2740 completion_code = MPT_SCANDV_DID_RESET;
2741 else
2742 completion_code = MPT_SCANDV_SOME_ERROR;
2743 break;
2744 default:
2745 completion_code = MPT_SCANDV_SOME_ERROR;
2746 break;
2747
2748 } /* switch(status) */
2749
2750 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2751 " completionCode set to %08xh\n", ioc->name, completion_code));
2752 return completion_code;
2753}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754
2755/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2756/**
2757 * mptscsih_do_cmd - Do internal command.
2758 * @hd: MPT_SCSI_HOST pointer
2759 * @io: INTERNAL_CMD pointer.
2760 *
2761 * Issue the specified internally generated command and do command
2762 * specific cleanup. For bus scan / DV only.
2763 * NOTES: If command is Inquiry and status is good,
2764 * initialize a target structure, save the data
2765 *
2766 * Remark: Single threaded access only.
2767 *
2768 * Return:
2769 * < 0 if an illegal command or no resources
2770 *
2771 * 0 if good
2772 *
2773 * > 0 if command complete but some type of completion error.
2774 */
2775static int
2776mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
2777{
2778 MPT_FRAME_HDR *mf;
2779 SCSIIORequest_t *pScsiReq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 int my_idx, ii, dir;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302781 int timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 char cmdLen;
2783 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302784 u8 cmd = io->cmd;
2785 MPT_ADAPTER *ioc = hd->ioc;
2786 int ret = 0;
2787 unsigned long timeleft;
2788 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302790 /* don't send internal command during diag reset */
2791 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2792 if (ioc->ioc_reset_in_progress) {
2793 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2794 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2795 "%s: busy with host reset\n", ioc->name, __func__));
2796 return MPT_SCANDV_BUSY;
2797 }
2798 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2799
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302800 mutex_lock(&ioc->internal_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801
2802 /* Set command specific information
2803 */
2804 switch (cmd) {
2805 case INQUIRY:
2806 cmdLen = 6;
2807 dir = MPI_SCSIIO_CONTROL_READ;
2808 CDB[0] = cmd;
2809 CDB[4] = io->size;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302810 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 break;
2812
2813 case TEST_UNIT_READY:
2814 cmdLen = 6;
2815 dir = MPI_SCSIIO_CONTROL_READ;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302816 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 break;
2818
2819 case START_STOP:
2820 cmdLen = 6;
2821 dir = MPI_SCSIIO_CONTROL_READ;
2822 CDB[0] = cmd;
2823 CDB[4] = 1; /*Spin up the disk */
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302824 timeout = 15;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 break;
2826
2827 case REQUEST_SENSE:
2828 cmdLen = 6;
2829 CDB[0] = cmd;
2830 CDB[4] = io->size;
2831 dir = MPI_SCSIIO_CONTROL_READ;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302832 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 break;
2834
2835 case READ_BUFFER:
2836 cmdLen = 10;
2837 dir = MPI_SCSIIO_CONTROL_READ;
2838 CDB[0] = cmd;
2839 if (io->flags & MPT_ICFLAG_ECHO) {
2840 CDB[1] = 0x0A;
2841 } else {
2842 CDB[1] = 0x02;
2843 }
2844
2845 if (io->flags & MPT_ICFLAG_BUF_CAP) {
2846 CDB[1] |= 0x01;
2847 }
2848 CDB[6] = (io->size >> 16) & 0xFF;
2849 CDB[7] = (io->size >> 8) & 0xFF;
2850 CDB[8] = io->size & 0xFF;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302851 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 break;
2853
2854 case WRITE_BUFFER:
2855 cmdLen = 10;
2856 dir = MPI_SCSIIO_CONTROL_WRITE;
2857 CDB[0] = cmd;
2858 if (io->flags & MPT_ICFLAG_ECHO) {
2859 CDB[1] = 0x0A;
2860 } else {
2861 CDB[1] = 0x02;
2862 }
2863 CDB[6] = (io->size >> 16) & 0xFF;
2864 CDB[7] = (io->size >> 8) & 0xFF;
2865 CDB[8] = io->size & 0xFF;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302866 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 break;
2868
2869 case RESERVE:
2870 cmdLen = 6;
2871 dir = MPI_SCSIIO_CONTROL_READ;
2872 CDB[0] = cmd;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302873 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 break;
2875
2876 case RELEASE:
2877 cmdLen = 6;
2878 dir = MPI_SCSIIO_CONTROL_READ;
2879 CDB[0] = cmd;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302880 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 break;
2882
2883 case SYNCHRONIZE_CACHE:
2884 cmdLen = 10;
2885 dir = MPI_SCSIIO_CONTROL_READ;
2886 CDB[0] = cmd;
2887// CDB[1] = 0x02; /* set immediate bit */
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302888 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 break;
2890
2891 default:
2892 /* Error Case */
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302893 ret = -EFAULT;
2894 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 }
2896
2897 /* Get and Populate a free Frame
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302898 * MsgContext set in mpt_get_msg_frame call
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 */
Eric Mooree80b0022007-09-14 18:49:03 -06002900 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302901 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
2902 ioc->name, __func__));
2903 ret = MPT_SCANDV_BUSY;
2904 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905 }
2906
2907 pScsiReq = (SCSIIORequest_t *) mf;
2908
2909 /* Get the request index */
2910 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2911 ADD_INDEX_LOG(my_idx); /* for debug */
2912
2913 if (io->flags & MPT_ICFLAG_PHYS_DISK) {
2914 pScsiReq->TargetID = io->physDiskNum;
2915 pScsiReq->Bus = 0;
2916 pScsiReq->ChainOffset = 0;
2917 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
2918 } else {
2919 pScsiReq->TargetID = io->id;
Eric Moore793955f2007-01-29 09:42:20 -07002920 pScsiReq->Bus = io->channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921 pScsiReq->ChainOffset = 0;
2922 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
2923 }
2924
2925 pScsiReq->CDBLength = cmdLen;
2926 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2927
2928 pScsiReq->Reserved = 0;
2929
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302930 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931 /* MsgContext set in mpt_get_msg_fram call */
2932
Eric Moore793955f2007-01-29 09:42:20 -07002933 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934
2935 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
2936 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
2937 else
2938 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2939
2940 if (cmd == REQUEST_SENSE) {
2941 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302942 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2943 "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 }
2945
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302946 for (ii = 0; ii < 16; ii++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 pScsiReq->CDB[ii] = CDB[ii];
2948
2949 pScsiReq->DataLength = cpu_to_le32(io->size);
Eric Mooree80b0022007-09-14 18:49:03 -06002950 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
2952
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302953 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Hannes Reinecke9cb78c12014-06-25 15:27:36 +02002954 "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%llu\n",
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302955 ioc->name, __func__, cmd, io->channel, io->id, io->lun));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302957 if (dir == MPI_SCSIIO_CONTROL_READ)
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302958 ioc->add_sge((char *) &pScsiReq->SGL,
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302959 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
2960 else
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302961 ioc->add_sge((char *) &pScsiReq->SGL,
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302962 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302964 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
Eric Mooree80b0022007-09-14 18:49:03 -06002965 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302966 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
2967 timeout*HZ);
2968 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2969 ret = MPT_SCANDV_DID_RESET;
2970 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2971 "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__,
2972 cmd));
2973 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2974 mpt_free_msg_frame(ioc, mf);
2975 goto out;
2976 }
2977 if (!timeleft) {
Kei Tokunaga97009a22010-06-22 19:01:51 +09002978 printk(MYIOC_s_WARN_FMT
2979 "Issuing Reset from %s!! doorbell=0x%08xh"
2980 " cmd=0x%02x\n",
2981 ioc->name, __func__, mpt_GetIocState(ioc, 0),
2982 cmd);
Kashyap, Desaid0f698c2010-03-18 19:12:17 +05302983 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302984 mpt_free_msg_frame(ioc, mf);
2985 }
2986 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 }
2988
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302989 ret = ioc->internal_cmds.completion_code;
2990 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
2991 ioc->name, __func__, ret));
2992
2993 out:
2994 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
2995 mutex_unlock(&ioc->internal_cmds.mutex);
2996 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997}
2998
2999/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3000/**
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07003001 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3002 * @hd: Pointer to a SCSI HOST structure
Randy Dunlapd9489fb2006-12-06 20:38:43 -08003003 * @vdevice: virtual target device
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07003004 *
3005 * Uses the ISR, but with special processing.
3006 * MUST be single-threaded.
3007 *
3008 */
3009static void
3010mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3011{
3012 INTERNAL_CMD iocmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013
Eric Moorecc78d302007-06-15 17:27:21 -06003014 /* Ignore hidden raid components, this is handled when the command
3015 * is sent to the volume
3016 */
3017 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
3018 return;
3019
3020 if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted ||
3021 !vdevice->configured_lun)
3022 return;
3023
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 /* Following parameters will not change
3025 * in this routine.
3026 */
3027 iocmd.cmd = SYNCHRONIZE_CACHE;
3028 iocmd.flags = 0;
3029 iocmd.physDiskNum = -1;
3030 iocmd.data = NULL;
3031 iocmd.data_dma = -1;
3032 iocmd.size = 0;
3033 iocmd.rsvd = iocmd.rsvd2 = 0;
Eric Moore793955f2007-01-29 09:42:20 -07003034 iocmd.channel = vdevice->vtarget->channel;
3035 iocmd.id = vdevice->vtarget->id;
3036 iocmd.lun = vdevice->lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037
Eric Moorecc78d302007-06-15 17:27:21 -06003038 mptscsih_do_cmd(hd, &iocmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039}
3040
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303041static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003042mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
3043 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303044{
Tony Jonesee959b02008-02-22 00:13:36 +01003045 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003046 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303047 MPT_ADAPTER *ioc = hd->ioc;
3048
3049 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
3050 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3051 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3052 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3053 ioc->facts.FWVersion.Word & 0x000000FF);
3054}
Tony Jonesee959b02008-02-22 00:13:36 +01003055static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303056
3057static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003058mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
3059 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303060{
Tony Jonesee959b02008-02-22 00:13:36 +01003061 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003062 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303063 MPT_ADAPTER *ioc = hd->ioc;
3064
3065 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
3066 (ioc->biosVersion & 0xFF000000) >> 24,
3067 (ioc->biosVersion & 0x00FF0000) >> 16,
3068 (ioc->biosVersion & 0x0000FF00) >> 8,
3069 ioc->biosVersion & 0x000000FF);
3070}
Tony Jonesee959b02008-02-22 00:13:36 +01003071static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303072
3073static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003074mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
3075 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303076{
Tony Jonesee959b02008-02-22 00:13:36 +01003077 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003078 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303079 MPT_ADAPTER *ioc = hd->ioc;
3080
3081 return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
3082}
Tony Jonesee959b02008-02-22 00:13:36 +01003083static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303084
3085static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003086mptscsih_version_product_show(struct device *dev,
3087 struct device_attribute *attr,
3088char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303089{
Tony Jonesee959b02008-02-22 00:13:36 +01003090 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003091 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303092 MPT_ADAPTER *ioc = hd->ioc;
3093
3094 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
3095}
Tony Jonesee959b02008-02-22 00:13:36 +01003096static DEVICE_ATTR(version_product, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303097 mptscsih_version_product_show, NULL);
3098
3099static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003100mptscsih_version_nvdata_persistent_show(struct device *dev,
3101 struct device_attribute *attr,
3102 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303103{
Tony Jonesee959b02008-02-22 00:13:36 +01003104 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003105 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303106 MPT_ADAPTER *ioc = hd->ioc;
3107
3108 return snprintf(buf, PAGE_SIZE, "%02xh\n",
3109 ioc->nvdata_version_persistent);
3110}
Tony Jonesee959b02008-02-22 00:13:36 +01003111static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303112 mptscsih_version_nvdata_persistent_show, NULL);
3113
3114static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003115mptscsih_version_nvdata_default_show(struct device *dev,
3116 struct device_attribute *attr, char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303117{
Tony Jonesee959b02008-02-22 00:13:36 +01003118 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003119 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303120 MPT_ADAPTER *ioc = hd->ioc;
3121
3122 return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
3123}
Tony Jonesee959b02008-02-22 00:13:36 +01003124static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303125 mptscsih_version_nvdata_default_show, NULL);
3126
3127static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003128mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
3129 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303130{
Tony Jonesee959b02008-02-22 00:13:36 +01003131 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003132 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303133 MPT_ADAPTER *ioc = hd->ioc;
3134
3135 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
3136}
Tony Jonesee959b02008-02-22 00:13:36 +01003137static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303138
3139static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003140mptscsih_board_assembly_show(struct device *dev,
3141 struct device_attribute *attr, char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303142{
Tony Jonesee959b02008-02-22 00:13:36 +01003143 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003144 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303145 MPT_ADAPTER *ioc = hd->ioc;
3146
3147 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
3148}
Tony Jonesee959b02008-02-22 00:13:36 +01003149static DEVICE_ATTR(board_assembly, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303150 mptscsih_board_assembly_show, NULL);
3151
3152static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003153mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
3154 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303155{
Tony Jonesee959b02008-02-22 00:13:36 +01003156 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003157 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303158 MPT_ADAPTER *ioc = hd->ioc;
3159
3160 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
3161}
Tony Jonesee959b02008-02-22 00:13:36 +01003162static DEVICE_ATTR(board_tracer, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303163 mptscsih_board_tracer_show, NULL);
3164
3165static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003166mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
3167 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303168{
Tony Jonesee959b02008-02-22 00:13:36 +01003169 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003170 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303171 MPT_ADAPTER *ioc = hd->ioc;
3172
3173 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
3174}
Tony Jonesee959b02008-02-22 00:13:36 +01003175static DEVICE_ATTR(io_delay, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303176 mptscsih_io_delay_show, NULL);
3177
3178static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003179mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
3180 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303181{
Tony Jonesee959b02008-02-22 00:13:36 +01003182 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003183 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303184 MPT_ADAPTER *ioc = hd->ioc;
3185
3186 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
3187}
Tony Jonesee959b02008-02-22 00:13:36 +01003188static DEVICE_ATTR(device_delay, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303189 mptscsih_device_delay_show, NULL);
3190
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303191static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003192mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
3193 char *buf)
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303194{
Tony Jonesee959b02008-02-22 00:13:36 +01003195 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003196 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303197 MPT_ADAPTER *ioc = hd->ioc;
3198
3199 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
3200}
3201static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003202mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
3203 const char *buf, size_t count)
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303204{
Tony Jonesee959b02008-02-22 00:13:36 +01003205 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003206 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303207 MPT_ADAPTER *ioc = hd->ioc;
3208 int val = 0;
3209
3210 if (sscanf(buf, "%x", &val) != 1)
3211 return -EINVAL;
3212
3213 ioc->debug_level = val;
3214 printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
3215 ioc->name, ioc->debug_level);
3216 return strlen(buf);
3217}
Tony Jonesee959b02008-02-22 00:13:36 +01003218static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
3219 mptscsih_debug_level_show, mptscsih_debug_level_store);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303220
Bart Van Assche28998362021-10-12 16:35:17 -07003221static struct attribute *mptscsih_host_attrs[] = {
3222 &dev_attr_version_fw.attr,
3223 &dev_attr_version_bios.attr,
3224 &dev_attr_version_mpi.attr,
3225 &dev_attr_version_product.attr,
3226 &dev_attr_version_nvdata_persistent.attr,
3227 &dev_attr_version_nvdata_default.attr,
3228 &dev_attr_board_name.attr,
3229 &dev_attr_board_assembly.attr,
3230 &dev_attr_board_tracer.attr,
3231 &dev_attr_io_delay.attr,
3232 &dev_attr_device_delay.attr,
3233 &dev_attr_debug_level.attr,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303234 NULL,
3235};
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303236
Bart Van Assche28998362021-10-12 16:35:17 -07003237static const struct attribute_group mptscsih_host_attr_group = {
3238 .attrs = mptscsih_host_attrs
3239};
3240
3241const struct attribute_group *mptscsih_host_attr_groups[] = {
3242 &mptscsih_host_attr_group,
3243 NULL
3244};
3245EXPORT_SYMBOL(mptscsih_host_attr_groups);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303246
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04003247EXPORT_SYMBOL(mptscsih_remove);
3248EXPORT_SYMBOL(mptscsih_shutdown);
3249#ifdef CONFIG_PM
3250EXPORT_SYMBOL(mptscsih_suspend);
3251EXPORT_SYMBOL(mptscsih_resume);
3252#endif
Al Virocac19702013-03-31 01:42:38 -04003253EXPORT_SYMBOL(mptscsih_show_info);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04003254EXPORT_SYMBOL(mptscsih_info);
3255EXPORT_SYMBOL(mptscsih_qcmd);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04003256EXPORT_SYMBOL(mptscsih_slave_destroy);
3257EXPORT_SYMBOL(mptscsih_slave_configure);
3258EXPORT_SYMBOL(mptscsih_abort);
3259EXPORT_SYMBOL(mptscsih_dev_reset);
3260EXPORT_SYMBOL(mptscsih_bus_reset);
3261EXPORT_SYMBOL(mptscsih_host_reset);
3262EXPORT_SYMBOL(mptscsih_bios_param);
3263EXPORT_SYMBOL(mptscsih_io_done);
3264EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3265EXPORT_SYMBOL(mptscsih_scandv_complete);
3266EXPORT_SYMBOL(mptscsih_event_process);
3267EXPORT_SYMBOL(mptscsih_ioc_reset);
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06003268EXPORT_SYMBOL(mptscsih_change_queue_depth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003269
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04003270/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/