1 /* 2 * linux/drivers/message/fusion/mptspi.c 3 * For use with LSI Logic PCI chip/adapter(s) 4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware. 5 * 6 * Copyright (c) 1999-2007 LSI Logic 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/init.h> 50 #include <linux/errno.h> 51 #include <linux/kdev_t.h> 52 #include <linux/blkdev.h> 53 #include <linux/delay.h> /* for mdelay */ 54 #include <linux/interrupt.h> /* needed for in_interrupt() proto */ 55 #include <linux/reboot.h> /* notifier code */ 56 #include <linux/workqueue.h> 57 #include <linux/raid_class.h> 58 59 #include <scsi/scsi.h> 60 #include <scsi/scsi_cmnd.h> 61 #include <scsi/scsi_device.h> 62 #include <scsi/scsi_host.h> 63 #include <scsi/scsi_tcq.h> 64 #include <scsi/scsi_transport.h> 65 #include <scsi/scsi_transport_spi.h> 66 #include <scsi/scsi_dbg.h> 67 68 #include "mptbase.h" 69 #include "mptscsih.h" 70 71 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 72 #define my_NAME "Fusion MPT SPI Host driver" 73 #define my_VERSION MPT_LINUX_VERSION_COMMON 74 #define MYNAM "mptspi" 75 76 MODULE_AUTHOR(MODULEAUTHOR); 77 MODULE_DESCRIPTION(my_NAME); 78 MODULE_LICENSE("GPL"); 79 MODULE_VERSION(my_VERSION); 80 81 /* Command line args */ 82 static int mpt_saf_te = MPTSCSIH_SAF_TE; 83 module_param(mpt_saf_te, int, 0); 84 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)"); 85 86 static void mptspi_write_offset(struct scsi_target *, int); 87 static void mptspi_write_width(struct scsi_target *, int); 88 static int mptspi_write_spi_device_pg1(struct scsi_target *, 89 struct _CONFIG_PAGE_SCSI_DEVICE_1 *); 90 91 static struct scsi_transport_template *mptspi_transport_template = NULL; 92 93 static int mptspiDoneCtx = -1; 94 static int mptspiTaskCtx = -1; 95 static int mptspiInternalCtx = -1; /* Used only for internal commands */ 96 97 /** 98 * mptspi_setTargetNegoParms - Update the target negotiation parameters 99 * @hd: Pointer to a SCSI Host Structure 100 * @target: per target private data 101 * @sdev: SCSI device 102 * 103 * Update the target negotiation parameters based on the the Inquiry 104 * data, adapter capabilities, and NVRAM settings. 105 **/ 106 static void 107 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target, 108 struct scsi_device *sdev) 109 { 110 SpiCfgData *pspi_data = &hd->ioc->spi_data; 111 int id = (int) target->id; 112 int nvram; 113 u8 width = MPT_NARROW; 114 u8 factor = MPT_ASYNC; 115 u8 offset = 0; 116 u8 nfactor; 117 u8 noQas = 1; 118 119 target->negoFlags = pspi_data->noQas; 120 121 if (sdev->scsi_level < SCSI_2) { 122 width = 0; 123 factor = MPT_ULTRA2; 124 offset = pspi_data->maxSyncOffset; 125 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES; 126 } else { 127 if (scsi_device_wide(sdev)) 128 width = 1; 129 130 if (scsi_device_sync(sdev)) { 131 factor = pspi_data->minSyncFactor; 132 if (!scsi_device_dt(sdev)) 133 factor = MPT_ULTRA2; 134 else { 135 if (!scsi_device_ius(sdev) && 136 !scsi_device_qas(sdev)) 137 factor = MPT_ULTRA160; 138 else { 139 factor = MPT_ULTRA320; 140 if (scsi_device_qas(sdev)) { 141 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id)); 142 noQas = 0; 143 } 144 if (sdev->type == TYPE_TAPE && 145 scsi_device_ius(sdev)) 146 target->negoFlags |= MPT_TAPE_NEGO_IDP; 147 } 148 } 149 offset = pspi_data->maxSyncOffset; 150 151 /* If RAID, never disable QAS 152 * else if non RAID, do not disable 153 * QAS if bit 1 is set 154 * bit 1 QAS support, non-raid only 155 * bit 0 IU support 156 */ 157 if (target->raidVolume == 1) 158 noQas = 0; 159 } else { 160 factor = MPT_ASYNC; 161 offset = 0; 162 } 163 } 164 165 if (!sdev->tagged_supported) 166 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES; 167 168 /* Update tflags based on NVRAM settings. (SCSI only) 169 */ 170 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) { 171 nvram = pspi_data->nvram[id]; 172 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8; 173 174 if (width) 175 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1; 176 177 if (offset > 0) { 178 /* Ensure factor is set to the 179 * maximum of: adapter, nvram, inquiry 180 */ 181 if (nfactor) { 182 if (nfactor < pspi_data->minSyncFactor ) 183 nfactor = pspi_data->minSyncFactor; 184 185 factor = max(factor, nfactor); 186 if (factor == MPT_ASYNC) 187 offset = 0; 188 } else { 189 offset = 0; 190 factor = MPT_ASYNC; 191 } 192 } else { 193 factor = MPT_ASYNC; 194 } 195 } 196 197 /* Make sure data is consistent 198 */ 199 if ((!width) && (factor < MPT_ULTRA2)) 200 factor = MPT_ULTRA2; 201 202 /* Save the data to the target structure. 203 */ 204 target->minSyncFactor = factor; 205 target->maxOffset = offset; 206 target->maxWidth = width; 207 208 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO; 209 210 /* Disable unused features. 211 */ 212 if (!width) 213 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE; 214 215 if (!offset) 216 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC; 217 218 if ( factor > MPT_ULTRA320 ) 219 noQas = 0; 220 221 if (noQas && (pspi_data->noQas == 0)) { 222 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS; 223 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS; 224 225 /* Disable QAS in a mixed configuration case 226 */ 227 228 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id)); 229 } 230 } 231 232 /** 233 * mptspi_writeIOCPage4 - write IOC Page 4 234 * @hd: Pointer to a SCSI Host Structure 235 * @channel: channel number 236 * @id: write IOC Page4 for this ID & Bus 237 * 238 * Return: -EAGAIN if unable to obtain a Message Frame 239 * or 0 if success. 240 * 241 * Remark: We do not wait for a return, write pages sequentially. 242 **/ 243 static int 244 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id) 245 { 246 MPT_ADAPTER *ioc = hd->ioc; 247 Config_t *pReq; 248 IOCPage4_t *IOCPage4Ptr; 249 MPT_FRAME_HDR *mf; 250 dma_addr_t dataDma; 251 u16 req_idx; 252 u32 frameOffset; 253 u32 flagsLength; 254 int ii; 255 256 /* Get a MF for this command. 257 */ 258 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) { 259 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n", 260 ioc->name)); 261 return -EAGAIN; 262 } 263 264 /* Set the request and the data pointers. 265 * Place data at end of MF. 266 */ 267 pReq = (Config_t *)mf; 268 269 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 270 frameOffset = ioc->req_sz - sizeof(IOCPage4_t); 271 272 /* Complete the request frame (same for all requests). 273 */ 274 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 275 pReq->Reserved = 0; 276 pReq->ChainOffset = 0; 277 pReq->Function = MPI_FUNCTION_CONFIG; 278 pReq->ExtPageLength = 0; 279 pReq->ExtPageType = 0; 280 pReq->MsgFlags = 0; 281 for (ii=0; ii < 8; ii++) { 282 pReq->Reserved2[ii] = 0; 283 } 284 285 IOCPage4Ptr = ioc->spi_data.pIocPg4; 286 dataDma = ioc->spi_data.IocPg4_dma; 287 ii = IOCPage4Ptr->ActiveSEP++; 288 IOCPage4Ptr->SEP[ii].SEPTargetID = id; 289 IOCPage4Ptr->SEP[ii].SEPBus = channel; 290 pReq->Header = IOCPage4Ptr->Header; 291 pReq->PageAddress = cpu_to_le32(id | (channel << 8 )); 292 293 /* Add a SGE to the config request. 294 */ 295 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE | 296 (IOCPage4Ptr->Header.PageLength + ii) * 4; 297 298 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma); 299 300 ddvprintk((MYIOC_s_INFO_FMT 301 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n", 302 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel)); 303 304 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf); 305 306 return 0; 307 } 308 309 /** 310 * mptspi_initTarget - Target, LUN alloc/free functionality. 311 * @hd: Pointer to MPT_SCSI_HOST structure 312 * @vtarget: per target private data 313 * @sdev: SCSI device 314 * 315 * NOTE: It's only SAFE to call this routine if data points to 316 * sane & valid STANDARD INQUIRY data! 317 * 318 * Allocate and initialize memory for this target. 319 * Save inquiry data. 320 * 321 **/ 322 static void 323 mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, 324 struct scsi_device *sdev) 325 { 326 327 /* Is LUN supported? If so, upper 2 bits will be 0 328 * in first byte of inquiry data. 329 */ 330 if (sdev->inq_periph_qual != 0) 331 return; 332 333 if (vtarget == NULL) 334 return; 335 336 vtarget->type = sdev->type; 337 338 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) { 339 /* Treat all Processors as SAF-TE if 340 * command line option is set */ 341 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; 342 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id); 343 }else if ((sdev->type == TYPE_PROCESSOR) && 344 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) { 345 if (sdev->inquiry_len > 49 ) { 346 if (sdev->inquiry[44] == 'S' && 347 sdev->inquiry[45] == 'A' && 348 sdev->inquiry[46] == 'F' && 349 sdev->inquiry[47] == '-' && 350 sdev->inquiry[48] == 'T' && 351 sdev->inquiry[49] == 'E' ) { 352 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; 353 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id); 354 } 355 } 356 } 357 mptspi_setTargetNegoParms(hd, vtarget, sdev); 358 } 359 360 /** 361 * mptspi_is_raid - Determines whether target is belonging to volume 362 * @hd: Pointer to a SCSI HOST structure 363 * @id: target device id 364 * 365 * Return: 366 * non-zero = true 367 * zero = false 368 * 369 */ 370 static int 371 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id) 372 { 373 int i, rc = 0; 374 375 if (!hd->ioc->raid_data.pIocPg2) 376 goto out; 377 378 if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes) 379 goto out; 380 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 381 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) { 382 rc = 1; 383 goto out; 384 } 385 } 386 387 out: 388 return rc; 389 } 390 391 static int mptspi_target_alloc(struct scsi_target *starget) 392 { 393 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 394 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata; 395 VirtTarget *vtarget; 396 397 if (hd == NULL) 398 return -ENODEV; 399 400 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL); 401 if (!vtarget) 402 return -ENOMEM; 403 404 vtarget->ioc_id = hd->ioc->id; 405 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES; 406 vtarget->id = (u8)starget->id; 407 vtarget->channel = (u8)starget->channel; 408 vtarget->starget = starget; 409 starget->hostdata = vtarget; 410 411 if (starget->channel == 1) { 412 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0) 413 return 0; 414 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT; 415 /* The real channel for this device is zero */ 416 vtarget->channel = 0; 417 /* The actual physdisknum (for RAID passthrough) */ 418 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0, 419 starget->id); 420 } 421 422 if (starget->channel == 0 && 423 mptspi_is_raid(hd, starget->id)) { 424 vtarget->raidVolume = 1; 425 ddvprintk((KERN_INFO 426 "RAID Volume @ channel=%d id=%d\n", starget->channel, 427 starget->id)); 428 } 429 430 if (hd->ioc->spi_data.nvram && 431 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) { 432 u32 nvram = hd->ioc->spi_data.nvram[starget->id]; 433 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT; 434 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1; 435 } else { 436 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor; 437 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth; 438 } 439 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset; 440 441 spi_offset(starget) = 0; 442 mptspi_write_width(starget, 0); 443 444 return 0; 445 } 446 447 static void 448 mptspi_target_destroy(struct scsi_target *starget) 449 { 450 if (starget->hostdata) 451 kfree(starget->hostdata); 452 starget->hostdata = NULL; 453 } 454 455 /** 456 * mptspi_print_write_nego - negotiation parameters debug info that is being sent 457 * @hd: Pointer to a SCSI HOST structure 458 * @starget: SCSI target 459 * @ii: negotiation parameters 460 * 461 */ 462 static void 463 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii) 464 { 465 ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x" 466 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n", 467 hd->ioc->name, starget->id, ii, 468 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "", 469 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF), 470 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "", 471 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "", 472 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "", 473 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "", 474 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "", 475 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "", 476 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "", 477 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "")); 478 } 479 480 /** 481 * mptspi_print_read_nego - negotiation parameters debug info that is being read 482 * @hd: Pointer to a SCSI HOST structure 483 * @starget: SCSI target 484 * @ii: negotiation parameters 485 * 486 */ 487 static void 488 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii) 489 { 490 ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x" 491 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n", 492 hd->ioc->name, starget->id, ii, 493 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "", 494 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF), 495 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "", 496 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "", 497 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "", 498 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "", 499 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "", 500 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "", 501 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "", 502 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "")); 503 } 504 505 static int mptspi_read_spi_device_pg0(struct scsi_target *starget, 506 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0) 507 { 508 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 509 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata; 510 struct _MPT_ADAPTER *ioc = hd->ioc; 511 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0; 512 dma_addr_t pg0_dma; 513 int size; 514 struct _x_config_parms cfg; 515 struct _CONFIG_PAGE_HEADER hdr; 516 int err = -EBUSY; 517 518 /* No SPI parameters for RAID devices */ 519 if (starget->channel == 0 && 520 mptspi_is_raid(hd, starget->id)) 521 return -1; 522 523 size = ioc->spi_data.sdp0length * 4; 524 /* 525 if (ioc->spi_data.sdp0length & 1) 526 size += size + 4; 527 size += 2048; 528 */ 529 530 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL); 531 if (pg0 == NULL) { 532 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n"); 533 return -EINVAL; 534 } 535 536 memset(&hdr, 0, sizeof(hdr)); 537 538 hdr.PageVersion = ioc->spi_data.sdp0version; 539 hdr.PageLength = ioc->spi_data.sdp0length; 540 hdr.PageNumber = 0; 541 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 542 543 memset(&cfg, 0, sizeof(cfg)); 544 545 cfg.cfghdr.hdr = &hdr; 546 cfg.physAddr = pg0_dma; 547 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 548 cfg.dir = 0; 549 cfg.pageAddr = starget->id; 550 551 if (mpt_config(ioc, &cfg)) { 552 starget_printk(KERN_ERR, starget, "mpt_config failed\n"); 553 goto out_free; 554 } 555 err = 0; 556 memcpy(pass_pg0, pg0, size); 557 558 mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters)); 559 560 out_free: 561 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma); 562 return err; 563 } 564 565 static u32 mptspi_getRP(struct scsi_target *starget) 566 { 567 u32 nego = 0; 568 569 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0; 570 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0; 571 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0; 572 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0; 573 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0; 574 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0; 575 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0; 576 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0; 577 578 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK; 579 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK; 580 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0; 581 582 return nego; 583 } 584 585 static void mptspi_read_parameters(struct scsi_target *starget) 586 { 587 int nego; 588 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0; 589 590 mptspi_read_spi_device_pg0(starget, &pg0); 591 592 nego = le32_to_cpu(pg0.NegotiatedParameters); 593 594 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0; 595 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0; 596 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0; 597 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0; 598 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0; 599 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0; 600 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0; 601 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0; 602 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD; 603 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET; 604 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0; 605 } 606 607 static int 608 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id) 609 { 610 MpiRaidActionRequest_t *pReq; 611 MPT_FRAME_HDR *mf; 612 613 /* Get and Populate a free Frame 614 */ 615 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) { 616 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n", 617 hd->ioc->name)); 618 return -EAGAIN; 619 } 620 pReq = (MpiRaidActionRequest_t *)mf; 621 if (quiesce) 622 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO; 623 else 624 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO; 625 pReq->Reserved1 = 0; 626 pReq->ChainOffset = 0; 627 pReq->Function = MPI_FUNCTION_RAID_ACTION; 628 pReq->VolumeID = id; 629 pReq->VolumeBus = channel; 630 pReq->PhysDiskNum = 0; 631 pReq->MsgFlags = 0; 632 pReq->Reserved2 = 0; 633 pReq->ActionDataWord = 0; /* Reserved for this action */ 634 635 mpt_add_sge((char *)&pReq->ActionDataSGE, 636 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1); 637 638 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n", 639 hd->ioc->name, pReq->Action, channel, id)); 640 641 hd->pLocal = NULL; 642 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */ 643 hd->scandv_wait_done = 0; 644 645 /* Save cmd pointer, for resource free if timeout or 646 * FW reload occurs 647 */ 648 hd->cmdPtr = mf; 649 650 add_timer(&hd->timer); 651 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf); 652 wait_event(hd->scandv_waitq, hd->scandv_wait_done); 653 654 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0)) 655 return -1; 656 657 return 0; 658 } 659 660 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd, 661 struct scsi_device *sdev) 662 { 663 VirtTarget *vtarget = scsi_target(sdev)->hostdata; 664 665 /* no DV on RAID devices */ 666 if (sdev->channel == 0 && 667 mptspi_is_raid(hd, sdev->id)) 668 return; 669 670 /* If this is a piece of a RAID, then quiesce first */ 671 if (sdev->channel == 1 && 672 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) { 673 starget_printk(KERN_ERR, scsi_target(sdev), 674 "Integrated RAID quiesce failed\n"); 675 return; 676 } 677 678 hd->spi_pending |= (1 << sdev->id); 679 spi_dv_device(sdev); 680 hd->spi_pending &= ~(1 << sdev->id); 681 682 if (sdev->channel == 1 && 683 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0) 684 starget_printk(KERN_ERR, scsi_target(sdev), 685 "Integrated RAID resume failed\n"); 686 687 mptspi_read_parameters(sdev->sdev_target); 688 spi_display_xfer_agreement(sdev->sdev_target); 689 mptspi_read_parameters(sdev->sdev_target); 690 } 691 692 static int mptspi_slave_alloc(struct scsi_device *sdev) 693 { 694 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata; 695 VirtTarget *vtarget; 696 VirtDevice *vdev; 697 struct scsi_target *starget; 698 699 if (sdev->channel == 1 && 700 mptscsih_is_phys_disk(hd->ioc, 0, sdev->id) == 0) 701 return -ENXIO; 702 703 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL); 704 if (!vdev) { 705 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n", 706 hd->ioc->name, sizeof(VirtDevice)); 707 return -ENOMEM; 708 } 709 710 vdev->lun = sdev->lun; 711 sdev->hostdata = vdev; 712 713 starget = scsi_target(sdev); 714 vtarget = starget->hostdata; 715 vdev->vtarget = vtarget; 716 vtarget->num_luns++; 717 718 if (sdev->channel == 1) 719 sdev->no_uld_attach = 1; 720 721 return 0; 722 } 723 724 static int mptspi_slave_configure(struct scsi_device *sdev) 725 { 726 struct _MPT_SCSI_HOST *hd = 727 (struct _MPT_SCSI_HOST *)sdev->host->hostdata; 728 VirtTarget *vtarget = scsi_target(sdev)->hostdata; 729 int ret; 730 731 mptspi_initTarget(hd, vtarget, sdev); 732 733 ret = mptscsih_slave_configure(sdev); 734 735 if (ret) 736 return ret; 737 738 ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x" 739 " max_offset=0x%02x max_width=%d\n", hd->ioc->name, 740 sdev->id, spi_min_period(scsi_target(sdev)), 741 spi_max_offset(scsi_target(sdev)), 742 spi_max_width(scsi_target(sdev)))); 743 744 if ((sdev->channel == 1 || 745 !(mptspi_is_raid(hd, sdev->id))) && 746 !spi_initial_dv(sdev->sdev_target)) 747 mptspi_dv_device(hd, sdev); 748 749 return 0; 750 } 751 752 static int 753 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 754 { 755 struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata; 756 VirtDevice *vdev = SCpnt->device->hostdata; 757 758 if (!vdev || !vdev->vtarget) { 759 SCpnt->result = DID_NO_CONNECT << 16; 760 done(SCpnt); 761 return 0; 762 } 763 764 if (SCpnt->device->channel == 1 && 765 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) { 766 SCpnt->result = DID_NO_CONNECT << 16; 767 done(SCpnt); 768 return 0; 769 } 770 771 #ifdef MPT_DEBUG_DV 772 if (spi_dv_pending(scsi_target(SCpnt->device))) 773 scsi_print_command(SCpnt); 774 #endif 775 776 return mptscsih_qcmd(SCpnt,done); 777 } 778 779 static void mptspi_slave_destroy(struct scsi_device *sdev) 780 { 781 struct scsi_target *starget = scsi_target(sdev); 782 VirtTarget *vtarget = starget->hostdata; 783 VirtDevice *vdevice = sdev->hostdata; 784 785 /* Will this be the last lun on a non-raid device? */ 786 if (vtarget->num_luns == 1 && vdevice->configured_lun) { 787 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 788 789 /* Async Narrow */ 790 pg1.RequestedParameters = 0; 791 pg1.Reserved = 0; 792 pg1.Configuration = 0; 793 794 mptspi_write_spi_device_pg1(starget, &pg1); 795 } 796 797 mptscsih_slave_destroy(sdev); 798 } 799 800 static struct scsi_host_template mptspi_driver_template = { 801 .module = THIS_MODULE, 802 .proc_name = "mptspi", 803 .proc_info = mptscsih_proc_info, 804 .name = "MPT SPI Host", 805 .info = mptscsih_info, 806 .queuecommand = mptspi_qcmd, 807 .target_alloc = mptspi_target_alloc, 808 .slave_alloc = mptspi_slave_alloc, 809 .slave_configure = mptspi_slave_configure, 810 .target_destroy = mptspi_target_destroy, 811 .slave_destroy = mptspi_slave_destroy, 812 .change_queue_depth = mptscsih_change_queue_depth, 813 .eh_abort_handler = mptscsih_abort, 814 .eh_device_reset_handler = mptscsih_dev_reset, 815 .eh_bus_reset_handler = mptscsih_bus_reset, 816 .eh_host_reset_handler = mptscsih_host_reset, 817 .bios_param = mptscsih_bios_param, 818 .can_queue = MPT_SCSI_CAN_QUEUE, 819 .this_id = -1, 820 .sg_tablesize = MPT_SCSI_SG_DEPTH, 821 .max_sectors = 8192, 822 .cmd_per_lun = 7, 823 .use_clustering = ENABLE_CLUSTERING, 824 }; 825 826 static int mptspi_write_spi_device_pg1(struct scsi_target *starget, 827 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1) 828 { 829 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 830 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata; 831 struct _MPT_ADAPTER *ioc = hd->ioc; 832 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1; 833 dma_addr_t pg1_dma; 834 int size; 835 struct _x_config_parms cfg; 836 struct _CONFIG_PAGE_HEADER hdr; 837 int err = -EBUSY; 838 839 /* don't allow updating nego parameters on RAID devices */ 840 if (starget->channel == 0 && 841 mptspi_is_raid(hd, starget->id)) 842 return -1; 843 844 size = ioc->spi_data.sdp1length * 4; 845 846 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL); 847 if (pg1 == NULL) { 848 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n"); 849 return -EINVAL; 850 } 851 852 memset(&hdr, 0, sizeof(hdr)); 853 854 hdr.PageVersion = ioc->spi_data.sdp1version; 855 hdr.PageLength = ioc->spi_data.sdp1length; 856 hdr.PageNumber = 1; 857 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 858 859 memset(&cfg, 0, sizeof(cfg)); 860 861 cfg.cfghdr.hdr = &hdr; 862 cfg.physAddr = pg1_dma; 863 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 864 cfg.dir = 1; 865 cfg.pageAddr = starget->id; 866 867 memcpy(pg1, pass_pg1, size); 868 869 pg1->Header.PageVersion = hdr.PageVersion; 870 pg1->Header.PageLength = hdr.PageLength; 871 pg1->Header.PageNumber = hdr.PageNumber; 872 pg1->Header.PageType = hdr.PageType; 873 874 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters)); 875 876 if (mpt_config(ioc, &cfg)) { 877 starget_printk(KERN_ERR, starget, "mpt_config failed\n"); 878 goto out_free; 879 } 880 err = 0; 881 882 out_free: 883 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma); 884 return err; 885 } 886 887 static void mptspi_write_offset(struct scsi_target *starget, int offset) 888 { 889 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 890 u32 nego; 891 892 if (offset < 0) 893 offset = 0; 894 895 if (offset > 255) 896 offset = 255; 897 898 if (spi_offset(starget) == -1) 899 mptspi_read_parameters(starget); 900 901 spi_offset(starget) = offset; 902 903 nego = mptspi_getRP(starget); 904 905 pg1.RequestedParameters = cpu_to_le32(nego); 906 pg1.Reserved = 0; 907 pg1.Configuration = 0; 908 909 mptspi_write_spi_device_pg1(starget, &pg1); 910 } 911 912 static void mptspi_write_period(struct scsi_target *starget, int period) 913 { 914 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 915 u32 nego; 916 917 if (period < 8) 918 period = 8; 919 920 if (period > 255) 921 period = 255; 922 923 if (spi_period(starget) == -1) 924 mptspi_read_parameters(starget); 925 926 if (period == 8) { 927 spi_iu(starget) = 1; 928 spi_dt(starget) = 1; 929 } else if (period == 9) { 930 spi_dt(starget) = 1; 931 } 932 933 spi_period(starget) = period; 934 935 nego = mptspi_getRP(starget); 936 937 pg1.RequestedParameters = cpu_to_le32(nego); 938 pg1.Reserved = 0; 939 pg1.Configuration = 0; 940 941 mptspi_write_spi_device_pg1(starget, &pg1); 942 } 943 944 static void mptspi_write_dt(struct scsi_target *starget, int dt) 945 { 946 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 947 u32 nego; 948 949 if (spi_period(starget) == -1) 950 mptspi_read_parameters(starget); 951 952 if (!dt && spi_period(starget) < 10) 953 spi_period(starget) = 10; 954 955 spi_dt(starget) = dt; 956 957 nego = mptspi_getRP(starget); 958 959 960 pg1.RequestedParameters = cpu_to_le32(nego); 961 pg1.Reserved = 0; 962 pg1.Configuration = 0; 963 964 mptspi_write_spi_device_pg1(starget, &pg1); 965 } 966 967 static void mptspi_write_iu(struct scsi_target *starget, int iu) 968 { 969 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 970 u32 nego; 971 972 if (spi_period(starget) == -1) 973 mptspi_read_parameters(starget); 974 975 if (!iu && spi_period(starget) < 9) 976 spi_period(starget) = 9; 977 978 spi_iu(starget) = iu; 979 980 nego = mptspi_getRP(starget); 981 982 pg1.RequestedParameters = cpu_to_le32(nego); 983 pg1.Reserved = 0; 984 pg1.Configuration = 0; 985 986 mptspi_write_spi_device_pg1(starget, &pg1); 987 } 988 989 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \ 990 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\ 991 { \ 992 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \ 993 u32 nego; \ 994 \ 995 spi_##parm(starget) = parm; \ 996 \ 997 nego = mptspi_getRP(starget); \ 998 \ 999 pg1.RequestedParameters = cpu_to_le32(nego); \ 1000 pg1.Reserved = 0; \ 1001 pg1.Configuration = 0; \ 1002 \ 1003 mptspi_write_spi_device_pg1(starget, &pg1); \ 1004 } 1005 1006 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm) 1007 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow) 1008 MPTSPI_SIMPLE_TRANSPORT_PARM(rti) 1009 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs) 1010 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en) 1011 1012 static void mptspi_write_qas(struct scsi_target *starget, int qas) 1013 { 1014 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1015 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1016 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata; 1017 VirtTarget *vtarget = starget->hostdata; 1018 u32 nego; 1019 1020 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) || 1021 hd->ioc->spi_data.noQas) 1022 spi_qas(starget) = 0; 1023 else 1024 spi_qas(starget) = qas; 1025 1026 nego = mptspi_getRP(starget); 1027 1028 pg1.RequestedParameters = cpu_to_le32(nego); 1029 pg1.Reserved = 0; 1030 pg1.Configuration = 0; 1031 1032 mptspi_write_spi_device_pg1(starget, &pg1); 1033 } 1034 1035 static void mptspi_write_width(struct scsi_target *starget, int width) 1036 { 1037 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1038 u32 nego; 1039 1040 if (!width) { 1041 spi_dt(starget) = 0; 1042 if (spi_period(starget) < 10) 1043 spi_period(starget) = 10; 1044 } 1045 1046 spi_width(starget) = width; 1047 1048 nego = mptspi_getRP(starget); 1049 1050 pg1.RequestedParameters = cpu_to_le32(nego); 1051 pg1.Reserved = 0; 1052 pg1.Configuration = 0; 1053 1054 mptspi_write_spi_device_pg1(starget, &pg1); 1055 } 1056 1057 struct work_queue_wrapper { 1058 struct work_struct work; 1059 struct _MPT_SCSI_HOST *hd; 1060 int disk; 1061 }; 1062 1063 static void mpt_work_wrapper(struct work_struct *work) 1064 { 1065 struct work_queue_wrapper *wqw = 1066 container_of(work, struct work_queue_wrapper, work); 1067 struct _MPT_SCSI_HOST *hd = wqw->hd; 1068 struct Scsi_Host *shost = hd->ioc->sh; 1069 struct scsi_device *sdev; 1070 int disk = wqw->disk; 1071 struct _CONFIG_PAGE_IOC_3 *pg3; 1072 1073 kfree(wqw); 1074 1075 mpt_findImVolumes(hd->ioc); 1076 pg3 = hd->ioc->raid_data.pIocPg3; 1077 if (!pg3) 1078 return; 1079 1080 shost_for_each_device(sdev,shost) { 1081 struct scsi_target *starget = scsi_target(sdev); 1082 VirtTarget *vtarget = starget->hostdata; 1083 1084 /* only want to search RAID components */ 1085 if (sdev->channel != 1) 1086 continue; 1087 1088 /* The id is the raid PhysDiskNum, even if 1089 * starget->id is the actual target address */ 1090 if(vtarget->id != disk) 1091 continue; 1092 1093 starget_printk(KERN_INFO, vtarget->starget, 1094 "Integrated RAID requests DV of new device\n"); 1095 mptspi_dv_device(hd, sdev); 1096 } 1097 shost_printk(KERN_INFO, shost, 1098 "Integrated RAID detects new device %d\n", disk); 1099 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1); 1100 } 1101 1102 1103 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk) 1104 { 1105 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC); 1106 1107 if (!wqw) { 1108 shost_printk(KERN_ERR, hd->ioc->sh, 1109 "Failed to act on RAID event for physical disk %d\n", 1110 disk); 1111 return; 1112 } 1113 INIT_WORK(&wqw->work, mpt_work_wrapper); 1114 wqw->hd = hd; 1115 wqw->disk = disk; 1116 1117 schedule_work(&wqw->work); 1118 } 1119 1120 static int 1121 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) 1122 { 1123 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF; 1124 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata; 1125 1126 if (hd && event == MPI_EVENT_INTEGRATED_RAID) { 1127 int reason 1128 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16; 1129 1130 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) { 1131 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24; 1132 mpt_dv_raid(hd, disk); 1133 } 1134 } 1135 return mptscsih_event_process(ioc, pEvReply); 1136 } 1137 1138 static int 1139 mptspi_deny_binding(struct scsi_target *starget) 1140 { 1141 struct _MPT_SCSI_HOST *hd = 1142 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata; 1143 return ((mptspi_is_raid(hd, starget->id)) && 1144 starget->channel == 0) ? 1 : 0; 1145 } 1146 1147 static struct spi_function_template mptspi_transport_functions = { 1148 .get_offset = mptspi_read_parameters, 1149 .set_offset = mptspi_write_offset, 1150 .show_offset = 1, 1151 .get_period = mptspi_read_parameters, 1152 .set_period = mptspi_write_period, 1153 .show_period = 1, 1154 .get_width = mptspi_read_parameters, 1155 .set_width = mptspi_write_width, 1156 .show_width = 1, 1157 .get_iu = mptspi_read_parameters, 1158 .set_iu = mptspi_write_iu, 1159 .show_iu = 1, 1160 .get_dt = mptspi_read_parameters, 1161 .set_dt = mptspi_write_dt, 1162 .show_dt = 1, 1163 .get_qas = mptspi_read_parameters, 1164 .set_qas = mptspi_write_qas, 1165 .show_qas = 1, 1166 .get_wr_flow = mptspi_read_parameters, 1167 .set_wr_flow = mptspi_write_wr_flow, 1168 .show_wr_flow = 1, 1169 .get_rd_strm = mptspi_read_parameters, 1170 .set_rd_strm = mptspi_write_rd_strm, 1171 .show_rd_strm = 1, 1172 .get_rti = mptspi_read_parameters, 1173 .set_rti = mptspi_write_rti, 1174 .show_rti = 1, 1175 .get_pcomp_en = mptspi_read_parameters, 1176 .set_pcomp_en = mptspi_write_pcomp_en, 1177 .show_pcomp_en = 1, 1178 .get_hold_mcs = mptspi_read_parameters, 1179 .set_hold_mcs = mptspi_write_hold_mcs, 1180 .show_hold_mcs = 1, 1181 .deny_binding = mptspi_deny_binding, 1182 }; 1183 1184 /**************************************************************************** 1185 * Supported hardware 1186 */ 1187 1188 static struct pci_device_id mptspi_pci_table[] = { 1189 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030, 1190 PCI_ANY_ID, PCI_ANY_ID }, 1191 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035, 1192 PCI_ANY_ID, PCI_ANY_ID }, 1193 {0} /* Terminating entry */ 1194 }; 1195 MODULE_DEVICE_TABLE(pci, mptspi_pci_table); 1196 1197 1198 /* 1199 * renegotiate for a given target 1200 */ 1201 static void 1202 mptspi_dv_renegotiate_work(struct work_struct *work) 1203 { 1204 struct work_queue_wrapper *wqw = 1205 container_of(work, struct work_queue_wrapper, work); 1206 struct _MPT_SCSI_HOST *hd = wqw->hd; 1207 struct scsi_device *sdev; 1208 struct scsi_target *starget; 1209 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1210 u32 nego; 1211 1212 kfree(wqw); 1213 1214 if (hd->spi_pending) { 1215 shost_for_each_device(sdev, hd->ioc->sh) { 1216 if (hd->spi_pending & (1 << sdev->id)) 1217 continue; 1218 starget = scsi_target(sdev); 1219 nego = mptspi_getRP(starget); 1220 pg1.RequestedParameters = cpu_to_le32(nego); 1221 pg1.Reserved = 0; 1222 pg1.Configuration = 0; 1223 mptspi_write_spi_device_pg1(starget, &pg1); 1224 } 1225 } else { 1226 shost_for_each_device(sdev, hd->ioc->sh) 1227 mptspi_dv_device(hd, sdev); 1228 } 1229 } 1230 1231 static void 1232 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd) 1233 { 1234 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC); 1235 1236 if (!wqw) 1237 return; 1238 1239 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work); 1240 wqw->hd = hd; 1241 1242 schedule_work(&wqw->work); 1243 } 1244 1245 /* 1246 * spi module reset handler 1247 */ 1248 static int 1249 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 1250 { 1251 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata; 1252 int rc; 1253 1254 rc = mptscsih_ioc_reset(ioc, reset_phase); 1255 1256 if (reset_phase == MPT_IOC_POST_RESET) 1257 mptspi_dv_renegotiate(hd); 1258 1259 return rc; 1260 } 1261 1262 #ifdef CONFIG_PM 1263 /* 1264 * spi module resume handler 1265 */ 1266 static int 1267 mptspi_resume(struct pci_dev *pdev) 1268 { 1269 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1270 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata; 1271 int rc; 1272 1273 rc = mptscsih_resume(pdev); 1274 mptspi_dv_renegotiate(hd); 1275 1276 return rc; 1277 } 1278 #endif 1279 1280 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1281 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1282 /* 1283 * mptspi_probe - Installs scsi devices per bus. 1284 * @pdev: Pointer to pci_dev structure 1285 * 1286 * Returns 0 for success, non-zero for failure. 1287 * 1288 */ 1289 static int 1290 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) 1291 { 1292 struct Scsi_Host *sh; 1293 MPT_SCSI_HOST *hd; 1294 MPT_ADAPTER *ioc; 1295 unsigned long flags; 1296 int ii; 1297 int numSGE = 0; 1298 int scale; 1299 int ioc_cap; 1300 int error=0; 1301 int r; 1302 1303 if ((r = mpt_attach(pdev,id)) != 0) 1304 return r; 1305 1306 ioc = pci_get_drvdata(pdev); 1307 ioc->DoneCtx = mptspiDoneCtx; 1308 ioc->TaskCtx = mptspiTaskCtx; 1309 ioc->InternalCtx = mptspiInternalCtx; 1310 1311 /* Added sanity check on readiness of the MPT adapter. 1312 */ 1313 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 1314 printk(MYIOC_s_WARN_FMT 1315 "Skipping because it's not operational!\n", 1316 ioc->name); 1317 error = -ENODEV; 1318 goto out_mptspi_probe; 1319 } 1320 1321 if (!ioc->active) { 1322 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 1323 ioc->name); 1324 error = -ENODEV; 1325 goto out_mptspi_probe; 1326 } 1327 1328 /* Sanity check - ensure at least 1 port is INITIATOR capable 1329 */ 1330 ioc_cap = 0; 1331 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) { 1332 if (ioc->pfacts[ii].ProtocolFlags & 1333 MPI_PORTFACTS_PROTOCOL_INITIATOR) 1334 ioc_cap ++; 1335 } 1336 1337 if (!ioc_cap) { 1338 printk(MYIOC_s_WARN_FMT 1339 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n", 1340 ioc->name, ioc); 1341 return 0; 1342 } 1343 1344 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST)); 1345 1346 if (!sh) { 1347 printk(MYIOC_s_WARN_FMT 1348 "Unable to register controller with SCSI subsystem\n", 1349 ioc->name); 1350 error = -1; 1351 goto out_mptspi_probe; 1352 } 1353 1354 spin_lock_irqsave(&ioc->FreeQlock, flags); 1355 1356 /* Attach the SCSI Host to the IOC structure 1357 */ 1358 ioc->sh = sh; 1359 1360 sh->io_port = 0; 1361 sh->n_io_port = 0; 1362 sh->irq = 0; 1363 1364 /* set 16 byte cdb's */ 1365 sh->max_cmd_len = 16; 1366 1367 /* Yikes! This is important! 1368 * Otherwise, by default, linux 1369 * only scans target IDs 0-7! 1370 * pfactsN->MaxDevices unreliable 1371 * (not supported in early 1372 * versions of the FW). 1373 * max_id = 1 + actual max id, 1374 * max_lun = 1 + actual last lun, 1375 * see hosts.h :o( 1376 */ 1377 sh->max_id = ioc->devices_per_bus; 1378 1379 sh->max_lun = MPT_LAST_LUN + 1; 1380 /* 1381 * If RAID Firmware Detected, setup virtual channel 1382 */ 1383 if (ioc->ir_firmware) 1384 sh->max_channel = 1; 1385 else 1386 sh->max_channel = 0; 1387 sh->this_id = ioc->pfacts[0].PortSCSIID; 1388 1389 /* Required entry. 1390 */ 1391 sh->unique_id = ioc->id; 1392 1393 /* Verify that we won't exceed the maximum 1394 * number of chain buffers 1395 * We can optimize: ZZ = req_sz/sizeof(SGE) 1396 * For 32bit SGE's: 1397 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 1398 * + (req_sz - 64)/sizeof(SGE) 1399 * A slightly different algorithm is required for 1400 * 64bit SGEs. 1401 */ 1402 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32)); 1403 if (sizeof(dma_addr_t) == sizeof(u64)) { 1404 numSGE = (scale - 1) * 1405 (ioc->facts.MaxChainDepth-1) + scale + 1406 (ioc->req_sz - 60) / (sizeof(dma_addr_t) + 1407 sizeof(u32)); 1408 } else { 1409 numSGE = 1 + (scale - 1) * 1410 (ioc->facts.MaxChainDepth-1) + scale + 1411 (ioc->req_sz - 64) / (sizeof(dma_addr_t) + 1412 sizeof(u32)); 1413 } 1414 1415 if (numSGE < sh->sg_tablesize) { 1416 /* Reset this value */ 1417 dprintk((MYIOC_s_INFO_FMT 1418 "Resetting sg_tablesize to %d from %d\n", 1419 ioc->name, numSGE, sh->sg_tablesize)); 1420 sh->sg_tablesize = numSGE; 1421 } 1422 1423 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 1424 1425 hd = (MPT_SCSI_HOST *) sh->hostdata; 1426 hd->ioc = ioc; 1427 1428 /* SCSI needs scsi_cmnd lookup table! 1429 * (with size equal to req_depth*PtrSz!) 1430 */ 1431 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 1432 if (!hd->ScsiLookup) { 1433 error = -ENOMEM; 1434 goto out_mptspi_probe; 1435 } 1436 1437 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n", 1438 ioc->name, hd->ScsiLookup)); 1439 1440 /* Clear the TM flags 1441 */ 1442 hd->tmPending = 0; 1443 hd->tmState = TM_STATE_NONE; 1444 hd->resetPending = 0; 1445 hd->abortSCpnt = NULL; 1446 1447 /* Clear the pointer used to store 1448 * single-threaded commands, i.e., those 1449 * issued during a bus scan, dv and 1450 * configuration pages. 1451 */ 1452 hd->cmdPtr = NULL; 1453 1454 /* Initialize this SCSI Hosts' timers 1455 * To use, set the timer expires field 1456 * and add_timer 1457 */ 1458 init_timer(&hd->timer); 1459 hd->timer.data = (unsigned long) hd; 1460 hd->timer.function = mptscsih_timer_expired; 1461 1462 ioc->spi_data.Saf_Te = mpt_saf_te; 1463 1464 hd->negoNvram = MPT_SCSICFG_USE_NVRAM; 1465 ddvprintk((MYIOC_s_INFO_FMT 1466 "saf_te %x\n", 1467 ioc->name, 1468 mpt_saf_te)); 1469 ioc->spi_data.noQas = 0; 1470 1471 init_waitqueue_head(&hd->scandv_waitq); 1472 hd->scandv_wait_done = 0; 1473 hd->last_queue_full = 0; 1474 hd->spi_pending = 0; 1475 1476 /* Some versions of the firmware don't support page 0; without 1477 * that we can't get the parameters */ 1478 if (hd->ioc->spi_data.sdp0length != 0) 1479 sh->transportt = mptspi_transport_template; 1480 1481 error = scsi_add_host (sh, &ioc->pcidev->dev); 1482 if(error) { 1483 dprintk((KERN_ERR MYNAM 1484 "scsi_add_host failed\n")); 1485 goto out_mptspi_probe; 1486 } 1487 1488 /* 1489 * issue internal bus reset 1490 */ 1491 if (ioc->spi_data.bus_reset) 1492 mptscsih_TMHandler(hd, 1493 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, 1494 0, 0, 0, 0, 5); 1495 1496 scsi_scan_host(sh); 1497 return 0; 1498 1499 out_mptspi_probe: 1500 1501 mptscsih_remove(pdev); 1502 return error; 1503 } 1504 1505 static struct pci_driver mptspi_driver = { 1506 .name = "mptspi", 1507 .id_table = mptspi_pci_table, 1508 .probe = mptspi_probe, 1509 .remove = __devexit_p(mptscsih_remove), 1510 .shutdown = mptscsih_shutdown, 1511 #ifdef CONFIG_PM 1512 .suspend = mptscsih_suspend, 1513 .resume = mptspi_resume, 1514 #endif 1515 }; 1516 1517 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1518 /** 1519 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer. 1520 * 1521 * Returns 0 for success, non-zero for failure. 1522 */ 1523 static int __init 1524 mptspi_init(void) 1525 { 1526 show_mptmod_ver(my_NAME, my_VERSION); 1527 1528 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions); 1529 if (!mptspi_transport_template) 1530 return -ENODEV; 1531 1532 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER); 1533 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER); 1534 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER); 1535 1536 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) { 1537 devtverboseprintk((KERN_INFO MYNAM 1538 ": Registered for IOC event notifications\n")); 1539 } 1540 1541 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) { 1542 dprintk((KERN_INFO MYNAM 1543 ": Registered for IOC reset notifications\n")); 1544 } 1545 1546 return pci_register_driver(&mptspi_driver); 1547 } 1548 1549 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1551 /** 1552 * mptspi_exit - Unregisters MPT adapter(s) 1553 */ 1554 static void __exit 1555 mptspi_exit(void) 1556 { 1557 pci_unregister_driver(&mptspi_driver); 1558 1559 mpt_reset_deregister(mptspiDoneCtx); 1560 dprintk((KERN_INFO MYNAM 1561 ": Deregistered for IOC reset notifications\n")); 1562 1563 mpt_event_deregister(mptspiDoneCtx); 1564 dprintk((KERN_INFO MYNAM 1565 ": Deregistered for IOC event notifications\n")); 1566 1567 mpt_deregister(mptspiInternalCtx); 1568 mpt_deregister(mptspiTaskCtx); 1569 mpt_deregister(mptspiDoneCtx); 1570 spi_release_transport(mptspi_transport_template); 1571 } 1572 1573 module_init(mptspi_init); 1574 module_exit(mptspi_exit); 1575