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.
6 * Copyright (c) 1999-2007 LSI 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 u8 mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
94 static u8 mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
95 static u8 mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
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 MPT_ADAPTER *ioc = hd->ioc;
111 SpiCfgData *pspi_data = &ioc->spi_data;
112 int id = (int) target->id;
114 u8 width = MPT_NARROW;
115 u8 factor = MPT_ASYNC;
120 target->negoFlags = pspi_data->noQas;
122 if (sdev->scsi_level < SCSI_2) {
125 offset = pspi_data->maxSyncOffset;
126 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
128 if (scsi_device_wide(sdev))
131 if (scsi_device_sync(sdev)) {
132 factor = pspi_data->minSyncFactor;
133 if (!scsi_device_dt(sdev))
136 if (!scsi_device_ius(sdev) &&
137 !scsi_device_qas(sdev))
138 factor = MPT_ULTRA160;
140 factor = MPT_ULTRA320;
141 if (scsi_device_qas(sdev)) {
143 printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
144 "byte56=%02x on id=%d!\n", ioc->name,
145 scsi_device_qas(sdev), id));
148 if (sdev->type == TYPE_TAPE &&
149 scsi_device_ius(sdev))
150 target->negoFlags |= MPT_TAPE_NEGO_IDP;
153 offset = pspi_data->maxSyncOffset;
155 /* If RAID, never disable QAS
156 * else if non RAID, do not disable
157 * QAS if bit 1 is set
158 * bit 1 QAS support, non-raid only
161 if (target->raidVolume == 1)
169 if (!sdev->tagged_supported)
170 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
172 /* Update tflags based on NVRAM settings. (SCSI only)
174 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
175 nvram = pspi_data->nvram[id];
176 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
179 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
182 /* Ensure factor is set to the
183 * maximum of: adapter, nvram, inquiry
186 if (nfactor < pspi_data->minSyncFactor )
187 nfactor = pspi_data->minSyncFactor;
189 factor = max(factor, nfactor);
190 if (factor == MPT_ASYNC)
201 /* Make sure data is consistent
203 if ((!width) && (factor < MPT_ULTRA2))
206 /* Save the data to the target structure.
208 target->minSyncFactor = factor;
209 target->maxOffset = offset;
210 target->maxWidth = width;
212 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
214 /* Disable unused features.
217 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
220 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
222 if ( factor > MPT_ULTRA320 )
225 if (noQas && (pspi_data->noQas == 0)) {
226 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
227 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
229 /* Disable QAS in a mixed configuration case
232 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
233 "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
238 * mptspi_writeIOCPage4 - write IOC Page 4
239 * @hd: Pointer to a SCSI Host Structure
240 * @channel: channel number
241 * @id: write IOC Page4 for this ID & Bus
243 * Return: -EAGAIN if unable to obtain a Message Frame
246 * Remark: We do not wait for a return, write pages sequentially.
249 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
251 MPT_ADAPTER *ioc = hd->ioc;
253 IOCPage4_t *IOCPage4Ptr;
261 /* Get a MF for this command.
263 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
264 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
265 "writeIOCPage4 : no msg frames!\n",ioc->name));
269 /* Set the request and the data pointers.
270 * Place data at end of MF.
272 pReq = (Config_t *)mf;
274 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
275 frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
277 /* Complete the request frame (same for all requests).
279 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
281 pReq->ChainOffset = 0;
282 pReq->Function = MPI_FUNCTION_CONFIG;
283 pReq->ExtPageLength = 0;
284 pReq->ExtPageType = 0;
286 for (ii=0; ii < 8; ii++) {
287 pReq->Reserved2[ii] = 0;
290 IOCPage4Ptr = ioc->spi_data.pIocPg4;
291 dataDma = ioc->spi_data.IocPg4_dma;
292 ii = IOCPage4Ptr->ActiveSEP++;
293 IOCPage4Ptr->SEP[ii].SEPTargetID = id;
294 IOCPage4Ptr->SEP[ii].SEPBus = channel;
295 pReq->Header = IOCPage4Ptr->Header;
296 pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
298 /* Add a SGE to the config request.
300 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
301 (IOCPage4Ptr->Header.PageLength + ii) * 4;
303 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
305 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
306 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
307 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
309 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
315 * mptspi_initTarget - Target, LUN alloc/free functionality.
316 * @hd: Pointer to MPT_SCSI_HOST structure
317 * @vtarget: per target private data
320 * NOTE: It's only SAFE to call this routine if data points to
321 * sane & valid STANDARD INQUIRY data!
323 * Allocate and initialize memory for this target.
328 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
329 struct scsi_device *sdev)
332 /* Is LUN supported? If so, upper 2 bits will be 0
333 * in first byte of inquiry data.
335 if (sdev->inq_periph_qual != 0)
341 vtarget->type = sdev->type;
343 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
344 /* Treat all Processors as SAF-TE if
345 * command line option is set */
346 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
347 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
348 }else if ((sdev->type == TYPE_PROCESSOR) &&
349 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
350 if (sdev->inquiry_len > 49 ) {
351 if (sdev->inquiry[44] == 'S' &&
352 sdev->inquiry[45] == 'A' &&
353 sdev->inquiry[46] == 'F' &&
354 sdev->inquiry[47] == '-' &&
355 sdev->inquiry[48] == 'T' &&
356 sdev->inquiry[49] == 'E' ) {
357 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
358 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
362 mptspi_setTargetNegoParms(hd, vtarget, sdev);
366 * mptspi_is_raid - Determines whether target is belonging to volume
367 * @hd: Pointer to a SCSI HOST structure
368 * @id: target device id
376 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
379 MPT_ADAPTER *ioc = hd->ioc;
381 if (!ioc->raid_data.pIocPg2)
384 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
386 for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
387 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
397 static int mptspi_target_alloc(struct scsi_target *starget)
399 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
400 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
408 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
412 vtarget->ioc_id = ioc->id;
413 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
414 vtarget->id = (u8)starget->id;
415 vtarget->channel = (u8)starget->channel;
416 vtarget->starget = starget;
417 starget->hostdata = vtarget;
419 if (starget->channel == 1) {
420 if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
422 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
423 /* The real channel for this device is zero */
424 vtarget->channel = 0;
425 /* The actual physdisknum (for RAID passthrough) */
426 vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
430 if (starget->channel == 0 &&
431 mptspi_is_raid(hd, starget->id)) {
432 vtarget->raidVolume = 1;
433 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
434 "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
438 if (ioc->spi_data.nvram &&
439 ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
440 u32 nvram = ioc->spi_data.nvram[starget->id];
441 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
442 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
444 spi_min_period(starget) = ioc->spi_data.minSyncFactor;
445 spi_max_width(starget) = ioc->spi_data.maxBusWidth;
447 spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
449 spi_offset(starget) = 0;
450 mptspi_write_width(starget, 0);
456 mptspi_target_destroy(struct scsi_target *starget)
458 if (starget->hostdata)
459 kfree(starget->hostdata);
460 starget->hostdata = NULL;
464 * mptspi_print_write_nego - negotiation parameters debug info that is being sent
465 * @hd: Pointer to a SCSI HOST structure
466 * @starget: SCSI target
467 * @ii: negotiation parameters
471 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
473 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
474 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
475 hd->ioc->name, starget->id, ii,
476 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
477 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
478 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
479 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
480 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
481 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
482 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
483 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
484 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
485 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
489 * mptspi_print_read_nego - negotiation parameters debug info that is being read
490 * @hd: Pointer to a SCSI HOST structure
491 * @starget: SCSI target
492 * @ii: negotiation parameters
496 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
498 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
499 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
500 hd->ioc->name, starget->id, ii,
501 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
502 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
503 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
504 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
505 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
506 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
507 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
508 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
509 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
510 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
513 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
514 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
516 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
517 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
518 struct _MPT_ADAPTER *ioc = hd->ioc;
519 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
522 struct _x_config_parms cfg;
523 struct _CONFIG_PAGE_HEADER hdr;
526 /* No SPI parameters for RAID devices */
527 if (starget->channel == 0 &&
528 mptspi_is_raid(hd, starget->id))
531 size = ioc->spi_data.sdp0length * 4;
533 if (ioc->spi_data.sdp0length & 1)
538 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
540 starget_printk(MYIOC_s_ERR_FMT, starget,
541 "dma_alloc_coherent for parameters failed\n", ioc->name);
545 memset(&hdr, 0, sizeof(hdr));
547 hdr.PageVersion = ioc->spi_data.sdp0version;
548 hdr.PageLength = ioc->spi_data.sdp0length;
550 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
552 memset(&cfg, 0, sizeof(cfg));
554 cfg.cfghdr.hdr = &hdr;
555 cfg.physAddr = pg0_dma;
556 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
558 cfg.pageAddr = starget->id;
560 if (mpt_config(ioc, &cfg)) {
561 starget_printk(MYIOC_s_ERR_FMT, starget, "mpt_config failed\n", ioc->name);
565 memcpy(pass_pg0, pg0, size);
567 mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
570 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
574 static u32 mptspi_getRP(struct scsi_target *starget)
578 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
579 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
580 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
581 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
582 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
583 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
584 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
585 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
587 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
588 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
589 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
594 static void mptspi_read_parameters(struct scsi_target *starget)
597 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
599 mptspi_read_spi_device_pg0(starget, &pg0);
601 nego = le32_to_cpu(pg0.NegotiatedParameters);
603 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
604 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
605 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
606 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
607 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
608 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
609 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
610 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
611 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
612 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
613 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
617 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
619 MpiRaidActionRequest_t *pReq;
621 MPT_ADAPTER *ioc = hd->ioc;
623 /* Get and Populate a free Frame
625 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
626 ddvprintk(ioc, printk(MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
630 pReq = (MpiRaidActionRequest_t *)mf;
632 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
634 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
636 pReq->ChainOffset = 0;
637 pReq->Function = MPI_FUNCTION_RAID_ACTION;
639 pReq->VolumeBus = channel;
640 pReq->PhysDiskNum = 0;
643 pReq->ActionDataWord = 0; /* Reserved for this action */
645 mpt_add_sge((char *)&pReq->ActionDataSGE,
646 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
648 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
649 ioc->name, pReq->Action, channel, id));
652 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
653 hd->scandv_wait_done = 0;
655 /* Save cmd pointer, for resource free if timeout or
660 add_timer(&hd->timer);
661 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
662 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
664 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
670 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
671 struct scsi_device *sdev)
673 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
674 MPT_ADAPTER *ioc = hd->ioc;
676 /* no DV on RAID devices */
677 if (sdev->channel == 0 &&
678 mptspi_is_raid(hd, sdev->id))
681 /* If this is a piece of a RAID, then quiesce first */
682 if (sdev->channel == 1 &&
683 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
684 starget_printk(MYIOC_s_ERR_FMT, scsi_target(sdev),
685 "Integrated RAID quiesce failed\n", ioc->name);
689 hd->spi_pending |= (1 << sdev->id);
691 hd->spi_pending &= ~(1 << sdev->id);
693 if (sdev->channel == 1 &&
694 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
695 starget_printk(MYIOC_s_ERR_FMT, scsi_target(sdev),
696 "Integrated RAID resume failed\n", ioc->name);
698 mptspi_read_parameters(sdev->sdev_target);
699 spi_display_xfer_agreement(sdev->sdev_target);
700 mptspi_read_parameters(sdev->sdev_target);
703 static int mptspi_slave_alloc(struct scsi_device *sdev)
705 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
708 struct scsi_target *starget;
709 MPT_ADAPTER *ioc = hd->ioc;
711 if (sdev->channel == 1 &&
712 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
715 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
717 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
718 ioc->name, sizeof(VirtDevice));
722 vdevice->lun = sdev->lun;
723 sdev->hostdata = vdevice;
725 starget = scsi_target(sdev);
726 vtarget = starget->hostdata;
727 vdevice->vtarget = vtarget;
730 if (sdev->channel == 1)
731 sdev->no_uld_attach = 1;
736 static int mptspi_slave_configure(struct scsi_device *sdev)
738 struct _MPT_SCSI_HOST *hd =
739 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
740 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
743 mptspi_initTarget(hd, vtarget, sdev);
745 ret = mptscsih_slave_configure(sdev);
750 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
751 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
752 sdev->id, spi_min_period(scsi_target(sdev)),
753 spi_max_offset(scsi_target(sdev)),
754 spi_max_width(scsi_target(sdev))));
756 if ((sdev->channel == 1 ||
757 !(mptspi_is_raid(hd, sdev->id))) &&
758 !spi_initial_dv(sdev->sdev_target))
759 mptspi_dv_device(hd, sdev);
765 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
767 struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
768 VirtDevice *vdevice = SCpnt->device->hostdata;
769 MPT_ADAPTER *ioc = hd->ioc;
771 if (!vdevice || !vdevice->vtarget) {
772 SCpnt->result = DID_NO_CONNECT << 16;
777 if (SCpnt->device->channel == 1 &&
778 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
779 SCpnt->result = DID_NO_CONNECT << 16;
784 if (spi_dv_pending(scsi_target(SCpnt->device)))
785 ddvprintk(ioc, scsi_print_command(SCpnt));
787 return mptscsih_qcmd(SCpnt,done);
790 static void mptspi_slave_destroy(struct scsi_device *sdev)
792 struct scsi_target *starget = scsi_target(sdev);
793 VirtTarget *vtarget = starget->hostdata;
794 VirtDevice *vdevice = sdev->hostdata;
796 /* Will this be the last lun on a non-raid device? */
797 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
798 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
801 pg1.RequestedParameters = 0;
803 pg1.Configuration = 0;
805 mptspi_write_spi_device_pg1(starget, &pg1);
808 mptscsih_slave_destroy(sdev);
811 static struct scsi_host_template mptspi_driver_template = {
812 .module = THIS_MODULE,
813 .proc_name = "mptspi",
814 .proc_info = mptscsih_proc_info,
815 .name = "MPT SPI Host",
816 .info = mptscsih_info,
817 .queuecommand = mptspi_qcmd,
818 .target_alloc = mptspi_target_alloc,
819 .slave_alloc = mptspi_slave_alloc,
820 .slave_configure = mptspi_slave_configure,
821 .target_destroy = mptspi_target_destroy,
822 .slave_destroy = mptspi_slave_destroy,
823 .change_queue_depth = mptscsih_change_queue_depth,
824 .eh_abort_handler = mptscsih_abort,
825 .eh_device_reset_handler = mptscsih_dev_reset,
826 .eh_bus_reset_handler = mptscsih_bus_reset,
827 .eh_host_reset_handler = mptscsih_host_reset,
828 .bios_param = mptscsih_bios_param,
829 .can_queue = MPT_SCSI_CAN_QUEUE,
831 .sg_tablesize = MPT_SCSI_SG_DEPTH,
834 .use_clustering = ENABLE_CLUSTERING,
835 .shost_attrs = mptscsih_host_attrs,
838 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
839 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
841 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
842 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
843 struct _MPT_ADAPTER *ioc = hd->ioc;
844 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
847 struct _x_config_parms cfg;
848 struct _CONFIG_PAGE_HEADER hdr;
851 /* don't allow updating nego parameters on RAID devices */
852 if (starget->channel == 0 &&
853 mptspi_is_raid(hd, starget->id))
856 size = ioc->spi_data.sdp1length * 4;
858 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
860 starget_printk(MYIOC_s_ERR_FMT, starget,
861 "dma_alloc_coherent for parameters failed\n", ioc->name);
865 memset(&hdr, 0, sizeof(hdr));
867 hdr.PageVersion = ioc->spi_data.sdp1version;
868 hdr.PageLength = ioc->spi_data.sdp1length;
870 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
872 memset(&cfg, 0, sizeof(cfg));
874 cfg.cfghdr.hdr = &hdr;
875 cfg.physAddr = pg1_dma;
876 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
878 cfg.pageAddr = starget->id;
880 memcpy(pg1, pass_pg1, size);
882 pg1->Header.PageVersion = hdr.PageVersion;
883 pg1->Header.PageLength = hdr.PageLength;
884 pg1->Header.PageNumber = hdr.PageNumber;
885 pg1->Header.PageType = hdr.PageType;
887 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
889 if (mpt_config(ioc, &cfg)) {
890 starget_printk(MYIOC_s_ERR_FMT, starget,
891 "mpt_config failed\n", ioc->name);
897 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
901 static void mptspi_write_offset(struct scsi_target *starget, int offset)
903 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
912 if (spi_offset(starget) == -1)
913 mptspi_read_parameters(starget);
915 spi_offset(starget) = offset;
917 nego = mptspi_getRP(starget);
919 pg1.RequestedParameters = cpu_to_le32(nego);
921 pg1.Configuration = 0;
923 mptspi_write_spi_device_pg1(starget, &pg1);
926 static void mptspi_write_period(struct scsi_target *starget, int period)
928 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
937 if (spi_period(starget) == -1)
938 mptspi_read_parameters(starget);
943 } else if (period == 9) {
947 spi_period(starget) = period;
949 nego = mptspi_getRP(starget);
951 pg1.RequestedParameters = cpu_to_le32(nego);
953 pg1.Configuration = 0;
955 mptspi_write_spi_device_pg1(starget, &pg1);
958 static void mptspi_write_dt(struct scsi_target *starget, int dt)
960 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
963 if (spi_period(starget) == -1)
964 mptspi_read_parameters(starget);
966 if (!dt && spi_period(starget) < 10)
967 spi_period(starget) = 10;
969 spi_dt(starget) = dt;
971 nego = mptspi_getRP(starget);
974 pg1.RequestedParameters = cpu_to_le32(nego);
976 pg1.Configuration = 0;
978 mptspi_write_spi_device_pg1(starget, &pg1);
981 static void mptspi_write_iu(struct scsi_target *starget, int iu)
983 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
986 if (spi_period(starget) == -1)
987 mptspi_read_parameters(starget);
989 if (!iu && spi_period(starget) < 9)
990 spi_period(starget) = 9;
992 spi_iu(starget) = iu;
994 nego = mptspi_getRP(starget);
996 pg1.RequestedParameters = cpu_to_le32(nego);
998 pg1.Configuration = 0;
1000 mptspi_write_spi_device_pg1(starget, &pg1);
1003 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1004 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1006 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1009 spi_##parm(starget) = parm; \
1011 nego = mptspi_getRP(starget); \
1013 pg1.RequestedParameters = cpu_to_le32(nego); \
1015 pg1.Configuration = 0; \
1017 mptspi_write_spi_device_pg1(starget, &pg1); \
1020 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1021 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1022 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1023 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1024 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1026 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1028 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1029 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1030 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1031 VirtTarget *vtarget = starget->hostdata;
1034 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1035 hd->ioc->spi_data.noQas)
1036 spi_qas(starget) = 0;
1038 spi_qas(starget) = qas;
1040 nego = mptspi_getRP(starget);
1042 pg1.RequestedParameters = cpu_to_le32(nego);
1044 pg1.Configuration = 0;
1046 mptspi_write_spi_device_pg1(starget, &pg1);
1049 static void mptspi_write_width(struct scsi_target *starget, int width)
1051 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1055 spi_dt(starget) = 0;
1056 if (spi_period(starget) < 10)
1057 spi_period(starget) = 10;
1060 spi_width(starget) = width;
1062 nego = mptspi_getRP(starget);
1064 pg1.RequestedParameters = cpu_to_le32(nego);
1066 pg1.Configuration = 0;
1068 mptspi_write_spi_device_pg1(starget, &pg1);
1071 struct work_queue_wrapper {
1072 struct work_struct work;
1073 struct _MPT_SCSI_HOST *hd;
1077 static void mpt_work_wrapper(struct work_struct *work)
1079 struct work_queue_wrapper *wqw =
1080 container_of(work, struct work_queue_wrapper, work);
1081 struct _MPT_SCSI_HOST *hd = wqw->hd;
1082 MPT_ADAPTER *ioc = hd->ioc;
1083 struct Scsi_Host *shost = ioc->sh;
1084 struct scsi_device *sdev;
1085 int disk = wqw->disk;
1086 struct _CONFIG_PAGE_IOC_3 *pg3;
1090 mpt_findImVolumes(ioc);
1091 pg3 = ioc->raid_data.pIocPg3;
1095 shost_for_each_device(sdev,shost) {
1096 struct scsi_target *starget = scsi_target(sdev);
1097 VirtTarget *vtarget = starget->hostdata;
1099 /* only want to search RAID components */
1100 if (sdev->channel != 1)
1103 /* The id is the raid PhysDiskNum, even if
1104 * starget->id is the actual target address */
1105 if(vtarget->id != disk)
1108 starget_printk(MYIOC_s_INFO_FMT, vtarget->starget,
1109 "Integrated RAID requests DV of new device\n", ioc->name);
1110 mptspi_dv_device(hd, sdev);
1112 shost_printk(MYIOC_s_INFO_FMT, shost,
1113 "Integrated RAID detects new device %d\n", ioc->name, disk);
1114 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1118 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1120 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1121 MPT_ADAPTER *ioc = hd->ioc;
1124 shost_printk(MYIOC_s_ERR_FMT, ioc->sh,
1125 "Failed to act on RAID event for physical disk %d\n",
1129 INIT_WORK(&wqw->work, mpt_work_wrapper);
1133 schedule_work(&wqw->work);
1137 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1139 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1140 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1142 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1144 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1146 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1147 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1148 mpt_dv_raid(hd, disk);
1151 return mptscsih_event_process(ioc, pEvReply);
1155 mptspi_deny_binding(struct scsi_target *starget)
1157 struct _MPT_SCSI_HOST *hd =
1158 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1159 return ((mptspi_is_raid(hd, starget->id)) &&
1160 starget->channel == 0) ? 1 : 0;
1163 static struct spi_function_template mptspi_transport_functions = {
1164 .get_offset = mptspi_read_parameters,
1165 .set_offset = mptspi_write_offset,
1167 .get_period = mptspi_read_parameters,
1168 .set_period = mptspi_write_period,
1170 .get_width = mptspi_read_parameters,
1171 .set_width = mptspi_write_width,
1173 .get_iu = mptspi_read_parameters,
1174 .set_iu = mptspi_write_iu,
1176 .get_dt = mptspi_read_parameters,
1177 .set_dt = mptspi_write_dt,
1179 .get_qas = mptspi_read_parameters,
1180 .set_qas = mptspi_write_qas,
1182 .get_wr_flow = mptspi_read_parameters,
1183 .set_wr_flow = mptspi_write_wr_flow,
1185 .get_rd_strm = mptspi_read_parameters,
1186 .set_rd_strm = mptspi_write_rd_strm,
1188 .get_rti = mptspi_read_parameters,
1189 .set_rti = mptspi_write_rti,
1191 .get_pcomp_en = mptspi_read_parameters,
1192 .set_pcomp_en = mptspi_write_pcomp_en,
1194 .get_hold_mcs = mptspi_read_parameters,
1195 .set_hold_mcs = mptspi_write_hold_mcs,
1197 .deny_binding = mptspi_deny_binding,
1200 /****************************************************************************
1201 * Supported hardware
1204 static struct pci_device_id mptspi_pci_table[] = {
1205 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1206 PCI_ANY_ID, PCI_ANY_ID },
1207 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1208 PCI_ANY_ID, PCI_ANY_ID },
1209 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1210 PCI_ANY_ID, PCI_ANY_ID },
1211 {0} /* Terminating entry */
1213 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1217 * renegotiate for a given target
1220 mptspi_dv_renegotiate_work(struct work_struct *work)
1222 struct work_queue_wrapper *wqw =
1223 container_of(work, struct work_queue_wrapper, work);
1224 struct _MPT_SCSI_HOST *hd = wqw->hd;
1225 struct scsi_device *sdev;
1226 struct scsi_target *starget;
1227 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1229 MPT_ADAPTER *ioc = hd->ioc;
1233 if (hd->spi_pending) {
1234 shost_for_each_device(sdev, ioc->sh) {
1235 if (hd->spi_pending & (1 << sdev->id))
1237 starget = scsi_target(sdev);
1238 nego = mptspi_getRP(starget);
1239 pg1.RequestedParameters = cpu_to_le32(nego);
1241 pg1.Configuration = 0;
1242 mptspi_write_spi_device_pg1(starget, &pg1);
1245 shost_for_each_device(sdev, ioc->sh)
1246 mptspi_dv_device(hd, sdev);
1251 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1253 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1258 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1261 schedule_work(&wqw->work);
1265 * spi module reset handler
1268 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1270 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1273 rc = mptscsih_ioc_reset(ioc, reset_phase);
1275 if (reset_phase == MPT_IOC_POST_RESET)
1276 mptspi_dv_renegotiate(hd);
1283 * spi module resume handler
1286 mptspi_resume(struct pci_dev *pdev)
1288 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1289 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1292 rc = mptscsih_resume(pdev);
1293 mptspi_dv_renegotiate(hd);
1299 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1300 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1302 * mptspi_probe - Installs scsi devices per bus.
1303 * @pdev: Pointer to pci_dev structure
1305 * Returns 0 for success, non-zero for failure.
1309 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1311 struct Scsi_Host *sh;
1314 unsigned long flags;
1322 if ((r = mpt_attach(pdev,id)) != 0)
1325 ioc = pci_get_drvdata(pdev);
1326 ioc->DoneCtx = mptspiDoneCtx;
1327 ioc->TaskCtx = mptspiTaskCtx;
1328 ioc->InternalCtx = mptspiInternalCtx;
1330 /* Added sanity check on readiness of the MPT adapter.
1332 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1333 printk(MYIOC_s_WARN_FMT
1334 "Skipping because it's not operational!\n",
1337 goto out_mptspi_probe;
1341 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1344 goto out_mptspi_probe;
1347 /* Sanity check - ensure at least 1 port is INITIATOR capable
1350 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1351 if (ioc->pfacts[ii].ProtocolFlags &
1352 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1357 printk(MYIOC_s_WARN_FMT
1358 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1363 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1366 printk(MYIOC_s_WARN_FMT
1367 "Unable to register controller with SCSI subsystem\n",
1370 goto out_mptspi_probe;
1373 spin_lock_irqsave(&ioc->FreeQlock, flags);
1375 /* Attach the SCSI Host to the IOC structure
1383 /* set 16 byte cdb's */
1384 sh->max_cmd_len = 16;
1386 /* Yikes! This is important!
1387 * Otherwise, by default, linux
1388 * only scans target IDs 0-7!
1389 * pfactsN->MaxDevices unreliable
1390 * (not supported in early
1391 * versions of the FW).
1392 * max_id = 1 + actual max id,
1393 * max_lun = 1 + actual last lun,
1396 sh->max_id = ioc->devices_per_bus;
1398 sh->max_lun = MPT_LAST_LUN + 1;
1400 * If RAID Firmware Detected, setup virtual channel
1402 if (ioc->ir_firmware)
1403 sh->max_channel = 1;
1405 sh->max_channel = 0;
1406 sh->this_id = ioc->pfacts[0].PortSCSIID;
1410 sh->unique_id = ioc->id;
1412 /* Verify that we won't exceed the maximum
1413 * number of chain buffers
1414 * We can optimize: ZZ = req_sz/sizeof(SGE)
1416 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1417 * + (req_sz - 64)/sizeof(SGE)
1418 * A slightly different algorithm is required for
1421 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1422 if (sizeof(dma_addr_t) == sizeof(u64)) {
1423 numSGE = (scale - 1) *
1424 (ioc->facts.MaxChainDepth-1) + scale +
1425 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1428 numSGE = 1 + (scale - 1) *
1429 (ioc->facts.MaxChainDepth-1) + scale +
1430 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1434 if (numSGE < sh->sg_tablesize) {
1435 /* Reset this value */
1436 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1437 "Resetting sg_tablesize to %d from %d\n",
1438 ioc->name, numSGE, sh->sg_tablesize));
1439 sh->sg_tablesize = numSGE;
1442 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1444 hd = (MPT_SCSI_HOST *) sh->hostdata;
1447 /* SCSI needs scsi_cmnd lookup table!
1448 * (with size equal to req_depth*PtrSz!)
1450 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1451 if (!hd->ScsiLookup) {
1453 goto out_mptspi_probe;
1456 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1457 ioc->name, hd->ScsiLookup));
1459 /* Clear the TM flags
1462 hd->tmState = TM_STATE_NONE;
1463 hd->resetPending = 0;
1464 hd->abortSCpnt = NULL;
1466 /* Clear the pointer used to store
1467 * single-threaded commands, i.e., those
1468 * issued during a bus scan, dv and
1469 * configuration pages.
1473 /* Initialize this SCSI Hosts' timers
1474 * To use, set the timer expires field
1477 init_timer(&hd->timer);
1478 hd->timer.data = (unsigned long) hd;
1479 hd->timer.function = mptscsih_timer_expired;
1481 ioc->spi_data.Saf_Te = mpt_saf_te;
1483 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1484 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1488 ioc->spi_data.noQas = 0;
1490 init_waitqueue_head(&hd->scandv_waitq);
1491 hd->scandv_wait_done = 0;
1492 hd->last_queue_full = 0;
1493 hd->spi_pending = 0;
1495 /* Some versions of the firmware don't support page 0; without
1496 * that we can't get the parameters */
1497 if (ioc->spi_data.sdp0length != 0)
1498 sh->transportt = mptspi_transport_template;
1500 error = scsi_add_host (sh, &ioc->pcidev->dev);
1502 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1503 "scsi_add_host failed\n", ioc->name));
1504 goto out_mptspi_probe;
1508 * issue internal bus reset
1510 if (ioc->spi_data.bus_reset)
1511 mptscsih_TMHandler(hd,
1512 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1520 mptscsih_remove(pdev);
1524 static struct pci_driver mptspi_driver = {
1526 .id_table = mptspi_pci_table,
1527 .probe = mptspi_probe,
1528 .remove = __devexit_p(mptscsih_remove),
1529 .shutdown = mptscsih_shutdown,
1531 .suspend = mptscsih_suspend,
1532 .resume = mptspi_resume,
1536 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1538 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1540 * Returns 0 for success, non-zero for failure.
1547 show_mptmod_ver(my_NAME, my_VERSION);
1549 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1550 if (!mptspi_transport_template)
1553 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1554 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1555 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1557 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1558 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1560 error = pci_register_driver(&mptspi_driver);
1562 spi_release_transport(mptspi_transport_template);
1567 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1568 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1570 * mptspi_exit - Unregisters MPT adapter(s)
1575 pci_unregister_driver(&mptspi_driver);
1577 mpt_reset_deregister(mptspiDoneCtx);
1578 mpt_event_deregister(mptspiDoneCtx);
1580 mpt_deregister(mptspiInternalCtx);
1581 mpt_deregister(mptspiTaskCtx);
1582 mpt_deregister(mptspiDoneCtx);
1583 spi_release_transport(mptspi_transport_template);
1586 module_init(mptspi_init);
1587 module_exit(mptspi_exit);