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