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