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:mpt_linux_developer@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_compat.h" /* linux-2.6 tweaks */
48 #include <linux/module.h>
49 #include <linux/kernel.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/sched.h>
58 #include <linux/workqueue.h>
59 #include <linux/raid_class.h>
61 #include <scsi/scsi.h>
62 #include <scsi/scsi_cmnd.h>
63 #include <scsi/scsi_device.h>
64 #include <scsi/scsi_host.h>
65 #include <scsi/scsi_tcq.h>
66 #include <scsi/scsi_transport.h>
67 #include <scsi/scsi_transport_spi.h>
68 #include <scsi/scsi_dbg.h>
73 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
74 #define my_NAME "Fusion MPT SPI Host driver"
75 #define my_VERSION MPT_LINUX_VERSION_COMMON
76 #define MYNAM "mptspi"
78 MODULE_AUTHOR(MODULEAUTHOR);
79 MODULE_DESCRIPTION(my_NAME);
80 MODULE_LICENSE("GPL");
81 MODULE_VERSION(my_VERSION);
83 /* Command line args */
84 static int mpt_saf_te = MPTSCSIH_SAF_TE;
85 module_param(mpt_saf_te, int, 0);
86 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
88 static void mptspi_write_offset(struct scsi_target *, int);
89 static void mptspi_write_width(struct scsi_target *, int);
90 static int mptspi_write_spi_device_pg1(struct scsi_target *,
91 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
93 static struct scsi_transport_template *mptspi_transport_template = NULL;
95 static int mptspiDoneCtx = -1;
96 static int mptspiTaskCtx = -1;
97 static int mptspiInternalCtx = -1; /* Used only for internal commands */
100 * mptspi_setTargetNegoParms - Update the target negotiation
101 * parameters based on the the Inquiry data, adapter capabilities,
104 * @hd: Pointer to a SCSI Host Structure
105 * @vtarget: per target private data
110 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
111 struct scsi_device *sdev)
113 SpiCfgData *pspi_data = &hd->ioc->spi_data;
114 int id = (int) target->id;
116 u8 width = MPT_NARROW;
117 u8 factor = MPT_ASYNC;
122 target->negoFlags = pspi_data->noQas;
124 if (sdev->scsi_level < SCSI_2) {
127 offset = pspi_data->maxSyncOffset;
128 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
130 if (scsi_device_wide(sdev))
133 if (scsi_device_sync(sdev)) {
134 factor = pspi_data->minSyncFactor;
135 if (!scsi_device_dt(sdev))
138 if (!scsi_device_ius(sdev) &&
139 !scsi_device_qas(sdev))
140 factor = MPT_ULTRA160;
142 factor = MPT_ULTRA320;
143 if (scsi_device_qas(sdev)) {
144 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
147 if (sdev->type == TYPE_TAPE &&
148 scsi_device_ius(sdev))
149 target->negoFlags |= MPT_TAPE_NEGO_IDP;
152 offset = pspi_data->maxSyncOffset;
154 /* If RAID, never disable QAS
155 * else if non RAID, do not disable
156 * QAS if bit 1 is set
157 * bit 1 QAS support, non-raid only
160 if (target->raidVolume == 1)
168 if (!sdev->tagged_supported)
169 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
171 /* Update tflags based on NVRAM settings. (SCSI only)
173 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
174 nvram = pspi_data->nvram[id];
175 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
178 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
181 /* Ensure factor is set to the
182 * maximum of: adapter, nvram, inquiry
185 if (nfactor < pspi_data->minSyncFactor )
186 nfactor = pspi_data->minSyncFactor;
188 factor = max(factor, nfactor);
189 if (factor == MPT_ASYNC)
200 /* Make sure data is consistent
202 if ((!width) && (factor < MPT_ULTRA2))
205 /* Save the data to the target structure.
207 target->minSyncFactor = factor;
208 target->maxOffset = offset;
209 target->maxWidth = width;
211 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
213 /* Disable unused features.
216 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
219 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
221 if ( factor > MPT_ULTRA320 )
224 if (noQas && (pspi_data->noQas == 0)) {
225 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
226 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
228 /* Disable QAS in a mixed configuration case
231 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
236 * mptspi_writeIOCPage4 - write IOC Page 4
237 * @hd: Pointer to a SCSI Host Structure
239 * @id: write IOC Page4 for this ID & Bus
241 * Return: -EAGAIN if unable to obtain a Message Frame
244 * Remark: We do not wait for a return, write pages sequentially.
247 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
249 MPT_ADAPTER *ioc = hd->ioc;
251 IOCPage4_t *IOCPage4Ptr;
259 /* Get a MF for this command.
261 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
262 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
267 /* Set the request and the data pointers.
268 * Place data at end of MF.
270 pReq = (Config_t *)mf;
272 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
273 frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
275 /* Complete the request frame (same for all requests).
277 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
279 pReq->ChainOffset = 0;
280 pReq->Function = MPI_FUNCTION_CONFIG;
281 pReq->ExtPageLength = 0;
282 pReq->ExtPageType = 0;
284 for (ii=0; ii < 8; ii++) {
285 pReq->Reserved2[ii] = 0;
288 IOCPage4Ptr = ioc->spi_data.pIocPg4;
289 dataDma = ioc->spi_data.IocPg4_dma;
290 ii = IOCPage4Ptr->ActiveSEP++;
291 IOCPage4Ptr->SEP[ii].SEPTargetID = id;
292 IOCPage4Ptr->SEP[ii].SEPBus = channel;
293 pReq->Header = IOCPage4Ptr->Header;
294 pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
296 /* Add a SGE to the config request.
298 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
299 (IOCPage4Ptr->Header.PageLength + ii) * 4;
301 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
303 ddvprintk((MYIOC_s_INFO_FMT
304 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
305 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
307 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
313 * mptspi_initTarget - Target, LUN alloc/free functionality.
314 * @hd: Pointer to MPT_SCSI_HOST structure
315 * @vtarget: per target private data
318 * NOTE: It's only SAFE to call this routine if data points to
319 * sane & valid STANDARD INQUIRY data!
321 * Allocate and initialize memory for this target.
326 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
327 struct scsi_device *sdev)
330 /* Is LUN supported? If so, upper 2 bits will be 0
331 * in first byte of inquiry data.
333 if (sdev->inq_periph_qual != 0)
339 vtarget->type = sdev->type;
341 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
342 /* Treat all Processors as SAF-TE if
343 * command line option is set */
344 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
345 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
346 }else if ((sdev->type == TYPE_PROCESSOR) &&
347 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
348 if (sdev->inquiry_len > 49 ) {
349 if (sdev->inquiry[44] == 'S' &&
350 sdev->inquiry[45] == 'A' &&
351 sdev->inquiry[46] == 'F' &&
352 sdev->inquiry[47] == '-' &&
353 sdev->inquiry[48] == 'T' &&
354 sdev->inquiry[49] == 'E' ) {
355 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
356 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
360 mptspi_setTargetNegoParms(hd, vtarget, sdev);
364 * mptspi_is_raid - Determines whether target is belonging to volume
365 * @hd: Pointer to a SCSI HOST structure
366 * @id: target device id
374 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
378 if (!hd->ioc->raid_data.pIocPg2)
381 if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
383 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
384 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
394 static int mptspi_target_alloc(struct scsi_target *starget)
396 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
397 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
403 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
407 vtarget->ioc_id = hd->ioc->id;
408 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
409 vtarget->id = (u8)starget->id;
410 vtarget->channel = (u8)starget->channel;
411 vtarget->starget = starget;
412 starget->hostdata = vtarget;
414 if (starget->channel == 1) {
415 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
417 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
418 /* The real channel for this device is zero */
419 vtarget->channel = 0;
420 /* The actual physdisknum (for RAID passthrough) */
421 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
425 if (starget->channel == 0 &&
426 mptspi_is_raid(hd, starget->id)) {
427 vtarget->raidVolume = 1;
429 "RAID Volume @ channel=%d id=%d\n", starget->channel,
433 if (hd->ioc->spi_data.nvram &&
434 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
435 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
436 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
437 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
439 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
440 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
442 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
444 spi_offset(starget) = 0;
445 mptspi_write_width(starget, 0);
451 mptspi_target_destroy(struct scsi_target *starget)
453 if (starget->hostdata)
454 kfree(starget->hostdata);
455 starget->hostdata = NULL;
459 * mptspi_print_write_nego - negotiation parameters debug info that is being sent
460 * @hd: Pointer to a SCSI HOST structure
461 * @starget: SCSI target
462 * @ii: negotiation parameters
466 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
468 ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x"
469 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
470 hd->ioc->name, starget->id, ii,
471 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
472 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
473 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
474 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
475 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
476 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
477 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
478 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
479 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
480 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
484 * mptspi_print_read_nego - negotiation parameters debug info that is being read
485 * @hd: Pointer to a SCSI HOST structure
486 * @starget: SCSI target
487 * @ii: negotiation parameters
491 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
493 ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x"
494 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
495 hd->ioc->name, starget->id, ii,
496 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
497 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
498 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
499 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
500 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
501 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
502 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
503 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
504 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
505 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
508 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
509 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
511 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
512 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
513 struct _MPT_ADAPTER *ioc = hd->ioc;
514 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
517 struct _x_config_parms cfg;
518 struct _CONFIG_PAGE_HEADER hdr;
521 /* No SPI parameters for RAID devices */
522 if (starget->channel == 0 &&
523 mptspi_is_raid(hd, starget->id))
526 size = ioc->spi_data.sdp0length * 4;
528 if (ioc->spi_data.sdp0length & 1)
533 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
535 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
539 memset(&hdr, 0, sizeof(hdr));
541 hdr.PageVersion = ioc->spi_data.sdp0version;
542 hdr.PageLength = ioc->spi_data.sdp0length;
544 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
546 memset(&cfg, 0, sizeof(cfg));
548 cfg.cfghdr.hdr = &hdr;
549 cfg.physAddr = pg0_dma;
550 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
552 cfg.pageAddr = starget->id;
554 if (mpt_config(ioc, &cfg)) {
555 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
559 memcpy(pass_pg0, pg0, size);
561 mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
564 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
568 static u32 mptspi_getRP(struct scsi_target *starget)
572 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
573 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
574 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
575 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
576 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
577 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
578 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
579 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
581 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
582 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
583 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
588 static void mptspi_read_parameters(struct scsi_target *starget)
591 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
593 mptspi_read_spi_device_pg0(starget, &pg0);
595 nego = le32_to_cpu(pg0.NegotiatedParameters);
597 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
598 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
599 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
600 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
601 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
602 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
603 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
604 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
605 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
606 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
607 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
611 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
613 MpiRaidActionRequest_t *pReq;
616 /* Get and Populate a free Frame
618 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
619 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
623 pReq = (MpiRaidActionRequest_t *)mf;
625 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
627 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
629 pReq->ChainOffset = 0;
630 pReq->Function = MPI_FUNCTION_RAID_ACTION;
632 pReq->VolumeBus = channel;
633 pReq->PhysDiskNum = 0;
636 pReq->ActionDataWord = 0; /* Reserved for this action */
638 mpt_add_sge((char *)&pReq->ActionDataSGE,
639 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
641 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n",
642 hd->ioc->name, pReq->Action, channel, id));
645 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
646 hd->scandv_wait_done = 0;
648 /* Save cmd pointer, for resource free if timeout or
653 add_timer(&hd->timer);
654 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
655 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
657 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
663 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
664 struct scsi_device *sdev)
666 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
668 /* no DV on RAID devices */
669 if (sdev->channel == 0 &&
670 mptspi_is_raid(hd, sdev->id))
673 /* If this is a piece of a RAID, then quiesce first */
674 if (sdev->channel == 1 &&
675 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
676 starget_printk(KERN_ERR, scsi_target(sdev),
677 "Integrated RAID quiesce failed\n");
683 if (sdev->channel == 1 &&
684 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
685 starget_printk(KERN_ERR, scsi_target(sdev),
686 "Integrated RAID resume failed\n");
688 mptspi_read_parameters(sdev->sdev_target);
689 spi_display_xfer_agreement(sdev->sdev_target);
690 mptspi_read_parameters(sdev->sdev_target);
693 static int mptspi_slave_alloc(struct scsi_device *sdev)
695 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
698 struct scsi_target *starget;
700 if (sdev->channel == 1 &&
701 mptscsih_is_phys_disk(hd->ioc, 0, sdev->id) == 0)
704 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
706 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
707 hd->ioc->name, sizeof(VirtDevice));
711 vdev->lun = sdev->lun;
712 sdev->hostdata = vdev;
714 starget = scsi_target(sdev);
715 vtarget = starget->hostdata;
716 vdev->vtarget = vtarget;
719 if (sdev->channel == 1)
720 sdev->no_uld_attach = 1;
725 static int mptspi_slave_configure(struct scsi_device *sdev)
727 struct _MPT_SCSI_HOST *hd =
728 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
729 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
730 int ret = mptscsih_slave_configure(sdev);
735 mptspi_initTarget(hd, vtarget, sdev);
737 ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
738 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
739 sdev->id, spi_min_period(scsi_target(sdev)),
740 spi_max_offset(scsi_target(sdev)),
741 spi_max_width(scsi_target(sdev))));
743 if ((sdev->channel == 1 ||
744 !(mptspi_is_raid(hd, sdev->id))) &&
745 !spi_initial_dv(sdev->sdev_target))
746 mptspi_dv_device(hd, sdev);
752 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
754 struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
755 VirtDevice *vdev = SCpnt->device->hostdata;
757 if (!vdev || !vdev->vtarget) {
758 SCpnt->result = DID_NO_CONNECT << 16;
763 if (SCpnt->device->channel == 1 &&
764 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
765 SCpnt->result = DID_NO_CONNECT << 16;
771 if (spi_dv_pending(scsi_target(SCpnt->device)))
772 scsi_print_command(SCpnt);
775 return mptscsih_qcmd(SCpnt,done);
778 static void mptspi_slave_destroy(struct scsi_device *sdev)
780 struct scsi_target *starget = scsi_target(sdev);
781 VirtTarget *vtarget = starget->hostdata;
782 VirtDevice *vdevice = sdev->hostdata;
784 /* Will this be the last lun on a non-raid device? */
785 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
786 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
789 pg1.RequestedParameters = 0;
791 pg1.Configuration = 0;
793 mptspi_write_spi_device_pg1(starget, &pg1);
796 mptscsih_slave_destroy(sdev);
799 static struct scsi_host_template mptspi_driver_template = {
800 .module = THIS_MODULE,
801 .proc_name = "mptspi",
802 .proc_info = mptscsih_proc_info,
803 .name = "MPT SPI Host",
804 .info = mptscsih_info,
805 .queuecommand = mptspi_qcmd,
806 .target_alloc = mptspi_target_alloc,
807 .slave_alloc = mptspi_slave_alloc,
808 .slave_configure = mptspi_slave_configure,
809 .target_destroy = mptspi_target_destroy,
810 .slave_destroy = mptspi_slave_destroy,
811 .change_queue_depth = mptscsih_change_queue_depth,
812 .eh_abort_handler = mptscsih_abort,
813 .eh_device_reset_handler = mptscsih_dev_reset,
814 .eh_bus_reset_handler = mptscsih_bus_reset,
815 .eh_host_reset_handler = mptscsih_host_reset,
816 .bios_param = mptscsih_bios_param,
817 .can_queue = MPT_SCSI_CAN_QUEUE,
819 .sg_tablesize = MPT_SCSI_SG_DEPTH,
822 .use_clustering = ENABLE_CLUSTERING,
825 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
826 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
828 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
829 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
830 struct _MPT_ADAPTER *ioc = hd->ioc;
831 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
834 struct _x_config_parms cfg;
835 struct _CONFIG_PAGE_HEADER hdr;
838 /* don't allow updating nego parameters on RAID devices */
839 if (starget->channel == 0 &&
840 mptspi_is_raid(hd, starget->id))
843 size = ioc->spi_data.sdp1length * 4;
845 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
847 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
851 memset(&hdr, 0, sizeof(hdr));
853 hdr.PageVersion = ioc->spi_data.sdp1version;
854 hdr.PageLength = ioc->spi_data.sdp1length;
856 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
858 memset(&cfg, 0, sizeof(cfg));
860 cfg.cfghdr.hdr = &hdr;
861 cfg.physAddr = pg1_dma;
862 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
864 cfg.pageAddr = starget->id;
866 memcpy(pg1, pass_pg1, size);
868 pg1->Header.PageVersion = hdr.PageVersion;
869 pg1->Header.PageLength = hdr.PageLength;
870 pg1->Header.PageNumber = hdr.PageNumber;
871 pg1->Header.PageType = hdr.PageType;
873 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
875 if (mpt_config(ioc, &cfg)) {
876 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
882 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
886 static void mptspi_write_offset(struct scsi_target *starget, int offset)
888 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
897 if (spi_offset(starget) == -1)
898 mptspi_read_parameters(starget);
900 spi_offset(starget) = offset;
902 nego = mptspi_getRP(starget);
904 pg1.RequestedParameters = cpu_to_le32(nego);
906 pg1.Configuration = 0;
908 mptspi_write_spi_device_pg1(starget, &pg1);
911 static void mptspi_write_period(struct scsi_target *starget, int period)
913 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
922 if (spi_period(starget) == -1)
923 mptspi_read_parameters(starget);
928 } else if (period == 9) {
932 spi_period(starget) = period;
934 nego = mptspi_getRP(starget);
936 pg1.RequestedParameters = cpu_to_le32(nego);
938 pg1.Configuration = 0;
940 mptspi_write_spi_device_pg1(starget, &pg1);
943 static void mptspi_write_dt(struct scsi_target *starget, int dt)
945 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
948 if (spi_period(starget) == -1)
949 mptspi_read_parameters(starget);
951 if (!dt && spi_period(starget) < 10)
952 spi_period(starget) = 10;
954 spi_dt(starget) = dt;
956 nego = mptspi_getRP(starget);
959 pg1.RequestedParameters = cpu_to_le32(nego);
961 pg1.Configuration = 0;
963 mptspi_write_spi_device_pg1(starget, &pg1);
966 static void mptspi_write_iu(struct scsi_target *starget, int iu)
968 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
971 if (spi_period(starget) == -1)
972 mptspi_read_parameters(starget);
974 if (!iu && spi_period(starget) < 9)
975 spi_period(starget) = 9;
977 spi_iu(starget) = iu;
979 nego = mptspi_getRP(starget);
981 pg1.RequestedParameters = cpu_to_le32(nego);
983 pg1.Configuration = 0;
985 mptspi_write_spi_device_pg1(starget, &pg1);
988 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
989 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
991 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
994 spi_##parm(starget) = parm; \
996 nego = mptspi_getRP(starget); \
998 pg1.RequestedParameters = cpu_to_le32(nego); \
1000 pg1.Configuration = 0; \
1002 mptspi_write_spi_device_pg1(starget, &pg1); \
1005 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1006 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1007 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1009 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1011 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1013 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1014 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1015 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1016 VirtTarget *vtarget = starget->hostdata;
1019 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1020 hd->ioc->spi_data.noQas)
1021 spi_qas(starget) = 0;
1023 spi_qas(starget) = qas;
1025 nego = mptspi_getRP(starget);
1027 pg1.RequestedParameters = cpu_to_le32(nego);
1029 pg1.Configuration = 0;
1031 mptspi_write_spi_device_pg1(starget, &pg1);
1034 static void mptspi_write_width(struct scsi_target *starget, int width)
1036 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1040 spi_dt(starget) = 0;
1041 if (spi_period(starget) < 10)
1042 spi_period(starget) = 10;
1045 spi_width(starget) = width;
1047 nego = mptspi_getRP(starget);
1049 pg1.RequestedParameters = cpu_to_le32(nego);
1051 pg1.Configuration = 0;
1053 mptspi_write_spi_device_pg1(starget, &pg1);
1056 struct work_queue_wrapper {
1057 struct work_struct work;
1058 struct _MPT_SCSI_HOST *hd;
1062 static void mpt_work_wrapper(struct work_struct *work)
1064 struct work_queue_wrapper *wqw =
1065 container_of(work, struct work_queue_wrapper, work);
1066 struct _MPT_SCSI_HOST *hd = wqw->hd;
1067 struct Scsi_Host *shost = hd->ioc->sh;
1068 struct scsi_device *sdev;
1069 int disk = wqw->disk;
1070 struct _CONFIG_PAGE_IOC_3 *pg3;
1074 mpt_findImVolumes(hd->ioc);
1075 pg3 = hd->ioc->raid_data.pIocPg3;
1079 shost_for_each_device(sdev,shost) {
1080 struct scsi_target *starget = scsi_target(sdev);
1081 VirtTarget *vtarget = starget->hostdata;
1083 /* only want to search RAID components */
1084 if (sdev->channel != 1)
1087 /* The id is the raid PhysDiskNum, even if
1088 * starget->id is the actual target address */
1089 if(vtarget->id != disk)
1092 starget_printk(KERN_INFO, vtarget->starget,
1093 "Integrated RAID requests DV of new device\n");
1094 mptspi_dv_device(hd, sdev);
1096 shost_printk(KERN_INFO, shost,
1097 "Integrated RAID detects new device %d\n", disk);
1098 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1102 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1104 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1107 shost_printk(KERN_ERR, hd->ioc->sh,
1108 "Failed to act on RAID event for physical disk %d\n",
1112 INIT_WORK(&wqw->work, mpt_work_wrapper);
1116 schedule_work(&wqw->work);
1120 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1122 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1123 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1125 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1127 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1129 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1130 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1131 mpt_dv_raid(hd, disk);
1134 return mptscsih_event_process(ioc, pEvReply);
1138 mptspi_deny_binding(struct scsi_target *starget)
1140 struct _MPT_SCSI_HOST *hd =
1141 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1142 return ((mptspi_is_raid(hd, starget->id)) &&
1143 starget->channel == 0) ? 1 : 0;
1146 static struct spi_function_template mptspi_transport_functions = {
1147 .get_offset = mptspi_read_parameters,
1148 .set_offset = mptspi_write_offset,
1150 .get_period = mptspi_read_parameters,
1151 .set_period = mptspi_write_period,
1153 .get_width = mptspi_read_parameters,
1154 .set_width = mptspi_write_width,
1156 .get_iu = mptspi_read_parameters,
1157 .set_iu = mptspi_write_iu,
1159 .get_dt = mptspi_read_parameters,
1160 .set_dt = mptspi_write_dt,
1162 .get_qas = mptspi_read_parameters,
1163 .set_qas = mptspi_write_qas,
1165 .get_wr_flow = mptspi_read_parameters,
1166 .set_wr_flow = mptspi_write_wr_flow,
1168 .get_rd_strm = mptspi_read_parameters,
1169 .set_rd_strm = mptspi_write_rd_strm,
1171 .get_rti = mptspi_read_parameters,
1172 .set_rti = mptspi_write_rti,
1174 .get_pcomp_en = mptspi_read_parameters,
1175 .set_pcomp_en = mptspi_write_pcomp_en,
1177 .get_hold_mcs = mptspi_read_parameters,
1178 .set_hold_mcs = mptspi_write_hold_mcs,
1180 .deny_binding = mptspi_deny_binding,
1183 /****************************************************************************
1184 * Supported hardware
1187 static struct pci_device_id mptspi_pci_table[] = {
1188 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1189 PCI_ANY_ID, PCI_ANY_ID },
1190 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1191 PCI_ANY_ID, PCI_ANY_ID },
1192 {0} /* Terminating entry */
1194 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1198 * renegotiate for a given target
1201 mptspi_dv_renegotiate_work(struct work_struct *work)
1203 struct work_queue_wrapper *wqw =
1204 container_of(work, struct work_queue_wrapper, work);
1205 struct _MPT_SCSI_HOST *hd = wqw->hd;
1206 struct scsi_device *sdev;
1210 shost_for_each_device(sdev, hd->ioc->sh)
1211 mptspi_dv_device(hd, sdev);
1215 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1217 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1222 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1225 schedule_work(&wqw->work);
1229 * spi module reset handler
1232 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1234 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1237 rc = mptscsih_ioc_reset(ioc, reset_phase);
1239 if (reset_phase == MPT_IOC_POST_RESET)
1240 mptspi_dv_renegotiate(hd);
1247 * spi module resume handler
1250 mptspi_resume(struct pci_dev *pdev)
1252 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1253 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1256 rc = mptscsih_resume(pdev);
1257 mptspi_dv_renegotiate(hd);
1263 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1264 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1266 * mptspi_probe - Installs scsi devices per bus.
1267 * @pdev: Pointer to pci_dev structure
1269 * Returns 0 for success, non-zero for failure.
1273 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1275 struct Scsi_Host *sh;
1278 unsigned long flags;
1286 if ((r = mpt_attach(pdev,id)) != 0)
1289 ioc = pci_get_drvdata(pdev);
1290 ioc->DoneCtx = mptspiDoneCtx;
1291 ioc->TaskCtx = mptspiTaskCtx;
1292 ioc->InternalCtx = mptspiInternalCtx;
1294 /* Added sanity check on readiness of the MPT adapter.
1296 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1297 printk(MYIOC_s_WARN_FMT
1298 "Skipping because it's not operational!\n",
1301 goto out_mptspi_probe;
1305 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1308 goto out_mptspi_probe;
1311 /* Sanity check - ensure at least 1 port is INITIATOR capable
1314 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1315 if (ioc->pfacts[ii].ProtocolFlags &
1316 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1321 printk(MYIOC_s_WARN_FMT
1322 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1327 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1330 printk(MYIOC_s_WARN_FMT
1331 "Unable to register controller with SCSI subsystem\n",
1334 goto out_mptspi_probe;
1337 spin_lock_irqsave(&ioc->FreeQlock, flags);
1339 /* Attach the SCSI Host to the IOC structure
1347 /* set 16 byte cdb's */
1348 sh->max_cmd_len = 16;
1350 /* Yikes! This is important!
1351 * Otherwise, by default, linux
1352 * only scans target IDs 0-7!
1353 * pfactsN->MaxDevices unreliable
1354 * (not supported in early
1355 * versions of the FW).
1356 * max_id = 1 + actual max id,
1357 * max_lun = 1 + actual last lun,
1360 sh->max_id = ioc->devices_per_bus;
1362 sh->max_lun = MPT_LAST_LUN + 1;
1364 * If RAID Firmware Detected, setup virtual channel
1366 if (ioc->ir_firmware)
1367 sh->max_channel = 1;
1369 sh->max_channel = 0;
1370 sh->this_id = ioc->pfacts[0].PortSCSIID;
1374 sh->unique_id = ioc->id;
1376 /* Verify that we won't exceed the maximum
1377 * number of chain buffers
1378 * We can optimize: ZZ = req_sz/sizeof(SGE)
1380 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1381 * + (req_sz - 64)/sizeof(SGE)
1382 * A slightly different algorithm is required for
1385 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1386 if (sizeof(dma_addr_t) == sizeof(u64)) {
1387 numSGE = (scale - 1) *
1388 (ioc->facts.MaxChainDepth-1) + scale +
1389 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1392 numSGE = 1 + (scale - 1) *
1393 (ioc->facts.MaxChainDepth-1) + scale +
1394 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1398 if (numSGE < sh->sg_tablesize) {
1399 /* Reset this value */
1400 dprintk((MYIOC_s_INFO_FMT
1401 "Resetting sg_tablesize to %d from %d\n",
1402 ioc->name, numSGE, sh->sg_tablesize));
1403 sh->sg_tablesize = numSGE;
1406 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1408 hd = (MPT_SCSI_HOST *) sh->hostdata;
1411 /* SCSI needs scsi_cmnd lookup table!
1412 * (with size equal to req_depth*PtrSz!)
1414 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1415 if (!hd->ScsiLookup) {
1417 goto out_mptspi_probe;
1420 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1421 ioc->name, hd->ScsiLookup));
1423 /* Clear the TM flags
1426 hd->tmState = TM_STATE_NONE;
1427 hd->resetPending = 0;
1428 hd->abortSCpnt = NULL;
1430 /* Clear the pointer used to store
1431 * single-threaded commands, i.e., those
1432 * issued during a bus scan, dv and
1433 * configuration pages.
1437 /* Initialize this SCSI Hosts' timers
1438 * To use, set the timer expires field
1441 init_timer(&hd->timer);
1442 hd->timer.data = (unsigned long) hd;
1443 hd->timer.function = mptscsih_timer_expired;
1445 ioc->spi_data.Saf_Te = mpt_saf_te;
1447 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1448 ddvprintk((MYIOC_s_INFO_FMT
1452 ioc->spi_data.noQas = 0;
1454 init_waitqueue_head(&hd->scandv_waitq);
1455 hd->scandv_wait_done = 0;
1456 hd->last_queue_full = 0;
1458 /* Some versions of the firmware don't support page 0; without
1459 * that we can't get the parameters */
1460 if (hd->ioc->spi_data.sdp0length != 0)
1461 sh->transportt = mptspi_transport_template;
1463 error = scsi_add_host (sh, &ioc->pcidev->dev);
1465 dprintk((KERN_ERR MYNAM
1466 "scsi_add_host failed\n"));
1467 goto out_mptspi_probe;
1471 * issue internal bus reset
1473 if (ioc->spi_data.bus_reset)
1474 mptscsih_TMHandler(hd,
1475 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1483 mptscsih_remove(pdev);
1487 static struct pci_driver mptspi_driver = {
1489 .id_table = mptspi_pci_table,
1490 .probe = mptspi_probe,
1491 .remove = __devexit_p(mptscsih_remove),
1492 .shutdown = mptscsih_shutdown,
1494 .suspend = mptscsih_suspend,
1495 .resume = mptspi_resume,
1499 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1501 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1503 * Returns 0 for success, non-zero for failure.
1508 show_mptmod_ver(my_NAME, my_VERSION);
1510 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1511 if (!mptspi_transport_template)
1514 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1515 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1516 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1518 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1519 devtverboseprintk((KERN_INFO MYNAM
1520 ": Registered for IOC event notifications\n"));
1523 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1524 dprintk((KERN_INFO MYNAM
1525 ": Registered for IOC reset notifications\n"));
1528 return pci_register_driver(&mptspi_driver);
1531 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1532 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1534 * mptspi_exit - Unregisters MPT adapter(s)
1539 pci_unregister_driver(&mptspi_driver);
1541 mpt_reset_deregister(mptspiDoneCtx);
1542 dprintk((KERN_INFO MYNAM
1543 ": Deregistered for IOC reset notifications\n"));
1545 mpt_event_deregister(mptspiDoneCtx);
1546 dprintk((KERN_INFO MYNAM
1547 ": Deregistered for IOC event notifications\n"));
1549 mpt_deregister(mptspiInternalCtx);
1550 mpt_deregister(mptspiTaskCtx);
1551 mpt_deregister(mptspiDoneCtx);
1552 spi_release_transport(mptspi_transport_template);
1555 module_init(mptspi_init);
1556 module_exit(mptspi_exit);