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-2005 LSI Logic Corporation
7 * (mailto:mpt_linux_developer@lsil.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>
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");
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 int mpt_pq_filter = 0;
87 module_param(mpt_pq_filter, int, 0);
88 MODULE_PARM_DESC(mpt_pq_filter, " Enable peripheral qualifier filter: enable=1 (default=0)");
90 static void mptspi_write_offset(struct scsi_target *, int);
91 static void mptspi_write_width(struct scsi_target *, int);
92 static int mptspi_write_spi_device_pg1(struct scsi_target *,
93 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
95 static struct scsi_transport_template *mptspi_transport_template = NULL;
97 static int mptspiDoneCtx = -1;
98 static int mptspiTaskCtx = -1;
99 static int mptspiInternalCtx = -1; /* Used only for internal commands */
101 static int mptspi_target_alloc(struct scsi_target *starget)
103 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
104 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
110 ret = mptscsih_target_alloc(starget);
114 /* if we're a device on virtual channel 1 and we're not part
115 * of an array, just return here (otherwise the setup below
116 * may actually affect a real physical device on channel 0 */
117 if (starget->channel == 1 &&
118 mptscsih_raid_id_to_num(hd, starget->id) < 0)
121 if (hd->ioc->spi_data.nvram &&
122 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
123 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
124 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
125 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
127 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
128 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
130 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
132 spi_offset(starget) = 0;
133 mptspi_write_width(starget, 0);
138 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
139 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
141 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
142 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
143 struct _MPT_ADAPTER *ioc = hd->ioc;
144 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
147 struct _x_config_parms cfg;
148 struct _CONFIG_PAGE_HEADER hdr;
151 /* No SPI parameters for RAID devices */
152 if (starget->channel == 0 &&
153 (hd->ioc->raid_data.isRaid & (1 << starget->id)))
156 size = ioc->spi_data.sdp0length * 4;
158 if (ioc->spi_data.sdp0length & 1)
163 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
165 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
169 memset(&hdr, 0, sizeof(hdr));
171 hdr.PageVersion = ioc->spi_data.sdp0version;
172 hdr.PageLength = ioc->spi_data.sdp0length;
174 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
176 memset(&cfg, 0, sizeof(cfg));
178 cfg.cfghdr.hdr = &hdr;
179 cfg.physAddr = pg0_dma;
180 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
182 cfg.pageAddr = starget->id;
184 if (mpt_config(ioc, &cfg)) {
185 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
189 memcpy(pass_pg0, pg0, size);
192 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
196 static u32 mptspi_getRP(struct scsi_target *starget)
200 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
201 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
202 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
203 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
204 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
205 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
206 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
207 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
209 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
210 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
211 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
216 static void mptspi_read_parameters(struct scsi_target *starget)
219 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
221 mptspi_read_spi_device_pg0(starget, &pg0);
223 nego = le32_to_cpu(pg0.NegotiatedParameters);
225 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
226 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
227 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
228 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
229 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
230 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
231 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
232 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
233 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
234 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
235 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
239 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, int disk)
241 MpiRaidActionRequest_t *pReq;
244 /* Get and Populate a free Frame
246 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
247 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
251 pReq = (MpiRaidActionRequest_t *)mf;
253 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
255 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
257 pReq->ChainOffset = 0;
258 pReq->Function = MPI_FUNCTION_RAID_ACTION;
259 pReq->VolumeID = disk;
261 pReq->PhysDiskNum = 0;
264 pReq->ActionDataWord = 0; /* Reserved for this action */
266 mpt_add_sge((char *)&pReq->ActionDataSGE,
267 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
269 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action %x id %d\n",
270 hd->ioc->name, action, io->id));
273 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
274 hd->scandv_wait_done = 0;
276 /* Save cmd pointer, for resource free if timeout or
281 add_timer(&hd->timer);
282 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
283 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
285 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
291 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
292 struct scsi_device *sdev)
294 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
296 /* no DV on RAID devices */
297 if (sdev->channel == 0 &&
298 (hd->ioc->raid_data.isRaid & (1 << sdev->id)))
301 /* If this is a piece of a RAID, then quiesce first */
302 if (sdev->channel == 1 &&
303 mptscsih_quiesce_raid(hd, 1, vtarget->target_id) < 0) {
304 starget_printk(KERN_ERR, scsi_target(sdev),
305 "Integrated RAID quiesce failed\n");
311 if (sdev->channel == 1 &&
312 mptscsih_quiesce_raid(hd, 0, vtarget->target_id) < 0)
313 starget_printk(KERN_ERR, scsi_target(sdev),
314 "Integrated RAID resume failed\n");
316 mptspi_read_parameters(sdev->sdev_target);
317 spi_display_xfer_agreement(sdev->sdev_target);
318 mptspi_read_parameters(sdev->sdev_target);
321 static int mptspi_slave_alloc(struct scsi_device *sdev)
324 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
325 /* gcc doesn't see that all uses of this variable occur within
326 * the if() statements, so stop it from whining */
329 if (sdev->channel == 1) {
330 physdisknum = mptscsih_raid_id_to_num(hd, sdev->id);
336 ret = mptscsih_slave_alloc(sdev);
341 if (sdev->channel == 1) {
342 VirtDevice *vdev = sdev->hostdata;
343 sdev->no_uld_attach = 1;
344 vdev->vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
345 /* The real channel for this device is zero */
346 vdev->vtarget->bus_id = 0;
347 /* The actual physdisknum (for RAID passthrough) */
348 vdev->vtarget->target_id = physdisknum;
354 static int mptspi_slave_configure(struct scsi_device *sdev)
356 int ret = mptscsih_slave_configure(sdev);
357 struct _MPT_SCSI_HOST *hd =
358 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
363 if ((sdev->channel == 1 ||
364 !(hd->ioc->raid_data.isRaid & (1 << sdev->id))) &&
365 !spi_initial_dv(sdev->sdev_target))
366 mptspi_dv_device(hd, sdev);
371 static void mptspi_slave_destroy(struct scsi_device *sdev)
373 struct scsi_target *starget = scsi_target(sdev);
374 VirtTarget *vtarget = starget->hostdata;
375 VirtDevice *vdevice = sdev->hostdata;
377 /* Will this be the last lun on a non-raid device? */
378 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
379 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
382 pg1.RequestedParameters = 0;
384 pg1.Configuration = 0;
386 mptspi_write_spi_device_pg1(starget, &pg1);
389 mptscsih_slave_destroy(sdev);
392 static struct scsi_host_template mptspi_driver_template = {
393 .module = THIS_MODULE,
394 .proc_name = "mptspi",
395 .proc_info = mptscsih_proc_info,
396 .name = "MPT SPI Host",
397 .info = mptscsih_info,
398 .queuecommand = mptscsih_qcmd,
399 .target_alloc = mptspi_target_alloc,
400 .slave_alloc = mptspi_slave_alloc,
401 .slave_configure = mptspi_slave_configure,
402 .target_destroy = mptscsih_target_destroy,
403 .slave_destroy = mptspi_slave_destroy,
404 .change_queue_depth = mptscsih_change_queue_depth,
405 .eh_abort_handler = mptscsih_abort,
406 .eh_device_reset_handler = mptscsih_dev_reset,
407 .eh_bus_reset_handler = mptscsih_bus_reset,
408 .eh_host_reset_handler = mptscsih_host_reset,
409 .bios_param = mptscsih_bios_param,
410 .can_queue = MPT_SCSI_CAN_QUEUE,
412 .sg_tablesize = MPT_SCSI_SG_DEPTH,
415 .use_clustering = ENABLE_CLUSTERING,
418 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
419 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
421 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
422 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
423 struct _MPT_ADAPTER *ioc = hd->ioc;
424 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
427 struct _x_config_parms cfg;
428 struct _CONFIG_PAGE_HEADER hdr;
431 /* don't allow updating nego parameters on RAID devices */
432 if (starget->channel == 0 &&
433 (hd->ioc->raid_data.isRaid & (1 << starget->id)))
436 size = ioc->spi_data.sdp1length * 4;
438 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
440 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
444 memset(&hdr, 0, sizeof(hdr));
446 hdr.PageVersion = ioc->spi_data.sdp1version;
447 hdr.PageLength = ioc->spi_data.sdp1length;
449 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
451 memset(&cfg, 0, sizeof(cfg));
453 cfg.cfghdr.hdr = &hdr;
454 cfg.physAddr = pg1_dma;
455 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
457 cfg.pageAddr = starget->id;
459 memcpy(pg1, pass_pg1, size);
461 pg1->Header.PageVersion = hdr.PageVersion;
462 pg1->Header.PageLength = hdr.PageLength;
463 pg1->Header.PageNumber = hdr.PageNumber;
464 pg1->Header.PageType = hdr.PageType;
466 if (mpt_config(ioc, &cfg)) {
467 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
473 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
477 static void mptspi_write_offset(struct scsi_target *starget, int offset)
479 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
488 if (spi_offset(starget) == -1)
489 mptspi_read_parameters(starget);
491 spi_offset(starget) = offset;
493 nego = mptspi_getRP(starget);
495 pg1.RequestedParameters = cpu_to_le32(nego);
497 pg1.Configuration = 0;
499 mptspi_write_spi_device_pg1(starget, &pg1);
502 static void mptspi_write_period(struct scsi_target *starget, int period)
504 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
513 if (spi_period(starget) == -1)
514 mptspi_read_parameters(starget);
519 } else if (period == 9) {
523 spi_period(starget) = period;
525 nego = mptspi_getRP(starget);
527 pg1.RequestedParameters = cpu_to_le32(nego);
529 pg1.Configuration = 0;
531 mptspi_write_spi_device_pg1(starget, &pg1);
534 static void mptspi_write_dt(struct scsi_target *starget, int dt)
536 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
539 if (spi_period(starget) == -1)
540 mptspi_read_parameters(starget);
542 if (!dt && spi_period(starget) < 10)
543 spi_period(starget) = 10;
545 spi_dt(starget) = dt;
547 nego = mptspi_getRP(starget);
550 pg1.RequestedParameters = cpu_to_le32(nego);
552 pg1.Configuration = 0;
554 mptspi_write_spi_device_pg1(starget, &pg1);
557 static void mptspi_write_iu(struct scsi_target *starget, int iu)
559 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
562 if (spi_period(starget) == -1)
563 mptspi_read_parameters(starget);
565 if (!iu && spi_period(starget) < 9)
566 spi_period(starget) = 9;
568 spi_iu(starget) = iu;
570 nego = mptspi_getRP(starget);
572 pg1.RequestedParameters = cpu_to_le32(nego);
574 pg1.Configuration = 0;
576 mptspi_write_spi_device_pg1(starget, &pg1);
579 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
580 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
582 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
585 spi_##parm(starget) = parm; \
587 nego = mptspi_getRP(starget); \
589 pg1.RequestedParameters = cpu_to_le32(nego); \
591 pg1.Configuration = 0; \
593 mptspi_write_spi_device_pg1(starget, &pg1); \
596 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
597 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
598 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
599 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
600 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
602 static void mptspi_write_qas(struct scsi_target *starget, int qas)
604 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
605 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
606 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
607 VirtTarget *vtarget = starget->hostdata;
610 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
611 hd->ioc->spi_data.noQas)
612 spi_qas(starget) = 0;
614 spi_qas(starget) = qas;
616 nego = mptspi_getRP(starget);
618 pg1.RequestedParameters = cpu_to_le32(nego);
620 pg1.Configuration = 0;
622 mptspi_write_spi_device_pg1(starget, &pg1);
625 static void mptspi_write_width(struct scsi_target *starget, int width)
627 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
632 if (spi_period(starget) < 10)
633 spi_period(starget) = 10;
636 spi_width(starget) = width;
638 nego = mptspi_getRP(starget);
640 pg1.RequestedParameters = cpu_to_le32(nego);
642 pg1.Configuration = 0;
644 mptspi_write_spi_device_pg1(starget, &pg1);
647 struct work_queue_wrapper {
648 struct work_struct work;
649 struct _MPT_SCSI_HOST *hd;
653 static void mpt_work_wrapper(void *data)
655 struct work_queue_wrapper *wqw = (struct work_queue_wrapper *)data;
656 struct _MPT_SCSI_HOST *hd = wqw->hd;
657 struct Scsi_Host *shost = hd->ioc->sh;
658 struct scsi_device *sdev;
659 int disk = wqw->disk;
660 struct _CONFIG_PAGE_IOC_3 *pg3;
664 mpt_findImVolumes(hd->ioc);
665 pg3 = hd->ioc->raid_data.pIocPg3;
669 shost_for_each_device(sdev,shost) {
670 struct scsi_target *starget = scsi_target(sdev);
671 VirtTarget *vtarget = starget->hostdata;
673 /* only want to search RAID components */
674 if (sdev->channel != 1)
677 /* The target_id is the raid PhysDiskNum, even if
678 * starget->id is the actual target address */
679 if(vtarget->target_id != disk)
682 starget_printk(KERN_INFO, vtarget->starget,
683 "Integrated RAID requests DV of new device\n");
684 mptspi_dv_device(hd, sdev);
686 shost_printk(KERN_INFO, shost,
687 "Integrated RAID detects new device %d\n", disk);
688 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
692 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
694 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
697 shost_printk(KERN_ERR, hd->ioc->sh,
698 "Failed to act on RAID event for physical disk %d\n",
702 INIT_WORK(&wqw->work, mpt_work_wrapper, wqw);
706 schedule_work(&wqw->work);
710 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
712 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
713 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
715 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
717 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
719 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
720 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
721 mpt_dv_raid(hd, disk);
724 return mptscsih_event_process(ioc, pEvReply);
728 mptspi_deny_binding(struct scsi_target *starget)
730 struct _MPT_SCSI_HOST *hd =
731 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
732 return ((hd->ioc->raid_data.isRaid & (1 << starget->id)) &&
733 starget->channel == 0) ? 1 : 0;
736 static struct spi_function_template mptspi_transport_functions = {
737 .get_offset = mptspi_read_parameters,
738 .set_offset = mptspi_write_offset,
740 .get_period = mptspi_read_parameters,
741 .set_period = mptspi_write_period,
743 .get_width = mptspi_read_parameters,
744 .set_width = mptspi_write_width,
746 .get_iu = mptspi_read_parameters,
747 .set_iu = mptspi_write_iu,
749 .get_dt = mptspi_read_parameters,
750 .set_dt = mptspi_write_dt,
752 .get_qas = mptspi_read_parameters,
753 .set_qas = mptspi_write_qas,
755 .get_wr_flow = mptspi_read_parameters,
756 .set_wr_flow = mptspi_write_wr_flow,
758 .get_rd_strm = mptspi_read_parameters,
759 .set_rd_strm = mptspi_write_rd_strm,
761 .get_rti = mptspi_read_parameters,
762 .set_rti = mptspi_write_rti,
764 .get_pcomp_en = mptspi_read_parameters,
765 .set_pcomp_en = mptspi_write_pcomp_en,
767 .get_hold_mcs = mptspi_read_parameters,
768 .set_hold_mcs = mptspi_write_hold_mcs,
770 .deny_binding = mptspi_deny_binding,
773 /****************************************************************************
777 static struct pci_device_id mptspi_pci_table[] = {
778 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1030,
779 PCI_ANY_ID, PCI_ANY_ID },
780 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_1030_53C1035,
781 PCI_ANY_ID, PCI_ANY_ID },
782 {0} /* Terminating entry */
784 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
788 * renegotiate for a given target
791 mptspi_dv_renegotiate_work(void *data)
793 struct work_queue_wrapper *wqw = (struct work_queue_wrapper *)data;
794 struct _MPT_SCSI_HOST *hd = wqw->hd;
795 struct scsi_device *sdev;
799 shost_for_each_device(sdev, hd->ioc->sh)
800 mptspi_dv_device(hd, sdev);
804 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
806 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
811 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work, wqw);
814 schedule_work(&wqw->work);
818 * spi module reset handler
821 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
823 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
826 rc = mptscsih_ioc_reset(ioc, reset_phase);
828 if (reset_phase == MPT_IOC_POST_RESET)
829 mptspi_dv_renegotiate(hd);
836 * spi module resume handler
839 mptspi_resume(struct pci_dev *pdev)
841 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
842 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
845 rc = mptscsih_resume(pdev);
846 mptspi_dv_renegotiate(hd);
852 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
853 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
855 * mptspi_probe - Installs scsi devices per bus.
856 * @pdev: Pointer to pci_dev structure
858 * Returns 0 for success, non-zero for failure.
862 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
864 struct Scsi_Host *sh;
875 if ((r = mpt_attach(pdev,id)) != 0)
878 ioc = pci_get_drvdata(pdev);
879 ioc->DoneCtx = mptspiDoneCtx;
880 ioc->TaskCtx = mptspiTaskCtx;
881 ioc->InternalCtx = mptspiInternalCtx;
883 /* Added sanity check on readiness of the MPT adapter.
885 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
886 printk(MYIOC_s_WARN_FMT
887 "Skipping because it's not operational!\n",
890 goto out_mptspi_probe;
894 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
897 goto out_mptspi_probe;
900 /* Sanity check - ensure at least 1 port is INITIATOR capable
903 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
904 if (ioc->pfacts[ii].ProtocolFlags &
905 MPI_PORTFACTS_PROTOCOL_INITIATOR)
910 printk(MYIOC_s_WARN_FMT
911 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
916 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
919 printk(MYIOC_s_WARN_FMT
920 "Unable to register controller with SCSI subsystem\n",
923 goto out_mptspi_probe;
926 spin_lock_irqsave(&ioc->FreeQlock, flags);
928 /* Attach the SCSI Host to the IOC structure
936 /* set 16 byte cdb's */
937 sh->max_cmd_len = 16;
939 /* Yikes! This is important!
940 * Otherwise, by default, linux
941 * only scans target IDs 0-7!
942 * pfactsN->MaxDevices unreliable
943 * (not supported in early
944 * versions of the FW).
945 * max_id = 1 + actual max id,
946 * max_lun = 1 + actual last lun,
949 sh->max_id = MPT_MAX_SCSI_DEVICES;
951 sh->max_lun = MPT_LAST_LUN + 1;
953 * If RAID Firmware Detected, setup virtual channel
955 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
956 > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
960 sh->this_id = ioc->pfacts[0].PortSCSIID;
964 sh->unique_id = ioc->id;
966 /* Verify that we won't exceed the maximum
967 * number of chain buffers
968 * We can optimize: ZZ = req_sz/sizeof(SGE)
970 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
971 * + (req_sz - 64)/sizeof(SGE)
972 * A slightly different algorithm is required for
975 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
976 if (sizeof(dma_addr_t) == sizeof(u64)) {
977 numSGE = (scale - 1) *
978 (ioc->facts.MaxChainDepth-1) + scale +
979 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
982 numSGE = 1 + (scale - 1) *
983 (ioc->facts.MaxChainDepth-1) + scale +
984 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
988 if (numSGE < sh->sg_tablesize) {
989 /* Reset this value */
990 dprintk((MYIOC_s_INFO_FMT
991 "Resetting sg_tablesize to %d from %d\n",
992 ioc->name, numSGE, sh->sg_tablesize));
993 sh->sg_tablesize = numSGE;
996 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
998 hd = (MPT_SCSI_HOST *) sh->hostdata;
1001 /* SCSI needs scsi_cmnd lookup table!
1002 * (with size equal to req_depth*PtrSz!)
1004 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1005 if (!hd->ScsiLookup) {
1007 goto out_mptspi_probe;
1010 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1011 ioc->name, hd->ScsiLookup));
1013 /* Allocate memory for the device structures.
1014 * A non-Null pointer at an offset
1015 * indicates a device exists.
1016 * max_id = 1 + maximum id (hosts.h)
1018 hd->Targets = kcalloc(sh->max_id * (sh->max_channel + 1),
1019 sizeof(void *), GFP_ATOMIC);
1022 goto out_mptspi_probe;
1025 dprintk((KERN_INFO " vdev @ %p\n", hd->Targets));
1027 /* Clear the TM flags
1030 hd->tmState = TM_STATE_NONE;
1031 hd->resetPending = 0;
1032 hd->abortSCpnt = NULL;
1034 /* Clear the pointer used to store
1035 * single-threaded commands, i.e., those
1036 * issued during a bus scan, dv and
1037 * configuration pages.
1041 /* Initialize this SCSI Hosts' timers
1042 * To use, set the timer expires field
1045 init_timer(&hd->timer);
1046 hd->timer.data = (unsigned long) hd;
1047 hd->timer.function = mptscsih_timer_expired;
1049 ioc->spi_data.Saf_Te = mpt_saf_te;
1050 hd->mpt_pq_filter = mpt_pq_filter;
1052 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1053 ddvprintk((MYIOC_s_INFO_FMT
1054 "saf_te %x mpt_pq_filter %x\n",
1058 ioc->spi_data.noQas = 0;
1060 init_waitqueue_head(&hd->scandv_waitq);
1061 hd->scandv_wait_done = 0;
1062 hd->last_queue_full = 0;
1064 /* Some versions of the firmware don't support page 0; without
1065 * that we can't get the parameters */
1066 if (hd->ioc->spi_data.sdp0length != 0)
1067 sh->transportt = mptspi_transport_template;
1069 error = scsi_add_host (sh, &ioc->pcidev->dev);
1071 dprintk((KERN_ERR MYNAM
1072 "scsi_add_host failed\n"));
1073 goto out_mptspi_probe;
1077 * issue internal bus reset
1079 if (ioc->spi_data.bus_reset)
1080 mptscsih_TMHandler(hd,
1081 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1089 mptscsih_remove(pdev);
1093 static struct pci_driver mptspi_driver = {
1095 .id_table = mptspi_pci_table,
1096 .probe = mptspi_probe,
1097 .remove = __devexit_p(mptscsih_remove),
1098 .shutdown = mptscsih_shutdown,
1100 .suspend = mptscsih_suspend,
1101 .resume = mptspi_resume,
1105 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1107 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with
1108 * linux scsi mid-layer.
1110 * Returns 0 for success, non-zero for failure.
1115 show_mptmod_ver(my_NAME, my_VERSION);
1117 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1118 if (!mptspi_transport_template)
1121 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1122 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1123 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1125 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1126 devtverboseprintk((KERN_INFO MYNAM
1127 ": Registered for IOC event notifications\n"));
1130 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1131 dprintk((KERN_INFO MYNAM
1132 ": Registered for IOC reset notifications\n"));
1135 return pci_register_driver(&mptspi_driver);
1138 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1139 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1141 * mptspi_exit - Unregisters MPT adapter(s)
1147 pci_unregister_driver(&mptspi_driver);
1149 mpt_reset_deregister(mptspiDoneCtx);
1150 dprintk((KERN_INFO MYNAM
1151 ": Deregistered for IOC reset notifications\n"));
1153 mpt_event_deregister(mptspiDoneCtx);
1154 dprintk((KERN_INFO MYNAM
1155 ": Deregistered for IOC event notifications\n"));
1157 mpt_deregister(mptspiInternalCtx);
1158 mpt_deregister(mptspiTaskCtx);
1159 mpt_deregister(mptspiDoneCtx);
1160 spi_release_transport(mptspi_transport_template);
1163 module_init(mptspi_init);
1164 module_exit(mptspi_exit);