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