?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] mpt fusion: Added support for Broadcast primitives Event handling
[linux-2.6/x86.git] / drivers / message / fusion / mptscsih.c
blob96681203d4a960475f53501f994e740f6792c8e4
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
2446 *
2447 * retrieves and clears scmd entry from ScsiLookup[] array list
2448 *
2449 * @ioc: Pointer to MPT_ADAPTER structure
2450 * @i: index into the array
2451 *
2452 * Returns the scsi_cmd pointer
2453 *
2454 **/
2455 static struct scsi_cmnd *
2456 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
2457 {
2458 unsigned long flags;
2459 struct scsi_cmnd *scmd;
2460
2461 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2462 scmd = ioc->ScsiLookup[i];
2463 ioc->ScsiLookup[i] = NULL;
2464 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2465
2466 return scmd;
2467 }
2468
2469 /**
2470 * mptscsih_set_scsi_lookup
2471 *
2472 * writes a scmd entry into the ScsiLookup[] array list
2473 *
2474 * @ioc: Pointer to MPT_ADAPTER structure
2475 * @i: index into the array
2476 * @scmd: scsi_cmnd pointer
2477 *
2478 **/
2479 static void
2480 mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd)
2481 {
2482 unsigned long flags;
2483
2484 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2485 ioc->ScsiLookup[i] = scmd;
2486 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2487 }
2488
2489 /**
2490 * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
2491 * @ioc: Pointer to MPT_ADAPTER structure
2492 * @sc: scsi_cmnd pointer
2493 */
2494 static int
2495 SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
2496 {
2497 unsigned long flags;
2498 int i, index=-1;
2499
2500 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2501 for (i = 0; i < ioc->req_depth; i++) {
2502 if (ioc->ScsiLookup[i] == sc) {
2503 index = i;
2504 goto out;
2505 }
2506 }
2507
2508 out:
2509 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2510 return index;
2511 }
2512
2513 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2514 int
2515 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2516 {
2517 MPT_SCSI_HOST *hd;
2518
2519 if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
2520 return 0;
2521
2522 hd = shost_priv(ioc->sh);
2523 switch (reset_phase) {
2524 case MPT_IOC_SETUP_RESET:
2525 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2526 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
2527 break;
2528 case MPT_IOC_PRE_RESET:
2529 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2530 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
2531 mptscsih_flush_running_cmds(hd);
2532 break;
2533 case MPT_IOC_POST_RESET:
2534 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2535 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
2536 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
2537 ioc->internal_cmds.status |=
2538 MPT_MGMT_STATUS_DID_IOCRESET;
2539 complete(&ioc->internal_cmds.done);
2540 }
2541 break;
2542 default:
2543 break;
2544 }
2545 return 1; /* currently means nothing really */
2546 }
2547
2548 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2549 int
2550 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2551 {
2552 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2553
2554 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2555 "MPT event (=%02Xh) routed to SCSI host driver!\n",
2556 ioc->name, event));
2557
2558 if ((event == MPI_EVENT_IOC_BUS_RESET ||
2559 event == MPI_EVENT_EXT_BUS_RESET) &&
2560 (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
2561 ioc->soft_resets++;
2562
2563 return 1; /* currently means nothing really */
2564 }
2565
2566 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2567 /*
2568 * Bus Scan and Domain Validation functionality ...
2569 */
2570
2571 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2572 /*
2573 * mptscsih_scandv_complete - Scan and DV callback routine registered
2574 * to Fustion MPT (base) driver.
2575 *
2576 * @ioc: Pointer to MPT_ADAPTER structure
2577 * @mf: Pointer to original MPT request frame
2578 * @mr: Pointer to MPT reply frame (NULL if TurboReply)
2579 *
2580 * This routine is called from mpt.c::mpt_interrupt() at the completion
2581 * of any SCSI IO request.
2582 * This routine is registered with the Fusion MPT (base) driver at driver
2583 * load/init time via the mpt_register() API call.
2584 *
2585 * Returns 1 indicating alloc'd request frame ptr should be freed.
2586 *
2587 * Remark: Sets a completion code and (possibly) saves sense data
2588 * in the IOC member localReply structure.
2589 * Used ONLY for DV and other internal commands.
2590 */
2591 int
2592 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2593 MPT_FRAME_HDR *reply)
2594 {
2595 SCSIIORequest_t *pReq;
2596 SCSIIOReply_t *pReply;
2597 u8 cmd;
2598 u16 req_idx;
2599 u8 *sense_data;
2600 int sz;
2601
2602 ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2603 ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
2604 if (!reply)
2605 goto out;
2606
2607 pReply = (SCSIIOReply_t *) reply;
2608 pReq = (SCSIIORequest_t *) req;
2609 ioc->internal_cmds.completion_code =
2610 mptscsih_get_completion_code(ioc, req, reply);
2611 ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2612 memcpy(ioc->internal_cmds.reply, reply,
2613 min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
2614 cmd = reply->u.hdr.Function;
2615 if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
2616 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
2617 (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
2618 req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
2619 sense_data = ((u8 *)ioc->sense_buf_pool +
2620 (req_idx * MPT_SENSE_BUFFER_ALLOC));
2621 sz = min_t(int, pReq->SenseBufferLength,
2622 MPT_SENSE_BUFFER_ALLOC);
2623 memcpy(ioc->internal_cmds.sense, sense_data, sz);
2624 }
2625 out:
2626 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
2627 return 0;
2628 ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2629 complete(&ioc->internal_cmds.done);
2630 return 1;
2631 }
2632
2633 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2634 /* mptscsih_timer_expired - Call back for timer process.
2635 * Used only for dv functionality.
2636 * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
2637 *
2638 */
2639 void
2640 mptscsih_timer_expired(unsigned long data)
2641 {
2642 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) data;
2643 MPT_ADAPTER *ioc = hd->ioc;
2644
2645 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Timer Expired! Cmd %p\n", ioc->name, hd->cmdPtr));
2646
2647 if (hd->cmdPtr) {
2648 MPIHeader_t *cmd = (MPIHeader_t *)hd->cmdPtr;
2649
2650 if (cmd->Function == MPI_FUNCTION_SCSI_IO_REQUEST) {
2651 /* Desire to issue a task management request here.
2652 * TM requests MUST be single threaded.
2653 * If old eh code and no TM current, issue request.
2654 * If new eh code, do nothing. Wait for OS cmd timeout
2655 * for bus reset.
2656 */
2657 } else {
2658 /* Perform a FW reload */
2659 if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0) {
2660 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
2661 }
2662 }
2663 } else {
2664 /* This should NEVER happen */
2665 printk(MYIOC_s_WARN_FMT "Null cmdPtr!!!!\n", ioc->name);
2666 }
2667
2668 /* No more processing.
2669 * TM call will generate an interrupt for SCSI TM Management.
2670 * The FW will reply to all outstanding commands, callback will finish cleanup.
2671 * Hard reset clean-up will free all resources.
2672 */
2673 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Timer Expired Complete!\n", ioc->name));
2674
2675 return;
2676 }
2677
2678 /**
2679 * mptscsih_get_completion_code -
2680 * @ioc: Pointer to MPT_ADAPTER structure
2681 * @reply:
2682 * @cmd:
2683 *
2684 **/
2685 static int
2686 mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2687 MPT_FRAME_HDR *reply)
2688 {
2689 SCSIIOReply_t *pReply;
2690 MpiRaidActionReply_t *pr;
2691 u8 scsi_status;
2692 u16 status;
2693 int completion_code;
2694
2695 pReply = (SCSIIOReply_t *)reply;
2696 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2697 scsi_status = pReply->SCSIStatus;
2698
2699 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2700 "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh,"
2701 "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState,
2702 scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
2703
2704 switch (status) {
2705
2706 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
2707 completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
2708 break;
2709
2710 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
2711 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
2712 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
2713 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
2714 completion_code = MPT_SCANDV_DID_RESET;
2715 break;
2716
2717 case MPI_IOCSTATUS_BUSY:
2718 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
2719 completion_code = MPT_SCANDV_BUSY;
2720 break;
2721
2722 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
2723 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
2724 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
2725 if (pReply->Function == MPI_FUNCTION_CONFIG) {
2726 completion_code = MPT_SCANDV_GOOD;
2727 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2728 pr = (MpiRaidActionReply_t *)reply;
2729 if (le16_to_cpu(pr->ActionStatus) ==
2730 MPI_RAID_ACTION_ASTATUS_SUCCESS)
2731 completion_code = MPT_SCANDV_GOOD;
2732 else
2733 completion_code = MPT_SCANDV_SOME_ERROR;
2734 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
2735 completion_code = MPT_SCANDV_SENSE;
2736 else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2737 if (req->u.scsireq.CDB[0] == INQUIRY)
2738 completion_code = MPT_SCANDV_ISSUE_SENSE;
2739 else
2740 completion_code = MPT_SCANDV_DID_RESET;
2741 } else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
2742 completion_code = MPT_SCANDV_DID_RESET;
2743 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2744 completion_code = MPT_SCANDV_DID_RESET;
2745 else if (scsi_status == MPI_SCSI_STATUS_BUSY)
2746 completion_code = MPT_SCANDV_BUSY;
2747 else
2748 completion_code = MPT_SCANDV_GOOD;
2749 break;
2750
2751 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
2752 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2753 completion_code = MPT_SCANDV_DID_RESET;
2754 else
2755 completion_code = MPT_SCANDV_SOME_ERROR;
2756 break;
2757 default:
2758 completion_code = MPT_SCANDV_SOME_ERROR;
2759 break;
2760
2761 } /* switch(status) */
2762
2763 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2764 " completionCode set to %08xh\n", ioc->name, completion_code));
2765 return completion_code;
2766 }
2767
2768 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2769 /**
2770 * mptscsih_do_cmd - Do internal command.
2771 * @hd: MPT_SCSI_HOST pointer
2772 * @io: INTERNAL_CMD pointer.
2773 *
2774 * Issue the specified internally generated command and do command
2775 * specific cleanup. For bus scan / DV only.
2776 * NOTES: If command is Inquiry and status is good,
2777 * initialize a target structure, save the data
2778 *
2779 * Remark: Single threaded access only.
2780 *
2781 * Return:
2782 * < 0 if an illegal command or no resources
2783 *
2784 * 0 if good
2785 *
2786 * > 0 if command complete but some type of completion error.
2787 */
2788 static int
2789 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
2790 {
2791 MPT_FRAME_HDR *mf;
2792 SCSIIORequest_t *pScsiReq;
2793 int my_idx, ii, dir;
2794 int timeout;
2795 char cmdLen;
2796 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
2797 u8 cmd = io->cmd;
2798 MPT_ADAPTER *ioc = hd->ioc;
2799 int ret = 0;
2800 unsigned long timeleft;
2801 unsigned long flags;
2802
2803 /* don't send internal command during diag reset */
2804 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2805 if (ioc->ioc_reset_in_progress) {
2806 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2807 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2808 "%s: busy with host reset\n", ioc->name, __func__));
2809 return MPT_SCANDV_BUSY;
2810 }
2811 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2812
2813 mutex_lock(&ioc->internal_cmds.mutex);
2814
2815 /* Set command specific information
2816 */
2817 switch (cmd) {
2818 case INQUIRY:
2819 cmdLen = 6;
2820 dir = MPI_SCSIIO_CONTROL_READ;
2821 CDB[0] = cmd;
2822 CDB[4] = io->size;
2823 timeout = 10;
2824 break;
2825
2826 case TEST_UNIT_READY:
2827 cmdLen = 6;
2828 dir = MPI_SCSIIO_CONTROL_READ;
2829 timeout = 10;
2830 break;
2831
2832 case START_STOP:
2833 cmdLen = 6;
2834 dir = MPI_SCSIIO_CONTROL_READ;
2835 CDB[0] = cmd;
2836 CDB[4] = 1; /*Spin up the disk */
2837 timeout = 15;
2838 break;
2839
2840 case REQUEST_SENSE:
2841 cmdLen = 6;
2842 CDB[0] = cmd;
2843 CDB[4] = io->size;
2844 dir = MPI_SCSIIO_CONTROL_READ;
2845 timeout = 10;
2846 break;
2847
2848 case READ_BUFFER:
2849 cmdLen = 10;
2850 dir = MPI_SCSIIO_CONTROL_READ;
2851 CDB[0] = cmd;
2852 if (io->flags & MPT_ICFLAG_ECHO) {
2853 CDB[1] = 0x0A;
2854 } else {
2855 CDB[1] = 0x02;
2856 }
2857
2858 if (io->flags & MPT_ICFLAG_BUF_CAP) {
2859 CDB[1] |= 0x01;
2860 }
2861 CDB[6] = (io->size >> 16) & 0xFF;
2862 CDB[7] = (io->size >> 8) & 0xFF;
2863 CDB[8] = io->size & 0xFF;
2864 timeout = 10;
2865 break;
2866
2867 case WRITE_BUFFER:
2868 cmdLen = 10;
2869 dir = MPI_SCSIIO_CONTROL_WRITE;
2870 CDB[0] = cmd;
2871 if (io->flags & MPT_ICFLAG_ECHO) {
2872 CDB[1] = 0x0A;
2873 } else {
2874 CDB[1] = 0x02;
2875 }
2876 CDB[6] = (io->size >> 16) & 0xFF;
2877 CDB[7] = (io->size >> 8) & 0xFF;
2878 CDB[8] = io->size & 0xFF;
2879 timeout = 10;
2880 break;
2881
2882 case RESERVE:
2883 cmdLen = 6;
2884 dir = MPI_SCSIIO_CONTROL_READ;
2885 CDB[0] = cmd;
2886 timeout = 10;
2887 break;
2888
2889 case RELEASE:
2890 cmdLen = 6;
2891 dir = MPI_SCSIIO_CONTROL_READ;
2892 CDB[0] = cmd;
2893 timeout = 10;
2894 break;
2895
2896 case SYNCHRONIZE_CACHE:
2897 cmdLen = 10;
2898 dir = MPI_SCSIIO_CONTROL_READ;
2899 CDB[0] = cmd;
2900 // CDB[1] = 0x02; /* set immediate bit */
2901 timeout = 10;
2902 break;
2903
2904 default:
2905 /* Error Case */
2906 ret = -EFAULT;
2907 goto out;
2908 }
2909
2910 /* Get and Populate a free Frame
2911 * MsgContext set in mpt_get_msg_frame call
2912 */
2913 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
2914 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
2915 ioc->name, __func__));
2916 ret = MPT_SCANDV_BUSY;
2917 goto out;
2918 }
2919
2920 pScsiReq = (SCSIIORequest_t *) mf;
2921
2922 /* Get the request index */
2923 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2924 ADD_INDEX_LOG(my_idx); /* for debug */
2925
2926 if (io->flags & MPT_ICFLAG_PHYS_DISK) {
2927 pScsiReq->TargetID = io->physDiskNum;
2928 pScsiReq->Bus = 0;
2929 pScsiReq->ChainOffset = 0;
2930 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
2931 } else {
2932 pScsiReq->TargetID = io->id;
2933 pScsiReq->Bus = io->channel;
2934 pScsiReq->ChainOffset = 0;
2935 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
2936 }
2937
2938 pScsiReq->CDBLength = cmdLen;
2939 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2940
2941 pScsiReq->Reserved = 0;
2942
2943 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
2944 /* MsgContext set in mpt_get_msg_fram call */
2945
2946 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
2947
2948 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
2949 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
2950 else
2951 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2952
2953 if (cmd == REQUEST_SENSE) {
2954 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2955 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2956 "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd));
2957 }
2958
2959 for (ii = 0; ii < 16; ii++)
2960 pScsiReq->CDB[ii] = CDB[ii];
2961
2962 pScsiReq->DataLength = cpu_to_le32(io->size);
2963 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
2964 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
2965
2966 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2967 "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%d\n",
2968 ioc->name, __func__, cmd, io->channel, io->id, io->lun));
2969
2970 if (dir == MPI_SCSIIO_CONTROL_READ)
2971 ioc->add_sge((char *) &pScsiReq->SGL,
2972 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
2973 else
2974 ioc->add_sge((char *) &pScsiReq->SGL,
2975 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
2976
2977 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
2978 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
2979 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
2980 timeout*HZ);
2981 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2982 ret = MPT_SCANDV_DID_RESET;
2983 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2984 "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__,
2985 cmd));
2986 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2987 mpt_free_msg_frame(ioc, mf);
2988 goto out;
2989 }
2990 if (!timeleft) {
2991 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
2992 ioc->name, __func__);
2993 mpt_HardResetHandler(ioc, CAN_SLEEP);
2994 mpt_free_msg_frame(ioc, mf);
2995 }
2996 goto out;
2997 }
2998
2999 ret = ioc->internal_cmds.completion_code;
3000 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
3001 ioc->name, __func__, ret));
3002
3003 out:
3004 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
3005 mutex_unlock(&ioc->internal_cmds.mutex);
3006 return ret;
3007 }
3008
3009 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3010 /**
3011 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3012 * @hd: Pointer to a SCSI HOST structure
3013 * @vdevice: virtual target device
3014 *
3015 * Uses the ISR, but with special processing.
3016 * MUST be single-threaded.
3017 *
3018 */
3019 static void
3020 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3021 {
3022 INTERNAL_CMD iocmd;
3023
3024 /* Ignore hidden raid components, this is handled when the command
3025 * is sent to the volume
3026 */
3027 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
3028 return;
3029
3030 if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted ||
3031 !vdevice->configured_lun)
3032 return;
3033
3034 /* Following parameters will not change
3035 * in this routine.
3036 */
3037 iocmd.cmd = SYNCHRONIZE_CACHE;
3038 iocmd.flags = 0;
3039 iocmd.physDiskNum = -1;
3040 iocmd.data = NULL;
3041 iocmd.data_dma = -1;
3042 iocmd.size = 0;
3043 iocmd.rsvd = iocmd.rsvd2 = 0;
3044 iocmd.channel = vdevice->vtarget->channel;
3045 iocmd.id = vdevice->vtarget->id;
3046 iocmd.lun = vdevice->lun;
3047
3048 mptscsih_do_cmd(hd, &iocmd);
3049 }
3050
3051 static ssize_t
3052 mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
3053 char *buf)
3054 {
3055 struct Scsi_Host *host = class_to_shost(dev);
3056 MPT_SCSI_HOST *hd = shost_priv(host);
3057 MPT_ADAPTER *ioc = hd->ioc;
3058
3059 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
3060 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3061 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3062 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3063 ioc->facts.FWVersion.Word & 0x000000FF);
3064 }
3065 static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
3066
3067 static ssize_t
3068 mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
3069 char *buf)
3070 {
3071 struct Scsi_Host *host = class_to_shost(dev);
3072 MPT_SCSI_HOST *hd = shost_priv(host);
3073 MPT_ADAPTER *ioc = hd->ioc;
3074
3075 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
3076 (ioc->biosVersion & 0xFF000000) >> 24,
3077 (ioc->biosVersion & 0x00FF0000) >> 16,
3078 (ioc->biosVersion & 0x0000FF00) >> 8,
3079 ioc->biosVersion & 0x000000FF);
3080 }
3081 static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
3082
3083 static ssize_t
3084 mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
3085 char *buf)
3086 {
3087 struct Scsi_Host *host = class_to_shost(dev);
3088 MPT_SCSI_HOST *hd = shost_priv(host);
3089 MPT_ADAPTER *ioc = hd->ioc;
3090
3091 return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
3092 }
3093 static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
3094
3095 static ssize_t
3096 mptscsih_version_product_show(struct device *dev,
3097 struct device_attribute *attr,
3098 char *buf)
3099 {
3100 struct Scsi_Host *host = class_to_shost(dev);
3101 MPT_SCSI_HOST *hd = shost_priv(host);
3102 MPT_ADAPTER *ioc = hd->ioc;
3103
3104 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
3105 }
3106 static DEVICE_ATTR(version_product, S_IRUGO,
3107 mptscsih_version_product_show, NULL);
3108
3109 static ssize_t
3110 mptscsih_version_nvdata_persistent_show(struct device *dev,
3111 struct device_attribute *attr,
3112 char *buf)
3113 {
3114 struct Scsi_Host *host = class_to_shost(dev);
3115 MPT_SCSI_HOST *hd = shost_priv(host);
3116 MPT_ADAPTER *ioc = hd->ioc;
3117
3118 return snprintf(buf, PAGE_SIZE, "%02xh\n",
3119 ioc->nvdata_version_persistent);
3120 }
3121 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
3122 mptscsih_version_nvdata_persistent_show, NULL);
3123
3124 static ssize_t
3125 mptscsih_version_nvdata_default_show(struct device *dev,
3126 struct device_attribute *attr, char *buf)
3127 {
3128 struct Scsi_Host *host = class_to_shost(dev);
3129 MPT_SCSI_HOST *hd = shost_priv(host);
3130 MPT_ADAPTER *ioc = hd->ioc;
3131
3132 return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
3133 }
3134 static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
3135 mptscsih_version_nvdata_default_show, NULL);
3136
3137 static ssize_t
3138 mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
3139 char *buf)
3140 {
3141 struct Scsi_Host *host = class_to_shost(dev);
3142 MPT_SCSI_HOST *hd = shost_priv(host);
3143 MPT_ADAPTER *ioc = hd->ioc;
3144
3145 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
3146 }
3147 static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
3148
3149 static ssize_t
3150 mptscsih_board_assembly_show(struct device *dev,
3151 struct device_attribute *attr, char *buf)
3152 {
3153 struct Scsi_Host *host = class_to_shost(dev);
3154 MPT_SCSI_HOST *hd = shost_priv(host);
3155 MPT_ADAPTER *ioc = hd->ioc;
3156
3157 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
3158 }
3159 static DEVICE_ATTR(board_assembly, S_IRUGO,
3160 mptscsih_board_assembly_show, NULL);
3161
3162 static ssize_t
3163 mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
3164 char *buf)
3165 {
3166 struct Scsi_Host *host = class_to_shost(dev);
3167 MPT_SCSI_HOST *hd = shost_priv(host);
3168 MPT_ADAPTER *ioc = hd->ioc;
3169
3170 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
3171 }
3172 static DEVICE_ATTR(board_tracer, S_IRUGO,
3173 mptscsih_board_tracer_show, NULL);
3174
3175 static ssize_t
3176 mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
3177 char *buf)
3178 {
3179 struct Scsi_Host *host = class_to_shost(dev);
3180 MPT_SCSI_HOST *hd = shost_priv(host);
3181 MPT_ADAPTER *ioc = hd->ioc;
3182
3183 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
3184 }
3185 static DEVICE_ATTR(io_delay, S_IRUGO,
3186 mptscsih_io_delay_show, NULL);
3187
3188 static ssize_t
3189 mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
3190 char *buf)
3191 {
3192 struct Scsi_Host *host = class_to_shost(dev);
3193 MPT_SCSI_HOST *hd = shost_priv(host);
3194 MPT_ADAPTER *ioc = hd->ioc;
3195
3196 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
3197 }
3198 static DEVICE_ATTR(device_delay, S_IRUGO,
3199 mptscsih_device_delay_show, NULL);
3200
3201 static ssize_t
3202 mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
3203 char *buf)
3204 {
3205 struct Scsi_Host *host = class_to_shost(dev);
3206 MPT_SCSI_HOST *hd = shost_priv(host);
3207 MPT_ADAPTER *ioc = hd->ioc;
3208
3209 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
3210 }
3211 static ssize_t
3212 mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
3213 const char *buf, size_t count)
3214 {
3215 struct Scsi_Host *host = class_to_shost(dev);
3216 MPT_SCSI_HOST *hd = shost_priv(host);
3217 MPT_ADAPTER *ioc = hd->ioc;
3218 int val = 0;
3219
3220 if (sscanf(buf, "%x", &val) != 1)
3221 return -EINVAL;
3222
3223 ioc->debug_level = val;
3224 printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
3225 ioc->name, ioc->debug_level);
3226 return strlen(buf);
3227 }
3228 static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
3229 mptscsih_debug_level_show, mptscsih_debug_level_store);
3230
3231 struct device_attribute *mptscsih_host_attrs[] = {
3232 &dev_attr_version_fw,
3233 &dev_attr_version_bios,
3234 &dev_attr_version_mpi,
3235 &dev_attr_version_product,
3236 &dev_attr_version_nvdata_persistent,
3237 &dev_attr_version_nvdata_default,
3238 &dev_attr_board_name,
3239 &dev_attr_board_assembly,
3240 &dev_attr_board_tracer,
3241 &dev_attr_io_delay,
3242 &dev_attr_device_delay,
3243 &dev_attr_debug_level,
3244 NULL,
3245 };
3246
3247 EXPORT_SYMBOL(mptscsih_host_attrs);
3248
3249 EXPORT_SYMBOL(mptscsih_remove);
3250 EXPORT_SYMBOL(mptscsih_shutdown);
3251 #ifdef CONFIG_PM
3252 EXPORT_SYMBOL(mptscsih_suspend);
3253 EXPORT_SYMBOL(mptscsih_resume);
3254 #endif
3255 EXPORT_SYMBOL(mptscsih_proc_info);
3256 EXPORT_SYMBOL(mptscsih_info);
3257 EXPORT_SYMBOL(mptscsih_qcmd);
3258 EXPORT_SYMBOL(mptscsih_slave_destroy);
3259 EXPORT_SYMBOL(mptscsih_slave_configure);
3260 EXPORT_SYMBOL(mptscsih_abort);
3261 EXPORT_SYMBOL(mptscsih_dev_reset);
3262 EXPORT_SYMBOL(mptscsih_bus_reset);
3263 EXPORT_SYMBOL(mptscsih_host_reset);
3264 EXPORT_SYMBOL(mptscsih_bios_param);
3265 EXPORT_SYMBOL(mptscsih_io_done);
3266 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3267 EXPORT_SYMBOL(mptscsih_scandv_complete);
3268 EXPORT_SYMBOL(mptscsih_event_process);
3269 EXPORT_SYMBOL(mptscsih_ioc_reset);
3270 EXPORT_SYMBOL(mptscsih_change_queue_depth);
3271 EXPORT_SYMBOL(mptscsih_timer_expired);
3272
3273 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
x86 "subsystem" repository