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> /* needed for in_interrupt() proto */ 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 u16 req_idx; 262 u32 frameOffset; 263 u32 flagsLength; 264 int ii; 265 266 /* Get a MF for this command. 267 */ 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)); 271 return -EAGAIN; 272 } 273 274 /* Set the request and the data pointers. 275 * Place data at end of MF. 276 */ 277 pReq = (Config_t *)mf; 278 279 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 280 frameOffset = ioc->req_sz - sizeof(IOCPage4_t); 281 282 /* Complete the request frame (same for all requests). 283 */ 284 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 285 pReq->Reserved = 0; 286 pReq->ChainOffset = 0; 287 pReq->Function = MPI_FUNCTION_CONFIG; 288 pReq->ExtPageLength = 0; 289 pReq->ExtPageType = 0; 290 pReq->MsgFlags = 0; 291 for (ii=0; ii < 8; ii++) { 292 pReq->Reserved2[ii] = 0; 293 } 294 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 )); 302 303 /* Add a SGE to the config request. 304 */ 305 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE | 306 (IOCPage4Ptr->Header.PageLength + ii) * 4; 307 308 ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma); 309 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)); 313 314 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf); 315 316 return 0; 317 } 318 319 /** 320 * mptspi_initTarget - Target, LUN alloc/free functionality. 321 * @hd: Pointer to MPT_SCSI_HOST structure 322 * @vtarget: per target private data 323 * @sdev: SCSI device 324 * 325 * NOTE: It's only SAFE to call this routine if data points to 326 * sane & valid STANDARD INQUIRY data! 327 * 328 * Allocate and initialize memory for this target. 329 * Save inquiry data. 330 * 331 **/ 332 static void 333 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, 334 struct scsi_device *sdev) 335 { 336 337 /* Is LUN supported? If so, upper 2 bits will be 0 338 * in first byte of inquiry data. 339 */ 340 if (sdev->inq_periph_qual != 0) 341 return; 342 343 if (vtarget == NULL) 344 return; 345 346 vtarget->type = sdev->type; 347 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); 364 } 365 } 366 } 367 mptspi_setTargetNegoParms(hd, vtarget, sdev); 368 } 369 370 /** 371 * mptspi_is_raid - Determines whether target is belonging to volume 372 * @hd: Pointer to a SCSI HOST structure 373 * @id: target device id 374 * 375 * Return: 376 * non-zero = true 377 * zero = false 378 * 379 */ 380 static int 381 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id) 382 { 383 int i, rc = 0; 384 MPT_ADAPTER *ioc = hd->ioc; 385 386 if (!ioc->raid_data.pIocPg2) 387 goto out; 388 389 if (!ioc->raid_data.pIocPg2->NumActiveVolumes) 390 goto out; 391 for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 392 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) { 393 rc = 1; 394 goto out; 395 } 396 } 397 398 out: 399 return rc; 400 } 401 402 static int mptspi_target_alloc(struct scsi_target *starget) 403 { 404 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 405 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 406 VirtTarget *vtarget; 407 MPT_ADAPTER *ioc; 408 409 if (hd == NULL) 410 return -ENODEV; 411 412 ioc = hd->ioc; 413 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL); 414 if (!vtarget) 415 return -ENOMEM; 416 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; 423 424 if (starget->channel == 1) { 425 if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0) 426 return 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, 432 starget->id); 433 } 434 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, 440 starget->id)); 441 } 442 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; 448 } else { 449 spi_min_period(starget) = ioc->spi_data.minSyncFactor; 450 spi_max_width(starget) = ioc->spi_data.maxBusWidth; 451 } 452 spi_max_offset(starget) = ioc->spi_data.maxSyncOffset; 453 454 spi_offset(starget) = 0; 455 spi_period(starget) = 0xFF; 456 mptspi_write_width(starget, 0); 457 458 return 0; 459 } 460 461 static void 462 mptspi_target_destroy(struct scsi_target *starget) 463 { 464 kfree(starget->hostdata); 465 starget->hostdata = NULL; 466 } 467 468 /** 469 * mptspi_print_write_nego - negotiation parameters debug info that is being sent 470 * @hd: Pointer to a SCSI HOST structure 471 * @starget: SCSI target 472 * @ii: negotiation parameters 473 * 474 */ 475 static void 476 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii) 477 { 478 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x" 479 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n", 480 hd->ioc->name, starget->id, ii, 481 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "", 482 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF), 483 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "", 484 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "", 485 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "", 486 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "", 487 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "", 488 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "", 489 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "", 490 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "")); 491 } 492 493 /** 494 * mptspi_print_read_nego - negotiation parameters debug info that is being read 495 * @hd: Pointer to a SCSI HOST structure 496 * @starget: SCSI target 497 * @ii: negotiation parameters 498 * 499 */ 500 static void 501 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii) 502 { 503 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x" 504 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n", 505 hd->ioc->name, starget->id, ii, 506 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "", 507 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF), 508 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "", 509 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "", 510 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "", 511 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "", 512 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "", 513 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "", 514 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "", 515 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "")); 516 } 517 518 static int mptspi_read_spi_device_pg0(struct scsi_target *starget, 519 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0) 520 { 521 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 522 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 523 struct _MPT_ADAPTER *ioc = hd->ioc; 524 struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0; 525 dma_addr_t spi_dev_pg0_dma; 526 int size; 527 struct _x_config_parms cfg; 528 struct _CONFIG_PAGE_HEADER hdr; 529 int err = -EBUSY; 530 531 /* No SPI parameters for RAID devices */ 532 if (starget->channel == 0 && 533 mptspi_is_raid(hd, starget->id)) 534 return -1; 535 536 size = ioc->spi_data.sdp0length * 4; 537 /* 538 if (ioc->spi_data.sdp0length & 1) 539 size += size + 4; 540 size += 2048; 541 */ 542 543 spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL); 544 if (spi_dev_pg0 == NULL) { 545 starget_printk(KERN_ERR, starget, MYIOC_s_FMT 546 "dma_alloc_coherent for parameters failed\n", ioc->name); 547 return -EINVAL; 548 } 549 550 memset(&hdr, 0, sizeof(hdr)); 551 552 hdr.PageVersion = ioc->spi_data.sdp0version; 553 hdr.PageLength = ioc->spi_data.sdp0length; 554 hdr.PageNumber = 0; 555 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 556 557 memset(&cfg, 0, sizeof(cfg)); 558 559 cfg.cfghdr.hdr = &hdr; 560 cfg.physAddr = spi_dev_pg0_dma; 561 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 562 cfg.dir = 0; 563 cfg.pageAddr = starget->id; 564 cfg.timeout = 60; 565 566 if (mpt_config(ioc, &cfg)) { 567 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name); 568 goto out_free; 569 } 570 err = 0; 571 memcpy(pass_pg0, spi_dev_pg0, size); 572 573 mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters)); 574 575 out_free: 576 dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma); 577 return err; 578 } 579 580 static u32 mptspi_getRP(struct scsi_target *starget) 581 { 582 u32 nego = 0; 583 584 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0; 585 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0; 586 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0; 587 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0; 588 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0; 589 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0; 590 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0; 591 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0; 592 593 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK; 594 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK; 595 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0; 596 597 return nego; 598 } 599 600 static void mptspi_read_parameters(struct scsi_target *starget) 601 { 602 int nego; 603 struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0; 604 605 mptspi_read_spi_device_pg0(starget, &spi_dev_pg0); 606 607 nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters); 608 609 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0; 610 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0; 611 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0; 612 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0; 613 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0; 614 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0; 615 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0; 616 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0; 617 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD; 618 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET; 619 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0; 620 } 621 622 static int 623 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id) 624 { 625 MPT_ADAPTER *ioc = hd->ioc; 626 MpiRaidActionRequest_t *pReq; 627 MPT_FRAME_HDR *mf; 628 int ret; 629 unsigned long timeleft; 630 631 mutex_lock(&ioc->internal_cmds.mutex); 632 633 /* Get and Populate a free Frame 634 */ 635 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) { 636 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT 637 "%s: no msg frames!\n", ioc->name, __func__)); 638 ret = -EAGAIN; 639 goto out; 640 } 641 pReq = (MpiRaidActionRequest_t *)mf; 642 if (quiesce) 643 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO; 644 else 645 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO; 646 pReq->Reserved1 = 0; 647 pReq->ChainOffset = 0; 648 pReq->Function = MPI_FUNCTION_RAID_ACTION; 649 pReq->VolumeID = id; 650 pReq->VolumeBus = channel; 651 pReq->PhysDiskNum = 0; 652 pReq->MsgFlags = 0; 653 pReq->Reserved2 = 0; 654 pReq->ActionDataWord = 0; /* Reserved for this action */ 655 656 ioc->add_sge((char *)&pReq->ActionDataSGE, 657 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1); 658 659 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n", 660 ioc->name, pReq->Action, channel, id)); 661 662 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status) 663 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf); 664 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ); 665 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 666 ret = -ETIME; 667 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n", 668 ioc->name, __func__)); 669 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) 670 goto out; 671 if (!timeleft) { 672 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n", 673 ioc->name, __func__); 674 mpt_HardResetHandler(ioc, CAN_SLEEP); 675 mpt_free_msg_frame(ioc, mf); 676 } 677 goto out; 678 } 679 680 ret = ioc->internal_cmds.completion_code; 681 682 out: 683 CLEAR_MGMT_STATUS(ioc->internal_cmds.status) 684 mutex_unlock(&ioc->internal_cmds.mutex); 685 return ret; 686 } 687 688 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd, 689 struct scsi_device *sdev) 690 { 691 VirtTarget *vtarget = scsi_target(sdev)->hostdata; 692 MPT_ADAPTER *ioc = hd->ioc; 693 694 /* no DV on RAID devices */ 695 if (sdev->channel == 0 && 696 mptspi_is_raid(hd, sdev->id)) 697 return; 698 699 /* If this is a piece of a RAID, then quiesce first */ 700 if (sdev->channel == 1 && 701 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) { 702 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT 703 "Integrated RAID quiesce failed\n", ioc->name); 704 return; 705 } 706 707 hd->spi_pending |= (1 << sdev->id); 708 spi_dv_device(sdev); 709 hd->spi_pending &= ~(1 << sdev->id); 710 711 if (sdev->channel == 1 && 712 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0) 713 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT 714 "Integrated RAID resume failed\n", ioc->name); 715 716 mptspi_read_parameters(sdev->sdev_target); 717 spi_display_xfer_agreement(sdev->sdev_target); 718 mptspi_read_parameters(sdev->sdev_target); 719 } 720 721 static int mptspi_slave_alloc(struct scsi_device *sdev) 722 { 723 MPT_SCSI_HOST *hd = shost_priv(sdev->host); 724 VirtTarget *vtarget; 725 VirtDevice *vdevice; 726 struct scsi_target *starget; 727 MPT_ADAPTER *ioc = hd->ioc; 728 729 if (sdev->channel == 1 && 730 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0) 731 return -ENXIO; 732 733 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL); 734 if (!vdevice) { 735 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n", 736 ioc->name, sizeof(VirtDevice)); 737 return -ENOMEM; 738 } 739 740 vdevice->lun = sdev->lun; 741 sdev->hostdata = vdevice; 742 743 starget = scsi_target(sdev); 744 vtarget = starget->hostdata; 745 vdevice->vtarget = vtarget; 746 vtarget->num_luns++; 747 748 if (sdev->channel == 1) 749 sdev->no_uld_attach = 1; 750 751 return 0; 752 } 753 754 static int mptspi_slave_configure(struct scsi_device *sdev) 755 { 756 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host); 757 VirtTarget *vtarget = scsi_target(sdev)->hostdata; 758 int ret; 759 760 mptspi_initTarget(hd, vtarget, sdev); 761 762 ret = mptscsih_slave_configure(sdev); 763 764 if (ret) 765 return ret; 766 767 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x" 768 " max_offset=0x%02x max_width=%d\n", hd->ioc->name, 769 sdev->id, spi_min_period(scsi_target(sdev)), 770 spi_max_offset(scsi_target(sdev)), 771 spi_max_width(scsi_target(sdev)))); 772 773 if ((sdev->channel == 1 || 774 !(mptspi_is_raid(hd, sdev->id))) && 775 !spi_initial_dv(sdev->sdev_target)) 776 mptspi_dv_device(hd, sdev); 777 778 return 0; 779 } 780 781 static int 782 mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt) 783 { 784 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 785 VirtDevice *vdevice = SCpnt->device->hostdata; 786 MPT_ADAPTER *ioc = hd->ioc; 787 788 if (!vdevice || !vdevice->vtarget) { 789 SCpnt->result = DID_NO_CONNECT << 16; 790 SCpnt->scsi_done(SCpnt); 791 return 0; 792 } 793 794 if (SCpnt->device->channel == 1 && 795 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) { 796 SCpnt->result = DID_NO_CONNECT << 16; 797 SCpnt->scsi_done(SCpnt); 798 return 0; 799 } 800 801 if (spi_dv_pending(scsi_target(SCpnt->device))) 802 ddvprintk(ioc, scsi_print_command(SCpnt)); 803 804 return mptscsih_qcmd(SCpnt); 805 } 806 807 static void mptspi_slave_destroy(struct scsi_device *sdev) 808 { 809 struct scsi_target *starget = scsi_target(sdev); 810 VirtTarget *vtarget = starget->hostdata; 811 VirtDevice *vdevice = sdev->hostdata; 812 813 /* Will this be the last lun on a non-raid device? */ 814 if (vtarget->num_luns == 1 && vdevice->configured_lun) { 815 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 816 817 /* Async Narrow */ 818 pg1.RequestedParameters = 0; 819 pg1.Reserved = 0; 820 pg1.Configuration = 0; 821 822 mptspi_write_spi_device_pg1(starget, &pg1); 823 } 824 825 mptscsih_slave_destroy(sdev); 826 } 827 828 static struct scsi_host_template mptspi_driver_template = { 829 .module = THIS_MODULE, 830 .proc_name = "mptspi", 831 .show_info = mptscsih_show_info, 832 .name = "MPT SPI Host", 833 .info = mptscsih_info, 834 .queuecommand = mptspi_qcmd, 835 .target_alloc = mptspi_target_alloc, 836 .slave_alloc = mptspi_slave_alloc, 837 .slave_configure = mptspi_slave_configure, 838 .target_destroy = mptspi_target_destroy, 839 .slave_destroy = mptspi_slave_destroy, 840 .change_queue_depth = mptscsih_change_queue_depth, 841 .eh_abort_handler = mptscsih_abort, 842 .eh_device_reset_handler = mptscsih_dev_reset, 843 .eh_bus_reset_handler = mptscsih_bus_reset, 844 .eh_host_reset_handler = mptscsih_host_reset, 845 .bios_param = mptscsih_bios_param, 846 .can_queue = MPT_SCSI_CAN_QUEUE, 847 .this_id = -1, 848 .sg_tablesize = MPT_SCSI_SG_DEPTH, 849 .max_sectors = 8192, 850 .cmd_per_lun = 7, 851 .shost_attrs = mptscsih_host_attrs, 852 }; 853 854 static int mptspi_write_spi_device_pg1(struct scsi_target *starget, 855 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1) 856 { 857 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 858 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 859 struct _MPT_ADAPTER *ioc = hd->ioc; 860 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1; 861 dma_addr_t pg1_dma; 862 int size; 863 struct _x_config_parms cfg; 864 struct _CONFIG_PAGE_HEADER hdr; 865 int err = -EBUSY; 866 u32 nego_parms; 867 u32 period; 868 struct scsi_device *sdev; 869 int i; 870 871 /* don't allow updating nego parameters on RAID devices */ 872 if (starget->channel == 0 && 873 mptspi_is_raid(hd, starget->id)) 874 return -1; 875 876 size = ioc->spi_data.sdp1length * 4; 877 878 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL); 879 if (pg1 == NULL) { 880 starget_printk(KERN_ERR, starget, MYIOC_s_FMT 881 "dma_alloc_coherent for parameters failed\n", ioc->name); 882 return -EINVAL; 883 } 884 885 memset(&hdr, 0, sizeof(hdr)); 886 887 hdr.PageVersion = ioc->spi_data.sdp1version; 888 hdr.PageLength = ioc->spi_data.sdp1length; 889 hdr.PageNumber = 1; 890 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 891 892 memset(&cfg, 0, sizeof(cfg)); 893 894 cfg.cfghdr.hdr = &hdr; 895 cfg.physAddr = pg1_dma; 896 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 897 cfg.dir = 1; 898 cfg.pageAddr = starget->id; 899 900 memcpy(pg1, pass_pg1, size); 901 902 pg1->Header.PageVersion = hdr.PageVersion; 903 pg1->Header.PageLength = hdr.PageLength; 904 pg1->Header.PageNumber = hdr.PageNumber; 905 pg1->Header.PageType = hdr.PageType; 906 907 nego_parms = le32_to_cpu(pg1->RequestedParameters); 908 period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >> 909 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD; 910 if (period == 8) { 911 /* Turn on inline data padding for TAPE when running U320 */ 912 for (i = 0 ; i < 16; i++) { 913 sdev = scsi_device_lookup_by_target(starget, i); 914 if (sdev && sdev->type == TYPE_TAPE) { 915 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT 916 "IDP:ON\n", ioc->name); 917 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP; 918 pg1->RequestedParameters = 919 cpu_to_le32(nego_parms); 920 break; 921 } 922 } 923 } 924 925 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters)); 926 927 if (mpt_config(ioc, &cfg)) { 928 starget_printk(KERN_ERR, starget, MYIOC_s_FMT 929 "mpt_config failed\n", ioc->name); 930 goto out_free; 931 } 932 err = 0; 933 934 out_free: 935 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma); 936 return err; 937 } 938 939 static void mptspi_write_offset(struct scsi_target *starget, int offset) 940 { 941 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 942 u32 nego; 943 944 if (offset < 0) 945 offset = 0; 946 947 if (offset > 255) 948 offset = 255; 949 950 if (spi_offset(starget) == -1) 951 mptspi_read_parameters(starget); 952 953 spi_offset(starget) = offset; 954 955 nego = mptspi_getRP(starget); 956 957 pg1.RequestedParameters = cpu_to_le32(nego); 958 pg1.Reserved = 0; 959 pg1.Configuration = 0; 960 961 mptspi_write_spi_device_pg1(starget, &pg1); 962 } 963 964 static void mptspi_write_period(struct scsi_target *starget, int period) 965 { 966 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 967 u32 nego; 968 969 if (period < 8) 970 period = 8; 971 972 if (period > 255) 973 period = 255; 974 975 if (spi_period(starget) == -1) 976 mptspi_read_parameters(starget); 977 978 if (period == 8) { 979 spi_iu(starget) = 1; 980 spi_dt(starget) = 1; 981 } else if (period == 9) { 982 spi_dt(starget) = 1; 983 } 984 985 spi_period(starget) = period; 986 987 nego = mptspi_getRP(starget); 988 989 pg1.RequestedParameters = cpu_to_le32(nego); 990 pg1.Reserved = 0; 991 pg1.Configuration = 0; 992 993 mptspi_write_spi_device_pg1(starget, &pg1); 994 } 995 996 static void mptspi_write_dt(struct scsi_target *starget, int dt) 997 { 998 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 999 u32 nego; 1000 1001 if (spi_period(starget) == -1) 1002 mptspi_read_parameters(starget); 1003 1004 if (!dt && spi_period(starget) < 10) 1005 spi_period(starget) = 10; 1006 1007 spi_dt(starget) = dt; 1008 1009 nego = mptspi_getRP(starget); 1010 1011 1012 pg1.RequestedParameters = cpu_to_le32(nego); 1013 pg1.Reserved = 0; 1014 pg1.Configuration = 0; 1015 1016 mptspi_write_spi_device_pg1(starget, &pg1); 1017 } 1018 1019 static void mptspi_write_iu(struct scsi_target *starget, int iu) 1020 { 1021 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1022 u32 nego; 1023 1024 if (spi_period(starget) == -1) 1025 mptspi_read_parameters(starget); 1026 1027 if (!iu && spi_period(starget) < 9) 1028 spi_period(starget) = 9; 1029 1030 spi_iu(starget) = iu; 1031 1032 nego = mptspi_getRP(starget); 1033 1034 pg1.RequestedParameters = cpu_to_le32(nego); 1035 pg1.Reserved = 0; 1036 pg1.Configuration = 0; 1037 1038 mptspi_write_spi_device_pg1(starget, &pg1); 1039 } 1040 1041 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \ 1042 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\ 1043 { \ 1044 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \ 1045 u32 nego; \ 1046 \ 1047 spi_##parm(starget) = parm; \ 1048 \ 1049 nego = mptspi_getRP(starget); \ 1050 \ 1051 pg1.RequestedParameters = cpu_to_le32(nego); \ 1052 pg1.Reserved = 0; \ 1053 pg1.Configuration = 0; \ 1054 \ 1055 mptspi_write_spi_device_pg1(starget, &pg1); \ 1056 } 1057 1058 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm) 1059 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow) 1060 MPTSPI_SIMPLE_TRANSPORT_PARM(rti) 1061 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs) 1062 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en) 1063 1064 static void mptspi_write_qas(struct scsi_target *starget, int qas) 1065 { 1066 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1067 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1068 struct _MPT_SCSI_HOST *hd = shost_priv(shost); 1069 VirtTarget *vtarget = starget->hostdata; 1070 u32 nego; 1071 1072 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) || 1073 hd->ioc->spi_data.noQas) 1074 spi_qas(starget) = 0; 1075 else 1076 spi_qas(starget) = qas; 1077 1078 nego = mptspi_getRP(starget); 1079 1080 pg1.RequestedParameters = cpu_to_le32(nego); 1081 pg1.Reserved = 0; 1082 pg1.Configuration = 0; 1083 1084 mptspi_write_spi_device_pg1(starget, &pg1); 1085 } 1086 1087 static void mptspi_write_width(struct scsi_target *starget, int width) 1088 { 1089 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1090 u32 nego; 1091 1092 if (!width) { 1093 spi_dt(starget) = 0; 1094 if (spi_period(starget) < 10) 1095 spi_period(starget) = 10; 1096 } 1097 1098 spi_width(starget) = width; 1099 1100 nego = mptspi_getRP(starget); 1101 1102 pg1.RequestedParameters = cpu_to_le32(nego); 1103 pg1.Reserved = 0; 1104 pg1.Configuration = 0; 1105 1106 mptspi_write_spi_device_pg1(starget, &pg1); 1107 } 1108 1109 struct work_queue_wrapper { 1110 struct work_struct work; 1111 struct _MPT_SCSI_HOST *hd; 1112 int disk; 1113 }; 1114 1115 static void mpt_work_wrapper(struct work_struct *work) 1116 { 1117 struct work_queue_wrapper *wqw = 1118 container_of(work, struct work_queue_wrapper, work); 1119 struct _MPT_SCSI_HOST *hd = wqw->hd; 1120 MPT_ADAPTER *ioc = hd->ioc; 1121 struct Scsi_Host *shost = ioc->sh; 1122 struct scsi_device *sdev; 1123 int disk = wqw->disk; 1124 struct _CONFIG_PAGE_IOC_3 *pg3; 1125 1126 kfree(wqw); 1127 1128 mpt_findImVolumes(ioc); 1129 pg3 = ioc->raid_data.pIocPg3; 1130 if (!pg3) 1131 return; 1132 1133 shost_for_each_device(sdev,shost) { 1134 struct scsi_target *starget = scsi_target(sdev); 1135 VirtTarget *vtarget = starget->hostdata; 1136 1137 /* only want to search RAID components */ 1138 if (sdev->channel != 1) 1139 continue; 1140 1141 /* The id is the raid PhysDiskNum, even if 1142 * starget->id is the actual target address */ 1143 if(vtarget->id != disk) 1144 continue; 1145 1146 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT 1147 "Integrated RAID requests DV of new device\n", ioc->name); 1148 mptspi_dv_device(hd, sdev); 1149 } 1150 shost_printk(KERN_INFO, shost, MYIOC_s_FMT 1151 "Integrated RAID detects new device %d\n", ioc->name, disk); 1152 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, SCSI_SCAN_RESCAN); 1153 } 1154 1155 1156 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk) 1157 { 1158 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC); 1159 MPT_ADAPTER *ioc = hd->ioc; 1160 1161 if (!wqw) { 1162 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT 1163 "Failed to act on RAID event for physical disk %d\n", 1164 ioc->name, disk); 1165 return; 1166 } 1167 INIT_WORK(&wqw->work, mpt_work_wrapper); 1168 wqw->hd = hd; 1169 wqw->disk = disk; 1170 1171 schedule_work(&wqw->work); 1172 } 1173 1174 static int 1175 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) 1176 { 1177 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF; 1178 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh); 1179 1180 if (ioc->bus_type != SPI) 1181 return 0; 1182 1183 if (hd && event == MPI_EVENT_INTEGRATED_RAID) { 1184 int reason 1185 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16; 1186 1187 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) { 1188 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24; 1189 mpt_dv_raid(hd, disk); 1190 } 1191 } 1192 return mptscsih_event_process(ioc, pEvReply); 1193 } 1194 1195 static int 1196 mptspi_deny_binding(struct scsi_target *starget) 1197 { 1198 struct _MPT_SCSI_HOST *hd = 1199 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata; 1200 return ((mptspi_is_raid(hd, starget->id)) && 1201 starget->channel == 0) ? 1 : 0; 1202 } 1203 1204 static struct spi_function_template mptspi_transport_functions = { 1205 .get_offset = mptspi_read_parameters, 1206 .set_offset = mptspi_write_offset, 1207 .show_offset = 1, 1208 .get_period = mptspi_read_parameters, 1209 .set_period = mptspi_write_period, 1210 .show_period = 1, 1211 .get_width = mptspi_read_parameters, 1212 .set_width = mptspi_write_width, 1213 .show_width = 1, 1214 .get_iu = mptspi_read_parameters, 1215 .set_iu = mptspi_write_iu, 1216 .show_iu = 1, 1217 .get_dt = mptspi_read_parameters, 1218 .set_dt = mptspi_write_dt, 1219 .show_dt = 1, 1220 .get_qas = mptspi_read_parameters, 1221 .set_qas = mptspi_write_qas, 1222 .show_qas = 1, 1223 .get_wr_flow = mptspi_read_parameters, 1224 .set_wr_flow = mptspi_write_wr_flow, 1225 .show_wr_flow = 1, 1226 .get_rd_strm = mptspi_read_parameters, 1227 .set_rd_strm = mptspi_write_rd_strm, 1228 .show_rd_strm = 1, 1229 .get_rti = mptspi_read_parameters, 1230 .set_rti = mptspi_write_rti, 1231 .show_rti = 1, 1232 .get_pcomp_en = mptspi_read_parameters, 1233 .set_pcomp_en = mptspi_write_pcomp_en, 1234 .show_pcomp_en = 1, 1235 .get_hold_mcs = mptspi_read_parameters, 1236 .set_hold_mcs = mptspi_write_hold_mcs, 1237 .show_hold_mcs = 1, 1238 .deny_binding = mptspi_deny_binding, 1239 }; 1240 1241 /**************************************************************************** 1242 * Supported hardware 1243 */ 1244 1245 static struct pci_device_id mptspi_pci_table[] = { 1246 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030, 1247 PCI_ANY_ID, PCI_ANY_ID }, 1248 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030, 1249 PCI_ANY_ID, PCI_ANY_ID }, 1250 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035, 1251 PCI_ANY_ID, PCI_ANY_ID }, 1252 {0} /* Terminating entry */ 1253 }; 1254 MODULE_DEVICE_TABLE(pci, mptspi_pci_table); 1255 1256 1257 /* 1258 * renegotiate for a given target 1259 */ 1260 static void 1261 mptspi_dv_renegotiate_work(struct work_struct *work) 1262 { 1263 struct work_queue_wrapper *wqw = 1264 container_of(work, struct work_queue_wrapper, work); 1265 struct _MPT_SCSI_HOST *hd = wqw->hd; 1266 struct scsi_device *sdev; 1267 struct scsi_target *starget; 1268 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1269 u32 nego; 1270 MPT_ADAPTER *ioc = hd->ioc; 1271 1272 kfree(wqw); 1273 1274 if (hd->spi_pending) { 1275 shost_for_each_device(sdev, ioc->sh) { 1276 if (hd->spi_pending & (1 << sdev->id)) 1277 continue; 1278 starget = scsi_target(sdev); 1279 nego = mptspi_getRP(starget); 1280 pg1.RequestedParameters = cpu_to_le32(nego); 1281 pg1.Reserved = 0; 1282 pg1.Configuration = 0; 1283 mptspi_write_spi_device_pg1(starget, &pg1); 1284 } 1285 } else { 1286 shost_for_each_device(sdev, ioc->sh) 1287 mptspi_dv_device(hd, sdev); 1288 } 1289 } 1290 1291 static void 1292 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd) 1293 { 1294 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC); 1295 1296 if (!wqw) 1297 return; 1298 1299 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work); 1300 wqw->hd = hd; 1301 1302 schedule_work(&wqw->work); 1303 } 1304 1305 /* 1306 * spi module reset handler 1307 */ 1308 static int 1309 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 1310 { 1311 int rc; 1312 1313 rc = mptscsih_ioc_reset(ioc, reset_phase); 1314 if ((ioc->bus_type != SPI) || (!rc)) 1315 return rc; 1316 1317 /* only try to do a renegotiation if we're properly set up 1318 * if we get an ioc fault on bringup, ioc->sh will be NULL */ 1319 if (reset_phase == MPT_IOC_POST_RESET && 1320 ioc->sh) { 1321 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh); 1322 1323 mptspi_dv_renegotiate(hd); 1324 } 1325 1326 return rc; 1327 } 1328 1329 #ifdef CONFIG_PM 1330 /* 1331 * spi module resume handler 1332 */ 1333 static int 1334 mptspi_resume(struct pci_dev *pdev) 1335 { 1336 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1337 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh); 1338 int rc; 1339 1340 rc = mptscsih_resume(pdev); 1341 mptspi_dv_renegotiate(hd); 1342 1343 return rc; 1344 } 1345 #endif 1346 1347 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1348 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1349 /* 1350 * mptspi_probe - Installs scsi devices per bus. 1351 * @pdev: Pointer to pci_dev structure 1352 * 1353 * Returns 0 for success, non-zero for failure. 1354 * 1355 */ 1356 static int 1357 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) 1358 { 1359 struct Scsi_Host *sh; 1360 MPT_SCSI_HOST *hd; 1361 MPT_ADAPTER *ioc; 1362 unsigned long flags; 1363 int ii; 1364 int numSGE = 0; 1365 int scale; 1366 int ioc_cap; 1367 int error=0; 1368 int r; 1369 1370 if ((r = mpt_attach(pdev,id)) != 0) 1371 return r; 1372 1373 ioc = pci_get_drvdata(pdev); 1374 ioc->DoneCtx = mptspiDoneCtx; 1375 ioc->TaskCtx = mptspiTaskCtx; 1376 ioc->InternalCtx = mptspiInternalCtx; 1377 1378 /* Added sanity check on readiness of the MPT adapter. 1379 */ 1380 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 1381 printk(MYIOC_s_WARN_FMT 1382 "Skipping because it's not operational!\n", 1383 ioc->name); 1384 error = -ENODEV; 1385 goto out_mptspi_probe; 1386 } 1387 1388 if (!ioc->active) { 1389 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 1390 ioc->name); 1391 error = -ENODEV; 1392 goto out_mptspi_probe; 1393 } 1394 1395 /* Sanity check - ensure at least 1 port is INITIATOR capable 1396 */ 1397 ioc_cap = 0; 1398 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) { 1399 if (ioc->pfacts[ii].ProtocolFlags & 1400 MPI_PORTFACTS_PROTOCOL_INITIATOR) 1401 ioc_cap ++; 1402 } 1403 1404 if (!ioc_cap) { 1405 printk(MYIOC_s_WARN_FMT 1406 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n", 1407 ioc->name, ioc); 1408 return 0; 1409 } 1410 1411 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST)); 1412 1413 if (!sh) { 1414 printk(MYIOC_s_WARN_FMT 1415 "Unable to register controller with SCSI subsystem\n", 1416 ioc->name); 1417 error = -1; 1418 goto out_mptspi_probe; 1419 } 1420 1421 /* VMWare emulation doesn't properly implement WRITE_SAME 1422 */ 1423 if (pdev->subsystem_vendor == 0x15AD) 1424 sh->no_write_same = 1; 1425 1426 spin_lock_irqsave(&ioc->FreeQlock, flags); 1427 1428 /* Attach the SCSI Host to the IOC structure 1429 */ 1430 ioc->sh = sh; 1431 1432 sh->io_port = 0; 1433 sh->n_io_port = 0; 1434 sh->irq = 0; 1435 1436 /* set 16 byte cdb's */ 1437 sh->max_cmd_len = 16; 1438 1439 /* Yikes! This is important! 1440 * Otherwise, by default, linux 1441 * only scans target IDs 0-7! 1442 * pfactsN->MaxDevices unreliable 1443 * (not supported in early 1444 * versions of the FW). 1445 * max_id = 1 + actual max id, 1446 * max_lun = 1 + actual last lun, 1447 * see hosts.h :o( 1448 */ 1449 sh->max_id = ioc->devices_per_bus; 1450 1451 sh->max_lun = MPT_LAST_LUN + 1; 1452 /* 1453 * If RAID Firmware Detected, setup virtual channel 1454 */ 1455 if (ioc->ir_firmware) 1456 sh->max_channel = 1; 1457 else 1458 sh->max_channel = 0; 1459 sh->this_id = ioc->pfacts[0].PortSCSIID; 1460 1461 /* Required entry. 1462 */ 1463 sh->unique_id = ioc->id; 1464 1465 /* Verify that we won't exceed the maximum 1466 * number of chain buffers 1467 * We can optimize: ZZ = req_sz/sizeof(SGE) 1468 * For 32bit SGE's: 1469 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 1470 * + (req_sz - 64)/sizeof(SGE) 1471 * A slightly different algorithm is required for 1472 * 64bit SGEs. 1473 */ 1474 scale = ioc->req_sz/ioc->SGE_size; 1475 if (ioc->sg_addr_size == sizeof(u64)) { 1476 numSGE = (scale - 1) * 1477 (ioc->facts.MaxChainDepth-1) + scale + 1478 (ioc->req_sz - 60) / ioc->SGE_size; 1479 } else { 1480 numSGE = 1 + (scale - 1) * 1481 (ioc->facts.MaxChainDepth-1) + scale + 1482 (ioc->req_sz - 64) / ioc->SGE_size; 1483 } 1484 1485 if (numSGE < sh->sg_tablesize) { 1486 /* Reset this value */ 1487 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1488 "Resetting sg_tablesize to %d from %d\n", 1489 ioc->name, numSGE, sh->sg_tablesize)); 1490 sh->sg_tablesize = numSGE; 1491 } 1492 1493 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 1494 1495 hd = shost_priv(sh); 1496 hd->ioc = ioc; 1497 1498 /* SCSI needs scsi_cmnd lookup table! 1499 * (with size equal to req_depth*PtrSz!) 1500 */ 1501 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 1502 if (!ioc->ScsiLookup) { 1503 error = -ENOMEM; 1504 goto out_mptspi_probe; 1505 } 1506 spin_lock_init(&ioc->scsi_lookup_lock); 1507 1508 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n", 1509 ioc->name, ioc->ScsiLookup)); 1510 1511 ioc->spi_data.Saf_Te = mpt_saf_te; 1512 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1513 "saf_te %x\n", 1514 ioc->name, 1515 mpt_saf_te)); 1516 ioc->spi_data.noQas = 0; 1517 1518 hd->last_queue_full = 0; 1519 hd->spi_pending = 0; 1520 1521 /* Some versions of the firmware don't support page 0; without 1522 * that we can't get the parameters */ 1523 if (ioc->spi_data.sdp0length != 0) 1524 sh->transportt = mptspi_transport_template; 1525 1526 error = scsi_add_host (sh, &ioc->pcidev->dev); 1527 if(error) { 1528 dprintk(ioc, printk(MYIOC_s_ERR_FMT 1529 "scsi_add_host failed\n", ioc->name)); 1530 goto out_mptspi_probe; 1531 } 1532 1533 /* 1534 * issue internal bus reset 1535 */ 1536 if (ioc->spi_data.bus_reset) 1537 mptscsih_IssueTaskMgmt(hd, 1538 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, 1539 0, 0, 0, 0, 5); 1540 1541 scsi_scan_host(sh); 1542 return 0; 1543 1544 out_mptspi_probe: 1545 1546 mptscsih_remove(pdev); 1547 return error; 1548 } 1549 1550 static void mptspi_remove(struct pci_dev *pdev) 1551 { 1552 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1553 1554 scsi_remove_host(ioc->sh); 1555 mptscsih_remove(pdev); 1556 } 1557 1558 static struct pci_driver mptspi_driver = { 1559 .name = "mptspi", 1560 .id_table = mptspi_pci_table, 1561 .probe = mptspi_probe, 1562 .remove = mptspi_remove, 1563 .shutdown = mptscsih_shutdown, 1564 #ifdef CONFIG_PM 1565 .suspend = mptscsih_suspend, 1566 .resume = mptspi_resume, 1567 #endif 1568 }; 1569 1570 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1571 /** 1572 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer. 1573 * 1574 * Returns 0 for success, non-zero for failure. 1575 */ 1576 static int __init 1577 mptspi_init(void) 1578 { 1579 int error; 1580 1581 show_mptmod_ver(my_NAME, my_VERSION); 1582 1583 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions); 1584 if (!mptspi_transport_template) 1585 return -ENODEV; 1586 1587 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER, 1588 "mptscsih_io_done"); 1589 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER, 1590 "mptscsih_taskmgmt_complete"); 1591 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, 1592 MPTSPI_DRIVER, "mptscsih_scandv_complete"); 1593 1594 mpt_event_register(mptspiDoneCtx, mptspi_event_process); 1595 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset); 1596 1597 error = pci_register_driver(&mptspi_driver); 1598 if (error) 1599 spi_release_transport(mptspi_transport_template); 1600 1601 return error; 1602 } 1603 1604 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1605 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1606 /** 1607 * mptspi_exit - Unregisters MPT adapter(s) 1608 */ 1609 static void __exit 1610 mptspi_exit(void) 1611 { 1612 pci_unregister_driver(&mptspi_driver); 1613 1614 mpt_reset_deregister(mptspiDoneCtx); 1615 mpt_event_deregister(mptspiDoneCtx); 1616 1617 mpt_deregister(mptspiInternalCtx); 1618 mpt_deregister(mptspiTaskCtx); 1619 mpt_deregister(mptspiDoneCtx); 1620 spi_release_transport(mptspi_transport_template); 1621 } 1622 1623 module_init(mptspi_init); 1624 module_exit(mptspi_exit); 1625