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