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