[SCSI] mpt fusion: Change company name from LSI Logic to LSI
[linux-2.6] / drivers / message / fusion / mptspi.c
1 /*
2  *  linux/drivers/message/fusion/mptspi.c
3  *      For use with LSI PCI chip/adapter(s)
4  *      running LSI Fusion MPT (Message Passing Technology) firmware.
5  *
6  *  Copyright (c) 1999-2007 LSI 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 u8       mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
94 static u8       mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
95 static u8       mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* 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_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1194                 PCI_ANY_ID, PCI_ANY_ID },
1195         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1196                 PCI_ANY_ID, PCI_ANY_ID },
1197         {0}     /* Terminating entry */
1198 };
1199 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1200
1201
1202 /*
1203  * renegotiate for a given target
1204  */
1205 static void
1206 mptspi_dv_renegotiate_work(struct work_struct *work)
1207 {
1208         struct work_queue_wrapper *wqw =
1209                 container_of(work, struct work_queue_wrapper, work);
1210         struct _MPT_SCSI_HOST *hd = wqw->hd;
1211         struct scsi_device *sdev;
1212         struct scsi_target *starget;
1213         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1214         u32 nego;
1215
1216         kfree(wqw);
1217
1218         if (hd->spi_pending) {
1219                 shost_for_each_device(sdev, hd->ioc->sh) {
1220                         if  (hd->spi_pending & (1 << sdev->id))
1221                                 continue;
1222                         starget = scsi_target(sdev);
1223                         nego = mptspi_getRP(starget);
1224                         pg1.RequestedParameters = cpu_to_le32(nego);
1225                         pg1.Reserved = 0;
1226                         pg1.Configuration = 0;
1227                         mptspi_write_spi_device_pg1(starget, &pg1);
1228                 }
1229         } else {
1230                 shost_for_each_device(sdev, hd->ioc->sh)
1231                         mptspi_dv_device(hd, sdev);
1232         }
1233 }
1234
1235 static void
1236 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1237 {
1238         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1239
1240         if (!wqw)
1241                 return;
1242
1243         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1244         wqw->hd = hd;
1245
1246         schedule_work(&wqw->work);
1247 }
1248
1249 /*
1250  * spi module reset handler
1251  */
1252 static int
1253 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1254 {
1255         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1256         int rc;
1257
1258         rc = mptscsih_ioc_reset(ioc, reset_phase);
1259
1260         if (reset_phase == MPT_IOC_POST_RESET)
1261                 mptspi_dv_renegotiate(hd);
1262
1263         return rc;
1264 }
1265
1266 #ifdef CONFIG_PM
1267 /*
1268  * spi module resume handler
1269  */
1270 static int
1271 mptspi_resume(struct pci_dev *pdev)
1272 {
1273         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1274         struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1275         int rc;
1276
1277         rc = mptscsih_resume(pdev);
1278         mptspi_dv_renegotiate(hd);
1279
1280         return rc;
1281 }
1282 #endif
1283
1284 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1285 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1286 /*
1287  *      mptspi_probe - Installs scsi devices per bus.
1288  *      @pdev: Pointer to pci_dev structure
1289  *
1290  *      Returns 0 for success, non-zero for failure.
1291  *
1292  */
1293 static int
1294 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1295 {
1296         struct Scsi_Host        *sh;
1297         MPT_SCSI_HOST           *hd;
1298         MPT_ADAPTER             *ioc;
1299         unsigned long            flags;
1300         int                      ii;
1301         int                      numSGE = 0;
1302         int                      scale;
1303         int                      ioc_cap;
1304         int                     error=0;
1305         int                     r;
1306
1307         if ((r = mpt_attach(pdev,id)) != 0)
1308                 return r;
1309
1310         ioc = pci_get_drvdata(pdev);
1311         ioc->DoneCtx = mptspiDoneCtx;
1312         ioc->TaskCtx = mptspiTaskCtx;
1313         ioc->InternalCtx = mptspiInternalCtx;
1314
1315         /*  Added sanity check on readiness of the MPT adapter.
1316          */
1317         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1318                 printk(MYIOC_s_WARN_FMT
1319                   "Skipping because it's not operational!\n",
1320                   ioc->name);
1321                 error = -ENODEV;
1322                 goto out_mptspi_probe;
1323         }
1324
1325         if (!ioc->active) {
1326                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1327                   ioc->name);
1328                 error = -ENODEV;
1329                 goto out_mptspi_probe;
1330         }
1331
1332         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1333          */
1334         ioc_cap = 0;
1335         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1336                 if (ioc->pfacts[ii].ProtocolFlags &
1337                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1338                         ioc_cap ++;
1339         }
1340
1341         if (!ioc_cap) {
1342                 printk(MYIOC_s_WARN_FMT
1343                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1344                         ioc->name, ioc);
1345                 return 0;
1346         }
1347
1348         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1349
1350         if (!sh) {
1351                 printk(MYIOC_s_WARN_FMT
1352                         "Unable to register controller with SCSI subsystem\n",
1353                         ioc->name);
1354                 error = -1;
1355                 goto out_mptspi_probe;
1356         }
1357
1358         spin_lock_irqsave(&ioc->FreeQlock, flags);
1359
1360         /* Attach the SCSI Host to the IOC structure
1361          */
1362         ioc->sh = sh;
1363
1364         sh->io_port = 0;
1365         sh->n_io_port = 0;
1366         sh->irq = 0;
1367
1368         /* set 16 byte cdb's */
1369         sh->max_cmd_len = 16;
1370
1371         /* Yikes!  This is important!
1372          * Otherwise, by default, linux
1373          * only scans target IDs 0-7!
1374          * pfactsN->MaxDevices unreliable
1375          * (not supported in early
1376          *      versions of the FW).
1377          * max_id = 1 + actual max id,
1378          * max_lun = 1 + actual last lun,
1379          *      see hosts.h :o(
1380          */
1381         sh->max_id = ioc->devices_per_bus;
1382
1383         sh->max_lun = MPT_LAST_LUN + 1;
1384         /*
1385          * If RAID Firmware Detected, setup virtual channel
1386          */
1387         if (ioc->ir_firmware)
1388                 sh->max_channel = 1;
1389         else
1390                 sh->max_channel = 0;
1391         sh->this_id = ioc->pfacts[0].PortSCSIID;
1392
1393         /* Required entry.
1394          */
1395         sh->unique_id = ioc->id;
1396
1397         /* Verify that we won't exceed the maximum
1398          * number of chain buffers
1399          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1400          * For 32bit SGE's:
1401          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1402          *               + (req_sz - 64)/sizeof(SGE)
1403          * A slightly different algorithm is required for
1404          * 64bit SGEs.
1405          */
1406         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1407         if (sizeof(dma_addr_t) == sizeof(u64)) {
1408                 numSGE = (scale - 1) *
1409                   (ioc->facts.MaxChainDepth-1) + scale +
1410                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1411                   sizeof(u32));
1412         } else {
1413                 numSGE = 1 + (scale - 1) *
1414                   (ioc->facts.MaxChainDepth-1) + scale +
1415                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1416                   sizeof(u32));
1417         }
1418
1419         if (numSGE < sh->sg_tablesize) {
1420                 /* Reset this value */
1421                 dprintk(ioc, printk(MYIOC_s_INFO_FMT
1422                   "Resetting sg_tablesize to %d from %d\n",
1423                   ioc->name, numSGE, sh->sg_tablesize));
1424                 sh->sg_tablesize = numSGE;
1425         }
1426
1427         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1428
1429         hd = (MPT_SCSI_HOST *) sh->hostdata;
1430         hd->ioc = ioc;
1431
1432         /* SCSI needs scsi_cmnd lookup table!
1433          * (with size equal to req_depth*PtrSz!)
1434          */
1435         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1436         if (!hd->ScsiLookup) {
1437                 error = -ENOMEM;
1438                 goto out_mptspi_probe;
1439         }
1440
1441         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1442                  ioc->name, hd->ScsiLookup));
1443
1444         /* Clear the TM flags
1445          */
1446         hd->tmPending = 0;
1447         hd->tmState = TM_STATE_NONE;
1448         hd->resetPending = 0;
1449         hd->abortSCpnt = NULL;
1450
1451         /* Clear the pointer used to store
1452          * single-threaded commands, i.e., those
1453          * issued during a bus scan, dv and
1454          * configuration pages.
1455          */
1456         hd->cmdPtr = NULL;
1457
1458         /* Initialize this SCSI Hosts' timers
1459          * To use, set the timer expires field
1460          * and add_timer
1461          */
1462         init_timer(&hd->timer);
1463         hd->timer.data = (unsigned long) hd;
1464         hd->timer.function = mptscsih_timer_expired;
1465
1466         ioc->spi_data.Saf_Te = mpt_saf_te;
1467
1468         hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1469         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1470                 "saf_te %x\n",
1471                 ioc->name,
1472                 mpt_saf_te));
1473         ioc->spi_data.noQas = 0;
1474
1475         init_waitqueue_head(&hd->scandv_waitq);
1476         hd->scandv_wait_done = 0;
1477         hd->last_queue_full = 0;
1478         hd->spi_pending = 0;
1479
1480         /* Some versions of the firmware don't support page 0; without
1481          * that we can't get the parameters */
1482         if (hd->ioc->spi_data.sdp0length != 0)
1483                 sh->transportt = mptspi_transport_template;
1484
1485         error = scsi_add_host (sh, &ioc->pcidev->dev);
1486         if(error) {
1487                 dprintk(ioc, printk(KERN_ERR MYNAM
1488                   "scsi_add_host failed\n"));
1489                 goto out_mptspi_probe;
1490         }
1491
1492         /*
1493          * issue internal bus reset
1494          */
1495         if (ioc->spi_data.bus_reset)
1496                 mptscsih_TMHandler(hd,
1497                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1498                     0, 0, 0, 0, 5);
1499
1500         scsi_scan_host(sh);
1501         return 0;
1502
1503 out_mptspi_probe:
1504
1505         mptscsih_remove(pdev);
1506         return error;
1507 }
1508
1509 static struct pci_driver mptspi_driver = {
1510         .name           = "mptspi",
1511         .id_table       = mptspi_pci_table,
1512         .probe          = mptspi_probe,
1513         .remove         = __devexit_p(mptscsih_remove),
1514         .shutdown       = mptscsih_shutdown,
1515 #ifdef CONFIG_PM
1516         .suspend        = mptscsih_suspend,
1517         .resume         = mptspi_resume,
1518 #endif
1519 };
1520
1521 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1522 /**
1523  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1524  *
1525  *      Returns 0 for success, non-zero for failure.
1526  */
1527 static int __init
1528 mptspi_init(void)
1529 {
1530         int error;
1531
1532         show_mptmod_ver(my_NAME, my_VERSION);
1533
1534         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1535         if (!mptspi_transport_template)
1536                 return -ENODEV;
1537
1538         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1539         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1540         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1541
1542         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1543         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1544
1545         error = pci_register_driver(&mptspi_driver);
1546         if (error)
1547                 spi_release_transport(mptspi_transport_template);
1548
1549         return error;
1550 }
1551
1552 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1553 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1554 /**
1555  *      mptspi_exit - Unregisters MPT adapter(s)
1556  */
1557 static void __exit
1558 mptspi_exit(void)
1559 {
1560         pci_unregister_driver(&mptspi_driver);
1561
1562         mpt_reset_deregister(mptspiDoneCtx);
1563         mpt_event_deregister(mptspiDoneCtx);
1564
1565         mpt_deregister(mptspiInternalCtx);
1566         mpt_deregister(mptspiTaskCtx);
1567         mpt_deregister(mptspiDoneCtx);
1568         spi_release_transport(mptspi_transport_template);
1569 }
1570
1571 module_init(mptspi_init);
1572 module_exit(mptspi_exit);