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/workqueue.h>
58 #include <linux/raid_class.h>
60 #include <scsi/scsi.h>
61 #include <scsi/scsi_cmnd.h>
62 #include <scsi/scsi_device.h>
63 #include <scsi/scsi_host.h>
64 #include <scsi/scsi_tcq.h>
65 #include <scsi/scsi_transport.h>
66 #include <scsi/scsi_transport_spi.h>
67 #include <scsi/scsi_dbg.h>
72 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
73 #define my_NAME "Fusion MPT SPI Host driver"
74 #define my_VERSION MPT_LINUX_VERSION_COMMON
75 #define MYNAM "mptspi"
77 MODULE_AUTHOR(MODULEAUTHOR);
78 MODULE_DESCRIPTION(my_NAME);
79 MODULE_LICENSE("GPL");
80 MODULE_VERSION(my_VERSION);
82 /* Command line args */
83 static int mpt_saf_te = MPTSCSIH_SAF_TE;
84 module_param(mpt_saf_te, int, 0);
85 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
87 static void mptspi_write_offset(struct scsi_target *, int);
88 static void mptspi_write_width(struct scsi_target *, int);
89 static int mptspi_write_spi_device_pg1(struct scsi_target *,
90 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
92 static struct scsi_transport_template *mptspi_transport_template = NULL;
94 static int mptspiDoneCtx = -1;
95 static int mptspiTaskCtx = -1;
96 static int mptspiInternalCtx = -1; /* Used only for internal commands */
99 * mptspi_setTargetNegoParms - Update the target negotiation parameters
100 * @hd: Pointer to a SCSI Host Structure
101 * @target: per target private data
104 * Update the target negotiation parameters based on the the Inquiry
105 * data, adapter capabilities, and NVRAM settings.
108 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
109 struct scsi_device *sdev)
111 SpiCfgData *pspi_data = &hd->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)) {
142 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
145 if (sdev->type == TYPE_TAPE &&
146 scsi_device_ius(sdev))
147 target->negoFlags |= MPT_TAPE_NEGO_IDP;
150 offset = pspi_data->maxSyncOffset;
152 /* If RAID, never disable QAS
153 * else if non RAID, do not disable
154 * QAS if bit 1 is set
155 * bit 1 QAS support, non-raid only
158 if (target->raidVolume == 1)
166 if (!sdev->tagged_supported)
167 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
169 /* Update tflags based on NVRAM settings. (SCSI only)
171 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
172 nvram = pspi_data->nvram[id];
173 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
176 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
179 /* Ensure factor is set to the
180 * maximum of: adapter, nvram, inquiry
183 if (nfactor < pspi_data->minSyncFactor )
184 nfactor = pspi_data->minSyncFactor;
186 factor = max(factor, nfactor);
187 if (factor == MPT_ASYNC)
198 /* Make sure data is consistent
200 if ((!width) && (factor < MPT_ULTRA2))
203 /* Save the data to the target structure.
205 target->minSyncFactor = factor;
206 target->maxOffset = offset;
207 target->maxWidth = width;
209 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
211 /* Disable unused features.
214 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
217 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
219 if ( factor > MPT_ULTRA320 )
222 if (noQas && (pspi_data->noQas == 0)) {
223 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
224 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
226 /* Disable QAS in a mixed configuration case
229 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
234 * mptspi_writeIOCPage4 - write IOC Page 4
235 * @hd: Pointer to a SCSI Host Structure
236 * @channel: channel number
237 * @id: write IOC Page4 for this ID & Bus
239 * Return: -EAGAIN if unable to obtain a Message Frame
242 * Remark: We do not wait for a return, write pages sequentially.
245 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
247 MPT_ADAPTER *ioc = hd->ioc;
249 IOCPage4_t *IOCPage4Ptr;
257 /* Get a MF for this command.
259 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
260 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
265 /* Set the request and the data pointers.
266 * Place data at end of MF.
268 pReq = (Config_t *)mf;
270 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
271 frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
273 /* Complete the request frame (same for all requests).
275 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
277 pReq->ChainOffset = 0;
278 pReq->Function = MPI_FUNCTION_CONFIG;
279 pReq->ExtPageLength = 0;
280 pReq->ExtPageType = 0;
282 for (ii=0; ii < 8; ii++) {
283 pReq->Reserved2[ii] = 0;
286 IOCPage4Ptr = ioc->spi_data.pIocPg4;
287 dataDma = ioc->spi_data.IocPg4_dma;
288 ii = IOCPage4Ptr->ActiveSEP++;
289 IOCPage4Ptr->SEP[ii].SEPTargetID = id;
290 IOCPage4Ptr->SEP[ii].SEPBus = channel;
291 pReq->Header = IOCPage4Ptr->Header;
292 pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
294 /* Add a SGE to the config request.
296 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
297 (IOCPage4Ptr->Header.PageLength + ii) * 4;
299 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
301 ddvprintk((MYIOC_s_INFO_FMT
302 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
303 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
305 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
311 * mptspi_initTarget - Target, LUN alloc/free functionality.
312 * @hd: Pointer to MPT_SCSI_HOST structure
313 * @vtarget: per target private data
316 * NOTE: It's only SAFE to call this routine if data points to
317 * sane & valid STANDARD INQUIRY data!
319 * Allocate and initialize memory for this target.
324 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
325 struct scsi_device *sdev)
328 /* Is LUN supported? If so, upper 2 bits will be 0
329 * in first byte of inquiry data.
331 if (sdev->inq_periph_qual != 0)
337 vtarget->type = sdev->type;
339 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
340 /* Treat all Processors as SAF-TE if
341 * command line option is set */
342 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
343 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
344 }else if ((sdev->type == TYPE_PROCESSOR) &&
345 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
346 if (sdev->inquiry_len > 49 ) {
347 if (sdev->inquiry[44] == 'S' &&
348 sdev->inquiry[45] == 'A' &&
349 sdev->inquiry[46] == 'F' &&
350 sdev->inquiry[47] == '-' &&
351 sdev->inquiry[48] == 'T' &&
352 sdev->inquiry[49] == 'E' ) {
353 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
354 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
358 mptspi_setTargetNegoParms(hd, vtarget, sdev);
362 * mptspi_is_raid - Determines whether target is belonging to volume
363 * @hd: Pointer to a SCSI HOST structure
364 * @id: target device id
372 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
376 if (!hd->ioc->raid_data.pIocPg2)
379 if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
381 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
382 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
392 static int mptspi_target_alloc(struct scsi_target *starget)
394 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
395 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
401 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
405 vtarget->ioc_id = hd->ioc->id;
406 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
407 vtarget->id = (u8)starget->id;
408 vtarget->channel = (u8)starget->channel;
409 vtarget->starget = starget;
410 starget->hostdata = vtarget;
412 if (starget->channel == 1) {
413 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
415 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
416 /* The real channel for this device is zero */
417 vtarget->channel = 0;
418 /* The actual physdisknum (for RAID passthrough) */
419 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
423 if (starget->channel == 0 &&
424 mptspi_is_raid(hd, starget->id)) {
425 vtarget->raidVolume = 1;
427 "RAID Volume @ channel=%d id=%d\n", starget->channel,
431 if (hd->ioc->spi_data.nvram &&
432 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
433 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
434 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
435 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
437 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
438 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
440 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
442 spi_offset(starget) = 0;
443 mptspi_write_width(starget, 0);
449 mptspi_target_destroy(struct scsi_target *starget)
451 if (starget->hostdata)
452 kfree(starget->hostdata);
453 starget->hostdata = NULL;
457 * mptspi_print_write_nego - negotiation parameters debug info that is being sent
458 * @hd: Pointer to a SCSI HOST structure
459 * @starget: SCSI target
460 * @ii: negotiation parameters
464 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
466 ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x"
467 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
468 hd->ioc->name, starget->id, ii,
469 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
470 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
471 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
472 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
473 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
474 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
475 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
476 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
477 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
478 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
482 * mptspi_print_read_nego - negotiation parameters debug info that is being read
483 * @hd: Pointer to a SCSI HOST structure
484 * @starget: SCSI target
485 * @ii: negotiation parameters
489 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
491 ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x"
492 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
493 hd->ioc->name, starget->id, ii,
494 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
495 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
496 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
497 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
498 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
499 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
500 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
501 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
502 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
503 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
506 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
507 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
509 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
510 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
511 struct _MPT_ADAPTER *ioc = hd->ioc;
512 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
515 struct _x_config_parms cfg;
516 struct _CONFIG_PAGE_HEADER hdr;
519 /* No SPI parameters for RAID devices */
520 if (starget->channel == 0 &&
521 mptspi_is_raid(hd, starget->id))
524 size = ioc->spi_data.sdp0length * 4;
526 if (ioc->spi_data.sdp0length & 1)
531 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
533 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
537 memset(&hdr, 0, sizeof(hdr));
539 hdr.PageVersion = ioc->spi_data.sdp0version;
540 hdr.PageLength = ioc->spi_data.sdp0length;
542 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
544 memset(&cfg, 0, sizeof(cfg));
546 cfg.cfghdr.hdr = &hdr;
547 cfg.physAddr = pg0_dma;
548 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
550 cfg.pageAddr = starget->id;
552 if (mpt_config(ioc, &cfg)) {
553 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
557 memcpy(pass_pg0, pg0, size);
559 mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
562 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
566 static u32 mptspi_getRP(struct scsi_target *starget)
570 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
571 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
572 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
573 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
574 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
575 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
576 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
577 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
579 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
580 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
581 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
586 static void mptspi_read_parameters(struct scsi_target *starget)
589 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
591 mptspi_read_spi_device_pg0(starget, &pg0);
593 nego = le32_to_cpu(pg0.NegotiatedParameters);
595 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
596 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
597 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
598 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
599 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
600 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
601 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
602 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
603 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
604 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
605 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
609 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
611 MpiRaidActionRequest_t *pReq;
614 /* Get and Populate a free Frame
616 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
617 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
621 pReq = (MpiRaidActionRequest_t *)mf;
623 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
625 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
627 pReq->ChainOffset = 0;
628 pReq->Function = MPI_FUNCTION_RAID_ACTION;
630 pReq->VolumeBus = channel;
631 pReq->PhysDiskNum = 0;
634 pReq->ActionDataWord = 0; /* Reserved for this action */
636 mpt_add_sge((char *)&pReq->ActionDataSGE,
637 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
639 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n",
640 hd->ioc->name, pReq->Action, channel, id));
643 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
644 hd->scandv_wait_done = 0;
646 /* Save cmd pointer, for resource free if timeout or
651 add_timer(&hd->timer);
652 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
653 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
655 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
661 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
662 struct scsi_device *sdev)
664 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
666 /* no DV on RAID devices */
667 if (sdev->channel == 0 &&
668 mptspi_is_raid(hd, sdev->id))
671 /* If this is a piece of a RAID, then quiesce first */
672 if (sdev->channel == 1 &&
673 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
674 starget_printk(KERN_ERR, scsi_target(sdev),
675 "Integrated RAID quiesce failed\n");
679 hd->spi_pending |= (1 << sdev->id);
681 hd->spi_pending &= ~(1 << sdev->id);
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;
732 mptspi_initTarget(hd, vtarget, sdev);
734 ret = mptscsih_slave_configure(sdev);
739 ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
740 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
741 sdev->id, spi_min_period(scsi_target(sdev)),
742 spi_max_offset(scsi_target(sdev)),
743 spi_max_width(scsi_target(sdev))));
745 if ((sdev->channel == 1 ||
746 !(mptspi_is_raid(hd, sdev->id))) &&
747 !spi_initial_dv(sdev->sdev_target))
748 mptspi_dv_device(hd, sdev);
754 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
756 struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
757 VirtDevice *vdev = SCpnt->device->hostdata;
759 if (!vdev || !vdev->vtarget) {
760 SCpnt->result = DID_NO_CONNECT << 16;
765 if (SCpnt->device->channel == 1 &&
766 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
767 SCpnt->result = DID_NO_CONNECT << 16;
773 if (spi_dv_pending(scsi_target(SCpnt->device)))
774 scsi_print_command(SCpnt);
777 return mptscsih_qcmd(SCpnt,done);
780 static void mptspi_slave_destroy(struct scsi_device *sdev)
782 struct scsi_target *starget = scsi_target(sdev);
783 VirtTarget *vtarget = starget->hostdata;
784 VirtDevice *vdevice = sdev->hostdata;
786 /* Will this be the last lun on a non-raid device? */
787 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
788 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
791 pg1.RequestedParameters = 0;
793 pg1.Configuration = 0;
795 mptspi_write_spi_device_pg1(starget, &pg1);
798 mptscsih_slave_destroy(sdev);
801 static struct scsi_host_template mptspi_driver_template = {
802 .module = THIS_MODULE,
803 .proc_name = "mptspi",
804 .proc_info = mptscsih_proc_info,
805 .name = "MPT SPI Host",
806 .info = mptscsih_info,
807 .queuecommand = mptspi_qcmd,
808 .target_alloc = mptspi_target_alloc,
809 .slave_alloc = mptspi_slave_alloc,
810 .slave_configure = mptspi_slave_configure,
811 .target_destroy = mptspi_target_destroy,
812 .slave_destroy = mptspi_slave_destroy,
813 .change_queue_depth = mptscsih_change_queue_depth,
814 .eh_abort_handler = mptscsih_abort,
815 .eh_device_reset_handler = mptscsih_dev_reset,
816 .eh_bus_reset_handler = mptscsih_bus_reset,
817 .eh_host_reset_handler = mptscsih_host_reset,
818 .bios_param = mptscsih_bios_param,
819 .can_queue = MPT_SCSI_CAN_QUEUE,
821 .sg_tablesize = MPT_SCSI_SG_DEPTH,
824 .use_clustering = ENABLE_CLUSTERING,
827 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
828 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
830 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
831 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
832 struct _MPT_ADAPTER *ioc = hd->ioc;
833 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
836 struct _x_config_parms cfg;
837 struct _CONFIG_PAGE_HEADER hdr;
840 /* don't allow updating nego parameters on RAID devices */
841 if (starget->channel == 0 &&
842 mptspi_is_raid(hd, starget->id))
845 size = ioc->spi_data.sdp1length * 4;
847 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
849 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
853 memset(&hdr, 0, sizeof(hdr));
855 hdr.PageVersion = ioc->spi_data.sdp1version;
856 hdr.PageLength = ioc->spi_data.sdp1length;
858 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
860 memset(&cfg, 0, sizeof(cfg));
862 cfg.cfghdr.hdr = &hdr;
863 cfg.physAddr = pg1_dma;
864 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
866 cfg.pageAddr = starget->id;
868 memcpy(pg1, pass_pg1, size);
870 pg1->Header.PageVersion = hdr.PageVersion;
871 pg1->Header.PageLength = hdr.PageLength;
872 pg1->Header.PageNumber = hdr.PageNumber;
873 pg1->Header.PageType = hdr.PageType;
875 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
877 if (mpt_config(ioc, &cfg)) {
878 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
884 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
888 static void mptspi_write_offset(struct scsi_target *starget, int offset)
890 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
899 if (spi_offset(starget) == -1)
900 mptspi_read_parameters(starget);
902 spi_offset(starget) = offset;
904 nego = mptspi_getRP(starget);
906 pg1.RequestedParameters = cpu_to_le32(nego);
908 pg1.Configuration = 0;
910 mptspi_write_spi_device_pg1(starget, &pg1);
913 static void mptspi_write_period(struct scsi_target *starget, int period)
915 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
924 if (spi_period(starget) == -1)
925 mptspi_read_parameters(starget);
930 } else if (period == 9) {
934 spi_period(starget) = period;
936 nego = mptspi_getRP(starget);
938 pg1.RequestedParameters = cpu_to_le32(nego);
940 pg1.Configuration = 0;
942 mptspi_write_spi_device_pg1(starget, &pg1);
945 static void mptspi_write_dt(struct scsi_target *starget, int dt)
947 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
950 if (spi_period(starget) == -1)
951 mptspi_read_parameters(starget);
953 if (!dt && spi_period(starget) < 10)
954 spi_period(starget) = 10;
956 spi_dt(starget) = dt;
958 nego = mptspi_getRP(starget);
961 pg1.RequestedParameters = cpu_to_le32(nego);
963 pg1.Configuration = 0;
965 mptspi_write_spi_device_pg1(starget, &pg1);
968 static void mptspi_write_iu(struct scsi_target *starget, int iu)
970 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
973 if (spi_period(starget) == -1)
974 mptspi_read_parameters(starget);
976 if (!iu && spi_period(starget) < 9)
977 spi_period(starget) = 9;
979 spi_iu(starget) = iu;
981 nego = mptspi_getRP(starget);
983 pg1.RequestedParameters = cpu_to_le32(nego);
985 pg1.Configuration = 0;
987 mptspi_write_spi_device_pg1(starget, &pg1);
990 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
991 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
993 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
996 spi_##parm(starget) = parm; \
998 nego = mptspi_getRP(starget); \
1000 pg1.RequestedParameters = cpu_to_le32(nego); \
1002 pg1.Configuration = 0; \
1004 mptspi_write_spi_device_pg1(starget, &pg1); \
1007 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1008 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1009 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1010 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1011 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1013 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1015 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1016 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1017 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1018 VirtTarget *vtarget = starget->hostdata;
1021 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1022 hd->ioc->spi_data.noQas)
1023 spi_qas(starget) = 0;
1025 spi_qas(starget) = qas;
1027 nego = mptspi_getRP(starget);
1029 pg1.RequestedParameters = cpu_to_le32(nego);
1031 pg1.Configuration = 0;
1033 mptspi_write_spi_device_pg1(starget, &pg1);
1036 static void mptspi_write_width(struct scsi_target *starget, int width)
1038 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1042 spi_dt(starget) = 0;
1043 if (spi_period(starget) < 10)
1044 spi_period(starget) = 10;
1047 spi_width(starget) = width;
1049 nego = mptspi_getRP(starget);
1051 pg1.RequestedParameters = cpu_to_le32(nego);
1053 pg1.Configuration = 0;
1055 mptspi_write_spi_device_pg1(starget, &pg1);
1058 struct work_queue_wrapper {
1059 struct work_struct work;
1060 struct _MPT_SCSI_HOST *hd;
1064 static void mpt_work_wrapper(struct work_struct *work)
1066 struct work_queue_wrapper *wqw =
1067 container_of(work, struct work_queue_wrapper, work);
1068 struct _MPT_SCSI_HOST *hd = wqw->hd;
1069 struct Scsi_Host *shost = hd->ioc->sh;
1070 struct scsi_device *sdev;
1071 int disk = wqw->disk;
1072 struct _CONFIG_PAGE_IOC_3 *pg3;
1076 mpt_findImVolumes(hd->ioc);
1077 pg3 = hd->ioc->raid_data.pIocPg3;
1081 shost_for_each_device(sdev,shost) {
1082 struct scsi_target *starget = scsi_target(sdev);
1083 VirtTarget *vtarget = starget->hostdata;
1085 /* only want to search RAID components */
1086 if (sdev->channel != 1)
1089 /* The id is the raid PhysDiskNum, even if
1090 * starget->id is the actual target address */
1091 if(vtarget->id != disk)
1094 starget_printk(KERN_INFO, vtarget->starget,
1095 "Integrated RAID requests DV of new device\n");
1096 mptspi_dv_device(hd, sdev);
1098 shost_printk(KERN_INFO, shost,
1099 "Integrated RAID detects new device %d\n", disk);
1100 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1104 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1106 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1109 shost_printk(KERN_ERR, hd->ioc->sh,
1110 "Failed to act on RAID event for physical disk %d\n",
1114 INIT_WORK(&wqw->work, mpt_work_wrapper);
1118 schedule_work(&wqw->work);
1122 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1124 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1125 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1127 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1129 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1131 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1132 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1133 mpt_dv_raid(hd, disk);
1136 return mptscsih_event_process(ioc, pEvReply);
1140 mptspi_deny_binding(struct scsi_target *starget)
1142 struct _MPT_SCSI_HOST *hd =
1143 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1144 return ((mptspi_is_raid(hd, starget->id)) &&
1145 starget->channel == 0) ? 1 : 0;
1148 static struct spi_function_template mptspi_transport_functions = {
1149 .get_offset = mptspi_read_parameters,
1150 .set_offset = mptspi_write_offset,
1152 .get_period = mptspi_read_parameters,
1153 .set_period = mptspi_write_period,
1155 .get_width = mptspi_read_parameters,
1156 .set_width = mptspi_write_width,
1158 .get_iu = mptspi_read_parameters,
1159 .set_iu = mptspi_write_iu,
1161 .get_dt = mptspi_read_parameters,
1162 .set_dt = mptspi_write_dt,
1164 .get_qas = mptspi_read_parameters,
1165 .set_qas = mptspi_write_qas,
1167 .get_wr_flow = mptspi_read_parameters,
1168 .set_wr_flow = mptspi_write_wr_flow,
1170 .get_rd_strm = mptspi_read_parameters,
1171 .set_rd_strm = mptspi_write_rd_strm,
1173 .get_rti = mptspi_read_parameters,
1174 .set_rti = mptspi_write_rti,
1176 .get_pcomp_en = mptspi_read_parameters,
1177 .set_pcomp_en = mptspi_write_pcomp_en,
1179 .get_hold_mcs = mptspi_read_parameters,
1180 .set_hold_mcs = mptspi_write_hold_mcs,
1182 .deny_binding = mptspi_deny_binding,
1185 /****************************************************************************
1186 * Supported hardware
1189 static struct pci_device_id mptspi_pci_table[] = {
1190 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1191 PCI_ANY_ID, PCI_ANY_ID },
1192 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1193 PCI_ANY_ID, PCI_ANY_ID },
1194 {0} /* Terminating entry */
1196 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1200 * renegotiate for a given target
1203 mptspi_dv_renegotiate_work(struct work_struct *work)
1205 struct work_queue_wrapper *wqw =
1206 container_of(work, struct work_queue_wrapper, work);
1207 struct _MPT_SCSI_HOST *hd = wqw->hd;
1208 struct scsi_device *sdev;
1209 struct scsi_target *starget;
1210 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1215 if (hd->spi_pending) {
1216 shost_for_each_device(sdev, hd->ioc->sh) {
1217 if (hd->spi_pending & (1 << sdev->id))
1219 starget = scsi_target(sdev);
1220 nego = mptspi_getRP(starget);
1221 pg1.RequestedParameters = cpu_to_le32(nego);
1223 pg1.Configuration = 0;
1224 mptspi_write_spi_device_pg1(starget, &pg1);
1227 shost_for_each_device(sdev, hd->ioc->sh)
1228 mptspi_dv_device(hd, sdev);
1233 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1235 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1240 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1243 schedule_work(&wqw->work);
1247 * spi module reset handler
1250 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1252 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1255 rc = mptscsih_ioc_reset(ioc, reset_phase);
1257 if (reset_phase == MPT_IOC_POST_RESET)
1258 mptspi_dv_renegotiate(hd);
1265 * spi module resume handler
1268 mptspi_resume(struct pci_dev *pdev)
1270 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1271 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1274 rc = mptscsih_resume(pdev);
1275 mptspi_dv_renegotiate(hd);
1281 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1282 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1284 * mptspi_probe - Installs scsi devices per bus.
1285 * @pdev: Pointer to pci_dev structure
1287 * Returns 0 for success, non-zero for failure.
1291 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1293 struct Scsi_Host *sh;
1296 unsigned long flags;
1304 if ((r = mpt_attach(pdev,id)) != 0)
1307 ioc = pci_get_drvdata(pdev);
1308 ioc->DoneCtx = mptspiDoneCtx;
1309 ioc->TaskCtx = mptspiTaskCtx;
1310 ioc->InternalCtx = mptspiInternalCtx;
1312 /* Added sanity check on readiness of the MPT adapter.
1314 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1315 printk(MYIOC_s_WARN_FMT
1316 "Skipping because it's not operational!\n",
1319 goto out_mptspi_probe;
1323 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1326 goto out_mptspi_probe;
1329 /* Sanity check - ensure at least 1 port is INITIATOR capable
1332 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1333 if (ioc->pfacts[ii].ProtocolFlags &
1334 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1339 printk(MYIOC_s_WARN_FMT
1340 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1345 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1348 printk(MYIOC_s_WARN_FMT
1349 "Unable to register controller with SCSI subsystem\n",
1352 goto out_mptspi_probe;
1355 spin_lock_irqsave(&ioc->FreeQlock, flags);
1357 /* Attach the SCSI Host to the IOC structure
1365 /* set 16 byte cdb's */
1366 sh->max_cmd_len = 16;
1368 /* Yikes! This is important!
1369 * Otherwise, by default, linux
1370 * only scans target IDs 0-7!
1371 * pfactsN->MaxDevices unreliable
1372 * (not supported in early
1373 * versions of the FW).
1374 * max_id = 1 + actual max id,
1375 * max_lun = 1 + actual last lun,
1378 sh->max_id = ioc->devices_per_bus;
1380 sh->max_lun = MPT_LAST_LUN + 1;
1382 * If RAID Firmware Detected, setup virtual channel
1384 if (ioc->ir_firmware)
1385 sh->max_channel = 1;
1387 sh->max_channel = 0;
1388 sh->this_id = ioc->pfacts[0].PortSCSIID;
1392 sh->unique_id = ioc->id;
1394 /* Verify that we won't exceed the maximum
1395 * number of chain buffers
1396 * We can optimize: ZZ = req_sz/sizeof(SGE)
1398 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1399 * + (req_sz - 64)/sizeof(SGE)
1400 * A slightly different algorithm is required for
1403 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1404 if (sizeof(dma_addr_t) == sizeof(u64)) {
1405 numSGE = (scale - 1) *
1406 (ioc->facts.MaxChainDepth-1) + scale +
1407 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1410 numSGE = 1 + (scale - 1) *
1411 (ioc->facts.MaxChainDepth-1) + scale +
1412 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1416 if (numSGE < sh->sg_tablesize) {
1417 /* Reset this value */
1418 dprintk((MYIOC_s_INFO_FMT
1419 "Resetting sg_tablesize to %d from %d\n",
1420 ioc->name, numSGE, sh->sg_tablesize));
1421 sh->sg_tablesize = numSGE;
1424 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1426 hd = (MPT_SCSI_HOST *) sh->hostdata;
1429 /* SCSI needs scsi_cmnd lookup table!
1430 * (with size equal to req_depth*PtrSz!)
1432 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1433 if (!hd->ScsiLookup) {
1435 goto out_mptspi_probe;
1438 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1439 ioc->name, hd->ScsiLookup));
1441 /* Clear the TM flags
1444 hd->tmState = TM_STATE_NONE;
1445 hd->resetPending = 0;
1446 hd->abortSCpnt = NULL;
1448 /* Clear the pointer used to store
1449 * single-threaded commands, i.e., those
1450 * issued during a bus scan, dv and
1451 * configuration pages.
1455 /* Initialize this SCSI Hosts' timers
1456 * To use, set the timer expires field
1459 init_timer(&hd->timer);
1460 hd->timer.data = (unsigned long) hd;
1461 hd->timer.function = mptscsih_timer_expired;
1463 ioc->spi_data.Saf_Te = mpt_saf_te;
1465 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1466 ddvprintk((MYIOC_s_INFO_FMT
1470 ioc->spi_data.noQas = 0;
1472 init_waitqueue_head(&hd->scandv_waitq);
1473 hd->scandv_wait_done = 0;
1474 hd->last_queue_full = 0;
1475 hd->spi_pending = 0;
1477 /* Some versions of the firmware don't support page 0; without
1478 * that we can't get the parameters */
1479 if (hd->ioc->spi_data.sdp0length != 0)
1480 sh->transportt = mptspi_transport_template;
1482 error = scsi_add_host (sh, &ioc->pcidev->dev);
1484 dprintk((KERN_ERR MYNAM
1485 "scsi_add_host failed\n"));
1486 goto out_mptspi_probe;
1490 * issue internal bus reset
1492 if (ioc->spi_data.bus_reset)
1493 mptscsih_TMHandler(hd,
1494 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1502 mptscsih_remove(pdev);
1506 static struct pci_driver mptspi_driver = {
1508 .id_table = mptspi_pci_table,
1509 .probe = mptspi_probe,
1510 .remove = __devexit_p(mptscsih_remove),
1511 .shutdown = mptscsih_shutdown,
1513 .suspend = mptscsih_suspend,
1514 .resume = mptspi_resume,
1518 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1520 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1522 * Returns 0 for success, non-zero for failure.
1527 show_mptmod_ver(my_NAME, my_VERSION);
1529 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1530 if (!mptspi_transport_template)
1533 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1534 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1535 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1537 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1538 devtverboseprintk((KERN_INFO MYNAM
1539 ": Registered for IOC event notifications\n"));
1542 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1543 dprintk((KERN_INFO MYNAM
1544 ": Registered for IOC reset notifications\n"));
1547 return pci_register_driver(&mptspi_driver);
1550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1551 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1553 * mptspi_exit - Unregisters MPT adapter(s)
1558 pci_unregister_driver(&mptspi_driver);
1560 mpt_reset_deregister(mptspiDoneCtx);
1561 dprintk((KERN_INFO MYNAM
1562 ": Deregistered for IOC reset notifications\n"));
1564 mpt_event_deregister(mptspiDoneCtx);
1565 dprintk((KERN_INFO MYNAM
1566 ": Deregistered for IOC event notifications\n"));
1568 mpt_deregister(mptspiInternalCtx);
1569 mpt_deregister(mptspiTaskCtx);
1570 mpt_deregister(mptspiDoneCtx);
1571 spi_release_transport(mptspi_transport_template);
1574 module_init(mptspi_init);
1575 module_exit(mptspi_exit);