2 * linux/drivers/message/fusion/mptspi.c
3 * For use with LSI Logic PCI chip/adapter(s)
4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
6 * Copyright (c) 1999-2007 LSI Logic Corporation
7 * (mailto:DL-MPTFusionLinux@lsi.com)
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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.
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.
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.
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
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
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/init.h>
50 #include <linux/errno.h>
51 #include <linux/kdev_t.h>
52 #include <linux/blkdev.h>
53 #include <linux/delay.h> /* for mdelay */
54 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
55 #include <linux/reboot.h> /* notifier code */
56 #include <linux/workqueue.h>
57 #include <linux/raid_class.h>
59 #include <scsi/scsi.h>
60 #include <scsi/scsi_cmnd.h>
61 #include <scsi/scsi_device.h>
62 #include <scsi/scsi_host.h>
63 #include <scsi/scsi_tcq.h>
64 #include <scsi/scsi_transport.h>
65 #include <scsi/scsi_transport_spi.h>
66 #include <scsi/scsi_dbg.h>
71 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
72 #define my_NAME "Fusion MPT SPI Host driver"
73 #define my_VERSION MPT_LINUX_VERSION_COMMON
74 #define MYNAM "mptspi"
76 MODULE_AUTHOR(MODULEAUTHOR);
77 MODULE_DESCRIPTION(my_NAME);
78 MODULE_LICENSE("GPL");
79 MODULE_VERSION(my_VERSION);
81 /* Command line args */
82 static int mpt_saf_te = MPTSCSIH_SAF_TE;
83 module_param(mpt_saf_te, int, 0);
84 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
86 static void mptspi_write_offset(struct scsi_target *, int);
87 static void mptspi_write_width(struct scsi_target *, int);
88 static int mptspi_write_spi_device_pg1(struct scsi_target *,
89 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
91 static struct scsi_transport_template *mptspi_transport_template = NULL;
93 static int mptspiDoneCtx = -1;
94 static int mptspiTaskCtx = -1;
95 static int mptspiInternalCtx = -1; /* Used only for internal commands */
98 * mptspi_setTargetNegoParms - Update the target negotiation parameters
99 * @hd: Pointer to a SCSI Host Structure
100 * @target: per target private data
103 * Update the target negotiation parameters based on the the Inquiry
104 * data, adapter capabilities, and NVRAM settings.
107 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
108 struct scsi_device *sdev)
110 SpiCfgData *pspi_data = &hd->ioc->spi_data;
111 int id = (int) target->id;
113 u8 width = MPT_NARROW;
114 u8 factor = MPT_ASYNC;
119 target->negoFlags = pspi_data->noQas;
121 if (sdev->scsi_level < SCSI_2) {
124 offset = pspi_data->maxSyncOffset;
125 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
127 if (scsi_device_wide(sdev))
130 if (scsi_device_sync(sdev)) {
131 factor = pspi_data->minSyncFactor;
132 if (!scsi_device_dt(sdev))
135 if (!scsi_device_ius(sdev) &&
136 !scsi_device_qas(sdev))
137 factor = MPT_ULTRA160;
139 factor = MPT_ULTRA320;
140 if (scsi_device_qas(sdev)) {
141 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
144 if (sdev->type == TYPE_TAPE &&
145 scsi_device_ius(sdev))
146 target->negoFlags |= MPT_TAPE_NEGO_IDP;
149 offset = pspi_data->maxSyncOffset;
151 /* If RAID, never disable QAS
152 * else if non RAID, do not disable
153 * QAS if bit 1 is set
154 * bit 1 QAS support, non-raid only
157 if (target->raidVolume == 1)
165 if (!sdev->tagged_supported)
166 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
168 /* Update tflags based on NVRAM settings. (SCSI only)
170 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
171 nvram = pspi_data->nvram[id];
172 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
175 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
178 /* Ensure factor is set to the
179 * maximum of: adapter, nvram, inquiry
182 if (nfactor < pspi_data->minSyncFactor )
183 nfactor = pspi_data->minSyncFactor;
185 factor = max(factor, nfactor);
186 if (factor == MPT_ASYNC)
197 /* Make sure data is consistent
199 if ((!width) && (factor < MPT_ULTRA2))
202 /* Save the data to the target structure.
204 target->minSyncFactor = factor;
205 target->maxOffset = offset;
206 target->maxWidth = width;
208 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
210 /* Disable unused features.
213 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
216 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
218 if ( factor > MPT_ULTRA320 )
221 if (noQas && (pspi_data->noQas == 0)) {
222 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
223 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
225 /* Disable QAS in a mixed configuration case
228 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
233 * mptspi_writeIOCPage4 - write IOC Page 4
234 * @hd: Pointer to a SCSI Host Structure
235 * @channel: channel number
236 * @id: write IOC Page4 for this ID & Bus
238 * Return: -EAGAIN if unable to obtain a Message Frame
241 * Remark: We do not wait for a return, write pages sequentially.
244 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
246 MPT_ADAPTER *ioc = hd->ioc;
248 IOCPage4_t *IOCPage4Ptr;
256 /* Get a MF for this command.
258 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
259 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
264 /* Set the request and the data pointers.
265 * Place data at end of MF.
267 pReq = (Config_t *)mf;
269 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
270 frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
272 /* Complete the request frame (same for all requests).
274 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
276 pReq->ChainOffset = 0;
277 pReq->Function = MPI_FUNCTION_CONFIG;
278 pReq->ExtPageLength = 0;
279 pReq->ExtPageType = 0;
281 for (ii=0; ii < 8; ii++) {
282 pReq->Reserved2[ii] = 0;
285 IOCPage4Ptr = ioc->spi_data.pIocPg4;
286 dataDma = ioc->spi_data.IocPg4_dma;
287 ii = IOCPage4Ptr->ActiveSEP++;
288 IOCPage4Ptr->SEP[ii].SEPTargetID = id;
289 IOCPage4Ptr->SEP[ii].SEPBus = channel;
290 pReq->Header = IOCPage4Ptr->Header;
291 pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
293 /* Add a SGE to the config request.
295 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
296 (IOCPage4Ptr->Header.PageLength + ii) * 4;
298 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
300 ddvprintk((MYIOC_s_INFO_FMT
301 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
302 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
304 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
310 * mptspi_initTarget - Target, LUN alloc/free functionality.
311 * @hd: Pointer to MPT_SCSI_HOST structure
312 * @vtarget: per target private data
315 * NOTE: It's only SAFE to call this routine if data points to
316 * sane & valid STANDARD INQUIRY data!
318 * Allocate and initialize memory for this target.
323 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
324 struct scsi_device *sdev)
327 /* Is LUN supported? If so, upper 2 bits will be 0
328 * in first byte of inquiry data.
330 if (sdev->inq_periph_qual != 0)
336 vtarget->type = sdev->type;
338 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
339 /* Treat all Processors as SAF-TE if
340 * command line option is set */
341 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
342 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
343 }else if ((sdev->type == TYPE_PROCESSOR) &&
344 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
345 if (sdev->inquiry_len > 49 ) {
346 if (sdev->inquiry[44] == 'S' &&
347 sdev->inquiry[45] == 'A' &&
348 sdev->inquiry[46] == 'F' &&
349 sdev->inquiry[47] == '-' &&
350 sdev->inquiry[48] == 'T' &&
351 sdev->inquiry[49] == 'E' ) {
352 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
353 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
357 mptspi_setTargetNegoParms(hd, vtarget, sdev);
361 * mptspi_is_raid - Determines whether target is belonging to volume
362 * @hd: Pointer to a SCSI HOST structure
363 * @id: target device id
371 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
375 if (!hd->ioc->raid_data.pIocPg2)
378 if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
380 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
381 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
391 static int mptspi_target_alloc(struct scsi_target *starget)
393 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
394 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
400 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
404 vtarget->ioc_id = hd->ioc->id;
405 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
406 vtarget->id = (u8)starget->id;
407 vtarget->channel = (u8)starget->channel;
408 vtarget->starget = starget;
409 starget->hostdata = vtarget;
411 if (starget->channel == 1) {
412 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
414 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
415 /* The real channel for this device is zero */
416 vtarget->channel = 0;
417 /* The actual physdisknum (for RAID passthrough) */
418 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
422 if (starget->channel == 0 &&
423 mptspi_is_raid(hd, starget->id)) {
424 vtarget->raidVolume = 1;
426 "RAID Volume @ channel=%d id=%d\n", starget->channel,
430 if (hd->ioc->spi_data.nvram &&
431 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
432 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
433 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
434 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
436 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
437 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
439 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
441 spi_offset(starget) = 0;
442 mptspi_write_width(starget, 0);
448 mptspi_target_destroy(struct scsi_target *starget)
450 if (starget->hostdata)
451 kfree(starget->hostdata);
452 starget->hostdata = NULL;
456 * mptspi_print_write_nego - negotiation parameters debug info that is being sent
457 * @hd: Pointer to a SCSI HOST structure
458 * @starget: SCSI target
459 * @ii: negotiation parameters
463 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
465 ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x"
466 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
467 hd->ioc->name, starget->id, ii,
468 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
469 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
470 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
471 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
472 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
473 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
474 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
475 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
476 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
477 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
481 * mptspi_print_read_nego - negotiation parameters debug info that is being read
482 * @hd: Pointer to a SCSI HOST structure
483 * @starget: SCSI target
484 * @ii: negotiation parameters
488 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
490 ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x"
491 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
492 hd->ioc->name, starget->id, ii,
493 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
494 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
495 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
496 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
497 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
498 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
499 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
500 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
501 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
502 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
505 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
506 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
508 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
509 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
510 struct _MPT_ADAPTER *ioc = hd->ioc;
511 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
514 struct _x_config_parms cfg;
515 struct _CONFIG_PAGE_HEADER hdr;
518 /* No SPI parameters for RAID devices */
519 if (starget->channel == 0 &&
520 mptspi_is_raid(hd, starget->id))
523 size = ioc->spi_data.sdp0length * 4;
525 if (ioc->spi_data.sdp0length & 1)
530 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
532 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
536 memset(&hdr, 0, sizeof(hdr));
538 hdr.PageVersion = ioc->spi_data.sdp0version;
539 hdr.PageLength = ioc->spi_data.sdp0length;
541 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
543 memset(&cfg, 0, sizeof(cfg));
545 cfg.cfghdr.hdr = &hdr;
546 cfg.physAddr = pg0_dma;
547 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
549 cfg.pageAddr = starget->id;
551 if (mpt_config(ioc, &cfg)) {
552 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
556 memcpy(pass_pg0, pg0, size);
558 mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
561 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
565 static u32 mptspi_getRP(struct scsi_target *starget)
569 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
570 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
571 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
572 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
573 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
574 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
575 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
576 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
578 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
579 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
580 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
585 static void mptspi_read_parameters(struct scsi_target *starget)
588 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
590 mptspi_read_spi_device_pg0(starget, &pg0);
592 nego = le32_to_cpu(pg0.NegotiatedParameters);
594 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
595 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
596 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
597 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
598 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
599 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
600 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
601 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
602 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
603 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
604 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
608 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
610 MpiRaidActionRequest_t *pReq;
613 /* Get and Populate a free Frame
615 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
616 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
620 pReq = (MpiRaidActionRequest_t *)mf;
622 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
624 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
626 pReq->ChainOffset = 0;
627 pReq->Function = MPI_FUNCTION_RAID_ACTION;
629 pReq->VolumeBus = channel;
630 pReq->PhysDiskNum = 0;
633 pReq->ActionDataWord = 0; /* Reserved for this action */
635 mpt_add_sge((char *)&pReq->ActionDataSGE,
636 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
638 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n",
639 hd->ioc->name, pReq->Action, channel, id));
642 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
643 hd->scandv_wait_done = 0;
645 /* Save cmd pointer, for resource free if timeout or
650 add_timer(&hd->timer);
651 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
652 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
654 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
660 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
661 struct scsi_device *sdev)
663 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
665 /* no DV on RAID devices */
666 if (sdev->channel == 0 &&
667 mptspi_is_raid(hd, sdev->id))
670 /* If this is a piece of a RAID, then quiesce first */
671 if (sdev->channel == 1 &&
672 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
673 starget_printk(KERN_ERR, scsi_target(sdev),
674 "Integrated RAID quiesce failed\n");
678 hd->spi_pending |= (1 << sdev->id);
680 hd->spi_pending &= ~(1 << sdev->id);
682 if (sdev->channel == 1 &&
683 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
684 starget_printk(KERN_ERR, scsi_target(sdev),
685 "Integrated RAID resume failed\n");
687 mptspi_read_parameters(sdev->sdev_target);
688 spi_display_xfer_agreement(sdev->sdev_target);
689 mptspi_read_parameters(sdev->sdev_target);
692 static int mptspi_slave_alloc(struct scsi_device *sdev)
694 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
697 struct scsi_target *starget;
699 if (sdev->channel == 1 &&
700 mptscsih_is_phys_disk(hd->ioc, 0, sdev->id) == 0)
703 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
705 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
706 hd->ioc->name, sizeof(VirtDevice));
710 vdev->lun = sdev->lun;
711 sdev->hostdata = vdev;
713 starget = scsi_target(sdev);
714 vtarget = starget->hostdata;
715 vdev->vtarget = vtarget;
718 if (sdev->channel == 1)
719 sdev->no_uld_attach = 1;
724 static int mptspi_slave_configure(struct scsi_device *sdev)
726 struct _MPT_SCSI_HOST *hd =
727 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
728 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
729 int ret = mptscsih_slave_configure(sdev);
734 mptspi_initTarget(hd, vtarget, sdev);
736 ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
737 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
738 sdev->id, spi_min_period(scsi_target(sdev)),
739 spi_max_offset(scsi_target(sdev)),
740 spi_max_width(scsi_target(sdev))));
742 if ((sdev->channel == 1 ||
743 !(mptspi_is_raid(hd, sdev->id))) &&
744 !spi_initial_dv(sdev->sdev_target))
745 mptspi_dv_device(hd, sdev);
751 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
753 struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
754 VirtDevice *vdev = SCpnt->device->hostdata;
756 if (!vdev || !vdev->vtarget) {
757 SCpnt->result = DID_NO_CONNECT << 16;
762 if (SCpnt->device->channel == 1 &&
763 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
764 SCpnt->result = DID_NO_CONNECT << 16;
770 if (spi_dv_pending(scsi_target(SCpnt->device)))
771 scsi_print_command(SCpnt);
774 return mptscsih_qcmd(SCpnt,done);
777 static void mptspi_slave_destroy(struct scsi_device *sdev)
779 struct scsi_target *starget = scsi_target(sdev);
780 VirtTarget *vtarget = starget->hostdata;
781 VirtDevice *vdevice = sdev->hostdata;
783 /* Will this be the last lun on a non-raid device? */
784 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
785 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
788 pg1.RequestedParameters = 0;
790 pg1.Configuration = 0;
792 mptspi_write_spi_device_pg1(starget, &pg1);
795 mptscsih_slave_destroy(sdev);
798 static struct scsi_host_template mptspi_driver_template = {
799 .module = THIS_MODULE,
800 .proc_name = "mptspi",
801 .proc_info = mptscsih_proc_info,
802 .name = "MPT SPI Host",
803 .info = mptscsih_info,
804 .queuecommand = mptspi_qcmd,
805 .target_alloc = mptspi_target_alloc,
806 .slave_alloc = mptspi_slave_alloc,
807 .slave_configure = mptspi_slave_configure,
808 .target_destroy = mptspi_target_destroy,
809 .slave_destroy = mptspi_slave_destroy,
810 .change_queue_depth = mptscsih_change_queue_depth,
811 .eh_abort_handler = mptscsih_abort,
812 .eh_device_reset_handler = mptscsih_dev_reset,
813 .eh_bus_reset_handler = mptscsih_bus_reset,
814 .eh_host_reset_handler = mptscsih_host_reset,
815 .bios_param = mptscsih_bios_param,
816 .can_queue = MPT_SCSI_CAN_QUEUE,
818 .sg_tablesize = MPT_SCSI_SG_DEPTH,
821 .use_clustering = ENABLE_CLUSTERING,
824 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
825 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
827 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
828 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
829 struct _MPT_ADAPTER *ioc = hd->ioc;
830 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
833 struct _x_config_parms cfg;
834 struct _CONFIG_PAGE_HEADER hdr;
837 /* don't allow updating nego parameters on RAID devices */
838 if (starget->channel == 0 &&
839 mptspi_is_raid(hd, starget->id))
842 size = ioc->spi_data.sdp1length * 4;
844 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
846 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
850 memset(&hdr, 0, sizeof(hdr));
852 hdr.PageVersion = ioc->spi_data.sdp1version;
853 hdr.PageLength = ioc->spi_data.sdp1length;
855 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
857 memset(&cfg, 0, sizeof(cfg));
859 cfg.cfghdr.hdr = &hdr;
860 cfg.physAddr = pg1_dma;
861 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
863 cfg.pageAddr = starget->id;
865 memcpy(pg1, pass_pg1, size);
867 pg1->Header.PageVersion = hdr.PageVersion;
868 pg1->Header.PageLength = hdr.PageLength;
869 pg1->Header.PageNumber = hdr.PageNumber;
870 pg1->Header.PageType = hdr.PageType;
872 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
874 if (mpt_config(ioc, &cfg)) {
875 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
881 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
885 static void mptspi_write_offset(struct scsi_target *starget, int offset)
887 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
896 if (spi_offset(starget) == -1)
897 mptspi_read_parameters(starget);
899 spi_offset(starget) = offset;
901 nego = mptspi_getRP(starget);
903 pg1.RequestedParameters = cpu_to_le32(nego);
905 pg1.Configuration = 0;
907 mptspi_write_spi_device_pg1(starget, &pg1);
910 static void mptspi_write_period(struct scsi_target *starget, int period)
912 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
921 if (spi_period(starget) == -1)
922 mptspi_read_parameters(starget);
927 } else if (period == 9) {
931 spi_period(starget) = period;
933 nego = mptspi_getRP(starget);
935 pg1.RequestedParameters = cpu_to_le32(nego);
937 pg1.Configuration = 0;
939 mptspi_write_spi_device_pg1(starget, &pg1);
942 static void mptspi_write_dt(struct scsi_target *starget, int dt)
944 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
947 if (spi_period(starget) == -1)
948 mptspi_read_parameters(starget);
950 if (!dt && spi_period(starget) < 10)
951 spi_period(starget) = 10;
953 spi_dt(starget) = dt;
955 nego = mptspi_getRP(starget);
958 pg1.RequestedParameters = cpu_to_le32(nego);
960 pg1.Configuration = 0;
962 mptspi_write_spi_device_pg1(starget, &pg1);
965 static void mptspi_write_iu(struct scsi_target *starget, int iu)
967 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
970 if (spi_period(starget) == -1)
971 mptspi_read_parameters(starget);
973 if (!iu && spi_period(starget) < 9)
974 spi_period(starget) = 9;
976 spi_iu(starget) = iu;
978 nego = mptspi_getRP(starget);
980 pg1.RequestedParameters = cpu_to_le32(nego);
982 pg1.Configuration = 0;
984 mptspi_write_spi_device_pg1(starget, &pg1);
987 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
988 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
990 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
993 spi_##parm(starget) = parm; \
995 nego = mptspi_getRP(starget); \
997 pg1.RequestedParameters = cpu_to_le32(nego); \
999 pg1.Configuration = 0; \
1001 mptspi_write_spi_device_pg1(starget, &pg1); \
1004 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1005 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1006 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1007 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1010 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1012 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1013 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1014 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1015 VirtTarget *vtarget = starget->hostdata;
1018 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1019 hd->ioc->spi_data.noQas)
1020 spi_qas(starget) = 0;
1022 spi_qas(starget) = qas;
1024 nego = mptspi_getRP(starget);
1026 pg1.RequestedParameters = cpu_to_le32(nego);
1028 pg1.Configuration = 0;
1030 mptspi_write_spi_device_pg1(starget, &pg1);
1033 static void mptspi_write_width(struct scsi_target *starget, int width)
1035 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1039 spi_dt(starget) = 0;
1040 if (spi_period(starget) < 10)
1041 spi_period(starget) = 10;
1044 spi_width(starget) = width;
1046 nego = mptspi_getRP(starget);
1048 pg1.RequestedParameters = cpu_to_le32(nego);
1050 pg1.Configuration = 0;
1052 mptspi_write_spi_device_pg1(starget, &pg1);
1055 struct work_queue_wrapper {
1056 struct work_struct work;
1057 struct _MPT_SCSI_HOST *hd;
1061 static void mpt_work_wrapper(struct work_struct *work)
1063 struct work_queue_wrapper *wqw =
1064 container_of(work, struct work_queue_wrapper, work);
1065 struct _MPT_SCSI_HOST *hd = wqw->hd;
1066 struct Scsi_Host *shost = hd->ioc->sh;
1067 struct scsi_device *sdev;
1068 int disk = wqw->disk;
1069 struct _CONFIG_PAGE_IOC_3 *pg3;
1073 mpt_findImVolumes(hd->ioc);
1074 pg3 = hd->ioc->raid_data.pIocPg3;
1078 shost_for_each_device(sdev,shost) {
1079 struct scsi_target *starget = scsi_target(sdev);
1080 VirtTarget *vtarget = starget->hostdata;
1082 /* only want to search RAID components */
1083 if (sdev->channel != 1)
1086 /* The id is the raid PhysDiskNum, even if
1087 * starget->id is the actual target address */
1088 if(vtarget->id != disk)
1091 starget_printk(KERN_INFO, vtarget->starget,
1092 "Integrated RAID requests DV of new device\n");
1093 mptspi_dv_device(hd, sdev);
1095 shost_printk(KERN_INFO, shost,
1096 "Integrated RAID detects new device %d\n", disk);
1097 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1101 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1103 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1106 shost_printk(KERN_ERR, hd->ioc->sh,
1107 "Failed to act on RAID event for physical disk %d\n",
1111 INIT_WORK(&wqw->work, mpt_work_wrapper);
1115 schedule_work(&wqw->work);
1119 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1121 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1122 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1124 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1126 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1128 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1129 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1130 mpt_dv_raid(hd, disk);
1133 return mptscsih_event_process(ioc, pEvReply);
1137 mptspi_deny_binding(struct scsi_target *starget)
1139 struct _MPT_SCSI_HOST *hd =
1140 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1141 return ((mptspi_is_raid(hd, starget->id)) &&
1142 starget->channel == 0) ? 1 : 0;
1145 static struct spi_function_template mptspi_transport_functions = {
1146 .get_offset = mptspi_read_parameters,
1147 .set_offset = mptspi_write_offset,
1149 .get_period = mptspi_read_parameters,
1150 .set_period = mptspi_write_period,
1152 .get_width = mptspi_read_parameters,
1153 .set_width = mptspi_write_width,
1155 .get_iu = mptspi_read_parameters,
1156 .set_iu = mptspi_write_iu,
1158 .get_dt = mptspi_read_parameters,
1159 .set_dt = mptspi_write_dt,
1161 .get_qas = mptspi_read_parameters,
1162 .set_qas = mptspi_write_qas,
1164 .get_wr_flow = mptspi_read_parameters,
1165 .set_wr_flow = mptspi_write_wr_flow,
1167 .get_rd_strm = mptspi_read_parameters,
1168 .set_rd_strm = mptspi_write_rd_strm,
1170 .get_rti = mptspi_read_parameters,
1171 .set_rti = mptspi_write_rti,
1173 .get_pcomp_en = mptspi_read_parameters,
1174 .set_pcomp_en = mptspi_write_pcomp_en,
1176 .get_hold_mcs = mptspi_read_parameters,
1177 .set_hold_mcs = mptspi_write_hold_mcs,
1179 .deny_binding = mptspi_deny_binding,
1182 /****************************************************************************
1183 * Supported hardware
1186 static struct pci_device_id mptspi_pci_table[] = {
1187 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1188 PCI_ANY_ID, PCI_ANY_ID },
1189 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1190 PCI_ANY_ID, PCI_ANY_ID },
1191 {0} /* Terminating entry */
1193 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1197 * renegotiate for a given target
1200 mptspi_dv_renegotiate_work(struct work_struct *work)
1202 struct work_queue_wrapper *wqw =
1203 container_of(work, struct work_queue_wrapper, work);
1204 struct _MPT_SCSI_HOST *hd = wqw->hd;
1205 struct scsi_device *sdev;
1206 struct scsi_target *starget;
1207 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1212 if (hd->spi_pending) {
1213 shost_for_each_device(sdev, hd->ioc->sh) {
1214 if (hd->spi_pending & (1 << sdev->id))
1216 starget = scsi_target(sdev);
1217 nego = mptspi_getRP(starget);
1218 pg1.RequestedParameters = cpu_to_le32(nego);
1220 pg1.Configuration = 0;
1221 mptspi_write_spi_device_pg1(starget, &pg1);
1224 shost_for_each_device(sdev, hd->ioc->sh)
1225 mptspi_dv_device(hd, sdev);
1230 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1232 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1237 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1240 schedule_work(&wqw->work);
1244 * spi module reset handler
1247 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1249 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1252 rc = mptscsih_ioc_reset(ioc, reset_phase);
1254 if (reset_phase == MPT_IOC_POST_RESET)
1255 mptspi_dv_renegotiate(hd);
1262 * spi module resume handler
1265 mptspi_resume(struct pci_dev *pdev)
1267 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1268 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1271 rc = mptscsih_resume(pdev);
1272 mptspi_dv_renegotiate(hd);
1278 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1279 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1281 * mptspi_probe - Installs scsi devices per bus.
1282 * @pdev: Pointer to pci_dev structure
1284 * Returns 0 for success, non-zero for failure.
1288 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1290 struct Scsi_Host *sh;
1293 unsigned long flags;
1301 if ((r = mpt_attach(pdev,id)) != 0)
1304 ioc = pci_get_drvdata(pdev);
1305 ioc->DoneCtx = mptspiDoneCtx;
1306 ioc->TaskCtx = mptspiTaskCtx;
1307 ioc->InternalCtx = mptspiInternalCtx;
1309 /* Added sanity check on readiness of the MPT adapter.
1311 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1312 printk(MYIOC_s_WARN_FMT
1313 "Skipping because it's not operational!\n",
1316 goto out_mptspi_probe;
1320 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1323 goto out_mptspi_probe;
1326 /* Sanity check - ensure at least 1 port is INITIATOR capable
1329 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1330 if (ioc->pfacts[ii].ProtocolFlags &
1331 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1336 printk(MYIOC_s_WARN_FMT
1337 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1342 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1345 printk(MYIOC_s_WARN_FMT
1346 "Unable to register controller with SCSI subsystem\n",
1349 goto out_mptspi_probe;
1352 spin_lock_irqsave(&ioc->FreeQlock, flags);
1354 /* Attach the SCSI Host to the IOC structure
1362 /* set 16 byte cdb's */
1363 sh->max_cmd_len = 16;
1365 /* Yikes! This is important!
1366 * Otherwise, by default, linux
1367 * only scans target IDs 0-7!
1368 * pfactsN->MaxDevices unreliable
1369 * (not supported in early
1370 * versions of the FW).
1371 * max_id = 1 + actual max id,
1372 * max_lun = 1 + actual last lun,
1375 sh->max_id = ioc->devices_per_bus;
1377 sh->max_lun = MPT_LAST_LUN + 1;
1379 * If RAID Firmware Detected, setup virtual channel
1381 if (ioc->ir_firmware)
1382 sh->max_channel = 1;
1384 sh->max_channel = 0;
1385 sh->this_id = ioc->pfacts[0].PortSCSIID;
1389 sh->unique_id = ioc->id;
1391 /* Verify that we won't exceed the maximum
1392 * number of chain buffers
1393 * We can optimize: ZZ = req_sz/sizeof(SGE)
1395 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1396 * + (req_sz - 64)/sizeof(SGE)
1397 * A slightly different algorithm is required for
1400 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1401 if (sizeof(dma_addr_t) == sizeof(u64)) {
1402 numSGE = (scale - 1) *
1403 (ioc->facts.MaxChainDepth-1) + scale +
1404 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1407 numSGE = 1 + (scale - 1) *
1408 (ioc->facts.MaxChainDepth-1) + scale +
1409 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1413 if (numSGE < sh->sg_tablesize) {
1414 /* Reset this value */
1415 dprintk((MYIOC_s_INFO_FMT
1416 "Resetting sg_tablesize to %d from %d\n",
1417 ioc->name, numSGE, sh->sg_tablesize));
1418 sh->sg_tablesize = numSGE;
1421 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1423 hd = (MPT_SCSI_HOST *) sh->hostdata;
1426 /* SCSI needs scsi_cmnd lookup table!
1427 * (with size equal to req_depth*PtrSz!)
1429 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1430 if (!hd->ScsiLookup) {
1432 goto out_mptspi_probe;
1435 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1436 ioc->name, hd->ScsiLookup));
1438 /* Clear the TM flags
1441 hd->tmState = TM_STATE_NONE;
1442 hd->resetPending = 0;
1443 hd->abortSCpnt = NULL;
1445 /* Clear the pointer used to store
1446 * single-threaded commands, i.e., those
1447 * issued during a bus scan, dv and
1448 * configuration pages.
1452 /* Initialize this SCSI Hosts' timers
1453 * To use, set the timer expires field
1456 init_timer(&hd->timer);
1457 hd->timer.data = (unsigned long) hd;
1458 hd->timer.function = mptscsih_timer_expired;
1460 ioc->spi_data.Saf_Te = mpt_saf_te;
1462 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1463 ddvprintk((MYIOC_s_INFO_FMT
1467 ioc->spi_data.noQas = 0;
1469 init_waitqueue_head(&hd->scandv_waitq);
1470 hd->scandv_wait_done = 0;
1471 hd->last_queue_full = 0;
1472 hd->spi_pending = 0;
1474 /* Some versions of the firmware don't support page 0; without
1475 * that we can't get the parameters */
1476 if (hd->ioc->spi_data.sdp0length != 0)
1477 sh->transportt = mptspi_transport_template;
1479 error = scsi_add_host (sh, &ioc->pcidev->dev);
1481 dprintk((KERN_ERR MYNAM
1482 "scsi_add_host failed\n"));
1483 goto out_mptspi_probe;
1487 * issue internal bus reset
1489 if (ioc->spi_data.bus_reset)
1490 mptscsih_TMHandler(hd,
1491 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1499 mptscsih_remove(pdev);
1503 static struct pci_driver mptspi_driver = {
1505 .id_table = mptspi_pci_table,
1506 .probe = mptspi_probe,
1507 .remove = __devexit_p(mptscsih_remove),
1508 .shutdown = mptscsih_shutdown,
1510 .suspend = mptscsih_suspend,
1511 .resume = mptspi_resume,
1515 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1517 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1519 * Returns 0 for success, non-zero for failure.
1524 show_mptmod_ver(my_NAME, my_VERSION);
1526 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1527 if (!mptspi_transport_template)
1530 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1531 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1532 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1534 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1535 devtverboseprintk((KERN_INFO MYNAM
1536 ": Registered for IOC event notifications\n"));
1539 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1540 dprintk((KERN_INFO MYNAM
1541 ": Registered for IOC reset notifications\n"));
1544 return pci_register_driver(&mptspi_driver);
1547 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1548 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1550 * mptspi_exit - Unregisters MPT adapter(s)
1555 pci_unregister_driver(&mptspi_driver);
1557 mpt_reset_deregister(mptspiDoneCtx);
1558 dprintk((KERN_INFO MYNAM
1559 ": Deregistered for IOC reset notifications\n"));
1561 mpt_event_deregister(mptspiDoneCtx);
1562 dprintk((KERN_INFO MYNAM
1563 ": Deregistered for IOC event notifications\n"));
1565 mpt_deregister(mptspiInternalCtx);
1566 mpt_deregister(mptspiTaskCtx);
1567 mpt_deregister(mptspiDoneCtx);
1568 spi_release_transport(mptspi_transport_template);
1571 module_init(mptspi_init);
1572 module_exit(mptspi_exit);