Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us