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