Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / 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 = mptscsih_slave_configure(sdev);
731
732         if (ret)
733                 return ret;
734
735         mptspi_initTarget(hd, vtarget, sdev);
736
737         ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
738                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
739                 sdev->id, spi_min_period(scsi_target(sdev)),
740                 spi_max_offset(scsi_target(sdev)),
741                 spi_max_width(scsi_target(sdev))));
742
743         if ((sdev->channel == 1 ||
744              !(mptspi_is_raid(hd, sdev->id))) &&
745             !spi_initial_dv(sdev->sdev_target))
746                 mptspi_dv_device(hd, sdev);
747
748         return 0;
749 }
750
751 static int
752 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
753 {
754         struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
755         VirtDevice      *vdev = SCpnt->device->hostdata;
756
757         if (!vdev || !vdev->vtarget) {
758                 SCpnt->result = DID_NO_CONNECT << 16;
759                 done(SCpnt);
760                 return 0;
761         }
762
763         if (SCpnt->device->channel == 1 &&
764                 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
765                 SCpnt->result = DID_NO_CONNECT << 16;
766                 done(SCpnt);
767                 return 0;
768         }
769
770 #ifdef MPT_DEBUG_DV
771         if (spi_dv_pending(scsi_target(SCpnt->device)))
772                 scsi_print_command(SCpnt);
773 #endif
774
775         return mptscsih_qcmd(SCpnt,done);
776 }
777
778 static void mptspi_slave_destroy(struct scsi_device *sdev)
779 {
780         struct scsi_target *starget = scsi_target(sdev);
781         VirtTarget *vtarget = starget->hostdata;
782         VirtDevice *vdevice = sdev->hostdata;
783
784         /* Will this be the last lun on a non-raid device? */
785         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
786                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
787
788                 /* Async Narrow */
789                 pg1.RequestedParameters = 0;
790                 pg1.Reserved = 0;
791                 pg1.Configuration = 0;
792
793                 mptspi_write_spi_device_pg1(starget, &pg1);
794         }
795
796         mptscsih_slave_destroy(sdev);
797 }
798
799 static struct scsi_host_template mptspi_driver_template = {
800         .module                         = THIS_MODULE,
801         .proc_name                      = "mptspi",
802         .proc_info                      = mptscsih_proc_info,
803         .name                           = "MPT SPI Host",
804         .info                           = mptscsih_info,
805         .queuecommand                   = mptspi_qcmd,
806         .target_alloc                   = mptspi_target_alloc,
807         .slave_alloc                    = mptspi_slave_alloc,
808         .slave_configure                = mptspi_slave_configure,
809         .target_destroy                 = mptspi_target_destroy,
810         .slave_destroy                  = mptspi_slave_destroy,
811         .change_queue_depth             = mptscsih_change_queue_depth,
812         .eh_abort_handler               = mptscsih_abort,
813         .eh_device_reset_handler        = mptscsih_dev_reset,
814         .eh_bus_reset_handler           = mptscsih_bus_reset,
815         .eh_host_reset_handler          = mptscsih_host_reset,
816         .bios_param                     = mptscsih_bios_param,
817         .can_queue                      = MPT_SCSI_CAN_QUEUE,
818         .this_id                        = -1,
819         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
820         .max_sectors                    = 8192,
821         .cmd_per_lun                    = 7,
822         .use_clustering                 = ENABLE_CLUSTERING,
823 };
824
825 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
826                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
827 {
828         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
829         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
830         struct _MPT_ADAPTER *ioc = hd->ioc;
831         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
832         dma_addr_t pg1_dma;
833         int size;
834         struct _x_config_parms cfg;
835         struct _CONFIG_PAGE_HEADER hdr;
836         int err = -EBUSY;
837
838         /* don't allow updating nego parameters on RAID devices */
839         if (starget->channel == 0 &&
840             mptspi_is_raid(hd, starget->id))
841                 return -1;
842
843         size = ioc->spi_data.sdp1length * 4;
844
845         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
846         if (pg1 == NULL) {
847                 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
848                 return -EINVAL;
849         }
850
851         memset(&hdr, 0, sizeof(hdr));
852
853         hdr.PageVersion = ioc->spi_data.sdp1version;
854         hdr.PageLength = ioc->spi_data.sdp1length;
855         hdr.PageNumber = 1;
856         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
857
858         memset(&cfg, 0, sizeof(cfg));
859
860         cfg.cfghdr.hdr = &hdr;
861         cfg.physAddr = pg1_dma;
862         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
863         cfg.dir = 1;
864         cfg.pageAddr = starget->id;
865
866         memcpy(pg1, pass_pg1, size);
867
868         pg1->Header.PageVersion = hdr.PageVersion;
869         pg1->Header.PageLength = hdr.PageLength;
870         pg1->Header.PageNumber = hdr.PageNumber;
871         pg1->Header.PageType = hdr.PageType;
872
873         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
874
875         if (mpt_config(ioc, &cfg)) {
876                 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
877                 goto out_free;
878         }
879         err = 0;
880
881  out_free:
882         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
883         return err;
884 }
885
886 static void mptspi_write_offset(struct scsi_target *starget, int offset)
887 {
888         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
889         u32 nego;
890
891         if (offset < 0)
892                 offset = 0;
893
894         if (offset > 255)
895                 offset = 255;
896
897         if (spi_offset(starget) == -1)
898                 mptspi_read_parameters(starget);
899
900         spi_offset(starget) = offset;
901
902         nego = mptspi_getRP(starget);
903
904         pg1.RequestedParameters = cpu_to_le32(nego);
905         pg1.Reserved = 0;
906         pg1.Configuration = 0;
907
908         mptspi_write_spi_device_pg1(starget, &pg1);
909 }
910
911 static void mptspi_write_period(struct scsi_target *starget, int period)
912 {
913         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
914         u32 nego;
915
916         if (period < 8)
917                 period = 8;
918
919         if (period > 255)
920                 period = 255;
921
922         if (spi_period(starget) == -1)
923                 mptspi_read_parameters(starget);
924
925         if (period == 8) {
926                 spi_iu(starget) = 1;
927                 spi_dt(starget) = 1;
928         } else if (period == 9) {
929                 spi_dt(starget) = 1;
930         }
931
932         spi_period(starget) = period;
933
934         nego = mptspi_getRP(starget);
935
936         pg1.RequestedParameters = cpu_to_le32(nego);
937         pg1.Reserved = 0;
938         pg1.Configuration = 0;
939
940         mptspi_write_spi_device_pg1(starget, &pg1);
941 }
942
943 static void mptspi_write_dt(struct scsi_target *starget, int dt)
944 {
945         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
946         u32 nego;
947
948         if (spi_period(starget) == -1)
949                 mptspi_read_parameters(starget);
950
951         if (!dt && spi_period(starget) < 10)
952                 spi_period(starget) = 10;
953
954         spi_dt(starget) = dt;
955
956         nego = mptspi_getRP(starget);
957
958
959         pg1.RequestedParameters = cpu_to_le32(nego);
960         pg1.Reserved = 0;
961         pg1.Configuration = 0;
962
963         mptspi_write_spi_device_pg1(starget, &pg1);
964 }
965
966 static void mptspi_write_iu(struct scsi_target *starget, int iu)
967 {
968         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
969         u32 nego;
970
971         if (spi_period(starget) == -1)
972                 mptspi_read_parameters(starget);
973
974         if (!iu && spi_period(starget) < 9)
975                 spi_period(starget) = 9;
976
977         spi_iu(starget) = iu;
978
979         nego = mptspi_getRP(starget);
980
981         pg1.RequestedParameters = cpu_to_le32(nego);
982         pg1.Reserved = 0;
983         pg1.Configuration = 0;
984
985         mptspi_write_spi_device_pg1(starget, &pg1);
986 }
987
988 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
989 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
990 {                                                                       \
991         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
992         u32 nego;                                                       \
993                                                                         \
994         spi_##parm(starget) = parm;                                     \
995                                                                         \
996         nego = mptspi_getRP(starget);                                   \
997                                                                         \
998         pg1.RequestedParameters = cpu_to_le32(nego);                    \
999         pg1.Reserved = 0;                                               \
1000         pg1.Configuration = 0;                                          \
1001                                                                         \
1002         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1003 }
1004
1005 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1006 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1007 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1009 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1010
1011 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1012 {
1013         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1014         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1015         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1016         VirtTarget *vtarget = starget->hostdata;
1017         u32 nego;
1018
1019         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1020             hd->ioc->spi_data.noQas)
1021                 spi_qas(starget) = 0;
1022         else
1023                 spi_qas(starget) = qas;
1024
1025         nego = mptspi_getRP(starget);
1026
1027         pg1.RequestedParameters = cpu_to_le32(nego);
1028         pg1.Reserved = 0;
1029         pg1.Configuration = 0;
1030
1031         mptspi_write_spi_device_pg1(starget, &pg1);
1032 }
1033
1034 static void mptspi_write_width(struct scsi_target *starget, int width)
1035 {
1036         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1037         u32 nego;
1038
1039         if (!width) {
1040                 spi_dt(starget) = 0;
1041                 if (spi_period(starget) < 10)
1042                         spi_period(starget) = 10;
1043         }
1044
1045         spi_width(starget) = width;
1046
1047         nego = mptspi_getRP(starget);
1048
1049         pg1.RequestedParameters = cpu_to_le32(nego);
1050         pg1.Reserved = 0;
1051         pg1.Configuration = 0;
1052
1053         mptspi_write_spi_device_pg1(starget, &pg1);
1054 }
1055
1056 struct work_queue_wrapper {
1057         struct work_struct      work;
1058         struct _MPT_SCSI_HOST   *hd;
1059         int                     disk;
1060 };
1061
1062 static void mpt_work_wrapper(struct work_struct *work)
1063 {
1064         struct work_queue_wrapper *wqw =
1065                 container_of(work, struct work_queue_wrapper, work);
1066         struct _MPT_SCSI_HOST *hd = wqw->hd;
1067         struct Scsi_Host *shost = hd->ioc->sh;
1068         struct scsi_device *sdev;
1069         int disk = wqw->disk;
1070         struct _CONFIG_PAGE_IOC_3 *pg3;
1071
1072         kfree(wqw);
1073
1074         mpt_findImVolumes(hd->ioc);
1075         pg3 = hd->ioc->raid_data.pIocPg3;
1076         if (!pg3)
1077                 return;
1078
1079         shost_for_each_device(sdev,shost) {
1080                 struct scsi_target *starget = scsi_target(sdev);
1081                 VirtTarget *vtarget = starget->hostdata;
1082
1083                 /* only want to search RAID components */
1084                 if (sdev->channel != 1)
1085                         continue;
1086
1087                 /* The id is the raid PhysDiskNum, even if
1088                  * starget->id is the actual target address */
1089                 if(vtarget->id != disk)
1090                         continue;
1091
1092                 starget_printk(KERN_INFO, vtarget->starget,
1093                                "Integrated RAID requests DV of new device\n");
1094                 mptspi_dv_device(hd, sdev);
1095         }
1096         shost_printk(KERN_INFO, shost,
1097                      "Integrated RAID detects new device %d\n", disk);
1098         scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1099 }
1100
1101
1102 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1103 {
1104         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1105
1106         if (!wqw) {
1107                 shost_printk(KERN_ERR, hd->ioc->sh,
1108                              "Failed to act on RAID event for physical disk %d\n",
1109                            disk);
1110                 return;
1111         }
1112         INIT_WORK(&wqw->work, mpt_work_wrapper);
1113         wqw->hd = hd;
1114         wqw->disk = disk;
1115
1116         schedule_work(&wqw->work);
1117 }
1118
1119 static int
1120 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1121 {
1122         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1123         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1124
1125         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1126                 int reason
1127                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1128
1129                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1130                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1131                         mpt_dv_raid(hd, disk);
1132                 }
1133         }
1134         return mptscsih_event_process(ioc, pEvReply);
1135 }
1136
1137 static int
1138 mptspi_deny_binding(struct scsi_target *starget)
1139 {
1140         struct _MPT_SCSI_HOST *hd =
1141                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1142         return ((mptspi_is_raid(hd, starget->id)) &&
1143                 starget->channel == 0) ? 1 : 0;
1144 }
1145
1146 static struct spi_function_template mptspi_transport_functions = {
1147         .get_offset     = mptspi_read_parameters,
1148         .set_offset     = mptspi_write_offset,
1149         .show_offset    = 1,
1150         .get_period     = mptspi_read_parameters,
1151         .set_period     = mptspi_write_period,
1152         .show_period    = 1,
1153         .get_width      = mptspi_read_parameters,
1154         .set_width      = mptspi_write_width,
1155         .show_width     = 1,
1156         .get_iu         = mptspi_read_parameters,
1157         .set_iu         = mptspi_write_iu,
1158         .show_iu        = 1,
1159         .get_dt         = mptspi_read_parameters,
1160         .set_dt         = mptspi_write_dt,
1161         .show_dt        = 1,
1162         .get_qas        = mptspi_read_parameters,
1163         .set_qas        = mptspi_write_qas,
1164         .show_qas       = 1,
1165         .get_wr_flow    = mptspi_read_parameters,
1166         .set_wr_flow    = mptspi_write_wr_flow,
1167         .show_wr_flow   = 1,
1168         .get_rd_strm    = mptspi_read_parameters,
1169         .set_rd_strm    = mptspi_write_rd_strm,
1170         .show_rd_strm   = 1,
1171         .get_rti        = mptspi_read_parameters,
1172         .set_rti        = mptspi_write_rti,
1173         .show_rti       = 1,
1174         .get_pcomp_en   = mptspi_read_parameters,
1175         .set_pcomp_en   = mptspi_write_pcomp_en,
1176         .show_pcomp_en  = 1,
1177         .get_hold_mcs   = mptspi_read_parameters,
1178         .set_hold_mcs   = mptspi_write_hold_mcs,
1179         .show_hold_mcs  = 1,
1180         .deny_binding   = mptspi_deny_binding,
1181 };
1182
1183 /****************************************************************************
1184  * Supported hardware
1185  */
1186
1187 static struct pci_device_id mptspi_pci_table[] = {
1188         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1189                 PCI_ANY_ID, PCI_ANY_ID },
1190         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1191                 PCI_ANY_ID, PCI_ANY_ID },
1192         {0}     /* Terminating entry */
1193 };
1194 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1195
1196
1197 /*
1198  * renegotiate for a given target
1199  */
1200 static void
1201 mptspi_dv_renegotiate_work(struct work_struct *work)
1202 {
1203         struct work_queue_wrapper *wqw =
1204                 container_of(work, struct work_queue_wrapper, work);
1205         struct _MPT_SCSI_HOST *hd = wqw->hd;
1206         struct scsi_device *sdev;
1207         struct scsi_target *starget;
1208         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1209         u32 nego;
1210
1211         kfree(wqw);
1212
1213         if (hd->spi_pending) {
1214                 shost_for_each_device(sdev, hd->ioc->sh) {
1215                         if  (hd->spi_pending & (1 << sdev->id))
1216                                 continue;
1217                         starget = scsi_target(sdev);
1218                         nego = mptspi_getRP(starget);
1219                         pg1.RequestedParameters = cpu_to_le32(nego);
1220                         pg1.Reserved = 0;
1221                         pg1.Configuration = 0;
1222                         mptspi_write_spi_device_pg1(starget, &pg1);
1223                 }
1224         } else {
1225                 shost_for_each_device(sdev, hd->ioc->sh)
1226                         mptspi_dv_device(hd, sdev);
1227         }
1228 }
1229
1230 static void
1231 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1232 {
1233         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1234
1235         if (!wqw)
1236                 return;
1237
1238         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1239         wqw->hd = hd;
1240
1241         schedule_work(&wqw->work);
1242 }
1243
1244 /*
1245  * spi module reset handler
1246  */
1247 static int
1248 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1249 {
1250         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1251         int rc;
1252
1253         rc = mptscsih_ioc_reset(ioc, reset_phase);
1254
1255         if (reset_phase == MPT_IOC_POST_RESET)
1256                 mptspi_dv_renegotiate(hd);
1257
1258         return rc;
1259 }
1260
1261 #ifdef CONFIG_PM
1262 /*
1263  * spi module resume handler
1264  */
1265 static int
1266 mptspi_resume(struct pci_dev *pdev)
1267 {
1268         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1269         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1270         int rc;
1271
1272         rc = mptscsih_resume(pdev);
1273         mptspi_dv_renegotiate(hd);
1274
1275         return rc;
1276 }
1277 #endif
1278
1279 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1280 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1281 /*
1282  *      mptspi_probe - Installs scsi devices per bus.
1283  *      @pdev: Pointer to pci_dev structure
1284  *
1285  *      Returns 0 for success, non-zero for failure.
1286  *
1287  */
1288 static int
1289 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1290 {
1291         struct Scsi_Host        *sh;
1292         MPT_SCSI_HOST           *hd;
1293         MPT_ADAPTER             *ioc;
1294         unsigned long            flags;
1295         int                      ii;
1296         int                      numSGE = 0;
1297         int                      scale;
1298         int                      ioc_cap;
1299         int                     error=0;
1300         int                     r;
1301
1302         if ((r = mpt_attach(pdev,id)) != 0)
1303                 return r;
1304
1305         ioc = pci_get_drvdata(pdev);
1306         ioc->DoneCtx = mptspiDoneCtx;
1307         ioc->TaskCtx = mptspiTaskCtx;
1308         ioc->InternalCtx = mptspiInternalCtx;
1309
1310         /*  Added sanity check on readiness of the MPT adapter.
1311          */
1312         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1313                 printk(MYIOC_s_WARN_FMT
1314                   "Skipping because it's not operational!\n",
1315                   ioc->name);
1316                 error = -ENODEV;
1317                 goto out_mptspi_probe;
1318         }
1319
1320         if (!ioc->active) {
1321                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1322                   ioc->name);
1323                 error = -ENODEV;
1324                 goto out_mptspi_probe;
1325         }
1326
1327         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1328          */
1329         ioc_cap = 0;
1330         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1331                 if (ioc->pfacts[ii].ProtocolFlags &
1332                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1333                         ioc_cap ++;
1334         }
1335
1336         if (!ioc_cap) {
1337                 printk(MYIOC_s_WARN_FMT
1338                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1339                         ioc->name, ioc);
1340                 return 0;
1341         }
1342
1343         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1344
1345         if (!sh) {
1346                 printk(MYIOC_s_WARN_FMT
1347                         "Unable to register controller with SCSI subsystem\n",
1348                         ioc->name);
1349                 error = -1;
1350                 goto out_mptspi_probe;
1351         }
1352
1353         spin_lock_irqsave(&ioc->FreeQlock, flags);
1354
1355         /* Attach the SCSI Host to the IOC structure
1356          */
1357         ioc->sh = sh;
1358
1359         sh->io_port = 0;
1360         sh->n_io_port = 0;
1361         sh->irq = 0;
1362
1363         /* set 16 byte cdb's */
1364         sh->max_cmd_len = 16;
1365
1366         /* Yikes!  This is important!
1367          * Otherwise, by default, linux
1368          * only scans target IDs 0-7!
1369          * pfactsN->MaxDevices unreliable
1370          * (not supported in early
1371          *      versions of the FW).
1372          * max_id = 1 + actual max id,
1373          * max_lun = 1 + actual last lun,
1374          *      see hosts.h :o(
1375          */
1376         sh->max_id = ioc->devices_per_bus;
1377
1378         sh->max_lun = MPT_LAST_LUN + 1;
1379         /*
1380          * If RAID Firmware Detected, setup virtual channel
1381          */
1382         if (ioc->ir_firmware)
1383                 sh->max_channel = 1;
1384         else
1385                 sh->max_channel = 0;
1386         sh->this_id = ioc->pfacts[0].PortSCSIID;
1387
1388         /* Required entry.
1389          */
1390         sh->unique_id = ioc->id;
1391
1392         /* Verify that we won't exceed the maximum
1393          * number of chain buffers
1394          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1395          * For 32bit SGE's:
1396          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1397          *               + (req_sz - 64)/sizeof(SGE)
1398          * A slightly different algorithm is required for
1399          * 64bit SGEs.
1400          */
1401         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1402         if (sizeof(dma_addr_t) == sizeof(u64)) {
1403                 numSGE = (scale - 1) *
1404                   (ioc->facts.MaxChainDepth-1) + scale +
1405                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1406                   sizeof(u32));
1407         } else {
1408                 numSGE = 1 + (scale - 1) *
1409                   (ioc->facts.MaxChainDepth-1) + scale +
1410                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1411                   sizeof(u32));
1412         }
1413
1414         if (numSGE < sh->sg_tablesize) {
1415                 /* Reset this value */
1416                 dprintk((MYIOC_s_INFO_FMT
1417                   "Resetting sg_tablesize to %d from %d\n",
1418                   ioc->name, numSGE, sh->sg_tablesize));
1419                 sh->sg_tablesize = numSGE;
1420         }
1421
1422         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1423
1424         hd = (MPT_SCSI_HOST *) sh->hostdata;
1425         hd->ioc = ioc;
1426
1427         /* SCSI needs scsi_cmnd lookup table!
1428          * (with size equal to req_depth*PtrSz!)
1429          */
1430         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1431         if (!hd->ScsiLookup) {
1432                 error = -ENOMEM;
1433                 goto out_mptspi_probe;
1434         }
1435
1436         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1437                  ioc->name, hd->ScsiLookup));
1438
1439         /* Clear the TM flags
1440          */
1441         hd->tmPending = 0;
1442         hd->tmState = TM_STATE_NONE;
1443         hd->resetPending = 0;
1444         hd->abortSCpnt = NULL;
1445
1446         /* Clear the pointer used to store
1447          * single-threaded commands, i.e., those
1448          * issued during a bus scan, dv and
1449          * configuration pages.
1450          */
1451         hd->cmdPtr = NULL;
1452
1453         /* Initialize this SCSI Hosts' timers
1454          * To use, set the timer expires field
1455          * and add_timer
1456          */
1457         init_timer(&hd->timer);
1458         hd->timer.data = (unsigned long) hd;
1459         hd->timer.function = mptscsih_timer_expired;
1460
1461         ioc->spi_data.Saf_Te = mpt_saf_te;
1462
1463         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1464         ddvprintk((MYIOC_s_INFO_FMT
1465                 "saf_te %x\n",
1466                 ioc->name,
1467                 mpt_saf_te));
1468         ioc->spi_data.noQas = 0;
1469
1470         init_waitqueue_head(&hd->scandv_waitq);
1471         hd->scandv_wait_done = 0;
1472         hd->last_queue_full = 0;
1473         hd->spi_pending = 0;
1474
1475         /* Some versions of the firmware don't support page 0; without
1476          * that we can't get the parameters */
1477         if (hd->ioc->spi_data.sdp0length != 0)
1478                 sh->transportt = mptspi_transport_template;
1479
1480         error = scsi_add_host (sh, &ioc->pcidev->dev);
1481         if(error) {
1482                 dprintk((KERN_ERR MYNAM
1483                   "scsi_add_host failed\n"));
1484                 goto out_mptspi_probe;
1485         }
1486
1487         /*
1488          * issue internal bus reset
1489          */
1490         if (ioc->spi_data.bus_reset)
1491                 mptscsih_TMHandler(hd,
1492                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1493                     0, 0, 0, 0, 5);
1494
1495         scsi_scan_host(sh);
1496         return 0;
1497
1498 out_mptspi_probe:
1499
1500         mptscsih_remove(pdev);
1501         return error;
1502 }
1503
1504 static struct pci_driver mptspi_driver = {
1505         .name           = "mptspi",
1506         .id_table       = mptspi_pci_table,
1507         .probe          = mptspi_probe,
1508         .remove         = __devexit_p(mptscsih_remove),
1509         .shutdown       = mptscsih_shutdown,
1510 #ifdef CONFIG_PM
1511         .suspend        = mptscsih_suspend,
1512         .resume         = mptspi_resume,
1513 #endif
1514 };
1515
1516 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1517 /**
1518  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1519  *
1520  *      Returns 0 for success, non-zero for failure.
1521  */
1522 static int __init
1523 mptspi_init(void)
1524 {
1525         show_mptmod_ver(my_NAME, my_VERSION);
1526
1527         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1528         if (!mptspi_transport_template)
1529                 return -ENODEV;
1530
1531         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1532         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1533         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1534
1535         if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1536                 devtverboseprintk((KERN_INFO MYNAM
1537                   ": Registered for IOC event notifications\n"));
1538         }
1539
1540         if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1541                 dprintk((KERN_INFO MYNAM
1542                   ": Registered for IOC reset notifications\n"));
1543         }
1544
1545         return pci_register_driver(&mptspi_driver);
1546 }
1547
1548 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1549 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1550 /**
1551  *      mptspi_exit - Unregisters MPT adapter(s)
1552  */
1553 static void __exit
1554 mptspi_exit(void)
1555 {
1556         pci_unregister_driver(&mptspi_driver);
1557
1558         mpt_reset_deregister(mptspiDoneCtx);
1559         dprintk((KERN_INFO MYNAM
1560           ": Deregistered for IOC reset notifications\n"));
1561
1562         mpt_event_deregister(mptspiDoneCtx);
1563         dprintk((KERN_INFO MYNAM
1564           ": Deregistered for IOC event notifications\n"));
1565
1566         mpt_deregister(mptspiInternalCtx);
1567         mpt_deregister(mptspiTaskCtx);
1568         mpt_deregister(mptspiDoneCtx);
1569         spi_release_transport(mptspi_transport_template);
1570 }
1571
1572 module_init(mptspi_init);
1573 module_exit(mptspi_exit);