Version:  2.0.40 2.2.26 2.4.37 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 3.16 3.17

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         kfree(starget->hostdata);
465         starget->hostdata = NULL;
466 }
467 
468 /**
469  *      mptspi_print_write_nego - negotiation parameters debug info that is being sent
470  *      @hd: Pointer to a SCSI HOST structure
471  *      @starget: SCSI target
472  *      @ii: negotiation parameters
473  *
474  */
475 static void
476 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
477 {
478         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
479             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
480             hd->ioc->name, starget->id, ii,
481             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
482             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
483             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
484             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
485             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
486             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
487             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
488             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
489             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
490             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
491 }
492 
493 /**
494  *      mptspi_print_read_nego - negotiation parameters debug info that is being read
495  *      @hd: Pointer to a SCSI HOST structure
496  *      @starget: SCSI target
497  *      @ii: negotiation parameters
498  *
499  */
500 static void
501 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
502 {
503         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
504             " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
505             hd->ioc->name, starget->id, ii,
506             ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
507             ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
508             ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
509             ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
510             ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
511             ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
512             ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
513             ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
514             ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
515             ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
516 }
517 
518 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
519                              struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
520 {
521         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
522         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
523         struct _MPT_ADAPTER *ioc = hd->ioc;
524         struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
525         dma_addr_t spi_dev_pg0_dma;
526         int size;
527         struct _x_config_parms cfg;
528         struct _CONFIG_PAGE_HEADER hdr;
529         int err = -EBUSY;
530 
531         /* No SPI parameters for RAID devices */
532         if (starget->channel == 0 &&
533             mptspi_is_raid(hd, starget->id))
534                 return -1;
535 
536         size = ioc->spi_data.sdp0length * 4;
537         /*
538         if (ioc->spi_data.sdp0length & 1)
539                 size += size + 4;
540         size += 2048;
541         */
542 
543         spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
544         if (spi_dev_pg0 == NULL) {
545                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
546                     "dma_alloc_coherent for parameters failed\n", ioc->name);
547                 return -EINVAL;
548         }
549 
550         memset(&hdr, 0, sizeof(hdr));
551 
552         hdr.PageVersion = ioc->spi_data.sdp0version;
553         hdr.PageLength = ioc->spi_data.sdp0length;
554         hdr.PageNumber = 0;
555         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
556 
557         memset(&cfg, 0, sizeof(cfg));
558 
559         cfg.cfghdr.hdr = &hdr;
560         cfg.physAddr = spi_dev_pg0_dma;
561         cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
562         cfg.dir = 0;
563         cfg.pageAddr = starget->id;
564         cfg.timeout = 60;
565 
566         if (mpt_config(ioc, &cfg)) {
567                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
568                 goto out_free;
569         }
570         err = 0;
571         memcpy(pass_pg0, spi_dev_pg0, size);
572 
573         mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
574 
575  out_free:
576         dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
577         return err;
578 }
579 
580 static u32 mptspi_getRP(struct scsi_target *starget)
581 {
582         u32 nego = 0;
583 
584         nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
585         nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
586         nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
587         nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
588         nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
589         nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
590         nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
591         nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
592 
593         nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
594         nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
595         nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
596 
597         return nego;
598 }
599 
600 static void mptspi_read_parameters(struct scsi_target *starget)
601 {
602         int nego;
603         struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
604 
605         mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
606 
607         nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
608 
609         spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
610         spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
611         spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
612         spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
613         spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
614         spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
615         spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
616         spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
617         spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
618         spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
619         spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
620 }
621 
622 static int
623 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
624 {
625         MPT_ADAPTER     *ioc = hd->ioc;
626         MpiRaidActionRequest_t  *pReq;
627         MPT_FRAME_HDR           *mf;
628         int                     ret;
629         unsigned long           timeleft;
630 
631         mutex_lock(&ioc->internal_cmds.mutex);
632 
633         /* Get and Populate a free Frame
634          */
635         if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
636                 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
637                         "%s: no msg frames!\n", ioc->name, __func__));
638                 ret = -EAGAIN;
639                 goto out;
640         }
641         pReq = (MpiRaidActionRequest_t *)mf;
642         if (quiesce)
643                 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
644         else
645                 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
646         pReq->Reserved1 = 0;
647         pReq->ChainOffset = 0;
648         pReq->Function = MPI_FUNCTION_RAID_ACTION;
649         pReq->VolumeID = id;
650         pReq->VolumeBus = channel;
651         pReq->PhysDiskNum = 0;
652         pReq->MsgFlags = 0;
653         pReq->Reserved2 = 0;
654         pReq->ActionDataWord = 0; /* Reserved for this action */
655 
656         ioc->add_sge((char *)&pReq->ActionDataSGE,
657                 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
658 
659         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
660                         ioc->name, pReq->Action, channel, id));
661 
662         INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
663         mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
664         timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
665         if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
666                 ret = -ETIME;
667                 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
668                     ioc->name, __func__));
669                 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
670                         goto out;
671                 if (!timeleft) {
672                         printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
673                             ioc->name, __func__);
674                         mpt_HardResetHandler(ioc, CAN_SLEEP);
675                         mpt_free_msg_frame(ioc, mf);
676                 }
677                 goto out;
678         }
679 
680         ret = ioc->internal_cmds.completion_code;
681 
682  out:
683         CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
684         mutex_unlock(&ioc->internal_cmds.mutex);
685         return ret;
686 }
687 
688 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
689                              struct scsi_device *sdev)
690 {
691         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
692         MPT_ADAPTER *ioc = hd->ioc;
693 
694         /* no DV on RAID devices */
695         if (sdev->channel == 0 &&
696             mptspi_is_raid(hd, sdev->id))
697                 return;
698 
699         /* If this is a piece of a RAID, then quiesce first */
700         if (sdev->channel == 1 &&
701             mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
702                 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
703                     "Integrated RAID quiesce failed\n", ioc->name);
704                 return;
705         }
706 
707         hd->spi_pending |= (1 << sdev->id);
708         spi_dv_device(sdev);
709         hd->spi_pending &= ~(1 << sdev->id);
710 
711         if (sdev->channel == 1 &&
712             mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
713                 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
714                     "Integrated RAID resume failed\n", ioc->name);
715 
716         mptspi_read_parameters(sdev->sdev_target);
717         spi_display_xfer_agreement(sdev->sdev_target);
718         mptspi_read_parameters(sdev->sdev_target);
719 }
720 
721 static int mptspi_slave_alloc(struct scsi_device *sdev)
722 {
723         MPT_SCSI_HOST *hd = shost_priv(sdev->host);
724         VirtTarget              *vtarget;
725         VirtDevice              *vdevice;
726         struct scsi_target      *starget;
727         MPT_ADAPTER *ioc = hd->ioc;
728 
729         if (sdev->channel == 1 &&
730                 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
731                         return -ENXIO;
732 
733         vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
734         if (!vdevice) {
735                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
736                                 ioc->name, sizeof(VirtDevice));
737                 return -ENOMEM;
738         }
739 
740         vdevice->lun = sdev->lun;
741         sdev->hostdata = vdevice;
742 
743         starget = scsi_target(sdev);
744         vtarget = starget->hostdata;
745         vdevice->vtarget = vtarget;
746         vtarget->num_luns++;
747 
748         if (sdev->channel == 1)
749                 sdev->no_uld_attach = 1;
750 
751         return 0;
752 }
753 
754 static int mptspi_slave_configure(struct scsi_device *sdev)
755 {
756         struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
757         VirtTarget *vtarget = scsi_target(sdev)->hostdata;
758         int ret;
759 
760         mptspi_initTarget(hd, vtarget, sdev);
761 
762         ret = mptscsih_slave_configure(sdev);
763 
764         if (ret)
765                 return ret;
766 
767         ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
768                 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
769                 sdev->id, spi_min_period(scsi_target(sdev)),
770                 spi_max_offset(scsi_target(sdev)),
771                 spi_max_width(scsi_target(sdev))));
772 
773         if ((sdev->channel == 1 ||
774              !(mptspi_is_raid(hd, sdev->id))) &&
775             !spi_initial_dv(sdev->sdev_target))
776                 mptspi_dv_device(hd, sdev);
777 
778         return 0;
779 }
780 
781 static int
782 mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
783 {
784         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
785         VirtDevice      *vdevice = SCpnt->device->hostdata;
786         MPT_ADAPTER *ioc = hd->ioc;
787 
788         if (!vdevice || !vdevice->vtarget) {
789                 SCpnt->result = DID_NO_CONNECT << 16;
790                 SCpnt->scsi_done(SCpnt);
791                 return 0;
792         }
793 
794         if (SCpnt->device->channel == 1 &&
795                 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
796                 SCpnt->result = DID_NO_CONNECT << 16;
797                 SCpnt->scsi_done(SCpnt);
798                 return 0;
799         }
800 
801         if (spi_dv_pending(scsi_target(SCpnt->device)))
802                 ddvprintk(ioc, scsi_print_command(SCpnt));
803 
804         return mptscsih_qcmd(SCpnt);
805 }
806 
807 static void mptspi_slave_destroy(struct scsi_device *sdev)
808 {
809         struct scsi_target *starget = scsi_target(sdev);
810         VirtTarget *vtarget = starget->hostdata;
811         VirtDevice *vdevice = sdev->hostdata;
812 
813         /* Will this be the last lun on a non-raid device? */
814         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
815                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
816 
817                 /* Async Narrow */
818                 pg1.RequestedParameters = 0;
819                 pg1.Reserved = 0;
820                 pg1.Configuration = 0;
821 
822                 mptspi_write_spi_device_pg1(starget, &pg1);
823         }
824 
825         mptscsih_slave_destroy(sdev);
826 }
827 
828 static struct scsi_host_template mptspi_driver_template = {
829         .module                         = THIS_MODULE,
830         .proc_name                      = "mptspi",
831         .show_info                      = mptscsih_show_info,
832         .name                           = "MPT SPI Host",
833         .info                           = mptscsih_info,
834         .queuecommand                   = mptspi_qcmd,
835         .target_alloc                   = mptspi_target_alloc,
836         .slave_alloc                    = mptspi_slave_alloc,
837         .slave_configure                = mptspi_slave_configure,
838         .target_destroy                 = mptspi_target_destroy,
839         .slave_destroy                  = mptspi_slave_destroy,
840         .change_queue_depth             = mptscsih_change_queue_depth,
841         .eh_abort_handler               = mptscsih_abort,
842         .eh_device_reset_handler        = mptscsih_dev_reset,
843         .eh_bus_reset_handler           = mptscsih_bus_reset,
844         .eh_host_reset_handler          = mptscsih_host_reset,
845         .bios_param                     = mptscsih_bios_param,
846         .can_queue                      = MPT_SCSI_CAN_QUEUE,
847         .this_id                        = -1,
848         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
849         .max_sectors                    = 8192,
850         .cmd_per_lun                    = 7,
851         .use_clustering                 = ENABLE_CLUSTERING,
852         .shost_attrs                    = mptscsih_host_attrs,
853 };
854 
855 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
856                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
857 {
858         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
859         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
860         struct _MPT_ADAPTER *ioc = hd->ioc;
861         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
862         dma_addr_t pg1_dma;
863         int size;
864         struct _x_config_parms cfg;
865         struct _CONFIG_PAGE_HEADER hdr;
866         int err = -EBUSY;
867         u32 nego_parms;
868         u32 period;
869         struct scsi_device *sdev;
870         int i;
871 
872         /* don't allow updating nego parameters on RAID devices */
873         if (starget->channel == 0 &&
874             mptspi_is_raid(hd, starget->id))
875                 return -1;
876 
877         size = ioc->spi_data.sdp1length * 4;
878 
879         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
880         if (pg1 == NULL) {
881                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
882                     "dma_alloc_coherent for parameters failed\n", ioc->name);
883                 return -EINVAL;
884         }
885 
886         memset(&hdr, 0, sizeof(hdr));
887 
888         hdr.PageVersion = ioc->spi_data.sdp1version;
889         hdr.PageLength = ioc->spi_data.sdp1length;
890         hdr.PageNumber = 1;
891         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
892 
893         memset(&cfg, 0, sizeof(cfg));
894 
895         cfg.cfghdr.hdr = &hdr;
896         cfg.physAddr = pg1_dma;
897         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
898         cfg.dir = 1;
899         cfg.pageAddr = starget->id;
900 
901         memcpy(pg1, pass_pg1, size);
902 
903         pg1->Header.PageVersion = hdr.PageVersion;
904         pg1->Header.PageLength = hdr.PageLength;
905         pg1->Header.PageNumber = hdr.PageNumber;
906         pg1->Header.PageType = hdr.PageType;
907 
908         nego_parms = le32_to_cpu(pg1->RequestedParameters);
909         period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
910                 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
911         if (period == 8) {
912                 /* Turn on inline data padding for TAPE when running U320 */
913                 for (i = 0 ; i < 16; i++) {
914                         sdev = scsi_device_lookup_by_target(starget, i);
915                         if (sdev && sdev->type == TYPE_TAPE) {
916                                 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
917                                             "IDP:ON\n", ioc->name);
918                                 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
919                                 pg1->RequestedParameters =
920                                     cpu_to_le32(nego_parms);
921                                 break;
922                         }
923                 }
924         }
925 
926         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
927 
928         if (mpt_config(ioc, &cfg)) {
929                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
930                     "mpt_config failed\n", ioc->name);
931                 goto out_free;
932         }
933         err = 0;
934 
935  out_free:
936         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
937         return err;
938 }
939 
940 static void mptspi_write_offset(struct scsi_target *starget, int offset)
941 {
942         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
943         u32 nego;
944 
945         if (offset < 0)
946                 offset = 0;
947 
948         if (offset > 255)
949                 offset = 255;
950 
951         if (spi_offset(starget) == -1)
952                 mptspi_read_parameters(starget);
953 
954         spi_offset(starget) = offset;
955 
956         nego = mptspi_getRP(starget);
957 
958         pg1.RequestedParameters = cpu_to_le32(nego);
959         pg1.Reserved = 0;
960         pg1.Configuration = 0;
961 
962         mptspi_write_spi_device_pg1(starget, &pg1);
963 }
964 
965 static void mptspi_write_period(struct scsi_target *starget, int period)
966 {
967         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
968         u32 nego;
969 
970         if (period < 8)
971                 period = 8;
972 
973         if (period > 255)
974                 period = 255;
975 
976         if (spi_period(starget) == -1)
977                 mptspi_read_parameters(starget);
978 
979         if (period == 8) {
980                 spi_iu(starget) = 1;
981                 spi_dt(starget) = 1;
982         } else if (period == 9) {
983                 spi_dt(starget) = 1;
984         }
985 
986         spi_period(starget) = period;
987 
988         nego = mptspi_getRP(starget);
989 
990         pg1.RequestedParameters = cpu_to_le32(nego);
991         pg1.Reserved = 0;
992         pg1.Configuration = 0;
993 
994         mptspi_write_spi_device_pg1(starget, &pg1);
995 }
996 
997 static void mptspi_write_dt(struct scsi_target *starget, int dt)
998 {
999         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1000         u32 nego;
1001 
1002         if (spi_period(starget) == -1)
1003                 mptspi_read_parameters(starget);
1004 
1005         if (!dt && spi_period(starget) < 10)
1006                 spi_period(starget) = 10;
1007 
1008         spi_dt(starget) = dt;
1009 
1010         nego = mptspi_getRP(starget);
1011 
1012 
1013         pg1.RequestedParameters = cpu_to_le32(nego);
1014         pg1.Reserved = 0;
1015         pg1.Configuration = 0;
1016 
1017         mptspi_write_spi_device_pg1(starget, &pg1);
1018 }
1019 
1020 static void mptspi_write_iu(struct scsi_target *starget, int iu)
1021 {
1022         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1023         u32 nego;
1024 
1025         if (spi_period(starget) == -1)
1026                 mptspi_read_parameters(starget);
1027 
1028         if (!iu && spi_period(starget) < 9)
1029                 spi_period(starget) = 9;
1030 
1031         spi_iu(starget) = iu;
1032 
1033         nego = mptspi_getRP(starget);
1034 
1035         pg1.RequestedParameters = cpu_to_le32(nego);
1036         pg1.Reserved = 0;
1037         pg1.Configuration = 0;
1038 
1039         mptspi_write_spi_device_pg1(starget, &pg1);
1040 }
1041 
1042 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
1043 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1044 {                                                                       \
1045         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
1046         u32 nego;                                                       \
1047                                                                         \
1048         spi_##parm(starget) = parm;                                     \
1049                                                                         \
1050         nego = mptspi_getRP(starget);                                   \
1051                                                                         \
1052         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1053         pg1.Reserved = 0;                                               \
1054         pg1.Configuration = 0;                                          \
1055                                                                         \
1056         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1057 }
1058 
1059 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1060 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1061 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1062 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1063 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1064 
1065 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1066 {
1067         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1068         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1069         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1070         VirtTarget *vtarget = starget->hostdata;
1071         u32 nego;
1072 
1073         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1074             hd->ioc->spi_data.noQas)
1075                 spi_qas(starget) = 0;
1076         else
1077                 spi_qas(starget) = qas;
1078 
1079         nego = mptspi_getRP(starget);
1080 
1081         pg1.RequestedParameters = cpu_to_le32(nego);
1082         pg1.Reserved = 0;
1083         pg1.Configuration = 0;
1084 
1085         mptspi_write_spi_device_pg1(starget, &pg1);
1086 }
1087 
1088 static void mptspi_write_width(struct scsi_target *starget, int width)
1089 {
1090         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1091         u32 nego;
1092 
1093         if (!width) {
1094                 spi_dt(starget) = 0;
1095                 if (spi_period(starget) < 10)
1096                         spi_period(starget) = 10;
1097         }
1098 
1099         spi_width(starget) = width;
1100 
1101         nego = mptspi_getRP(starget);
1102 
1103         pg1.RequestedParameters = cpu_to_le32(nego);
1104         pg1.Reserved = 0;
1105         pg1.Configuration = 0;
1106 
1107         mptspi_write_spi_device_pg1(starget, &pg1);
1108 }
1109 
1110 struct work_queue_wrapper {
1111         struct work_struct      work;
1112         struct _MPT_SCSI_HOST   *hd;
1113         int                     disk;
1114 };
1115 
1116 static void mpt_work_wrapper(struct work_struct *work)
1117 {
1118         struct work_queue_wrapper *wqw =
1119                 container_of(work, struct work_queue_wrapper, work);
1120         struct _MPT_SCSI_HOST *hd = wqw->hd;
1121         MPT_ADAPTER *ioc = hd->ioc;
1122         struct Scsi_Host *shost = ioc->sh;
1123         struct scsi_device *sdev;
1124         int disk = wqw->disk;
1125         struct _CONFIG_PAGE_IOC_3 *pg3;
1126 
1127         kfree(wqw);
1128 
1129         mpt_findImVolumes(ioc);
1130         pg3 = ioc->raid_data.pIocPg3;
1131         if (!pg3)
1132                 return;
1133 
1134         shost_for_each_device(sdev,shost) {
1135                 struct scsi_target *starget = scsi_target(sdev);
1136                 VirtTarget *vtarget = starget->hostdata;
1137 
1138                 /* only want to search RAID components */
1139                 if (sdev->channel != 1)
1140                         continue;
1141 
1142                 /* The id is the raid PhysDiskNum, even if
1143                  * starget->id is the actual target address */
1144                 if(vtarget->id != disk)
1145                         continue;
1146 
1147                 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1148                     "Integrated RAID requests DV of new device\n", ioc->name);
1149                 mptspi_dv_device(hd, sdev);
1150         }
1151         shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1152             "Integrated RAID detects new device %d\n", ioc->name, disk);
1153         scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1154 }
1155 
1156 
1157 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1158 {
1159         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1160         MPT_ADAPTER *ioc = hd->ioc;
1161 
1162         if (!wqw) {
1163                 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1164                     "Failed to act on RAID event for physical disk %d\n",
1165                     ioc->name, disk);
1166                 return;
1167         }
1168         INIT_WORK(&wqw->work, mpt_work_wrapper);
1169         wqw->hd = hd;
1170         wqw->disk = disk;
1171 
1172         schedule_work(&wqw->work);
1173 }
1174 
1175 static int
1176 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1177 {
1178         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1179         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1180 
1181         if (ioc->bus_type != SPI)
1182                 return 0;
1183 
1184         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1185                 int reason
1186                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1187 
1188                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1189                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1190                         mpt_dv_raid(hd, disk);
1191                 }
1192         }
1193         return mptscsih_event_process(ioc, pEvReply);
1194 }
1195 
1196 static int
1197 mptspi_deny_binding(struct scsi_target *starget)
1198 {
1199         struct _MPT_SCSI_HOST *hd =
1200                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1201         return ((mptspi_is_raid(hd, starget->id)) &&
1202                 starget->channel == 0) ? 1 : 0;
1203 }
1204 
1205 static struct spi_function_template mptspi_transport_functions = {
1206         .get_offset     = mptspi_read_parameters,
1207         .set_offset     = mptspi_write_offset,
1208         .show_offset    = 1,
1209         .get_period     = mptspi_read_parameters,
1210         .set_period     = mptspi_write_period,
1211         .show_period    = 1,
1212         .get_width      = mptspi_read_parameters,
1213         .set_width      = mptspi_write_width,
1214         .show_width     = 1,
1215         .get_iu         = mptspi_read_parameters,
1216         .set_iu         = mptspi_write_iu,
1217         .show_iu        = 1,
1218         .get_dt         = mptspi_read_parameters,
1219         .set_dt         = mptspi_write_dt,
1220         .show_dt        = 1,
1221         .get_qas        = mptspi_read_parameters,
1222         .set_qas        = mptspi_write_qas,
1223         .show_qas       = 1,
1224         .get_wr_flow    = mptspi_read_parameters,
1225         .set_wr_flow    = mptspi_write_wr_flow,
1226         .show_wr_flow   = 1,
1227         .get_rd_strm    = mptspi_read_parameters,
1228         .set_rd_strm    = mptspi_write_rd_strm,
1229         .show_rd_strm   = 1,
1230         .get_rti        = mptspi_read_parameters,
1231         .set_rti        = mptspi_write_rti,
1232         .show_rti       = 1,
1233         .get_pcomp_en   = mptspi_read_parameters,
1234         .set_pcomp_en   = mptspi_write_pcomp_en,
1235         .show_pcomp_en  = 1,
1236         .get_hold_mcs   = mptspi_read_parameters,
1237         .set_hold_mcs   = mptspi_write_hold_mcs,
1238         .show_hold_mcs  = 1,
1239         .deny_binding   = mptspi_deny_binding,
1240 };
1241 
1242 /****************************************************************************
1243  * Supported hardware
1244  */
1245 
1246 static struct pci_device_id mptspi_pci_table[] = {
1247         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1248                 PCI_ANY_ID, PCI_ANY_ID },
1249         { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1250                 PCI_ANY_ID, PCI_ANY_ID },
1251         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1252                 PCI_ANY_ID, PCI_ANY_ID },
1253         {0}     /* Terminating entry */
1254 };
1255 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1256 
1257 
1258 /*
1259  * renegotiate for a given target
1260  */
1261 static void
1262 mptspi_dv_renegotiate_work(struct work_struct *work)
1263 {
1264         struct work_queue_wrapper *wqw =
1265                 container_of(work, struct work_queue_wrapper, work);
1266         struct _MPT_SCSI_HOST *hd = wqw->hd;
1267         struct scsi_device *sdev;
1268         struct scsi_target *starget;
1269         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1270         u32 nego;
1271         MPT_ADAPTER *ioc = hd->ioc;
1272 
1273         kfree(wqw);
1274 
1275         if (hd->spi_pending) {
1276                 shost_for_each_device(sdev, ioc->sh) {
1277                         if  (hd->spi_pending & (1 << sdev->id))
1278                                 continue;
1279                         starget = scsi_target(sdev);
1280                         nego = mptspi_getRP(starget);
1281                         pg1.RequestedParameters = cpu_to_le32(nego);
1282                         pg1.Reserved = 0;
1283                         pg1.Configuration = 0;
1284                         mptspi_write_spi_device_pg1(starget, &pg1);
1285                 }
1286         } else {
1287                 shost_for_each_device(sdev, ioc->sh)
1288                         mptspi_dv_device(hd, sdev);
1289         }
1290 }
1291 
1292 static void
1293 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1294 {
1295         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1296 
1297         if (!wqw)
1298                 return;
1299 
1300         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1301         wqw->hd = hd;
1302 
1303         schedule_work(&wqw->work);
1304 }
1305 
1306 /*
1307  * spi module reset handler
1308  */
1309 static int
1310 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1311 {
1312         int rc;
1313 
1314         rc = mptscsih_ioc_reset(ioc, reset_phase);
1315         if ((ioc->bus_type != SPI) || (!rc))
1316                 return rc;
1317 
1318         /* only try to do a renegotiation if we're properly set up
1319          * if we get an ioc fault on bringup, ioc->sh will be NULL */
1320         if (reset_phase == MPT_IOC_POST_RESET &&
1321             ioc->sh) {
1322                 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1323 
1324                 mptspi_dv_renegotiate(hd);
1325         }
1326 
1327         return rc;
1328 }
1329 
1330 #ifdef CONFIG_PM
1331 /*
1332  * spi module resume handler
1333  */
1334 static int
1335 mptspi_resume(struct pci_dev *pdev)
1336 {
1337         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1338         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1339         int rc;
1340 
1341         rc = mptscsih_resume(pdev);
1342         mptspi_dv_renegotiate(hd);
1343 
1344         return rc;
1345 }
1346 #endif
1347 
1348 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1349 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1350 /*
1351  *      mptspi_probe - Installs scsi devices per bus.
1352  *      @pdev: Pointer to pci_dev structure
1353  *
1354  *      Returns 0 for success, non-zero for failure.
1355  *
1356  */
1357 static int
1358 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1359 {
1360         struct Scsi_Host        *sh;
1361         MPT_SCSI_HOST           *hd;
1362         MPT_ADAPTER             *ioc;
1363         unsigned long            flags;
1364         int                      ii;
1365         int                      numSGE = 0;
1366         int                      scale;
1367         int                      ioc_cap;
1368         int                     error=0;
1369         int                     r;
1370 
1371         if ((r = mpt_attach(pdev,id)) != 0)
1372                 return r;
1373 
1374         ioc = pci_get_drvdata(pdev);
1375         ioc->DoneCtx = mptspiDoneCtx;
1376         ioc->TaskCtx = mptspiTaskCtx;
1377         ioc->InternalCtx = mptspiInternalCtx;
1378 
1379         /*  Added sanity check on readiness of the MPT adapter.
1380          */
1381         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1382                 printk(MYIOC_s_WARN_FMT
1383                   "Skipping because it's not operational!\n",
1384                   ioc->name);
1385                 error = -ENODEV;
1386                 goto out_mptspi_probe;
1387         }
1388 
1389         if (!ioc->active) {
1390                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1391                   ioc->name);
1392                 error = -ENODEV;
1393                 goto out_mptspi_probe;
1394         }
1395 
1396         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1397          */
1398         ioc_cap = 0;
1399         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1400                 if (ioc->pfacts[ii].ProtocolFlags &
1401                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1402                         ioc_cap ++;
1403         }
1404 
1405         if (!ioc_cap) {
1406                 printk(MYIOC_s_WARN_FMT
1407                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1408                         ioc->name, ioc);
1409                 return 0;
1410         }
1411 
1412         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1413 
1414         if (!sh) {
1415                 printk(MYIOC_s_WARN_FMT
1416                         "Unable to register controller with SCSI subsystem\n",
1417                         ioc->name);
1418                 error = -1;
1419                 goto out_mptspi_probe;
1420         }
1421 
1422         spin_lock_irqsave(&ioc->FreeQlock, flags);
1423 
1424         /* Attach the SCSI Host to the IOC structure
1425          */
1426         ioc->sh = sh;
1427 
1428         sh->io_port = 0;
1429         sh->n_io_port = 0;
1430         sh->irq = 0;
1431 
1432         /* set 16 byte cdb's */
1433         sh->max_cmd_len = 16;
1434 
1435         /* Yikes!  This is important!
1436          * Otherwise, by default, linux
1437          * only scans target IDs 0-7!
1438          * pfactsN->MaxDevices unreliable
1439          * (not supported in early
1440          *      versions of the FW).
1441          * max_id = 1 + actual max id,
1442          * max_lun = 1 + actual last lun,
1443          *      see hosts.h :o(
1444          */
1445         sh->max_id = ioc->devices_per_bus;
1446 
1447         sh->max_lun = MPT_LAST_LUN + 1;
1448         /*
1449          * If RAID Firmware Detected, setup virtual channel
1450          */
1451         if (ioc->ir_firmware)
1452                 sh->max_channel = 1;
1453         else
1454                 sh->max_channel = 0;
1455         sh->this_id = ioc->pfacts[0].PortSCSIID;
1456 
1457         /* Required entry.
1458          */
1459         sh->unique_id = ioc->id;
1460 
1461         /* Verify that we won't exceed the maximum
1462          * number of chain buffers
1463          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1464          * For 32bit SGE's:
1465          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1466          *               + (req_sz - 64)/sizeof(SGE)
1467          * A slightly different algorithm is required for
1468          * 64bit SGEs.
1469          */
1470         scale = ioc->req_sz/ioc->SGE_size;
1471         if (ioc->sg_addr_size == sizeof(u64)) {
1472                 numSGE = (scale - 1) *
1473                   (ioc->facts.MaxChainDepth-1) + scale +
1474                   (ioc->req_sz - 60) / ioc->SGE_size;
1475         } else {
1476                 numSGE = 1 + (scale - 1) *
1477                   (ioc->facts.MaxChainDepth-1) + scale +
1478                   (ioc->req_sz - 64) / ioc->SGE_size;
1479         }
1480 
1481         if (numSGE < sh->sg_tablesize) {
1482                 /* Reset this value */
1483                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1484                   "Resetting sg_tablesize to %d from %d\n",
1485                   ioc->name, numSGE, sh->sg_tablesize));
1486                 sh->sg_tablesize = numSGE;
1487         }
1488 
1489         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1490 
1491         hd = shost_priv(sh);
1492         hd->ioc = ioc;
1493 
1494         /* SCSI needs scsi_cmnd lookup table!
1495          * (with size equal to req_depth*PtrSz!)
1496          */
1497         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1498         if (!ioc->ScsiLookup) {
1499                 error = -ENOMEM;
1500                 goto out_mptspi_probe;
1501         }
1502         spin_lock_init(&ioc->scsi_lookup_lock);
1503 
1504         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1505                  ioc->name, ioc->ScsiLookup));
1506 
1507         ioc->spi_data.Saf_Te = mpt_saf_te;
1508         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1509                 "saf_te %x\n",
1510                 ioc->name,
1511                 mpt_saf_te));
1512         ioc->spi_data.noQas = 0;
1513 
1514         hd->last_queue_full = 0;
1515         hd->spi_pending = 0;
1516 
1517         /* Some versions of the firmware don't support page 0; without
1518          * that we can't get the parameters */
1519         if (ioc->spi_data.sdp0length != 0)
1520                 sh->transportt = mptspi_transport_template;
1521 
1522         error = scsi_add_host (sh, &ioc->pcidev->dev);
1523         if(error) {
1524                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1525                   "scsi_add_host failed\n", ioc->name));
1526                 goto out_mptspi_probe;
1527         }
1528 
1529         /*
1530          * issue internal bus reset
1531          */
1532         if (ioc->spi_data.bus_reset)
1533                 mptscsih_IssueTaskMgmt(hd,
1534                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1535                     0, 0, 0, 0, 5);
1536 
1537         scsi_scan_host(sh);
1538         return 0;
1539 
1540 out_mptspi_probe:
1541 
1542         mptscsih_remove(pdev);
1543         return error;
1544 }
1545 
1546 static struct pci_driver mptspi_driver = {
1547         .name           = "mptspi",
1548         .id_table       = mptspi_pci_table,
1549         .probe          = mptspi_probe,
1550         .remove         = mptscsih_remove,
1551         .shutdown       = mptscsih_shutdown,
1552 #ifdef CONFIG_PM
1553         .suspend        = mptscsih_suspend,
1554         .resume         = mptspi_resume,
1555 #endif
1556 };
1557 
1558 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1559 /**
1560  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1561  *
1562  *      Returns 0 for success, non-zero for failure.
1563  */
1564 static int __init
1565 mptspi_init(void)
1566 {
1567         int error;
1568 
1569         show_mptmod_ver(my_NAME, my_VERSION);
1570 
1571         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1572         if (!mptspi_transport_template)
1573                 return -ENODEV;
1574 
1575         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1576             "mptscsih_io_done");
1577         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1578             "mptscsih_taskmgmt_complete");
1579         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1580             MPTSPI_DRIVER, "mptscsih_scandv_complete");
1581 
1582         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1583         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1584 
1585         error = pci_register_driver(&mptspi_driver);
1586         if (error)
1587                 spi_release_transport(mptspi_transport_template);
1588 
1589         return error;
1590 }
1591 
1592 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1593 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1594 /**
1595  *      mptspi_exit - Unregisters MPT adapter(s)
1596  */
1597 static void __exit
1598 mptspi_exit(void)
1599 {
1600         pci_unregister_driver(&mptspi_driver);
1601 
1602         mpt_reset_deregister(mptspiDoneCtx);
1603         mpt_event_deregister(mptspiDoneCtx);
1604 
1605         mpt_deregister(mptspiInternalCtx);
1606         mpt_deregister(mptspiTaskCtx);
1607         mpt_deregister(mptspiDoneCtx);
1608         spi_release_transport(mptspi_transport_template);
1609 }
1610 
1611 module_init(mptspi_init);
1612 module_exit(mptspi_exit);
1613 

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