1 /*
2 * linux/drivers/message/fusion/mptscsih.c
3 * For use with LSI PCI chip/adapter(s)
4 * running LSI Fusion MPT (Message Passing Technology) firmware.
5 *
6 * Copyright (c) 1999-2008 LSI Corporation
7 * (mailto:DL-MPTFusionLinux@lsi.com)
8 *
9 */
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
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/slab.h>
50 #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 */
55 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
56 #include <linux/reboot.h> /* notifier code */
57 #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>
64 #include <scsi/scsi_dbg.h>
65
66 #include "mptbase.h"
67 #include "mptscsih.h"
68 #include "lsi/mpi_log_sas.h"
69
70 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
71 #define my_NAME "Fusion MPT SCSI Host driver"
72 #define my_VERSION MPT_LINUX_VERSION_COMMON
73 #define MYNAM "mptscsih"
74
75 MODULE_AUTHOR(MODULEAUTHOR);
76 MODULE_DESCRIPTION(my_NAME);
77 MODULE_LICENSE("GPL");
78 MODULE_VERSION(my_VERSION);
79
80 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
81 /*
82 * Other private/forward protos...
83 */
84 struct scsi_cmnd *mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
85 static struct scsi_cmnd * mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i);
86 static void mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd);
87 static int SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *scmd);
88 int mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
89 static void mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq);
90 int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
91
92 static int mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
93 SCSIIORequest_t *pReq, int req_idx);
94 static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
95 static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
96
97 int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id,
98 u64 lun, int ctx2abort, ulong timeout);
99
100 int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
101 int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
102
103 void
104 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code);
105 static int mptscsih_get_completion_code(MPT_ADAPTER *ioc,
106 MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
107 int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
108 static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
109 static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
110
111 static int
112 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
113 SCSITaskMgmtReply_t *pScsiTmReply);
114 void mptscsih_remove(struct pci_dev *);
115 void mptscsih_shutdown(struct pci_dev *);
116 #ifdef CONFIG_PM
117 int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
118 int mptscsih_resume(struct pci_dev *pdev);
119 #endif
120
121
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 */
131 static inline int
mptscsih_getFreeChainBuffer(MPT_ADAPTER * ioc,int * retIndex)132 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
133 {
134 MPT_FRAME_HDR *chainBuf;
135 unsigned long flags;
136 int rc;
137 int chain_idx;
138
139 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n",
140 ioc->name));
141 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;
151 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));
154 } else {
155 rc = FAILED;
156 chain_idx = MPT_HOST_NO_CHAIN;
157 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n",
158 ioc->name));
159 }
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 */
176 static int
mptscsih_AddSGE(MPT_ADAPTER * ioc,struct scsi_cmnd * SCpnt,SCSIIORequest_t * pReq,int req_idx)177 mptscsih_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 */
208 sges_left = scsi_dma_map(SCpnt);
209 if (sges_left < 0)
210 return FAILED;
211
212 /* Handle the SG case.
213 */
214 sg = scsi_sglist(SCpnt);
215 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
225 nextSGEset:
226 numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size);
227 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
228
229 sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir;
230
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) {
238 /* Get next SG element from the OS */
239 sg = sg_next(sg);
240 sg_done++;
241 continue;
242 }
243
244 v2 = sg_dma_address(sg);
245 ioc->add_sge(psge, sgflags | thisxfer, v2);
246
247 /* Get next SG element from the OS */
248 sg = sg_next(sg);
249 psge += ioc->SGE_size;
250 sgeOffset += ioc->SGE_size;
251 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);
267 ioc->add_sge(psge, sgflags | thisxfer, v2);
268 sgeOffset += ioc->SGE_size;
269 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 */
277 ioc->add_chain((char *)chainSge, 0, sgeOffset,
278 ioc->ChainBufferDMA + chain_dma_off);
279 } 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;
285 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
286 "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
301 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SG: Chain Required! sg done %d\n",
302 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) {
311 u32 *ptmp = (u32 *) (psge - ioc->SGE_size);
312 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);
325 sgeOffset += ioc->SGE_size;
326 ioc->add_chain((char *)chainSge, nextChain, sgeOffset,
327 ioc->ChainBufferDMA + chain_dma_off);
328 } 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;
335 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
336 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 */
345 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) {
346 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
347 "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n",
348 ioc->name, pReq->CDB[0], SCpnt));
349 return FAILED;
350 }
351
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;
368 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Current buff @ %p (index 0x%x)",
369 ioc->name, psge, req_idx));
370
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
377 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Chain buff @ %p (index 0x%x)\n",
378 ioc->name, psge, chain_idx));
379
380 /* Start the SGE for the next buffer
381 */
382
383 goto nextSGEset;
384 }
385
386 return SUCCESS;
387 } /* mptscsih_AddSGE() */
388
389 static void
mptscsih_issue_sep_command(MPT_ADAPTER * ioc,VirtTarget * vtarget,U32 SlotStatus)390 mptscsih_issue_sep_command(MPT_ADAPTER *ioc, VirtTarget *vtarget,
391 U32 SlotStatus)
392 {
393 MPT_FRAME_HDR *mf;
394 SEPRequest_t *SEPMsg;
395
396 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)
402 return;
403
404 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
405 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
406 ioc->name,__func__));
407 return;
408 }
409
410 SEPMsg = (SEPRequest_t *)mf;
411 SEPMsg->Function = MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
412 SEPMsg->Bus = vtarget->channel;
413 SEPMsg->TargetID = vtarget->id;
414 SEPMsg->Action = MPI_SEP_REQ_ACTION_WRITE_STATUS;
415 SEPMsg->SlotStatus = SlotStatus;
416 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
417 "Sending SEP cmd=%x channel=%d id=%d\n",
418 ioc->name, SlotStatus, SEPMsg->Bus, SEPMsg->TargetID));
419 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
420 }
421
422 #ifdef CONFIG_FUSION_LOGGING
423 /**
424 * mptscsih_info_scsiio - debug print info on reply frame
425 * @ioc: Pointer to MPT_ADAPTER structure
426 * @sc: original scsi cmnd pointer
427 * @pScsiReply: Pointer to MPT reply frame
428 *
429 * MPT_DEBUG_REPLY needs to be enabled to obtain this info
430 *
431 * Refer to lsi/mpi.h.
432 **/
433 static void
mptscsih_info_scsiio(MPT_ADAPTER * ioc,struct scsi_cmnd * sc,SCSIIOReply_t * pScsiReply)434 mptscsih_info_scsiio(MPT_ADAPTER *ioc, struct scsi_cmnd *sc, SCSIIOReply_t * pScsiReply)
435 {
436 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;
442
443 switch (ioc_status) {
444
445 case MPI_IOCSTATUS_SUCCESS:
446 desc = "success";
447 break;
448 case MPI_IOCSTATUS_SCSI_INVALID_BUS:
449 desc = "invalid bus";
450 break;
451 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID:
452 desc = "invalid target_id";
453 break;
454 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
455 desc = "device not there";
456 break;
457 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN:
458 desc = "data overrun";
459 break;
460 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:
461 desc = "data underrun";
462 break;
463 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:
464 desc = "I/O data error";
465 break;
466 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:
467 desc = "protocol error";
468 break;
469 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:
470 desc = "task terminated";
471 break;
472 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
473 desc = "residual mismatch";
474 break;
475 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 = "";
486 break;
487 }
488
489 switch (pScsiReply->SCSIStatus)
490 {
491
492 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 }
535
536 scsi_print_command(sc);
537 printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %llu\n",
538 ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun);
539 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),
544 le32_to_cpu(pScsiReply->TransferCount), sc->result);
545
546 printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), "
547 "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n",
548 ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus,
549 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
556 printk(MYIOC_s_DEBUG_FMT "\t[sense_key,asc,ascq]: "
557 "[0x%02x,0x%02x,0x%02x]\n", ioc->name, skey, asc, ascq);
558 }
559
560 /*
561 * Look for + dump FCP ResponseInfo[]!
562 */
563 if (pScsiReply->SCSIState & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
564 pScsiReply->ResponseInfo)
565 printk(MYIOC_s_DEBUG_FMT "response_info = %08xh\n",
566 ioc->name, le32_to_cpu(pScsiReply->ResponseInfo));
567 }
568 #endif
569
570 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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 */
585 int
mptscsih_io_done(MPT_ADAPTER * ioc,MPT_FRAME_HDR * mf,MPT_FRAME_HDR * mr)586 mptscsih_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;
592 u16 req_idx, req_idx_MR;
593 VirtDevice *vdevice;
594 VirtTarget *vtarget;
595
596 hd = shost_priv(ioc->sh);
597 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
598 req_idx_MR = (mr != NULL) ?
599 le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
600
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 */
605 if ((req_idx != req_idx_MR) ||
606 (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf))
607 return 0;
608
609 sc = mptscsih_getclear_scsi_lookup(ioc, req_idx);
610 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
625 if ((unsigned char *)mf != sc->host_scribble) {
626 mptscsih_freeChainBuffers(ioc, req_idx);
627 return 1;
628 }
629
630 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
640 sc->host_scribble = NULL;
641 sc->result = DID_OK << 16; /* Set default reply as OK */
642 pScsiReq = (SCSIIORequest_t *) mf;
643 pScsiReply = (SCSIIOReply_t *) mr;
644
645 if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
646 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
647 "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{
650 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
651 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n",
652 ioc->name, mf, mr, sc, req_idx));
653 }
654
655 if (pScsiReply == NULL) {
656 /* special context reply handling */
657 ;
658 } else {
659 u32 xfer_cnt;
660 u16 status;
661 u8 scsi_state, scsi_status;
662 u32 log_info;
663
664 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
665
666 scsi_state = pScsiReply->SCSIState;
667 scsi_status = pScsiReply->SCSIStatus;
668 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
669 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
670 log_info = le32_to_cpu(pScsiReply->IOCLogInfo);
671
672 /*
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
685 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
686 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
687
688 /*
689 * Look for + dump FCP ResponseInfo[]!
690 */
691 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
692 pScsiReply->ResponseInfo) {
693 printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%llu] "
694 "FCP_ResponseInfo=%08xh\n", ioc->name,
695 sc->device->host->host_no, sc->device->channel,
696 sc->device->id, sc->device->lun,
697 le32_to_cpu(pScsiReply->ResponseInfo));
698 }
699
700 switch(status) {
701 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
702 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
703 /* 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! */
718 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;
723
724 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
725 hd->sel_timeout[pScsiReq->TargetID]++;
726
727 vdevice = sc->device->hostdata;
728 if (!vdevice)
729 break;
730 vtarget = vdevice->vtarget;
731 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 }
736 break;
737
738 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
739 if ( ioc->bus_type == SAS ) {
740 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;
770 }
771 } 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;
782 }
783
784 /*
785 * Allow non-SAS & non-NEXUS_LOSS to drop into below code
786 */
787
788 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
789 /* Linux handles an unsolicited DID_RESET better
790 * than an unsolicited DID_ABORT.
791 */
792 sc->result = DID_RESET << 16;
793 break;
794
795 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
796 if (ioc->bus_type == FC)
797 sc->result = DID_ERROR << 16;
798 else
799 sc->result = DID_RESET << 16;
800 break;
801
802 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
803 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
804 if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
805 sc->result=DID_SOFT_ERROR << 16;
806 else /* Sufficient data transfer occurred */
807 sc->result = (DID_OK << 16) | scsi_status;
808 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
809 "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
810 ioc->name, sc->result, sc->device->channel, sc->device->id));
811 break;
812
813 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
814 /*
815 * Do upfront check for valid SenseData and give it
816 * precedence!
817 */
818 sc->result = (DID_OK << 16) | scsi_status;
819 if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
820
821 /*
822 * For an Errata on LSI53C1030
823 * When the length of request data
824 * and transfer data are different
825 * with result of command (READ or VERIFY),
826 * DID_SOFT_ERROR is set.
827 */
828 if (ioc->bus_type == SPI) {
829 if ((pScsiReq->CDB[0] == READ_6 && ((pScsiReq->CDB[1] & 0x02) == 0)) ||
830 pScsiReq->CDB[0] == READ_10 ||
831 pScsiReq->CDB[0] == READ_12 ||
832 (pScsiReq->CDB[0] == READ_16 &&
833 ((pScsiReq->CDB[1] & 0x02) == 0)) ||
834 pScsiReq->CDB[0] == VERIFY ||
835 pScsiReq->CDB[0] == VERIFY_16) {
836 if (scsi_bufflen(sc) !=
837 xfer_cnt) {
838 sc->result =
839 DID_SOFT_ERROR << 16;
840 printk(KERN_WARNING "Errata"
841 "on LSI53C1030 occurred."
842 "sc->req_bufflen=0x%02x,"
843 "xfer_cnt=0x%02x\n",
844 scsi_bufflen(sc),
845 xfer_cnt);
846 }
847 }
848 }
849
850 if (xfer_cnt < sc->underflow) {
851 if (scsi_status == SAM_STAT_BUSY)
852 sc->result = SAM_STAT_BUSY;
853 else
854 sc->result = DID_SOFT_ERROR << 16;
855 }
856 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
857 /* What to do?
858 */
859 sc->result = DID_SOFT_ERROR << 16;
860 }
861 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
862 /* Not real sure here either... */
863 sc->result = DID_RESET << 16;
864 }
865 }
866
867
868 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
869 " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
870 ioc->name, sc->underflow));
871 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
872 " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
873
874 /* Report Queue Full
875 */
876 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
877 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
878
879 break;
880
881 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
882 scsi_set_resid(sc, 0);
883 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
884 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
885 sc->result = (DID_OK << 16) | scsi_status;
886 if (scsi_state == 0) {
887 ;
888 } else if (scsi_state &
889 MPI_SCSI_STATE_AUTOSENSE_VALID) {
890
891 /*
892 * For potential trouble on LSI53C1030.
893 * (date:2007.xx.)
894 * It is checked whether the length of
895 * request data is equal to
896 * the length of transfer and residual.
897 * MEDIUM_ERROR is set by incorrect data.
898 */
899 if ((ioc->bus_type == SPI) &&
900 (sc->sense_buffer[2] & 0x20)) {
901 u32 difftransfer;
902 difftransfer =
903 sc->sense_buffer[3] << 24 |
904 sc->sense_buffer[4] << 16 |
905 sc->sense_buffer[5] << 8 |
906 sc->sense_buffer[6];
907 if (((sc->sense_buffer[3] & 0x80) ==
908 0x80) && (scsi_bufflen(sc)
909 != xfer_cnt)) {
910 sc->sense_buffer[2] =
911 MEDIUM_ERROR;
912 sc->sense_buffer[12] = 0xff;
913 sc->sense_buffer[13] = 0xff;
914 printk(KERN_WARNING"Errata"
915 "on LSI53C1030 occurred."
916 "sc->req_bufflen=0x%02x,"
917 "xfer_cnt=0x%02x\n" ,
918 scsi_bufflen(sc),
919 xfer_cnt);
920 }
921 if (((sc->sense_buffer[3] & 0x80)
922 != 0x80) &&
923 (scsi_bufflen(sc) !=
924 xfer_cnt + difftransfer)) {
925 sc->sense_buffer[2] =
926 MEDIUM_ERROR;
927 sc->sense_buffer[12] = 0xff;
928 sc->sense_buffer[13] = 0xff;
929 printk(KERN_WARNING
930 "Errata on LSI53C1030 occurred"
931 "sc->req_bufflen=0x%02x,"
932 " xfer_cnt=0x%02x,"
933 "difftransfer=0x%02x\n",
934 scsi_bufflen(sc),
935 xfer_cnt,
936 difftransfer);
937 }
938 }
939
940 /*
941 * If running against circa 200003dd 909 MPT f/w,
942 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
943 * (QUEUE_FULL) returned from device! --> get 0x0000?128
944 * and with SenseBytes set to 0.
945 */
946 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
947 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
948
949 }
950 else if (scsi_state &
951 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
952 ) {
953 /*
954 * What to do?
955 */
956 sc->result = DID_SOFT_ERROR << 16;
957 }
958 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
959 /* Not real sure here either... */
960 sc->result = DID_RESET << 16;
961 }
962 else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) {
963 /* Device Inq. data indicates that it supports
964 * QTags, but rejects QTag messages.
965 * This command completed OK.
966 *
967 * Not real sure here either so do nothing... */
968 }
969
970 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
971 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
972
973 /* Add handling of:
974 * Reservation Conflict, Busy,
975 * Command Terminated, CHECK
976 */
977 break;
978
979 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
980 sc->result = DID_SOFT_ERROR << 16;
981 break;
982
983 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
984 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
985 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
986 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
987 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
988 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
989 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
990 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
991 default:
992 /*
993 * What to do?
994 */
995 sc->result = DID_SOFT_ERROR << 16;
996 break;
997
998 } /* switch(status) */
999
1000 #ifdef CONFIG_FUSION_LOGGING
1001 if (sc->result && (ioc->debug_level & MPT_DEBUG_REPLY))
1002 mptscsih_info_scsiio(ioc, sc, pScsiReply);
1003 #endif
1004
1005 } /* end of address reply case */
1006 out:
1007 /* Unmap the DMA buffers, if any. */
1008 scsi_dma_unmap(sc);
1009
1010 sc->scsi_done(sc); /* Issue the command callback */
1011
1012 /* Free Chain buffers */
1013 mptscsih_freeChainBuffers(ioc, req_idx);
1014 return 1;
1015 }
1016
1017 /*
1018 * mptscsih_flush_running_cmds - For each command found, search
1019 * Scsi_Host instance taskQ and reply to OS.
1020 * Called only if recovering from a FW reload.
1021 * @hd: Pointer to a SCSI HOST structure
1022 *
1023 * Returns: None.
1024 *
1025 * Must be called while new I/Os are being queued.
1026 */
1027 void
mptscsih_flush_running_cmds(MPT_SCSI_HOST * hd)1028 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
1029 {
1030 MPT_ADAPTER *ioc = hd->ioc;
1031 struct scsi_cmnd *sc;
1032 SCSIIORequest_t *mf = NULL;
1033 int ii;
1034 int channel, id;
1035
1036 for (ii= 0; ii < ioc->req_depth; ii++) {
1037 sc = mptscsih_getclear_scsi_lookup(ioc, ii);
1038 if (!sc)
1039 continue;
1040 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1041 if (!mf)
1042 continue;
1043 channel = mf->Bus;
1044 id = mf->TargetID;
1045 mptscsih_freeChainBuffers(ioc, ii);
1046 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
1047 if ((unsigned char *)mf != sc->host_scribble)
1048 continue;
1049 scsi_dma_unmap(sc);
1050 sc->result = DID_RESET << 16;
1051 sc->host_scribble = NULL;
1052 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
1053 "completing cmds: fw_channel %d, fw_id %d, sc=%p, mf = %p, "
1054 "idx=%x\n", ioc->name, channel, id, sc, mf, ii));
1055 sc->scsi_done(sc);
1056 }
1057 }
1058 EXPORT_SYMBOL(mptscsih_flush_running_cmds);
1059
1060 /*
1061 * mptscsih_search_running_cmds - Delete any commands associated
1062 * with the specified target and lun. Function called only
1063 * when a lun is disable by mid-layer.
1064 * Do NOT access the referenced scsi_cmnd structure or
1065 * members. Will cause either a paging or NULL ptr error.
1066 * (BUT, BUT, BUT, the code does reference it! - mdr)
1067 * @hd: Pointer to a SCSI HOST structure
1068 * @vdevice: per device private data
1069 *
1070 * Returns: None.
1071 *
1072 * Called from slave_destroy.
1073 */
1074 static void
mptscsih_search_running_cmds(MPT_SCSI_HOST * hd,VirtDevice * vdevice)1075 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
1076 {
1077 SCSIIORequest_t *mf = NULL;
1078 int ii;
1079 struct scsi_cmnd *sc;
1080 struct scsi_lun lun;
1081 MPT_ADAPTER *ioc = hd->ioc;
1082 unsigned long flags;
1083
1084 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1085 for (ii = 0; ii < ioc->req_depth; ii++) {
1086 if ((sc = ioc->ScsiLookup[ii]) != NULL) {
1087
1088 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1089 if (mf == NULL)
1090 continue;
1091 /* If the device is a hidden raid component, then its
1092 * expected that the mf->function will be RAID_SCSI_IO
1093 */
1094 if (vdevice->vtarget->tflags &
1095 MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function !=
1096 MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
1097 continue;
1098
1099 int_to_scsilun(vdevice->lun, &lun);
1100 if ((mf->Bus != vdevice->vtarget->channel) ||
1101 (mf->TargetID != vdevice->vtarget->id) ||
1102 memcmp(lun.scsi_lun, mf->LUN, 8))
1103 continue;
1104
1105 if ((unsigned char *)mf != sc->host_scribble)
1106 continue;
1107 ioc->ScsiLookup[ii] = NULL;
1108 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1109 mptscsih_freeChainBuffers(ioc, ii);
1110 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
1111 scsi_dma_unmap(sc);
1112 sc->host_scribble = NULL;
1113 sc->result = DID_NO_CONNECT << 16;
1114 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device,
1115 MYIOC_s_FMT "completing cmds: fw_channel %d, "
1116 "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name,
1117 vdevice->vtarget->channel, vdevice->vtarget->id,
1118 sc, mf, ii));
1119 sc->scsi_done(sc);
1120 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1121 }
1122 }
1123 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1124 return;
1125 }
1126
1127 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1128
1129 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1130 /*
1131 * mptscsih_report_queue_full - Report QUEUE_FULL status returned
1132 * from a SCSI target device.
1133 * @sc: Pointer to scsi_cmnd structure
1134 * @pScsiReply: Pointer to SCSIIOReply_t
1135 * @pScsiReq: Pointer to original SCSI request
1136 *
1137 * This routine periodically reports QUEUE_FULL status returned from a
1138 * SCSI target device. It reports this to the console via kernel
1139 * printk() API call, not more than once every 10 seconds.
1140 */
1141 static void
mptscsih_report_queue_full(struct scsi_cmnd * sc,SCSIIOReply_t * pScsiReply,SCSIIORequest_t * pScsiReq)1142 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
1143 {
1144 long time = jiffies;
1145 MPT_SCSI_HOST *hd;
1146 MPT_ADAPTER *ioc;
1147
1148 if (sc->device == NULL)
1149 return;
1150 if (sc->device->host == NULL)
1151 return;
1152 if ((hd = shost_priv(sc->device->host)) == NULL)
1153 return;
1154 ioc = hd->ioc;
1155 if (time - hd->last_queue_full > 10 * HZ) {
1156 dprintk(ioc, printk(MYIOC_s_WARN_FMT "Device (%d:%d:%llu) reported QUEUE_FULL!\n",
1157 ioc->name, 0, sc->device->id, sc->device->lun));
1158 hd->last_queue_full = time;
1159 }
1160 }
1161
1162 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1163 /*
1164 * mptscsih_remove - Removed scsi devices
1165 * @pdev: Pointer to pci_dev structure
1166 *
1167 *
1168 */
1169 void
mptscsih_remove(struct pci_dev * pdev)1170 mptscsih_remove(struct pci_dev *pdev)
1171 {
1172 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1173 struct Scsi_Host *host = ioc->sh;
1174 MPT_SCSI_HOST *hd;
1175 int sz1;
1176
1177 scsi_remove_host(host);
1178
1179 if (host == NULL)
1180 hd = NULL;
1181 else
1182 hd = shost_priv(host);
1183
1184 mptscsih_shutdown(pdev);
1185
1186 sz1=0;
1187
1188 if (ioc->ScsiLookup != NULL) {
1189 sz1 = ioc->req_depth * sizeof(void *);
1190 kfree(ioc->ScsiLookup);
1191 ioc->ScsiLookup = NULL;
1192 }
1193
1194 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1195 "Free'd ScsiLookup (%d) memory\n",
1196 ioc->name, sz1));
1197
1198 if (hd)
1199 kfree(hd->info_kbuf);
1200
1201 /* NULL the Scsi_Host pointer
1202 */
1203 ioc->sh = NULL;
1204
1205 if (host)
1206 scsi_host_put(host);
1207 mpt_detach(pdev);
1208
1209 }
1210
1211 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1212 /*
1213 * mptscsih_shutdown - reboot notifier
1214 *
1215 */
1216 void
mptscsih_shutdown(struct pci_dev * pdev)1217 mptscsih_shutdown(struct pci_dev *pdev)
1218 {
1219 }
1220
1221 #ifdef CONFIG_PM
1222 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1223 /*
1224 * mptscsih_suspend - Fusion MPT scsi driver suspend routine.
1225 *
1226 *
1227 */
1228 int
mptscsih_suspend(struct pci_dev * pdev,pm_message_t state)1229 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
1230 {
1231 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1232
1233 scsi_block_requests(ioc->sh);
1234 flush_scheduled_work();
1235 mptscsih_shutdown(pdev);
1236 return mpt_suspend(pdev,state);
1237 }
1238
1239 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1240 /*
1241 * mptscsih_resume - Fusion MPT scsi driver resume routine.
1242 *
1243 *
1244 */
1245 int
mptscsih_resume(struct pci_dev * pdev)1246 mptscsih_resume(struct pci_dev *pdev)
1247 {
1248 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;
1254 }
1255
1256 #endif
1257
1258 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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 */
1267 const char *
mptscsih_info(struct Scsi_Host * SChost)1268 mptscsih_info(struct Scsi_Host *SChost)
1269 {
1270 MPT_SCSI_HOST *h;
1271 int size = 0;
1272
1273 h = shost_priv(SChost);
1274
1275 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';
1279
1280 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0);
1281 h->info_kbuf[size-1] = '\0';
1282
1283 return h->info_kbuf;
1284 }
1285
mptscsih_show_info(struct seq_file * m,struct Scsi_Host * host)1286 int mptscsih_show_info(struct seq_file *m, struct Scsi_Host *host)
1287 {
1288 MPT_SCSI_HOST *hd = shost_priv(host);
1289 MPT_ADAPTER *ioc = hd->ioc;
1290
1291 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);
1295
1296 return 0;
1297 }
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
1306 *
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 */
1313 int
mptscsih_qcmd(struct scsi_cmnd * SCpnt)1314 mptscsih_qcmd(struct scsi_cmnd *SCpnt)
1315 {
1316 MPT_SCSI_HOST *hd;
1317 MPT_FRAME_HDR *mf;
1318 SCSIIORequest_t *pScsiReq;
1319 VirtDevice *vdevice = SCpnt->device->hostdata;
1320 u32 datalen;
1321 u32 scsictl;
1322 u32 scsidir;
1323 u32 cmd_len;
1324 int my_idx;
1325 int ii;
1326 MPT_ADAPTER *ioc;
1327
1328 hd = shost_priv(SCpnt->device->host);
1329 ioc = hd->ioc;
1330
1331 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p\n",
1332 ioc->name, SCpnt));
1333
1334 if (ioc->taskmgmt_quiesce_io)
1335 return SCSI_MLQUEUE_HOST_BUSY;
1336
1337 /*
1338 * Put together a MPT SCSI request...
1339 */
1340 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
1341 dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
1342 ioc->name));
1343 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
1352 /* TUR's being issued with scsictl=0x02000000 (DATA_IN)!
1353 * 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) {
1357 datalen = scsi_bufflen(SCpnt);
1358 scsidir = MPI_SCSIIO_CONTROL_READ; /* DATA IN (host<--ioc<--dev) */
1359 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1360 datalen = scsi_bufflen(SCpnt);
1361 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 */
1370 if ((vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
1371 && (SCpnt->device->tagged_supported)) {
1372 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
1373 if (SCpnt->request && SCpnt->request->ioprio) {
1374 if (((SCpnt->request->ioprio & 0x7) == 1) ||
1375 !(SCpnt->request->ioprio & 0x7))
1376 scsictl |= MPI_SCSIIO_CONTROL_HEADOFQ;
1377 }
1378 } else
1379 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
1380
1381
1382 /* Use the above information to set up the message frame
1383 */
1384 pScsiReq->TargetID = (u8) vdevice->vtarget->id;
1385 pScsiReq->Bus = vdevice->vtarget->channel;
1386 pScsiReq->ChainOffset = 0;
1387 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
1388 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
1389 else
1390 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
1391 pScsiReq->CDBLength = SCpnt->cmd_len;
1392 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1393 pScsiReq->Reserved = 0;
1394 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
1395 int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN);
1396 pScsiReq->Control = cpu_to_le32(scsictl);
1397
1398 /*
1399 * Write SCSI CDB into the message
1400 */
1401 cmd_len = SCpnt->cmd_len;
1402 for (ii=0; ii < cmd_len; ii++)
1403 pScsiReq->CDB[ii] = SCpnt->cmnd[ii];
1404
1405 for (ii=cmd_len; ii < 16; ii++)
1406 pScsiReq->CDB[ii] = 0;
1407
1408 /* DataLength */
1409 pScsiReq->DataLength = cpu_to_le32(datalen);
1410
1411 /* SenseBuffer low address */
1412 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
1413 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
1414
1415 /* Now add the SG list
1416 * Always have a SGE even if null length.
1417 */
1418 if (datalen == 0) {
1419 /* Add a NULL SGE */
1420 ioc->add_sge((char *)&pScsiReq->SGL,
1421 MPT_SGE_FLAGS_SSIMPLE_READ | 0,
1422 (dma_addr_t) -1);
1423 } else {
1424 /* Add a 32 or 64 bit SGE */
1425 if (mptscsih_AddSGE(ioc, SCpnt, pScsiReq, my_idx) != SUCCESS)
1426 goto fail;
1427 }
1428
1429 SCpnt->host_scribble = (unsigned char *)mf;
1430 mptscsih_set_scsi_lookup(ioc, my_idx, SCpnt);
1431
1432 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
1433 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n",
1434 ioc->name, SCpnt, mf, my_idx));
1435 DBG_DUMP_REQUEST_FRAME(ioc, (u32 *)mf);
1436 return 0;
1437
1438 fail:
1439 mptscsih_freeChainBuffers(ioc, my_idx);
1440 mpt_free_msg_frame(ioc, mf);
1441 return SCSI_MLQUEUE_HOST_BUSY;
1442 }
1443
1444 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1445 /*
1446 * mptscsih_freeChainBuffers - Function to free chain buffers associated
1447 * with a SCSI IO request
1448 * @hd: Pointer to the MPT_SCSI_HOST instance
1449 * @req_idx: Index of the SCSI IO request frame.
1450 *
1451 * Called if SG chain buffer allocation fails and mptscsih callbacks.
1452 * No return.
1453 */
1454 static void
mptscsih_freeChainBuffers(MPT_ADAPTER * ioc,int req_idx)1455 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
1456 {
1457 MPT_FRAME_HDR *chain;
1458 unsigned long flags;
1459 int chain_idx;
1460 int next;
1461
1462 /* Get the first chain index and reset
1463 * tracker state.
1464 */
1465 chain_idx = ioc->ReqToChain[req_idx];
1466 ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN;
1467
1468 while (chain_idx != MPT_HOST_NO_CHAIN) {
1469
1470 /* Save the next chain buffer index */
1471 next = ioc->ChainToChain[chain_idx];
1472
1473 /* Free this chain buffer and reset
1474 * tracker
1475 */
1476 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN;
1477
1478 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer
1479 + (chain_idx * ioc->req_sz));
1480
1481 spin_lock_irqsave(&ioc->FreeQlock, flags);
1482 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);
1483 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1484
1485 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FreeChainBuffers (index %d)\n",
1486 ioc->name, chain_idx));
1487
1488 /* handle next */
1489 chain_idx = next;
1490 }
1491 return;
1492 }
1493
1494 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1495 /*
1496 * Reset Handling
1497 */
1498
1499 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1500 /**
1501 * mptscsih_IssueTaskMgmt - Generic send Task Management function.
1502 * @hd: Pointer to MPT_SCSI_HOST structure
1503 * @type: Task Management type
1504 * @channel: channel number for task management
1505 * @id: Logical Target ID for reset (if appropriate)
1506 * @lun: Logical Unit for reset (if appropriate)
1507 * @ctx2abort: Context for the task to be aborted (if appropriate)
1508 * @timeout: timeout for task management control
1509 *
1510 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
1511 * or a non-interrupt thread. In the former, must not call schedule().
1512 *
1513 * Not all fields are meaningfull for all task types.
1514 *
1515 * Returns 0 for SUCCESS, or FAILED.
1516 *
1517 **/
1518 int
mptscsih_IssueTaskMgmt(MPT_SCSI_HOST * hd,u8 type,u8 channel,u8 id,u64 lun,int ctx2abort,ulong timeout)1519 mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, u64 lun,
1520 int ctx2abort, ulong timeout)
1521 {
1522 MPT_FRAME_HDR *mf;
1523 SCSITaskMgmt_t *pScsiTm;
1524 int ii;
1525 int retval;
1526 MPT_ADAPTER *ioc = hd->ioc;
1527 unsigned long timeleft;
1528 u8 issue_hard_reset;
1529 u32 ioc_raw_state;
1530 unsigned long time_count;
1531
1532 issue_hard_reset = 0;
1533 ioc_raw_state = mpt_GetIocState(ioc, 0);
1534
1535 if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
1536 printk(MYIOC_s_WARN_FMT
1537 "TaskMgmt type=%x: IOC Not operational (0x%x)!\n",
1538 ioc->name, type, ioc_raw_state);
1539 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
1540 ioc->name, __func__);
1541 if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
1542 printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset "
1543 "FAILED!!\n", ioc->name);
1544 return 0;
1545 }
1546
1547 /* DOORBELL ACTIVE check is not required if
1548 * MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q is supported.
1549 */
1550
1551 if (!((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q)
1552 && (ioc->facts.MsgVersion >= MPI_VERSION_01_05)) &&
1553 (ioc_raw_state & MPI_DOORBELL_ACTIVE)) {
1554 printk(MYIOC_s_WARN_FMT
1555 "TaskMgmt type=%x: ioc_state: "
1556 "DOORBELL_ACTIVE (0x%x)!\n",
1557 ioc->name, type, ioc_raw_state);
1558 return FAILED;
1559 }
1560
1561 mutex_lock(&ioc->taskmgmt_cmds.mutex);
1562 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
1563 mf = NULL;
1564 retval = FAILED;
1565 goto out;
1566 }
1567
1568 /* Return Fail to calling function if no message frames available.
1569 */
1570 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
1571 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1572 "TaskMgmt no msg frames!!\n", ioc->name));
1573 retval = FAILED;
1574 mpt_clear_taskmgmt_in_progress_flag(ioc);
1575 goto out;
1576 }
1577 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1578 ioc->name, mf));
1579
1580 /* Format the Request
1581 */
1582 pScsiTm = (SCSITaskMgmt_t *) mf;
1583 pScsiTm->TargetID = id;
1584 pScsiTm->Bus = channel;
1585 pScsiTm->ChainOffset = 0;
1586 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1587
1588 pScsiTm->Reserved = 0;
1589 pScsiTm->TaskType = type;
1590 pScsiTm->Reserved1 = 0;
1591 pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
1592 ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
1593
1594 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
1595
1596 for (ii=0; ii < 7; ii++)
1597 pScsiTm->Reserved2[ii] = 0;
1598
1599 pScsiTm->TaskMsgContext = ctx2abort;
1600
1601 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) "
1602 "task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort,
1603 type, timeout));
1604
1605 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
1606
1607 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1608 time_count = jiffies;
1609 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
1610 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
1611 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
1612 else {
1613 retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
1614 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
1615 if (retval) {
1616 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1617 "TaskMgmt handshake FAILED!(mf=%p, rc=%d) \n",
1618 ioc->name, mf, retval));
1619 mpt_free_msg_frame(ioc, mf);
1620 mpt_clear_taskmgmt_in_progress_flag(ioc);
1621 goto out;
1622 }
1623 }
1624
1625 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
1626 timeout*HZ);
1627 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
1628 retval = FAILED;
1629 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
1630 "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf));
1631 mpt_clear_taskmgmt_in_progress_flag(ioc);
1632 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
1633 goto out;
1634 issue_hard_reset = 1;
1635 goto out;
1636 }
1637
1638 retval = mptscsih_taskmgmt_reply(ioc, type,
1639 (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply);
1640
1641 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1642 "TaskMgmt completed (%d seconds)\n",
1643 ioc->name, jiffies_to_msecs(jiffies - time_count)/1000));
1644
1645 out:
1646
1647 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1648 if (issue_hard_reset) {
1649 printk(MYIOC_s_WARN_FMT
1650 "Issuing Reset from %s!! doorbell=0x%08x\n",
1651 ioc->name, __func__, mpt_GetIocState(ioc, 0));
1652 retval = (ioc->bus_type == SAS) ?
1653 mpt_HardResetHandler(ioc, CAN_SLEEP) :
1654 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
1655 mpt_free_msg_frame(ioc, mf);
1656 }
1657
1658 retval = (retval == 0) ? 0 : FAILED;
1659 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
1660 return retval;
1661 }
1662 EXPORT_SYMBOL(mptscsih_IssueTaskMgmt);
1663
1664 static int
mptscsih_get_tm_timeout(MPT_ADAPTER * ioc)1665 mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
1666 {
1667 switch (ioc->bus_type) {
1668 case FC:
1669 return 40;
1670 case SAS:
1671 return 30;
1672 case SPI:
1673 default:
1674 return 10;
1675 }
1676 }
1677
1678 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1679 /**
1680 * mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant
1681 * @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted
1682 *
1683 * (linux scsi_host_template.eh_abort_handler routine)
1684 *
1685 * Returns SUCCESS or FAILED.
1686 **/
1687 int
mptscsih_abort(struct scsi_cmnd * SCpnt)1688 mptscsih_abort(struct scsi_cmnd * SCpnt)
1689 {
1690 MPT_SCSI_HOST *hd;
1691 MPT_FRAME_HDR *mf;
1692 u32 ctx2abort;
1693 int scpnt_idx;
1694 int retval;
1695 VirtDevice *vdevice;
1696 MPT_ADAPTER *ioc;
1697
1698 /* If we can't locate our host adapter structure, return FAILED status.
1699 */
1700 if ((hd = shost_priv(SCpnt->device->host)) == NULL) {
1701 SCpnt->result = DID_RESET << 16;
1702 SCpnt->scsi_done(SCpnt);
1703 printk(KERN_ERR MYNAM ": task abort: "
1704 "can't locate host! (sc=%p)\n", SCpnt);
1705 return FAILED;
1706 }
1707
1708 ioc = hd->ioc;
1709 printk(MYIOC_s_INFO_FMT "attempting task abort! (sc=%p)\n",
1710 ioc->name, SCpnt);
1711 scsi_print_command(SCpnt);
1712
1713 vdevice = SCpnt->device->hostdata;
1714 if (!vdevice || !vdevice->vtarget) {
1715 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1716 "task abort: device has been deleted (sc=%p)\n",
1717 ioc->name, SCpnt));
1718 SCpnt->result = DID_NO_CONNECT << 16;
1719 SCpnt->scsi_done(SCpnt);
1720 retval = SUCCESS;
1721 goto out;
1722 }
1723
1724 /* Task aborts are not supported for hidden raid components.
1725 */
1726 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1727 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1728 "task abort: hidden raid component (sc=%p)\n",
1729 ioc->name, SCpnt));
1730 SCpnt->result = DID_RESET << 16;
1731 retval = FAILED;
1732 goto out;
1733 }
1734
1735 /* Task aborts are not supported for volumes.
1736 */
1737 if (vdevice->vtarget->raidVolume) {
1738 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1739 "task abort: raid volume (sc=%p)\n",
1740 ioc->name, SCpnt));
1741 SCpnt->result = DID_RESET << 16;
1742 retval = FAILED;
1743 goto out;
1744 }
1745
1746 /* Find this command
1747 */
1748 if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
1749 /* Cmd not found in ScsiLookup.
1750 * Do OS callback.
1751 */
1752 SCpnt->result = DID_RESET << 16;
1753 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
1754 "Command not in the active list! (sc=%p)\n", ioc->name,
1755 SCpnt));
1756 retval = SUCCESS;
1757 goto out;
1758 }
1759
1760 if (ioc->timeouts < -1)
1761 ioc->timeouts++;
1762
1763 if (mpt_fwfault_debug)
1764 mpt_halt_firmware(ioc);
1765
1766 /* Most important! Set TaskMsgContext to SCpnt's MsgContext!
1767 * (the IO to be ABORT'd)
1768 *
1769 * NOTE: Since we do not byteswap MsgContext, we do not
1770 * swap it here either. It is an opaque cookie to
1771 * the controller, so it does not matter. -DaveM
1772 */
1773 mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx);
1774 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
1775 retval = mptscsih_IssueTaskMgmt(hd,
1776 MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1777 vdevice->vtarget->channel,
1778 vdevice->vtarget->id, vdevice->lun,
1779 ctx2abort, mptscsih_get_tm_timeout(ioc));
1780
1781 if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx) {
1782 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1783 "task abort: command still in active list! (sc=%p)\n",
1784 ioc->name, SCpnt));
1785 retval = FAILED;
1786 } else {
1787 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1788 "task abort: command cleared from active list! (sc=%p)\n",
1789 ioc->name, SCpnt));
1790 retval = SUCCESS;
1791 }
1792
1793 out:
1794 printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p)\n",
1795 ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), retval,
1796 SCpnt);
1797
1798 return retval;
1799 }
1800
1801 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1802 /**
1803 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant
1804 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1805 *
1806 * (linux scsi_host_template.eh_dev_reset_handler routine)
1807 *
1808 * Returns SUCCESS or FAILED.
1809 **/
1810 int
mptscsih_dev_reset(struct scsi_cmnd * SCpnt)1811 mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1812 {
1813 MPT_SCSI_HOST *hd;
1814 int retval;
1815 VirtDevice *vdevice;
1816 MPT_ADAPTER *ioc;
1817
1818 /* If we can't locate our host adapter structure, return FAILED status.
1819 */
1820 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1821 printk(KERN_ERR MYNAM ": target reset: "
1822 "Can't locate host! (sc=%p)\n", SCpnt);
1823 return FAILED;
1824 }
1825
1826 ioc = hd->ioc;
1827 printk(MYIOC_s_INFO_FMT "attempting target reset! (sc=%p)\n",
1828 ioc->name, SCpnt);
1829 scsi_print_command(SCpnt);
1830
1831 vdevice = SCpnt->device->hostdata;
1832 if (!vdevice || !vdevice->vtarget) {
1833 retval = 0;
1834 goto out;
1835 }
1836
1837 /* Target reset to hidden raid component is not supported
1838 */
1839 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1840 retval = FAILED;
1841 goto out;
1842 }
1843
1844 retval = mptscsih_IssueTaskMgmt(hd,
1845 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1846 vdevice->vtarget->channel,
1847 vdevice->vtarget->id, 0, 0,
1848 mptscsih_get_tm_timeout(ioc));
1849
1850 out:
1851 printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
1852 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1853
1854 if (retval == 0)
1855 return SUCCESS;
1856 else
1857 return FAILED;
1858 }
1859
1860
1861 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1862 /**
1863 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant
1864 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1865 *
1866 * (linux scsi_host_template.eh_bus_reset_handler routine)
1867 *
1868 * Returns SUCCESS or FAILED.
1869 **/
1870 int
mptscsih_bus_reset(struct scsi_cmnd * SCpnt)1871 mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1872 {
1873 MPT_SCSI_HOST *hd;
1874 int retval;
1875 VirtDevice *vdevice;
1876 MPT_ADAPTER *ioc;
1877
1878 /* If we can't locate our host adapter structure, return FAILED status.
1879 */
1880 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1881 printk(KERN_ERR MYNAM ": bus reset: "
1882 "Can't locate host! (sc=%p)\n", SCpnt);
1883 return FAILED;
1884 }
1885
1886 ioc = hd->ioc;
1887 printk(MYIOC_s_INFO_FMT "attempting bus reset! (sc=%p)\n",
1888 ioc->name, SCpnt);
1889 scsi_print_command(SCpnt);
1890
1891 if (ioc->timeouts < -1)
1892 ioc->timeouts++;
1893
1894 vdevice = SCpnt->device->hostdata;
1895 if (!vdevice || !vdevice->vtarget)
1896 return SUCCESS;
1897 retval = mptscsih_IssueTaskMgmt(hd,
1898 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1899 vdevice->vtarget->channel, 0, 0, 0,
1900 mptscsih_get_tm_timeout(ioc));
1901
1902 printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
1903 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1904
1905 if (retval == 0)
1906 return SUCCESS;
1907 else
1908 return FAILED;
1909 }
1910
1911 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1912 /**
1913 * mptscsih_host_reset - Perform a SCSI host adapter RESET (new_eh variant)
1914 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1915 *
1916 * (linux scsi_host_template.eh_host_reset_handler routine)
1917 *
1918 * Returns SUCCESS or FAILED.
1919 */
1920 int
mptscsih_host_reset(struct scsi_cmnd * SCpnt)1921 mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1922 {
1923 MPT_SCSI_HOST * hd;
1924 int status = SUCCESS;
1925 MPT_ADAPTER *ioc;
1926 int retval;
1927
1928 /* If we can't locate the host to reset, then we failed. */
1929 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1930 printk(KERN_ERR MYNAM ": host reset: "
1931 "Can't locate host! (sc=%p)\n", SCpnt);
1932 return FAILED;
1933 }
1934
1935 /* make sure we have no outstanding commands at this stage */
1936 mptscsih_flush_running_cmds(hd);
1937
1938 ioc = hd->ioc;
1939 printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
1940 ioc->name, SCpnt);
1941
1942 /* If our attempts to reset the host failed, then return a failed
1943 * status. The host will be taken off line by the SCSI mid-layer.
1944 */
1945 retval = mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
1946 if (retval < 0)
1947 status = FAILED;
1948 else
1949 status = SUCCESS;
1950
1951 printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
1952 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1953
1954 return status;
1955 }
1956
1957 static int
mptscsih_taskmgmt_reply(MPT_ADAPTER * ioc,u8 type,SCSITaskMgmtReply_t * pScsiTmReply)1958 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
1959 SCSITaskMgmtReply_t *pScsiTmReply)
1960 {
1961 u16 iocstatus;
1962 u32 termination_count;
1963 int retval;
1964
1965 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
1966 retval = FAILED;
1967 goto out;
1968 }
1969
1970 DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
1971
1972 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
1973 termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
1974
1975 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1976 "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
1977 "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
1978 "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
1979 pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
1980 le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
1981 termination_count));
1982
1983 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
1984 pScsiTmReply->ResponseCode)
1985 mptscsih_taskmgmt_response_code(ioc,
1986 pScsiTmReply->ResponseCode);
1987
1988 if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
1989 retval = 0;
1990 goto out;
1991 }
1992
1993 retval = FAILED;
1994 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1995 if (termination_count == 1)
1996 retval = 0;
1997 goto out;
1998 }
1999
2000 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
2001 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
2002 retval = 0;
2003
2004 out:
2005 return retval;
2006 }
2007
2008 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2009 void
mptscsih_taskmgmt_response_code(MPT_ADAPTER * ioc,u8 response_code)2010 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
2011 {
2012 char *desc;
2013
2014 switch (response_code) {
2015 case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
2016 desc = "The task completed.";
2017 break;
2018 case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
2019 desc = "The IOC received an invalid frame status.";
2020 break;
2021 case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2022 desc = "The task type is not supported.";
2023 break;
2024 case MPI_SCSITASKMGMT_RSP_TM_FAILED:
2025 desc = "The requested task failed.";
2026 break;
2027 case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2028 desc = "The task completed successfully.";
2029 break;
2030 case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2031 desc = "The LUN request is invalid.";
2032 break;
2033 case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2034 desc = "The task is in the IOC queue and has not been sent to target.";
2035 break;
2036 default:
2037 desc = "unknown";
2038 break;
2039 }
2040 printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
2041 ioc->name, response_code, desc);
2042 }
2043 EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
2044
2045 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2046 /**
2047 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2048 * @ioc: Pointer to MPT_ADAPTER structure
2049 * @mf: Pointer to SCSI task mgmt request frame
2050 * @mr: Pointer to SCSI task mgmt reply frame
2051 *
2052 * This routine is called from mptbase.c::mpt_interrupt() at the completion
2053 * of any SCSI task management request.
2054 * This routine is registered with the MPT (base) driver at driver
2055 * load/init time via the mpt_register() API call.
2056 *
2057 * Returns 1 indicating alloc'd request frame ptr should be freed.
2058 **/
2059 int
mptscsih_taskmgmt_complete(MPT_ADAPTER * ioc,MPT_FRAME_HDR * mf,MPT_FRAME_HDR * mr)2060 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
2061 MPT_FRAME_HDR *mr)
2062 {
2063 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2064 "TaskMgmt completed (mf=%p, mr=%p)\n", ioc->name, mf, mr));
2065
2066 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2067
2068 if (!mr)
2069 goto out;
2070
2071 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2072 memcpy(ioc->taskmgmt_cmds.reply, mr,
2073 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
2074 out:
2075 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
2076 mpt_clear_taskmgmt_in_progress_flag(ioc);
2077 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2078 complete(&ioc->taskmgmt_cmds.done);
2079 if (ioc->bus_type == SAS)
2080 ioc->schedule_target_reset(ioc);
2081 return 1;
2082 }
2083 return 0;
2084 }
2085
2086 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2087 /*
2088 * This is anyones guess quite frankly.
2089 */
2090 int
mptscsih_bios_param(struct scsi_device * sdev,struct block_device * bdev,sector_t capacity,int geom[])2091 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2092 sector_t capacity, int geom[])
2093 {
2094 int heads;
2095 int sectors;
2096 sector_t cylinders;
2097 ulong dummy;
2098
2099 heads = 64;
2100 sectors = 32;
2101
2102 dummy = heads * sectors;
2103 cylinders = capacity;
2104 sector_div(cylinders,dummy);
2105
2106 /*
2107 * Handle extended translation size for logical drives
2108 * > 1Gb
2109 */
2110 if ((ulong)capacity >= 0x200000) {
2111 heads = 255;
2112 sectors = 63;
2113 dummy = heads * sectors;
2114 cylinders = capacity;
2115 sector_div(cylinders,dummy);
2116 }
2117
2118 /* return result */
2119 geom[0] = heads;
2120 geom[1] = sectors;
2121 geom[2] = cylinders;
2122
2123 return 0;
2124 }
2125
2126 /* Search IOC page 3 to determine if this is hidden physical disk
2127 *
2128 */
2129 int
mptscsih_is_phys_disk(MPT_ADAPTER * ioc,u8 channel,u8 id)2130 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
2131 {
2132 struct inactive_raid_component_info *component_info;
2133 int i, j;
2134 RaidPhysDiskPage1_t *phys_disk;
2135 int rc = 0;
2136 int num_paths;
2137
2138 if (!ioc->raid_data.pIocPg3)
2139 goto out;
2140 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2141 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2142 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2143 rc = 1;
2144 goto out;
2145 }
2146 }
2147
2148 if (ioc->bus_type != SAS)
2149 goto out;
2150
2151 /*
2152 * Check if dual path
2153 */
2154 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2155 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2156 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2157 if (num_paths < 2)
2158 continue;
2159 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2160 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2161 if (!phys_disk)
2162 continue;
2163 if ((mpt_raid_phys_disk_pg1(ioc,
2164 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2165 phys_disk))) {
2166 kfree(phys_disk);
2167 continue;
2168 }
2169 for (j = 0; j < num_paths; j++) {
2170 if ((phys_disk->Path[j].Flags &
2171 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2172 continue;
2173 if ((phys_disk->Path[j].Flags &
2174 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2175 continue;
2176 if ((id == phys_disk->Path[j].PhysDiskID) &&
2177 (channel == phys_disk->Path[j].PhysDiskBus)) {
2178 rc = 1;
2179 kfree(phys_disk);
2180 goto out;
2181 }
2182 }
2183 kfree(phys_disk);
2184 }
2185
2186
2187 /*
2188 * Check inactive list for matching phys disks
2189 */
2190 if (list_empty(&ioc->raid_data.inactive_list))
2191 goto out;
2192
2193 mutex_lock(&ioc->raid_data.inactive_list_mutex);
2194 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2195 list) {
2196 if ((component_info->d.PhysDiskID == id) &&
2197 (component_info->d.PhysDiskBus == channel))
2198 rc = 1;
2199 }
2200 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2201
2202 out:
2203 return rc;
2204 }
2205 EXPORT_SYMBOL(mptscsih_is_phys_disk);
2206
2207 u8
mptscsih_raid_id_to_num(MPT_ADAPTER * ioc,u8 channel,u8 id)2208 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
2209 {
2210 struct inactive_raid_component_info *component_info;
2211 int i, j;
2212 RaidPhysDiskPage1_t *phys_disk;
2213 int rc = -ENXIO;
2214 int num_paths;
2215
2216 if (!ioc->raid_data.pIocPg3)
2217 goto out;
2218 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2219 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2220 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2221 rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
2222 goto out;
2223 }
2224 }
2225
2226 if (ioc->bus_type != SAS)
2227 goto out;
2228
2229 /*
2230 * Check if dual path
2231 */
2232 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2233 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2234 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2235 if (num_paths < 2)
2236 continue;
2237 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2238 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2239 if (!phys_disk)
2240 continue;
2241 if ((mpt_raid_phys_disk_pg1(ioc,
2242 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2243 phys_disk))) {
2244 kfree(phys_disk);
2245 continue;
2246 }
2247 for (j = 0; j < num_paths; j++) {
2248 if ((phys_disk->Path[j].Flags &
2249 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2250 continue;
2251 if ((phys_disk->Path[j].Flags &
2252 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2253 continue;
2254 if ((id == phys_disk->Path[j].PhysDiskID) &&
2255 (channel == phys_disk->Path[j].PhysDiskBus)) {
2256 rc = phys_disk->PhysDiskNum;
2257 kfree(phys_disk);
2258 goto out;
2259 }
2260 }
2261 kfree(phys_disk);
2262 }
2263
2264 /*
2265 * Check inactive list for matching phys disks
2266 */
2267 if (list_empty(&ioc->raid_data.inactive_list))
2268 goto out;
2269
2270 mutex_lock(&ioc->raid_data.inactive_list_mutex);
2271 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2272 list) {
2273 if ((component_info->d.PhysDiskID == id) &&
2274 (component_info->d.PhysDiskBus == channel))
2275 rc = component_info->d.PhysDiskNum;
2276 }
2277 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2278
2279 out:
2280 return rc;
2281 }
2282 EXPORT_SYMBOL(mptscsih_raid_id_to_num);
2283
2284 /*
2285 * OS entry point to allow for host driver to free allocated memory
2286 * Called if no device present or device being unloaded
2287 */
2288 void
mptscsih_slave_destroy(struct scsi_device * sdev)2289 mptscsih_slave_destroy(struct scsi_device *sdev)
2290 {
2291 struct Scsi_Host *host = sdev->host;
2292 MPT_SCSI_HOST *hd = shost_priv(host);
2293 VirtTarget *vtarget;
2294 VirtDevice *vdevice;
2295 struct scsi_target *starget;
2296
2297 starget = scsi_target(sdev);
2298 vtarget = starget->hostdata;
2299 vdevice = sdev->hostdata;
2300 if (!vdevice)
2301 return;
2302
2303 mptscsih_search_running_cmds(hd, vdevice);
2304 vtarget->num_luns--;
2305 mptscsih_synchronize_cache(hd, vdevice);
2306 kfree(vdevice);
2307 sdev->hostdata = NULL;
2308 }
2309
2310 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2311 /*
2312 * mptscsih_change_queue_depth - This function will set a devices queue depth
2313 * @sdev: per scsi_device pointer
2314 * @qdepth: requested queue depth
2315 *
2316 * Adding support for new 'change_queue_depth' api.
2317 */
2318 int
mptscsih_change_queue_depth(struct scsi_device * sdev,int qdepth)2319 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
2320 {
2321 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
2322 VirtTarget *vtarget;
2323 struct scsi_target *starget;
2324 int max_depth;
2325 MPT_ADAPTER *ioc = hd->ioc;
2326
2327 starget = scsi_target(sdev);
2328 vtarget = starget->hostdata;
2329
2330 if (ioc->bus_type == SPI) {
2331 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2332 max_depth = 1;
2333 else if (sdev->type == TYPE_DISK &&
2334 vtarget->minSyncFactor <= MPT_ULTRA160)
2335 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2336 else
2337 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
2338 } else
2339 max_depth = ioc->sh->can_queue;
2340
2341 if (!sdev->tagged_supported)
2342 max_depth = 1;
2343
2344 if (qdepth > max_depth)
2345 qdepth = max_depth;
2346
2347 return scsi_change_queue_depth(sdev, qdepth);
2348 }
2349
2350 /*
2351 * OS entry point to adjust the queue_depths on a per-device basis.
2352 * Called once per device the bus scan. Use it to force the queue_depth
2353 * member to 1 if a device does not support Q tags.
2354 * Return non-zero if fails.
2355 */
2356 int
mptscsih_slave_configure(struct scsi_device * sdev)2357 mptscsih_slave_configure(struct scsi_device *sdev)
2358 {
2359 struct Scsi_Host *sh = sdev->host;
2360 VirtTarget *vtarget;
2361 VirtDevice *vdevice;
2362 struct scsi_target *starget;
2363 MPT_SCSI_HOST *hd = shost_priv(sh);
2364 MPT_ADAPTER *ioc = hd->ioc;
2365
2366 starget = scsi_target(sdev);
2367 vtarget = starget->hostdata;
2368 vdevice = sdev->hostdata;
2369
2370 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2371 "device @ %p, channel=%d, id=%d, lun=%llu\n",
2372 ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
2373 if (ioc->bus_type == SPI)
2374 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2375 "sdtr %d wdtr %d ppr %d inq length=%d\n",
2376 ioc->name, sdev->sdtr, sdev->wdtr,
2377 sdev->ppr, sdev->inquiry_len));
2378
2379 vdevice->configured_lun = 1;
2380
2381 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2382 "Queue depth=%d, tflags=%x\n",
2383 ioc->name, sdev->queue_depth, vtarget->tflags));
2384
2385 if (ioc->bus_type == SPI)
2386 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2387 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
2388 ioc->name, vtarget->negoFlags, vtarget->maxOffset,
2389 vtarget->minSyncFactor));
2390
2391 mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
2392 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2393 "tagged %d, simple %d\n",
2394 ioc->name,sdev->tagged_supported, sdev->simple_tags));
2395
2396 blk_queue_dma_alignment (sdev->request_queue, 512 - 1);
2397
2398 return 0;
2399 }
2400
2401 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2402 /*
2403 * Private routines...
2404 */
2405
2406 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2407 /* Utility function to copy sense data from the scsi_cmnd buffer
2408 * to the FC and SCSI target structures.
2409 *
2410 */
2411 static void
mptscsih_copy_sense_data(struct scsi_cmnd * sc,MPT_SCSI_HOST * hd,MPT_FRAME_HDR * mf,SCSIIOReply_t * pScsiReply)2412 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
2413 {
2414 VirtDevice *vdevice;
2415 SCSIIORequest_t *pReq;
2416 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount);
2417 MPT_ADAPTER *ioc = hd->ioc;
2418
2419 /* Get target structure
2420 */
2421 pReq = (SCSIIORequest_t *) mf;
2422 vdevice = sc->device->hostdata;
2423
2424 if (sense_count) {
2425 u8 *sense_data;
2426 int req_index;
2427
2428 /* Copy the sense received into the scsi command block. */
2429 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2430 sense_data = ((u8 *)ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
2431 memcpy(sc->sense_buffer, sense_data, MPT_SENSE_BUFFER_ALLOC);
2432
2433 /* Log SMART data (asc = 0x5D, non-IM case only) if required.
2434 */
2435 if ((ioc->events) && (ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
2436 if ((sense_data[12] == 0x5D) && (vdevice->vtarget->raidVolume == 0)) {
2437 int idx;
2438
2439 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
2440 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2441 ioc->events[idx].eventContext = ioc->eventContext;
2442
2443 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) |
2444 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) |
2445 (sc->device->channel << 8) | sc->device->id;
2446
2447 ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
2448
2449 ioc->eventContext++;
2450 if (ioc->pcidev->vendor ==
2451 PCI_VENDOR_ID_IBM) {
2452 mptscsih_issue_sep_command(ioc,
2453 vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
2454 vdevice->vtarget->tflags |=
2455 MPT_TARGET_FLAGS_LED_ON;
2456 }
2457 }
2458 }
2459 } else {
2460 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
2461 ioc->name));
2462 }
2463 }
2464
2465 /**
2466 * mptscsih_get_scsi_lookup - retrieves scmd entry
2467 * @ioc: Pointer to MPT_ADAPTER structure
2468 * @i: index into the array
2469 *
2470 * Returns the scsi_cmd pointer
2471 */
2472 struct scsi_cmnd *
mptscsih_get_scsi_lookup(MPT_ADAPTER * ioc,int i)2473 mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
2474 {
2475 unsigned long flags;
2476 struct scsi_cmnd *scmd;
2477
2478 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2479 scmd = ioc->ScsiLookup[i];
2480 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2481
2482 return scmd;
2483 }
2484 EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
2485
2486 /**
2487 * mptscsih_getclear_scsi_lookup - retrieves and clears scmd entry from ScsiLookup[] array list
2488 * @ioc: Pointer to MPT_ADAPTER structure
2489 * @i: index into the array
2490 *
2491 * Returns the scsi_cmd pointer
2492 *
2493 **/
2494 static struct scsi_cmnd *
mptscsih_getclear_scsi_lookup(MPT_ADAPTER * ioc,int i)2495 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
2496 {
2497 unsigned long flags;
2498 struct scsi_cmnd *scmd;
2499
2500 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2501 scmd = ioc->ScsiLookup[i];
2502 ioc->ScsiLookup[i] = NULL;
2503 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2504
2505 return scmd;
2506 }
2507
2508 /**
2509 * mptscsih_set_scsi_lookup - write a scmd entry into the ScsiLookup[] array list
2510 *
2511 * @ioc: Pointer to MPT_ADAPTER structure
2512 * @i: index into the array
2513 * @scmd: scsi_cmnd pointer
2514 *
2515 **/
2516 static void
mptscsih_set_scsi_lookup(MPT_ADAPTER * ioc,int i,struct scsi_cmnd * scmd)2517 mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd)
2518 {
2519 unsigned long flags;
2520
2521 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2522 ioc->ScsiLookup[i] = scmd;
2523 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2524 }
2525
2526 /**
2527 * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
2528 * @ioc: Pointer to MPT_ADAPTER structure
2529 * @sc: scsi_cmnd pointer
2530 */
2531 static int
SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER * ioc,struct scsi_cmnd * sc)2532 SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
2533 {
2534 unsigned long flags;
2535 int i, index=-1;
2536
2537 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2538 for (i = 0; i < ioc->req_depth; i++) {
2539 if (ioc->ScsiLookup[i] == sc) {
2540 index = i;
2541 goto out;
2542 }
2543 }
2544
2545 out:
2546 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2547 return index;
2548 }
2549
2550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2551 int
mptscsih_ioc_reset(MPT_ADAPTER * ioc,int reset_phase)2552 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2553 {
2554 MPT_SCSI_HOST *hd;
2555
2556 if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
2557 return 0;
2558
2559 hd = shost_priv(ioc->sh);
2560 switch (reset_phase) {
2561 case MPT_IOC_SETUP_RESET:
2562 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2563 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
2564 break;
2565 case MPT_IOC_PRE_RESET:
2566 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2567 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
2568 mptscsih_flush_running_cmds(hd);
2569 break;
2570 case MPT_IOC_POST_RESET:
2571 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2572 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
2573 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
2574 ioc->internal_cmds.status |=
2575 MPT_MGMT_STATUS_DID_IOCRESET;
2576 complete(&ioc->internal_cmds.done);
2577 }
2578 break;
2579 default:
2580 break;
2581 }
2582 return 1; /* currently means nothing really */
2583 }
2584
2585 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2586 int
mptscsih_event_process(MPT_ADAPTER * ioc,EventNotificationReply_t * pEvReply)2587 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2588 {
2589 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2590
2591 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2592 "MPT event (=%02Xh) routed to SCSI host driver!\n",
2593 ioc->name, event));
2594
2595 if ((event == MPI_EVENT_IOC_BUS_RESET ||
2596 event == MPI_EVENT_EXT_BUS_RESET) &&
2597 (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
2598 ioc->soft_resets++;
2599
2600 return 1; /* currently means nothing really */
2601 }
2602
2603 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2604 /*
2605 * Bus Scan and Domain Validation functionality ...
2606 */
2607
2608 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2609 /*
2610 * mptscsih_scandv_complete - Scan and DV callback routine registered
2611 * to Fustion MPT (base) driver.
2612 *
2613 * @ioc: Pointer to MPT_ADAPTER structure
2614 * @mf: Pointer to original MPT request frame
2615 * @mr: Pointer to MPT reply frame (NULL if TurboReply)
2616 *
2617 * This routine is called from mpt.c::mpt_interrupt() at the completion
2618 * of any SCSI IO request.
2619 * This routine is registered with the Fusion MPT (base) driver at driver
2620 * load/init time via the mpt_register() API call.
2621 *
2622 * Returns 1 indicating alloc'd request frame ptr should be freed.
2623 *
2624 * Remark: Sets a completion code and (possibly) saves sense data
2625 * in the IOC member localReply structure.
2626 * Used ONLY for DV and other internal commands.
2627 */
2628 int
mptscsih_scandv_complete(MPT_ADAPTER * ioc,MPT_FRAME_HDR * req,MPT_FRAME_HDR * reply)2629 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2630 MPT_FRAME_HDR *reply)
2631 {
2632 SCSIIORequest_t *pReq;
2633 SCSIIOReply_t *pReply;
2634 u8 cmd;
2635 u16 req_idx;
2636 u8 *sense_data;
2637 int sz;
2638
2639 ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2640 ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
2641 if (!reply)
2642 goto out;
2643
2644 pReply = (SCSIIOReply_t *) reply;
2645 pReq = (SCSIIORequest_t *) req;
2646 ioc->internal_cmds.completion_code =
2647 mptscsih_get_completion_code(ioc, req, reply);
2648 ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2649 memcpy(ioc->internal_cmds.reply, reply,
2650 min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
2651 cmd = reply->u.hdr.Function;
2652 if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
2653 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
2654 (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
2655 req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
2656 sense_data = ((u8 *)ioc->sense_buf_pool +
2657 (req_idx * MPT_SENSE_BUFFER_ALLOC));
2658 sz = min_t(int, pReq->SenseBufferLength,
2659 MPT_SENSE_BUFFER_ALLOC);
2660 memcpy(ioc->internal_cmds.sense, sense_data, sz);
2661 }
2662 out:
2663 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
2664 return 0;
2665 ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2666 complete(&ioc->internal_cmds.done);
2667 return 1;
2668 }
2669
2670
2671 /**
2672 * mptscsih_get_completion_code - get completion code from MPT request
2673 * @ioc: Pointer to MPT_ADAPTER structure
2674 * @req: Pointer to original MPT request frame
2675 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
2676 *
2677 **/
2678 static int
mptscsih_get_completion_code(MPT_ADAPTER * ioc,MPT_FRAME_HDR * req,MPT_FRAME_HDR * reply)2679 mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2680 MPT_FRAME_HDR *reply)
2681 {
2682 SCSIIOReply_t *pReply;
2683 MpiRaidActionReply_t *pr;
2684 u8 scsi_status;
2685 u16 status;
2686 int completion_code;
2687
2688 pReply = (SCSIIOReply_t *)reply;
2689 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2690 scsi_status = pReply->SCSIStatus;
2691
2692 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2693 "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh,"
2694 "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState,
2695 scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
2696
2697 switch (status) {
2698
2699 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
2700 completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
2701 break;
2702
2703 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
2704 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
2705 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
2706 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
2707 completion_code = MPT_SCANDV_DID_RESET;
2708 break;
2709
2710 case MPI_IOCSTATUS_BUSY:
2711 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
2712 completion_code = MPT_SCANDV_BUSY;
2713 break;
2714
2715 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
2716 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
2717 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
2718 if (pReply->Function == MPI_FUNCTION_CONFIG) {
2719 completion_code = MPT_SCANDV_GOOD;
2720 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2721 pr = (MpiRaidActionReply_t *)reply;
2722 if (le16_to_cpu(pr->ActionStatus) ==
2723 MPI_RAID_ACTION_ASTATUS_SUCCESS)
2724 completion_code = MPT_SCANDV_GOOD;
2725 else
2726 completion_code = MPT_SCANDV_SOME_ERROR;
2727 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
2728 completion_code = MPT_SCANDV_SENSE;
2729 else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2730 if (req->u.scsireq.CDB[0] == INQUIRY)
2731 completion_code = MPT_SCANDV_ISSUE_SENSE;
2732 else
2733 completion_code = MPT_SCANDV_DID_RESET;
2734 } else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
2735 completion_code = MPT_SCANDV_DID_RESET;
2736 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2737 completion_code = MPT_SCANDV_DID_RESET;
2738 else if (scsi_status == MPI_SCSI_STATUS_BUSY)
2739 completion_code = MPT_SCANDV_BUSY;
2740 else
2741 completion_code = MPT_SCANDV_GOOD;
2742 break;
2743
2744 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
2745 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2746 completion_code = MPT_SCANDV_DID_RESET;
2747 else
2748 completion_code = MPT_SCANDV_SOME_ERROR;
2749 break;
2750 default:
2751 completion_code = MPT_SCANDV_SOME_ERROR;
2752 break;
2753
2754 } /* switch(status) */
2755
2756 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2757 " completionCode set to %08xh\n", ioc->name, completion_code));
2758 return completion_code;
2759 }
2760
2761 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2762 /**
2763 * mptscsih_do_cmd - Do internal command.
2764 * @hd: MPT_SCSI_HOST pointer
2765 * @io: INTERNAL_CMD pointer.
2766 *
2767 * Issue the specified internally generated command and do command
2768 * specific cleanup. For bus scan / DV only.
2769 * NOTES: If command is Inquiry and status is good,
2770 * initialize a target structure, save the data
2771 *
2772 * Remark: Single threaded access only.
2773 *
2774 * Return:
2775 * < 0 if an illegal command or no resources
2776 *
2777 * 0 if good
2778 *
2779 * > 0 if command complete but some type of completion error.
2780 */
2781 static int
mptscsih_do_cmd(MPT_SCSI_HOST * hd,INTERNAL_CMD * io)2782 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
2783 {
2784 MPT_FRAME_HDR *mf;
2785 SCSIIORequest_t *pScsiReq;
2786 int my_idx, ii, dir;
2787 int timeout;
2788 char cmdLen;
2789 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
2790 u8 cmd = io->cmd;
2791 MPT_ADAPTER *ioc = hd->ioc;
2792 int ret = 0;
2793 unsigned long timeleft;
2794 unsigned long flags;
2795
2796 /* don't send internal command during diag reset */
2797 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2798 if (ioc->ioc_reset_in_progress) {
2799 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2800 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2801 "%s: busy with host reset\n", ioc->name, __func__));
2802 return MPT_SCANDV_BUSY;
2803 }
2804 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2805
2806 mutex_lock(&ioc->internal_cmds.mutex);
2807
2808 /* Set command specific information
2809 */
2810 switch (cmd) {
2811 case INQUIRY:
2812 cmdLen = 6;
2813 dir = MPI_SCSIIO_CONTROL_READ;
2814 CDB[0] = cmd;
2815 CDB[4] = io->size;
2816 timeout = 10;
2817 break;
2818
2819 case TEST_UNIT_READY:
2820 cmdLen = 6;
2821 dir = MPI_SCSIIO_CONTROL_READ;
2822 timeout = 10;
2823 break;
2824
2825 case START_STOP:
2826 cmdLen = 6;
2827 dir = MPI_SCSIIO_CONTROL_READ;
2828 CDB[0] = cmd;
2829 CDB[4] = 1; /*Spin up the disk */
2830 timeout = 15;
2831 break;
2832
2833 case REQUEST_SENSE:
2834 cmdLen = 6;
2835 CDB[0] = cmd;
2836 CDB[4] = io->size;
2837 dir = MPI_SCSIIO_CONTROL_READ;
2838 timeout = 10;
2839 break;
2840
2841 case READ_BUFFER:
2842 cmdLen = 10;
2843 dir = MPI_SCSIIO_CONTROL_READ;
2844 CDB[0] = cmd;
2845 if (io->flags & MPT_ICFLAG_ECHO) {
2846 CDB[1] = 0x0A;
2847 } else {
2848 CDB[1] = 0x02;
2849 }
2850
2851 if (io->flags & MPT_ICFLAG_BUF_CAP) {
2852 CDB[1] |= 0x01;
2853 }
2854 CDB[6] = (io->size >> 16) & 0xFF;
2855 CDB[7] = (io->size >> 8) & 0xFF;
2856 CDB[8] = io->size & 0xFF;
2857 timeout = 10;
2858 break;
2859
2860 case WRITE_BUFFER:
2861 cmdLen = 10;
2862 dir = MPI_SCSIIO_CONTROL_WRITE;
2863 CDB[0] = cmd;
2864 if (io->flags & MPT_ICFLAG_ECHO) {
2865 CDB[1] = 0x0A;
2866 } else {
2867 CDB[1] = 0x02;
2868 }
2869 CDB[6] = (io->size >> 16) & 0xFF;
2870 CDB[7] = (io->size >> 8) & 0xFF;
2871 CDB[8] = io->size & 0xFF;
2872 timeout = 10;
2873 break;
2874
2875 case RESERVE:
2876 cmdLen = 6;
2877 dir = MPI_SCSIIO_CONTROL_READ;
2878 CDB[0] = cmd;
2879 timeout = 10;
2880 break;
2881
2882 case RELEASE:
2883 cmdLen = 6;
2884 dir = MPI_SCSIIO_CONTROL_READ;
2885 CDB[0] = cmd;
2886 timeout = 10;
2887 break;
2888
2889 case SYNCHRONIZE_CACHE:
2890 cmdLen = 10;
2891 dir = MPI_SCSIIO_CONTROL_READ;
2892 CDB[0] = cmd;
2893 // CDB[1] = 0x02; /* set immediate bit */
2894 timeout = 10;
2895 break;
2896
2897 default:
2898 /* Error Case */
2899 ret = -EFAULT;
2900 goto out;
2901 }
2902
2903 /* Get and Populate a free Frame
2904 * MsgContext set in mpt_get_msg_frame call
2905 */
2906 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
2907 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
2908 ioc->name, __func__));
2909 ret = MPT_SCANDV_BUSY;
2910 goto out;
2911 }
2912
2913 pScsiReq = (SCSIIORequest_t *) mf;
2914
2915 /* Get the request index */
2916 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2917 ADD_INDEX_LOG(my_idx); /* for debug */
2918
2919 if (io->flags & MPT_ICFLAG_PHYS_DISK) {
2920 pScsiReq->TargetID = io->physDiskNum;
2921 pScsiReq->Bus = 0;
2922 pScsiReq->ChainOffset = 0;
2923 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
2924 } else {
2925 pScsiReq->TargetID = io->id;
2926 pScsiReq->Bus = io->channel;
2927 pScsiReq->ChainOffset = 0;
2928 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
2929 }
2930
2931 pScsiReq->CDBLength = cmdLen;
2932 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2933
2934 pScsiReq->Reserved = 0;
2935
2936 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
2937 /* MsgContext set in mpt_get_msg_fram call */
2938
2939 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
2940
2941 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
2942 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
2943 else
2944 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2945
2946 if (cmd == REQUEST_SENSE) {
2947 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2948 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2949 "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd));
2950 }
2951
2952 for (ii = 0; ii < 16; ii++)
2953 pScsiReq->CDB[ii] = CDB[ii];
2954
2955 pScsiReq->DataLength = cpu_to_le32(io->size);
2956 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
2957 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
2958
2959 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2960 "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%llu\n",
2961 ioc->name, __func__, cmd, io->channel, io->id, io->lun));
2962
2963 if (dir == MPI_SCSIIO_CONTROL_READ)
2964 ioc->add_sge((char *) &pScsiReq->SGL,
2965 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
2966 else
2967 ioc->add_sge((char *) &pScsiReq->SGL,
2968 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
2969
2970 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
2971 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
2972 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
2973 timeout*HZ);
2974 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2975 ret = MPT_SCANDV_DID_RESET;
2976 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2977 "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__,
2978 cmd));
2979 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2980 mpt_free_msg_frame(ioc, mf);
2981 goto out;
2982 }
2983 if (!timeleft) {
2984 printk(MYIOC_s_WARN_FMT
2985 "Issuing Reset from %s!! doorbell=0x%08xh"
2986 " cmd=0x%02x\n",
2987 ioc->name, __func__, mpt_GetIocState(ioc, 0),
2988 cmd);
2989 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2990 mpt_free_msg_frame(ioc, mf);
2991 }
2992 goto out;
2993 }
2994
2995 ret = ioc->internal_cmds.completion_code;
2996 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
2997 ioc->name, __func__, ret));
2998
2999 out:
3000 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
3001 mutex_unlock(&ioc->internal_cmds.mutex);
3002 return ret;
3003 }
3004
3005 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3006 /**
3007 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3008 * @hd: Pointer to a SCSI HOST structure
3009 * @vdevice: virtual target device
3010 *
3011 * Uses the ISR, but with special processing.
3012 * MUST be single-threaded.
3013 *
3014 */
3015 static void
mptscsih_synchronize_cache(MPT_SCSI_HOST * hd,VirtDevice * vdevice)3016 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3017 {
3018 INTERNAL_CMD iocmd;
3019
3020 /* Ignore hidden raid components, this is handled when the command
3021 * is sent to the volume
3022 */
3023 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
3024 return;
3025
3026 if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted ||
3027 !vdevice->configured_lun)
3028 return;
3029
3030 /* Following parameters will not change
3031 * in this routine.
3032 */
3033 iocmd.cmd = SYNCHRONIZE_CACHE;
3034 iocmd.flags = 0;
3035 iocmd.physDiskNum = -1;
3036 iocmd.data = NULL;
3037 iocmd.data_dma = -1;
3038 iocmd.size = 0;
3039 iocmd.rsvd = iocmd.rsvd2 = 0;
3040 iocmd.channel = vdevice->vtarget->channel;
3041 iocmd.id = vdevice->vtarget->id;
3042 iocmd.lun = vdevice->lun;
3043
3044 mptscsih_do_cmd(hd, &iocmd);
3045 }
3046
3047 static ssize_t
mptscsih_version_fw_show(struct device * dev,struct device_attribute * attr,char * buf)3048 mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
3049 char *buf)
3050 {
3051 struct Scsi_Host *host = class_to_shost(dev);
3052 MPT_SCSI_HOST *hd = shost_priv(host);
3053 MPT_ADAPTER *ioc = hd->ioc;
3054
3055 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
3056 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3057 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3058 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3059 ioc->facts.FWVersion.Word & 0x000000FF);
3060 }
3061 static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
3062
3063 static ssize_t
mptscsih_version_bios_show(struct device * dev,struct device_attribute * attr,char * buf)3064 mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
3065 char *buf)
3066 {
3067 struct Scsi_Host *host = class_to_shost(dev);
3068 MPT_SCSI_HOST *hd = shost_priv(host);
3069 MPT_ADAPTER *ioc = hd->ioc;
3070
3071 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
3072 (ioc->biosVersion & 0xFF000000) >> 24,
3073 (ioc->biosVersion & 0x00FF0000) >> 16,
3074 (ioc->biosVersion & 0x0000FF00) >> 8,
3075 ioc->biosVersion & 0x000000FF);
3076 }
3077 static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
3078
3079 static ssize_t
mptscsih_version_mpi_show(struct device * dev,struct device_attribute * attr,char * buf)3080 mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
3081 char *buf)
3082 {
3083 struct Scsi_Host *host = class_to_shost(dev);
3084 MPT_SCSI_HOST *hd = shost_priv(host);
3085 MPT_ADAPTER *ioc = hd->ioc;
3086
3087 return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
3088 }
3089 static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
3090
3091 static ssize_t
mptscsih_version_product_show(struct device * dev,struct device_attribute * attr,char * buf)3092 mptscsih_version_product_show(struct device *dev,
3093 struct device_attribute *attr,
3094 char *buf)
3095 {
3096 struct Scsi_Host *host = class_to_shost(dev);
3097 MPT_SCSI_HOST *hd = shost_priv(host);
3098 MPT_ADAPTER *ioc = hd->ioc;
3099
3100 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
3101 }
3102 static DEVICE_ATTR(version_product, S_IRUGO,
3103 mptscsih_version_product_show, NULL);
3104
3105 static ssize_t
mptscsih_version_nvdata_persistent_show(struct device * dev,struct device_attribute * attr,char * buf)3106 mptscsih_version_nvdata_persistent_show(struct device *dev,
3107 struct device_attribute *attr,
3108 char *buf)
3109 {
3110 struct Scsi_Host *host = class_to_shost(dev);
3111 MPT_SCSI_HOST *hd = shost_priv(host);
3112 MPT_ADAPTER *ioc = hd->ioc;
3113
3114 return snprintf(buf, PAGE_SIZE, "%02xh\n",
3115 ioc->nvdata_version_persistent);
3116 }
3117 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
3118 mptscsih_version_nvdata_persistent_show, NULL);
3119
3120 static ssize_t
mptscsih_version_nvdata_default_show(struct device * dev,struct device_attribute * attr,char * buf)3121 mptscsih_version_nvdata_default_show(struct device *dev,
3122 struct device_attribute *attr, char *buf)
3123 {
3124 struct Scsi_Host *host = class_to_shost(dev);
3125 MPT_SCSI_HOST *hd = shost_priv(host);
3126 MPT_ADAPTER *ioc = hd->ioc;
3127
3128 return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
3129 }
3130 static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
3131 mptscsih_version_nvdata_default_show, NULL);
3132
3133 static ssize_t
mptscsih_board_name_show(struct device * dev,struct device_attribute * attr,char * buf)3134 mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
3135 char *buf)
3136 {
3137 struct Scsi_Host *host = class_to_shost(dev);
3138 MPT_SCSI_HOST *hd = shost_priv(host);
3139 MPT_ADAPTER *ioc = hd->ioc;
3140
3141 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
3142 }
3143 static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
3144
3145 static ssize_t
mptscsih_board_assembly_show(struct device * dev,struct device_attribute * attr,char * buf)3146 mptscsih_board_assembly_show(struct device *dev,
3147 struct device_attribute *attr, char *buf)
3148 {
3149 struct Scsi_Host *host = class_to_shost(dev);
3150 MPT_SCSI_HOST *hd = shost_priv(host);
3151 MPT_ADAPTER *ioc = hd->ioc;
3152
3153 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
3154 }
3155 static DEVICE_ATTR(board_assembly, S_IRUGO,
3156 mptscsih_board_assembly_show, NULL);
3157
3158 static ssize_t
mptscsih_board_tracer_show(struct device * dev,struct device_attribute * attr,char * buf)3159 mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
3160 char *buf)
3161 {
3162 struct Scsi_Host *host = class_to_shost(dev);
3163 MPT_SCSI_HOST *hd = shost_priv(host);
3164 MPT_ADAPTER *ioc = hd->ioc;
3165
3166 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
3167 }
3168 static DEVICE_ATTR(board_tracer, S_IRUGO,
3169 mptscsih_board_tracer_show, NULL);
3170
3171 static ssize_t
mptscsih_io_delay_show(struct device * dev,struct device_attribute * attr,char * buf)3172 mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
3173 char *buf)
3174 {
3175 struct Scsi_Host *host = class_to_shost(dev);
3176 MPT_SCSI_HOST *hd = shost_priv(host);
3177 MPT_ADAPTER *ioc = hd->ioc;
3178
3179 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
3180 }
3181 static DEVICE_ATTR(io_delay, S_IRUGO,
3182 mptscsih_io_delay_show, NULL);
3183
3184 static ssize_t
mptscsih_device_delay_show(struct device * dev,struct device_attribute * attr,char * buf)3185 mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
3186 char *buf)
3187 {
3188 struct Scsi_Host *host = class_to_shost(dev);
3189 MPT_SCSI_HOST *hd = shost_priv(host);
3190 MPT_ADAPTER *ioc = hd->ioc;
3191
3192 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
3193 }
3194 static DEVICE_ATTR(device_delay, S_IRUGO,
3195 mptscsih_device_delay_show, NULL);
3196
3197 static ssize_t
mptscsih_debug_level_show(struct device * dev,struct device_attribute * attr,char * buf)3198 mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
3199 char *buf)
3200 {
3201 struct Scsi_Host *host = class_to_shost(dev);
3202 MPT_SCSI_HOST *hd = shost_priv(host);
3203 MPT_ADAPTER *ioc = hd->ioc;
3204
3205 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
3206 }
3207 static ssize_t
mptscsih_debug_level_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3208 mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
3209 const char *buf, size_t count)
3210 {
3211 struct Scsi_Host *host = class_to_shost(dev);
3212 MPT_SCSI_HOST *hd = shost_priv(host);
3213 MPT_ADAPTER *ioc = hd->ioc;
3214 int val = 0;
3215
3216 if (sscanf(buf, "%x", &val) != 1)
3217 return -EINVAL;
3218
3219 ioc->debug_level = val;
3220 printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
3221 ioc->name, ioc->debug_level);
3222 return strlen(buf);
3223 }
3224 static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
3225 mptscsih_debug_level_show, mptscsih_debug_level_store);
3226
3227 struct device_attribute *mptscsih_host_attrs[] = {
3228 &dev_attr_version_fw,
3229 &dev_attr_version_bios,
3230 &dev_attr_version_mpi,
3231 &dev_attr_version_product,
3232 &dev_attr_version_nvdata_persistent,
3233 &dev_attr_version_nvdata_default,
3234 &dev_attr_board_name,
3235 &dev_attr_board_assembly,
3236 &dev_attr_board_tracer,
3237 &dev_attr_io_delay,
3238 &dev_attr_device_delay,
3239 &dev_attr_debug_level,
3240 NULL,
3241 };
3242
3243 EXPORT_SYMBOL(mptscsih_host_attrs);
3244
3245 EXPORT_SYMBOL(mptscsih_remove);
3246 EXPORT_SYMBOL(mptscsih_shutdown);
3247 #ifdef CONFIG_PM
3248 EXPORT_SYMBOL(mptscsih_suspend);
3249 EXPORT_SYMBOL(mptscsih_resume);
3250 #endif
3251 EXPORT_SYMBOL(mptscsih_show_info);
3252 EXPORT_SYMBOL(mptscsih_info);
3253 EXPORT_SYMBOL(mptscsih_qcmd);
3254 EXPORT_SYMBOL(mptscsih_slave_destroy);
3255 EXPORT_SYMBOL(mptscsih_slave_configure);
3256 EXPORT_SYMBOL(mptscsih_abort);
3257 EXPORT_SYMBOL(mptscsih_dev_reset);
3258 EXPORT_SYMBOL(mptscsih_bus_reset);
3259 EXPORT_SYMBOL(mptscsih_host_reset);
3260 EXPORT_SYMBOL(mptscsih_bios_param);
3261 EXPORT_SYMBOL(mptscsih_io_done);
3262 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3263 EXPORT_SYMBOL(mptscsih_scandv_complete);
3264 EXPORT_SYMBOL(mptscsih_event_process);
3265 EXPORT_SYMBOL(mptscsih_ioc_reset);
3266 EXPORT_SYMBOL(mptscsih_change_queue_depth);
3267
3268 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3269