0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047 #include <linux/module.h>
0048 #include <linux/kernel.h>
0049 #include <linux/slab.h>
0050 #include <linux/init.h>
0051 #include <linux/errno.h>
0052 #include <linux/kdev_t.h>
0053 #include <linux/blkdev.h>
0054 #include <linux/delay.h> /* for mdelay */
0055 #include <linux/interrupt.h>
0056 #include <linux/reboot.h> /* notifier code */
0057 #include <linux/workqueue.h>
0058 #include <linux/raid_class.h>
0059
0060 #include <scsi/scsi.h>
0061 #include <scsi/scsi_cmnd.h>
0062 #include <scsi/scsi_device.h>
0063 #include <scsi/scsi_host.h>
0064 #include <scsi/scsi_tcq.h>
0065 #include <scsi/scsi_transport.h>
0066 #include <scsi/scsi_transport_spi.h>
0067 #include <scsi/scsi_dbg.h>
0068
0069 #include "mptbase.h"
0070 #include "mptscsih.h"
0071
0072
0073 #define my_NAME "Fusion MPT SPI Host driver"
0074 #define my_VERSION MPT_LINUX_VERSION_COMMON
0075 #define MYNAM "mptspi"
0076
0077 MODULE_AUTHOR(MODULEAUTHOR);
0078 MODULE_DESCRIPTION(my_NAME);
0079 MODULE_LICENSE("GPL");
0080 MODULE_VERSION(my_VERSION);
0081
0082
0083 static int mpt_saf_te = MPTSCSIH_SAF_TE;
0084 module_param(mpt_saf_te, int, 0);
0085 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
0086
0087 static void mptspi_write_offset(struct scsi_target *, int);
0088 static void mptspi_write_width(struct scsi_target *, int);
0089 static int mptspi_write_spi_device_pg1(struct scsi_target *,
0090 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
0091
0092 static struct scsi_transport_template *mptspi_transport_template = NULL;
0093
0094 static u8 mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
0095 static u8 mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
0096 static u8 mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS;
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107 static void
0108 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
0109 struct scsi_device *sdev)
0110 {
0111 MPT_ADAPTER *ioc = hd->ioc;
0112 SpiCfgData *pspi_data = &ioc->spi_data;
0113 int id = (int) target->id;
0114 int nvram;
0115 u8 width = MPT_NARROW;
0116 u8 factor = MPT_ASYNC;
0117 u8 offset = 0;
0118 u8 nfactor;
0119 u8 noQas = 1;
0120
0121 target->negoFlags = pspi_data->noQas;
0122
0123 if (sdev->scsi_level < SCSI_2) {
0124 width = 0;
0125 factor = MPT_ULTRA2;
0126 offset = pspi_data->maxSyncOffset;
0127 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
0128 } else {
0129 if (scsi_device_wide(sdev))
0130 width = 1;
0131
0132 if (scsi_device_sync(sdev)) {
0133 factor = pspi_data->minSyncFactor;
0134 if (!scsi_device_dt(sdev))
0135 factor = MPT_ULTRA2;
0136 else {
0137 if (!scsi_device_ius(sdev) &&
0138 !scsi_device_qas(sdev))
0139 factor = MPT_ULTRA160;
0140 else {
0141 factor = MPT_ULTRA320;
0142 if (scsi_device_qas(sdev)) {
0143 ddvprintk(ioc,
0144 printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
0145 "byte56=%02x on id=%d!\n", ioc->name,
0146 scsi_device_qas(sdev), id));
0147 noQas = 0;
0148 }
0149 if (sdev->type == TYPE_TAPE &&
0150 scsi_device_ius(sdev))
0151 target->negoFlags |= MPT_TAPE_NEGO_IDP;
0152 }
0153 }
0154 offset = pspi_data->maxSyncOffset;
0155
0156
0157
0158
0159
0160
0161
0162 if (target->raidVolume == 1)
0163 noQas = 0;
0164 } else {
0165 factor = MPT_ASYNC;
0166 offset = 0;
0167 }
0168 }
0169
0170 if (!sdev->tagged_supported)
0171 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
0172
0173
0174
0175 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
0176 nvram = pspi_data->nvram[id];
0177 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
0178
0179 if (width)
0180 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
0181
0182 if (offset > 0) {
0183
0184
0185
0186 if (nfactor) {
0187 if (nfactor < pspi_data->minSyncFactor )
0188 nfactor = pspi_data->minSyncFactor;
0189
0190 factor = max(factor, nfactor);
0191 if (factor == MPT_ASYNC)
0192 offset = 0;
0193 } else {
0194 offset = 0;
0195 factor = MPT_ASYNC;
0196 }
0197 } else {
0198 factor = MPT_ASYNC;
0199 }
0200 }
0201
0202
0203
0204 if ((!width) && (factor < MPT_ULTRA2))
0205 factor = MPT_ULTRA2;
0206
0207
0208
0209 target->minSyncFactor = factor;
0210 target->maxOffset = offset;
0211 target->maxWidth = width;
0212
0213 spi_min_period(scsi_target(sdev)) = factor;
0214 spi_max_offset(scsi_target(sdev)) = offset;
0215 spi_max_width(scsi_target(sdev)) = width;
0216
0217 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
0218
0219
0220
0221 if (!width)
0222 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
0223
0224 if (!offset)
0225 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
0226
0227 if ( factor > MPT_ULTRA320 )
0228 noQas = 0;
0229
0230 if (noQas && (pspi_data->noQas == 0)) {
0231 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
0232 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
0233
0234
0235
0236
0237 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
0238 "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
0239 }
0240 }
0241
0242
0243
0244
0245
0246
0247
0248
0249
0250
0251
0252
0253 static int
0254 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
0255 {
0256 MPT_ADAPTER *ioc = hd->ioc;
0257 Config_t *pReq;
0258 IOCPage4_t *IOCPage4Ptr;
0259 MPT_FRAME_HDR *mf;
0260 dma_addr_t dataDma;
0261 u32 flagsLength;
0262 int ii;
0263
0264
0265
0266 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
0267 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
0268 "writeIOCPage4 : no msg frames!\n",ioc->name));
0269 return -EAGAIN;
0270 }
0271
0272
0273
0274
0275 pReq = (Config_t *)mf;
0276
0277
0278
0279 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
0280 pReq->Reserved = 0;
0281 pReq->ChainOffset = 0;
0282 pReq->Function = MPI_FUNCTION_CONFIG;
0283 pReq->ExtPageLength = 0;
0284 pReq->ExtPageType = 0;
0285 pReq->MsgFlags = 0;
0286 for (ii=0; ii < 8; ii++) {
0287 pReq->Reserved2[ii] = 0;
0288 }
0289
0290 IOCPage4Ptr = ioc->spi_data.pIocPg4;
0291 dataDma = ioc->spi_data.IocPg4_dma;
0292 ii = IOCPage4Ptr->ActiveSEP++;
0293 IOCPage4Ptr->SEP[ii].SEPTargetID = id;
0294 IOCPage4Ptr->SEP[ii].SEPBus = channel;
0295 pReq->Header = IOCPage4Ptr->Header;
0296 pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
0297
0298
0299
0300 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
0301 (IOCPage4Ptr->Header.PageLength + ii) * 4;
0302
0303 ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
0304
0305 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
0306 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
0307 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
0308
0309 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
0310
0311 return 0;
0312 }
0313
0314
0315
0316
0317
0318
0319
0320
0321
0322
0323
0324
0325
0326
0327 static void
0328 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
0329 struct scsi_device *sdev)
0330 {
0331
0332
0333
0334
0335 if (sdev->inq_periph_qual != 0)
0336 return;
0337
0338 if (vtarget == NULL)
0339 return;
0340
0341 vtarget->type = sdev->type;
0342
0343 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
0344
0345
0346 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
0347 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
0348 }else if ((sdev->type == TYPE_PROCESSOR) &&
0349 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
0350 if (sdev->inquiry_len > 49 ) {
0351 if (sdev->inquiry[44] == 'S' &&
0352 sdev->inquiry[45] == 'A' &&
0353 sdev->inquiry[46] == 'F' &&
0354 sdev->inquiry[47] == '-' &&
0355 sdev->inquiry[48] == 'T' &&
0356 sdev->inquiry[49] == 'E' ) {
0357 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
0358 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
0359 }
0360 }
0361 }
0362 mptspi_setTargetNegoParms(hd, vtarget, sdev);
0363 }
0364
0365
0366
0367
0368
0369
0370
0371
0372
0373
0374
0375 static int
0376 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
0377 {
0378 int i, rc = 0;
0379 MPT_ADAPTER *ioc = hd->ioc;
0380
0381 if (!ioc->raid_data.pIocPg2)
0382 goto out;
0383
0384 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
0385 goto out;
0386 for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
0387 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
0388 rc = 1;
0389 goto out;
0390 }
0391 }
0392
0393 out:
0394 return rc;
0395 }
0396
0397 static int mptspi_target_alloc(struct scsi_target *starget)
0398 {
0399 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
0400 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0401 VirtTarget *vtarget;
0402 MPT_ADAPTER *ioc;
0403
0404 if (hd == NULL)
0405 return -ENODEV;
0406
0407 ioc = hd->ioc;
0408 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
0409 if (!vtarget)
0410 return -ENOMEM;
0411
0412 vtarget->ioc_id = ioc->id;
0413 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
0414 vtarget->id = (u8)starget->id;
0415 vtarget->channel = (u8)starget->channel;
0416 vtarget->starget = starget;
0417 starget->hostdata = vtarget;
0418
0419 if (starget->channel == 1) {
0420 if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
0421 return 0;
0422 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
0423
0424 vtarget->channel = 0;
0425
0426 vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
0427 starget->id);
0428 }
0429
0430 if (starget->channel == 0 &&
0431 mptspi_is_raid(hd, starget->id)) {
0432 vtarget->raidVolume = 1;
0433 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
0434 "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
0435 starget->id));
0436 }
0437
0438 if (ioc->spi_data.nvram &&
0439 ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
0440 u32 nvram = ioc->spi_data.nvram[starget->id];
0441 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
0442 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
0443 } else {
0444 spi_min_period(starget) = ioc->spi_data.minSyncFactor;
0445 spi_max_width(starget) = ioc->spi_data.maxBusWidth;
0446 }
0447 spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
0448
0449 spi_offset(starget) = 0;
0450 spi_period(starget) = 0xFF;
0451 mptspi_write_width(starget, 0);
0452
0453 return 0;
0454 }
0455
0456 static void
0457 mptspi_target_destroy(struct scsi_target *starget)
0458 {
0459 kfree(starget->hostdata);
0460 starget->hostdata = NULL;
0461 }
0462
0463
0464
0465
0466
0467
0468
0469
0470 static void
0471 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
0472 {
0473 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
0474 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
0475 hd->ioc->name, starget->id, ii,
0476 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
0477 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
0478 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
0479 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
0480 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
0481 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
0482 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
0483 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
0484 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
0485 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
0486 }
0487
0488
0489
0490
0491
0492
0493
0494
0495 static void
0496 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
0497 {
0498 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
0499 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
0500 hd->ioc->name, starget->id, ii,
0501 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
0502 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
0503 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
0504 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
0505 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
0506 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
0507 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
0508 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
0509 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
0510 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
0511 }
0512
0513 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
0514 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
0515 {
0516 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
0517 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0518 struct _MPT_ADAPTER *ioc = hd->ioc;
0519 struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
0520 dma_addr_t spi_dev_pg0_dma;
0521 int size;
0522 struct _x_config_parms cfg;
0523 struct _CONFIG_PAGE_HEADER hdr;
0524 int err = -EBUSY;
0525
0526
0527 if (starget->channel == 0 &&
0528 mptspi_is_raid(hd, starget->id))
0529 return -1;
0530
0531 size = ioc->spi_data.sdp0length * 4;
0532
0533
0534
0535
0536
0537
0538 spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
0539 if (spi_dev_pg0 == NULL) {
0540 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
0541 "dma_alloc_coherent for parameters failed\n", ioc->name);
0542 return -EINVAL;
0543 }
0544
0545 memset(&hdr, 0, sizeof(hdr));
0546
0547 hdr.PageVersion = ioc->spi_data.sdp0version;
0548 hdr.PageLength = ioc->spi_data.sdp0length;
0549 hdr.PageNumber = 0;
0550 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
0551
0552 memset(&cfg, 0, sizeof(cfg));
0553
0554 cfg.cfghdr.hdr = &hdr;
0555 cfg.physAddr = spi_dev_pg0_dma;
0556 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
0557 cfg.dir = 0;
0558 cfg.pageAddr = starget->id;
0559 cfg.timeout = 60;
0560
0561 if (mpt_config(ioc, &cfg)) {
0562 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
0563 goto out_free;
0564 }
0565 err = 0;
0566 memcpy(pass_pg0, spi_dev_pg0, size);
0567
0568 mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
0569
0570 out_free:
0571 dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
0572 return err;
0573 }
0574
0575 static u32 mptspi_getRP(struct scsi_target *starget)
0576 {
0577 u32 nego = 0;
0578
0579 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
0580 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
0581 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
0582 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
0583 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
0584 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
0585 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
0586 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
0587
0588 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
0589 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
0590 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
0591
0592 return nego;
0593 }
0594
0595 static void mptspi_read_parameters(struct scsi_target *starget)
0596 {
0597 int nego;
0598 struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
0599
0600 mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
0601
0602 nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
0603
0604 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
0605 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
0606 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
0607 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
0608 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
0609 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
0610 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
0611 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
0612 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
0613 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
0614 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
0615 }
0616
0617 static int
0618 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
0619 {
0620 MPT_ADAPTER *ioc = hd->ioc;
0621 MpiRaidActionRequest_t *pReq;
0622 MPT_FRAME_HDR *mf;
0623 int ret;
0624 unsigned long timeleft;
0625
0626 mutex_lock(&ioc->internal_cmds.mutex);
0627
0628
0629
0630 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
0631 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
0632 "%s: no msg frames!\n", ioc->name, __func__));
0633 ret = -EAGAIN;
0634 goto out;
0635 }
0636 pReq = (MpiRaidActionRequest_t *)mf;
0637 if (quiesce)
0638 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
0639 else
0640 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
0641 pReq->Reserved1 = 0;
0642 pReq->ChainOffset = 0;
0643 pReq->Function = MPI_FUNCTION_RAID_ACTION;
0644 pReq->VolumeID = id;
0645 pReq->VolumeBus = channel;
0646 pReq->PhysDiskNum = 0;
0647 pReq->MsgFlags = 0;
0648 pReq->Reserved2 = 0;
0649 pReq->ActionDataWord = 0;
0650
0651 ioc->add_sge((char *)&pReq->ActionDataSGE,
0652 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
0653
0654 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
0655 ioc->name, pReq->Action, channel, id));
0656
0657 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
0658 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
0659 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
0660 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
0661 ret = -ETIME;
0662 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
0663 ioc->name, __func__));
0664 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
0665 goto out;
0666 if (!timeleft) {
0667 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
0668 ioc->name, __func__);
0669 mpt_HardResetHandler(ioc, CAN_SLEEP);
0670 mpt_free_msg_frame(ioc, mf);
0671 }
0672 goto out;
0673 }
0674
0675 ret = ioc->internal_cmds.completion_code;
0676
0677 out:
0678 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
0679 mutex_unlock(&ioc->internal_cmds.mutex);
0680 return ret;
0681 }
0682
0683 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
0684 struct scsi_device *sdev)
0685 {
0686 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
0687 MPT_ADAPTER *ioc = hd->ioc;
0688
0689
0690 if (sdev->channel == 0 &&
0691 mptspi_is_raid(hd, sdev->id))
0692 return;
0693
0694
0695 if (sdev->channel == 1 &&
0696 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
0697 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
0698 "Integrated RAID quiesce failed\n", ioc->name);
0699 return;
0700 }
0701
0702 hd->spi_pending |= (1 << sdev->id);
0703 spi_dv_device(sdev);
0704 hd->spi_pending &= ~(1 << sdev->id);
0705
0706 if (sdev->channel == 1 &&
0707 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
0708 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
0709 "Integrated RAID resume failed\n", ioc->name);
0710
0711 mptspi_read_parameters(sdev->sdev_target);
0712 spi_display_xfer_agreement(sdev->sdev_target);
0713 mptspi_read_parameters(sdev->sdev_target);
0714 }
0715
0716 static int mptspi_slave_alloc(struct scsi_device *sdev)
0717 {
0718 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
0719 VirtTarget *vtarget;
0720 VirtDevice *vdevice;
0721 struct scsi_target *starget;
0722 MPT_ADAPTER *ioc = hd->ioc;
0723
0724 if (sdev->channel == 1 &&
0725 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
0726 return -ENXIO;
0727
0728 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
0729 if (!vdevice) {
0730 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
0731 ioc->name, sizeof(VirtDevice));
0732 return -ENOMEM;
0733 }
0734
0735 vdevice->lun = sdev->lun;
0736 sdev->hostdata = vdevice;
0737
0738 starget = scsi_target(sdev);
0739 vtarget = starget->hostdata;
0740 vdevice->vtarget = vtarget;
0741 vtarget->num_luns++;
0742
0743 if (sdev->channel == 1)
0744 sdev->no_uld_attach = 1;
0745
0746 return 0;
0747 }
0748
0749 static int mptspi_slave_configure(struct scsi_device *sdev)
0750 {
0751 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
0752 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
0753 int ret;
0754
0755 mptspi_initTarget(hd, vtarget, sdev);
0756
0757 ret = mptscsih_slave_configure(sdev);
0758
0759 if (ret)
0760 return ret;
0761
0762 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
0763 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
0764 sdev->id, spi_min_period(scsi_target(sdev)),
0765 spi_max_offset(scsi_target(sdev)),
0766 spi_max_width(scsi_target(sdev))));
0767
0768 if ((sdev->channel == 1 ||
0769 !(mptspi_is_raid(hd, sdev->id))) &&
0770 !spi_initial_dv(sdev->sdev_target))
0771 mptspi_dv_device(hd, sdev);
0772
0773 return 0;
0774 }
0775
0776 static int
0777 mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
0778 {
0779 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0780 VirtDevice *vdevice = SCpnt->device->hostdata;
0781 MPT_ADAPTER *ioc = hd->ioc;
0782
0783 if (!vdevice || !vdevice->vtarget) {
0784 SCpnt->result = DID_NO_CONNECT << 16;
0785 scsi_done(SCpnt);
0786 return 0;
0787 }
0788
0789 if (SCpnt->device->channel == 1 &&
0790 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
0791 SCpnt->result = DID_NO_CONNECT << 16;
0792 scsi_done(SCpnt);
0793 return 0;
0794 }
0795
0796 if (spi_dv_pending(scsi_target(SCpnt->device)))
0797 ddvprintk(ioc, scsi_print_command(SCpnt));
0798
0799 return mptscsih_qcmd(SCpnt);
0800 }
0801
0802 static void mptspi_slave_destroy(struct scsi_device *sdev)
0803 {
0804 struct scsi_target *starget = scsi_target(sdev);
0805 VirtTarget *vtarget = starget->hostdata;
0806 VirtDevice *vdevice = sdev->hostdata;
0807
0808
0809 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
0810 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0811
0812
0813 pg1.RequestedParameters = 0;
0814 pg1.Reserved = 0;
0815 pg1.Configuration = 0;
0816
0817 mptspi_write_spi_device_pg1(starget, &pg1);
0818 }
0819
0820 mptscsih_slave_destroy(sdev);
0821 }
0822
0823 static struct scsi_host_template mptspi_driver_template = {
0824 .module = THIS_MODULE,
0825 .proc_name = "mptspi",
0826 .show_info = mptscsih_show_info,
0827 .name = "MPT SPI Host",
0828 .info = mptscsih_info,
0829 .queuecommand = mptspi_qcmd,
0830 .target_alloc = mptspi_target_alloc,
0831 .slave_alloc = mptspi_slave_alloc,
0832 .slave_configure = mptspi_slave_configure,
0833 .target_destroy = mptspi_target_destroy,
0834 .slave_destroy = mptspi_slave_destroy,
0835 .change_queue_depth = mptscsih_change_queue_depth,
0836 .eh_abort_handler = mptscsih_abort,
0837 .eh_device_reset_handler = mptscsih_dev_reset,
0838 .eh_bus_reset_handler = mptscsih_bus_reset,
0839 .eh_host_reset_handler = mptscsih_host_reset,
0840 .bios_param = mptscsih_bios_param,
0841 .can_queue = MPT_SCSI_CAN_QUEUE,
0842 .this_id = -1,
0843 .sg_tablesize = MPT_SCSI_SG_DEPTH,
0844 .max_sectors = 8192,
0845 .cmd_per_lun = 7,
0846 .shost_groups = mptscsih_host_attr_groups,
0847 };
0848
0849 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
0850 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
0851 {
0852 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
0853 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
0854 struct _MPT_ADAPTER *ioc = hd->ioc;
0855 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
0856 dma_addr_t pg1_dma;
0857 int size;
0858 struct _x_config_parms cfg;
0859 struct _CONFIG_PAGE_HEADER hdr;
0860 int err = -EBUSY;
0861 u32 nego_parms;
0862 u32 period;
0863 struct scsi_device *sdev;
0864 int i;
0865
0866
0867 if (starget->channel == 0 &&
0868 mptspi_is_raid(hd, starget->id))
0869 return -1;
0870
0871 size = ioc->spi_data.sdp1length * 4;
0872
0873 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
0874 if (pg1 == NULL) {
0875 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
0876 "dma_alloc_coherent for parameters failed\n", ioc->name);
0877 return -EINVAL;
0878 }
0879
0880 memset(&hdr, 0, sizeof(hdr));
0881
0882 hdr.PageVersion = ioc->spi_data.sdp1version;
0883 hdr.PageLength = ioc->spi_data.sdp1length;
0884 hdr.PageNumber = 1;
0885 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
0886
0887 memset(&cfg, 0, sizeof(cfg));
0888
0889 cfg.cfghdr.hdr = &hdr;
0890 cfg.physAddr = pg1_dma;
0891 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
0892 cfg.dir = 1;
0893 cfg.pageAddr = starget->id;
0894
0895 memcpy(pg1, pass_pg1, size);
0896
0897 pg1->Header.PageVersion = hdr.PageVersion;
0898 pg1->Header.PageLength = hdr.PageLength;
0899 pg1->Header.PageNumber = hdr.PageNumber;
0900 pg1->Header.PageType = hdr.PageType;
0901
0902 nego_parms = le32_to_cpu(pg1->RequestedParameters);
0903 period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
0904 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
0905 if (period == 8) {
0906
0907 for (i = 0 ; i < 16; i++) {
0908 sdev = scsi_device_lookup_by_target(starget, i);
0909 if (sdev && sdev->type == TYPE_TAPE) {
0910 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
0911 "IDP:ON\n", ioc->name);
0912 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
0913 pg1->RequestedParameters =
0914 cpu_to_le32(nego_parms);
0915 break;
0916 }
0917 }
0918 }
0919
0920 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
0921
0922 if (mpt_config(ioc, &cfg)) {
0923 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
0924 "mpt_config failed\n", ioc->name);
0925 goto out_free;
0926 }
0927 err = 0;
0928
0929 out_free:
0930 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
0931 return err;
0932 }
0933
0934 static void mptspi_write_offset(struct scsi_target *starget, int offset)
0935 {
0936 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0937 u32 nego;
0938
0939 if (offset < 0)
0940 offset = 0;
0941
0942 if (offset > 255)
0943 offset = 255;
0944
0945 if (spi_offset(starget) == -1)
0946 mptspi_read_parameters(starget);
0947
0948 spi_offset(starget) = offset;
0949
0950 nego = mptspi_getRP(starget);
0951
0952 pg1.RequestedParameters = cpu_to_le32(nego);
0953 pg1.Reserved = 0;
0954 pg1.Configuration = 0;
0955
0956 mptspi_write_spi_device_pg1(starget, &pg1);
0957 }
0958
0959 static void mptspi_write_period(struct scsi_target *starget, int period)
0960 {
0961 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0962 u32 nego;
0963
0964 if (period < 8)
0965 period = 8;
0966
0967 if (period > 255)
0968 period = 255;
0969
0970 if (spi_period(starget) == -1)
0971 mptspi_read_parameters(starget);
0972
0973 if (period == 8) {
0974 spi_iu(starget) = 1;
0975 spi_dt(starget) = 1;
0976 } else if (period == 9) {
0977 spi_dt(starget) = 1;
0978 }
0979
0980 spi_period(starget) = period;
0981
0982 nego = mptspi_getRP(starget);
0983
0984 pg1.RequestedParameters = cpu_to_le32(nego);
0985 pg1.Reserved = 0;
0986 pg1.Configuration = 0;
0987
0988 mptspi_write_spi_device_pg1(starget, &pg1);
0989 }
0990
0991 static void mptspi_write_dt(struct scsi_target *starget, int dt)
0992 {
0993 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
0994 u32 nego;
0995
0996 if (spi_period(starget) == -1)
0997 mptspi_read_parameters(starget);
0998
0999 if (!dt && spi_period(starget) < 10)
1000 spi_period(starget) = 10;
1001
1002 spi_dt(starget) = dt;
1003
1004 nego = mptspi_getRP(starget);
1005
1006
1007 pg1.RequestedParameters = cpu_to_le32(nego);
1008 pg1.Reserved = 0;
1009 pg1.Configuration = 0;
1010
1011 mptspi_write_spi_device_pg1(starget, &pg1);
1012 }
1013
1014 static void mptspi_write_iu(struct scsi_target *starget, int iu)
1015 {
1016 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1017 u32 nego;
1018
1019 if (spi_period(starget) == -1)
1020 mptspi_read_parameters(starget);
1021
1022 if (!iu && spi_period(starget) < 9)
1023 spi_period(starget) = 9;
1024
1025 spi_iu(starget) = iu;
1026
1027 nego = mptspi_getRP(starget);
1028
1029 pg1.RequestedParameters = cpu_to_le32(nego);
1030 pg1.Reserved = 0;
1031 pg1.Configuration = 0;
1032
1033 mptspi_write_spi_device_pg1(starget, &pg1);
1034 }
1035
1036 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1037 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1038 { \
1039 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1040 u32 nego; \
1041 \
1042 spi_##parm(starget) = parm; \
1043 \
1044 nego = mptspi_getRP(starget); \
1045 \
1046 pg1.RequestedParameters = cpu_to_le32(nego); \
1047 pg1.Reserved = 0; \
1048 pg1.Configuration = 0; \
1049 \
1050 mptspi_write_spi_device_pg1(starget, &pg1); \
1051 }
1052
1053 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1054 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1055 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1056 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1057 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1058
1059 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1060 {
1061 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1062 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1063 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1064 VirtTarget *vtarget = starget->hostdata;
1065 u32 nego;
1066
1067 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1068 hd->ioc->spi_data.noQas)
1069 spi_qas(starget) = 0;
1070 else
1071 spi_qas(starget) = qas;
1072
1073 nego = mptspi_getRP(starget);
1074
1075 pg1.RequestedParameters = cpu_to_le32(nego);
1076 pg1.Reserved = 0;
1077 pg1.Configuration = 0;
1078
1079 mptspi_write_spi_device_pg1(starget, &pg1);
1080 }
1081
1082 static void mptspi_write_width(struct scsi_target *starget, int width)
1083 {
1084 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1085 u32 nego;
1086
1087 if (!width) {
1088 spi_dt(starget) = 0;
1089 if (spi_period(starget) < 10)
1090 spi_period(starget) = 10;
1091 }
1092
1093 spi_width(starget) = width;
1094
1095 nego = mptspi_getRP(starget);
1096
1097 pg1.RequestedParameters = cpu_to_le32(nego);
1098 pg1.Reserved = 0;
1099 pg1.Configuration = 0;
1100
1101 mptspi_write_spi_device_pg1(starget, &pg1);
1102 }
1103
1104 struct work_queue_wrapper {
1105 struct work_struct work;
1106 struct _MPT_SCSI_HOST *hd;
1107 int disk;
1108 };
1109
1110 static void mpt_work_wrapper(struct work_struct *work)
1111 {
1112 struct work_queue_wrapper *wqw =
1113 container_of(work, struct work_queue_wrapper, work);
1114 struct _MPT_SCSI_HOST *hd = wqw->hd;
1115 MPT_ADAPTER *ioc = hd->ioc;
1116 struct Scsi_Host *shost = ioc->sh;
1117 struct scsi_device *sdev;
1118 int disk = wqw->disk;
1119 struct _CONFIG_PAGE_IOC_3 *pg3;
1120
1121 kfree(wqw);
1122
1123 mpt_findImVolumes(ioc);
1124 pg3 = ioc->raid_data.pIocPg3;
1125 if (!pg3)
1126 return;
1127
1128 shost_for_each_device(sdev,shost) {
1129 struct scsi_target *starget = scsi_target(sdev);
1130 VirtTarget *vtarget = starget->hostdata;
1131
1132
1133 if (sdev->channel != 1)
1134 continue;
1135
1136
1137
1138 if(vtarget->id != disk)
1139 continue;
1140
1141 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1142 "Integrated RAID requests DV of new device\n", ioc->name);
1143 mptspi_dv_device(hd, sdev);
1144 }
1145 shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1146 "Integrated RAID detects new device %d\n", ioc->name, disk);
1147 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, SCSI_SCAN_RESCAN);
1148 }
1149
1150
1151 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1152 {
1153 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1154 MPT_ADAPTER *ioc = hd->ioc;
1155
1156 if (!wqw) {
1157 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1158 "Failed to act on RAID event for physical disk %d\n",
1159 ioc->name, disk);
1160 return;
1161 }
1162 INIT_WORK(&wqw->work, mpt_work_wrapper);
1163 wqw->hd = hd;
1164 wqw->disk = disk;
1165
1166 schedule_work(&wqw->work);
1167 }
1168
1169 static int
1170 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1171 {
1172 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1173 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1174
1175 if (ioc->bus_type != SPI)
1176 return 0;
1177
1178 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1179 int reason
1180 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1181
1182 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1183 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1184 mpt_dv_raid(hd, disk);
1185 }
1186 }
1187 return mptscsih_event_process(ioc, pEvReply);
1188 }
1189
1190 static int
1191 mptspi_deny_binding(struct scsi_target *starget)
1192 {
1193 struct _MPT_SCSI_HOST *hd =
1194 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1195 return ((mptspi_is_raid(hd, starget->id)) &&
1196 starget->channel == 0) ? 1 : 0;
1197 }
1198
1199 static struct spi_function_template mptspi_transport_functions = {
1200 .get_offset = mptspi_read_parameters,
1201 .set_offset = mptspi_write_offset,
1202 .show_offset = 1,
1203 .get_period = mptspi_read_parameters,
1204 .set_period = mptspi_write_period,
1205 .show_period = 1,
1206 .get_width = mptspi_read_parameters,
1207 .set_width = mptspi_write_width,
1208 .show_width = 1,
1209 .get_iu = mptspi_read_parameters,
1210 .set_iu = mptspi_write_iu,
1211 .show_iu = 1,
1212 .get_dt = mptspi_read_parameters,
1213 .set_dt = mptspi_write_dt,
1214 .show_dt = 1,
1215 .get_qas = mptspi_read_parameters,
1216 .set_qas = mptspi_write_qas,
1217 .show_qas = 1,
1218 .get_wr_flow = mptspi_read_parameters,
1219 .set_wr_flow = mptspi_write_wr_flow,
1220 .show_wr_flow = 1,
1221 .get_rd_strm = mptspi_read_parameters,
1222 .set_rd_strm = mptspi_write_rd_strm,
1223 .show_rd_strm = 1,
1224 .get_rti = mptspi_read_parameters,
1225 .set_rti = mptspi_write_rti,
1226 .show_rti = 1,
1227 .get_pcomp_en = mptspi_read_parameters,
1228 .set_pcomp_en = mptspi_write_pcomp_en,
1229 .show_pcomp_en = 1,
1230 .get_hold_mcs = mptspi_read_parameters,
1231 .set_hold_mcs = mptspi_write_hold_mcs,
1232 .show_hold_mcs = 1,
1233 .deny_binding = mptspi_deny_binding,
1234 };
1235
1236
1237
1238
1239
1240 static struct pci_device_id mptspi_pci_table[] = {
1241 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1242 PCI_ANY_ID, PCI_ANY_ID },
1243 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1244 PCI_ANY_ID, PCI_ANY_ID },
1245 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1246 PCI_ANY_ID, PCI_ANY_ID },
1247 {0}
1248 };
1249 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1250
1251
1252
1253
1254
1255 static void
1256 mptspi_dv_renegotiate_work(struct work_struct *work)
1257 {
1258 struct work_queue_wrapper *wqw =
1259 container_of(work, struct work_queue_wrapper, work);
1260 struct _MPT_SCSI_HOST *hd = wqw->hd;
1261 struct scsi_device *sdev;
1262 struct scsi_target *starget;
1263 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1264 u32 nego;
1265 MPT_ADAPTER *ioc = hd->ioc;
1266
1267 kfree(wqw);
1268
1269 if (hd->spi_pending) {
1270 shost_for_each_device(sdev, ioc->sh) {
1271 if (hd->spi_pending & (1 << sdev->id))
1272 continue;
1273 starget = scsi_target(sdev);
1274 nego = mptspi_getRP(starget);
1275 pg1.RequestedParameters = cpu_to_le32(nego);
1276 pg1.Reserved = 0;
1277 pg1.Configuration = 0;
1278 mptspi_write_spi_device_pg1(starget, &pg1);
1279 }
1280 } else {
1281 shost_for_each_device(sdev, ioc->sh)
1282 mptspi_dv_device(hd, sdev);
1283 }
1284 }
1285
1286 static void
1287 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1288 {
1289 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1290
1291 if (!wqw)
1292 return;
1293
1294 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1295 wqw->hd = hd;
1296
1297 schedule_work(&wqw->work);
1298 }
1299
1300
1301
1302
1303 static int
1304 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1305 {
1306 int rc;
1307
1308 rc = mptscsih_ioc_reset(ioc, reset_phase);
1309 if ((ioc->bus_type != SPI) || (!rc))
1310 return rc;
1311
1312
1313
1314 if (reset_phase == MPT_IOC_POST_RESET &&
1315 ioc->sh) {
1316 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1317
1318 mptspi_dv_renegotiate(hd);
1319 }
1320
1321 return rc;
1322 }
1323
1324 #ifdef CONFIG_PM
1325
1326
1327
1328 static int
1329 mptspi_resume(struct pci_dev *pdev)
1330 {
1331 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1332 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1333 int rc;
1334
1335 rc = mptscsih_resume(pdev);
1336 mptspi_dv_renegotiate(hd);
1337
1338 return rc;
1339 }
1340 #endif
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351 static int
1352 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1353 {
1354 struct Scsi_Host *sh;
1355 MPT_SCSI_HOST *hd;
1356 MPT_ADAPTER *ioc;
1357 unsigned long flags;
1358 int ii;
1359 int numSGE = 0;
1360 int scale;
1361 int ioc_cap;
1362 int error=0;
1363 int r;
1364
1365 if ((r = mpt_attach(pdev,id)) != 0)
1366 return r;
1367
1368 ioc = pci_get_drvdata(pdev);
1369 ioc->DoneCtx = mptspiDoneCtx;
1370 ioc->TaskCtx = mptspiTaskCtx;
1371 ioc->InternalCtx = mptspiInternalCtx;
1372
1373
1374
1375 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1376 printk(MYIOC_s_WARN_FMT
1377 "Skipping because it's not operational!\n",
1378 ioc->name);
1379 error = -ENODEV;
1380 goto out_mptspi_probe;
1381 }
1382
1383 if (!ioc->active) {
1384 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1385 ioc->name);
1386 error = -ENODEV;
1387 goto out_mptspi_probe;
1388 }
1389
1390
1391
1392 ioc_cap = 0;
1393 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1394 if (ioc->pfacts[ii].ProtocolFlags &
1395 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1396 ioc_cap ++;
1397 }
1398
1399 if (!ioc_cap) {
1400 printk(MYIOC_s_WARN_FMT
1401 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1402 ioc->name, ioc);
1403 return 0;
1404 }
1405
1406 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1407
1408 if (!sh) {
1409 printk(MYIOC_s_WARN_FMT
1410 "Unable to register controller with SCSI subsystem\n",
1411 ioc->name);
1412 error = -1;
1413 goto out_mptspi_probe;
1414 }
1415
1416
1417
1418 if (pdev->subsystem_vendor == 0x15AD)
1419 sh->no_write_same = 1;
1420
1421 spin_lock_irqsave(&ioc->FreeQlock, flags);
1422
1423
1424
1425 ioc->sh = sh;
1426
1427 sh->io_port = 0;
1428 sh->n_io_port = 0;
1429 sh->irq = 0;
1430
1431
1432 sh->max_cmd_len = 16;
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444 sh->max_id = ioc->devices_per_bus;
1445
1446 sh->max_lun = MPT_LAST_LUN + 1;
1447
1448
1449
1450 if (ioc->ir_firmware)
1451 sh->max_channel = 1;
1452 else
1453 sh->max_channel = 0;
1454 sh->this_id = ioc->pfacts[0].PortSCSIID;
1455
1456
1457
1458 sh->unique_id = ioc->id;
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469 scale = ioc->req_sz/ioc->SGE_size;
1470 if (ioc->sg_addr_size == sizeof(u64)) {
1471 numSGE = (scale - 1) *
1472 (ioc->facts.MaxChainDepth-1) + scale +
1473 (ioc->req_sz - 60) / ioc->SGE_size;
1474 } else {
1475 numSGE = 1 + (scale - 1) *
1476 (ioc->facts.MaxChainDepth-1) + scale +
1477 (ioc->req_sz - 64) / ioc->SGE_size;
1478 }
1479
1480 if (numSGE < sh->sg_tablesize) {
1481
1482 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1483 "Resetting sg_tablesize to %d from %d\n",
1484 ioc->name, numSGE, sh->sg_tablesize));
1485 sh->sg_tablesize = numSGE;
1486 }
1487
1488 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1489
1490 hd = shost_priv(sh);
1491 hd->ioc = ioc;
1492
1493
1494
1495
1496 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_KERNEL);
1497 if (!ioc->ScsiLookup) {
1498 error = -ENOMEM;
1499 goto out_mptspi_probe;
1500 }
1501 spin_lock_init(&ioc->scsi_lookup_lock);
1502
1503 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1504 ioc->name, ioc->ScsiLookup));
1505
1506 ioc->spi_data.Saf_Te = mpt_saf_te;
1507 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1508 "saf_te %x\n",
1509 ioc->name,
1510 mpt_saf_te));
1511 ioc->spi_data.noQas = 0;
1512
1513 hd->last_queue_full = 0;
1514 hd->spi_pending = 0;
1515
1516
1517
1518 if (ioc->spi_data.sdp0length != 0)
1519 sh->transportt = mptspi_transport_template;
1520
1521 error = scsi_add_host (sh, &ioc->pcidev->dev);
1522 if(error) {
1523 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1524 "scsi_add_host failed\n", ioc->name));
1525 goto out_mptspi_probe;
1526 }
1527
1528
1529
1530
1531 if (ioc->spi_data.bus_reset)
1532 mptscsih_IssueTaskMgmt(hd,
1533 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1534 0, 0, 0, 0, 5);
1535
1536 scsi_scan_host(sh);
1537 return 0;
1538
1539 out_mptspi_probe:
1540
1541 mptscsih_remove(pdev);
1542 return error;
1543 }
1544
1545 static void mptspi_remove(struct pci_dev *pdev)
1546 {
1547 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1548
1549 scsi_remove_host(ioc->sh);
1550 mptscsih_remove(pdev);
1551 }
1552
1553 static struct pci_driver mptspi_driver = {
1554 .name = "mptspi",
1555 .id_table = mptspi_pci_table,
1556 .probe = mptspi_probe,
1557 .remove = mptspi_remove,
1558 .shutdown = mptscsih_shutdown,
1559 #ifdef CONFIG_PM
1560 .suspend = mptscsih_suspend,
1561 .resume = mptspi_resume,
1562 #endif
1563 };
1564
1565
1566
1567
1568
1569
1570
1571 static int __init
1572 mptspi_init(void)
1573 {
1574 int error;
1575
1576 show_mptmod_ver(my_NAME, my_VERSION);
1577
1578 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1579 if (!mptspi_transport_template)
1580 return -ENODEV;
1581
1582 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1583 "mptscsih_io_done");
1584 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1585 "mptscsih_taskmgmt_complete");
1586 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1587 MPTSPI_DRIVER, "mptscsih_scandv_complete");
1588
1589 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1590 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1591
1592 error = pci_register_driver(&mptspi_driver);
1593 if (error)
1594 spi_release_transport(mptspi_transport_template);
1595
1596 return error;
1597 }
1598
1599
1600
1601
1602
1603
1604 static void __exit
1605 mptspi_exit(void)
1606 {
1607 pci_unregister_driver(&mptspi_driver);
1608
1609 mpt_reset_deregister(mptspiDoneCtx);
1610 mpt_event_deregister(mptspiDoneCtx);
1611
1612 mpt_deregister(mptspiInternalCtx);
1613 mpt_deregister(mptspiTaskCtx);
1614 mpt_deregister(mptspiDoneCtx);
1615 spi_release_transport(mptspi_transport_template);
1616 }
1617
1618 module_init(mptspi_init);
1619 module_exit(mptspi_exit);