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