2
* linux/drivers/message/fusion/mptspi.c
3
* For use with LSI PCI chip/adapter(s)
4
* running LSI Fusion MPT (Message Passing Technology) firmware.
6
* Copyright (c) 1999-2008 LSI Corporation
7
* (mailto:DL-MPTFusionLinux@lsi.com)
10
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12
This program is free software; you can redistribute it and/or modify
13
it under the terms of the GNU General Public License as published by
14
the Free Software Foundation; version 2 of the License.
16
This program is distributed in the hope that it will be useful,
17
but WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
GNU General Public License for more details.
22
THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23
CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24
LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26
solely responsible for determining the appropriateness of using and
27
distributing the Program and assumes all risks associated with its
28
exercise of rights under this Agreement, including but not limited to
29
the risks and costs of program errors, damage to or loss of data,
30
programs or equipment, and unavailability or interruption of operations.
32
DISCLAIMER OF LIABILITY
33
NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35
DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38
USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39
HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
41
You should have received a copy of the GNU General Public License
42
along with this program; if not, write to the Free Software
43
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
45
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
47
#include <linux/module.h>
48
#include <linux/kernel.h>
49
#include <linux/slab.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 u8 mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
95
static u8 mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
96
static u8 mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* 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
MPT_ADAPTER *ioc = hd->ioc;
112
SpiCfgData *pspi_data = &ioc->spi_data;
113
int id = (int) target->id;
115
u8 width = MPT_NARROW;
116
u8 factor = MPT_ASYNC;
121
target->negoFlags = pspi_data->noQas;
123
if (sdev->scsi_level < SCSI_2) {
126
offset = pspi_data->maxSyncOffset;
127
target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
129
if (scsi_device_wide(sdev))
132
if (scsi_device_sync(sdev)) {
133
factor = pspi_data->minSyncFactor;
134
if (!scsi_device_dt(sdev))
137
if (!scsi_device_ius(sdev) &&
138
!scsi_device_qas(sdev))
139
factor = MPT_ULTRA160;
141
factor = MPT_ULTRA320;
142
if (scsi_device_qas(sdev)) {
144
printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
145
"byte56=%02x on id=%d!\n", ioc->name,
146
scsi_device_qas(sdev), id));
149
if (sdev->type == TYPE_TAPE &&
150
scsi_device_ius(sdev))
151
target->negoFlags |= MPT_TAPE_NEGO_IDP;
154
offset = pspi_data->maxSyncOffset;
156
/* If RAID, never disable QAS
157
* else if non RAID, do not disable
158
* QAS if bit 1 is set
159
* bit 1 QAS support, non-raid only
162
if (target->raidVolume == 1)
170
if (!sdev->tagged_supported)
171
target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
173
/* Update tflags based on NVRAM settings. (SCSI only)
175
if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
176
nvram = pspi_data->nvram[id];
177
nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
180
width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
183
/* Ensure factor is set to the
184
* maximum of: adapter, nvram, inquiry
187
if (nfactor < pspi_data->minSyncFactor )
188
nfactor = pspi_data->minSyncFactor;
190
factor = max(factor, nfactor);
191
if (factor == MPT_ASYNC)
202
/* Make sure data is consistent
204
if ((!width) && (factor < MPT_ULTRA2))
207
/* Save the data to the target structure.
209
target->minSyncFactor = factor;
210
target->maxOffset = offset;
211
target->maxWidth = width;
213
spi_min_period(scsi_target(sdev)) = factor;
214
spi_max_offset(scsi_target(sdev)) = offset;
215
spi_max_width(scsi_target(sdev)) = width;
217
target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
219
/* Disable unused features.
222
target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
225
target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
227
if ( factor > MPT_ULTRA320 )
230
if (noQas && (pspi_data->noQas == 0)) {
231
pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
232
target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
234
/* Disable QAS in a mixed configuration case
237
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
238
"Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
243
* mptspi_writeIOCPage4 - write IOC Page 4
244
* @hd: Pointer to a SCSI Host Structure
245
* @channel: channel number
246
* @id: write IOC Page4 for this ID & Bus
248
* Return: -EAGAIN if unable to obtain a Message Frame
251
* Remark: We do not wait for a return, write pages sequentially.
254
mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
256
MPT_ADAPTER *ioc = hd->ioc;
258
IOCPage4_t *IOCPage4Ptr;
266
/* Get a MF for this command.
268
if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
269
dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
270
"writeIOCPage4 : no msg frames!\n",ioc->name));
274
/* Set the request and the data pointers.
275
* Place data at end of MF.
277
pReq = (Config_t *)mf;
279
req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
280
frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
282
/* Complete the request frame (same for all requests).
284
pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
286
pReq->ChainOffset = 0;
287
pReq->Function = MPI_FUNCTION_CONFIG;
288
pReq->ExtPageLength = 0;
289
pReq->ExtPageType = 0;
291
for (ii=0; ii < 8; ii++) {
292
pReq->Reserved2[ii] = 0;
295
IOCPage4Ptr = ioc->spi_data.pIocPg4;
296
dataDma = ioc->spi_data.IocPg4_dma;
297
ii = IOCPage4Ptr->ActiveSEP++;
298
IOCPage4Ptr->SEP[ii].SEPTargetID = id;
299
IOCPage4Ptr->SEP[ii].SEPBus = channel;
300
pReq->Header = IOCPage4Ptr->Header;
301
pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
303
/* Add a SGE to the config request.
305
flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
306
(IOCPage4Ptr->Header.PageLength + ii) * 4;
308
ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
310
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
311
"writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
312
ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
314
mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
320
* mptspi_initTarget - Target, LUN alloc/free functionality.
321
* @hd: Pointer to MPT_SCSI_HOST structure
322
* @vtarget: per target private data
325
* NOTE: It's only SAFE to call this routine if data points to
326
* sane & valid STANDARD INQUIRY data!
328
* Allocate and initialize memory for this target.
333
mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
334
struct scsi_device *sdev)
337
/* Is LUN supported? If so, upper 2 bits will be 0
338
* in first byte of inquiry data.
340
if (sdev->inq_periph_qual != 0)
346
vtarget->type = sdev->type;
348
if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
349
/* Treat all Processors as SAF-TE if
350
* command line option is set */
351
vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
352
mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
353
}else if ((sdev->type == TYPE_PROCESSOR) &&
354
!(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
355
if (sdev->inquiry_len > 49 ) {
356
if (sdev->inquiry[44] == 'S' &&
357
sdev->inquiry[45] == 'A' &&
358
sdev->inquiry[46] == 'F' &&
359
sdev->inquiry[47] == '-' &&
360
sdev->inquiry[48] == 'T' &&
361
sdev->inquiry[49] == 'E' ) {
362
vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
363
mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
367
mptspi_setTargetNegoParms(hd, vtarget, sdev);
371
* mptspi_is_raid - Determines whether target is belonging to volume
372
* @hd: Pointer to a SCSI HOST structure
373
* @id: target device id
381
mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
384
MPT_ADAPTER *ioc = hd->ioc;
386
if (!ioc->raid_data.pIocPg2)
389
if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
391
for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
392
if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
402
static int mptspi_target_alloc(struct scsi_target *starget)
404
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
405
struct _MPT_SCSI_HOST *hd = shost_priv(shost);
413
vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
417
vtarget->ioc_id = ioc->id;
418
vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
419
vtarget->id = (u8)starget->id;
420
vtarget->channel = (u8)starget->channel;
421
vtarget->starget = starget;
422
starget->hostdata = vtarget;
424
if (starget->channel == 1) {
425
if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
427
vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
428
/* The real channel for this device is zero */
429
vtarget->channel = 0;
430
/* The actual physdisknum (for RAID passthrough) */
431
vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
435
if (starget->channel == 0 &&
436
mptspi_is_raid(hd, starget->id)) {
437
vtarget->raidVolume = 1;
438
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
439
"RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
443
if (ioc->spi_data.nvram &&
444
ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
445
u32 nvram = ioc->spi_data.nvram[starget->id];
446
spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
447
spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
449
spi_min_period(starget) = ioc->spi_data.minSyncFactor;
450
spi_max_width(starget) = ioc->spi_data.maxBusWidth;
452
spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
454
spi_offset(starget) = 0;
455
spi_period(starget) = 0xFF;
456
mptspi_write_width(starget, 0);
462
mptspi_target_destroy(struct scsi_target *starget)
464
if (starget->hostdata)
465
kfree(starget->hostdata);
466
starget->hostdata = NULL;
470
* mptspi_print_write_nego - negotiation parameters debug info that is being sent
471
* @hd: Pointer to a SCSI HOST structure
472
* @starget: SCSI target
473
* @ii: negotiation parameters
477
mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
479
ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
480
" ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
481
hd->ioc->name, starget->id, ii,
482
ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
483
((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
484
ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
485
ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
486
ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
487
ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
488
ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
489
ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
490
ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
491
ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
495
* mptspi_print_read_nego - negotiation parameters debug info that is being read
496
* @hd: Pointer to a SCSI HOST structure
497
* @starget: SCSI target
498
* @ii: negotiation parameters
502
mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
504
ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
505
" ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
506
hd->ioc->name, starget->id, ii,
507
ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
508
((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
509
ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
510
ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
511
ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
512
ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
513
ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
514
ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
515
ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
516
ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
519
static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
520
struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
522
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
523
struct _MPT_SCSI_HOST *hd = shost_priv(shost);
524
struct _MPT_ADAPTER *ioc = hd->ioc;
525
struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
526
dma_addr_t spi_dev_pg0_dma;
528
struct _x_config_parms cfg;
529
struct _CONFIG_PAGE_HEADER hdr;
532
/* No SPI parameters for RAID devices */
533
if (starget->channel == 0 &&
534
mptspi_is_raid(hd, starget->id))
537
size = ioc->spi_data.sdp0length * 4;
539
if (ioc->spi_data.sdp0length & 1)
544
spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
545
if (spi_dev_pg0 == NULL) {
546
starget_printk(KERN_ERR, starget, MYIOC_s_FMT
547
"dma_alloc_coherent for parameters failed\n", ioc->name);
551
memset(&hdr, 0, sizeof(hdr));
553
hdr.PageVersion = ioc->spi_data.sdp0version;
554
hdr.PageLength = ioc->spi_data.sdp0length;
556
hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
558
memset(&cfg, 0, sizeof(cfg));
560
cfg.cfghdr.hdr = &hdr;
561
cfg.physAddr = spi_dev_pg0_dma;
562
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
564
cfg.pageAddr = starget->id;
567
if (mpt_config(ioc, &cfg)) {
568
starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
572
memcpy(pass_pg0, spi_dev_pg0, size);
574
mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
577
dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
581
static u32 mptspi_getRP(struct scsi_target *starget)
585
nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
586
nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
587
nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
588
nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
589
nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
590
nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
591
nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
592
nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
594
nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
595
nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
596
nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
601
static void mptspi_read_parameters(struct scsi_target *starget)
604
struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
606
mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
608
nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
610
spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
611
spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
612
spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
613
spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
614
spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
615
spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
616
spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
617
spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
618
spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
619
spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
620
spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
624
mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
626
MPT_ADAPTER *ioc = hd->ioc;
627
MpiRaidActionRequest_t *pReq;
630
unsigned long timeleft;
632
mutex_lock(&ioc->internal_cmds.mutex);
634
/* Get and Populate a free Frame
636
if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
637
dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
638
"%s: no msg frames!\n", ioc->name, __func__));
642
pReq = (MpiRaidActionRequest_t *)mf;
644
pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
646
pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
648
pReq->ChainOffset = 0;
649
pReq->Function = MPI_FUNCTION_RAID_ACTION;
651
pReq->VolumeBus = channel;
652
pReq->PhysDiskNum = 0;
655
pReq->ActionDataWord = 0; /* Reserved for this action */
657
ioc->add_sge((char *)&pReq->ActionDataSGE,
658
MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
660
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
661
ioc->name, pReq->Action, channel, id));
663
INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
664
mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
665
timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
666
if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
668
dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
669
ioc->name, __func__));
670
if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
673
printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
674
ioc->name, __func__);
675
mpt_HardResetHandler(ioc, CAN_SLEEP);
676
mpt_free_msg_frame(ioc, mf);
681
ret = ioc->internal_cmds.completion_code;
684
CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
685
mutex_unlock(&ioc->internal_cmds.mutex);
689
static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
690
struct scsi_device *sdev)
692
VirtTarget *vtarget = scsi_target(sdev)->hostdata;
693
MPT_ADAPTER *ioc = hd->ioc;
695
/* no DV on RAID devices */
696
if (sdev->channel == 0 &&
697
mptspi_is_raid(hd, sdev->id))
700
/* If this is a piece of a RAID, then quiesce first */
701
if (sdev->channel == 1 &&
702
mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
703
starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
704
"Integrated RAID quiesce failed\n", ioc->name);
708
hd->spi_pending |= (1 << sdev->id);
710
hd->spi_pending &= ~(1 << sdev->id);
712
if (sdev->channel == 1 &&
713
mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
714
starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
715
"Integrated RAID resume failed\n", ioc->name);
717
mptspi_read_parameters(sdev->sdev_target);
718
spi_display_xfer_agreement(sdev->sdev_target);
719
mptspi_read_parameters(sdev->sdev_target);
722
static int mptspi_slave_alloc(struct scsi_device *sdev)
724
MPT_SCSI_HOST *hd = shost_priv(sdev->host);
727
struct scsi_target *starget;
728
MPT_ADAPTER *ioc = hd->ioc;
730
if (sdev->channel == 1 &&
731
mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
734
vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
736
printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
737
ioc->name, sizeof(VirtDevice));
741
vdevice->lun = sdev->lun;
742
sdev->hostdata = vdevice;
744
starget = scsi_target(sdev);
745
vtarget = starget->hostdata;
746
vdevice->vtarget = vtarget;
749
if (sdev->channel == 1)
750
sdev->no_uld_attach = 1;
755
static int mptspi_slave_configure(struct scsi_device *sdev)
757
struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
758
VirtTarget *vtarget = scsi_target(sdev)->hostdata;
761
mptspi_initTarget(hd, vtarget, sdev);
763
ret = mptscsih_slave_configure(sdev);
768
ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
769
" max_offset=0x%02x max_width=%d\n", hd->ioc->name,
770
sdev->id, spi_min_period(scsi_target(sdev)),
771
spi_max_offset(scsi_target(sdev)),
772
spi_max_width(scsi_target(sdev))));
774
if ((sdev->channel == 1 ||
775
!(mptspi_is_raid(hd, sdev->id))) &&
776
!spi_initial_dv(sdev->sdev_target))
777
mptspi_dv_device(hd, sdev);
783
mptspi_qcmd_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
785
struct _MPT_SCSI_HOST *hd = shost_priv(SCpnt->device->host);
786
VirtDevice *vdevice = SCpnt->device->hostdata;
787
MPT_ADAPTER *ioc = hd->ioc;
789
if (!vdevice || !vdevice->vtarget) {
790
SCpnt->result = DID_NO_CONNECT << 16;
795
if (SCpnt->device->channel == 1 &&
796
mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
797
SCpnt->result = DID_NO_CONNECT << 16;
802
if (spi_dv_pending(scsi_target(SCpnt->device)))
803
ddvprintk(ioc, scsi_print_command(SCpnt));
805
return mptscsih_qcmd(SCpnt,done);
808
static DEF_SCSI_QCMD(mptspi_qcmd)
810
static void mptspi_slave_destroy(struct scsi_device *sdev)
812
struct scsi_target *starget = scsi_target(sdev);
813
VirtTarget *vtarget = starget->hostdata;
814
VirtDevice *vdevice = sdev->hostdata;
816
/* Will this be the last lun on a non-raid device? */
817
if (vtarget->num_luns == 1 && vdevice->configured_lun) {
818
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
821
pg1.RequestedParameters = 0;
823
pg1.Configuration = 0;
825
mptspi_write_spi_device_pg1(starget, &pg1);
828
mptscsih_slave_destroy(sdev);
831
static struct scsi_host_template mptspi_driver_template = {
832
.module = THIS_MODULE,
833
.proc_name = "mptspi",
834
.proc_info = mptscsih_proc_info,
835
.name = "MPT SPI Host",
836
.info = mptscsih_info,
837
.queuecommand = mptspi_qcmd,
838
.target_alloc = mptspi_target_alloc,
839
.slave_alloc = mptspi_slave_alloc,
840
.slave_configure = mptspi_slave_configure,
841
.target_destroy = mptspi_target_destroy,
842
.slave_destroy = mptspi_slave_destroy,
843
.change_queue_depth = mptscsih_change_queue_depth,
844
.eh_abort_handler = mptscsih_abort,
845
.eh_device_reset_handler = mptscsih_dev_reset,
846
.eh_bus_reset_handler = mptscsih_bus_reset,
847
.eh_host_reset_handler = mptscsih_host_reset,
848
.bios_param = mptscsih_bios_param,
849
.can_queue = MPT_SCSI_CAN_QUEUE,
851
.sg_tablesize = MPT_SCSI_SG_DEPTH,
854
.use_clustering = ENABLE_CLUSTERING,
855
.shost_attrs = mptscsih_host_attrs,
858
static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
859
struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
861
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
862
struct _MPT_SCSI_HOST *hd = shost_priv(shost);
863
struct _MPT_ADAPTER *ioc = hd->ioc;
864
struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
867
struct _x_config_parms cfg;
868
struct _CONFIG_PAGE_HEADER hdr;
872
struct scsi_device *sdev;
875
/* don't allow updating nego parameters on RAID devices */
876
if (starget->channel == 0 &&
877
mptspi_is_raid(hd, starget->id))
880
size = ioc->spi_data.sdp1length * 4;
882
pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
884
starget_printk(KERN_ERR, starget, MYIOC_s_FMT
885
"dma_alloc_coherent for parameters failed\n", ioc->name);
889
memset(&hdr, 0, sizeof(hdr));
891
hdr.PageVersion = ioc->spi_data.sdp1version;
892
hdr.PageLength = ioc->spi_data.sdp1length;
894
hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
896
memset(&cfg, 0, sizeof(cfg));
898
cfg.cfghdr.hdr = &hdr;
899
cfg.physAddr = pg1_dma;
900
cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
902
cfg.pageAddr = starget->id;
904
memcpy(pg1, pass_pg1, size);
906
pg1->Header.PageVersion = hdr.PageVersion;
907
pg1->Header.PageLength = hdr.PageLength;
908
pg1->Header.PageNumber = hdr.PageNumber;
909
pg1->Header.PageType = hdr.PageType;
911
nego_parms = le32_to_cpu(pg1->RequestedParameters);
912
period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
913
MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
915
/* Turn on inline data padding for TAPE when running U320 */
916
for (i = 0 ; i < 16; i++) {
917
sdev = scsi_device_lookup_by_target(starget, i);
918
if (sdev && sdev->type == TYPE_TAPE) {
919
sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
920
"IDP:ON\n", ioc->name);
921
nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
922
pg1->RequestedParameters =
923
cpu_to_le32(nego_parms);
929
mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
931
if (mpt_config(ioc, &cfg)) {
932
starget_printk(KERN_ERR, starget, MYIOC_s_FMT
933
"mpt_config failed\n", ioc->name);
939
dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
943
static void mptspi_write_offset(struct scsi_target *starget, int offset)
945
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
954
if (spi_offset(starget) == -1)
955
mptspi_read_parameters(starget);
957
spi_offset(starget) = offset;
959
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_period(struct scsi_target *starget, int period)
970
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
979
if (spi_period(starget) == -1)
980
mptspi_read_parameters(starget);
985
} else if (period == 9) {
989
spi_period(starget) = period;
991
nego = mptspi_getRP(starget);
993
pg1.RequestedParameters = cpu_to_le32(nego);
995
pg1.Configuration = 0;
997
mptspi_write_spi_device_pg1(starget, &pg1);
1000
static void mptspi_write_dt(struct scsi_target *starget, int dt)
1002
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1005
if (spi_period(starget) == -1)
1006
mptspi_read_parameters(starget);
1008
if (!dt && spi_period(starget) < 10)
1009
spi_period(starget) = 10;
1011
spi_dt(starget) = dt;
1013
nego = mptspi_getRP(starget);
1016
pg1.RequestedParameters = cpu_to_le32(nego);
1018
pg1.Configuration = 0;
1020
mptspi_write_spi_device_pg1(starget, &pg1);
1023
static void mptspi_write_iu(struct scsi_target *starget, int iu)
1025
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1028
if (spi_period(starget) == -1)
1029
mptspi_read_parameters(starget);
1031
if (!iu && spi_period(starget) < 9)
1032
spi_period(starget) = 9;
1034
spi_iu(starget) = iu;
1036
nego = mptspi_getRP(starget);
1038
pg1.RequestedParameters = cpu_to_le32(nego);
1040
pg1.Configuration = 0;
1042
mptspi_write_spi_device_pg1(starget, &pg1);
1045
#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1046
static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1048
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1051
spi_##parm(starget) = parm; \
1053
nego = mptspi_getRP(starget); \
1055
pg1.RequestedParameters = cpu_to_le32(nego); \
1057
pg1.Configuration = 0; \
1059
mptspi_write_spi_device_pg1(starget, &pg1); \
1062
MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1063
MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1064
MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1065
MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1066
MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1068
static void mptspi_write_qas(struct scsi_target *starget, int qas)
1070
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1071
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1072
struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1073
VirtTarget *vtarget = starget->hostdata;
1076
if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1077
hd->ioc->spi_data.noQas)
1078
spi_qas(starget) = 0;
1080
spi_qas(starget) = qas;
1082
nego = mptspi_getRP(starget);
1084
pg1.RequestedParameters = cpu_to_le32(nego);
1086
pg1.Configuration = 0;
1088
mptspi_write_spi_device_pg1(starget, &pg1);
1091
static void mptspi_write_width(struct scsi_target *starget, int width)
1093
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1097
spi_dt(starget) = 0;
1098
if (spi_period(starget) < 10)
1099
spi_period(starget) = 10;
1102
spi_width(starget) = width;
1104
nego = mptspi_getRP(starget);
1106
pg1.RequestedParameters = cpu_to_le32(nego);
1108
pg1.Configuration = 0;
1110
mptspi_write_spi_device_pg1(starget, &pg1);
1113
struct work_queue_wrapper {
1114
struct work_struct work;
1115
struct _MPT_SCSI_HOST *hd;
1119
static void mpt_work_wrapper(struct work_struct *work)
1121
struct work_queue_wrapper *wqw =
1122
container_of(work, struct work_queue_wrapper, work);
1123
struct _MPT_SCSI_HOST *hd = wqw->hd;
1124
MPT_ADAPTER *ioc = hd->ioc;
1125
struct Scsi_Host *shost = ioc->sh;
1126
struct scsi_device *sdev;
1127
int disk = wqw->disk;
1128
struct _CONFIG_PAGE_IOC_3 *pg3;
1132
mpt_findImVolumes(ioc);
1133
pg3 = ioc->raid_data.pIocPg3;
1137
shost_for_each_device(sdev,shost) {
1138
struct scsi_target *starget = scsi_target(sdev);
1139
VirtTarget *vtarget = starget->hostdata;
1141
/* only want to search RAID components */
1142
if (sdev->channel != 1)
1145
/* The id is the raid PhysDiskNum, even if
1146
* starget->id is the actual target address */
1147
if(vtarget->id != disk)
1150
starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1151
"Integrated RAID requests DV of new device\n", ioc->name);
1152
mptspi_dv_device(hd, sdev);
1154
shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1155
"Integrated RAID detects new device %d\n", ioc->name, disk);
1156
scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1160
static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1162
struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1163
MPT_ADAPTER *ioc = hd->ioc;
1166
shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1167
"Failed to act on RAID event for physical disk %d\n",
1171
INIT_WORK(&wqw->work, mpt_work_wrapper);
1175
schedule_work(&wqw->work);
1179
mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1181
u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1182
struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1184
if (ioc->bus_type != SPI)
1187
if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1189
= (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1191
if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1192
int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1193
mpt_dv_raid(hd, disk);
1196
return mptscsih_event_process(ioc, pEvReply);
1200
mptspi_deny_binding(struct scsi_target *starget)
1202
struct _MPT_SCSI_HOST *hd =
1203
(struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1204
return ((mptspi_is_raid(hd, starget->id)) &&
1205
starget->channel == 0) ? 1 : 0;
1208
static struct spi_function_template mptspi_transport_functions = {
1209
.get_offset = mptspi_read_parameters,
1210
.set_offset = mptspi_write_offset,
1212
.get_period = mptspi_read_parameters,
1213
.set_period = mptspi_write_period,
1215
.get_width = mptspi_read_parameters,
1216
.set_width = mptspi_write_width,
1218
.get_iu = mptspi_read_parameters,
1219
.set_iu = mptspi_write_iu,
1221
.get_dt = mptspi_read_parameters,
1222
.set_dt = mptspi_write_dt,
1224
.get_qas = mptspi_read_parameters,
1225
.set_qas = mptspi_write_qas,
1227
.get_wr_flow = mptspi_read_parameters,
1228
.set_wr_flow = mptspi_write_wr_flow,
1230
.get_rd_strm = mptspi_read_parameters,
1231
.set_rd_strm = mptspi_write_rd_strm,
1233
.get_rti = mptspi_read_parameters,
1234
.set_rti = mptspi_write_rti,
1236
.get_pcomp_en = mptspi_read_parameters,
1237
.set_pcomp_en = mptspi_write_pcomp_en,
1239
.get_hold_mcs = mptspi_read_parameters,
1240
.set_hold_mcs = mptspi_write_hold_mcs,
1242
.deny_binding = mptspi_deny_binding,
1245
/****************************************************************************
1246
* Supported hardware
1249
static struct pci_device_id mptspi_pci_table[] = {
1250
{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1251
PCI_ANY_ID, PCI_ANY_ID },
1252
{ PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1253
PCI_ANY_ID, PCI_ANY_ID },
1254
{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1255
PCI_ANY_ID, PCI_ANY_ID },
1256
{0} /* Terminating entry */
1258
MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1262
* renegotiate for a given target
1265
mptspi_dv_renegotiate_work(struct work_struct *work)
1267
struct work_queue_wrapper *wqw =
1268
container_of(work, struct work_queue_wrapper, work);
1269
struct _MPT_SCSI_HOST *hd = wqw->hd;
1270
struct scsi_device *sdev;
1271
struct scsi_target *starget;
1272
struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1274
MPT_ADAPTER *ioc = hd->ioc;
1278
if (hd->spi_pending) {
1279
shost_for_each_device(sdev, ioc->sh) {
1280
if (hd->spi_pending & (1 << sdev->id))
1282
starget = scsi_target(sdev);
1283
nego = mptspi_getRP(starget);
1284
pg1.RequestedParameters = cpu_to_le32(nego);
1286
pg1.Configuration = 0;
1287
mptspi_write_spi_device_pg1(starget, &pg1);
1290
shost_for_each_device(sdev, ioc->sh)
1291
mptspi_dv_device(hd, sdev);
1296
mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1298
struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1303
INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1306
schedule_work(&wqw->work);
1310
* spi module reset handler
1313
mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1317
rc = mptscsih_ioc_reset(ioc, reset_phase);
1318
if ((ioc->bus_type != SPI) || (!rc))
1321
/* only try to do a renegotiation if we're properly set up
1322
* if we get an ioc fault on bringup, ioc->sh will be NULL */
1323
if (reset_phase == MPT_IOC_POST_RESET &&
1325
struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1327
mptspi_dv_renegotiate(hd);
1335
* spi module resume handler
1338
mptspi_resume(struct pci_dev *pdev)
1340
MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1341
struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1344
rc = mptscsih_resume(pdev);
1345
mptspi_dv_renegotiate(hd);
1351
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1352
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1354
* mptspi_probe - Installs scsi devices per bus.
1355
* @pdev: Pointer to pci_dev structure
1357
* Returns 0 for success, non-zero for failure.
1361
mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1363
struct Scsi_Host *sh;
1366
unsigned long flags;
1374
if ((r = mpt_attach(pdev,id)) != 0)
1377
ioc = pci_get_drvdata(pdev);
1378
ioc->DoneCtx = mptspiDoneCtx;
1379
ioc->TaskCtx = mptspiTaskCtx;
1380
ioc->InternalCtx = mptspiInternalCtx;
1382
/* Added sanity check on readiness of the MPT adapter.
1384
if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1385
printk(MYIOC_s_WARN_FMT
1386
"Skipping because it's not operational!\n",
1389
goto out_mptspi_probe;
1393
printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1396
goto out_mptspi_probe;
1399
/* Sanity check - ensure at least 1 port is INITIATOR capable
1402
for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1403
if (ioc->pfacts[ii].ProtocolFlags &
1404
MPI_PORTFACTS_PROTOCOL_INITIATOR)
1409
printk(MYIOC_s_WARN_FMT
1410
"Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1415
sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1418
printk(MYIOC_s_WARN_FMT
1419
"Unable to register controller with SCSI subsystem\n",
1422
goto out_mptspi_probe;
1425
spin_lock_irqsave(&ioc->FreeQlock, flags);
1427
/* Attach the SCSI Host to the IOC structure
1435
/* set 16 byte cdb's */
1436
sh->max_cmd_len = 16;
1438
/* Yikes! This is important!
1439
* Otherwise, by default, linux
1440
* only scans target IDs 0-7!
1441
* pfactsN->MaxDevices unreliable
1442
* (not supported in early
1443
* versions of the FW).
1444
* max_id = 1 + actual max id,
1445
* max_lun = 1 + actual last lun,
1448
sh->max_id = ioc->devices_per_bus;
1450
sh->max_lun = MPT_LAST_LUN + 1;
1452
* If RAID Firmware Detected, setup virtual channel
1454
if (ioc->ir_firmware)
1455
sh->max_channel = 1;
1457
sh->max_channel = 0;
1458
sh->this_id = ioc->pfacts[0].PortSCSIID;
1462
sh->unique_id = ioc->id;
1464
/* Verify that we won't exceed the maximum
1465
* number of chain buffers
1466
* We can optimize: ZZ = req_sz/sizeof(SGE)
1468
* numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1469
* + (req_sz - 64)/sizeof(SGE)
1470
* A slightly different algorithm is required for
1473
scale = ioc->req_sz/ioc->SGE_size;
1474
if (ioc->sg_addr_size == sizeof(u64)) {
1475
numSGE = (scale - 1) *
1476
(ioc->facts.MaxChainDepth-1) + scale +
1477
(ioc->req_sz - 60) / ioc->SGE_size;
1479
numSGE = 1 + (scale - 1) *
1480
(ioc->facts.MaxChainDepth-1) + scale +
1481
(ioc->req_sz - 64) / ioc->SGE_size;
1484
if (numSGE < sh->sg_tablesize) {
1485
/* Reset this value */
1486
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1487
"Resetting sg_tablesize to %d from %d\n",
1488
ioc->name, numSGE, sh->sg_tablesize));
1489
sh->sg_tablesize = numSGE;
1492
spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1494
hd = shost_priv(sh);
1497
/* SCSI needs scsi_cmnd lookup table!
1498
* (with size equal to req_depth*PtrSz!)
1500
ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1501
if (!ioc->ScsiLookup) {
1503
goto out_mptspi_probe;
1505
spin_lock_init(&ioc->scsi_lookup_lock);
1507
dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1508
ioc->name, ioc->ScsiLookup));
1510
ioc->spi_data.Saf_Te = mpt_saf_te;
1511
ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1515
ioc->spi_data.noQas = 0;
1517
hd->last_queue_full = 0;
1518
hd->spi_pending = 0;
1520
/* Some versions of the firmware don't support page 0; without
1521
* that we can't get the parameters */
1522
if (ioc->spi_data.sdp0length != 0)
1523
sh->transportt = mptspi_transport_template;
1525
error = scsi_add_host (sh, &ioc->pcidev->dev);
1527
dprintk(ioc, printk(MYIOC_s_ERR_FMT
1528
"scsi_add_host failed\n", ioc->name));
1529
goto out_mptspi_probe;
1533
* issue internal bus reset
1535
if (ioc->spi_data.bus_reset)
1536
mptscsih_IssueTaskMgmt(hd,
1537
MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1545
mptscsih_remove(pdev);
1549
static struct pci_driver mptspi_driver = {
1551
.id_table = mptspi_pci_table,
1552
.probe = mptspi_probe,
1553
.remove = __devexit_p(mptscsih_remove),
1554
.shutdown = mptscsih_shutdown,
1556
.suspend = mptscsih_suspend,
1557
.resume = mptspi_resume,
1561
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1563
* mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1565
* Returns 0 for success, non-zero for failure.
1572
show_mptmod_ver(my_NAME, my_VERSION);
1574
mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1575
if (!mptspi_transport_template)
1578
mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1579
"mptscsih_io_done");
1580
mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1581
"mptscsih_taskmgmt_complete");
1582
mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1583
MPTSPI_DRIVER, "mptscsih_scandv_complete");
1585
mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1586
mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1588
error = pci_register_driver(&mptspi_driver);
1590
spi_release_transport(mptspi_transport_template);
1595
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1596
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1598
* mptspi_exit - Unregisters MPT adapter(s)
1603
pci_unregister_driver(&mptspi_driver);
1605
mpt_reset_deregister(mptspiDoneCtx);
1606
mpt_event_deregister(mptspiDoneCtx);
1608
mpt_deregister(mptspiInternalCtx);
1609
mpt_deregister(mptspiTaskCtx);
1610
mpt_deregister(mptspiDoneCtx);
1611
spi_release_transport(mptspi_transport_template);
1614
module_init(mptspi_init);
1615
module_exit(mptspi_exit);