?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] mptsas : Handle INSUFFICIENT resources status as similar to IOC BUSY status
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / message / fusion / mptscsih.c
blob1466a5aed5f87f5c6472ed5f95c9edcfe164ed2e
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 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
693 /* CHECKME!
694 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
695 * But not: DID_BUS_BUSY lest one risk
696 * killing interrupt handler:-(
697 */
698 sc->result = SAM_STAT_BUSY;
699 break;
700
701 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
702 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
703 sc->result = DID_BAD_TARGET << 16;
704 break;
705
706 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
707 /* Spoof to SCSI Selection Timeout! */
708 if (ioc->bus_type != FC)
709 sc->result = DID_NO_CONNECT << 16;
710 /* else fibre, just stall until rescan event */
711 else
712 sc->result = DID_REQUEUE << 16;
713
714 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
715 hd->sel_timeout[pScsiReq->TargetID]++;
716
717 vdevice = sc->device->hostdata;
718 if (!vdevice)
719 break;
720 vtarget = vdevice->vtarget;
721 if (vtarget->tflags & MPT_TARGET_FLAGS_LED_ON) {
722 mptscsih_issue_sep_command(ioc, vtarget,
723 MPI_SEP_REQ_SLOTSTATUS_UNCONFIGURED);
724 vtarget->tflags &= ~MPT_TARGET_FLAGS_LED_ON;
725 }
726 break;
727
728 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
729 if ( ioc->bus_type == SAS ) {
730 u16 ioc_status = le16_to_cpu(pScsiReply->IOCStatus);
731 if (ioc_status & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
732 if ((log_info & SAS_LOGINFO_MASK)
733 == SAS_LOGINFO_NEXUS_LOSS) {
734 sc->result = (DID_BUS_BUSY << 16);
735 break;
736 }
737 }
738 } else if (ioc->bus_type == FC) {
739 /*
740 * The FC IOC may kill a request for variety of
741 * reasons, some of which may be recovered by a
742 * retry, some which are unlikely to be
743 * recovered. Return DID_ERROR instead of
744 * DID_RESET to permit retry of the command,
745 * just not an infinite number of them
746 */
747 sc->result = DID_ERROR << 16;
748 break;
749 }
750
751 /*
752 * Allow non-SAS & non-NEXUS_LOSS to drop into below code
753 */
754
755 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
756 /* Linux handles an unsolicited DID_RESET better
757 * than an unsolicited DID_ABORT.
758 */
759 sc->result = DID_RESET << 16;
760
761 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
762 if (ioc->bus_type == FC)
763 sc->result = DID_ERROR << 16;
764 else
765 sc->result = DID_RESET << 16;
766 break;
767
768 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
769 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
770 if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
771 sc->result=DID_SOFT_ERROR << 16;
772 else /* Sufficient data transfer occurred */
773 sc->result = (DID_OK << 16) | scsi_status;
774 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
775 "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
776 ioc->name, sc->result, sc->device->channel, sc->device->id));
777 break;
778
779 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
780 /*
781 * Do upfront check for valid SenseData and give it
782 * precedence!
783 */
784 sc->result = (DID_OK << 16) | scsi_status;
785 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
786 /* Have already saved the status and sense data
787 */
788 ;
789 } else {
790 if (xfer_cnt < sc->underflow) {
791 if (scsi_status == SAM_STAT_BUSY)
792 sc->result = SAM_STAT_BUSY;
793 else
794 sc->result = DID_SOFT_ERROR << 16;
795 }
796 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
797 /* What to do?
798 */
799 sc->result = DID_SOFT_ERROR << 16;
800 }
801 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
802 /* Not real sure here either... */
803 sc->result = DID_RESET << 16;
804 }
805 }
806
807
808 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
809 " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
810 ioc->name, sc->underflow));
811 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
812 " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
813
814 /* Report Queue Full
815 */
816 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
817 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
818
819 break;
820
821 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
822 scsi_set_resid(sc, 0);
823 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
824 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
825 sc->result = (DID_OK << 16) | scsi_status;
826 if (scsi_state == 0) {
827 ;
828 } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
829 /*
830 * If running against circa 200003dd 909 MPT f/w,
831 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
832 * (QUEUE_FULL) returned from device! --> get 0x0000?128
833 * and with SenseBytes set to 0.
834 */
835 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
836 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
837
838 }
839 else if (scsi_state &
840 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
841 ) {
842 /*
843 * What to do?
844 */
845 sc->result = DID_SOFT_ERROR << 16;
846 }
847 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
848 /* Not real sure here either... */
849 sc->result = DID_RESET << 16;
850 }
851 else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) {
852 /* Device Inq. data indicates that it supports
853 * QTags, but rejects QTag messages.
854 * This command completed OK.
855 *
856 * Not real sure here either so do nothing... */
857 }
858
859 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
860 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
861
862 /* Add handling of:
863 * Reservation Conflict, Busy,
864 * Command Terminated, CHECK
865 */
866 break;
867
868 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
869 sc->result = DID_SOFT_ERROR << 16;
870 break;
871
872 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
873 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
874 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
875 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
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 retval = mptscsih_IssueTaskMgmt(hd,
1733 MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1734 vdevice->vtarget->channel,
1735 vdevice->vtarget->id, vdevice->lun,
1736 ctx2abort, mptscsih_get_tm_timeout(ioc));
1737
1738 if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx &&
1739 SCpnt->serial_number == sn) {
1740 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1741 "task abort: command still in active list! (sc=%p)\n",
1742 ioc->name, SCpnt));
1743 retval = FAILED;
1744 } else {
1745 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1746 "task abort: command cleared from active list! (sc=%p)\n",
1747 ioc->name, SCpnt));
1748 retval = SUCCESS;
1749 }
1750
1751 out:
1752 printk(MYIOC_s_INFO_FMT "task abort: %s (sc=%p)\n",
1753 ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), SCpnt);
1754
1755 return retval;
1756 }
1757
1758 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1759 /**
1760 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant
1761 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1762 *
1763 * (linux scsi_host_template.eh_dev_reset_handler routine)
1764 *
1765 * Returns SUCCESS or FAILED.
1766 **/
1767 int
1768 mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1769 {
1770 MPT_SCSI_HOST *hd;
1771 int retval;
1772 VirtDevice *vdevice;
1773 MPT_ADAPTER *ioc;
1774
1775 /* If we can't locate our host adapter structure, return FAILED status.
1776 */
1777 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1778 printk(KERN_ERR MYNAM ": target reset: "
1779 "Can't locate host! (sc=%p)\n", SCpnt);
1780 return FAILED;
1781 }
1782
1783 ioc = hd->ioc;
1784 printk(MYIOC_s_INFO_FMT "attempting target reset! (sc=%p)\n",
1785 ioc->name, SCpnt);
1786 scsi_print_command(SCpnt);
1787
1788 vdevice = SCpnt->device->hostdata;
1789 if (!vdevice || !vdevice->vtarget) {
1790 retval = SUCCESS;
1791 goto out;
1792 }
1793
1794 /* Target reset to hidden raid component is not supported
1795 */
1796 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1797 retval = FAILED;
1798 goto out;
1799 }
1800
1801 retval = mptscsih_IssueTaskMgmt(hd,
1802 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1803 vdevice->vtarget->channel,
1804 vdevice->vtarget->id, 0, 0,
1805 mptscsih_get_tm_timeout(ioc));
1806
1807 out:
1808 printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
1809 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1810
1811 if (retval == 0)
1812 return SUCCESS;
1813 else
1814 return FAILED;
1815 }
1816
1817
1818 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1819 /**
1820 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant
1821 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1822 *
1823 * (linux scsi_host_template.eh_bus_reset_handler routine)
1824 *
1825 * Returns SUCCESS or FAILED.
1826 **/
1827 int
1828 mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1829 {
1830 MPT_SCSI_HOST *hd;
1831 int retval;
1832 VirtDevice *vdevice;
1833 MPT_ADAPTER *ioc;
1834
1835 /* If we can't locate our host adapter structure, return FAILED status.
1836 */
1837 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1838 printk(KERN_ERR MYNAM ": bus reset: "
1839 "Can't locate host! (sc=%p)\n", SCpnt);
1840 return FAILED;
1841 }
1842
1843 ioc = hd->ioc;
1844 printk(MYIOC_s_INFO_FMT "attempting bus reset! (sc=%p)\n",
1845 ioc->name, SCpnt);
1846 scsi_print_command(SCpnt);
1847
1848 if (ioc->timeouts < -1)
1849 ioc->timeouts++;
1850
1851 vdevice = SCpnt->device->hostdata;
1852 if (!vdevice || !vdevice->vtarget)
1853 return SUCCESS;
1854 retval = mptscsih_IssueTaskMgmt(hd,
1855 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1856 vdevice->vtarget->channel, 0, 0, 0,
1857 mptscsih_get_tm_timeout(ioc));
1858
1859 printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
1860 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1861
1862 if (retval == 0)
1863 return SUCCESS;
1864 else
1865 return FAILED;
1866 }
1867
1868 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1869 /**
1870 * mptscsih_host_reset - Perform a SCSI host adapter RESET (new_eh variant)
1871 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1872 *
1873 * (linux scsi_host_template.eh_host_reset_handler routine)
1874 *
1875 * Returns SUCCESS or FAILED.
1876 */
1877 int
1878 mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1879 {
1880 MPT_SCSI_HOST * hd;
1881 int status = SUCCESS;
1882 MPT_ADAPTER *ioc;
1883 int retval;
1884
1885 /* If we can't locate the host to reset, then we failed. */
1886 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
1887 printk(KERN_ERR MYNAM ": host reset: "
1888 "Can't locate host! (sc=%p)\n", SCpnt);
1889 return FAILED;
1890 }
1891
1892 /* make sure we have no outstanding commands at this stage */
1893 mptscsih_flush_running_cmds(hd);
1894
1895 ioc = hd->ioc;
1896 printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
1897 ioc->name, SCpnt);
1898
1899 /* If our attempts to reset the host failed, then return a failed
1900 * status. The host will be taken off line by the SCSI mid-layer.
1901 */
1902 retval = mpt_HardResetHandler(ioc, CAN_SLEEP);
1903 if (retval < 0)
1904 status = FAILED;
1905 else
1906 status = SUCCESS;
1907
1908 printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
1909 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1910
1911 return status;
1912 }
1913
1914 static int
1915 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
1916 SCSITaskMgmtReply_t *pScsiTmReply)
1917 {
1918 u16 iocstatus;
1919 u32 termination_count;
1920 int retval;
1921
1922 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
1923 retval = FAILED;
1924 goto out;
1925 }
1926
1927 DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
1928
1929 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
1930 termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
1931
1932 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1933 "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
1934 "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
1935 "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
1936 pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
1937 le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
1938 termination_count));
1939
1940 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
1941 pScsiTmReply->ResponseCode)
1942 mptscsih_taskmgmt_response_code(ioc,
1943 pScsiTmReply->ResponseCode);
1944
1945 if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
1946 retval = 0;
1947 goto out;
1948 }
1949
1950 retval = FAILED;
1951 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1952 if (termination_count == 1)
1953 retval = 0;
1954 goto out;
1955 }
1956
1957 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
1958 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
1959 retval = 0;
1960
1961 out:
1962 return retval;
1963 }
1964
1965 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1966 void
1967 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
1968 {
1969 char *desc;
1970
1971 switch (response_code) {
1972 case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
1973 desc = "The task completed.";
1974 break;
1975 case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
1976 desc = "The IOC received an invalid frame status.";
1977 break;
1978 case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
1979 desc = "The task type is not supported.";
1980 break;
1981 case MPI_SCSITASKMGMT_RSP_TM_FAILED:
1982 desc = "The requested task failed.";
1983 break;
1984 case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
1985 desc = "The task completed successfully.";
1986 break;
1987 case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
1988 desc = "The LUN request is invalid.";
1989 break;
1990 case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
1991 desc = "The task is in the IOC queue and has not been sent to target.";
1992 break;
1993 default:
1994 desc = "unknown";
1995 break;
1996 }
1997 printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
1998 ioc->name, response_code, desc);
1999 }
2000 EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
2001
2002 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2003 /**
2004 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2005 * @ioc: Pointer to MPT_ADAPTER structure
2006 * @mf: Pointer to SCSI task mgmt request frame
2007 * @mr: Pointer to SCSI task mgmt reply frame
2008 *
2009 * This routine is called from mptbase.c::mpt_interrupt() at the completion
2010 * of any SCSI task management request.
2011 * This routine is registered with the MPT (base) driver at driver
2012 * load/init time via the mpt_register() API call.
2013 *
2014 * Returns 1 indicating alloc'd request frame ptr should be freed.
2015 **/
2016 int
2017 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
2018 MPT_FRAME_HDR *mr)
2019 {
2020 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2021 "TaskMgmt completed (mf=%p, mr=%p)\n", ioc->name, mf, mr));
2022
2023 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2024
2025 if (!mr)
2026 goto out;
2027
2028 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2029 memcpy(ioc->taskmgmt_cmds.reply, mr,
2030 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
2031 out:
2032 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
2033 mpt_clear_taskmgmt_in_progress_flag(ioc);
2034 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2035 complete(&ioc->taskmgmt_cmds.done);
2036 return 1;
2037 }
2038 return 0;
2039 }
2040
2041 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2042 /*
2043 * This is anyones guess quite frankly.
2044 */
2045 int
2046 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2047 sector_t capacity, int geom[])
2048 {
2049 int heads;
2050 int sectors;
2051 sector_t cylinders;
2052 ulong dummy;
2053
2054 heads = 64;
2055 sectors = 32;
2056
2057 dummy = heads * sectors;
2058 cylinders = capacity;
2059 sector_div(cylinders,dummy);
2060
2061 /*
2062 * Handle extended translation size for logical drives
2063 * > 1Gb
2064 */
2065 if ((ulong)capacity >= 0x200000) {
2066 heads = 255;
2067 sectors = 63;
2068 dummy = heads * sectors;
2069 cylinders = capacity;
2070 sector_div(cylinders,dummy);
2071 }
2072
2073 /* return result */
2074 geom[0] = heads;
2075 geom[1] = sectors;
2076 geom[2] = cylinders;
2077
2078 return 0;
2079 }
2080
2081 /* Search IOC page 3 to determine if this is hidden physical disk
2082 *
2083 */
2084 int
2085 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
2086 {
2087 struct inactive_raid_component_info *component_info;
2088 int i, j;
2089 RaidPhysDiskPage1_t *phys_disk;
2090 int rc = 0;
2091 int num_paths;
2092
2093 if (!ioc->raid_data.pIocPg3)
2094 goto out;
2095 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2096 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2097 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2098 rc = 1;
2099 goto out;
2100 }
2101 }
2102
2103 if (ioc->bus_type != SAS)
2104 goto out;
2105
2106 /*
2107 * Check if dual path
2108 */
2109 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2110 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2111 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2112 if (num_paths < 2)
2113 continue;
2114 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2115 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2116 if (!phys_disk)
2117 continue;
2118 if ((mpt_raid_phys_disk_pg1(ioc,
2119 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2120 phys_disk))) {
2121 kfree(phys_disk);
2122 continue;
2123 }
2124 for (j = 0; j < num_paths; j++) {
2125 if ((phys_disk->Path[j].Flags &
2126 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2127 continue;
2128 if ((phys_disk->Path[j].Flags &
2129 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2130 continue;
2131 if ((id == phys_disk->Path[j].PhysDiskID) &&
2132 (channel == phys_disk->Path[j].PhysDiskBus)) {
2133 rc = 1;
2134 kfree(phys_disk);
2135 goto out;
2136 }
2137 }
2138 kfree(phys_disk);
2139 }
2140
2141
2142 /*
2143 * Check inactive list for matching phys disks
2144 */
2145 if (list_empty(&ioc->raid_data.inactive_list))
2146 goto out;
2147
2148 mutex_lock(&ioc->raid_data.inactive_list_mutex);
2149 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2150 list) {
2151 if ((component_info->d.PhysDiskID == id) &&
2152 (component_info->d.PhysDiskBus == channel))
2153 rc = 1;
2154 }
2155 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2156
2157 out:
2158 return rc;
2159 }
2160 EXPORT_SYMBOL(mptscsih_is_phys_disk);
2161
2162 u8
2163 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
2164 {
2165 struct inactive_raid_component_info *component_info;
2166 int i, j;
2167 RaidPhysDiskPage1_t *phys_disk;
2168 int rc = -ENXIO;
2169 int num_paths;
2170
2171 if (!ioc->raid_data.pIocPg3)
2172 goto out;
2173 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2174 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2175 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2176 rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
2177 goto out;
2178 }
2179 }
2180
2181 if (ioc->bus_type != SAS)
2182 goto out;
2183
2184 /*
2185 * Check if dual path
2186 */
2187 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2188 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2189 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2190 if (num_paths < 2)
2191 continue;
2192 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2193 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2194 if (!phys_disk)
2195 continue;
2196 if ((mpt_raid_phys_disk_pg1(ioc,
2197 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2198 phys_disk))) {
2199 kfree(phys_disk);
2200 continue;
2201 }
2202 for (j = 0; j < num_paths; j++) {
2203 if ((phys_disk->Path[j].Flags &
2204 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2205 continue;
2206 if ((phys_disk->Path[j].Flags &
2207 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2208 continue;
2209 if ((id == phys_disk->Path[j].PhysDiskID) &&
2210 (channel == phys_disk->Path[j].PhysDiskBus)) {
2211 rc = phys_disk->PhysDiskNum;
2212 kfree(phys_disk);
2213 goto out;
2214 }
2215 }
2216 kfree(phys_disk);
2217 }
2218
2219 /*
2220 * Check inactive list for matching phys disks
2221 */
2222 if (list_empty(&ioc->raid_data.inactive_list))
2223 goto out;
2224
2225 mutex_lock(&ioc->raid_data.inactive_list_mutex);
2226 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2227 list) {
2228 if ((component_info->d.PhysDiskID == id) &&
2229 (component_info->d.PhysDiskBus == channel))
2230 rc = component_info->d.PhysDiskNum;
2231 }
2232 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
2233
2234 out:
2235 return rc;
2236 }
2237 EXPORT_SYMBOL(mptscsih_raid_id_to_num);
2238
2239 /*
2240 * OS entry point to allow for host driver to free allocated memory
2241 * Called if no device present or device being unloaded
2242 */
2243 void
2244 mptscsih_slave_destroy(struct scsi_device *sdev)
2245 {
2246 struct Scsi_Host *host = sdev->host;
2247 MPT_SCSI_HOST *hd = shost_priv(host);
2248 VirtTarget *vtarget;
2249 VirtDevice *vdevice;
2250 struct scsi_target *starget;
2251
2252 starget = scsi_target(sdev);
2253 vtarget = starget->hostdata;
2254 vdevice = sdev->hostdata;
2255
2256 mptscsih_search_running_cmds(hd, vdevice);
2257 vtarget->num_luns--;
2258 mptscsih_synchronize_cache(hd, vdevice);
2259 kfree(vdevice);
2260 sdev->hostdata = NULL;
2261 }
2262
2263 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2264 /*
2265 * mptscsih_change_queue_depth - This function will set a devices queue depth
2266 * @sdev: per scsi_device pointer
2267 * @qdepth: requested queue depth
2268 *
2269 * Adding support for new 'change_queue_depth' api.
2270 */
2271 int
2272 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
2273 {
2274 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
2275 VirtTarget *vtarget;
2276 struct scsi_target *starget;
2277 int max_depth;
2278 int tagged;
2279 MPT_ADAPTER *ioc = hd->ioc;
2280
2281 starget = scsi_target(sdev);
2282 vtarget = starget->hostdata;
2283
2284 if (ioc->bus_type == SPI) {
2285 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2286 max_depth = 1;
2287 else if (sdev->type == TYPE_DISK &&
2288 vtarget->minSyncFactor <= MPT_ULTRA160)
2289 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2290 else
2291 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
2292 } else
2293 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2294
2295 if (qdepth > max_depth)
2296 qdepth = max_depth;
2297 if (qdepth == 1)
2298 tagged = 0;
2299 else
2300 tagged = MSG_SIMPLE_TAG;
2301
2302 scsi_adjust_queue_depth(sdev, tagged, qdepth);
2303 return sdev->queue_depth;
2304 }
2305
2306 /*
2307 * OS entry point to adjust the queue_depths on a per-device basis.
2308 * Called once per device the bus scan. Use it to force the queue_depth
2309 * member to 1 if a device does not support Q tags.
2310 * Return non-zero if fails.
2311 */
2312 int
2313 mptscsih_slave_configure(struct scsi_device *sdev)
2314 {
2315 struct Scsi_Host *sh = sdev->host;
2316 VirtTarget *vtarget;
2317 VirtDevice *vdevice;
2318 struct scsi_target *starget;
2319 MPT_SCSI_HOST *hd = shost_priv(sh);
2320 MPT_ADAPTER *ioc = hd->ioc;
2321
2322 starget = scsi_target(sdev);
2323 vtarget = starget->hostdata;
2324 vdevice = sdev->hostdata;
2325
2326 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2327 "device @ %p, channel=%d, id=%d, lun=%d\n",
2328 ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
2329 if (ioc->bus_type == SPI)
2330 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2331 "sdtr %d wdtr %d ppr %d inq length=%d\n",
2332 ioc->name, sdev->sdtr, sdev->wdtr,
2333 sdev->ppr, sdev->inquiry_len));
2334
2335 vdevice->configured_lun = 1;
2336
2337 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2338 "Queue depth=%d, tflags=%x\n",
2339 ioc->name, sdev->queue_depth, vtarget->tflags));
2340
2341 if (ioc->bus_type == SPI)
2342 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2343 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
2344 ioc->name, vtarget->negoFlags, vtarget->maxOffset,
2345 vtarget->minSyncFactor));
2346
2347 mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
2348 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2349 "tagged %d, simple %d, ordered %d\n",
2350 ioc->name,sdev->tagged_supported, sdev->simple_tags,
2351 sdev->ordered_tags));
2352
2353 return 0;
2354 }
2355
2356 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2357 /*
2358 * Private routines...
2359 */
2360
2361 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2362 /* Utility function to copy sense data from the scsi_cmnd buffer
2363 * to the FC and SCSI target structures.
2364 *
2365 */
2366 static void
2367 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
2368 {
2369 VirtDevice *vdevice;
2370 SCSIIORequest_t *pReq;
2371 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount);
2372 MPT_ADAPTER *ioc = hd->ioc;
2373
2374 /* Get target structure
2375 */
2376 pReq = (SCSIIORequest_t *) mf;
2377 vdevice = sc->device->hostdata;
2378
2379 if (sense_count) {
2380 u8 *sense_data;
2381 int req_index;
2382
2383 /* Copy the sense received into the scsi command block. */
2384 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2385 sense_data = ((u8 *)ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
2386 memcpy(sc->sense_buffer, sense_data, SNS_LEN(sc));
2387
2388 /* Log SMART data (asc = 0x5D, non-IM case only) if required.
2389 */
2390 if ((ioc->events) && (ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
2391 if ((sense_data[12] == 0x5D) && (vdevice->vtarget->raidVolume == 0)) {
2392 int idx;
2393
2394 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
2395 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2396 ioc->events[idx].eventContext = ioc->eventContext;
2397
2398 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) |
2399 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) |
2400 (sc->device->channel << 8) | sc->device->id;
2401
2402 ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
2403
2404 ioc->eventContext++;
2405 if (ioc->pcidev->vendor ==
2406 PCI_VENDOR_ID_IBM) {
2407 mptscsih_issue_sep_command(ioc,
2408 vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
2409 vdevice->vtarget->tflags |=
2410 MPT_TARGET_FLAGS_LED_ON;
2411 }
2412 }
2413 }
2414 } else {
2415 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
2416 ioc->name));
2417 }
2418 }
2419
2420 /**
2421 * mptscsih_get_scsi_lookup - retrieves scmd entry
2422 * @ioc: Pointer to MPT_ADAPTER structure
2423 * @i: index into the array
2424 *
2425 * Returns the scsi_cmd pointer
2426 */
2427 struct scsi_cmnd *
2428 mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
2429 {
2430 unsigned long flags;
2431 struct scsi_cmnd *scmd;
2432
2433 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2434 scmd = ioc->ScsiLookup[i];
2435 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2436
2437 return scmd;
2438 }
2439 EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
2440
2441 /**
2442 * mptscsih_getclear_scsi_lookup - retrieves and clears scmd entry from ScsiLookup[] array list
2443 * @ioc: Pointer to MPT_ADAPTER structure
2444 * @i: index into the array
2445 *
2446 * Returns the scsi_cmd pointer
2447 *
2448 **/
2449 static struct scsi_cmnd *
2450 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
2451 {
2452 unsigned long flags;
2453 struct scsi_cmnd *scmd;
2454
2455 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2456 scmd = ioc->ScsiLookup[i];
2457 ioc->ScsiLookup[i] = NULL;
2458 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2459
2460 return scmd;
2461 }
2462
2463 /**
2464 * mptscsih_set_scsi_lookup
2465 *
2466 * writes a scmd entry into the ScsiLookup[] array list
2467 *
2468 * @ioc: Pointer to MPT_ADAPTER structure
2469 * @i: index into the array
2470 * @scmd: scsi_cmnd pointer
2471 *
2472 **/
2473 static void
2474 mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd)
2475 {
2476 unsigned long flags;
2477
2478 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2479 ioc->ScsiLookup[i] = scmd;
2480 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2481 }
2482
2483 /**
2484 * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
2485 * @ioc: Pointer to MPT_ADAPTER structure
2486 * @sc: scsi_cmnd pointer
2487 */
2488 static int
2489 SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
2490 {
2491 unsigned long flags;
2492 int i, index=-1;
2493
2494 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2495 for (i = 0; i < ioc->req_depth; i++) {
2496 if (ioc->ScsiLookup[i] == sc) {
2497 index = i;
2498 goto out;
2499 }
2500 }
2501
2502 out:
2503 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2504 return index;
2505 }
2506
2507 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2508 int
2509 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2510 {
2511 MPT_SCSI_HOST *hd;
2512
2513 if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
2514 return 0;
2515
2516 hd = shost_priv(ioc->sh);
2517 switch (reset_phase) {
2518 case MPT_IOC_SETUP_RESET:
2519 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2520 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
2521 break;
2522 case MPT_IOC_PRE_RESET:
2523 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2524 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
2525 mptscsih_flush_running_cmds(hd);
2526 break;
2527 case MPT_IOC_POST_RESET:
2528 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2529 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
2530 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
2531 ioc->internal_cmds.status |=
2532 MPT_MGMT_STATUS_DID_IOCRESET;
2533 complete(&ioc->internal_cmds.done);
2534 }
2535 break;
2536 default:
2537 break;
2538 }
2539 return 1; /* currently means nothing really */
2540 }
2541
2542 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2543 int
2544 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2545 {
2546 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2547
2548 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2549 "MPT event (=%02Xh) routed to SCSI host driver!\n",
2550 ioc->name, event));
2551
2552 if ((event == MPI_EVENT_IOC_BUS_RESET ||
2553 event == MPI_EVENT_EXT_BUS_RESET) &&
2554 (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
2555 ioc->soft_resets++;
2556
2557 return 1; /* currently means nothing really */
2558 }
2559
2560 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2561 /*
2562 * Bus Scan and Domain Validation functionality ...
2563 */
2564
2565 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2566 /*
2567 * mptscsih_scandv_complete - Scan and DV callback routine registered
2568 * to Fustion MPT (base) driver.
2569 *
2570 * @ioc: Pointer to MPT_ADAPTER structure
2571 * @mf: Pointer to original MPT request frame
2572 * @mr: Pointer to MPT reply frame (NULL if TurboReply)
2573 *
2574 * This routine is called from mpt.c::mpt_interrupt() at the completion
2575 * of any SCSI IO request.
2576 * This routine is registered with the Fusion MPT (base) driver at driver
2577 * load/init time via the mpt_register() API call.
2578 *
2579 * Returns 1 indicating alloc'd request frame ptr should be freed.
2580 *
2581 * Remark: Sets a completion code and (possibly) saves sense data
2582 * in the IOC member localReply structure.
2583 * Used ONLY for DV and other internal commands.
2584 */
2585 int
2586 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2587 MPT_FRAME_HDR *reply)
2588 {
2589 SCSIIORequest_t *pReq;
2590 SCSIIOReply_t *pReply;
2591 u8 cmd;
2592 u16 req_idx;
2593 u8 *sense_data;
2594 int sz;
2595
2596 ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2597 ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
2598 if (!reply)
2599 goto out;
2600
2601 pReply = (SCSIIOReply_t *) reply;
2602 pReq = (SCSIIORequest_t *) req;
2603 ioc->internal_cmds.completion_code =
2604 mptscsih_get_completion_code(ioc, req, reply);
2605 ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2606 memcpy(ioc->internal_cmds.reply, reply,
2607 min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
2608 cmd = reply->u.hdr.Function;
2609 if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
2610 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
2611 (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
2612 req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
2613 sense_data = ((u8 *)ioc->sense_buf_pool +
2614 (req_idx * MPT_SENSE_BUFFER_ALLOC));
2615 sz = min_t(int, pReq->SenseBufferLength,
2616 MPT_SENSE_BUFFER_ALLOC);
2617 memcpy(ioc->internal_cmds.sense, sense_data, sz);
2618 }
2619 out:
2620 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
2621 return 0;
2622 ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2623 complete(&ioc->internal_cmds.done);
2624 return 1;
2625 }
2626
2627
2628 /**
2629 * mptscsih_get_completion_code -
2630 * @ioc: Pointer to MPT_ADAPTER structure
2631 * @req: Pointer to original MPT request frame
2632 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
2633 *
2634 **/
2635 static int
2636 mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2637 MPT_FRAME_HDR *reply)
2638 {
2639 SCSIIOReply_t *pReply;
2640 MpiRaidActionReply_t *pr;
2641 u8 scsi_status;
2642 u16 status;
2643 int completion_code;
2644
2645 pReply = (SCSIIOReply_t *)reply;
2646 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2647 scsi_status = pReply->SCSIStatus;
2648
2649 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2650 "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh,"
2651 "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState,
2652 scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
2653
2654 switch (status) {
2655
2656 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
2657 completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
2658 break;
2659
2660 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
2661 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
2662 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
2663 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
2664 completion_code = MPT_SCANDV_DID_RESET;
2665 break;
2666
2667 case MPI_IOCSTATUS_BUSY:
2668 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
2669 completion_code = MPT_SCANDV_BUSY;
2670 break;
2671
2672 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
2673 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
2674 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
2675 if (pReply->Function == MPI_FUNCTION_CONFIG) {
2676 completion_code = MPT_SCANDV_GOOD;
2677 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2678 pr = (MpiRaidActionReply_t *)reply;
2679 if (le16_to_cpu(pr->ActionStatus) ==
2680 MPI_RAID_ACTION_ASTATUS_SUCCESS)
2681 completion_code = MPT_SCANDV_GOOD;
2682 else
2683 completion_code = MPT_SCANDV_SOME_ERROR;
2684 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
2685 completion_code = MPT_SCANDV_SENSE;
2686 else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2687 if (req->u.scsireq.CDB[0] == INQUIRY)
2688 completion_code = MPT_SCANDV_ISSUE_SENSE;
2689 else
2690 completion_code = MPT_SCANDV_DID_RESET;
2691 } else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
2692 completion_code = MPT_SCANDV_DID_RESET;
2693 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2694 completion_code = MPT_SCANDV_DID_RESET;
2695 else if (scsi_status == MPI_SCSI_STATUS_BUSY)
2696 completion_code = MPT_SCANDV_BUSY;
2697 else
2698 completion_code = MPT_SCANDV_GOOD;
2699 break;
2700
2701 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
2702 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2703 completion_code = MPT_SCANDV_DID_RESET;
2704 else
2705 completion_code = MPT_SCANDV_SOME_ERROR;
2706 break;
2707 default:
2708 completion_code = MPT_SCANDV_SOME_ERROR;
2709 break;
2710
2711 } /* switch(status) */
2712
2713 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2714 " completionCode set to %08xh\n", ioc->name, completion_code));
2715 return completion_code;
2716 }
2717
2718 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2719 /**
2720 * mptscsih_do_cmd - Do internal command.
2721 * @hd: MPT_SCSI_HOST pointer
2722 * @io: INTERNAL_CMD pointer.
2723 *
2724 * Issue the specified internally generated command and do command
2725 * specific cleanup. For bus scan / DV only.
2726 * NOTES: If command is Inquiry and status is good,
2727 * initialize a target structure, save the data
2728 *
2729 * Remark: Single threaded access only.
2730 *
2731 * Return:
2732 * < 0 if an illegal command or no resources
2733 *
2734 * 0 if good
2735 *
2736 * > 0 if command complete but some type of completion error.
2737 */
2738 static int
2739 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
2740 {
2741 MPT_FRAME_HDR *mf;
2742 SCSIIORequest_t *pScsiReq;
2743 int my_idx, ii, dir;
2744 int timeout;
2745 char cmdLen;
2746 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
2747 u8 cmd = io->cmd;
2748 MPT_ADAPTER *ioc = hd->ioc;
2749 int ret = 0;
2750 unsigned long timeleft;
2751 unsigned long flags;
2752
2753 /* don't send internal command during diag reset */
2754 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2755 if (ioc->ioc_reset_in_progress) {
2756 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2757 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2758 "%s: busy with host reset\n", ioc->name, __func__));
2759 return MPT_SCANDV_BUSY;
2760 }
2761 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2762
2763 mutex_lock(&ioc->internal_cmds.mutex);
2764
2765 /* Set command specific information
2766 */
2767 switch (cmd) {
2768 case INQUIRY:
2769 cmdLen = 6;
2770 dir = MPI_SCSIIO_CONTROL_READ;
2771 CDB[0] = cmd;
2772 CDB[4] = io->size;
2773 timeout = 10;
2774 break;
2775
2776 case TEST_UNIT_READY:
2777 cmdLen = 6;
2778 dir = MPI_SCSIIO_CONTROL_READ;
2779 timeout = 10;
2780 break;
2781
2782 case START_STOP:
2783 cmdLen = 6;
2784 dir = MPI_SCSIIO_CONTROL_READ;
2785 CDB[0] = cmd;
2786 CDB[4] = 1; /*Spin up the disk */
2787 timeout = 15;
2788 break;
2789
2790 case REQUEST_SENSE:
2791 cmdLen = 6;
2792 CDB[0] = cmd;
2793 CDB[4] = io->size;
2794 dir = MPI_SCSIIO_CONTROL_READ;
2795 timeout = 10;
2796 break;
2797
2798 case READ_BUFFER:
2799 cmdLen = 10;
2800 dir = MPI_SCSIIO_CONTROL_READ;
2801 CDB[0] = cmd;
2802 if (io->flags & MPT_ICFLAG_ECHO) {
2803 CDB[1] = 0x0A;
2804 } else {
2805 CDB[1] = 0x02;
2806 }
2807
2808 if (io->flags & MPT_ICFLAG_BUF_CAP) {
2809 CDB[1] |= 0x01;
2810 }
2811 CDB[6] = (io->size >> 16) & 0xFF;
2812 CDB[7] = (io->size >> 8) & 0xFF;
2813 CDB[8] = io->size & 0xFF;
2814 timeout = 10;
2815 break;
2816
2817 case WRITE_BUFFER:
2818 cmdLen = 10;
2819 dir = MPI_SCSIIO_CONTROL_WRITE;
2820 CDB[0] = cmd;
2821 if (io->flags & MPT_ICFLAG_ECHO) {
2822 CDB[1] = 0x0A;
2823 } else {
2824 CDB[1] = 0x02;
2825 }
2826 CDB[6] = (io->size >> 16) & 0xFF;
2827 CDB[7] = (io->size >> 8) & 0xFF;
2828 CDB[8] = io->size & 0xFF;
2829 timeout = 10;
2830 break;
2831
2832 case RESERVE:
2833 cmdLen = 6;
2834 dir = MPI_SCSIIO_CONTROL_READ;
2835 CDB[0] = cmd;
2836 timeout = 10;
2837 break;
2838
2839 case RELEASE:
2840 cmdLen = 6;
2841 dir = MPI_SCSIIO_CONTROL_READ;
2842 CDB[0] = cmd;
2843 timeout = 10;
2844 break;
2845
2846 case SYNCHRONIZE_CACHE:
2847 cmdLen = 10;
2848 dir = MPI_SCSIIO_CONTROL_READ;
2849 CDB[0] = cmd;
2850 // CDB[1] = 0x02; /* set immediate bit */
2851 timeout = 10;
2852 break;
2853
2854 default:
2855 /* Error Case */
2856 ret = -EFAULT;
2857 goto out;
2858 }
2859
2860 /* Get and Populate a free Frame
2861 * MsgContext set in mpt_get_msg_frame call
2862 */
2863 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
2864 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
2865 ioc->name, __func__));
2866 ret = MPT_SCANDV_BUSY;
2867 goto out;
2868 }
2869
2870 pScsiReq = (SCSIIORequest_t *) mf;
2871
2872 /* Get the request index */
2873 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2874 ADD_INDEX_LOG(my_idx); /* for debug */
2875
2876 if (io->flags & MPT_ICFLAG_PHYS_DISK) {
2877 pScsiReq->TargetID = io->physDiskNum;
2878 pScsiReq->Bus = 0;
2879 pScsiReq->ChainOffset = 0;
2880 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
2881 } else {
2882 pScsiReq->TargetID = io->id;
2883 pScsiReq->Bus = io->channel;
2884 pScsiReq->ChainOffset = 0;
2885 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
2886 }
2887
2888 pScsiReq->CDBLength = cmdLen;
2889 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2890
2891 pScsiReq->Reserved = 0;
2892
2893 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
2894 /* MsgContext set in mpt_get_msg_fram call */
2895
2896 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
2897
2898 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
2899 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
2900 else
2901 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2902
2903 if (cmd == REQUEST_SENSE) {
2904 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2905 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2906 "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd));
2907 }
2908
2909 for (ii = 0; ii < 16; ii++)
2910 pScsiReq->CDB[ii] = CDB[ii];
2911
2912 pScsiReq->DataLength = cpu_to_le32(io->size);
2913 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
2914 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
2915
2916 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2917 "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%d\n",
2918 ioc->name, __func__, cmd, io->channel, io->id, io->lun));
2919
2920 if (dir == MPI_SCSIIO_CONTROL_READ)
2921 ioc->add_sge((char *) &pScsiReq->SGL,
2922 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
2923 else
2924 ioc->add_sge((char *) &pScsiReq->SGL,
2925 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
2926
2927 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
2928 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
2929 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
2930 timeout*HZ);
2931 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2932 ret = MPT_SCANDV_DID_RESET;
2933 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2934 "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__,
2935 cmd));
2936 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
2937 mpt_free_msg_frame(ioc, mf);
2938 goto out;
2939 }
2940 if (!timeleft) {
2941 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
2942 ioc->name, __func__);
2943 mpt_HardResetHandler(ioc, CAN_SLEEP);
2944 mpt_free_msg_frame(ioc, mf);
2945 }
2946 goto out;
2947 }
2948
2949 ret = ioc->internal_cmds.completion_code;
2950 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
2951 ioc->name, __func__, ret));
2952
2953 out:
2954 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
2955 mutex_unlock(&ioc->internal_cmds.mutex);
2956 return ret;
2957 }
2958
2959 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2960 /**
2961 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
2962 * @hd: Pointer to a SCSI HOST structure
2963 * @vdevice: virtual target device
2964 *
2965 * Uses the ISR, but with special processing.
2966 * MUST be single-threaded.
2967 *
2968 */
2969 static void
2970 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
2971 {
2972 INTERNAL_CMD iocmd;
2973
2974 /* Ignore hidden raid components, this is handled when the command
2975 * is sent to the volume
2976 */
2977 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
2978 return;
2979
2980 if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted ||
2981 !vdevice->configured_lun)
2982 return;
2983
2984 /* Following parameters will not change
2985 * in this routine.
2986 */
2987 iocmd.cmd = SYNCHRONIZE_CACHE;
2988 iocmd.flags = 0;
2989 iocmd.physDiskNum = -1;
2990 iocmd.data = NULL;
2991 iocmd.data_dma = -1;
2992 iocmd.size = 0;
2993 iocmd.rsvd = iocmd.rsvd2 = 0;
2994 iocmd.channel = vdevice->vtarget->channel;
2995 iocmd.id = vdevice->vtarget->id;
2996 iocmd.lun = vdevice->lun;
2997
2998 mptscsih_do_cmd(hd, &iocmd);
2999 }
3000
3001 static ssize_t
3002 mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
3003 char *buf)
3004 {
3005 struct Scsi_Host *host = class_to_shost(dev);
3006 MPT_SCSI_HOST *hd = shost_priv(host);
3007 MPT_ADAPTER *ioc = hd->ioc;
3008
3009 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
3010 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3011 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3012 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3013 ioc->facts.FWVersion.Word & 0x000000FF);
3014 }
3015 static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
3016
3017 static ssize_t
3018 mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
3019 char *buf)
3020 {
3021 struct Scsi_Host *host = class_to_shost(dev);
3022 MPT_SCSI_HOST *hd = shost_priv(host);
3023 MPT_ADAPTER *ioc = hd->ioc;
3024
3025 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
3026 (ioc->biosVersion & 0xFF000000) >> 24,
3027 (ioc->biosVersion & 0x00FF0000) >> 16,
3028 (ioc->biosVersion & 0x0000FF00) >> 8,
3029 ioc->biosVersion & 0x000000FF);
3030 }
3031 static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
3032
3033 static ssize_t
3034 mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
3035 char *buf)
3036 {
3037 struct Scsi_Host *host = class_to_shost(dev);
3038 MPT_SCSI_HOST *hd = shost_priv(host);
3039 MPT_ADAPTER *ioc = hd->ioc;
3040
3041 return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
3042 }
3043 static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
3044
3045 static ssize_t
3046 mptscsih_version_product_show(struct device *dev,
3047 struct device_attribute *attr,
3048 char *buf)
3049 {
3050 struct Scsi_Host *host = class_to_shost(dev);
3051 MPT_SCSI_HOST *hd = shost_priv(host);
3052 MPT_ADAPTER *ioc = hd->ioc;
3053
3054 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
3055 }
3056 static DEVICE_ATTR(version_product, S_IRUGO,
3057 mptscsih_version_product_show, NULL);
3058
3059 static ssize_t
3060 mptscsih_version_nvdata_persistent_show(struct device *dev,
3061 struct device_attribute *attr,
3062 char *buf)
3063 {
3064 struct Scsi_Host *host = class_to_shost(dev);
3065 MPT_SCSI_HOST *hd = shost_priv(host);
3066 MPT_ADAPTER *ioc = hd->ioc;
3067
3068 return snprintf(buf, PAGE_SIZE, "%02xh\n",
3069 ioc->nvdata_version_persistent);
3070 }
3071 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
3072 mptscsih_version_nvdata_persistent_show, NULL);
3073
3074 static ssize_t
3075 mptscsih_version_nvdata_default_show(struct device *dev,
3076 struct device_attribute *attr, char *buf)
3077 {
3078 struct Scsi_Host *host = class_to_shost(dev);
3079 MPT_SCSI_HOST *hd = shost_priv(host);
3080 MPT_ADAPTER *ioc = hd->ioc;
3081
3082 return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
3083 }
3084 static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
3085 mptscsih_version_nvdata_default_show, NULL);
3086
3087 static ssize_t
3088 mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
3089 char *buf)
3090 {
3091 struct Scsi_Host *host = class_to_shost(dev);
3092 MPT_SCSI_HOST *hd = shost_priv(host);
3093 MPT_ADAPTER *ioc = hd->ioc;
3094
3095 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
3096 }
3097 static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
3098
3099 static ssize_t
3100 mptscsih_board_assembly_show(struct device *dev,
3101 struct device_attribute *attr, char *buf)
3102 {
3103 struct Scsi_Host *host = class_to_shost(dev);
3104 MPT_SCSI_HOST *hd = shost_priv(host);
3105 MPT_ADAPTER *ioc = hd->ioc;
3106
3107 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
3108 }
3109 static DEVICE_ATTR(board_assembly, S_IRUGO,
3110 mptscsih_board_assembly_show, NULL);
3111
3112 static ssize_t
3113 mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
3114 char *buf)
3115 {
3116 struct Scsi_Host *host = class_to_shost(dev);
3117 MPT_SCSI_HOST *hd = shost_priv(host);
3118 MPT_ADAPTER *ioc = hd->ioc;
3119
3120 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
3121 }
3122 static DEVICE_ATTR(board_tracer, S_IRUGO,
3123 mptscsih_board_tracer_show, NULL);
3124
3125 static ssize_t
3126 mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
3127 char *buf)
3128 {
3129 struct Scsi_Host *host = class_to_shost(dev);
3130 MPT_SCSI_HOST *hd = shost_priv(host);
3131 MPT_ADAPTER *ioc = hd->ioc;
3132
3133 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
3134 }
3135 static DEVICE_ATTR(io_delay, S_IRUGO,
3136 mptscsih_io_delay_show, NULL);
3137
3138 static ssize_t
3139 mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
3140 char *buf)
3141 {
3142 struct Scsi_Host *host = class_to_shost(dev);
3143 MPT_SCSI_HOST *hd = shost_priv(host);
3144 MPT_ADAPTER *ioc = hd->ioc;
3145
3146 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
3147 }
3148 static DEVICE_ATTR(device_delay, S_IRUGO,
3149 mptscsih_device_delay_show, NULL);
3150
3151 static ssize_t
3152 mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
3153 char *buf)
3154 {
3155 struct Scsi_Host *host = class_to_shost(dev);
3156 MPT_SCSI_HOST *hd = shost_priv(host);
3157 MPT_ADAPTER *ioc = hd->ioc;
3158
3159 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
3160 }
3161 static ssize_t
3162 mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
3163 const char *buf, size_t count)
3164 {
3165 struct Scsi_Host *host = class_to_shost(dev);
3166 MPT_SCSI_HOST *hd = shost_priv(host);
3167 MPT_ADAPTER *ioc = hd->ioc;
3168 int val = 0;
3169
3170 if (sscanf(buf, "%x", &val) != 1)
3171 return -EINVAL;
3172
3173 ioc->debug_level = val;
3174 printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
3175 ioc->name, ioc->debug_level);
3176 return strlen(buf);
3177 }
3178 static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
3179 mptscsih_debug_level_show, mptscsih_debug_level_store);
3180
3181 struct device_attribute *mptscsih_host_attrs[] = {
3182 &dev_attr_version_fw,
3183 &dev_attr_version_bios,
3184 &dev_attr_version_mpi,
3185 &dev_attr_version_product,
3186 &dev_attr_version_nvdata_persistent,
3187 &dev_attr_version_nvdata_default,
3188 &dev_attr_board_name,
3189 &dev_attr_board_assembly,
3190 &dev_attr_board_tracer,
3191 &dev_attr_io_delay,
3192 &dev_attr_device_delay,
3193 &dev_attr_debug_level,
3194 NULL,
3195 };
3196
3197 EXPORT_SYMBOL(mptscsih_host_attrs);
3198
3199 EXPORT_SYMBOL(mptscsih_remove);
3200 EXPORT_SYMBOL(mptscsih_shutdown);
3201 #ifdef CONFIG_PM
3202 EXPORT_SYMBOL(mptscsih_suspend);
3203 EXPORT_SYMBOL(mptscsih_resume);
3204 #endif
3205 EXPORT_SYMBOL(mptscsih_proc_info);
3206 EXPORT_SYMBOL(mptscsih_info);
3207 EXPORT_SYMBOL(mptscsih_qcmd);
3208 EXPORT_SYMBOL(mptscsih_slave_destroy);
3209 EXPORT_SYMBOL(mptscsih_slave_configure);
3210 EXPORT_SYMBOL(mptscsih_abort);
3211 EXPORT_SYMBOL(mptscsih_dev_reset);
3212 EXPORT_SYMBOL(mptscsih_bus_reset);
3213 EXPORT_SYMBOL(mptscsih_host_reset);
3214 EXPORT_SYMBOL(mptscsih_bios_param);
3215 EXPORT_SYMBOL(mptscsih_io_done);
3216 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3217 EXPORT_SYMBOL(mptscsih_scandv_complete);
3218 EXPORT_SYMBOL(mptscsih_event_process);
3219 EXPORT_SYMBOL(mptscsih_ioc_reset);
3220 EXPORT_SYMBOL(mptscsih_change_queue_depth);
3221
3222 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree