37bf65348372c8b629651ff2f2c3128182a2e653
[linux-2.6.git] / drivers / message / fusion / mptspi.c
1 /*
2  *  linux/drivers/message/fusion/mptspi.c
3  *      For use with LSI Logic PCI chip/adapter(s)
4  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
5  *
6  *  Copyright (c) 1999-2007 LSI Logic Corporation
7  *  (mailto:mpt_linux_developer@lsi.com)
8  *
9  */
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11 /*
12     This program is free software; you can redistribute it and/or modify
13     it under the terms of the GNU General Public License as published by
14     the Free Software Foundation; version 2 of the License.
15
16     This program is distributed in the hope that it will be useful,
17     but WITHOUT ANY WARRANTY; without even the implied warranty of
18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19     GNU General Public License for more details.
20
21     NO WARRANTY
22     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26     solely responsible for determining the appropriateness of using and
27     distributing the Program and assumes all risks associated with its
28     exercise of rights under this Agreement, including but not limited to
29     the risks and costs of program errors, damage to or loss of data,
30     programs or equipment, and unavailability or interruption of operations.
31
32     DISCLAIMER OF LIABILITY
33     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40
41     You should have received a copy of the GNU General Public License
42     along with this program; if not, write to the Free Software
43     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
44 */
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46
47 #include "linux_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/workqueue.h>
58 #include <linux/raid_class.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_transport.h>
66 #include <scsi/scsi_transport_spi.h>
67 #include <scsi/scsi_dbg.h>
68
69 #include "mptbase.h"
70 #include "mptscsih.h"
71
72 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
73 #define my_NAME         "Fusion MPT SPI Host driver"
74 #define my_VERSION      MPT_LINUX_VERSION_COMMON
75 #define MYNAM           "mptspi"
76
77 MODULE_AUTHOR(MODULEAUTHOR);
78 MODULE_DESCRIPTION(my_NAME);
79 MODULE_LICENSE("GPL");
80 MODULE_VERSION(my_VERSION);
81
82 /* Command line args */
83 static int mpt_saf_te = MPTSCSIH_SAF_TE;
84 module_param(mpt_saf_te, int, 0);
85 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
86
87 static void mptspi_write_offset(struct scsi_target *, int);
88 static void mptspi_write_width(struct scsi_target *, int);
89 static int mptspi_write_spi_device_pg1(struct scsi_target *,
90                                        struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
91
92 static struct scsi_transport_template *mptspi_transport_template = NULL;
93
94 static int      mptspiDoneCtx = -1;
95 static int      mptspiTaskCtx = -1;
96 static int      mptspiInternalCtx = -1; /* Used only for internal commands */
97
98 /**
99  *      mptspi_setTargetNegoParms  - Update the target negotiation parameters
100  *      @hd: Pointer to a SCSI Host Structure
101  *      @target: per target private data
102  *      @sdev: SCSI device
103  *
104  *      Update the target negotiation parameters based on the the Inquiry
105  *      data, adapter capabilities, and NVRAM settings.
106  **/
107 static void
108 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
109                             struct scsi_device *sdev)
110 {
111         SpiCfgData *pspi_data = &hd->ioc->spi_data;
112         int  id = (int) target->id;
113         int  nvram;
114         u8 width = MPT_NARROW;
115         u8 factor = MPT_ASYNC;
116         u8 offset = 0;
117         u8 nfactor;
118         u8 noQas = 1;
119
120         target->negoFlags = pspi_data->noQas;
121
122         if (sdev->scsi_level < SCSI_2) {
123                 width = 0;
124                 factor = MPT_ULTRA2;
125                 offset = pspi_data->maxSyncOffset;
126                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
127         } else {
128                 if (scsi_device_wide(sdev))
129                         width = 1;
130
131                 if (scsi_device_sync(sdev)) {
132                         factor = pspi_data->minSyncFactor;
133                         if (!scsi_device_dt(sdev))
134                                         factor = MPT_ULTRA2;
135                         else {
136                                 if (!scsi_device_ius(sdev) &&
137                                     !scsi_device_qas(sdev))
138                                         factor = MPT_ULTRA160;
139                                 else {
140                                         factor = MPT_ULTRA320;
141                                         if (scsi_device_qas(sdev)) {
142                                                 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
143                                                 noQas = 0;
144                                         }
145                                         if (sdev->type == TYPE_TAPE &&
146                                             scsi_device_ius(sdev))
147                                                 target->negoFlags |= MPT_TAPE_NEGO_IDP;
148                                 }
149                         }
150                         offset = pspi_data->maxSyncOffset;
151
152                         /* If RAID, never disable QAS
153                          * else if non RAID, do not disable
154                          *   QAS if bit 1 is set
155                          * bit 1 QAS support, non-raid only
156                          * bit 0 IU support
157                          */
158                         if (target->raidVolume == 1)
159                                 noQas = 0;
160                 } else {
161                         factor = MPT_ASYNC;
162                         offset = 0;
163                 }
164         }
165
166         if (!sdev->tagged_supported)
167                 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
168
169         /* Update tflags based on NVRAM settings. (SCSI only)
170          */
171         if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
172                 nvram = pspi_data->nvram[id];
173                 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
174
175                 if (width)
176                         width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
177
178                 if (offset > 0) {
179                         /* Ensure factor is set to the
180                          * maximum of: adapter, nvram, inquiry
181                          */
182                         if (nfactor) {
183                                 if (nfactor < pspi_data->minSyncFactor )
184                                         nfactor = pspi_data->minSyncFactor;
185
186                                 factor = max(factor, nfactor);
187                                 if (factor == MPT_ASYNC)
188                                         offset = 0;
189                         } else {
190                                 offset = 0;
191                                 factor = MPT_ASYNC;
192                 }
193                 } else {
194                         factor = MPT_ASYNC;
195                 }
196         }
197
198         /* Make sure data is consistent
199          */
200         if ((!width) && (factor < MPT_ULTRA2))
201                 factor = MPT_ULTRA2;
202
203         /* Save the data to the target structure.
204          */
205         target->minSyncFactor = factor;
206         target->maxOffset = offset;
207         target->maxWidth = width;
208
209         target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
210
211         /* Disable unused features.
212          */
213         if (!width)
214                 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
215
216         if (!offset)
217                 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
218
219         if ( factor > MPT_ULTRA320 )
220                 noQas = 0;
221
222         if (noQas && (pspi_data->noQas == 0)) {
223                 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
224                 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
225
226                 /* Disable QAS in a mixed configuration case
227                  */
228
229                 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
230         }
231 }
232
233 /**
234  *      mptspi_writeIOCPage4  - write IOC Page 4
235  *      @hd: Pointer to a SCSI Host Structure
236  *      @channel: channel number
237  *      @id: write IOC Page4 for this ID & Bus
238  *
239  *      Return: -EAGAIN if unable to obtain a Message Frame
240  *              or 0 if success.
241  *
242  *      Remark: We do not wait for a return, write pages sequentially.
243  **/
244 static int
245 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
246 {
247         MPT_ADAPTER             *ioc = hd->ioc;
248         Config_t                *pReq;
249         IOCPage4_t              *IOCPage4Ptr;
250         MPT_FRAME_HDR           *mf;
251         dma_addr_t               dataDma;
252         u16                      req_idx;
253         u32                      frameOffset;
254         u32                      flagsLength;
255         int                      ii;
256
257         /* Get a MF for this command.
258          */
259         if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
260                 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
261                                         ioc->name));
262                 return -EAGAIN;
263         }
264
265         /* Set the request and the data pointers.
266          * Place data at end of MF.
267          */
268         pReq = (Config_t *)mf;
269
270         req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
271         frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
272
273         /* Complete the request frame (same for all requests).
274          */
275         pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
276         pReq->Reserved = 0;
277         pReq->ChainOffset = 0;
278         pReq->Function = MPI_FUNCTION_CONFIG;
279         pReq->ExtPageLength = 0;
280         pReq->ExtPageType = 0;
281         pReq->MsgFlags = 0;
282         for (ii=0; ii < 8; ii++) {
283                 pReq->Reserved2[ii] = 0;
284         }
285
286         IOCPage4Ptr = ioc->spi_data.pIocPg4;
287         dataDma = ioc->spi_data.IocPg4_dma;
288         ii = IOCPage4Ptr->ActiveSEP++;
289         IOCPage4Ptr->SEP[ii].SEPTargetID = id;
290         IOCPage4Ptr->SEP[ii].SEPBus = channel;
291         pReq->Header = IOCPage4Ptr->Header;
292         pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
293
294         /* Add a SGE to the config request.
295          */
296         flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
297                 (IOCPage4Ptr->Header.PageLength + ii) * 4;
298
299         mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
300
301         ddvprintk((MYIOC_s_INFO_FMT
302                 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
303                         ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
304
305         mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
306
307         return 0;
308 }
309
310 /**
311  *      mptspi_initTarget - Target, LUN alloc/free functionality.
312  *      @hd: Pointer to MPT_SCSI_HOST structure
313  *      @vtarget: per target private data
314  *      @sdev: SCSI device
315  *
316  *      NOTE: It's only SAFE to call this routine if data points to
317  *      sane & valid STANDARD INQUIRY data!
318  *
319  *      Allocate and initialize memory for this target.
320  *      Save inquiry data.
321  *
322  **/
323 static void
324 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
325                     struct scsi_device *sdev)
326 {
327
328         /* Is LUN supported? If so, upper 2 bits will be 0
329         * in first byte of inquiry data.
330         */
331         if (sdev->inq_periph_qual != 0)
332                 return;
333
334         if (vtarget == NULL)
335                 return;
336
337         vtarget->type = sdev->type;
338
339         if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
340                 /* Treat all Processors as SAF-TE if
341                  * command line option is set */
342                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
343                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
344         }else if ((sdev->type == TYPE_PROCESSOR) &&
345                 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
346                 if (sdev->inquiry_len > 49 ) {
347                         if (sdev->inquiry[44] == 'S' &&
348                             sdev->inquiry[45] == 'A' &&
349                             sdev->inquiry[46] == 'F' &&
350                             sdev->inquiry[47] == '-' &&
351                             sdev->inquiry[48] == 'T' &&
352                             sdev->inquiry[49] == 'E' ) {
353                                 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
354                                 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
355                         }
356                 }
357         }
358         mptspi_setTargetNegoParms(hd, vtarget, sdev);
359 }
360
361 /**
362  *      mptspi_is_raid - Determines whether target is belonging to volume
363  *      @hd: Pointer to a SCSI HOST structure
364  *      @id: target device id
365  *
366  *      Return:
367  *              non-zero = true
368  *              zero = false
369  *
370  */
371 static int
372 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
373 {
374         int i, rc = 0;
375
376         if (!hd->ioc->raid_data.pIocPg2)
377                 goto out;
378
379         if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
380                 goto out;
381         for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
382                 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
383                         rc = 1;
384                         goto out;
385                 }
386         }
387
388  out:
389         return rc;
390 }
391
392 static int mptspi_target_alloc(struct scsi_target *starget)
393 {
394         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
395         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
396         VirtTarget              *vtarget;
397
398         if (hd == NULL)
399                 return -ENODEV;
400
401         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
402         if (!vtarget)
403                 return -ENOMEM;
404
405         vtarget->ioc_id = hd->ioc->id;
406         vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
407         vtarget->id = (u8)starget->id;
408         vtarget->channel = (u8)starget->channel;
409         vtarget->starget = starget;
410         starget->hostdata = vtarget;
411
412         if (starget->channel == 1) {
413                 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
414                         return 0;
415                 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
416                 /* The real channel for this device is zero */
417                 vtarget->channel = 0;
418                 /* The actual physdisknum (for RAID passthrough) */
419                 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
420                     starget->id);
421         }
422
423         if (starget->channel == 0 &&
424             mptspi_is_raid(hd, starget->id)) {
425                 vtarget->raidVolume = 1;
426                 ddvprintk((KERN_INFO
427                     "RAID Volume @ channel=%d id=%d\n", starget->channel,
428                     starget->id));
429         }
430
431         if (hd->ioc->spi_data.nvram &&
432             hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
433                 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
434                 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
435                 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
436         } else {
437                 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
438                 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
439         }
440         spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
441
442         spi_offset(starget) = 0;
443         mptspi_write_width(starget, 0);
444
445         return 0;
446 }
447
448 static void
449 mptspi_target_destroy(struct scsi_target *starget)
450 {
451         if (starget->hostdata)
452                 kfree(starget->hostdata);
453         starget->hostdata = NULL;
454 }
455
456 /**
457  *      mptspi_print_write_nego - negotiation parameters debug info that is being sent
458  *      @hd: Pointer to a SCSI HOST structure
459  *      @starget: SCSI target
460  *      @ii: negotiation parameters
461  *
462  */
463 static void
464 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
465 {
466         ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x"
467             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
468             hd->ioc->name, starget->id, ii,
469             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
470             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
471             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
472             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
473             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
474             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
475             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
476             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
477             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
478             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
479 }
480
481 /**
482  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
483  *      @hd: Pointer to a SCSI HOST structure
484  *      @starget: SCSI target
485  *      @ii: negotiation parameters
486  *
487  */
488 static void
489 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
490 {
491         ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x"
492             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
493             hd->ioc->name, starget->id, ii,
494             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
495             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
496             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
497             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
498             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
499             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
500             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
501             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
502             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
503             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
504 }
505
506 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
507                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
508 {
509         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
510         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
511         struct _MPT_ADAPTER *ioc = hd->ioc;
512         struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
513         dma_addr_t pg0_dma;
514         int size;
515         struct _x_config_parms cfg;
516         struct _CONFIG_PAGE_HEADER hdr;
517         int err = -EBUSY;
518
519         /* No SPI parameters for RAID devices */
520         if (starget->channel == 0 &&
521             mptspi_is_raid(hd, starget->id))
522                 return -1;
523
524         size = ioc->spi_data.sdp0length * 4;
525         /*
526         if (ioc->spi_data.sdp0length & 1)
527                 size += size + 4;
528         size += 2048;
529         */
530
531         pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
532         if (pg0 == NULL) {
533                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
534                 return -EINVAL;
535         }
536
537         memset(&hdr, 0, sizeof(hdr));
538
539         hdr.PageVersion = ioc->spi_data.sdp0version;
540         hdr.PageLength = ioc->spi_data.sdp0length;
541         hdr.PageNumber = 0;
542         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
543
544         memset(&cfg, 0, sizeof(cfg));
545
546         cfg.cfghdr.hdr = &hdr;
547         cfg.physAddr = pg0_dma;
548         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
549         cfg.dir = 0;
550         cfg.pageAddr = starget->id;
551
552         if (mpt_config(ioc, &cfg)) {
553                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
554                 goto out_free;
555         }
556         err = 0;
557         memcpy(pass_pg0, pg0, size);
558
559         mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
560
561  out_free:
562         dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
563         return err;
564 }
565
566 static u32 mptspi_getRP(struct scsi_target *starget)
567 {
568         u32 nego = 0;
569
570         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
571         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
572         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
573         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
574         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
575         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
576         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
577         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
578
579         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
580         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
581         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
582
583         return nego;
584 }
585
586 static void mptspi_read_parameters(struct scsi_target *starget)
587 {
588         int nego;
589         struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
590
591         mptspi_read_spi_device_pg0(starget, &pg0);
592
593         nego = le32_to_cpu(pg0.NegotiatedParameters);
594
595         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
596         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
597         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
598         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
599         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
600         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
601         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
602         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
603         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
604         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
605         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
606 }
607
608 static int
609 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
610 {
611         MpiRaidActionRequest_t  *pReq;
612         MPT_FRAME_HDR           *mf;
613
614         /* Get and Populate a free Frame
615          */
616         if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
617                 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
618                                         hd->ioc->name));
619                 return -EAGAIN;
620         }
621         pReq = (MpiRaidActionRequest_t *)mf;
622         if (quiesce)
623                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
624         else
625                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
626         pReq->Reserved1 = 0;
627         pReq->ChainOffset = 0;
628         pReq->Function = MPI_FUNCTION_RAID_ACTION;
629         pReq->VolumeID = id;
630         pReq->VolumeBus = channel;
631         pReq->PhysDiskNum = 0;
632         pReq->MsgFlags = 0;
633         pReq->Reserved2 = 0;
634         pReq->ActionDataWord = 0; /* Reserved for this action */
635
636         mpt_add_sge((char *)&pReq->ActionDataSGE,
637                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
638
639         ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n",
640                         hd->ioc->name, pReq->Action, channel, id));
641
642         hd->pLocal = NULL;
643         hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
644         hd->scandv_wait_done = 0;
645
646         /* Save cmd pointer, for resource free if timeout or
647          * FW reload occurs
648          */
649         hd->cmdPtr = mf;
650
651         add_timer(&hd->timer);
652         mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
653         wait_event(hd->scandv_waitq, hd->scandv_wait_done);
654
655         if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
656                 return -1;
657
658         return 0;
659 }
660
661 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
662                              struct scsi_device *sdev)
663 {
664         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
665
666         /* no DV on RAID devices */
667         if (sdev->channel == 0 &&
668             mptspi_is_raid(hd, sdev->id))
669                 return;
670
671         /* If this is a piece of a RAID, then quiesce first */
672         if (sdev->channel == 1 &&
673             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
674                 starget_printk(KERN_ERR, scsi_target(sdev),
675                                "Integrated RAID quiesce failed\n");
676                 return;
677         }
678
679         hd->spi_pending |= (1 << sdev->id);
680         spi_dv_device(sdev);
681         hd->spi_pending &= ~(1 << sdev->id);
682
683         if (sdev->channel == 1 &&
684             mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
685                 starget_printk(KERN_ERR, scsi_target(sdev),
686                                "Integrated RAID resume failed\n");
687
688         mptspi_read_parameters(sdev->sdev_target);
689         spi_display_xfer_agreement(sdev->sdev_target);
690         mptspi_read_parameters(sdev->sdev_target);
691 }
692
693 static int mptspi_slave_alloc(struct scsi_device *sdev)
694 {
695         MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
696         VirtTarget              *vtarget;
697         VirtDevice              *vdev;
698         struct scsi_target      *starget;
699
700         if (sdev->channel == 1 &&
701                 mptscsih_is_phys_disk(hd->ioc, 0, sdev->id) == 0)
702                         return -ENXIO;
703
704         vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
705         if (!vdev) {
706                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
707                                 hd->ioc->name, sizeof(VirtDevice));
708                 return -ENOMEM;
709         }
710
711         vdev->lun = sdev->lun;
712         sdev->hostdata = vdev;
713
714         starget = scsi_target(sdev);
715         vtarget = starget->hostdata;
716         vdev->vtarget = vtarget;
717         vtarget->num_luns++;
718
719         if (sdev->channel == 1)
720                 sdev->no_uld_attach = 1;
721
722         return 0;
723 }
724
725 static int mptspi_slave_configure(struct scsi_device *sdev)
726 {
727         struct _MPT_SCSI_HOST *hd =
728                 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
729         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
730         int ret;
731
732         mptspi_initTarget(hd, vtarget, sdev);
733
734         ret = mptscsih_slave_configure(sdev);
735
736         if (ret)
737                 return ret;
738
739         ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
740                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
741                 sdev->id, spi_min_period(scsi_target(sdev)),
742                 spi_max_offset(scsi_target(sdev)),
743                 spi_max_width(scsi_target(sdev))));
744
745         if ((sdev->channel == 1 ||
746              !(mptspi_is_raid(hd, sdev->id))) &&
747             !spi_initial_dv(sdev->sdev_target))
748                 mptspi_dv_device(hd, sdev);
749
750         return 0;
751 }
752
753 static int
754 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
755 {
756         struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
757         VirtDevice      *vdev = SCpnt->device->hostdata;
758
759         if (!vdev || !vdev->vtarget) {
760                 SCpnt->result = DID_NO_CONNECT << 16;
761                 done(SCpnt);
762                 return 0;
763         }
764
765         if (SCpnt->device->channel == 1 &&
766                 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
767                 SCpnt->result = DID_NO_CONNECT << 16;
768                 done(SCpnt);
769                 return 0;
770         }
771
772 #ifdef MPT_DEBUG_DV
773         if (spi_dv_pending(scsi_target(SCpnt->device)))
774                 scsi_print_command(SCpnt);
775 #endif
776
777         return mptscsih_qcmd(SCpnt,done);
778 }
779
780 static void mptspi_slave_destroy(struct scsi_device *sdev)
781 {
782         struct scsi_target *starget = scsi_target(sdev);
783         VirtTarget *vtarget = starget->hostdata;
784         VirtDevice *vdevice = sdev->hostdata;
785
786         /* Will this be the last lun on a non-raid device? */
787         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
788                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
789
790                 /* Async Narrow */
791                 pg1.RequestedParameters = 0;
792                 pg1.Reserved = 0;
793                 pg1.Configuration = 0;
794
795                 mptspi_write_spi_device_pg1(starget, &pg1);
796         }
797
798         mptscsih_slave_destroy(sdev);
799 }
800
801 static struct scsi_host_template mptspi_driver_template = {
802         .module                         = THIS_MODULE,
803         .proc_name                      = "mptspi",
804         .proc_info                      = mptscsih_proc_info,
805         .name                           = "MPT SPI Host",
806         .info                           = mptscsih_info,
807         .queuecommand                   = mptspi_qcmd,
808         .target_alloc                   = mptspi_target_alloc,
809         .slave_alloc                    = mptspi_slave_alloc,
810         .slave_configure                = mptspi_slave_configure,
811         .target_destroy                 = mptspi_target_destroy,
812         .slave_destroy                  = mptspi_slave_destroy,
813         .change_queue_depth             = mptscsih_change_queue_depth,
814         .eh_abort_handler               = mptscsih_abort,
815         .eh_device_reset_handler        = mptscsih_dev_reset,
816         .eh_bus_reset_handler           = mptscsih_bus_reset,
817         .eh_host_reset_handler          = mptscsih_host_reset,
818         .bios_param                     = mptscsih_bios_param,
819         .can_queue                      = MPT_SCSI_CAN_QUEUE,
820         .this_id                        = -1,
821         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
822         .max_sectors                    = 8192,
823         .cmd_per_lun                    = 7,
824         .use_clustering                 = ENABLE_CLUSTERING,
825 };
826
827 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
828                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
829 {
830         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
831         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
832         struct _MPT_ADAPTER *ioc = hd->ioc;
833         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
834         dma_addr_t pg1_dma;
835         int size;
836         struct _x_config_parms cfg;
837         struct _CONFIG_PAGE_HEADER hdr;
838         int err = -EBUSY;
839
840         /* don't allow updating nego parameters on RAID devices */
841         if (starget->channel == 0 &&
842             mptspi_is_raid(hd, starget->id))
843                 return -1;
844
845         size = ioc->spi_data.sdp1length * 4;
846
847         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
848         if (pg1 == NULL) {
849                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
850                 return -EINVAL;
851         }
852
853         memset(&hdr, 0, sizeof(hdr));
854
855         hdr.PageVersion = ioc->spi_data.sdp1version;
856         hdr.PageLength = ioc->spi_data.sdp1length;
857         hdr.PageNumber = 1;
858         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
859
860         memset(&cfg, 0, sizeof(cfg));
861
862         cfg.cfghdr.hdr = &hdr;
863         cfg.physAddr = pg1_dma;
864         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
865         cfg.dir = 1;
866         cfg.pageAddr = starget->id;
867
868         memcpy(pg1, pass_pg1, size);
869
870         pg1->Header.PageVersion = hdr.PageVersion;
871         pg1->Header.PageLength = hdr.PageLength;
872         pg1->Header.PageNumber = hdr.PageNumber;
873         pg1->Header.PageType = hdr.PageType;
874
875         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
876
877         if (mpt_config(ioc, &cfg)) {
878                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
879                 goto out_free;
880         }
881         err = 0;
882
883  out_free:
884         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
885         return err;
886 }
887
888 static void mptspi_write_offset(struct scsi_target *starget, int offset)
889 {
890         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
891         u32 nego;
892
893         if (offset < 0)
894                 offset = 0;
895
896         if (offset > 255)
897                 offset = 255;
898
899         if (spi_offset(starget) == -1)
900                 mptspi_read_parameters(starget);
901
902         spi_offset(starget) = offset;
903
904         nego = mptspi_getRP(starget);
905
906         pg1.RequestedParameters = cpu_to_le32(nego);
907         pg1.Reserved = 0;
908         pg1.Configuration = 0;
909
910         mptspi_write_spi_device_pg1(starget, &pg1);
911 }
912
913 static void mptspi_write_period(struct scsi_target *starget, int period)
914 {
915         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
916         u32 nego;
917
918         if (period < 8)
919                 period = 8;
920
921         if (period > 255)
922                 period = 255;
923
924         if (spi_period(starget) == -1)
925                 mptspi_read_parameters(starget);
926
927         if (period == 8) {
928                 spi_iu(starget) = 1;
929                 spi_dt(starget) = 1;
930         } else if (period == 9) {
931                 spi_dt(starget) = 1;
932         }
933
934         spi_period(starget) = period;
935
936         nego = mptspi_getRP(starget);
937
938         pg1.RequestedParameters = cpu_to_le32(nego);
939         pg1.Reserved = 0;
940         pg1.Configuration = 0;
941
942         mptspi_write_spi_device_pg1(starget, &pg1);
943 }
944
945 static void mptspi_write_dt(struct scsi_target *starget, int dt)
946 {
947         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
948         u32 nego;
949
950         if (spi_period(starget) == -1)
951                 mptspi_read_parameters(starget);
952
953         if (!dt && spi_period(starget) < 10)
954                 spi_period(starget) = 10;
955
956         spi_dt(starget) = dt;
957
958         nego = mptspi_getRP(starget);
959
960
961         pg1.RequestedParameters = cpu_to_le32(nego);
962         pg1.Reserved = 0;
963         pg1.Configuration = 0;
964
965         mptspi_write_spi_device_pg1(starget, &pg1);
966 }
967
968 static void mptspi_write_iu(struct scsi_target *starget, int iu)
969 {
970         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
971         u32 nego;
972
973         if (spi_period(starget) == -1)
974                 mptspi_read_parameters(starget);
975
976         if (!iu && spi_period(starget) < 9)
977                 spi_period(starget) = 9;
978
979         spi_iu(starget) = iu;
980
981         nego = mptspi_getRP(starget);
982
983         pg1.RequestedParameters = cpu_to_le32(nego);
984         pg1.Reserved = 0;
985         pg1.Configuration = 0;
986
987         mptspi_write_spi_device_pg1(starget, &pg1);
988 }
989
990 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
991 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
992 {                                                                       \
993         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
994         u32 nego;                                                       \
995                                                                         \
996         spi_##parm(starget) = parm;                                     \
997                                                                         \
998         nego = mptspi_getRP(starget);                                   \
999                                                                         \
1000         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1001         pg1.Reserved = 0;                                               \
1002         pg1.Configuration = 0;                                          \
1003                                                                         \
1004         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1005 }
1006
1007 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1009 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1010 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1011 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1012
1013 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1014 {
1015         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1016         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1017         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1018         VirtTarget *vtarget = starget->hostdata;
1019         u32 nego;
1020
1021         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1022             hd->ioc->spi_data.noQas)
1023                 spi_qas(starget) = 0;
1024         else
1025                 spi_qas(starget) = qas;
1026
1027         nego = mptspi_getRP(starget);
1028
1029         pg1.RequestedParameters = cpu_to_le32(nego);
1030         pg1.Reserved = 0;
1031         pg1.Configuration = 0;
1032
1033         mptspi_write_spi_device_pg1(starget, &pg1);
1034 }
1035
1036 static void mptspi_write_width(struct scsi_target *starget, int width)
1037 {
1038         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1039         u32 nego;
1040
1041         if (!width) {
1042                 spi_dt(starget) = 0;
1043                 if (spi_period(starget) < 10)
1044                         spi_period(starget) = 10;
1045         }
1046
1047         spi_width(starget) = width;
1048
1049         nego = mptspi_getRP(starget);
1050
1051         pg1.RequestedParameters = cpu_to_le32(nego);
1052         pg1.Reserved = 0;
1053         pg1.Configuration = 0;
1054
1055         mptspi_write_spi_device_pg1(starget, &pg1);
1056 }
1057
1058 struct work_queue_wrapper {
1059         struct work_struct      work;
1060         struct _MPT_SCSI_HOST   *hd;
1061         int                     disk;
1062 };
1063
1064 static void mpt_work_wrapper(struct work_struct *work)
1065 {
1066         struct work_queue_wrapper *wqw =
1067                 container_of(work, struct work_queue_wrapper, work);
1068         struct _MPT_SCSI_HOST *hd = wqw->hd;
1069         struct Scsi_Host *shost = hd->ioc->sh;
1070         struct scsi_device *sdev;
1071         int disk = wqw->disk;
1072         struct _CONFIG_PAGE_IOC_3 *pg3;
1073
1074         kfree(wqw);
1075
1076         mpt_findImVolumes(hd->ioc);
1077         pg3 = hd->ioc->raid_data.pIocPg3;
1078         if (!pg3)
1079                 return;
1080
1081         shost_for_each_device(sdev,shost) {
1082                 struct scsi_target *starget = scsi_target(sdev);
1083                 VirtTarget *vtarget = starget->hostdata;
1084
1085                 /* only want to search RAID components */
1086                 if (sdev->channel != 1)
1087                         continue;
1088
1089                 /* The id is the raid PhysDiskNum, even if
1090                  * starget->id is the actual target address */
1091                 if(vtarget->id != disk)
1092                         continue;
1093
1094                 starget_printk(KERN_INFO, vtarget->starget,
1095                                "Integrated RAID requests DV of new device\n");
1096                 mptspi_dv_device(hd, sdev);
1097         }
1098         shost_printk(KERN_INFO, shost,
1099                      "Integrated RAID detects new device %d\n", disk);
1100         scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1101 }
1102
1103
1104 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1105 {
1106         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1107
1108         if (!wqw) {
1109                 shost_printk(KERN_ERR, hd->ioc->sh,
1110                              "Failed to act on RAID event for physical disk %d\n",
1111                            disk);
1112                 return;
1113         }
1114         INIT_WORK(&wqw->work, mpt_work_wrapper);
1115         wqw->hd = hd;
1116         wqw->disk = disk;
1117
1118         schedule_work(&wqw->work);
1119 }
1120
1121 static int
1122 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1123 {
1124         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1125         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1126
1127         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1128                 int reason
1129                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1130
1131                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1132                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1133                         mpt_dv_raid(hd, disk);
1134                 }
1135         }
1136         return mptscsih_event_process(ioc, pEvReply);
1137 }
1138
1139 static int
1140 mptspi_deny_binding(struct scsi_target *starget)
1141 {
1142         struct _MPT_SCSI_HOST *hd =
1143                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1144         return ((mptspi_is_raid(hd, starget->id)) &&
1145                 starget->channel == 0) ? 1 : 0;
1146 }
1147
1148 static struct spi_function_template mptspi_transport_functions = {
1149         .get_offset     = mptspi_read_parameters,
1150         .set_offset     = mptspi_write_offset,
1151         .show_offset    = 1,
1152         .get_period     = mptspi_read_parameters,
1153         .set_period     = mptspi_write_period,
1154         .show_period    = 1,
1155         .get_width      = mptspi_read_parameters,
1156         .set_width      = mptspi_write_width,
1157         .show_width     = 1,
1158         .get_iu         = mptspi_read_parameters,
1159         .set_iu         = mptspi_write_iu,
1160         .show_iu        = 1,
1161         .get_dt         = mptspi_read_parameters,
1162         .set_dt         = mptspi_write_dt,
1163         .show_dt        = 1,
1164         .get_qas        = mptspi_read_parameters,
1165         .set_qas        = mptspi_write_qas,
1166         .show_qas       = 1,
1167         .get_wr_flow    = mptspi_read_parameters,
1168         .set_wr_flow    = mptspi_write_wr_flow,
1169         .show_wr_flow   = 1,
1170         .get_rd_strm    = mptspi_read_parameters,
1171         .set_rd_strm    = mptspi_write_rd_strm,
1172         .show_rd_strm   = 1,
1173         .get_rti        = mptspi_read_parameters,
1174         .set_rti        = mptspi_write_rti,
1175         .show_rti       = 1,
1176         .get_pcomp_en   = mptspi_read_parameters,
1177         .set_pcomp_en   = mptspi_write_pcomp_en,
1178         .show_pcomp_en  = 1,
1179         .get_hold_mcs   = mptspi_read_parameters,
1180         .set_hold_mcs   = mptspi_write_hold_mcs,
1181         .show_hold_mcs  = 1,
1182         .deny_binding   = mptspi_deny_binding,
1183 };
1184
1185 /****************************************************************************
1186  * Supported hardware
1187  */
1188
1189 static struct pci_device_id mptspi_pci_table[] = {
1190         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1191                 PCI_ANY_ID, PCI_ANY_ID },
1192         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1193                 PCI_ANY_ID, PCI_ANY_ID },
1194         {0}     /* Terminating entry */
1195 };
1196 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1197
1198
1199 /*
1200  * renegotiate for a given target
1201  */
1202 static void
1203 mptspi_dv_renegotiate_work(struct work_struct *work)
1204 {
1205         struct work_queue_wrapper *wqw =
1206                 container_of(work, struct work_queue_wrapper, work);
1207         struct _MPT_SCSI_HOST *hd = wqw->hd;
1208         struct scsi_device *sdev;
1209         struct scsi_target *starget;
1210         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1211         u32 nego;
1212
1213         kfree(wqw);
1214
1215         if (hd->spi_pending) {
1216                 shost_for_each_device(sdev, hd->ioc->sh) {
1217                         if  (hd->spi_pending & (1 << sdev->id))
1218                                 continue;
1219                         starget = scsi_target(sdev);
1220                         nego = mptspi_getRP(starget);
1221                         pg1.RequestedParameters = cpu_to_le32(nego);
1222                         pg1.Reserved = 0;
1223                         pg1.Configuration = 0;
1224                         mptspi_write_spi_device_pg1(starget, &pg1);
1225                 }
1226         } else {
1227                 shost_for_each_device(sdev, hd->ioc->sh)
1228                         mptspi_dv_device(hd, sdev);
1229         }
1230 }
1231
1232 static void
1233 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1234 {
1235         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1236
1237         if (!wqw)
1238                 return;
1239
1240         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1241         wqw->hd = hd;
1242
1243         schedule_work(&wqw->work);
1244 }
1245
1246 /*
1247  * spi module reset handler
1248  */
1249 static int
1250 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1251 {
1252         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1253         int rc;
1254
1255         rc = mptscsih_ioc_reset(ioc, reset_phase);
1256
1257         if (reset_phase == MPT_IOC_POST_RESET)
1258                 mptspi_dv_renegotiate(hd);
1259
1260         return rc;
1261 }
1262
1263 #ifdef CONFIG_PM
1264 /*
1265  * spi module resume handler
1266  */
1267 static int
1268 mptspi_resume(struct pci_dev *pdev)
1269 {
1270         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1271         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1272         int rc;
1273
1274         rc = mptscsih_resume(pdev);
1275         mptspi_dv_renegotiate(hd);
1276
1277         return rc;
1278 }
1279 #endif
1280
1281 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1282 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1283 /*
1284  *      mptspi_probe - Installs scsi devices per bus.
1285  *      @pdev: Pointer to pci_dev structure
1286  *
1287  *      Returns 0 for success, non-zero for failure.
1288  *
1289  */
1290 static int
1291 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1292 {
1293         struct Scsi_Host        *sh;
1294         MPT_SCSI_HOST           *hd;
1295         MPT_ADAPTER             *ioc;
1296         unsigned long            flags;
1297         int                      ii;
1298         int                      numSGE = 0;
1299         int                      scale;
1300         int                      ioc_cap;
1301         int                     error=0;
1302         int                     r;
1303
1304         if ((r = mpt_attach(pdev,id)) != 0)
1305                 return r;
1306
1307         ioc = pci_get_drvdata(pdev);
1308         ioc->DoneCtx = mptspiDoneCtx;
1309         ioc->TaskCtx = mptspiTaskCtx;
1310         ioc->InternalCtx = mptspiInternalCtx;
1311
1312         /*  Added sanity check on readiness of the MPT adapter.
1313          */
1314         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1315                 printk(MYIOC_s_WARN_FMT
1316                   "Skipping because it's not operational!\n",
1317                   ioc->name);
1318                 error = -ENODEV;
1319                 goto out_mptspi_probe;
1320         }
1321
1322         if (!ioc->active) {
1323                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1324                   ioc->name);
1325                 error = -ENODEV;
1326                 goto out_mptspi_probe;
1327         }
1328
1329         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1330          */
1331         ioc_cap = 0;
1332         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1333                 if (ioc->pfacts[ii].ProtocolFlags &
1334                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1335                         ioc_cap ++;
1336         }
1337
1338         if (!ioc_cap) {
1339                 printk(MYIOC_s_WARN_FMT
1340                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1341                         ioc->name, ioc);
1342                 return 0;
1343         }
1344
1345         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1346
1347         if (!sh) {
1348                 printk(MYIOC_s_WARN_FMT
1349                         "Unable to register controller with SCSI subsystem\n",
1350                         ioc->name);
1351                 error = -1;
1352                 goto out_mptspi_probe;
1353         }
1354
1355         spin_lock_irqsave(&ioc->FreeQlock, flags);
1356
1357         /* Attach the SCSI Host to the IOC structure
1358          */
1359         ioc->sh = sh;
1360
1361         sh->io_port = 0;
1362         sh->n_io_port = 0;
1363         sh->irq = 0;
1364
1365         /* set 16 byte cdb's */
1366         sh->max_cmd_len = 16;
1367
1368         /* Yikes!  This is important!
1369          * Otherwise, by default, linux
1370          * only scans target IDs 0-7!
1371          * pfactsN->MaxDevices unreliable
1372          * (not supported in early
1373          *      versions of the FW).
1374          * max_id = 1 + actual max id,
1375          * max_lun = 1 + actual last lun,
1376          *      see hosts.h :o(
1377          */
1378         sh->max_id = ioc->devices_per_bus;
1379
1380         sh->max_lun = MPT_LAST_LUN + 1;
1381         /*
1382          * If RAID Firmware Detected, setup virtual channel
1383          */
1384         if (ioc->ir_firmware)
1385                 sh->max_channel = 1;
1386         else
1387                 sh->max_channel = 0;
1388         sh->this_id = ioc->pfacts[0].PortSCSIID;
1389
1390         /* Required entry.
1391          */
1392         sh->unique_id = ioc->id;
1393
1394         /* Verify that we won't exceed the maximum
1395          * number of chain buffers
1396          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1397          * For 32bit SGE's:
1398          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1399          *               + (req_sz - 64)/sizeof(SGE)
1400          * A slightly different algorithm is required for
1401          * 64bit SGEs.
1402          */
1403         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1404         if (sizeof(dma_addr_t) == sizeof(u64)) {
1405                 numSGE = (scale - 1) *
1406                   (ioc->facts.MaxChainDepth-1) + scale +
1407                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1408                   sizeof(u32));
1409         } else {
1410                 numSGE = 1 + (scale - 1) *
1411                   (ioc->facts.MaxChainDepth-1) + scale +
1412                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1413                   sizeof(u32));
1414         }
1415
1416         if (numSGE < sh->sg_tablesize) {
1417                 /* Reset this value */
1418                 dprintk((MYIOC_s_INFO_FMT
1419                   "Resetting sg_tablesize to %d from %d\n",
1420                   ioc->name, numSGE, sh->sg_tablesize));
1421                 sh->sg_tablesize = numSGE;
1422         }
1423
1424         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1425
1426         hd = (MPT_SCSI_HOST *) sh->hostdata;
1427         hd->ioc = ioc;
1428
1429         /* SCSI needs scsi_cmnd lookup table!
1430          * (with size equal to req_depth*PtrSz!)
1431          */
1432         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1433         if (!hd->ScsiLookup) {
1434                 error = -ENOMEM;
1435                 goto out_mptspi_probe;
1436         }
1437
1438         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1439                  ioc->name, hd->ScsiLookup));
1440
1441         /* Clear the TM flags
1442          */
1443         hd->tmPending = 0;
1444         hd->tmState = TM_STATE_NONE;
1445         hd->resetPending = 0;
1446         hd->abortSCpnt = NULL;
1447
1448         /* Clear the pointer used to store
1449          * single-threaded commands, i.e., those
1450          * issued during a bus scan, dv and
1451          * configuration pages.
1452          */
1453         hd->cmdPtr = NULL;
1454
1455         /* Initialize this SCSI Hosts' timers
1456          * To use, set the timer expires field
1457          * and add_timer
1458          */
1459         init_timer(&hd->timer);
1460         hd->timer.data = (unsigned long) hd;
1461         hd->timer.function = mptscsih_timer_expired;
1462
1463         ioc->spi_data.Saf_Te = mpt_saf_te;
1464
1465         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1466         ddvprintk((MYIOC_s_INFO_FMT
1467                 "saf_te %x\n",
1468                 ioc->name,
1469                 mpt_saf_te));
1470         ioc->spi_data.noQas = 0;
1471
1472         init_waitqueue_head(&hd->scandv_waitq);
1473         hd->scandv_wait_done = 0;
1474         hd->last_queue_full = 0;
1475         hd->spi_pending = 0;
1476
1477         /* Some versions of the firmware don't support page 0; without
1478          * that we can't get the parameters */
1479         if (hd->ioc->spi_data.sdp0length != 0)
1480                 sh->transportt = mptspi_transport_template;
1481
1482         error = scsi_add_host (sh, &ioc->pcidev->dev);
1483         if(error) {
1484                 dprintk((KERN_ERR MYNAM
1485                   "scsi_add_host failed\n"));
1486                 goto out_mptspi_probe;
1487         }
1488
1489         /*
1490          * issue internal bus reset
1491          */
1492         if (ioc->spi_data.bus_reset)
1493                 mptscsih_TMHandler(hd,
1494                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1495                     0, 0, 0, 0, 5);
1496
1497         scsi_scan_host(sh);
1498         return 0;
1499
1500 out_mptspi_probe:
1501
1502         mptscsih_remove(pdev);
1503         return error;
1504 }
1505
1506 static struct pci_driver mptspi_driver = {
1507         .name           = "mptspi",
1508         .id_table       = mptspi_pci_table,
1509         .probe          = mptspi_probe,
1510         .remove         = __devexit_p(mptscsih_remove),
1511         .shutdown       = mptscsih_shutdown,
1512 #ifdef CONFIG_PM
1513         .suspend        = mptscsih_suspend,
1514         .resume         = mptspi_resume,
1515 #endif
1516 };
1517
1518 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1519 /**
1520  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1521  *
1522  *      Returns 0 for success, non-zero for failure.
1523  */
1524 static int __init
1525 mptspi_init(void)
1526 {
1527         show_mptmod_ver(my_NAME, my_VERSION);
1528
1529         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1530         if (!mptspi_transport_template)
1531                 return -ENODEV;
1532
1533         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1534         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1535         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1536
1537         if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1538                 devtverboseprintk((KERN_INFO MYNAM
1539                   ": Registered for IOC event notifications\n"));
1540         }
1541
1542         if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1543                 dprintk((KERN_INFO MYNAM
1544                   ": Registered for IOC reset notifications\n"));
1545         }
1546
1547         return pci_register_driver(&mptspi_driver);
1548 }
1549
1550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1551 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1552 /**
1553  *      mptspi_exit - Unregisters MPT adapter(s)
1554  */
1555 static void __exit
1556 mptspi_exit(void)
1557 {
1558         pci_unregister_driver(&mptspi_driver);
1559
1560         mpt_reset_deregister(mptspiDoneCtx);
1561         dprintk((KERN_INFO MYNAM
1562           ": Deregistered for IOC reset notifications\n"));
1563
1564         mpt_event_deregister(mptspiDoneCtx);
1565         dprintk((KERN_INFO MYNAM
1566           ": Deregistered for IOC event notifications\n"));
1567
1568         mpt_deregister(mptspiInternalCtx);
1569         mpt_deregister(mptspiTaskCtx);
1570         mpt_deregister(mptspiDoneCtx);
1571         spi_release_transport(mptspi_transport_template);
1572 }
1573
1574 module_init(mptspi_init);
1575 module_exit(mptspi_exit);