1 /* 2 * linux/drivers/message/fusion/mptscsih.c 3 * For use with LSI PCI chip/adapter(s) 4 * running LSI Fusion MPT (Message Passing Technology) firmware. 5 * 6 * Copyright (c) 1999-2008 LSI Corporation 7 * (mailto:DL-MPTFusionLinux@lsi.com) 8 * 9 */ 10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 11 /* 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; version 2 of the License. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 NO WARRANTY 22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 26 solely responsible for determining the appropriateness of using and 27 distributing the Program and assumes all risks associated with its 28 exercise of rights under this Agreement, including but not limited to 29 the risks and costs of program errors, damage to or loss of data, 30 programs or equipment, and unavailability or interruption of operations. 31 32 DISCLAIMER OF LIABILITY 33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 40 41 You should have received a copy of the GNU General Public License 42 along with this program; if not, write to the Free Software 43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 44 */ 45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 46 47 #include <linux/module.h> 48 #include <linux/kernel.h> 49 #include <linux/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 58 #include <scsi/scsi.h> 59 #include <scsi/scsi_cmnd.h> 60 #include <scsi/scsi_device.h> 61 #include <scsi/scsi_host.h> 62 #include <scsi/scsi_tcq.h> 63 #include <scsi/scsi_dbg.h> 64 65 #include "mptbase.h" 66 #include "mptscsih.h" 67 #include "lsi/mpi_log_sas.h" 68 69 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 70 #define my_NAME "Fusion MPT SCSI Host driver" 71 #define my_VERSION MPT_LINUX_VERSION_COMMON 72 #define MYNAM "mptscsih" 73 74 MODULE_AUTHOR(MODULEAUTHOR); 75 MODULE_DESCRIPTION(my_NAME); 76 MODULE_LICENSE("GPL"); 77 MODULE_VERSION(my_VERSION); 78 79 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 80 /* 81 * Other private/forward protos... 82 */ 83 struct scsi_cmnd *mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i); 84 static struct scsi_cmnd * mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i); 85 static void mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd); 86 static int SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *scmd); 87 int mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r); 88 static void mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq); 89 int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r); 90 91 static int mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt, 92 SCSIIORequest_t *pReq, int req_idx); 93 static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx); 94 static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply); 95 96 int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, 97 int lun, int ctx2abort, ulong timeout); 98 99 int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset); 100 int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply); 101 102 void 103 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code); 104 static int mptscsih_get_completion_code(MPT_ADAPTER *ioc, 105 MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply); 106 int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r); 107 static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd); 108 static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice); 109 110 static int 111 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type, 112 SCSITaskMgmtReply_t *pScsiTmReply); 113 void mptscsih_remove(struct pci_dev *); 114 void mptscsih_shutdown(struct pci_dev *); 115 #ifdef CONFIG_PM 116 int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state); 117 int mptscsih_resume(struct pci_dev *pdev); 118 #endif 119 120 #define SNS_LEN(scp) SCSI_SENSE_BUFFERSIZE 121 122 123 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 124 /* 125 * mptscsih_getFreeChainBuffer - Function to get a free chain 126 * from the MPT_SCSI_HOST FreeChainQ. 127 * @ioc: Pointer to MPT_ADAPTER structure 128 * @req_idx: Index of the SCSI IO request frame. (output) 129 * 130 * return SUCCESS or FAILED 131 */ 132 static inline int 133 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex) 134 { 135 MPT_FRAME_HDR *chainBuf; 136 unsigned long flags; 137 int rc; 138 int chain_idx; 139 140 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n", 141 ioc->name)); 142 spin_lock_irqsave(&ioc->FreeQlock, flags); 143 if (!list_empty(&ioc->FreeChainQ)) { 144 int offset; 145 146 chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR, 147 u.frame.linkage.list); 148 list_del(&chainBuf->u.frame.linkage.list); 149 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer; 150 chain_idx = offset / ioc->req_sz; 151 rc = SUCCESS; 152 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT 153 "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n", 154 ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx)); 155 } else { 156 rc = FAILED; 157 chain_idx = MPT_HOST_NO_CHAIN; 158 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n", 159 ioc->name)); 160 } 161 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 162 163 *retIndex = chain_idx; 164 return rc; 165 } /* mptscsih_getFreeChainBuffer() */ 166 167 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 168 /* 169 * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the 170 * SCSIIORequest_t Message Frame. 171 * @ioc: Pointer to MPT_ADAPTER structure 172 * @SCpnt: Pointer to scsi_cmnd structure 173 * @pReq: Pointer to SCSIIORequest_t structure 174 * 175 * Returns ... 176 */ 177 static int 178 mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt, 179 SCSIIORequest_t *pReq, int req_idx) 180 { 181 char *psge; 182 char *chainSge; 183 struct scatterlist *sg; 184 int frm_sz; 185 int sges_left, sg_done; 186 int chain_idx = MPT_HOST_NO_CHAIN; 187 int sgeOffset; 188 int numSgeSlots, numSgeThisFrame; 189 u32 sgflags, sgdir, thisxfer = 0; 190 int chain_dma_off = 0; 191 int newIndex; 192 int ii; 193 dma_addr_t v2; 194 u32 RequestNB; 195 196 sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK; 197 if (sgdir == MPI_SCSIIO_CONTROL_WRITE) { 198 sgdir = MPT_TRANSFER_HOST_TO_IOC; 199 } else { 200 sgdir = MPT_TRANSFER_IOC_TO_HOST; 201 } 202 203 psge = (char *) &pReq->SGL; 204 frm_sz = ioc->req_sz; 205 206 /* Map the data portion, if any. 207 * sges_left = 0 if no data transfer. 208 */ 209 sges_left = scsi_dma_map(SCpnt); 210 if (sges_left < 0) 211 return FAILED; 212 213 /* Handle the SG case. 214 */ 215 sg = scsi_sglist(SCpnt); 216 sg_done = 0; 217 sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION); 218 chainSge = NULL; 219 220 /* Prior to entering this loop - the following must be set 221 * current MF: sgeOffset (bytes) 222 * chainSge (Null if original MF is not a chain buffer) 223 * sg_done (num SGE done for this MF) 224 */ 225 226 nextSGEset: 227 numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size); 228 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots; 229 230 sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir; 231 232 /* Get first (num - 1) SG elements 233 * Skip any SG entries with a length of 0 234 * NOTE: at finish, sg and psge pointed to NEXT data/location positions 235 */ 236 for (ii=0; ii < (numSgeThisFrame-1); ii++) { 237 thisxfer = sg_dma_len(sg); 238 if (thisxfer == 0) { 239 /* Get next SG element from the OS */ 240 sg = sg_next(sg); 241 sg_done++; 242 continue; 243 } 244 245 v2 = sg_dma_address(sg); 246 ioc->add_sge(psge, sgflags | thisxfer, v2); 247 248 /* Get next SG element from the OS */ 249 sg = sg_next(sg); 250 psge += ioc->SGE_size; 251 sgeOffset += ioc->SGE_size; 252 sg_done++; 253 } 254 255 if (numSgeThisFrame == sges_left) { 256 /* Add last element, end of buffer and end of list flags. 257 */ 258 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT | 259 MPT_SGE_FLAGS_END_OF_BUFFER | 260 MPT_SGE_FLAGS_END_OF_LIST; 261 262 /* Add last SGE and set termination flags. 263 * Note: Last SGE may have a length of 0 - which should be ok. 264 */ 265 thisxfer = sg_dma_len(sg); 266 267 v2 = sg_dma_address(sg); 268 ioc->add_sge(psge, sgflags | thisxfer, v2); 269 sgeOffset += ioc->SGE_size; 270 sg_done++; 271 272 if (chainSge) { 273 /* The current buffer is a chain buffer, 274 * but there is not another one. 275 * Update the chain element 276 * Offset and Length fields. 277 */ 278 ioc->add_chain((char *)chainSge, 0, sgeOffset, 279 ioc->ChainBufferDMA + chain_dma_off); 280 } else { 281 /* The current buffer is the original MF 282 * and there is no Chain buffer. 283 */ 284 pReq->ChainOffset = 0; 285 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03; 286 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT 287 "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset)); 288 ioc->RequestNB[req_idx] = RequestNB; 289 } 290 } else { 291 /* At least one chain buffer is needed. 292 * Complete the first MF 293 * - last SGE element, set the LastElement bit 294 * - set ChainOffset (words) for orig MF 295 * (OR finish previous MF chain buffer) 296 * - update MFStructPtr ChainIndex 297 * - Populate chain element 298 * Also 299 * Loop until done. 300 */ 301 302 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SG: Chain Required! sg done %d\n", 303 ioc->name, sg_done)); 304 305 /* Set LAST_ELEMENT flag for last non-chain element 306 * in the buffer. Since psge points at the NEXT 307 * SGE element, go back one SGE element, update the flags 308 * and reset the pointer. (Note: sgflags & thisxfer are already 309 * set properly). 310 */ 311 if (sg_done) { 312 u32 *ptmp = (u32 *) (psge - ioc->SGE_size); 313 sgflags = le32_to_cpu(*ptmp); 314 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT; 315 *ptmp = cpu_to_le32(sgflags); 316 } 317 318 if (chainSge) { 319 /* The current buffer is a chain buffer. 320 * chainSge points to the previous Chain Element. 321 * Update its chain element Offset and Length (must 322 * include chain element size) fields. 323 * Old chain element is now complete. 324 */ 325 u8 nextChain = (u8) (sgeOffset >> 2); 326 sgeOffset += ioc->SGE_size; 327 ioc->add_chain((char *)chainSge, nextChain, sgeOffset, 328 ioc->ChainBufferDMA + chain_dma_off); 329 } else { 330 /* The original MF buffer requires a chain buffer - 331 * set the offset. 332 * Last element in this MF is a chain element. 333 */ 334 pReq->ChainOffset = (u8) (sgeOffset >> 2); 335 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03; 336 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset)); 337 ioc->RequestNB[req_idx] = RequestNB; 338 } 339 340 sges_left -= sg_done; 341 342 343 /* NOTE: psge points to the beginning of the chain element 344 * in current buffer. Get a chain buffer. 345 */ 346 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) { 347 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT 348 "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n", 349 ioc->name, pReq->CDB[0], SCpnt)); 350 return FAILED; 351 } 352 353 /* Update the tracking arrays. 354 * If chainSge == NULL, update ReqToChain, else ChainToChain 355 */ 356 if (chainSge) { 357 ioc->ChainToChain[chain_idx] = newIndex; 358 } else { 359 ioc->ReqToChain[req_idx] = newIndex; 360 } 361 chain_idx = newIndex; 362 chain_dma_off = ioc->req_sz * chain_idx; 363 364 /* Populate the chainSGE for the current buffer. 365 * - Set chain buffer pointer to psge and fill 366 * out the Address and Flags fields. 367 */ 368 chainSge = (char *) psge; 369 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Current buff @ %p (index 0x%x)", 370 ioc->name, psge, req_idx)); 371 372 /* Start the SGE for the next buffer 373 */ 374 psge = (char *) (ioc->ChainBuffer + chain_dma_off); 375 sgeOffset = 0; 376 sg_done = 0; 377 378 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Chain buff @ %p (index 0x%x)\n", 379 ioc->name, psge, chain_idx)); 380 381 /* Start the SGE for the next buffer 382 */ 383 384 goto nextSGEset; 385 } 386 387 return SUCCESS; 388 } /* mptscsih_AddSGE() */ 389 390 static void 391 mptscsih_issue_sep_command(MPT_ADAPTER *ioc, VirtTarget *vtarget, 392 U32 SlotStatus) 393 { 394 MPT_FRAME_HDR *mf; 395 SEPRequest_t *SEPMsg; 396 397 if (ioc->bus_type != SAS) 398 return; 399 400 /* Not supported for hidden raid components 401 */ 402 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) 403 return; 404 405 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) { 406 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n", 407 ioc->name,__func__)); 408 return; 409 } 410 411 SEPMsg = (SEPRequest_t *)mf; 412 SEPMsg->Function = MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR; 413 SEPMsg->Bus = vtarget->channel; 414 SEPMsg->TargetID = vtarget->id; 415 SEPMsg->Action = MPI_SEP_REQ_ACTION_WRITE_STATUS; 416 SEPMsg->SlotStatus = SlotStatus; 417 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT 418 "Sending SEP cmd=%x channel=%d id=%d\n", 419 ioc->name, SlotStatus, SEPMsg->Bus, SEPMsg->TargetID)); 420 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf); 421 } 422 423 #ifdef CONFIG_FUSION_LOGGING 424 /** 425 * mptscsih_info_scsiio - debug print info on reply frame 426 * @ioc: Pointer to MPT_ADAPTER structure 427 * @sc: original scsi cmnd pointer 428 * @pScsiReply: Pointer to MPT reply frame 429 * 430 * MPT_DEBUG_REPLY needs to be enabled to obtain this info 431 * 432 * Refer to lsi/mpi.h. 433 **/ 434 static void 435 mptscsih_info_scsiio(MPT_ADAPTER *ioc, struct scsi_cmnd *sc, SCSIIOReply_t * pScsiReply) 436 { 437 char *desc = NULL; 438 char *desc1 = NULL; 439 u16 ioc_status; 440 u8 skey, asc, ascq; 441 442 ioc_status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK; 443 444 switch (ioc_status) { 445 446 case MPI_IOCSTATUS_SUCCESS: 447 desc = "success"; 448 break; 449 case MPI_IOCSTATUS_SCSI_INVALID_BUS: 450 desc = "invalid bus"; 451 break; 452 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: 453 desc = "invalid target_id"; 454 break; 455 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 456 desc = "device not there"; 457 break; 458 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: 459 desc = "data overrun"; 460 break; 461 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: 462 desc = "data underrun"; 463 break; 464 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: 465 desc = "I/O data error"; 466 break; 467 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: 468 desc = "protocol error"; 469 break; 470 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: 471 desc = "task terminated"; 472 break; 473 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 474 desc = "residual mismatch"; 475 break; 476 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 477 desc = "task management failed"; 478 break; 479 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: 480 desc = "IOC terminated"; 481 break; 482 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: 483 desc = "ext terminated"; 484 break; 485 default: 486 desc = ""; 487 break; 488 } 489 490 switch (pScsiReply->SCSIStatus) 491 { 492 493 case MPI_SCSI_STATUS_SUCCESS: 494 desc1 = "success"; 495 break; 496 case MPI_SCSI_STATUS_CHECK_CONDITION: 497 desc1 = "check condition"; 498 break; 499 case MPI_SCSI_STATUS_CONDITION_MET: 500 desc1 = "condition met"; 501 break; 502 case MPI_SCSI_STATUS_BUSY: 503 desc1 = "busy"; 504 break; 505 case MPI_SCSI_STATUS_INTERMEDIATE: 506 desc1 = "intermediate"; 507 break; 508 case MPI_SCSI_STATUS_INTERMEDIATE_CONDMET: 509 desc1 = "intermediate condmet"; 510 break; 511 case MPI_SCSI_STATUS_RESERVATION_CONFLICT: 512 desc1 = "reservation conflict"; 513 break; 514 case MPI_SCSI_STATUS_COMMAND_TERMINATED: 515 desc1 = "command terminated"; 516 break; 517 case MPI_SCSI_STATUS_TASK_SET_FULL: 518 desc1 = "task set full"; 519 break; 520 case MPI_SCSI_STATUS_ACA_ACTIVE: 521 desc1 = "aca active"; 522 break; 523 case MPI_SCSI_STATUS_FCPEXT_DEVICE_LOGGED_OUT: 524 desc1 = "fcpext device logged out"; 525 break; 526 case MPI_SCSI_STATUS_FCPEXT_NO_LINK: 527 desc1 = "fcpext no link"; 528 break; 529 case MPI_SCSI_STATUS_FCPEXT_UNASSIGNED: 530 desc1 = "fcpext unassigned"; 531 break; 532 default: 533 desc1 = ""; 534 break; 535 } 536 537 scsi_print_command(sc); 538 printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %d\n", 539 ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun); 540 printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, " 541 "resid = %d\n", ioc->name, scsi_bufflen(sc), sc->underflow, 542 scsi_get_resid(sc)); 543 printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, " 544 "sc->result = %08X\n", ioc->name, le16_to_cpu(pScsiReply->TaskTag), 545 le32_to_cpu(pScsiReply->TransferCount), sc->result); 546 547 printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), " 548 "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n", 549 ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus, 550 pScsiReply->SCSIState); 551 552 if (pScsiReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) { 553 skey = sc->sense_buffer[2] & 0x0F; 554 asc = sc->sense_buffer[12]; 555 ascq = sc->sense_buffer[13]; 556 557 printk(MYIOC_s_DEBUG_FMT "\t[sense_key,asc,ascq]: " 558 "[0x%02x,0x%02x,0x%02x]\n", ioc->name, skey, asc, ascq); 559 } 560 561 /* 562 * Look for + dump FCP ResponseInfo[]! 563 */ 564 if (pScsiReply->SCSIState & MPI_SCSI_STATE_RESPONSE_INFO_VALID && 565 pScsiReply->ResponseInfo) 566 printk(MYIOC_s_DEBUG_FMT "response_info = %08xh\n", 567 ioc->name, le32_to_cpu(pScsiReply->ResponseInfo)); 568 } 569 #endif 570 571 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 572 /* 573 * mptscsih_io_done - Main SCSI IO callback routine registered to 574 * Fusion MPT (base) driver 575 * @ioc: Pointer to MPT_ADAPTER structure 576 * @mf: Pointer to original MPT request frame 577 * @r: Pointer to MPT reply frame (NULL if TurboReply) 578 * 579 * This routine is called from mpt.c::mpt_interrupt() at the completion 580 * of any SCSI IO request. 581 * This routine is registered with the Fusion MPT (base) driver at driver 582 * load/init time via the mpt_register() API call. 583 * 584 * Returns 1 indicating alloc'd request frame ptr should be freed. 585 */ 586 int 587 mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) 588 { 589 struct scsi_cmnd *sc; 590 MPT_SCSI_HOST *hd; 591 SCSIIORequest_t *pScsiReq; 592 SCSIIOReply_t *pScsiReply; 593 u16 req_idx, req_idx_MR; 594 VirtDevice *vdevice; 595 VirtTarget *vtarget; 596 597 hd = shost_priv(ioc->sh); 598 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 599 req_idx_MR = (mr != NULL) ? 600 le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx; 601 602 /* Special case, where already freed message frame is received from 603 * Firmware. It happens with Resetting IOC. 604 * Return immediately. Do not care 605 */ 606 if ((req_idx != req_idx_MR) || 607 (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf)) 608 return 0; 609 610 sc = mptscsih_getclear_scsi_lookup(ioc, req_idx); 611 if (sc == NULL) { 612 MPIHeader_t *hdr = (MPIHeader_t *)mf; 613 614 /* Remark: writeSDP1 will use the ScsiDoneCtx 615 * If a SCSI I/O cmd, device disabled by OS and 616 * completion done. Cannot touch sc struct. Just free mem. 617 */ 618 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST) 619 printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n", 620 ioc->name); 621 622 mptscsih_freeChainBuffers(ioc, req_idx); 623 return 1; 624 } 625 626 if ((unsigned char *)mf != sc->host_scribble) { 627 mptscsih_freeChainBuffers(ioc, req_idx); 628 return 1; 629 } 630 631 if (ioc->bus_type == SAS) { 632 VirtDevice *vdevice = sc->device->hostdata; 633 634 if (!vdevice || !vdevice->vtarget || 635 vdevice->vtarget->deleted) { 636 sc->result = DID_NO_CONNECT << 16; 637 goto out; 638 } 639 } 640 641 sc->host_scribble = NULL; 642 sc->result = DID_OK << 16; /* Set default reply as OK */ 643 pScsiReq = (SCSIIORequest_t *) mf; 644 pScsiReply = (SCSIIOReply_t *) mr; 645 646 if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){ 647 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT 648 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n", 649 ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag)); 650 }else{ 651 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT 652 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n", 653 ioc->name, mf, mr, sc, req_idx)); 654 } 655 656 if (pScsiReply == NULL) { 657 /* special context reply handling */ 658 ; 659 } else { 660 u32 xfer_cnt; 661 u16 status; 662 u8 scsi_state, scsi_status; 663 u32 log_info; 664 665 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK; 666 scsi_state = pScsiReply->SCSIState; 667 scsi_status = pScsiReply->SCSIStatus; 668 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount); 669 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt); 670 log_info = le32_to_cpu(pScsiReply->IOCLogInfo); 671 672 /* 673 * if we get a data underrun indication, yet no data was 674 * transferred and the SCSI status indicates that the 675 * command was never started, change the data underrun 676 * to success 677 */ 678 if (status == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 && 679 (scsi_status == MPI_SCSI_STATUS_BUSY || 680 scsi_status == MPI_SCSI_STATUS_RESERVATION_CONFLICT || 681 scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)) { 682 status = MPI_IOCSTATUS_SUCCESS; 683 } 684 685 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) 686 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply); 687 688 /* 689 * Look for + dump FCP ResponseInfo[]! 690 */ 691 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID && 692 pScsiReply->ResponseInfo) { 693 printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%d] " 694 "FCP_ResponseInfo=%08xh\n", ioc->name, 695 sc->device->host->host_no, sc->device->channel, 696 sc->device->id, sc->device->lun, 697 le32_to_cpu(pScsiReply->ResponseInfo)); 698 } 699 700 switch(status) { 701 case MPI_IOCSTATUS_BUSY: /* 0x0002 */ 702 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */ 703 /* CHECKME! 704 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry) 705 * But not: DID_BUS_BUSY lest one risk 706 * killing interrupt handler:-( 707 */ 708 sc->result = SAM_STAT_BUSY; 709 break; 710 711 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */ 712 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */ 713 sc->result = DID_BAD_TARGET << 16; 714 break; 715 716 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */ 717 /* Spoof to SCSI Selection Timeout! */ 718 if (ioc->bus_type != FC) 719 sc->result = DID_NO_CONNECT << 16; 720 /* else fibre, just stall until rescan event */ 721 else 722 sc->result = DID_REQUEUE << 16; 723 724 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF) 725 hd->sel_timeout[pScsiReq->TargetID]++; 726 727 vdevice = sc->device->hostdata; 728 if (!vdevice) 729 break; 730 vtarget = vdevice->vtarget; 731 if (vtarget->tflags & MPT_TARGET_FLAGS_LED_ON) { 732 mptscsih_issue_sep_command(ioc, vtarget, 733 MPI_SEP_REQ_SLOTSTATUS_UNCONFIGURED); 734 vtarget->tflags &= ~MPT_TARGET_FLAGS_LED_ON; 735 } 736 break; 737 738 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */ 739 if ( ioc->bus_type == SAS ) { 740 u16 ioc_status = le16_to_cpu(pScsiReply->IOCStatus); 741 if (ioc_status & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) { 742 if ((log_info & SAS_LOGINFO_MASK) 743 == SAS_LOGINFO_NEXUS_LOSS) { 744 sc->result = (DID_BUS_BUSY << 16); 745 break; 746 } 747 } 748 } else if (ioc->bus_type == FC) { 749 /* 750 * The FC IOC may kill a request for variety of 751 * reasons, some of which may be recovered by a 752 * retry, some which are unlikely to be 753 * recovered. Return DID_ERROR instead of 754 * DID_RESET to permit retry of the command, 755 * just not an infinite number of them 756 */ 757 sc->result = DID_ERROR << 16; 758 break; 759 } 760 761 /* 762 * Allow non-SAS & non-NEXUS_LOSS to drop into below code 763 */ 764 765 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */ 766 /* Linux handles an unsolicited DID_RESET better 767 * than an unsolicited DID_ABORT. 768 */ 769 sc->result = DID_RESET << 16; 770 771 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */ 772 if (ioc->bus_type == FC) 773 sc->result = DID_ERROR << 16; 774 else 775 sc->result = DID_RESET << 16; 776 break; 777 778 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */ 779 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt); 780 if((xfer_cnt==0)||(sc->underflow > xfer_cnt)) 781 sc->result=DID_SOFT_ERROR << 16; 782 else /* Sufficient data transfer occurred */ 783 sc->result = (DID_OK << 16) | scsi_status; 784 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT 785 "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n", 786 ioc->name, sc->result, sc->device->channel, sc->device->id)); 787 break; 788 789 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */ 790 /* 791 * Do upfront check for valid SenseData and give it 792 * precedence! 793 */ 794 sc->result = (DID_OK << 16) | scsi_status; 795 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) { 796 /* Have already saved the status and sense data 797 */ 798 ; 799 } else { 800 if (xfer_cnt < sc->underflow) { 801 if (scsi_status == SAM_STAT_BUSY) 802 sc->result = SAM_STAT_BUSY; 803 else 804 sc->result = DID_SOFT_ERROR << 16; 805 } 806 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) { 807 /* What to do? 808 */ 809 sc->result = DID_SOFT_ERROR << 16; 810 } 811 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) { 812 /* Not real sure here either... */ 813 sc->result = DID_RESET << 16; 814 } 815 } 816 817 818 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT 819 " sc->underflow={report ERR if < %02xh bytes xfer'd}\n", 820 ioc->name, sc->underflow)); 821 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT 822 " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt)); 823 824 /* Report Queue Full 825 */ 826 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL) 827 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq); 828 829 break; 830 831 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */ 832 scsi_set_resid(sc, 0); 833 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */ 834 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */ 835 sc->result = (DID_OK << 16) | scsi_status; 836 if (scsi_state == 0) { 837 ; 838 } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) { 839 /* 840 * If running against circa 200003dd 909 MPT f/w, 841 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL 842 * (QUEUE_FULL) returned from device! --> get 0x0000?128 843 * and with SenseBytes set to 0. 844 */ 845 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL) 846 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq); 847 848 } 849 else if (scsi_state & 850 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS) 851 ) { 852 /* 853 * What to do? 854 */ 855 sc->result = DID_SOFT_ERROR << 16; 856 } 857 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) { 858 /* Not real sure here either... */ 859 sc->result = DID_RESET << 16; 860 } 861 else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) { 862 /* Device Inq. data indicates that it supports 863 * QTags, but rejects QTag messages. 864 * This command completed OK. 865 * 866 * Not real sure here either so do nothing... */ 867 } 868 869 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL) 870 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq); 871 872 /* Add handling of: 873 * Reservation Conflict, Busy, 874 * Command Terminated, CHECK 875 */ 876 break; 877 878 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */ 879 sc->result = DID_SOFT_ERROR << 16; 880 break; 881 882 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */ 883 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */ 884 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */ 885 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */ 886 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */ 887 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */ 888 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */ 889 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */ 890 default: 891 /* 892 * What to do? 893 */ 894 sc->result = DID_SOFT_ERROR << 16; 895 break; 896 897 } /* switch(status) */ 898 899 #ifdef CONFIG_FUSION_LOGGING 900 if (sc->result && (ioc->debug_level & MPT_DEBUG_REPLY)) 901 mptscsih_info_scsiio(ioc, sc, pScsiReply); 902 #endif 903 904 } /* end of address reply case */ 905 out: 906 /* Unmap the DMA buffers, if any. */ 907 scsi_dma_unmap(sc); 908 909 sc->scsi_done(sc); /* Issue the command callback */ 910 911 /* Free Chain buffers */ 912 mptscsih_freeChainBuffers(ioc, req_idx); 913 return 1; 914 } 915 916 /* 917 * mptscsih_flush_running_cmds - For each command found, search 918 * Scsi_Host instance taskQ and reply to OS. 919 * Called only if recovering from a FW reload. 920 * @hd: Pointer to a SCSI HOST structure 921 * 922 * Returns: None. 923 * 924 * Must be called while new I/Os are being queued. 925 */ 926 static void 927 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd) 928 { 929 MPT_ADAPTER *ioc = hd->ioc; 930 struct scsi_cmnd *sc; 931 SCSIIORequest_t *mf = NULL; 932 int ii; 933 int channel, id; 934 935 for (ii= 0; ii < ioc->req_depth; ii++) { 936 sc = mptscsih_getclear_scsi_lookup(ioc, ii); 937 if (!sc) 938 continue; 939 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii); 940 if (!mf) 941 continue; 942 channel = mf->Bus; 943 id = mf->TargetID; 944 mptscsih_freeChainBuffers(ioc, ii); 945 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf); 946 if ((unsigned char *)mf != sc->host_scribble) 947 continue; 948 scsi_dma_unmap(sc); 949 sc->result = DID_RESET << 16; 950 sc->host_scribble = NULL; 951 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT 952 "completing cmds: fw_channel %d, fw_id %d, sc=%p, mf = %p, " 953 "idx=%x\n", ioc->name, channel, id, sc, mf, ii)); 954 sc->scsi_done(sc); 955 } 956 } 957 958 /* 959 * mptscsih_search_running_cmds - Delete any commands associated 960 * with the specified target and lun. Function called only 961 * when a lun is disable by mid-layer. 962 * Do NOT access the referenced scsi_cmnd structure or 963 * members. Will cause either a paging or NULL ptr error. 964 * (BUT, BUT, BUT, the code does reference it! - mdr) 965 * @hd: Pointer to a SCSI HOST structure 966 * @vdevice: per device private data 967 * 968 * Returns: None. 969 * 970 * Called from slave_destroy. 971 */ 972 static void 973 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice) 974 { 975 SCSIIORequest_t *mf = NULL; 976 int ii; 977 struct scsi_cmnd *sc; 978 struct scsi_lun lun; 979 MPT_ADAPTER *ioc = hd->ioc; 980 unsigned long flags; 981 982 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 983 for (ii = 0; ii < ioc->req_depth; ii++) { 984 if ((sc = ioc->ScsiLookup[ii]) != NULL) { 985 986 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii); 987 if (mf == NULL) 988 continue; 989 /* If the device is a hidden raid component, then its 990 * expected that the mf->function will be RAID_SCSI_IO 991 */ 992 if (vdevice->vtarget->tflags & 993 MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function != 994 MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) 995 continue; 996 997 int_to_scsilun(vdevice->lun, &lun); 998 if ((mf->Bus != vdevice->vtarget->channel) || 999 (mf->TargetID != vdevice->vtarget->id) || 1000 memcmp(lun.scsi_lun, mf->LUN, 8)) 1001 continue; 1002 1003 if ((unsigned char *)mf != sc->host_scribble) 1004 continue; 1005 ioc->ScsiLookup[ii] = NULL; 1006 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 1007 mptscsih_freeChainBuffers(ioc, ii); 1008 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf); 1009 scsi_dma_unmap(sc); 1010 sc->host_scribble = NULL; 1011 sc->result = DID_NO_CONNECT << 16; 1012 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, 1013 MYIOC_s_FMT "completing cmds: fw_channel %d, " 1014 "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name, 1015 vdevice->vtarget->channel, vdevice->vtarget->id, 1016 sc, mf, ii)); 1017 sc->scsi_done(sc); 1018 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 1019 } 1020 } 1021 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 1022 return; 1023 } 1024 1025 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1026 1027 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1028 /* 1029 * mptscsih_report_queue_full - Report QUEUE_FULL status returned 1030 * from a SCSI target device. 1031 * @sc: Pointer to scsi_cmnd structure 1032 * @pScsiReply: Pointer to SCSIIOReply_t 1033 * @pScsiReq: Pointer to original SCSI request 1034 * 1035 * This routine periodically reports QUEUE_FULL status returned from a 1036 * SCSI target device. It reports this to the console via kernel 1037 * printk() API call, not more than once every 10 seconds. 1038 */ 1039 static void 1040 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq) 1041 { 1042 long time = jiffies; 1043 MPT_SCSI_HOST *hd; 1044 MPT_ADAPTER *ioc; 1045 1046 if (sc->device == NULL) 1047 return; 1048 if (sc->device->host == NULL) 1049 return; 1050 if ((hd = shost_priv(sc->device->host)) == NULL) 1051 return; 1052 ioc = hd->ioc; 1053 if (time - hd->last_queue_full > 10 * HZ) { 1054 dprintk(ioc, printk(MYIOC_s_WARN_FMT "Device (%d:%d:%d) reported QUEUE_FULL!\n", 1055 ioc->name, 0, sc->device->id, sc->device->lun)); 1056 hd->last_queue_full = time; 1057 } 1058 } 1059 1060 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1061 /* 1062 * mptscsih_remove - Removed scsi devices 1063 * @pdev: Pointer to pci_dev structure 1064 * 1065 * 1066 */ 1067 void 1068 mptscsih_remove(struct pci_dev *pdev) 1069 { 1070 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1071 struct Scsi_Host *host = ioc->sh; 1072 MPT_SCSI_HOST *hd; 1073 int sz1; 1074 1075 if(!host) { 1076 mpt_detach(pdev); 1077 return; 1078 } 1079 1080 scsi_remove_host(host); 1081 1082 if((hd = shost_priv(host)) == NULL) 1083 return; 1084 1085 mptscsih_shutdown(pdev); 1086 1087 sz1=0; 1088 1089 if (ioc->ScsiLookup != NULL) { 1090 sz1 = ioc->req_depth * sizeof(void *); 1091 kfree(ioc->ScsiLookup); 1092 ioc->ScsiLookup = NULL; 1093 } 1094 1095 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1096 "Free'd ScsiLookup (%d) memory\n", 1097 ioc->name, sz1)); 1098 1099 kfree(hd->info_kbuf); 1100 1101 /* NULL the Scsi_Host pointer 1102 */ 1103 ioc->sh = NULL; 1104 1105 scsi_host_put(host); 1106 1107 mpt_detach(pdev); 1108 1109 } 1110 1111 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1112 /* 1113 * mptscsih_shutdown - reboot notifier 1114 * 1115 */ 1116 void 1117 mptscsih_shutdown(struct pci_dev *pdev) 1118 { 1119 } 1120 1121 #ifdef CONFIG_PM 1122 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1123 /* 1124 * mptscsih_suspend - Fusion MPT scsi driver suspend routine. 1125 * 1126 * 1127 */ 1128 int 1129 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state) 1130 { 1131 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1132 1133 scsi_block_requests(ioc->sh); 1134 flush_scheduled_work(); 1135 mptscsih_shutdown(pdev); 1136 return mpt_suspend(pdev,state); 1137 } 1138 1139 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1140 /* 1141 * mptscsih_resume - Fusion MPT scsi driver resume routine. 1142 * 1143 * 1144 */ 1145 int 1146 mptscsih_resume(struct pci_dev *pdev) 1147 { 1148 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1149 int rc; 1150 1151 rc = mpt_resume(pdev); 1152 scsi_unblock_requests(ioc->sh); 1153 return rc; 1154 } 1155 1156 #endif 1157 1158 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1159 /** 1160 * mptscsih_info - Return information about MPT adapter 1161 * @SChost: Pointer to Scsi_Host structure 1162 * 1163 * (linux scsi_host_template.info routine) 1164 * 1165 * Returns pointer to buffer where information was written. 1166 */ 1167 const char * 1168 mptscsih_info(struct Scsi_Host *SChost) 1169 { 1170 MPT_SCSI_HOST *h; 1171 int size = 0; 1172 1173 h = shost_priv(SChost); 1174 1175 if (h) { 1176 if (h->info_kbuf == NULL) 1177 if ((h->info_kbuf = kmalloc(0x1000 /* 4Kb */, GFP_KERNEL)) == NULL) 1178 return h->info_kbuf; 1179 h->info_kbuf[0] = '\0'; 1180 1181 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0); 1182 h->info_kbuf[size-1] = '\0'; 1183 } 1184 1185 return h->info_kbuf; 1186 } 1187 1188 struct info_str { 1189 char *buffer; 1190 int length; 1191 int offset; 1192 int pos; 1193 }; 1194 1195 static void 1196 mptscsih_copy_mem_info(struct info_str *info, char *data, int len) 1197 { 1198 if (info->pos + len > info->length) 1199 len = info->length - info->pos; 1200 1201 if (info->pos + len < info->offset) { 1202 info->pos += len; 1203 return; 1204 } 1205 1206 if (info->pos < info->offset) { 1207 data += (info->offset - info->pos); 1208 len -= (info->offset - info->pos); 1209 } 1210 1211 if (len > 0) { 1212 memcpy(info->buffer + info->pos, data, len); 1213 info->pos += len; 1214 } 1215 } 1216 1217 static int 1218 mptscsih_copy_info(struct info_str *info, char *fmt, ...) 1219 { 1220 va_list args; 1221 char buf[81]; 1222 int len; 1223 1224 va_start(args, fmt); 1225 len = vsprintf(buf, fmt, args); 1226 va_end(args); 1227 1228 mptscsih_copy_mem_info(info, buf, len); 1229 return len; 1230 } 1231 1232 static int 1233 mptscsih_host_info(MPT_ADAPTER *ioc, char *pbuf, off_t offset, int len) 1234 { 1235 struct info_str info; 1236 1237 info.buffer = pbuf; 1238 info.length = len; 1239 info.offset = offset; 1240 info.pos = 0; 1241 1242 mptscsih_copy_info(&info, "%s: %s, ", ioc->name, ioc->prod_name); 1243 mptscsih_copy_info(&info, "%s%08xh, ", MPT_FW_REV_MAGIC_ID_STRING, ioc->facts.FWVersion.Word); 1244 mptscsih_copy_info(&info, "Ports=%d, ", ioc->facts.NumberOfPorts); 1245 mptscsih_copy_info(&info, "MaxQ=%d\n", ioc->req_depth); 1246 1247 return ((info.pos > info.offset) ? info.pos - info.offset : 0); 1248 } 1249 1250 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1251 /** 1252 * mptscsih_proc_info - Return information about MPT adapter 1253 * @host: scsi host struct 1254 * @buffer: if write, user data; if read, buffer for user 1255 * @start: returns the buffer address 1256 * @offset: if write, 0; if read, the current offset into the buffer from 1257 * the previous read. 1258 * @length: if write, return length; 1259 * @func: write = 1; read = 0 1260 * 1261 * (linux scsi_host_template.info routine) 1262 */ 1263 int 1264 mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, 1265 int length, int func) 1266 { 1267 MPT_SCSI_HOST *hd = shost_priv(host); 1268 MPT_ADAPTER *ioc = hd->ioc; 1269 int size = 0; 1270 1271 if (func) { 1272 /* 1273 * write is not supported 1274 */ 1275 } else { 1276 if (start) 1277 *start = buffer; 1278 1279 size = mptscsih_host_info(ioc, buffer, offset, length); 1280 } 1281 1282 return size; 1283 } 1284 1285 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1286 #define ADD_INDEX_LOG(req_ent) do { } while(0) 1287 1288 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1289 /** 1290 * mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine. 1291 * @SCpnt: Pointer to scsi_cmnd structure 1292 * @done: Pointer SCSI mid-layer IO completion function 1293 * 1294 * (linux scsi_host_template.queuecommand routine) 1295 * This is the primary SCSI IO start routine. Create a MPI SCSIIORequest 1296 * from a linux scsi_cmnd request and send it to the IOC. 1297 * 1298 * Returns 0. (rtn value discarded by linux scsi mid-layer) 1299 */ 1300 int 1301 mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 1302 { 1303 MPT_SCSI_HOST *hd; 1304 MPT_FRAME_HDR *mf; 1305 SCSIIORequest_t *pScsiReq; 1306 VirtDevice *vdevice = SCpnt->device->hostdata; 1307 u32 datalen; 1308 u32 scsictl; 1309 u32 scsidir; 1310 u32 cmd_len; 1311 int my_idx; 1312 int ii; 1313 MPT_ADAPTER *ioc; 1314 1315 hd = shost_priv(SCpnt->device->host); 1316 ioc = hd->ioc; 1317 SCpnt->scsi_done = done; 1318 1319 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p, done()=%p\n", 1320 ioc->name, SCpnt, done)); 1321 1322 if (ioc->taskmgmt_quiesce_io) { 1323 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n", 1324 ioc->name, SCpnt)); 1325 return SCSI_MLQUEUE_HOST_BUSY; 1326 } 1327 1328 /* 1329 * Put together a MPT SCSI request... 1330 */ 1331 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) { 1332 dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n", 1333 ioc->name)); 1334 return SCSI_MLQUEUE_HOST_BUSY; 1335 } 1336 1337 pScsiReq = (SCSIIORequest_t *) mf; 1338 1339 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 1340 1341 ADD_INDEX_LOG(my_idx); 1342 1343 /* TUR's being issued with scsictl=0x02000000 (DATA_IN)! 1344 * Seems we may receive a buffer (datalen>0) even when there 1345 * will be no data transfer! GRRRRR... 1346 */ 1347 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 1348 datalen = scsi_bufflen(SCpnt); 1349 scsidir = MPI_SCSIIO_CONTROL_READ; /* DATA IN (host<--ioc<--dev) */ 1350 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) { 1351 datalen = scsi_bufflen(SCpnt); 1352 scsidir = MPI_SCSIIO_CONTROL_WRITE; /* DATA OUT (host-->ioc-->dev) */ 1353 } else { 1354 datalen = 0; 1355 scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER; 1356 } 1357 1358 /* Default to untagged. Once a target structure has been allocated, 1359 * use the Inquiry data to determine if device supports tagged. 1360 */ 1361 if (vdevice 1362 && (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES) 1363 && (SCpnt->device->tagged_supported)) { 1364 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ; 1365 } else { 1366 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED; 1367 } 1368 1369 /* Use the above information to set up the message frame 1370 */ 1371 pScsiReq->TargetID = (u8) vdevice->vtarget->id; 1372 pScsiReq->Bus = vdevice->vtarget->channel; 1373 pScsiReq->ChainOffset = 0; 1374 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) 1375 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH; 1376 else 1377 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST; 1378 pScsiReq->CDBLength = SCpnt->cmd_len; 1379 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE; 1380 pScsiReq->Reserved = 0; 1381 pScsiReq->MsgFlags = mpt_msg_flags(ioc); 1382 int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN); 1383 pScsiReq->Control = cpu_to_le32(scsictl); 1384 1385 /* 1386 * Write SCSI CDB into the message 1387 */ 1388 cmd_len = SCpnt->cmd_len; 1389 for (ii=0; ii < cmd_len; ii++) 1390 pScsiReq->CDB[ii] = SCpnt->cmnd[ii]; 1391 1392 for (ii=cmd_len; ii < 16; ii++) 1393 pScsiReq->CDB[ii] = 0; 1394 1395 /* DataLength */ 1396 pScsiReq->DataLength = cpu_to_le32(datalen); 1397 1398 /* SenseBuffer low address */ 1399 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma 1400 + (my_idx * MPT_SENSE_BUFFER_ALLOC)); 1401 1402 /* Now add the SG list 1403 * Always have a SGE even if null length. 1404 */ 1405 if (datalen == 0) { 1406 /* Add a NULL SGE */ 1407 ioc->add_sge((char *)&pScsiReq->SGL, 1408 MPT_SGE_FLAGS_SSIMPLE_READ | 0, 1409 (dma_addr_t) -1); 1410 } else { 1411 /* Add a 32 or 64 bit SGE */ 1412 if (mptscsih_AddSGE(ioc, SCpnt, pScsiReq, my_idx) != SUCCESS) 1413 goto fail; 1414 } 1415 1416 SCpnt->host_scribble = (unsigned char *)mf; 1417 mptscsih_set_scsi_lookup(ioc, my_idx, SCpnt); 1418 1419 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf); 1420 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n", 1421 ioc->name, SCpnt, mf, my_idx)); 1422 DBG_DUMP_REQUEST_FRAME(ioc, (u32 *)mf); 1423 return 0; 1424 1425 fail: 1426 mptscsih_freeChainBuffers(ioc, my_idx); 1427 mpt_free_msg_frame(ioc, mf); 1428 return SCSI_MLQUEUE_HOST_BUSY; 1429 } 1430 1431 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1432 /* 1433 * mptscsih_freeChainBuffers - Function to free chain buffers associated 1434 * with a SCSI IO request 1435 * @hd: Pointer to the MPT_SCSI_HOST instance 1436 * @req_idx: Index of the SCSI IO request frame. 1437 * 1438 * Called if SG chain buffer allocation fails and mptscsih callbacks. 1439 * No return. 1440 */ 1441 static void 1442 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx) 1443 { 1444 MPT_FRAME_HDR *chain; 1445 unsigned long flags; 1446 int chain_idx; 1447 int next; 1448 1449 /* Get the first chain index and reset 1450 * tracker state. 1451 */ 1452 chain_idx = ioc->ReqToChain[req_idx]; 1453 ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN; 1454 1455 while (chain_idx != MPT_HOST_NO_CHAIN) { 1456 1457 /* Save the next chain buffer index */ 1458 next = ioc->ChainToChain[chain_idx]; 1459 1460 /* Free this chain buffer and reset 1461 * tracker 1462 */ 1463 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN; 1464 1465 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer 1466 + (chain_idx * ioc->req_sz)); 1467 1468 spin_lock_irqsave(&ioc->FreeQlock, flags); 1469 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ); 1470 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 1471 1472 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FreeChainBuffers (index %d)\n", 1473 ioc->name, chain_idx)); 1474 1475 /* handle next */ 1476 chain_idx = next; 1477 } 1478 return; 1479 } 1480 1481 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1482 /* 1483 * Reset Handling 1484 */ 1485 1486 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1487 /** 1488 * mptscsih_IssueTaskMgmt - Generic send Task Management function. 1489 * @hd: Pointer to MPT_SCSI_HOST structure 1490 * @type: Task Management type 1491 * @channel: channel number for task management 1492 * @id: Logical Target ID for reset (if appropriate) 1493 * @lun: Logical Unit for reset (if appropriate) 1494 * @ctx2abort: Context for the task to be aborted (if appropriate) 1495 * @timeout: timeout for task management control 1496 * 1497 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer) 1498 * or a non-interrupt thread. In the former, must not call schedule(). 1499 * 1500 * Not all fields are meaningfull for all task types. 1501 * 1502 * Returns 0 for SUCCESS, or FAILED. 1503 * 1504 **/ 1505 int 1506 mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, 1507 int ctx2abort, ulong timeout) 1508 { 1509 MPT_FRAME_HDR *mf; 1510 SCSITaskMgmt_t *pScsiTm; 1511 int ii; 1512 int retval; 1513 MPT_ADAPTER *ioc = hd->ioc; 1514 unsigned long timeleft; 1515 u8 issue_hard_reset; 1516 u32 ioc_raw_state; 1517 unsigned long time_count; 1518 1519 issue_hard_reset = 0; 1520 ioc_raw_state = mpt_GetIocState(ioc, 0); 1521 1522 if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) { 1523 printk(MYIOC_s_WARN_FMT 1524 "TaskMgmt type=%x: IOC Not operational (0x%x)!\n", 1525 ioc->name, type, ioc_raw_state); 1526 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n", 1527 ioc->name, __func__); 1528 if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0) 1529 printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset " 1530 "FAILED!!\n", ioc->name); 1531 return 0; 1532 } 1533 1534 if (ioc_raw_state & MPI_DOORBELL_ACTIVE) { 1535 printk(MYIOC_s_WARN_FMT 1536 "TaskMgmt type=%x: ioc_state: " 1537 "DOORBELL_ACTIVE (0x%x)!\n", 1538 ioc->name, type, ioc_raw_state); 1539 return FAILED; 1540 } 1541 1542 mutex_lock(&ioc->taskmgmt_cmds.mutex); 1543 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) { 1544 mf = NULL; 1545 retval = FAILED; 1546 goto out; 1547 } 1548 1549 /* Return Fail to calling function if no message frames available. 1550 */ 1551 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) { 1552 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1553 "TaskMgmt no msg frames!!\n", ioc->name)); 1554 retval = FAILED; 1555 mpt_clear_taskmgmt_in_progress_flag(ioc); 1556 goto out; 1557 } 1558 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n", 1559 ioc->name, mf)); 1560 1561 /* Format the Request 1562 */ 1563 pScsiTm = (SCSITaskMgmt_t *) mf; 1564 pScsiTm->TargetID = id; 1565 pScsiTm->Bus = channel; 1566 pScsiTm->ChainOffset = 0; 1567 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT; 1568 1569 pScsiTm->Reserved = 0; 1570 pScsiTm->TaskType = type; 1571 pScsiTm->Reserved1 = 0; 1572 pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) 1573 ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0; 1574 1575 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN); 1576 1577 for (ii=0; ii < 7; ii++) 1578 pScsiTm->Reserved2[ii] = 0; 1579 1580 pScsiTm->TaskMsgContext = ctx2abort; 1581 1582 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) " 1583 "task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort, 1584 type, timeout)); 1585 1586 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm); 1587 1588 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status) 1589 time_count = jiffies; 1590 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) && 1591 (ioc->facts.MsgVersion >= MPI_VERSION_01_05)) 1592 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf); 1593 else { 1594 retval = mpt_send_handshake_request(ioc->TaskCtx, ioc, 1595 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP); 1596 if (retval) { 1597 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1598 "TaskMgmt handshake FAILED!(mf=%p, rc=%d) \n", 1599 ioc->name, mf, retval)); 1600 mpt_free_msg_frame(ioc, mf); 1601 mpt_clear_taskmgmt_in_progress_flag(ioc); 1602 goto out; 1603 } 1604 } 1605 1606 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, 1607 timeout*HZ); 1608 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 1609 retval = FAILED; 1610 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT 1611 "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf)); 1612 mpt_clear_taskmgmt_in_progress_flag(ioc); 1613 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) 1614 goto out; 1615 issue_hard_reset = 1; 1616 goto out; 1617 } 1618 1619 retval = mptscsih_taskmgmt_reply(ioc, type, 1620 (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply); 1621 1622 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1623 "TaskMgmt completed (%d seconds)\n", 1624 ioc->name, jiffies_to_msecs(jiffies - time_count)/1000)); 1625 1626 out: 1627 1628 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status) 1629 if (issue_hard_reset) { 1630 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n", 1631 ioc->name, __func__); 1632 retval = mpt_HardResetHandler(ioc, CAN_SLEEP); 1633 mpt_free_msg_frame(ioc, mf); 1634 } 1635 1636 retval = (retval == 0) ? 0 : FAILED; 1637 mutex_unlock(&ioc->taskmgmt_cmds.mutex); 1638 return retval; 1639 } 1640 EXPORT_SYMBOL(mptscsih_IssueTaskMgmt); 1641 1642 static int 1643 mptscsih_get_tm_timeout(MPT_ADAPTER *ioc) 1644 { 1645 switch (ioc->bus_type) { 1646 case FC: 1647 return 40; 1648 case SAS: 1649 case SPI: 1650 default: 1651 return 10; 1652 } 1653 } 1654 1655 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1656 /** 1657 * mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant 1658 * @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted 1659 * 1660 * (linux scsi_host_template.eh_abort_handler routine) 1661 * 1662 * Returns SUCCESS or FAILED. 1663 **/ 1664 int 1665 mptscsih_abort(struct scsi_cmnd * SCpnt) 1666 { 1667 MPT_SCSI_HOST *hd; 1668 MPT_FRAME_HDR *mf; 1669 u32 ctx2abort; 1670 int scpnt_idx; 1671 int retval; 1672 VirtDevice *vdevice; 1673 ulong sn = SCpnt->serial_number; 1674 MPT_ADAPTER *ioc; 1675 1676 /* If we can't locate our host adapter structure, return FAILED status. 1677 */ 1678 if ((hd = shost_priv(SCpnt->device->host)) == NULL) { 1679 SCpnt->result = DID_RESET << 16; 1680 SCpnt->scsi_done(SCpnt); 1681 printk(KERN_ERR MYNAM ": task abort: " 1682 "can't locate host! (sc=%p)\n", SCpnt); 1683 return FAILED; 1684 } 1685 1686 ioc = hd->ioc; 1687 printk(MYIOC_s_INFO_FMT "attempting task abort! (sc=%p)\n", 1688 ioc->name, SCpnt); 1689 scsi_print_command(SCpnt); 1690 1691 vdevice = SCpnt->device->hostdata; 1692 if (!vdevice || !vdevice->vtarget) { 1693 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1694 "task abort: device has been deleted (sc=%p)\n", 1695 ioc->name, SCpnt)); 1696 SCpnt->result = DID_NO_CONNECT << 16; 1697 SCpnt->scsi_done(SCpnt); 1698 retval = 0; 1699 goto out; 1700 } 1701 1702 /* Task aborts are not supported for hidden raid components. 1703 */ 1704 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) { 1705 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1706 "task abort: hidden raid component (sc=%p)\n", 1707 ioc->name, SCpnt)); 1708 SCpnt->result = DID_RESET << 16; 1709 retval = FAILED; 1710 goto out; 1711 } 1712 1713 /* Find this command 1714 */ 1715 if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) { 1716 /* Cmd not found in ScsiLookup. 1717 * Do OS callback. 1718 */ 1719 SCpnt->result = DID_RESET << 16; 1720 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: " 1721 "Command not in the active list! (sc=%p)\n", ioc->name, 1722 SCpnt)); 1723 retval = 0; 1724 goto out; 1725 } 1726 1727 if (ioc->timeouts < -1) 1728 ioc->timeouts++; 1729 1730 if (mpt_fwfault_debug) 1731 mpt_halt_firmware(ioc); 1732 1733 /* Most important! Set TaskMsgContext to SCpnt's MsgContext! 1734 * (the IO to be ABORT'd) 1735 * 1736 * NOTE: Since we do not byteswap MsgContext, we do not 1737 * swap it here either. It is an opaque cookie to 1738 * the controller, so it does not matter. -DaveM 1739 */ 1740 mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx); 1741 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext; 1742 retval = mptscsih_IssueTaskMgmt(hd, 1743 MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK, 1744 vdevice->vtarget->channel, 1745 vdevice->vtarget->id, vdevice->lun, 1746 ctx2abort, mptscsih_get_tm_timeout(ioc)); 1747 1748 if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx && 1749 SCpnt->serial_number == sn) { 1750 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1751 "task abort: command still in active list! (sc=%p)\n", 1752 ioc->name, SCpnt)); 1753 retval = FAILED; 1754 } else { 1755 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1756 "task abort: command cleared from active list! (sc=%p)\n", 1757 ioc->name, SCpnt)); 1758 retval = SUCCESS; 1759 } 1760 1761 out: 1762 printk(MYIOC_s_INFO_FMT "task abort: %s (sc=%p)\n", 1763 ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), SCpnt); 1764 1765 return retval; 1766 } 1767 1768 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1769 /** 1770 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant 1771 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to 1772 * 1773 * (linux scsi_host_template.eh_dev_reset_handler routine) 1774 * 1775 * Returns SUCCESS or FAILED. 1776 **/ 1777 int 1778 mptscsih_dev_reset(struct scsi_cmnd * SCpnt) 1779 { 1780 MPT_SCSI_HOST *hd; 1781 int retval; 1782 VirtDevice *vdevice; 1783 MPT_ADAPTER *ioc; 1784 1785 /* If we can't locate our host adapter structure, return FAILED status. 1786 */ 1787 if ((hd = shost_priv(SCpnt->device->host)) == NULL){ 1788 printk(KERN_ERR MYNAM ": target reset: " 1789 "Can't locate host! (sc=%p)\n", SCpnt); 1790 return FAILED; 1791 } 1792 1793 ioc = hd->ioc; 1794 printk(MYIOC_s_INFO_FMT "attempting target reset! (sc=%p)\n", 1795 ioc->name, SCpnt); 1796 scsi_print_command(SCpnt); 1797 1798 vdevice = SCpnt->device->hostdata; 1799 if (!vdevice || !vdevice->vtarget) { 1800 retval = SUCCESS; 1801 goto out; 1802 } 1803 1804 /* Target reset to hidden raid component is not supported 1805 */ 1806 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) { 1807 retval = FAILED; 1808 goto out; 1809 } 1810 1811 retval = mptscsih_IssueTaskMgmt(hd, 1812 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 1813 vdevice->vtarget->channel, 1814 vdevice->vtarget->id, 0, 0, 1815 mptscsih_get_tm_timeout(ioc)); 1816 1817 out: 1818 printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n", 1819 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt); 1820 1821 if (retval == 0) 1822 return SUCCESS; 1823 else 1824 return FAILED; 1825 } 1826 1827 1828 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1829 /** 1830 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant 1831 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to 1832 * 1833 * (linux scsi_host_template.eh_bus_reset_handler routine) 1834 * 1835 * Returns SUCCESS or FAILED. 1836 **/ 1837 int 1838 mptscsih_bus_reset(struct scsi_cmnd * SCpnt) 1839 { 1840 MPT_SCSI_HOST *hd; 1841 int retval; 1842 VirtDevice *vdevice; 1843 MPT_ADAPTER *ioc; 1844 1845 /* If we can't locate our host adapter structure, return FAILED status. 1846 */ 1847 if ((hd = shost_priv(SCpnt->device->host)) == NULL){ 1848 printk(KERN_ERR MYNAM ": bus reset: " 1849 "Can't locate host! (sc=%p)\n", SCpnt); 1850 return FAILED; 1851 } 1852 1853 ioc = hd->ioc; 1854 printk(MYIOC_s_INFO_FMT "attempting bus reset! (sc=%p)\n", 1855 ioc->name, SCpnt); 1856 scsi_print_command(SCpnt); 1857 1858 if (ioc->timeouts < -1) 1859 ioc->timeouts++; 1860 1861 vdevice = SCpnt->device->hostdata; 1862 if (!vdevice || !vdevice->vtarget) 1863 return SUCCESS; 1864 retval = mptscsih_IssueTaskMgmt(hd, 1865 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, 1866 vdevice->vtarget->channel, 0, 0, 0, 1867 mptscsih_get_tm_timeout(ioc)); 1868 1869 printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n", 1870 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt); 1871 1872 if (retval == 0) 1873 return SUCCESS; 1874 else 1875 return FAILED; 1876 } 1877 1878 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1879 /** 1880 * mptscsih_host_reset - Perform a SCSI host adapter RESET (new_eh variant) 1881 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to 1882 * 1883 * (linux scsi_host_template.eh_host_reset_handler routine) 1884 * 1885 * Returns SUCCESS or FAILED. 1886 */ 1887 int 1888 mptscsih_host_reset(struct scsi_cmnd *SCpnt) 1889 { 1890 MPT_SCSI_HOST * hd; 1891 int status = SUCCESS; 1892 MPT_ADAPTER *ioc; 1893 int retval; 1894 1895 /* If we can't locate the host to reset, then we failed. */ 1896 if ((hd = shost_priv(SCpnt->device->host)) == NULL){ 1897 printk(KERN_ERR MYNAM ": host reset: " 1898 "Can't locate host! (sc=%p)\n", SCpnt); 1899 return FAILED; 1900 } 1901 1902 /* make sure we have no outstanding commands at this stage */ 1903 mptscsih_flush_running_cmds(hd); 1904 1905 ioc = hd->ioc; 1906 printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n", 1907 ioc->name, SCpnt); 1908 1909 /* If our attempts to reset the host failed, then return a failed 1910 * status. The host will be taken off line by the SCSI mid-layer. 1911 */ 1912 retval = mpt_HardResetHandler(ioc, CAN_SLEEP); 1913 if (retval < 0) 1914 status = FAILED; 1915 else 1916 status = SUCCESS; 1917 1918 printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n", 1919 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt); 1920 1921 return status; 1922 } 1923 1924 static int 1925 mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type, 1926 SCSITaskMgmtReply_t *pScsiTmReply) 1927 { 1928 u16 iocstatus; 1929 u32 termination_count; 1930 int retval; 1931 1932 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) { 1933 retval = FAILED; 1934 goto out; 1935 } 1936 1937 DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply); 1938 1939 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK; 1940 termination_count = le32_to_cpu(pScsiTmReply->TerminationCount); 1941 1942 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1943 "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n" 1944 "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n" 1945 "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus, 1946 pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus), 1947 le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode, 1948 termination_count)); 1949 1950 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 && 1951 pScsiTmReply->ResponseCode) 1952 mptscsih_taskmgmt_response_code(ioc, 1953 pScsiTmReply->ResponseCode); 1954 1955 if (iocstatus == MPI_IOCSTATUS_SUCCESS) { 1956 retval = 0; 1957 goto out; 1958 } 1959 1960 retval = FAILED; 1961 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) { 1962 if (termination_count == 1) 1963 retval = 0; 1964 goto out; 1965 } 1966 1967 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED || 1968 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED) 1969 retval = 0; 1970 1971 out: 1972 return retval; 1973 } 1974 1975 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1976 void 1977 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code) 1978 { 1979 char *desc; 1980 1981 switch (response_code) { 1982 case MPI_SCSITASKMGMT_RSP_TM_COMPLETE: 1983 desc = "The task completed."; 1984 break; 1985 case MPI_SCSITASKMGMT_RSP_INVALID_FRAME: 1986 desc = "The IOC received an invalid frame status."; 1987 break; 1988 case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED: 1989 desc = "The task type is not supported."; 1990 break; 1991 case MPI_SCSITASKMGMT_RSP_TM_FAILED: 1992 desc = "The requested task failed."; 1993 break; 1994 case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED: 1995 desc = "The task completed successfully."; 1996 break; 1997 case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN: 1998 desc = "The LUN request is invalid."; 1999 break; 2000 case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC: 2001 desc = "The task is in the IOC queue and has not been sent to target."; 2002 break; 2003 default: 2004 desc = "unknown"; 2005 break; 2006 } 2007 printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n", 2008 ioc->name, response_code, desc); 2009 } 2010 EXPORT_SYMBOL(mptscsih_taskmgmt_response_code); 2011 2012 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2013 /** 2014 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver 2015 * @ioc: Pointer to MPT_ADAPTER structure 2016 * @mf: Pointer to SCSI task mgmt request frame 2017 * @mr: Pointer to SCSI task mgmt reply frame 2018 * 2019 * This routine is called from mptbase.c::mpt_interrupt() at the completion 2020 * of any SCSI task management request. 2021 * This routine is registered with the MPT (base) driver at driver 2022 * load/init time via the mpt_register() API call. 2023 * 2024 * Returns 1 indicating alloc'd request frame ptr should be freed. 2025 **/ 2026 int 2027 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, 2028 MPT_FRAME_HDR *mr) 2029 { 2030 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2031 "TaskMgmt completed (mf=%p, mr=%p)\n", ioc->name, mf, mr)); 2032 2033 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD; 2034 2035 if (!mr) 2036 goto out; 2037 2038 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID; 2039 memcpy(ioc->taskmgmt_cmds.reply, mr, 2040 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength)); 2041 out: 2042 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) { 2043 mpt_clear_taskmgmt_in_progress_flag(ioc); 2044 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING; 2045 complete(&ioc->taskmgmt_cmds.done); 2046 return 1; 2047 } 2048 return 0; 2049 } 2050 2051 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2052 /* 2053 * This is anyones guess quite frankly. 2054 */ 2055 int 2056 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev, 2057 sector_t capacity, int geom[]) 2058 { 2059 int heads; 2060 int sectors; 2061 sector_t cylinders; 2062 ulong dummy; 2063 2064 heads = 64; 2065 sectors = 32; 2066 2067 dummy = heads * sectors; 2068 cylinders = capacity; 2069 sector_div(cylinders,dummy); 2070 2071 /* 2072 * Handle extended translation size for logical drives 2073 * > 1Gb 2074 */ 2075 if ((ulong)capacity >= 0x200000) { 2076 heads = 255; 2077 sectors = 63; 2078 dummy = heads * sectors; 2079 cylinders = capacity; 2080 sector_div(cylinders,dummy); 2081 } 2082 2083 /* return result */ 2084 geom[0] = heads; 2085 geom[1] = sectors; 2086 geom[2] = cylinders; 2087 2088 return 0; 2089 } 2090 2091 /* Search IOC page 3 to determine if this is hidden physical disk 2092 * 2093 */ 2094 int 2095 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id) 2096 { 2097 struct inactive_raid_component_info *component_info; 2098 int i, j; 2099 RaidPhysDiskPage1_t *phys_disk; 2100 int rc = 0; 2101 int num_paths; 2102 2103 if (!ioc->raid_data.pIocPg3) 2104 goto out; 2105 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) { 2106 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) && 2107 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) { 2108 rc = 1; 2109 goto out; 2110 } 2111 } 2112 2113 if (ioc->bus_type != SAS) 2114 goto out; 2115 2116 /* 2117 * Check if dual path 2118 */ 2119 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) { 2120 num_paths = mpt_raid_phys_disk_get_num_paths(ioc, 2121 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum); 2122 if (num_paths < 2) 2123 continue; 2124 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) + 2125 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL); 2126 if (!phys_disk) 2127 continue; 2128 if ((mpt_raid_phys_disk_pg1(ioc, 2129 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum, 2130 phys_disk))) { 2131 kfree(phys_disk); 2132 continue; 2133 } 2134 for (j = 0; j < num_paths; j++) { 2135 if ((phys_disk->Path[j].Flags & 2136 MPI_RAID_PHYSDISK1_FLAG_INVALID)) 2137 continue; 2138 if ((phys_disk->Path[j].Flags & 2139 MPI_RAID_PHYSDISK1_FLAG_BROKEN)) 2140 continue; 2141 if ((id == phys_disk->Path[j].PhysDiskID) && 2142 (channel == phys_disk->Path[j].PhysDiskBus)) { 2143 rc = 1; 2144 kfree(phys_disk); 2145 goto out; 2146 } 2147 } 2148 kfree(phys_disk); 2149 } 2150 2151 2152 /* 2153 * Check inactive list for matching phys disks 2154 */ 2155 if (list_empty(&ioc->raid_data.inactive_list)) 2156 goto out; 2157 2158 mutex_lock(&ioc->raid_data.inactive_list_mutex); 2159 list_for_each_entry(component_info, &ioc->raid_data.inactive_list, 2160 list) { 2161 if ((component_info->d.PhysDiskID == id) && 2162 (component_info->d.PhysDiskBus == channel)) 2163 rc = 1; 2164 } 2165 mutex_unlock(&ioc->raid_data.inactive_list_mutex); 2166 2167 out: 2168 return rc; 2169 } 2170 EXPORT_SYMBOL(mptscsih_is_phys_disk); 2171 2172 u8 2173 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id) 2174 { 2175 struct inactive_raid_component_info *component_info; 2176 int i, j; 2177 RaidPhysDiskPage1_t *phys_disk; 2178 int rc = -ENXIO; 2179 int num_paths; 2180 2181 if (!ioc->raid_data.pIocPg3) 2182 goto out; 2183 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) { 2184 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) && 2185 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) { 2186 rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum; 2187 goto out; 2188 } 2189 } 2190 2191 if (ioc->bus_type != SAS) 2192 goto out; 2193 2194 /* 2195 * Check if dual path 2196 */ 2197 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) { 2198 num_paths = mpt_raid_phys_disk_get_num_paths(ioc, 2199 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum); 2200 if (num_paths < 2) 2201 continue; 2202 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) + 2203 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL); 2204 if (!phys_disk) 2205 continue; 2206 if ((mpt_raid_phys_disk_pg1(ioc, 2207 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum, 2208 phys_disk))) { 2209 kfree(phys_disk); 2210 continue; 2211 } 2212 for (j = 0; j < num_paths; j++) { 2213 if ((phys_disk->Path[j].Flags & 2214 MPI_RAID_PHYSDISK1_FLAG_INVALID)) 2215 continue; 2216 if ((phys_disk->Path[j].Flags & 2217 MPI_RAID_PHYSDISK1_FLAG_BROKEN)) 2218 continue; 2219 if ((id == phys_disk->Path[j].PhysDiskID) && 2220 (channel == phys_disk->Path[j].PhysDiskBus)) { 2221 rc = phys_disk->PhysDiskNum; 2222 kfree(phys_disk); 2223 goto out; 2224 } 2225 } 2226 kfree(phys_disk); 2227 } 2228 2229 /* 2230 * Check inactive list for matching phys disks 2231 */ 2232 if (list_empty(&ioc->raid_data.inactive_list)) 2233 goto out; 2234 2235 mutex_lock(&ioc->raid_data.inactive_list_mutex); 2236 list_for_each_entry(component_info, &ioc->raid_data.inactive_list, 2237 list) { 2238 if ((component_info->d.PhysDiskID == id) && 2239 (component_info->d.PhysDiskBus == channel)) 2240 rc = component_info->d.PhysDiskNum; 2241 } 2242 mutex_unlock(&ioc->raid_data.inactive_list_mutex); 2243 2244 out: 2245 return rc; 2246 } 2247 EXPORT_SYMBOL(mptscsih_raid_id_to_num); 2248 2249 /* 2250 * OS entry point to allow for host driver to free allocated memory 2251 * Called if no device present or device being unloaded 2252 */ 2253 void 2254 mptscsih_slave_destroy(struct scsi_device *sdev) 2255 { 2256 struct Scsi_Host *host = sdev->host; 2257 MPT_SCSI_HOST *hd = shost_priv(host); 2258 VirtTarget *vtarget; 2259 VirtDevice *vdevice; 2260 struct scsi_target *starget; 2261 2262 starget = scsi_target(sdev); 2263 vtarget = starget->hostdata; 2264 vdevice = sdev->hostdata; 2265 2266 mptscsih_search_running_cmds(hd, vdevice); 2267 vtarget->num_luns--; 2268 mptscsih_synchronize_cache(hd, vdevice); 2269 kfree(vdevice); 2270 sdev->hostdata = NULL; 2271 } 2272 2273 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2274 /* 2275 * mptscsih_change_queue_depth - This function will set a devices queue depth 2276 * @sdev: per scsi_device pointer 2277 * @qdepth: requested queue depth 2278 * 2279 * Adding support for new 'change_queue_depth' api. 2280 */ 2281 int 2282 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth) 2283 { 2284 MPT_SCSI_HOST *hd = shost_priv(sdev->host); 2285 VirtTarget *vtarget; 2286 struct scsi_target *starget; 2287 int max_depth; 2288 int tagged; 2289 MPT_ADAPTER *ioc = hd->ioc; 2290 2291 starget = scsi_target(sdev); 2292 vtarget = starget->hostdata; 2293 2294 if (ioc->bus_type == SPI) { 2295 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)) 2296 max_depth = 1; 2297 else if (sdev->type == TYPE_DISK && 2298 vtarget->minSyncFactor <= MPT_ULTRA160) 2299 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH; 2300 else 2301 max_depth = MPT_SCSI_CMD_PER_DEV_LOW; 2302 } else 2303 max_depth = ioc->sh->can_queue; 2304 2305 if (!sdev->tagged_supported) 2306 max_depth = 1; 2307 2308 if (qdepth > max_depth) 2309 qdepth = max_depth; 2310 if (qdepth == 1) 2311 tagged = 0; 2312 else 2313 tagged = MSG_SIMPLE_TAG; 2314 2315 scsi_adjust_queue_depth(sdev, tagged, qdepth); 2316 return sdev->queue_depth; 2317 } 2318 2319 /* 2320 * OS entry point to adjust the queue_depths on a per-device basis. 2321 * Called once per device the bus scan. Use it to force the queue_depth 2322 * member to 1 if a device does not support Q tags. 2323 * Return non-zero if fails. 2324 */ 2325 int 2326 mptscsih_slave_configure(struct scsi_device *sdev) 2327 { 2328 struct Scsi_Host *sh = sdev->host; 2329 VirtTarget *vtarget; 2330 VirtDevice *vdevice; 2331 struct scsi_target *starget; 2332 MPT_SCSI_HOST *hd = shost_priv(sh); 2333 MPT_ADAPTER *ioc = hd->ioc; 2334 2335 starget = scsi_target(sdev); 2336 vtarget = starget->hostdata; 2337 vdevice = sdev->hostdata; 2338 2339 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2340 "device @ %p, channel=%d, id=%d, lun=%d\n", 2341 ioc->name, sdev, sdev->channel, sdev->id, sdev->lun)); 2342 if (ioc->bus_type == SPI) 2343 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2344 "sdtr %d wdtr %d ppr %d inq length=%d\n", 2345 ioc->name, sdev->sdtr, sdev->wdtr, 2346 sdev->ppr, sdev->inquiry_len)); 2347 2348 vdevice->configured_lun = 1; 2349 2350 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2351 "Queue depth=%d, tflags=%x\n", 2352 ioc->name, sdev->queue_depth, vtarget->tflags)); 2353 2354 if (ioc->bus_type == SPI) 2355 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2356 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n", 2357 ioc->name, vtarget->negoFlags, vtarget->maxOffset, 2358 vtarget->minSyncFactor)); 2359 2360 mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH); 2361 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2362 "tagged %d, simple %d, ordered %d\n", 2363 ioc->name,sdev->tagged_supported, sdev->simple_tags, 2364 sdev->ordered_tags)); 2365 2366 return 0; 2367 } 2368 2369 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2370 /* 2371 * Private routines... 2372 */ 2373 2374 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2375 /* Utility function to copy sense data from the scsi_cmnd buffer 2376 * to the FC and SCSI target structures. 2377 * 2378 */ 2379 static void 2380 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply) 2381 { 2382 VirtDevice *vdevice; 2383 SCSIIORequest_t *pReq; 2384 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount); 2385 MPT_ADAPTER *ioc = hd->ioc; 2386 2387 /* Get target structure 2388 */ 2389 pReq = (SCSIIORequest_t *) mf; 2390 vdevice = sc->device->hostdata; 2391 2392 if (sense_count) { 2393 u8 *sense_data; 2394 int req_index; 2395 2396 /* Copy the sense received into the scsi command block. */ 2397 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 2398 sense_data = ((u8 *)ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC)); 2399 memcpy(sc->sense_buffer, sense_data, SNS_LEN(sc)); 2400 2401 /* Log SMART data (asc = 0x5D, non-IM case only) if required. 2402 */ 2403 if ((ioc->events) && (ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) { 2404 if ((sense_data[12] == 0x5D) && (vdevice->vtarget->raidVolume == 0)) { 2405 int idx; 2406 2407 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE; 2408 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE; 2409 ioc->events[idx].eventContext = ioc->eventContext; 2410 2411 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) | 2412 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) | 2413 (sc->device->channel << 8) | sc->device->id; 2414 2415 ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12]; 2416 2417 ioc->eventContext++; 2418 if (ioc->pcidev->vendor == 2419 PCI_VENDOR_ID_IBM) { 2420 mptscsih_issue_sep_command(ioc, 2421 vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT); 2422 vdevice->vtarget->tflags |= 2423 MPT_TARGET_FLAGS_LED_ON; 2424 } 2425 } 2426 } 2427 } else { 2428 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n", 2429 ioc->name)); 2430 } 2431 } 2432 2433 /** 2434 * mptscsih_get_scsi_lookup - retrieves scmd entry 2435 * @ioc: Pointer to MPT_ADAPTER structure 2436 * @i: index into the array 2437 * 2438 * Returns the scsi_cmd pointer 2439 */ 2440 struct scsi_cmnd * 2441 mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i) 2442 { 2443 unsigned long flags; 2444 struct scsi_cmnd *scmd; 2445 2446 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 2447 scmd = ioc->ScsiLookup[i]; 2448 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 2449 2450 return scmd; 2451 } 2452 EXPORT_SYMBOL(mptscsih_get_scsi_lookup); 2453 2454 /** 2455 * mptscsih_getclear_scsi_lookup - retrieves and clears scmd entry from ScsiLookup[] array list 2456 * @ioc: Pointer to MPT_ADAPTER structure 2457 * @i: index into the array 2458 * 2459 * Returns the scsi_cmd pointer 2460 * 2461 **/ 2462 static struct scsi_cmnd * 2463 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i) 2464 { 2465 unsigned long flags; 2466 struct scsi_cmnd *scmd; 2467 2468 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 2469 scmd = ioc->ScsiLookup[i]; 2470 ioc->ScsiLookup[i] = NULL; 2471 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 2472 2473 return scmd; 2474 } 2475 2476 /** 2477 * mptscsih_set_scsi_lookup 2478 * 2479 * writes a scmd entry into the ScsiLookup[] array list 2480 * 2481 * @ioc: Pointer to MPT_ADAPTER structure 2482 * @i: index into the array 2483 * @scmd: scsi_cmnd pointer 2484 * 2485 **/ 2486 static void 2487 mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd) 2488 { 2489 unsigned long flags; 2490 2491 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 2492 ioc->ScsiLookup[i] = scmd; 2493 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 2494 } 2495 2496 /** 2497 * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list 2498 * @ioc: Pointer to MPT_ADAPTER structure 2499 * @sc: scsi_cmnd pointer 2500 */ 2501 static int 2502 SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc) 2503 { 2504 unsigned long flags; 2505 int i, index=-1; 2506 2507 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 2508 for (i = 0; i < ioc->req_depth; i++) { 2509 if (ioc->ScsiLookup[i] == sc) { 2510 index = i; 2511 goto out; 2512 } 2513 } 2514 2515 out: 2516 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 2517 return index; 2518 } 2519 2520 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2521 int 2522 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 2523 { 2524 MPT_SCSI_HOST *hd; 2525 2526 if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL) 2527 return 0; 2528 2529 hd = shost_priv(ioc->sh); 2530 switch (reset_phase) { 2531 case MPT_IOC_SETUP_RESET: 2532 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2533 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__)); 2534 break; 2535 case MPT_IOC_PRE_RESET: 2536 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2537 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__)); 2538 mptscsih_flush_running_cmds(hd); 2539 break; 2540 case MPT_IOC_POST_RESET: 2541 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2542 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__)); 2543 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) { 2544 ioc->internal_cmds.status |= 2545 MPT_MGMT_STATUS_DID_IOCRESET; 2546 complete(&ioc->internal_cmds.done); 2547 } 2548 break; 2549 default: 2550 break; 2551 } 2552 return 1; /* currently means nothing really */ 2553 } 2554 2555 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2556 int 2557 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) 2558 { 2559 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF; 2560 2561 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2562 "MPT event (=%02Xh) routed to SCSI host driver!\n", 2563 ioc->name, event)); 2564 2565 if ((event == MPI_EVENT_IOC_BUS_RESET || 2566 event == MPI_EVENT_EXT_BUS_RESET) && 2567 (ioc->bus_type == SPI) && (ioc->soft_resets < -1)) 2568 ioc->soft_resets++; 2569 2570 return 1; /* currently means nothing really */ 2571 } 2572 2573 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2574 /* 2575 * Bus Scan and Domain Validation functionality ... 2576 */ 2577 2578 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2579 /* 2580 * mptscsih_scandv_complete - Scan and DV callback routine registered 2581 * to Fustion MPT (base) driver. 2582 * 2583 * @ioc: Pointer to MPT_ADAPTER structure 2584 * @mf: Pointer to original MPT request frame 2585 * @mr: Pointer to MPT reply frame (NULL if TurboReply) 2586 * 2587 * This routine is called from mpt.c::mpt_interrupt() at the completion 2588 * of any SCSI IO request. 2589 * This routine is registered with the Fusion MPT (base) driver at driver 2590 * load/init time via the mpt_register() API call. 2591 * 2592 * Returns 1 indicating alloc'd request frame ptr should be freed. 2593 * 2594 * Remark: Sets a completion code and (possibly) saves sense data 2595 * in the IOC member localReply structure. 2596 * Used ONLY for DV and other internal commands. 2597 */ 2598 int 2599 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, 2600 MPT_FRAME_HDR *reply) 2601 { 2602 SCSIIORequest_t *pReq; 2603 SCSIIOReply_t *pReply; 2604 u8 cmd; 2605 u16 req_idx; 2606 u8 *sense_data; 2607 int sz; 2608 2609 ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD; 2610 ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD; 2611 if (!reply) 2612 goto out; 2613 2614 pReply = (SCSIIOReply_t *) reply; 2615 pReq = (SCSIIORequest_t *) req; 2616 ioc->internal_cmds.completion_code = 2617 mptscsih_get_completion_code(ioc, req, reply); 2618 ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID; 2619 memcpy(ioc->internal_cmds.reply, reply, 2620 min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength)); 2621 cmd = reply->u.hdr.Function; 2622 if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) || 2623 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) && 2624 (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) { 2625 req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx); 2626 sense_data = ((u8 *)ioc->sense_buf_pool + 2627 (req_idx * MPT_SENSE_BUFFER_ALLOC)); 2628 sz = min_t(int, pReq->SenseBufferLength, 2629 MPT_SENSE_BUFFER_ALLOC); 2630 memcpy(ioc->internal_cmds.sense, sense_data, sz); 2631 } 2632 out: 2633 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING)) 2634 return 0; 2635 ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING; 2636 complete(&ioc->internal_cmds.done); 2637 return 1; 2638 } 2639 2640 2641 /** 2642 * mptscsih_get_completion_code - 2643 * @ioc: Pointer to MPT_ADAPTER structure 2644 * @req: Pointer to original MPT request frame 2645 * @reply: Pointer to MPT reply frame (NULL if TurboReply) 2646 * 2647 **/ 2648 static int 2649 mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, 2650 MPT_FRAME_HDR *reply) 2651 { 2652 SCSIIOReply_t *pReply; 2653 MpiRaidActionReply_t *pr; 2654 u8 scsi_status; 2655 u16 status; 2656 int completion_code; 2657 2658 pReply = (SCSIIOReply_t *)reply; 2659 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK; 2660 scsi_status = pReply->SCSIStatus; 2661 2662 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2663 "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh," 2664 "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState, 2665 scsi_status, le32_to_cpu(pReply->IOCLogInfo))); 2666 2667 switch (status) { 2668 2669 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */ 2670 completion_code = MPT_SCANDV_SELECTION_TIMEOUT; 2671 break; 2672 2673 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */ 2674 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */ 2675 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */ 2676 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */ 2677 completion_code = MPT_SCANDV_DID_RESET; 2678 break; 2679 2680 case MPI_IOCSTATUS_BUSY: 2681 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: 2682 completion_code = MPT_SCANDV_BUSY; 2683 break; 2684 2685 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */ 2686 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */ 2687 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */ 2688 if (pReply->Function == MPI_FUNCTION_CONFIG) { 2689 completion_code = MPT_SCANDV_GOOD; 2690 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) { 2691 pr = (MpiRaidActionReply_t *)reply; 2692 if (le16_to_cpu(pr->ActionStatus) == 2693 MPI_RAID_ACTION_ASTATUS_SUCCESS) 2694 completion_code = MPT_SCANDV_GOOD; 2695 else 2696 completion_code = MPT_SCANDV_SOME_ERROR; 2697 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) 2698 completion_code = MPT_SCANDV_SENSE; 2699 else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) { 2700 if (req->u.scsireq.CDB[0] == INQUIRY) 2701 completion_code = MPT_SCANDV_ISSUE_SENSE; 2702 else 2703 completion_code = MPT_SCANDV_DID_RESET; 2704 } else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS) 2705 completion_code = MPT_SCANDV_DID_RESET; 2706 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED) 2707 completion_code = MPT_SCANDV_DID_RESET; 2708 else if (scsi_status == MPI_SCSI_STATUS_BUSY) 2709 completion_code = MPT_SCANDV_BUSY; 2710 else 2711 completion_code = MPT_SCANDV_GOOD; 2712 break; 2713 2714 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */ 2715 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED) 2716 completion_code = MPT_SCANDV_DID_RESET; 2717 else 2718 completion_code = MPT_SCANDV_SOME_ERROR; 2719 break; 2720 default: 2721 completion_code = MPT_SCANDV_SOME_ERROR; 2722 break; 2723 2724 } /* switch(status) */ 2725 2726 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2727 " completionCode set to %08xh\n", ioc->name, completion_code)); 2728 return completion_code; 2729 } 2730 2731 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2732 /** 2733 * mptscsih_do_cmd - Do internal command. 2734 * @hd: MPT_SCSI_HOST pointer 2735 * @io: INTERNAL_CMD pointer. 2736 * 2737 * Issue the specified internally generated command and do command 2738 * specific cleanup. For bus scan / DV only. 2739 * NOTES: If command is Inquiry and status is good, 2740 * initialize a target structure, save the data 2741 * 2742 * Remark: Single threaded access only. 2743 * 2744 * Return: 2745 * < 0 if an illegal command or no resources 2746 * 2747 * 0 if good 2748 * 2749 * > 0 if command complete but some type of completion error. 2750 */ 2751 static int 2752 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io) 2753 { 2754 MPT_FRAME_HDR *mf; 2755 SCSIIORequest_t *pScsiReq; 2756 int my_idx, ii, dir; 2757 int timeout; 2758 char cmdLen; 2759 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 2760 u8 cmd = io->cmd; 2761 MPT_ADAPTER *ioc = hd->ioc; 2762 int ret = 0; 2763 unsigned long timeleft; 2764 unsigned long flags; 2765 2766 /* don't send internal command during diag reset */ 2767 spin_lock_irqsave(&ioc->taskmgmt_lock, flags); 2768 if (ioc->ioc_reset_in_progress) { 2769 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 2770 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2771 "%s: busy with host reset\n", ioc->name, __func__)); 2772 return MPT_SCANDV_BUSY; 2773 } 2774 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 2775 2776 mutex_lock(&ioc->internal_cmds.mutex); 2777 2778 /* Set command specific information 2779 */ 2780 switch (cmd) { 2781 case INQUIRY: 2782 cmdLen = 6; 2783 dir = MPI_SCSIIO_CONTROL_READ; 2784 CDB[0] = cmd; 2785 CDB[4] = io->size; 2786 timeout = 10; 2787 break; 2788 2789 case TEST_UNIT_READY: 2790 cmdLen = 6; 2791 dir = MPI_SCSIIO_CONTROL_READ; 2792 timeout = 10; 2793 break; 2794 2795 case START_STOP: 2796 cmdLen = 6; 2797 dir = MPI_SCSIIO_CONTROL_READ; 2798 CDB[0] = cmd; 2799 CDB[4] = 1; /*Spin up the disk */ 2800 timeout = 15; 2801 break; 2802 2803 case REQUEST_SENSE: 2804 cmdLen = 6; 2805 CDB[0] = cmd; 2806 CDB[4] = io->size; 2807 dir = MPI_SCSIIO_CONTROL_READ; 2808 timeout = 10; 2809 break; 2810 2811 case READ_BUFFER: 2812 cmdLen = 10; 2813 dir = MPI_SCSIIO_CONTROL_READ; 2814 CDB[0] = cmd; 2815 if (io->flags & MPT_ICFLAG_ECHO) { 2816 CDB[1] = 0x0A; 2817 } else { 2818 CDB[1] = 0x02; 2819 } 2820 2821 if (io->flags & MPT_ICFLAG_BUF_CAP) { 2822 CDB[1] |= 0x01; 2823 } 2824 CDB[6] = (io->size >> 16) & 0xFF; 2825 CDB[7] = (io->size >> 8) & 0xFF; 2826 CDB[8] = io->size & 0xFF; 2827 timeout = 10; 2828 break; 2829 2830 case WRITE_BUFFER: 2831 cmdLen = 10; 2832 dir = MPI_SCSIIO_CONTROL_WRITE; 2833 CDB[0] = cmd; 2834 if (io->flags & MPT_ICFLAG_ECHO) { 2835 CDB[1] = 0x0A; 2836 } else { 2837 CDB[1] = 0x02; 2838 } 2839 CDB[6] = (io->size >> 16) & 0xFF; 2840 CDB[7] = (io->size >> 8) & 0xFF; 2841 CDB[8] = io->size & 0xFF; 2842 timeout = 10; 2843 break; 2844 2845 case RESERVE: 2846 cmdLen = 6; 2847 dir = MPI_SCSIIO_CONTROL_READ; 2848 CDB[0] = cmd; 2849 timeout = 10; 2850 break; 2851 2852 case RELEASE: 2853 cmdLen = 6; 2854 dir = MPI_SCSIIO_CONTROL_READ; 2855 CDB[0] = cmd; 2856 timeout = 10; 2857 break; 2858 2859 case SYNCHRONIZE_CACHE: 2860 cmdLen = 10; 2861 dir = MPI_SCSIIO_CONTROL_READ; 2862 CDB[0] = cmd; 2863 // CDB[1] = 0x02; /* set immediate bit */ 2864 timeout = 10; 2865 break; 2866 2867 default: 2868 /* Error Case */ 2869 ret = -EFAULT; 2870 goto out; 2871 } 2872 2873 /* Get and Populate a free Frame 2874 * MsgContext set in mpt_get_msg_frame call 2875 */ 2876 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) { 2877 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n", 2878 ioc->name, __func__)); 2879 ret = MPT_SCANDV_BUSY; 2880 goto out; 2881 } 2882 2883 pScsiReq = (SCSIIORequest_t *) mf; 2884 2885 /* Get the request index */ 2886 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 2887 ADD_INDEX_LOG(my_idx); /* for debug */ 2888 2889 if (io->flags & MPT_ICFLAG_PHYS_DISK) { 2890 pScsiReq->TargetID = io->physDiskNum; 2891 pScsiReq->Bus = 0; 2892 pScsiReq->ChainOffset = 0; 2893 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH; 2894 } else { 2895 pScsiReq->TargetID = io->id; 2896 pScsiReq->Bus = io->channel; 2897 pScsiReq->ChainOffset = 0; 2898 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST; 2899 } 2900 2901 pScsiReq->CDBLength = cmdLen; 2902 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE; 2903 2904 pScsiReq->Reserved = 0; 2905 2906 pScsiReq->MsgFlags = mpt_msg_flags(ioc); 2907 /* MsgContext set in mpt_get_msg_fram call */ 2908 2909 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN); 2910 2911 if (io->flags & MPT_ICFLAG_TAGGED_CMD) 2912 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ); 2913 else 2914 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED); 2915 2916 if (cmd == REQUEST_SENSE) { 2917 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED); 2918 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2919 "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd)); 2920 } 2921 2922 for (ii = 0; ii < 16; ii++) 2923 pScsiReq->CDB[ii] = CDB[ii]; 2924 2925 pScsiReq->DataLength = cpu_to_le32(io->size); 2926 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma 2927 + (my_idx * MPT_SENSE_BUFFER_ALLOC)); 2928 2929 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2930 "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%d\n", 2931 ioc->name, __func__, cmd, io->channel, io->id, io->lun)); 2932 2933 if (dir == MPI_SCSIIO_CONTROL_READ) 2934 ioc->add_sge((char *) &pScsiReq->SGL, 2935 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma); 2936 else 2937 ioc->add_sge((char *) &pScsiReq->SGL, 2938 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma); 2939 2940 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status) 2941 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf); 2942 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 2943 timeout*HZ); 2944 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 2945 ret = MPT_SCANDV_DID_RESET; 2946 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT 2947 "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__, 2948 cmd)); 2949 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) { 2950 mpt_free_msg_frame(ioc, mf); 2951 goto out; 2952 } 2953 if (!timeleft) { 2954 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n", 2955 ioc->name, __func__); 2956 mpt_HardResetHandler(ioc, CAN_SLEEP); 2957 mpt_free_msg_frame(ioc, mf); 2958 } 2959 goto out; 2960 } 2961 2962 ret = ioc->internal_cmds.completion_code; 2963 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n", 2964 ioc->name, __func__, ret)); 2965 2966 out: 2967 CLEAR_MGMT_STATUS(ioc->internal_cmds.status) 2968 mutex_unlock(&ioc->internal_cmds.mutex); 2969 return ret; 2970 } 2971 2972 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2973 /** 2974 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks. 2975 * @hd: Pointer to a SCSI HOST structure 2976 * @vdevice: virtual target device 2977 * 2978 * Uses the ISR, but with special processing. 2979 * MUST be single-threaded. 2980 * 2981 */ 2982 static void 2983 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice) 2984 { 2985 INTERNAL_CMD iocmd; 2986 2987 /* Ignore hidden raid components, this is handled when the command 2988 * is sent to the volume 2989 */ 2990 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) 2991 return; 2992 2993 if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted || 2994 !vdevice->configured_lun) 2995 return; 2996 2997 /* Following parameters will not change 2998 * in this routine. 2999 */ 3000 iocmd.cmd = SYNCHRONIZE_CACHE; 3001 iocmd.flags = 0; 3002 iocmd.physDiskNum = -1; 3003 iocmd.data = NULL; 3004 iocmd.data_dma = -1; 3005 iocmd.size = 0; 3006 iocmd.rsvd = iocmd.rsvd2 = 0; 3007 iocmd.channel = vdevice->vtarget->channel; 3008 iocmd.id = vdevice->vtarget->id; 3009 iocmd.lun = vdevice->lun; 3010 3011 mptscsih_do_cmd(hd, &iocmd); 3012 } 3013 3014 static ssize_t 3015 mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr, 3016 char *buf) 3017 { 3018 struct Scsi_Host *host = class_to_shost(dev); 3019 MPT_SCSI_HOST *hd = shost_priv(host); 3020 MPT_ADAPTER *ioc = hd->ioc; 3021 3022 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 3023 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24, 3024 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16, 3025 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8, 3026 ioc->facts.FWVersion.Word & 0x000000FF); 3027 } 3028 static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL); 3029 3030 static ssize_t 3031 mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr, 3032 char *buf) 3033 { 3034 struct Scsi_Host *host = class_to_shost(dev); 3035 MPT_SCSI_HOST *hd = shost_priv(host); 3036 MPT_ADAPTER *ioc = hd->ioc; 3037 3038 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n", 3039 (ioc->biosVersion & 0xFF000000) >> 24, 3040 (ioc->biosVersion & 0x00FF0000) >> 16, 3041 (ioc->biosVersion & 0x0000FF00) >> 8, 3042 ioc->biosVersion & 0x000000FF); 3043 } 3044 static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL); 3045 3046 static ssize_t 3047 mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr, 3048 char *buf) 3049 { 3050 struct Scsi_Host *host = class_to_shost(dev); 3051 MPT_SCSI_HOST *hd = shost_priv(host); 3052 MPT_ADAPTER *ioc = hd->ioc; 3053 3054 return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion); 3055 } 3056 static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL); 3057 3058 static ssize_t 3059 mptscsih_version_product_show(struct device *dev, 3060 struct device_attribute *attr, 3061 char *buf) 3062 { 3063 struct Scsi_Host *host = class_to_shost(dev); 3064 MPT_SCSI_HOST *hd = shost_priv(host); 3065 MPT_ADAPTER *ioc = hd->ioc; 3066 3067 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name); 3068 } 3069 static DEVICE_ATTR(version_product, S_IRUGO, 3070 mptscsih_version_product_show, NULL); 3071 3072 static ssize_t 3073 mptscsih_version_nvdata_persistent_show(struct device *dev, 3074 struct device_attribute *attr, 3075 char *buf) 3076 { 3077 struct Scsi_Host *host = class_to_shost(dev); 3078 MPT_SCSI_HOST *hd = shost_priv(host); 3079 MPT_ADAPTER *ioc = hd->ioc; 3080 3081 return snprintf(buf, PAGE_SIZE, "%02xh\n", 3082 ioc->nvdata_version_persistent); 3083 } 3084 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO, 3085 mptscsih_version_nvdata_persistent_show, NULL); 3086 3087 static ssize_t 3088 mptscsih_version_nvdata_default_show(struct device *dev, 3089 struct device_attribute *attr, char *buf) 3090 { 3091 struct Scsi_Host *host = class_to_shost(dev); 3092 MPT_SCSI_HOST *hd = shost_priv(host); 3093 MPT_ADAPTER *ioc = hd->ioc; 3094 3095 return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default); 3096 } 3097 static DEVICE_ATTR(version_nvdata_default, S_IRUGO, 3098 mptscsih_version_nvdata_default_show, NULL); 3099 3100 static ssize_t 3101 mptscsih_board_name_show(struct device *dev, struct device_attribute *attr, 3102 char *buf) 3103 { 3104 struct Scsi_Host *host = class_to_shost(dev); 3105 MPT_SCSI_HOST *hd = shost_priv(host); 3106 MPT_ADAPTER *ioc = hd->ioc; 3107 3108 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name); 3109 } 3110 static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL); 3111 3112 static ssize_t 3113 mptscsih_board_assembly_show(struct device *dev, 3114 struct device_attribute *attr, char *buf) 3115 { 3116 struct Scsi_Host *host = class_to_shost(dev); 3117 MPT_SCSI_HOST *hd = shost_priv(host); 3118 MPT_ADAPTER *ioc = hd->ioc; 3119 3120 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly); 3121 } 3122 static DEVICE_ATTR(board_assembly, S_IRUGO, 3123 mptscsih_board_assembly_show, NULL); 3124 3125 static ssize_t 3126 mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr, 3127 char *buf) 3128 { 3129 struct Scsi_Host *host = class_to_shost(dev); 3130 MPT_SCSI_HOST *hd = shost_priv(host); 3131 MPT_ADAPTER *ioc = hd->ioc; 3132 3133 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer); 3134 } 3135 static DEVICE_ATTR(board_tracer, S_IRUGO, 3136 mptscsih_board_tracer_show, NULL); 3137 3138 static ssize_t 3139 mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr, 3140 char *buf) 3141 { 3142 struct Scsi_Host *host = class_to_shost(dev); 3143 MPT_SCSI_HOST *hd = shost_priv(host); 3144 MPT_ADAPTER *ioc = hd->ioc; 3145 3146 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay); 3147 } 3148 static DEVICE_ATTR(io_delay, S_IRUGO, 3149 mptscsih_io_delay_show, NULL); 3150 3151 static ssize_t 3152 mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr, 3153 char *buf) 3154 { 3155 struct Scsi_Host *host = class_to_shost(dev); 3156 MPT_SCSI_HOST *hd = shost_priv(host); 3157 MPT_ADAPTER *ioc = hd->ioc; 3158 3159 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay); 3160 } 3161 static DEVICE_ATTR(device_delay, S_IRUGO, 3162 mptscsih_device_delay_show, NULL); 3163 3164 static ssize_t 3165 mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr, 3166 char *buf) 3167 { 3168 struct Scsi_Host *host = class_to_shost(dev); 3169 MPT_SCSI_HOST *hd = shost_priv(host); 3170 MPT_ADAPTER *ioc = hd->ioc; 3171 3172 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level); 3173 } 3174 static ssize_t 3175 mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr, 3176 const char *buf, size_t count) 3177 { 3178 struct Scsi_Host *host = class_to_shost(dev); 3179 MPT_SCSI_HOST *hd = shost_priv(host); 3180 MPT_ADAPTER *ioc = hd->ioc; 3181 int val = 0; 3182 3183 if (sscanf(buf, "%x", &val) != 1) 3184 return -EINVAL; 3185 3186 ioc->debug_level = val; 3187 printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n", 3188 ioc->name, ioc->debug_level); 3189 return strlen(buf); 3190 } 3191 static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR, 3192 mptscsih_debug_level_show, mptscsih_debug_level_store); 3193 3194 struct device_attribute *mptscsih_host_attrs[] = { 3195 &dev_attr_version_fw, 3196 &dev_attr_version_bios, 3197 &dev_attr_version_mpi, 3198 &dev_attr_version_product, 3199 &dev_attr_version_nvdata_persistent, 3200 &dev_attr_version_nvdata_default, 3201 &dev_attr_board_name, 3202 &dev_attr_board_assembly, 3203 &dev_attr_board_tracer, 3204 &dev_attr_io_delay, 3205 &dev_attr_device_delay, 3206 &dev_attr_debug_level, 3207 NULL, 3208 }; 3209 3210 EXPORT_SYMBOL(mptscsih_host_attrs); 3211 3212 EXPORT_SYMBOL(mptscsih_remove); 3213 EXPORT_SYMBOL(mptscsih_shutdown); 3214 #ifdef CONFIG_PM 3215 EXPORT_SYMBOL(mptscsih_suspend); 3216 EXPORT_SYMBOL(mptscsih_resume); 3217 #endif 3218 EXPORT_SYMBOL(mptscsih_proc_info); 3219 EXPORT_SYMBOL(mptscsih_info); 3220 EXPORT_SYMBOL(mptscsih_qcmd); 3221 EXPORT_SYMBOL(mptscsih_slave_destroy); 3222 EXPORT_SYMBOL(mptscsih_slave_configure); 3223 EXPORT_SYMBOL(mptscsih_abort); 3224 EXPORT_SYMBOL(mptscsih_dev_reset); 3225 EXPORT_SYMBOL(mptscsih_bus_reset); 3226 EXPORT_SYMBOL(mptscsih_host_reset); 3227 EXPORT_SYMBOL(mptscsih_bios_param); 3228 EXPORT_SYMBOL(mptscsih_io_done); 3229 EXPORT_SYMBOL(mptscsih_taskmgmt_complete); 3230 EXPORT_SYMBOL(mptscsih_scandv_complete); 3231 EXPORT_SYMBOL(mptscsih_event_process); 3232 EXPORT_SYMBOL(mptscsih_ioc_reset); 3233 EXPORT_SYMBOL(mptscsih_change_queue_depth); 3234 3235 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3236