1 /* 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. 5 * 6 * Copyright (c) 1999-2008 LSI Corporation 7 * (mailto:DL-MPTFusionLinux@lsi.com) 8 * 9 */ 10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 11 /* 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. 15 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. 20 21 NO WARRANTY 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. 31 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 40 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 44 */ 45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 46 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> 56 #include <linux/reboot.h> /* notifier code */ 57 #include <linux/workqueue.h> 58 #include <linux/raid_class.h> 59 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> 68 69 #include "mptbase.h" 70 #include "mptscsih.h" 71 72 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 73 #define my_NAME "Fusion MPT SPI Host driver" 74 #define my_VERSION MPT_LINUX_VERSION_COMMON 75 #define MYNAM "mptspi" 76 77 MODULE_AUTHOR(MODULEAUTHOR); 78 MODULE_DESCRIPTION(my_NAME); 79 MODULE_LICENSE("GPL"); 80 MODULE_VERSION(my_VERSION); 81 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)"); 86 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 *); 91 92 static struct scsi_transport_template *mptspi_transport_template = NULL; 93 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 */ 97 98 /** 99 * mptspi_setTargetNegoParms - Update the target negotiation parameters 100 * @hd: Pointer to a SCSI Host Structure 101 * @target: per target private data 102 * @sdev: SCSI device 103 * 104 * Update the target negotiation parameters based on the the Inquiry 105 * data, adapter capabilities, and NVRAM settings. 106 **/ 107 static void 108 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target, 109 struct scsi_device *sdev) 110 { 111 MPT_ADAPTER *ioc = hd->ioc; 112 SpiCfgData *pspi_data = &ioc->spi_data; 113 int id = (int) target->id; 114 int nvram; 115 u8 width = MPT_NARROW; 116 u8 factor = MPT_ASYNC; 117 u8 offset = 0; 118 u8 nfactor; 119 u8 noQas = 1; 120 121 target->negoFlags = pspi_data->noQas; 122 123 if (sdev->scsi_level < SCSI_2) { 124 width = 0; 125 factor = MPT_ULTRA2; 126 offset = pspi_data->maxSyncOffset; 127 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES; 128 } else { 129 if (scsi_device_wide(sdev)) 130 width = 1; 131 132 if (scsi_device_sync(sdev)) { 133 factor = pspi_data->minSyncFactor; 134 if (!scsi_device_dt(sdev)) 135 factor = MPT_ULTRA2; 136 else { 137 if (!scsi_device_ius(sdev) && 138 !scsi_device_qas(sdev)) 139 factor = MPT_ULTRA160; 140 else { 141 factor = MPT_ULTRA320; 142 if (scsi_device_qas(sdev)) { 143 ddvprintk(ioc, 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)); 147 noQas = 0; 148 } 149 if (sdev->type == TYPE_TAPE && 150 scsi_device_ius(sdev)) 151 target->negoFlags |= MPT_TAPE_NEGO_IDP; 152 } 153 } 154 offset = pspi_data->maxSyncOffset; 155 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 160 * bit 0 IU support 161 */ 162 if (target->raidVolume == 1) 163 noQas = 0; 164 } else { 165 factor = MPT_ASYNC; 166 offset = 0; 167 } 168 } 169 170 if (!sdev->tagged_supported) 171 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES; 172 173 /* Update tflags based on NVRAM settings. (SCSI only) 174 */ 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; 178 179 if (width) 180 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1; 181 182 if (offset > 0) { 183 /* Ensure factor is set to the 184 * maximum of: adapter, nvram, inquiry 185 */ 186 if (nfactor) { 187 if (nfactor < pspi_data->minSyncFactor ) 188 nfactor = pspi_data->minSyncFactor; 189 190 factor = max(factor, nfactor); 191 if (factor == MPT_ASYNC) 192 offset = 0; 193 } else { 194 offset = 0; 195 factor = MPT_ASYNC; 196 } 197 } else { 198 factor = MPT_ASYNC; 199 } 200 } 201 202 /* Make sure data is consistent 203 */ 204 if ((!width) && (factor < MPT_ULTRA2)) 205 factor = MPT_ULTRA2; 206 207 /* Save the data to the target structure. 208 */ 209 target->minSyncFactor = factor; 210 target->maxOffset = offset; 211 target->maxWidth = width; 212 213 spi_min_period(scsi_target(sdev)) = factor; 214 spi_max_offset(scsi_target(sdev)) = offset; 215 spi_max_width(scsi_target(sdev)) = width; 216 217 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO; 218 219 /* Disable unused features. 220 */ 221 if (!width) 222 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE; 223 224 if (!offset) 225 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC; 226 227 if ( factor > MPT_ULTRA320 ) 228 noQas = 0; 229 230 if (noQas && (pspi_data->noQas == 0)) { 231 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS; 232 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS; 233 234 /* Disable QAS in a mixed configuration case 235 */ 236 237 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT 238 "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id)); 239 } 240 } 241 242 /** 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 247 * 248 * Return: -EAGAIN if unable to obtain a Message Frame 249 * or 0 if success. 250 * 251 * Remark: We do not wait for a return, write pages sequentially. 252 **/ 253 static int 254 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id) 255 { 256 MPT_ADAPTER *ioc = hd->ioc; 257 Config_t *pReq; 258 IOCPage4_t *IOCPage4Ptr; 259 MPT_FRAME_HDR *mf; 260 dma_addr_t dataDma; 261 u32 flagsLength; 262 int ii; 263 264 /* Get a MF for this command. 265 */ 266 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) { 267 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT 268 "writeIOCPage4 : no msg frames!\n",ioc->name)); 269 return -EAGAIN; 270 } 271 272 /* Set the request and the data pointers. 273 * Place data at end of MF. 274 */ 275 pReq = (Config_t *)mf; 276 277 /* Complete the request frame (same for all requests). 278 */ 279 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 280 pReq->Reserved = 0; 281 pReq->ChainOffset = 0; 282 pReq->Function = MPI_FUNCTION_CONFIG; 283 pReq->ExtPageLength = 0; 284 pReq->ExtPageType = 0; 285 pReq->MsgFlags = 0; 286 for (ii=0; ii < 8; ii++) { 287 pReq->Reserved2[ii] = 0; 288 } 289 290 IOCPage4Ptr = ioc->spi_data.pIocPg4; 291 dataDma = ioc->spi_data.IocPg4_dma; 292 ii = IOCPage4Ptr->ActiveSEP++; 293 IOCPage4Ptr->SEP[ii].SEPTargetID = id; 294 IOCPage4Ptr->SEP[ii].SEPBus = channel; 295 pReq->Header = IOCPage4Ptr->Header; 296 pReq->PageAddress = cpu_to_le32(id | (channel << 8 )); 297 298 /* Add a SGE to the config request. 299 */ 300 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE | 301 (IOCPage4Ptr->Header.PageLength + ii) * 4; 302 303 ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma); 304 305 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT 306 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n", 307 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel)); 308 309 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf); 310 311 return 0; 312 } 313 314 /** 315 * mptspi_initTarget - Target, LUN alloc/free functionality. 316 * @hd: Pointer to MPT_SCSI_HOST structure 317 * @vtarget: per target private data 318 * @sdev: SCSI device 319 * 320 * NOTE: It's only SAFE to call this routine if data points to 321 * sane & valid STANDARD INQUIRY data! 322 * 323 * Allocate and initialize memory for this target. 324 * Save inquiry data. 325 * 326 **/ 327 static void 328 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, 329 struct scsi_device *sdev) 330 { 331 332 /* Is LUN supported? If so, upper 2 bits will be 0 333 * in first byte of inquiry data. 334 */ 335 if (sdev->inq_periph_qual != 0) 336 return; 337 338 if (vtarget == NULL) 339 return; 340 341 vtarget->type = sdev->type; 342 343 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) { 344 /* Treat all Processors as SAF-TE if 345 * command line option is set */ 346 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; 347 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id); 348 }else if ((sdev->type == TYPE_PROCESSOR) && 349 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) { 350 if (sdev->inquiry_len > 49 ) { 351 if (sdev->inquiry[44] == 'S' && 352 sdev->inquiry[45] == 'A' && 353 sdev->inquiry[46] == 'F' && 354 sdev->inquiry[47] == '-' && 355 sdev->inquiry[48] == 'T' && 356 sdev->inquiry[49] == 'E' ) { 357 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; 358 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id); 359 } 360 } 361 } 362 mptspi_setTargetNegoParms(hd, vtarget, sdev); 363 } 364 365 /** 366 * mptspi_is_raid - Determines whether target is belonging to volume 367 * @hd: Pointer to a SCSI HOST structure 368 * @id: target device id 369 * 370 * Return: 371 * non-zero = true 372 * zero = false 373 * 374 */ 375 static int 376 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id) 377 { 378 int i, rc = 0; 379 MPT_ADAPTER *ioc = hd->ioc; 380 381 if (!ioc->raid_data.pIocPg2) 382 goto out; 383 384 if (!ioc->raid_data.pIocPg2->NumActiveVolumes) 385 goto out; 386 for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 387 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) { 388 rc = 1; 389 goto out; 390 } 391 } 392 393 out: 394 return rc; 395 } 396 397 static int mptspi_target_alloc(struct scsi_target *starget) 398 { 399 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 400 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 401 VirtTarget *vtarget; 402 MPT_ADAPTER *ioc; 403 404 if (hd == NULL) 405 return -ENODEV; 406 407 ioc = hd->ioc; 408 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL); 409 if (!vtarget) 410 return -ENOMEM; 411 412 vtarget->ioc_id = ioc->id; 413 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES; 414 vtarget->id = (u8)starget->id; 415 vtarget->channel = (u8)starget->channel; 416 vtarget->starget = starget; 417 starget->hostdata = vtarget; 418 419 if (starget->channel == 1) { 420 if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0) 421 return 0; 422 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT; 423 /* The real channel for this device is zero */ 424 vtarget->channel = 0; 425 /* The actual physdisknum (for RAID passthrough) */ 426 vtarget->id = mptscsih_raid_id_to_num(ioc, 0, 427 starget->id); 428 } 429 430 if (starget->channel == 0 && 431 mptspi_is_raid(hd, starget->id)) { 432 vtarget->raidVolume = 1; 433 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT 434 "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel, 435 starget->id)); 436 } 437 438 if (ioc->spi_data.nvram && 439 ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) { 440 u32 nvram = ioc->spi_data.nvram[starget->id]; 441 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT; 442 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1; 443 } else { 444 spi_min_period(starget) = ioc->spi_data.minSyncFactor; 445 spi_max_width(starget) = ioc->spi_data.maxBusWidth; 446 } 447 spi_max_offset(starget) = ioc->spi_data.maxSyncOffset; 448 449 spi_offset(starget) = 0; 450 spi_period(starget) = 0xFF; 451 mptspi_write_width(starget, 0); 452 453 return 0; 454 } 455 456 static void 457 mptspi_target_destroy(struct scsi_target *starget) 458 { 459 kfree(starget->hostdata); 460 starget->hostdata = NULL; 461 } 462 463 /** 464 * mptspi_print_write_nego - negotiation parameters debug info that is being sent 465 * @hd: Pointer to a SCSI HOST structure 466 * @starget: SCSI target 467 * @ii: negotiation parameters 468 * 469 */ 470 static void 471 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii) 472 { 473 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x" 474 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n", 475 hd->ioc->name, starget->id, ii, 476 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "", 477 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF), 478 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "", 479 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "", 480 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "", 481 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "", 482 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "", 483 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "", 484 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "", 485 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "")); 486 } 487 488 /** 489 * mptspi_print_read_nego - negotiation parameters debug info that is being read 490 * @hd: Pointer to a SCSI HOST structure 491 * @starget: SCSI target 492 * @ii: negotiation parameters 493 * 494 */ 495 static void 496 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii) 497 { 498 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x" 499 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n", 500 hd->ioc->name, starget->id, ii, 501 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "", 502 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF), 503 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "", 504 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "", 505 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "", 506 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "", 507 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "", 508 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "", 509 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "", 510 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "")); 511 } 512 513 static int mptspi_read_spi_device_pg0(struct scsi_target *starget, 514 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0) 515 { 516 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 517 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 518 struct _MPT_ADAPTER *ioc = hd->ioc; 519 struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0; 520 dma_addr_t spi_dev_pg0_dma; 521 int size; 522 struct _x_config_parms cfg; 523 struct _CONFIG_PAGE_HEADER hdr; 524 int err = -EBUSY; 525 526 /* No SPI parameters for RAID devices */ 527 if (starget->channel == 0 && 528 mptspi_is_raid(hd, starget->id)) 529 return -1; 530 531 size = ioc->spi_data.sdp0length * 4; 532 /* 533 if (ioc->spi_data.sdp0length & 1) 534 size += size + 4; 535 size += 2048; 536 */ 537 538 spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL); 539 if (spi_dev_pg0 == NULL) { 540 starget_printk(KERN_ERR, starget, MYIOC_s_FMT 541 "dma_alloc_coherent for parameters failed\n", ioc->name); 542 return -EINVAL; 543 } 544 545 memset(&hdr, 0, sizeof(hdr)); 546 547 hdr.PageVersion = ioc->spi_data.sdp0version; 548 hdr.PageLength = ioc->spi_data.sdp0length; 549 hdr.PageNumber = 0; 550 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 551 552 memset(&cfg, 0, sizeof(cfg)); 553 554 cfg.cfghdr.hdr = &hdr; 555 cfg.physAddr = spi_dev_pg0_dma; 556 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 557 cfg.dir = 0; 558 cfg.pageAddr = starget->id; 559 cfg.timeout = 60; 560 561 if (mpt_config(ioc, &cfg)) { 562 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name); 563 goto out_free; 564 } 565 err = 0; 566 memcpy(pass_pg0, spi_dev_pg0, size); 567 568 mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters)); 569 570 out_free: 571 dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma); 572 return err; 573 } 574 575 static u32 mptspi_getRP(struct scsi_target *starget) 576 { 577 u32 nego = 0; 578 579 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0; 580 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0; 581 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0; 582 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0; 583 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0; 584 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0; 585 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0; 586 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0; 587 588 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK; 589 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK; 590 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0; 591 592 return nego; 593 } 594 595 static void mptspi_read_parameters(struct scsi_target *starget) 596 { 597 int nego; 598 struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0; 599 600 mptspi_read_spi_device_pg0(starget, &spi_dev_pg0); 601 602 nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters); 603 604 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0; 605 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0; 606 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0; 607 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0; 608 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0; 609 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0; 610 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0; 611 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0; 612 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD; 613 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET; 614 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0; 615 } 616 617 static int 618 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id) 619 { 620 MPT_ADAPTER *ioc = hd->ioc; 621 MpiRaidActionRequest_t *pReq; 622 MPT_FRAME_HDR *mf; 623 int ret; 624 unsigned long timeleft; 625 626 mutex_lock(&ioc->internal_cmds.mutex); 627 628 /* Get and Populate a free Frame 629 */ 630 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) { 631 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT 632 "%s: no msg frames!\n", ioc->name, __func__)); 633 ret = -EAGAIN; 634 goto out; 635 } 636 pReq = (MpiRaidActionRequest_t *)mf; 637 if (quiesce) 638 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO; 639 else 640 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO; 641 pReq->Reserved1 = 0; 642 pReq->ChainOffset = 0; 643 pReq->Function = MPI_FUNCTION_RAID_ACTION; 644 pReq->VolumeID = id; 645 pReq->VolumeBus = channel; 646 pReq->PhysDiskNum = 0; 647 pReq->MsgFlags = 0; 648 pReq->Reserved2 = 0; 649 pReq->ActionDataWord = 0; /* Reserved for this action */ 650 651 ioc->add_sge((char *)&pReq->ActionDataSGE, 652 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1); 653 654 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n", 655 ioc->name, pReq->Action, channel, id)); 656 657 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status) 658 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf); 659 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ); 660 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 661 ret = -ETIME; 662 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n", 663 ioc->name, __func__)); 664 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) 665 goto out; 666 if (!timeleft) { 667 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n", 668 ioc->name, __func__); 669 mpt_HardResetHandler(ioc, CAN_SLEEP); 670 mpt_free_msg_frame(ioc, mf); 671 } 672 goto out; 673 } 674 675 ret = ioc->internal_cmds.completion_code; 676 677 out: 678 CLEAR_MGMT_STATUS(ioc->internal_cmds.status) 679 mutex_unlock(&ioc->internal_cmds.mutex); 680 return ret; 681 } 682 683 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd, 684 struct scsi_device *sdev) 685 { 686 VirtTarget *vtarget = scsi_target(sdev)->hostdata; 687 MPT_ADAPTER *ioc = hd->ioc; 688 689 /* no DV on RAID devices */ 690 if (sdev->channel == 0 && 691 mptspi_is_raid(hd, sdev->id)) 692 return; 693 694 /* If this is a piece of a RAID, then quiesce first */ 695 if (sdev->channel == 1 && 696 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) { 697 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT 698 "Integrated RAID quiesce failed\n", ioc->name); 699 return; 700 } 701 702 hd->spi_pending |= (1 << sdev->id); 703 spi_dv_device(sdev); 704 hd->spi_pending &= ~(1 << sdev->id); 705 706 if (sdev->channel == 1 && 707 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0) 708 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT 709 "Integrated RAID resume failed\n", ioc->name); 710 711 mptspi_read_parameters(sdev->sdev_target); 712 spi_display_xfer_agreement(sdev->sdev_target); 713 mptspi_read_parameters(sdev->sdev_target); 714 } 715 716 static int mptspi_slave_alloc(struct scsi_device *sdev) 717 { 718 MPT_SCSI_HOST *hd = shost_priv(sdev->host); 719 VirtTarget *vtarget; 720 VirtDevice *vdevice; 721 struct scsi_target *starget; 722 MPT_ADAPTER *ioc = hd->ioc; 723 724 if (sdev->channel == 1 && 725 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0) 726 return -ENXIO; 727 728 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL); 729 if (!vdevice) { 730 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n", 731 ioc->name, sizeof(VirtDevice)); 732 return -ENOMEM; 733 } 734 735 vdevice->lun = sdev->lun; 736 sdev->hostdata = vdevice; 737 738 starget = scsi_target(sdev); 739 vtarget = starget->hostdata; 740 vdevice->vtarget = vtarget; 741 vtarget->num_luns++; 742 743 if (sdev->channel == 1) 744 sdev->no_uld_attach = 1; 745 746 return 0; 747 } 748 749 static int mptspi_slave_configure(struct scsi_device *sdev) 750 { 751 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host); 752 VirtTarget *vtarget = scsi_target(sdev)->hostdata; 753 int ret; 754 755 mptspi_initTarget(hd, vtarget, sdev); 756 757 ret = mptscsih_slave_configure(sdev); 758 759 if (ret) 760 return ret; 761 762 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x" 763 " max_offset=0x%02x max_width=%d\n", hd->ioc->name, 764 sdev->id, spi_min_period(scsi_target(sdev)), 765 spi_max_offset(scsi_target(sdev)), 766 spi_max_width(scsi_target(sdev)))); 767 768 if ((sdev->channel == 1 || 769 !(mptspi_is_raid(hd, sdev->id))) && 770 !spi_initial_dv(sdev->sdev_target)) 771 mptspi_dv_device(hd, sdev); 772 773 return 0; 774 } 775 776 static int 777 mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt) 778 { 779 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 780 VirtDevice *vdevice = SCpnt->device->hostdata; 781 MPT_ADAPTER *ioc = hd->ioc; 782 783 if (!vdevice || !vdevice->vtarget) { 784 SCpnt->result = DID_NO_CONNECT << 16; 785 scsi_done(SCpnt); 786 return 0; 787 } 788 789 if (SCpnt->device->channel == 1 && 790 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) { 791 SCpnt->result = DID_NO_CONNECT << 16; 792 scsi_done(SCpnt); 793 return 0; 794 } 795 796 if (spi_dv_pending(scsi_target(SCpnt->device))) 797 ddvprintk(ioc, scsi_print_command(SCpnt)); 798 799 return mptscsih_qcmd(SCpnt); 800 } 801 802 static void mptspi_slave_destroy(struct scsi_device *sdev) 803 { 804 struct scsi_target *starget = scsi_target(sdev); 805 VirtTarget *vtarget = starget->hostdata; 806 VirtDevice *vdevice = sdev->hostdata; 807 808 /* Will this be the last lun on a non-raid device? */ 809 if (vtarget->num_luns == 1 && vdevice->configured_lun) { 810 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 811 812 /* Async Narrow */ 813 pg1.RequestedParameters = 0; 814 pg1.Reserved = 0; 815 pg1.Configuration = 0; 816 817 mptspi_write_spi_device_pg1(starget, &pg1); 818 } 819 820 mptscsih_slave_destroy(sdev); 821 } 822 823 static struct scsi_host_template mptspi_driver_template = { 824 .module = THIS_MODULE, 825 .proc_name = "mptspi", 826 .show_info = mptscsih_show_info, 827 .name = "MPT SPI Host", 828 .info = mptscsih_info, 829 .queuecommand = mptspi_qcmd, 830 .target_alloc = mptspi_target_alloc, 831 .slave_alloc = mptspi_slave_alloc, 832 .slave_configure = mptspi_slave_configure, 833 .target_destroy = mptspi_target_destroy, 834 .slave_destroy = mptspi_slave_destroy, 835 .change_queue_depth = mptscsih_change_queue_depth, 836 .eh_abort_handler = mptscsih_abort, 837 .eh_device_reset_handler = mptscsih_dev_reset, 838 .eh_bus_reset_handler = mptscsih_bus_reset, 839 .eh_host_reset_handler = mptscsih_host_reset, 840 .bios_param = mptscsih_bios_param, 841 .can_queue = MPT_SCSI_CAN_QUEUE, 842 .this_id = -1, 843 .sg_tablesize = MPT_SCSI_SG_DEPTH, 844 .max_sectors = 8192, 845 .cmd_per_lun = 7, 846 .shost_groups = mptscsih_host_attr_groups, 847 }; 848 849 static int mptspi_write_spi_device_pg1(struct scsi_target *starget, 850 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1) 851 { 852 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 853 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 854 struct _MPT_ADAPTER *ioc = hd->ioc; 855 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1; 856 dma_addr_t pg1_dma; 857 int size; 858 struct _x_config_parms cfg; 859 struct _CONFIG_PAGE_HEADER hdr; 860 int err = -EBUSY; 861 u32 nego_parms; 862 u32 period; 863 struct scsi_device *sdev; 864 int i; 865 866 /* don't allow updating nego parameters on RAID devices */ 867 if (starget->channel == 0 && 868 mptspi_is_raid(hd, starget->id)) 869 return -1; 870 871 size = ioc->spi_data.sdp1length * 4; 872 873 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL); 874 if (pg1 == NULL) { 875 starget_printk(KERN_ERR, starget, MYIOC_s_FMT 876 "dma_alloc_coherent for parameters failed\n", ioc->name); 877 return -EINVAL; 878 } 879 880 memset(&hdr, 0, sizeof(hdr)); 881 882 hdr.PageVersion = ioc->spi_data.sdp1version; 883 hdr.PageLength = ioc->spi_data.sdp1length; 884 hdr.PageNumber = 1; 885 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 886 887 memset(&cfg, 0, sizeof(cfg)); 888 889 cfg.cfghdr.hdr = &hdr; 890 cfg.physAddr = pg1_dma; 891 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 892 cfg.dir = 1; 893 cfg.pageAddr = starget->id; 894 895 memcpy(pg1, pass_pg1, size); 896 897 pg1->Header.PageVersion = hdr.PageVersion; 898 pg1->Header.PageLength = hdr.PageLength; 899 pg1->Header.PageNumber = hdr.PageNumber; 900 pg1->Header.PageType = hdr.PageType; 901 902 nego_parms = le32_to_cpu(pg1->RequestedParameters); 903 period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >> 904 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD; 905 if (period == 8) { 906 /* Turn on inline data padding for TAPE when running U320 */ 907 for (i = 0 ; i < 16; i++) { 908 sdev = scsi_device_lookup_by_target(starget, i); 909 if (sdev && sdev->type == TYPE_TAPE) { 910 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT 911 "IDP:ON\n", ioc->name); 912 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP; 913 pg1->RequestedParameters = 914 cpu_to_le32(nego_parms); 915 break; 916 } 917 } 918 } 919 920 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters)); 921 922 if (mpt_config(ioc, &cfg)) { 923 starget_printk(KERN_ERR, starget, MYIOC_s_FMT 924 "mpt_config failed\n", ioc->name); 925 goto out_free; 926 } 927 err = 0; 928 929 out_free: 930 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma); 931 return err; 932 } 933 934 static void mptspi_write_offset(struct scsi_target *starget, int offset) 935 { 936 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 937 u32 nego; 938 939 if (offset < 0) 940 offset = 0; 941 942 if (offset > 255) 943 offset = 255; 944 945 if (spi_offset(starget) == -1) 946 mptspi_read_parameters(starget); 947 948 spi_offset(starget) = offset; 949 950 nego = mptspi_getRP(starget); 951 952 pg1.RequestedParameters = cpu_to_le32(nego); 953 pg1.Reserved = 0; 954 pg1.Configuration = 0; 955 956 mptspi_write_spi_device_pg1(starget, &pg1); 957 } 958 959 static void mptspi_write_period(struct scsi_target *starget, int period) 960 { 961 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 962 u32 nego; 963 964 if (period < 8) 965 period = 8; 966 967 if (period > 255) 968 period = 255; 969 970 if (spi_period(starget) == -1) 971 mptspi_read_parameters(starget); 972 973 if (period == 8) { 974 spi_iu(starget) = 1; 975 spi_dt(starget) = 1; 976 } else if (period == 9) { 977 spi_dt(starget) = 1; 978 } 979 980 spi_period(starget) = period; 981 982 nego = mptspi_getRP(starget); 983 984 pg1.RequestedParameters = cpu_to_le32(nego); 985 pg1.Reserved = 0; 986 pg1.Configuration = 0; 987 988 mptspi_write_spi_device_pg1(starget, &pg1); 989 } 990 991 static void mptspi_write_dt(struct scsi_target *starget, int dt) 992 { 993 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 994 u32 nego; 995 996 if (spi_period(starget) == -1) 997 mptspi_read_parameters(starget); 998 999 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 /* only want to search RAID components */ 1133 if (sdev->channel != 1) 1134 continue; 1135 1136 /* The id is the raid PhysDiskNum, even if 1137 * starget->id is the actual target address */ 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 * Supported hardware 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} /* Terminating entry */ 1248 }; 1249 MODULE_DEVICE_TABLE(pci, mptspi_pci_table); 1250 1251 1252 /* 1253 * renegotiate for a given target 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 * spi module reset handler 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 /* only try to do a renegotiation if we're properly set up 1313 * if we get an ioc fault on bringup, ioc->sh will be NULL */ 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 * spi module resume handler 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 * mptspi_probe - Installs scsi devices per bus. 1346 * @pdev: Pointer to pci_dev structure 1347 * 1348 * Returns 0 for success, non-zero for failure. 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 /* Added sanity check on readiness of the MPT adapter. 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 /* Sanity check - ensure at least 1 port is INITIATOR capable 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 /* VMWare emulation doesn't properly implement WRITE_SAME 1417 */ 1418 if (pdev->subsystem_vendor == 0x15AD) 1419 sh->no_write_same = 1; 1420 1421 spin_lock_irqsave(&ioc->FreeQlock, flags); 1422 1423 /* Attach the SCSI Host to the IOC structure 1424 */ 1425 ioc->sh = sh; 1426 1427 sh->io_port = 0; 1428 sh->n_io_port = 0; 1429 sh->irq = 0; 1430 1431 /* set 16 byte cdb's */ 1432 sh->max_cmd_len = 16; 1433 1434 /* Yikes! This is important! 1435 * Otherwise, by default, linux 1436 * only scans target IDs 0-7! 1437 * pfactsN->MaxDevices unreliable 1438 * (not supported in early 1439 * versions of the FW). 1440 * max_id = 1 + actual max id, 1441 * max_lun = 1 + actual last lun, 1442 * see hosts.h :o( 1443 */ 1444 sh->max_id = ioc->devices_per_bus; 1445 1446 sh->max_lun = MPT_LAST_LUN + 1; 1447 /* 1448 * If RAID Firmware Detected, setup virtual channel 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 /* Required entry. 1457 */ 1458 sh->unique_id = ioc->id; 1459 1460 /* Verify that we won't exceed the maximum 1461 * number of chain buffers 1462 * We can optimize: ZZ = req_sz/sizeof(SGE) 1463 * For 32bit SGE's: 1464 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 1465 * + (req_sz - 64)/sizeof(SGE) 1466 * A slightly different algorithm is required for 1467 * 64bit SGEs. 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 /* Reset this value */ 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 /* SCSI needs scsi_cmnd lookup table! 1494 * (with size equal to req_depth*PtrSz!) 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 /* Some versions of the firmware don't support page 0; without 1517 * that we can't get the parameters */ 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 * issue internal bus reset 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 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer. 1568 * 1569 * Returns 0 for success, non-zero for failure. 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 * mptspi_exit - Unregisters MPT adapter(s) 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); 1620