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