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