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; 731 732 mptspi_initTarget(hd, vtarget, sdev); 733 734 ret = mptscsih_slave_configure(sdev); 735 736 if (ret) 737 return ret; 738 739 ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x" 740 " max_offset=0x%02x max_width=%d\n", hd->ioc->name, 741 sdev->id, spi_min_period(scsi_target(sdev)), 742 spi_max_offset(scsi_target(sdev)), 743 spi_max_width(scsi_target(sdev)))); 744 745 if ((sdev->channel == 1 || 746 !(mptspi_is_raid(hd, sdev->id))) && 747 !spi_initial_dv(sdev->sdev_target)) 748 mptspi_dv_device(hd, sdev); 749 750 return 0; 751 } 752 753 static int 754 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 755 { 756 struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata; 757 VirtDevice *vdev = SCpnt->device->hostdata; 758 759 if (!vdev || !vdev->vtarget) { 760 SCpnt->result = DID_NO_CONNECT << 16; 761 done(SCpnt); 762 return 0; 763 } 764 765 if (SCpnt->device->channel == 1 && 766 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) { 767 SCpnt->result = DID_NO_CONNECT << 16; 768 done(SCpnt); 769 return 0; 770 } 771 772 #ifdef MPT_DEBUG_DV 773 if (spi_dv_pending(scsi_target(SCpnt->device))) 774 scsi_print_command(SCpnt); 775 #endif 776 777 return mptscsih_qcmd(SCpnt,done); 778 } 779 780 static void mptspi_slave_destroy(struct scsi_device *sdev) 781 { 782 struct scsi_target *starget = scsi_target(sdev); 783 VirtTarget *vtarget = starget->hostdata; 784 VirtDevice *vdevice = sdev->hostdata; 785 786 /* Will this be the last lun on a non-raid device? */ 787 if (vtarget->num_luns == 1 && vdevice->configured_lun) { 788 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 789 790 /* Async Narrow */ 791 pg1.RequestedParameters = 0; 792 pg1.Reserved = 0; 793 pg1.Configuration = 0; 794 795 mptspi_write_spi_device_pg1(starget, &pg1); 796 } 797 798 mptscsih_slave_destroy(sdev); 799 } 800 801 static struct scsi_host_template mptspi_driver_template = { 802 .module = THIS_MODULE, 803 .proc_name = "mptspi", 804 .proc_info = mptscsih_proc_info, 805 .name = "MPT SPI Host", 806 .info = mptscsih_info, 807 .queuecommand = mptspi_qcmd, 808 .target_alloc = mptspi_target_alloc, 809 .slave_alloc = mptspi_slave_alloc, 810 .slave_configure = mptspi_slave_configure, 811 .target_destroy = mptspi_target_destroy, 812 .slave_destroy = mptspi_slave_destroy, 813 .change_queue_depth = mptscsih_change_queue_depth, 814 .eh_abort_handler = mptscsih_abort, 815 .eh_device_reset_handler = mptscsih_dev_reset, 816 .eh_bus_reset_handler = mptscsih_bus_reset, 817 .eh_host_reset_handler = mptscsih_host_reset, 818 .bios_param = mptscsih_bios_param, 819 .can_queue = MPT_SCSI_CAN_QUEUE, 820 .this_id = -1, 821 .sg_tablesize = MPT_SCSI_SG_DEPTH, 822 .max_sectors = 8192, 823 .cmd_per_lun = 7, 824 .use_clustering = ENABLE_CLUSTERING, 825 }; 826 827 static int mptspi_write_spi_device_pg1(struct scsi_target *starget, 828 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1) 829 { 830 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 831 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata; 832 struct _MPT_ADAPTER *ioc = hd->ioc; 833 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1; 834 dma_addr_t pg1_dma; 835 int size; 836 struct _x_config_parms cfg; 837 struct _CONFIG_PAGE_HEADER hdr; 838 int err = -EBUSY; 839 840 /* don't allow updating nego parameters on RAID devices */ 841 if (starget->channel == 0 && 842 mptspi_is_raid(hd, starget->id)) 843 return -1; 844 845 size = ioc->spi_data.sdp1length * 4; 846 847 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL); 848 if (pg1 == NULL) { 849 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n"); 850 return -EINVAL; 851 } 852 853 memset(&hdr, 0, sizeof(hdr)); 854 855 hdr.PageVersion = ioc->spi_data.sdp1version; 856 hdr.PageLength = ioc->spi_data.sdp1length; 857 hdr.PageNumber = 1; 858 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 859 860 memset(&cfg, 0, sizeof(cfg)); 861 862 cfg.cfghdr.hdr = &hdr; 863 cfg.physAddr = pg1_dma; 864 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 865 cfg.dir = 1; 866 cfg.pageAddr = starget->id; 867 868 memcpy(pg1, pass_pg1, size); 869 870 pg1->Header.PageVersion = hdr.PageVersion; 871 pg1->Header.PageLength = hdr.PageLength; 872 pg1->Header.PageNumber = hdr.PageNumber; 873 pg1->Header.PageType = hdr.PageType; 874 875 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters)); 876 877 if (mpt_config(ioc, &cfg)) { 878 starget_printk(KERN_ERR, starget, "mpt_config failed\n"); 879 goto out_free; 880 } 881 err = 0; 882 883 out_free: 884 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma); 885 return err; 886 } 887 888 static void mptspi_write_offset(struct scsi_target *starget, int offset) 889 { 890 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 891 u32 nego; 892 893 if (offset < 0) 894 offset = 0; 895 896 if (offset > 255) 897 offset = 255; 898 899 if (spi_offset(starget) == -1) 900 mptspi_read_parameters(starget); 901 902 spi_offset(starget) = offset; 903 904 nego = mptspi_getRP(starget); 905 906 pg1.RequestedParameters = cpu_to_le32(nego); 907 pg1.Reserved = 0; 908 pg1.Configuration = 0; 909 910 mptspi_write_spi_device_pg1(starget, &pg1); 911 } 912 913 static void mptspi_write_period(struct scsi_target *starget, int period) 914 { 915 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 916 u32 nego; 917 918 if (period < 8) 919 period = 8; 920 921 if (period > 255) 922 period = 255; 923 924 if (spi_period(starget) == -1) 925 mptspi_read_parameters(starget); 926 927 if (period == 8) { 928 spi_iu(starget) = 1; 929 spi_dt(starget) = 1; 930 } else if (period == 9) { 931 spi_dt(starget) = 1; 932 } 933 934 spi_period(starget) = period; 935 936 nego = mptspi_getRP(starget); 937 938 pg1.RequestedParameters = cpu_to_le32(nego); 939 pg1.Reserved = 0; 940 pg1.Configuration = 0; 941 942 mptspi_write_spi_device_pg1(starget, &pg1); 943 } 944 945 static void mptspi_write_dt(struct scsi_target *starget, int dt) 946 { 947 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 948 u32 nego; 949 950 if (spi_period(starget) == -1) 951 mptspi_read_parameters(starget); 952 953 if (!dt && spi_period(starget) < 10) 954 spi_period(starget) = 10; 955 956 spi_dt(starget) = dt; 957 958 nego = mptspi_getRP(starget); 959 960 961 pg1.RequestedParameters = cpu_to_le32(nego); 962 pg1.Reserved = 0; 963 pg1.Configuration = 0; 964 965 mptspi_write_spi_device_pg1(starget, &pg1); 966 } 967 968 static void mptspi_write_iu(struct scsi_target *starget, int iu) 969 { 970 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 971 u32 nego; 972 973 if (spi_period(starget) == -1) 974 mptspi_read_parameters(starget); 975 976 if (!iu && spi_period(starget) < 9) 977 spi_period(starget) = 9; 978 979 spi_iu(starget) = iu; 980 981 nego = mptspi_getRP(starget); 982 983 pg1.RequestedParameters = cpu_to_le32(nego); 984 pg1.Reserved = 0; 985 pg1.Configuration = 0; 986 987 mptspi_write_spi_device_pg1(starget, &pg1); 988 } 989 990 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \ 991 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\ 992 { \ 993 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \ 994 u32 nego; \ 995 \ 996 spi_##parm(starget) = parm; \ 997 \ 998 nego = mptspi_getRP(starget); \ 999 \ 1000 pg1.RequestedParameters = cpu_to_le32(nego); \ 1001 pg1.Reserved = 0; \ 1002 pg1.Configuration = 0; \ 1003 \ 1004 mptspi_write_spi_device_pg1(starget, &pg1); \ 1005 } 1006 1007 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm) 1008 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow) 1009 MPTSPI_SIMPLE_TRANSPORT_PARM(rti) 1010 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs) 1011 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en) 1012 1013 static void mptspi_write_qas(struct scsi_target *starget, int qas) 1014 { 1015 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1016 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1017 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata; 1018 VirtTarget *vtarget = starget->hostdata; 1019 u32 nego; 1020 1021 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) || 1022 hd->ioc->spi_data.noQas) 1023 spi_qas(starget) = 0; 1024 else 1025 spi_qas(starget) = qas; 1026 1027 nego = mptspi_getRP(starget); 1028 1029 pg1.RequestedParameters = cpu_to_le32(nego); 1030 pg1.Reserved = 0; 1031 pg1.Configuration = 0; 1032 1033 mptspi_write_spi_device_pg1(starget, &pg1); 1034 } 1035 1036 static void mptspi_write_width(struct scsi_target *starget, int width) 1037 { 1038 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1039 u32 nego; 1040 1041 if (!width) { 1042 spi_dt(starget) = 0; 1043 if (spi_period(starget) < 10) 1044 spi_period(starget) = 10; 1045 } 1046 1047 spi_width(starget) = width; 1048 1049 nego = mptspi_getRP(starget); 1050 1051 pg1.RequestedParameters = cpu_to_le32(nego); 1052 pg1.Reserved = 0; 1053 pg1.Configuration = 0; 1054 1055 mptspi_write_spi_device_pg1(starget, &pg1); 1056 } 1057 1058 struct work_queue_wrapper { 1059 struct work_struct work; 1060 struct _MPT_SCSI_HOST *hd; 1061 int disk; 1062 }; 1063 1064 static void mpt_work_wrapper(struct work_struct *work) 1065 { 1066 struct work_queue_wrapper *wqw = 1067 container_of(work, struct work_queue_wrapper, work); 1068 struct _MPT_SCSI_HOST *hd = wqw->hd; 1069 struct Scsi_Host *shost = hd->ioc->sh; 1070 struct scsi_device *sdev; 1071 int disk = wqw->disk; 1072 struct _CONFIG_PAGE_IOC_3 *pg3; 1073 1074 kfree(wqw); 1075 1076 mpt_findImVolumes(hd->ioc); 1077 pg3 = hd->ioc->raid_data.pIocPg3; 1078 if (!pg3) 1079 return; 1080 1081 shost_for_each_device(sdev,shost) { 1082 struct scsi_target *starget = scsi_target(sdev); 1083 VirtTarget *vtarget = starget->hostdata; 1084 1085 /* only want to search RAID components */ 1086 if (sdev->channel != 1) 1087 continue; 1088 1089 /* The id is the raid PhysDiskNum, even if 1090 * starget->id is the actual target address */ 1091 if(vtarget->id != disk) 1092 continue; 1093 1094 starget_printk(KERN_INFO, vtarget->starget, 1095 "Integrated RAID requests DV of new device\n"); 1096 mptspi_dv_device(hd, sdev); 1097 } 1098 shost_printk(KERN_INFO, shost, 1099 "Integrated RAID detects new device %d\n", disk); 1100 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1); 1101 } 1102 1103 1104 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk) 1105 { 1106 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC); 1107 1108 if (!wqw) { 1109 shost_printk(KERN_ERR, hd->ioc->sh, 1110 "Failed to act on RAID event for physical disk %d\n", 1111 disk); 1112 return; 1113 } 1114 INIT_WORK(&wqw->work, mpt_work_wrapper); 1115 wqw->hd = hd; 1116 wqw->disk = disk; 1117 1118 schedule_work(&wqw->work); 1119 } 1120 1121 static int 1122 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) 1123 { 1124 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF; 1125 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata; 1126 1127 if (hd && event == MPI_EVENT_INTEGRATED_RAID) { 1128 int reason 1129 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16; 1130 1131 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) { 1132 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24; 1133 mpt_dv_raid(hd, disk); 1134 } 1135 } 1136 return mptscsih_event_process(ioc, pEvReply); 1137 } 1138 1139 static int 1140 mptspi_deny_binding(struct scsi_target *starget) 1141 { 1142 struct _MPT_SCSI_HOST *hd = 1143 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata; 1144 return ((mptspi_is_raid(hd, starget->id)) && 1145 starget->channel == 0) ? 1 : 0; 1146 } 1147 1148 static struct spi_function_template mptspi_transport_functions = { 1149 .get_offset = mptspi_read_parameters, 1150 .set_offset = mptspi_write_offset, 1151 .show_offset = 1, 1152 .get_period = mptspi_read_parameters, 1153 .set_period = mptspi_write_period, 1154 .show_period = 1, 1155 .get_width = mptspi_read_parameters, 1156 .set_width = mptspi_write_width, 1157 .show_width = 1, 1158 .get_iu = mptspi_read_parameters, 1159 .set_iu = mptspi_write_iu, 1160 .show_iu = 1, 1161 .get_dt = mptspi_read_parameters, 1162 .set_dt = mptspi_write_dt, 1163 .show_dt = 1, 1164 .get_qas = mptspi_read_parameters, 1165 .set_qas = mptspi_write_qas, 1166 .show_qas = 1, 1167 .get_wr_flow = mptspi_read_parameters, 1168 .set_wr_flow = mptspi_write_wr_flow, 1169 .show_wr_flow = 1, 1170 .get_rd_strm = mptspi_read_parameters, 1171 .set_rd_strm = mptspi_write_rd_strm, 1172 .show_rd_strm = 1, 1173 .get_rti = mptspi_read_parameters, 1174 .set_rti = mptspi_write_rti, 1175 .show_rti = 1, 1176 .get_pcomp_en = mptspi_read_parameters, 1177 .set_pcomp_en = mptspi_write_pcomp_en, 1178 .show_pcomp_en = 1, 1179 .get_hold_mcs = mptspi_read_parameters, 1180 .set_hold_mcs = mptspi_write_hold_mcs, 1181 .show_hold_mcs = 1, 1182 .deny_binding = mptspi_deny_binding, 1183 }; 1184 1185 /**************************************************************************** 1186 * Supported hardware 1187 */ 1188 1189 static struct pci_device_id mptspi_pci_table[] = { 1190 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030, 1191 PCI_ANY_ID, PCI_ANY_ID }, 1192 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035, 1193 PCI_ANY_ID, PCI_ANY_ID }, 1194 {0} /* Terminating entry */ 1195 }; 1196 MODULE_DEVICE_TABLE(pci, mptspi_pci_table); 1197 1198 1199 /* 1200 * renegotiate for a given target 1201 */ 1202 static void 1203 mptspi_dv_renegotiate_work(struct work_struct *work) 1204 { 1205 struct work_queue_wrapper *wqw = 1206 container_of(work, struct work_queue_wrapper, work); 1207 struct _MPT_SCSI_HOST *hd = wqw->hd; 1208 struct scsi_device *sdev; 1209 struct scsi_target *starget; 1210 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; 1211 u32 nego; 1212 1213 kfree(wqw); 1214 1215 if (hd->spi_pending) { 1216 shost_for_each_device(sdev, hd->ioc->sh) { 1217 if (hd->spi_pending & (1 << sdev->id)) 1218 continue; 1219 starget = scsi_target(sdev); 1220 nego = mptspi_getRP(starget); 1221 pg1.RequestedParameters = cpu_to_le32(nego); 1222 pg1.Reserved = 0; 1223 pg1.Configuration = 0; 1224 mptspi_write_spi_device_pg1(starget, &pg1); 1225 } 1226 } else { 1227 shost_for_each_device(sdev, hd->ioc->sh) 1228 mptspi_dv_device(hd, sdev); 1229 } 1230 } 1231 1232 static void 1233 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd) 1234 { 1235 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC); 1236 1237 if (!wqw) 1238 return; 1239 1240 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work); 1241 wqw->hd = hd; 1242 1243 schedule_work(&wqw->work); 1244 } 1245 1246 /* 1247 * spi module reset handler 1248 */ 1249 static int 1250 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 1251 { 1252 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata; 1253 int rc; 1254 1255 rc = mptscsih_ioc_reset(ioc, reset_phase); 1256 1257 if (reset_phase == MPT_IOC_POST_RESET) 1258 mptspi_dv_renegotiate(hd); 1259 1260 return rc; 1261 } 1262 1263 #ifdef CONFIG_PM 1264 /* 1265 * spi module resume handler 1266 */ 1267 static int 1268 mptspi_resume(struct pci_dev *pdev) 1269 { 1270 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1271 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata; 1272 int rc; 1273 1274 rc = mptscsih_resume(pdev); 1275 mptspi_dv_renegotiate(hd); 1276 1277 return rc; 1278 } 1279 #endif 1280 1281 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1282 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1283 /* 1284 * mptspi_probe - Installs scsi devices per bus. 1285 * @pdev: Pointer to pci_dev structure 1286 * 1287 * Returns 0 for success, non-zero for failure. 1288 * 1289 */ 1290 static int 1291 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) 1292 { 1293 struct Scsi_Host *sh; 1294 MPT_SCSI_HOST *hd; 1295 MPT_ADAPTER *ioc; 1296 unsigned long flags; 1297 int ii; 1298 int numSGE = 0; 1299 int scale; 1300 int ioc_cap; 1301 int error=0; 1302 int r; 1303 1304 if ((r = mpt_attach(pdev,id)) != 0) 1305 return r; 1306 1307 ioc = pci_get_drvdata(pdev); 1308 ioc->DoneCtx = mptspiDoneCtx; 1309 ioc->TaskCtx = mptspiTaskCtx; 1310 ioc->InternalCtx = mptspiInternalCtx; 1311 1312 /* Added sanity check on readiness of the MPT adapter. 1313 */ 1314 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 1315 printk(MYIOC_s_WARN_FMT 1316 "Skipping because it's not operational!\n", 1317 ioc->name); 1318 error = -ENODEV; 1319 goto out_mptspi_probe; 1320 } 1321 1322 if (!ioc->active) { 1323 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 1324 ioc->name); 1325 error = -ENODEV; 1326 goto out_mptspi_probe; 1327 } 1328 1329 /* Sanity check - ensure at least 1 port is INITIATOR capable 1330 */ 1331 ioc_cap = 0; 1332 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) { 1333 if (ioc->pfacts[ii].ProtocolFlags & 1334 MPI_PORTFACTS_PROTOCOL_INITIATOR) 1335 ioc_cap ++; 1336 } 1337 1338 if (!ioc_cap) { 1339 printk(MYIOC_s_WARN_FMT 1340 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n", 1341 ioc->name, ioc); 1342 return 0; 1343 } 1344 1345 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST)); 1346 1347 if (!sh) { 1348 printk(MYIOC_s_WARN_FMT 1349 "Unable to register controller with SCSI subsystem\n", 1350 ioc->name); 1351 error = -1; 1352 goto out_mptspi_probe; 1353 } 1354 1355 spin_lock_irqsave(&ioc->FreeQlock, flags); 1356 1357 /* Attach the SCSI Host to the IOC structure 1358 */ 1359 ioc->sh = sh; 1360 1361 sh->io_port = 0; 1362 sh->n_io_port = 0; 1363 sh->irq = 0; 1364 1365 /* set 16 byte cdb's */ 1366 sh->max_cmd_len = 16; 1367 1368 /* Yikes! This is important! 1369 * Otherwise, by default, linux 1370 * only scans target IDs 0-7! 1371 * pfactsN->MaxDevices unreliable 1372 * (not supported in early 1373 * versions of the FW). 1374 * max_id = 1 + actual max id, 1375 * max_lun = 1 + actual last lun, 1376 * see hosts.h :o( 1377 */ 1378 sh->max_id = ioc->devices_per_bus; 1379 1380 sh->max_lun = MPT_LAST_LUN + 1; 1381 /* 1382 * If RAID Firmware Detected, setup virtual channel 1383 */ 1384 if (ioc->ir_firmware) 1385 sh->max_channel = 1; 1386 else 1387 sh->max_channel = 0; 1388 sh->this_id = ioc->pfacts[0].PortSCSIID; 1389 1390 /* Required entry. 1391 */ 1392 sh->unique_id = ioc->id; 1393 1394 /* Verify that we won't exceed the maximum 1395 * number of chain buffers 1396 * We can optimize: ZZ = req_sz/sizeof(SGE) 1397 * For 32bit SGE's: 1398 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 1399 * + (req_sz - 64)/sizeof(SGE) 1400 * A slightly different algorithm is required for 1401 * 64bit SGEs. 1402 */ 1403 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32)); 1404 if (sizeof(dma_addr_t) == sizeof(u64)) { 1405 numSGE = (scale - 1) * 1406 (ioc->facts.MaxChainDepth-1) + scale + 1407 (ioc->req_sz - 60) / (sizeof(dma_addr_t) + 1408 sizeof(u32)); 1409 } else { 1410 numSGE = 1 + (scale - 1) * 1411 (ioc->facts.MaxChainDepth-1) + scale + 1412 (ioc->req_sz - 64) / (sizeof(dma_addr_t) + 1413 sizeof(u32)); 1414 } 1415 1416 if (numSGE < sh->sg_tablesize) { 1417 /* Reset this value */ 1418 dprintk((MYIOC_s_INFO_FMT 1419 "Resetting sg_tablesize to %d from %d\n", 1420 ioc->name, numSGE, sh->sg_tablesize)); 1421 sh->sg_tablesize = numSGE; 1422 } 1423 1424 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 1425 1426 hd = (MPT_SCSI_HOST *) sh->hostdata; 1427 hd->ioc = ioc; 1428 1429 /* SCSI needs scsi_cmnd lookup table! 1430 * (with size equal to req_depth*PtrSz!) 1431 */ 1432 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 1433 if (!hd->ScsiLookup) { 1434 error = -ENOMEM; 1435 goto out_mptspi_probe; 1436 } 1437 1438 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n", 1439 ioc->name, hd->ScsiLookup)); 1440 1441 /* Clear the TM flags 1442 */ 1443 hd->tmPending = 0; 1444 hd->tmState = TM_STATE_NONE; 1445 hd->resetPending = 0; 1446 hd->abortSCpnt = NULL; 1447 1448 /* Clear the pointer used to store 1449 * single-threaded commands, i.e., those 1450 * issued during a bus scan, dv and 1451 * configuration pages. 1452 */ 1453 hd->cmdPtr = NULL; 1454 1455 /* Initialize this SCSI Hosts' timers 1456 * To use, set the timer expires field 1457 * and add_timer 1458 */ 1459 init_timer(&hd->timer); 1460 hd->timer.data = (unsigned long) hd; 1461 hd->timer.function = mptscsih_timer_expired; 1462 1463 ioc->spi_data.Saf_Te = mpt_saf_te; 1464 1465 hd->negoNvram = MPT_SCSICFG_USE_NVRAM; 1466 ddvprintk((MYIOC_s_INFO_FMT 1467 "saf_te %x\n", 1468 ioc->name, 1469 mpt_saf_te)); 1470 ioc->spi_data.noQas = 0; 1471 1472 init_waitqueue_head(&hd->scandv_waitq); 1473 hd->scandv_wait_done = 0; 1474 hd->last_queue_full = 0; 1475 hd->spi_pending = 0; 1476 1477 /* Some versions of the firmware don't support page 0; without 1478 * that we can't get the parameters */ 1479 if (hd->ioc->spi_data.sdp0length != 0) 1480 sh->transportt = mptspi_transport_template; 1481 1482 error = scsi_add_host (sh, &ioc->pcidev->dev); 1483 if(error) { 1484 dprintk((KERN_ERR MYNAM 1485 "scsi_add_host failed\n")); 1486 goto out_mptspi_probe; 1487 } 1488 1489 /* 1490 * issue internal bus reset 1491 */ 1492 if (ioc->spi_data.bus_reset) 1493 mptscsih_TMHandler(hd, 1494 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, 1495 0, 0, 0, 0, 5); 1496 1497 scsi_scan_host(sh); 1498 return 0; 1499 1500 out_mptspi_probe: 1501 1502 mptscsih_remove(pdev); 1503 return error; 1504 } 1505 1506 static struct pci_driver mptspi_driver = { 1507 .name = "mptspi", 1508 .id_table = mptspi_pci_table, 1509 .probe = mptspi_probe, 1510 .remove = __devexit_p(mptscsih_remove), 1511 .shutdown = mptscsih_shutdown, 1512 #ifdef CONFIG_PM 1513 .suspend = mptscsih_suspend, 1514 .resume = mptspi_resume, 1515 #endif 1516 }; 1517 1518 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1519 /** 1520 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer. 1521 * 1522 * Returns 0 for success, non-zero for failure. 1523 */ 1524 static int __init 1525 mptspi_init(void) 1526 { 1527 show_mptmod_ver(my_NAME, my_VERSION); 1528 1529 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions); 1530 if (!mptspi_transport_template) 1531 return -ENODEV; 1532 1533 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER); 1534 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER); 1535 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER); 1536 1537 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) { 1538 devtverboseprintk((KERN_INFO MYNAM 1539 ": Registered for IOC event notifications\n")); 1540 } 1541 1542 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) { 1543 dprintk((KERN_INFO MYNAM 1544 ": Registered for IOC reset notifications\n")); 1545 } 1546 1547 return pci_register_driver(&mptspi_driver); 1548 } 1549 1550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1551 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1552 /** 1553 * mptspi_exit - Unregisters MPT adapter(s) 1554 */ 1555 static void __exit 1556 mptspi_exit(void) 1557 { 1558 pci_unregister_driver(&mptspi_driver); 1559 1560 mpt_reset_deregister(mptspiDoneCtx); 1561 dprintk((KERN_INFO MYNAM 1562 ": Deregistered for IOC reset notifications\n")); 1563 1564 mpt_event_deregister(mptspiDoneCtx); 1565 dprintk((KERN_INFO MYNAM 1566 ": Deregistered for IOC event notifications\n")); 1567 1568 mpt_deregister(mptspiInternalCtx); 1569 mpt_deregister(mptspiTaskCtx); 1570 mpt_deregister(mptspiDoneCtx); 1571 spi_release_transport(mptspi_transport_template); 1572 } 1573 1574 module_init(mptspi_init); 1575 module_exit(mptspi_exit); 1576