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