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

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(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
784 {
785         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
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                 SCpnt->scsi_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                 SCpnt->scsi_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);
806 }
807 
808 static void mptspi_slave_destroy(struct scsi_device *sdev)
809 {
810         struct scsi_target *starget = scsi_target(sdev);
811         VirtTarget *vtarget = starget->hostdata;
812         VirtDevice *vdevice = sdev->hostdata;
813 
814         /* Will this be the last lun on a non-raid device? */
815         if (vtarget->num_luns == 1 && vdevice->configured_lun) {
816                 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
817 
818                 /* Async Narrow */
819                 pg1.RequestedParameters = 0;
820                 pg1.Reserved = 0;
821                 pg1.Configuration = 0;
822 
823                 mptspi_write_spi_device_pg1(starget, &pg1);
824         }
825 
826         mptscsih_slave_destroy(sdev);
827 }
828 
829 static struct scsi_host_template mptspi_driver_template = {
830         .module                         = THIS_MODULE,
831         .proc_name                      = "mptspi",
832         .show_info                      = mptscsih_show_info,
833         .name                           = "MPT SPI Host",
834         .info                           = mptscsih_info,
835         .queuecommand                   = mptspi_qcmd,
836         .target_alloc                   = mptspi_target_alloc,
837         .slave_alloc                    = mptspi_slave_alloc,
838         .slave_configure                = mptspi_slave_configure,
839         .target_destroy                 = mptspi_target_destroy,
840         .slave_destroy                  = mptspi_slave_destroy,
841         .change_queue_depth             = mptscsih_change_queue_depth,
842         .eh_abort_handler               = mptscsih_abort,
843         .eh_device_reset_handler        = mptscsih_dev_reset,
844         .eh_bus_reset_handler           = mptscsih_bus_reset,
845         .eh_host_reset_handler          = mptscsih_host_reset,
846         .bios_param                     = mptscsih_bios_param,
847         .can_queue                      = MPT_SCSI_CAN_QUEUE,
848         .this_id                        = -1,
849         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
850         .max_sectors                    = 8192,
851         .cmd_per_lun                    = 7,
852         .use_clustering                 = ENABLE_CLUSTERING,
853         .shost_attrs                    = mptscsih_host_attrs,
854 };
855 
856 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
857                                struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
858 {
859         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
860         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
861         struct _MPT_ADAPTER *ioc = hd->ioc;
862         struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
863         dma_addr_t pg1_dma;
864         int size;
865         struct _x_config_parms cfg;
866         struct _CONFIG_PAGE_HEADER hdr;
867         int err = -EBUSY;
868         u32 nego_parms;
869         u32 period;
870         struct scsi_device *sdev;
871         int i;
872 
873         /* don't allow updating nego parameters on RAID devices */
874         if (starget->channel == 0 &&
875             mptspi_is_raid(hd, starget->id))
876                 return -1;
877 
878         size = ioc->spi_data.sdp1length * 4;
879 
880         pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
881         if (pg1 == NULL) {
882                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
883                     "dma_alloc_coherent for parameters failed\n", ioc->name);
884                 return -EINVAL;
885         }
886 
887         memset(&hdr, 0, sizeof(hdr));
888 
889         hdr.PageVersion = ioc->spi_data.sdp1version;
890         hdr.PageLength = ioc->spi_data.sdp1length;
891         hdr.PageNumber = 1;
892         hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
893 
894         memset(&cfg, 0, sizeof(cfg));
895 
896         cfg.cfghdr.hdr = &hdr;
897         cfg.physAddr = pg1_dma;
898         cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
899         cfg.dir = 1;
900         cfg.pageAddr = starget->id;
901 
902         memcpy(pg1, pass_pg1, size);
903 
904         pg1->Header.PageVersion = hdr.PageVersion;
905         pg1->Header.PageLength = hdr.PageLength;
906         pg1->Header.PageNumber = hdr.PageNumber;
907         pg1->Header.PageType = hdr.PageType;
908 
909         nego_parms = le32_to_cpu(pg1->RequestedParameters);
910         period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
911                 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
912         if (period == 8) {
913                 /* Turn on inline data padding for TAPE when running U320 */
914                 for (i = 0 ; i < 16; i++) {
915                         sdev = scsi_device_lookup_by_target(starget, i);
916                         if (sdev && sdev->type == TYPE_TAPE) {
917                                 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
918                                             "IDP:ON\n", ioc->name);
919                                 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
920                                 pg1->RequestedParameters =
921                                     cpu_to_le32(nego_parms);
922                                 break;
923                         }
924                 }
925         }
926 
927         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
928 
929         if (mpt_config(ioc, &cfg)) {
930                 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
931                     "mpt_config failed\n", ioc->name);
932                 goto out_free;
933         }
934         err = 0;
935 
936  out_free:
937         dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
938         return err;
939 }
940 
941 static void mptspi_write_offset(struct scsi_target *starget, int offset)
942 {
943         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
944         u32 nego;
945 
946         if (offset < 0)
947                 offset = 0;
948 
949         if (offset > 255)
950                 offset = 255;
951 
952         if (spi_offset(starget) == -1)
953                 mptspi_read_parameters(starget);
954 
955         spi_offset(starget) = offset;
956 
957         nego = mptspi_getRP(starget);
958 
959         pg1.RequestedParameters = cpu_to_le32(nego);
960         pg1.Reserved = 0;
961         pg1.Configuration = 0;
962 
963         mptspi_write_spi_device_pg1(starget, &pg1);
964 }
965 
966 static void mptspi_write_period(struct scsi_target *starget, int period)
967 {
968         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
969         u32 nego;
970 
971         if (period < 8)
972                 period = 8;
973 
974         if (period > 255)
975                 period = 255;
976 
977         if (spi_period(starget) == -1)
978                 mptspi_read_parameters(starget);
979 
980         if (period == 8) {
981                 spi_iu(starget) = 1;
982                 spi_dt(starget) = 1;
983         } else if (period == 9) {
984                 spi_dt(starget) = 1;
985         }
986 
987         spi_period(starget) = period;
988 
989         nego = mptspi_getRP(starget);
990 
991         pg1.RequestedParameters = cpu_to_le32(nego);
992         pg1.Reserved = 0;
993         pg1.Configuration = 0;
994 
995         mptspi_write_spi_device_pg1(starget, &pg1);
996 }
997 
998 static void mptspi_write_dt(struct scsi_target *starget, int dt)
999 {
1000         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1001         u32 nego;
1002 
1003         if (spi_period(starget) == -1)
1004                 mptspi_read_parameters(starget);
1005 
1006         if (!dt && spi_period(starget) < 10)
1007                 spi_period(starget) = 10;
1008 
1009         spi_dt(starget) = dt;
1010 
1011         nego = mptspi_getRP(starget);
1012 
1013 
1014         pg1.RequestedParameters = cpu_to_le32(nego);
1015         pg1.Reserved = 0;
1016         pg1.Configuration = 0;
1017 
1018         mptspi_write_spi_device_pg1(starget, &pg1);
1019 }
1020 
1021 static void mptspi_write_iu(struct scsi_target *starget, int iu)
1022 {
1023         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1024         u32 nego;
1025 
1026         if (spi_period(starget) == -1)
1027                 mptspi_read_parameters(starget);
1028 
1029         if (!iu && spi_period(starget) < 9)
1030                 spi_period(starget) = 9;
1031 
1032         spi_iu(starget) = iu;
1033 
1034         nego = mptspi_getRP(starget);
1035 
1036         pg1.RequestedParameters = cpu_to_le32(nego);
1037         pg1.Reserved = 0;
1038         pg1.Configuration = 0;
1039 
1040         mptspi_write_spi_device_pg1(starget, &pg1);
1041 }
1042 
1043 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm)                              \
1044 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1045 {                                                                       \
1046         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;                          \
1047         u32 nego;                                                       \
1048                                                                         \
1049         spi_##parm(starget) = parm;                                     \
1050                                                                         \
1051         nego = mptspi_getRP(starget);                                   \
1052                                                                         \
1053         pg1.RequestedParameters = cpu_to_le32(nego);                    \
1054         pg1.Reserved = 0;                                               \
1055         pg1.Configuration = 0;                                          \
1056                                                                         \
1057         mptspi_write_spi_device_pg1(starget, &pg1);                             \
1058 }
1059 
1060 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1061 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1062 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1063 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1064 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1065 
1066 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1067 {
1068         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1069         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1070         struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1071         VirtTarget *vtarget = starget->hostdata;
1072         u32 nego;
1073 
1074         if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1075             hd->ioc->spi_data.noQas)
1076                 spi_qas(starget) = 0;
1077         else
1078                 spi_qas(starget) = qas;
1079 
1080         nego = mptspi_getRP(starget);
1081 
1082         pg1.RequestedParameters = cpu_to_le32(nego);
1083         pg1.Reserved = 0;
1084         pg1.Configuration = 0;
1085 
1086         mptspi_write_spi_device_pg1(starget, &pg1);
1087 }
1088 
1089 static void mptspi_write_width(struct scsi_target *starget, int width)
1090 {
1091         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1092         u32 nego;
1093 
1094         if (!width) {
1095                 spi_dt(starget) = 0;
1096                 if (spi_period(starget) < 10)
1097                         spi_period(starget) = 10;
1098         }
1099 
1100         spi_width(starget) = width;
1101 
1102         nego = mptspi_getRP(starget);
1103 
1104         pg1.RequestedParameters = cpu_to_le32(nego);
1105         pg1.Reserved = 0;
1106         pg1.Configuration = 0;
1107 
1108         mptspi_write_spi_device_pg1(starget, &pg1);
1109 }
1110 
1111 struct work_queue_wrapper {
1112         struct work_struct      work;
1113         struct _MPT_SCSI_HOST   *hd;
1114         int                     disk;
1115 };
1116 
1117 static void mpt_work_wrapper(struct work_struct *work)
1118 {
1119         struct work_queue_wrapper *wqw =
1120                 container_of(work, struct work_queue_wrapper, work);
1121         struct _MPT_SCSI_HOST *hd = wqw->hd;
1122         MPT_ADAPTER *ioc = hd->ioc;
1123         struct Scsi_Host *shost = ioc->sh;
1124         struct scsi_device *sdev;
1125         int disk = wqw->disk;
1126         struct _CONFIG_PAGE_IOC_3 *pg3;
1127 
1128         kfree(wqw);
1129 
1130         mpt_findImVolumes(ioc);
1131         pg3 = ioc->raid_data.pIocPg3;
1132         if (!pg3)
1133                 return;
1134 
1135         shost_for_each_device(sdev,shost) {
1136                 struct scsi_target *starget = scsi_target(sdev);
1137                 VirtTarget *vtarget = starget->hostdata;
1138 
1139                 /* only want to search RAID components */
1140                 if (sdev->channel != 1)
1141                         continue;
1142 
1143                 /* The id is the raid PhysDiskNum, even if
1144                  * starget->id is the actual target address */
1145                 if(vtarget->id != disk)
1146                         continue;
1147 
1148                 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1149                     "Integrated RAID requests DV of new device\n", ioc->name);
1150                 mptspi_dv_device(hd, sdev);
1151         }
1152         shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1153             "Integrated RAID detects new device %d\n", ioc->name, disk);
1154         scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1155 }
1156 
1157 
1158 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1159 {
1160         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1161         MPT_ADAPTER *ioc = hd->ioc;
1162 
1163         if (!wqw) {
1164                 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1165                     "Failed to act on RAID event for physical disk %d\n",
1166                     ioc->name, disk);
1167                 return;
1168         }
1169         INIT_WORK(&wqw->work, mpt_work_wrapper);
1170         wqw->hd = hd;
1171         wqw->disk = disk;
1172 
1173         schedule_work(&wqw->work);
1174 }
1175 
1176 static int
1177 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1178 {
1179         u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1180         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1181 
1182         if (ioc->bus_type != SPI)
1183                 return 0;
1184 
1185         if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1186                 int reason
1187                         = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1188 
1189                 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1190                         int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1191                         mpt_dv_raid(hd, disk);
1192                 }
1193         }
1194         return mptscsih_event_process(ioc, pEvReply);
1195 }
1196 
1197 static int
1198 mptspi_deny_binding(struct scsi_target *starget)
1199 {
1200         struct _MPT_SCSI_HOST *hd =
1201                 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1202         return ((mptspi_is_raid(hd, starget->id)) &&
1203                 starget->channel == 0) ? 1 : 0;
1204 }
1205 
1206 static struct spi_function_template mptspi_transport_functions = {
1207         .get_offset     = mptspi_read_parameters,
1208         .set_offset     = mptspi_write_offset,
1209         .show_offset    = 1,
1210         .get_period     = mptspi_read_parameters,
1211         .set_period     = mptspi_write_period,
1212         .show_period    = 1,
1213         .get_width      = mptspi_read_parameters,
1214         .set_width      = mptspi_write_width,
1215         .show_width     = 1,
1216         .get_iu         = mptspi_read_parameters,
1217         .set_iu         = mptspi_write_iu,
1218         .show_iu        = 1,
1219         .get_dt         = mptspi_read_parameters,
1220         .set_dt         = mptspi_write_dt,
1221         .show_dt        = 1,
1222         .get_qas        = mptspi_read_parameters,
1223         .set_qas        = mptspi_write_qas,
1224         .show_qas       = 1,
1225         .get_wr_flow    = mptspi_read_parameters,
1226         .set_wr_flow    = mptspi_write_wr_flow,
1227         .show_wr_flow   = 1,
1228         .get_rd_strm    = mptspi_read_parameters,
1229         .set_rd_strm    = mptspi_write_rd_strm,
1230         .show_rd_strm   = 1,
1231         .get_rti        = mptspi_read_parameters,
1232         .set_rti        = mptspi_write_rti,
1233         .show_rti       = 1,
1234         .get_pcomp_en   = mptspi_read_parameters,
1235         .set_pcomp_en   = mptspi_write_pcomp_en,
1236         .show_pcomp_en  = 1,
1237         .get_hold_mcs   = mptspi_read_parameters,
1238         .set_hold_mcs   = mptspi_write_hold_mcs,
1239         .show_hold_mcs  = 1,
1240         .deny_binding   = mptspi_deny_binding,
1241 };
1242 
1243 /****************************************************************************
1244  * Supported hardware
1245  */
1246 
1247 static struct pci_device_id mptspi_pci_table[] = {
1248         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1249                 PCI_ANY_ID, PCI_ANY_ID },
1250         { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1251                 PCI_ANY_ID, PCI_ANY_ID },
1252         { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1253                 PCI_ANY_ID, PCI_ANY_ID },
1254         {0}     /* Terminating entry */
1255 };
1256 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1257 
1258 
1259 /*
1260  * renegotiate for a given target
1261  */
1262 static void
1263 mptspi_dv_renegotiate_work(struct work_struct *work)
1264 {
1265         struct work_queue_wrapper *wqw =
1266                 container_of(work, struct work_queue_wrapper, work);
1267         struct _MPT_SCSI_HOST *hd = wqw->hd;
1268         struct scsi_device *sdev;
1269         struct scsi_target *starget;
1270         struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1271         u32 nego;
1272         MPT_ADAPTER *ioc = hd->ioc;
1273 
1274         kfree(wqw);
1275 
1276         if (hd->spi_pending) {
1277                 shost_for_each_device(sdev, ioc->sh) {
1278                         if  (hd->spi_pending & (1 << sdev->id))
1279                                 continue;
1280                         starget = scsi_target(sdev);
1281                         nego = mptspi_getRP(starget);
1282                         pg1.RequestedParameters = cpu_to_le32(nego);
1283                         pg1.Reserved = 0;
1284                         pg1.Configuration = 0;
1285                         mptspi_write_spi_device_pg1(starget, &pg1);
1286                 }
1287         } else {
1288                 shost_for_each_device(sdev, ioc->sh)
1289                         mptspi_dv_device(hd, sdev);
1290         }
1291 }
1292 
1293 static void
1294 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1295 {
1296         struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1297 
1298         if (!wqw)
1299                 return;
1300 
1301         INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1302         wqw->hd = hd;
1303 
1304         schedule_work(&wqw->work);
1305 }
1306 
1307 /*
1308  * spi module reset handler
1309  */
1310 static int
1311 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1312 {
1313         int rc;
1314 
1315         rc = mptscsih_ioc_reset(ioc, reset_phase);
1316         if ((ioc->bus_type != SPI) || (!rc))
1317                 return rc;
1318 
1319         /* only try to do a renegotiation if we're properly set up
1320          * if we get an ioc fault on bringup, ioc->sh will be NULL */
1321         if (reset_phase == MPT_IOC_POST_RESET &&
1322             ioc->sh) {
1323                 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1324 
1325                 mptspi_dv_renegotiate(hd);
1326         }
1327 
1328         return rc;
1329 }
1330 
1331 #ifdef CONFIG_PM
1332 /*
1333  * spi module resume handler
1334  */
1335 static int
1336 mptspi_resume(struct pci_dev *pdev)
1337 {
1338         MPT_ADAPTER     *ioc = pci_get_drvdata(pdev);
1339         struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1340         int rc;
1341 
1342         rc = mptscsih_resume(pdev);
1343         mptspi_dv_renegotiate(hd);
1344 
1345         return rc;
1346 }
1347 #endif
1348 
1349 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1350 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1351 /*
1352  *      mptspi_probe - Installs scsi devices per bus.
1353  *      @pdev: Pointer to pci_dev structure
1354  *
1355  *      Returns 0 for success, non-zero for failure.
1356  *
1357  */
1358 static int
1359 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1360 {
1361         struct Scsi_Host        *sh;
1362         MPT_SCSI_HOST           *hd;
1363         MPT_ADAPTER             *ioc;
1364         unsigned long            flags;
1365         int                      ii;
1366         int                      numSGE = 0;
1367         int                      scale;
1368         int                      ioc_cap;
1369         int                     error=0;
1370         int                     r;
1371 
1372         if ((r = mpt_attach(pdev,id)) != 0)
1373                 return r;
1374 
1375         ioc = pci_get_drvdata(pdev);
1376         ioc->DoneCtx = mptspiDoneCtx;
1377         ioc->TaskCtx = mptspiTaskCtx;
1378         ioc->InternalCtx = mptspiInternalCtx;
1379 
1380         /*  Added sanity check on readiness of the MPT adapter.
1381          */
1382         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1383                 printk(MYIOC_s_WARN_FMT
1384                   "Skipping because it's not operational!\n",
1385                   ioc->name);
1386                 error = -ENODEV;
1387                 goto out_mptspi_probe;
1388         }
1389 
1390         if (!ioc->active) {
1391                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1392                   ioc->name);
1393                 error = -ENODEV;
1394                 goto out_mptspi_probe;
1395         }
1396 
1397         /*  Sanity check - ensure at least 1 port is INITIATOR capable
1398          */
1399         ioc_cap = 0;
1400         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1401                 if (ioc->pfacts[ii].ProtocolFlags &
1402                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
1403                         ioc_cap ++;
1404         }
1405 
1406         if (!ioc_cap) {
1407                 printk(MYIOC_s_WARN_FMT
1408                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1409                         ioc->name, ioc);
1410                 return 0;
1411         }
1412 
1413         sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1414 
1415         if (!sh) {
1416                 printk(MYIOC_s_WARN_FMT
1417                         "Unable to register controller with SCSI subsystem\n",
1418                         ioc->name);
1419                 error = -1;
1420                 goto out_mptspi_probe;
1421         }
1422 
1423         spin_lock_irqsave(&ioc->FreeQlock, flags);
1424 
1425         /* Attach the SCSI Host to the IOC structure
1426          */
1427         ioc->sh = sh;
1428 
1429         sh->io_port = 0;
1430         sh->n_io_port = 0;
1431         sh->irq = 0;
1432 
1433         /* set 16 byte cdb's */
1434         sh->max_cmd_len = 16;
1435 
1436         /* Yikes!  This is important!
1437          * Otherwise, by default, linux
1438          * only scans target IDs 0-7!
1439          * pfactsN->MaxDevices unreliable
1440          * (not supported in early
1441          *      versions of the FW).
1442          * max_id = 1 + actual max id,
1443          * max_lun = 1 + actual last lun,
1444          *      see hosts.h :o(
1445          */
1446         sh->max_id = ioc->devices_per_bus;
1447 
1448         sh->max_lun = MPT_LAST_LUN + 1;
1449         /*
1450          * If RAID Firmware Detected, setup virtual channel
1451          */
1452         if (ioc->ir_firmware)
1453                 sh->max_channel = 1;
1454         else
1455                 sh->max_channel = 0;
1456         sh->this_id = ioc->pfacts[0].PortSCSIID;
1457 
1458         /* Required entry.
1459          */
1460         sh->unique_id = ioc->id;
1461 
1462         /* Verify that we won't exceed the maximum
1463          * number of chain buffers
1464          * We can optimize:  ZZ = req_sz/sizeof(SGE)
1465          * For 32bit SGE's:
1466          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1467          *               + (req_sz - 64)/sizeof(SGE)
1468          * A slightly different algorithm is required for
1469          * 64bit SGEs.
1470          */
1471         scale = ioc->req_sz/ioc->SGE_size;
1472         if (ioc->sg_addr_size == sizeof(u64)) {
1473                 numSGE = (scale - 1) *
1474                   (ioc->facts.MaxChainDepth-1) + scale +
1475                   (ioc->req_sz - 60) / ioc->SGE_size;
1476         } else {
1477                 numSGE = 1 + (scale - 1) *
1478                   (ioc->facts.MaxChainDepth-1) + scale +
1479                   (ioc->req_sz - 64) / ioc->SGE_size;
1480         }
1481 
1482         if (numSGE < sh->sg_tablesize) {
1483                 /* Reset this value */
1484                 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1485                   "Resetting sg_tablesize to %d from %d\n",
1486                   ioc->name, numSGE, sh->sg_tablesize));
1487                 sh->sg_tablesize = numSGE;
1488         }
1489 
1490         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1491 
1492         hd = shost_priv(sh);
1493         hd->ioc = ioc;
1494 
1495         /* SCSI needs scsi_cmnd lookup table!
1496          * (with size equal to req_depth*PtrSz!)
1497          */
1498         ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1499         if (!ioc->ScsiLookup) {
1500                 error = -ENOMEM;
1501                 goto out_mptspi_probe;
1502         }
1503         spin_lock_init(&ioc->scsi_lookup_lock);
1504 
1505         dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1506                  ioc->name, ioc->ScsiLookup));
1507 
1508         ioc->spi_data.Saf_Te = mpt_saf_te;
1509         ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1510                 "saf_te %x\n",
1511                 ioc->name,
1512                 mpt_saf_te));
1513         ioc->spi_data.noQas = 0;
1514 
1515         hd->last_queue_full = 0;
1516         hd->spi_pending = 0;
1517 
1518         /* Some versions of the firmware don't support page 0; without
1519          * that we can't get the parameters */
1520         if (ioc->spi_data.sdp0length != 0)
1521                 sh->transportt = mptspi_transport_template;
1522 
1523         error = scsi_add_host (sh, &ioc->pcidev->dev);
1524         if(error) {
1525                 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1526                   "scsi_add_host failed\n", ioc->name));
1527                 goto out_mptspi_probe;
1528         }
1529 
1530         /*
1531          * issue internal bus reset
1532          */
1533         if (ioc->spi_data.bus_reset)
1534                 mptscsih_IssueTaskMgmt(hd,
1535                     MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1536                     0, 0, 0, 0, 5);
1537 
1538         scsi_scan_host(sh);
1539         return 0;
1540 
1541 out_mptspi_probe:
1542 
1543         mptscsih_remove(pdev);
1544         return error;
1545 }
1546 
1547 static struct pci_driver mptspi_driver = {
1548         .name           = "mptspi",
1549         .id_table       = mptspi_pci_table,
1550         .probe          = mptspi_probe,
1551         .remove         = mptscsih_remove,
1552         .shutdown       = mptscsih_shutdown,
1553 #ifdef CONFIG_PM
1554         .suspend        = mptscsih_suspend,
1555         .resume         = mptspi_resume,
1556 #endif
1557 };
1558 
1559 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1560 /**
1561  *      mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1562  *
1563  *      Returns 0 for success, non-zero for failure.
1564  */
1565 static int __init
1566 mptspi_init(void)
1567 {
1568         int error;
1569 
1570         show_mptmod_ver(my_NAME, my_VERSION);
1571 
1572         mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1573         if (!mptspi_transport_template)
1574                 return -ENODEV;
1575 
1576         mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1577             "mptscsih_io_done");
1578         mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1579             "mptscsih_taskmgmt_complete");
1580         mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1581             MPTSPI_DRIVER, "mptscsih_scandv_complete");
1582 
1583         mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1584         mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1585 
1586         error = pci_register_driver(&mptspi_driver);
1587         if (error)
1588                 spi_release_transport(mptspi_transport_template);
1589 
1590         return error;
1591 }
1592 
1593 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1594 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1595 /**
1596  *      mptspi_exit - Unregisters MPT adapter(s)
1597  */
1598 static void __exit
1599 mptspi_exit(void)
1600 {
1601         pci_unregister_driver(&mptspi_driver);
1602 
1603         mpt_reset_deregister(mptspiDoneCtx);
1604         mpt_event_deregister(mptspiDoneCtx);
1605 
1606         mpt_deregister(mptspiInternalCtx);
1607         mpt_deregister(mptspiTaskCtx);
1608         mpt_deregister(mptspiDoneCtx);
1609         spi_release_transport(mptspi_transport_template);
1610 }
1611 
1612 module_init(mptspi_init);
1613 module_exit(mptspi_exit);
1614 

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