1 /* 2 * linux/drivers/message/fusion/mptscsih.c 3 * For use with LSI Logic PCI chip/adapter(s) 4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware. 5 * 6 * Copyright (c) 1999-2005 LSI Logic Corporation 7 * (mailto:mpt_linux_developer@lsil.com) 8 * 9 */ 10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 11 /* 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; version 2 of the License. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 NO WARRANTY 22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 26 solely responsible for determining the appropriateness of using and 27 distributing the Program and assumes all risks associated with its 28 exercise of rights under this Agreement, including but not limited to 29 the risks and costs of program errors, damage to or loss of data, 30 programs or equipment, and unavailability or interruption of operations. 31 32 DISCLAIMER OF LIABILITY 33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 40 41 You should have received a copy of the GNU General Public License 42 along with this program; if not, write to the Free Software 43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 44 */ 45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 46 47 #include "linux_compat.h" /* linux-2.6 tweaks */ 48 #include <linux/module.h> 49 #include <linux/kernel.h> 50 #include <linux/init.h> 51 #include <linux/errno.h> 52 #include <linux/kdev_t.h> 53 #include <linux/blkdev.h> 54 #include <linux/delay.h> /* for mdelay */ 55 #include <linux/interrupt.h> /* needed for in_interrupt() proto */ 56 #include <linux/reboot.h> /* notifier code */ 57 #include <linux/sched.h> 58 #include <linux/workqueue.h> 59 60 #include <scsi/scsi.h> 61 #include <scsi/scsi_cmnd.h> 62 #include <scsi/scsi_device.h> 63 #include <scsi/scsi_host.h> 64 #include <scsi/scsi_tcq.h> 65 66 #include "mptbase.h" 67 #include "mptscsih.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 78 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 79 80 typedef struct _BIG_SENSE_BUF { 81 u8 data[MPT_SENSE_BUFFER_ALLOC]; 82 } BIG_SENSE_BUF; 83 84 #define MPT_SCANDV_GOOD (0x00000000) /* must be 0 */ 85 #define MPT_SCANDV_DID_RESET (0x00000001) 86 #define MPT_SCANDV_SENSE (0x00000002) 87 #define MPT_SCANDV_SOME_ERROR (0x00000004) 88 #define MPT_SCANDV_SELECTION_TIMEOUT (0x00000008) 89 #define MPT_SCANDV_ISSUE_SENSE (0x00000010) 90 #define MPT_SCANDV_FALLBACK (0x00000020) 91 92 #define MPT_SCANDV_MAX_RETRIES (10) 93 94 #define MPT_ICFLAG_BUF_CAP 0x01 /* ReadBuffer Read Capacity format */ 95 #define MPT_ICFLAG_ECHO 0x02 /* ReadBuffer Echo buffer format */ 96 #define MPT_ICFLAG_PHYS_DISK 0x04 /* Any SCSI IO but do Phys Disk Format */ 97 #define MPT_ICFLAG_TAGGED_CMD 0x08 /* Do tagged IO */ 98 #define MPT_ICFLAG_DID_RESET 0x20 /* Bus Reset occurred with this command */ 99 #define MPT_ICFLAG_RESERVED 0x40 /* Reserved has been issued */ 100 101 typedef struct _internal_cmd { 102 char *data; /* data pointer */ 103 dma_addr_t data_dma; /* data dma address */ 104 int size; /* transfer size */ 105 u8 cmd; /* SCSI Op Code */ 106 u8 bus; /* bus number */ 107 u8 id; /* SCSI ID (virtual) */ 108 u8 lun; 109 u8 flags; /* Bit Field - See above */ 110 u8 physDiskNum; /* Phys disk number, -1 else */ 111 u8 rsvd2; 112 u8 rsvd; 113 } INTERNAL_CMD; 114 115 typedef struct _negoparms { 116 u8 width; 117 u8 offset; 118 u8 factor; 119 u8 flags; 120 } NEGOPARMS; 121 122 typedef struct _dv_parameters { 123 NEGOPARMS max; 124 NEGOPARMS now; 125 u8 cmd; 126 u8 id; 127 u16 pad1; 128 } DVPARAMETERS; 129 130 /* 131 * Other private/forward protos... 132 */ 133 int mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r); 134 static void mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq); 135 int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r); 136 137 static int mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt, 138 SCSIIORequest_t *pReq, int req_idx); 139 static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx); 140 static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply); 141 static int mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd); 142 static int mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout ); 143 static u32 SCPNT_TO_LOOKUP_IDX(struct scsi_cmnd *sc); 144 145 static int mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout); 146 static int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout); 147 148 int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset); 149 int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply); 150 151 static void mptscsih_initTarget(MPT_SCSI_HOST *hd, int bus_id, int target_id, u8 lun, char *data, int dlen); 152 static void mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtDevice *target, char byte56); 153 static void mptscsih_set_dvflags(MPT_SCSI_HOST *hd, SCSIIORequest_t *pReq); 154 static void mptscsih_setDevicePage1Flags (u8 width, u8 factor, u8 offset, int *requestedPtr, int *configurationPtr, u8 flags); 155 static void mptscsih_no_negotiate(MPT_SCSI_HOST *hd, int target_id); 156 static int mptscsih_writeSDP1(MPT_SCSI_HOST *hd, int portnum, int target, int flags); 157 static int mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus); 158 int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r); 159 static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd); 160 static int mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, int portnum); 161 162 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 163 static int mptscsih_do_raid(MPT_SCSI_HOST *hd, u8 action, INTERNAL_CMD *io); 164 static void mptscsih_domainValidation(void *hd); 165 static int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id); 166 static void mptscsih_qas_check(MPT_SCSI_HOST *hd, int id); 167 static int mptscsih_doDv(MPT_SCSI_HOST *hd, int channel, int target); 168 static void mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage); 169 static void mptscsih_fillbuf(char *buffer, int size, int index, int width); 170 #endif 171 172 void mptscsih_remove(struct pci_dev *); 173 void mptscsih_shutdown(struct pci_dev *); 174 #ifdef CONFIG_PM 175 int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state); 176 int mptscsih_resume(struct pci_dev *pdev); 177 #endif 178 179 #define SNS_LEN(scp) sizeof((scp)->sense_buffer) 180 181 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 182 /* 183 * Domain Validation task structure 184 */ 185 static DEFINE_SPINLOCK(dvtaskQ_lock); 186 static int dvtaskQ_active = 0; 187 static int dvtaskQ_release = 0; 188 static struct work_struct dvTaskQ_task; 189 #endif 190 191 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 192 /** 193 * mptscsih_add_sge - Place a simple SGE at address pAddr. 194 * @pAddr: virtual address for SGE 195 * @flagslength: SGE flags and data transfer length 196 * @dma_addr: Physical address 197 * 198 * This routine places a MPT request frame back on the MPT adapter's 199 * FreeQ. 200 */ 201 static inline void 202 mptscsih_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr) 203 { 204 if (sizeof(dma_addr_t) == sizeof(u64)) { 205 SGESimple64_t *pSge = (SGESimple64_t *) pAddr; 206 u32 tmp = dma_addr & 0xFFFFFFFF; 207 208 pSge->FlagsLength = cpu_to_le32(flagslength); 209 pSge->Address.Low = cpu_to_le32(tmp); 210 tmp = (u32) ((u64)dma_addr >> 32); 211 pSge->Address.High = cpu_to_le32(tmp); 212 213 } else { 214 SGESimple32_t *pSge = (SGESimple32_t *) pAddr; 215 pSge->FlagsLength = cpu_to_le32(flagslength); 216 pSge->Address = cpu_to_le32(dma_addr); 217 } 218 } /* mptscsih_add_sge() */ 219 220 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 221 /** 222 * mptscsih_add_chain - Place a chain SGE at address pAddr. 223 * @pAddr: virtual address for SGE 224 * @next: nextChainOffset value (u32's) 225 * @length: length of next SGL segment 226 * @dma_addr: Physical address 227 * 228 * This routine places a MPT request frame back on the MPT adapter's 229 * FreeQ. 230 */ 231 static inline void 232 mptscsih_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr) 233 { 234 if (sizeof(dma_addr_t) == sizeof(u64)) { 235 SGEChain64_t *pChain = (SGEChain64_t *) pAddr; 236 u32 tmp = dma_addr & 0xFFFFFFFF; 237 238 pChain->Length = cpu_to_le16(length); 239 pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size(); 240 241 pChain->NextChainOffset = next; 242 243 pChain->Address.Low = cpu_to_le32(tmp); 244 tmp = (u32) ((u64)dma_addr >> 32); 245 pChain->Address.High = cpu_to_le32(tmp); 246 } else { 247 SGEChain32_t *pChain = (SGEChain32_t *) pAddr; 248 pChain->Length = cpu_to_le16(length); 249 pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size(); 250 pChain->NextChainOffset = next; 251 pChain->Address = cpu_to_le32(dma_addr); 252 } 253 } /* mptscsih_add_chain() */ 254 255 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 256 /* 257 * mptscsih_getFreeChainBuffer - Function to get a free chain 258 * from the MPT_SCSI_HOST FreeChainQ. 259 * @ioc: Pointer to MPT_ADAPTER structure 260 * @req_idx: Index of the SCSI IO request frame. (output) 261 * 262 * return SUCCESS or FAILED 263 */ 264 static inline int 265 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex) 266 { 267 MPT_FRAME_HDR *chainBuf; 268 unsigned long flags; 269 int rc; 270 int chain_idx; 271 272 dsgprintk((MYIOC_s_INFO_FMT "getFreeChainBuffer called\n", 273 ioc->name)); 274 spin_lock_irqsave(&ioc->FreeQlock, flags); 275 if (!list_empty(&ioc->FreeChainQ)) { 276 int offset; 277 278 chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR, 279 u.frame.linkage.list); 280 list_del(&chainBuf->u.frame.linkage.list); 281 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer; 282 chain_idx = offset / ioc->req_sz; 283 rc = SUCCESS; 284 dsgprintk((MYIOC_s_INFO_FMT "getFreeChainBuffer (index %d), got buf=%p\n", 285 ioc->name, *retIndex, chainBuf)); 286 } else { 287 rc = FAILED; 288 chain_idx = MPT_HOST_NO_CHAIN; 289 dfailprintk((MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n", 290 ioc->name)); 291 } 292 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 293 294 *retIndex = chain_idx; 295 return rc; 296 } /* mptscsih_getFreeChainBuffer() */ 297 298 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 299 /* 300 * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the 301 * SCSIIORequest_t Message Frame. 302 * @ioc: Pointer to MPT_ADAPTER structure 303 * @SCpnt: Pointer to scsi_cmnd structure 304 * @pReq: Pointer to SCSIIORequest_t structure 305 * 306 * Returns ... 307 */ 308 static int 309 mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt, 310 SCSIIORequest_t *pReq, int req_idx) 311 { 312 char *psge; 313 char *chainSge; 314 struct scatterlist *sg; 315 int frm_sz; 316 int sges_left, sg_done; 317 int chain_idx = MPT_HOST_NO_CHAIN; 318 int sgeOffset; 319 int numSgeSlots, numSgeThisFrame; 320 u32 sgflags, sgdir, thisxfer = 0; 321 int chain_dma_off = 0; 322 int newIndex; 323 int ii; 324 dma_addr_t v2; 325 u32 RequestNB; 326 327 sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK; 328 if (sgdir == MPI_SCSIIO_CONTROL_WRITE) { 329 sgdir = MPT_TRANSFER_HOST_TO_IOC; 330 } else { 331 sgdir = MPT_TRANSFER_IOC_TO_HOST; 332 } 333 334 psge = (char *) &pReq->SGL; 335 frm_sz = ioc->req_sz; 336 337 /* Map the data portion, if any. 338 * sges_left = 0 if no data transfer. 339 */ 340 if ( (sges_left = SCpnt->use_sg) ) { 341 sges_left = pci_map_sg(ioc->pcidev, 342 (struct scatterlist *) SCpnt->request_buffer, 343 SCpnt->use_sg, 344 SCpnt->sc_data_direction); 345 if (sges_left == 0) 346 return FAILED; 347 } else if (SCpnt->request_bufflen) { 348 SCpnt->SCp.dma_handle = pci_map_single(ioc->pcidev, 349 SCpnt->request_buffer, 350 SCpnt->request_bufflen, 351 SCpnt->sc_data_direction); 352 dsgprintk((MYIOC_s_INFO_FMT "SG: non-SG for %p, len=%d\n", 353 ioc->name, SCpnt, SCpnt->request_bufflen)); 354 mptscsih_add_sge((char *) &pReq->SGL, 355 0xD1000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|SCpnt->request_bufflen, 356 SCpnt->SCp.dma_handle); 357 358 return SUCCESS; 359 } 360 361 /* Handle the SG case. 362 */ 363 sg = (struct scatterlist *) SCpnt->request_buffer; 364 sg_done = 0; 365 sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION); 366 chainSge = NULL; 367 368 /* Prior to entering this loop - the following must be set 369 * current MF: sgeOffset (bytes) 370 * chainSge (Null if original MF is not a chain buffer) 371 * sg_done (num SGE done for this MF) 372 */ 373 374 nextSGEset: 375 numSgeSlots = ((frm_sz - sgeOffset) / (sizeof(u32) + sizeof(dma_addr_t)) ); 376 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots; 377 378 sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | MPT_SGE_FLAGS_ADDRESSING | sgdir; 379 380 /* Get first (num - 1) SG elements 381 * Skip any SG entries with a length of 0 382 * NOTE: at finish, sg and psge pointed to NEXT data/location positions 383 */ 384 for (ii=0; ii < (numSgeThisFrame-1); ii++) { 385 thisxfer = sg_dma_len(sg); 386 if (thisxfer == 0) { 387 sg ++; /* Get next SG element from the OS */ 388 sg_done++; 389 continue; 390 } 391 392 v2 = sg_dma_address(sg); 393 mptscsih_add_sge(psge, sgflags | thisxfer, v2); 394 395 sg++; /* Get next SG element from the OS */ 396 psge += (sizeof(u32) + sizeof(dma_addr_t)); 397 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t)); 398 sg_done++; 399 } 400 401 if (numSgeThisFrame == sges_left) { 402 /* Add last element, end of buffer and end of list flags. 403 */ 404 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT | 405 MPT_SGE_FLAGS_END_OF_BUFFER | 406 MPT_SGE_FLAGS_END_OF_LIST; 407 408 /* Add last SGE and set termination flags. 409 * Note: Last SGE may have a length of 0 - which should be ok. 410 */ 411 thisxfer = sg_dma_len(sg); 412 413 v2 = sg_dma_address(sg); 414 mptscsih_add_sge(psge, sgflags | thisxfer, v2); 415 /* 416 sg++; 417 psge += (sizeof(u32) + sizeof(dma_addr_t)); 418 */ 419 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t)); 420 sg_done++; 421 422 if (chainSge) { 423 /* The current buffer is a chain buffer, 424 * but there is not another one. 425 * Update the chain element 426 * Offset and Length fields. 427 */ 428 mptscsih_add_chain((char *)chainSge, 0, sgeOffset, ioc->ChainBufferDMA + chain_dma_off); 429 } else { 430 /* The current buffer is the original MF 431 * and there is no Chain buffer. 432 */ 433 pReq->ChainOffset = 0; 434 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03; 435 dsgprintk((MYIOC_s_ERR_FMT 436 "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset)); 437 ioc->RequestNB[req_idx] = RequestNB; 438 } 439 } else { 440 /* At least one chain buffer is needed. 441 * Complete the first MF 442 * - last SGE element, set the LastElement bit 443 * - set ChainOffset (words) for orig MF 444 * (OR finish previous MF chain buffer) 445 * - update MFStructPtr ChainIndex 446 * - Populate chain element 447 * Also 448 * Loop until done. 449 */ 450 451 dsgprintk((MYIOC_s_INFO_FMT "SG: Chain Required! sg done %d\n", 452 ioc->name, sg_done)); 453 454 /* Set LAST_ELEMENT flag for last non-chain element 455 * in the buffer. Since psge points at the NEXT 456 * SGE element, go back one SGE element, update the flags 457 * and reset the pointer. (Note: sgflags & thisxfer are already 458 * set properly). 459 */ 460 if (sg_done) { 461 u32 *ptmp = (u32 *) (psge - (sizeof(u32) + sizeof(dma_addr_t))); 462 sgflags = le32_to_cpu(*ptmp); 463 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT; 464 *ptmp = cpu_to_le32(sgflags); 465 } 466 467 if (chainSge) { 468 /* The current buffer is a chain buffer. 469 * chainSge points to the previous Chain Element. 470 * Update its chain element Offset and Length (must 471 * include chain element size) fields. 472 * Old chain element is now complete. 473 */ 474 u8 nextChain = (u8) (sgeOffset >> 2); 475 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t)); 476 mptscsih_add_chain((char *)chainSge, nextChain, sgeOffset, ioc->ChainBufferDMA + chain_dma_off); 477 } else { 478 /* The original MF buffer requires a chain buffer - 479 * set the offset. 480 * Last element in this MF is a chain element. 481 */ 482 pReq->ChainOffset = (u8) (sgeOffset >> 2); 483 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03; 484 dsgprintk((MYIOC_s_ERR_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset)); 485 ioc->RequestNB[req_idx] = RequestNB; 486 } 487 488 sges_left -= sg_done; 489 490 491 /* NOTE: psge points to the beginning of the chain element 492 * in current buffer. Get a chain buffer. 493 */ 494 dsgprintk((MYIOC_s_INFO_FMT 495 "calling getFreeChainBuffer SCSI cmd=%02x (%p)\n", 496 ioc->name, pReq->CDB[0], SCpnt)); 497 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) 498 return FAILED; 499 500 /* Update the tracking arrays. 501 * If chainSge == NULL, update ReqToChain, else ChainToChain 502 */ 503 if (chainSge) { 504 ioc->ChainToChain[chain_idx] = newIndex; 505 } else { 506 ioc->ReqToChain[req_idx] = newIndex; 507 } 508 chain_idx = newIndex; 509 chain_dma_off = ioc->req_sz * chain_idx; 510 511 /* Populate the chainSGE for the current buffer. 512 * - Set chain buffer pointer to psge and fill 513 * out the Address and Flags fields. 514 */ 515 chainSge = (char *) psge; 516 dsgprintk((KERN_INFO " Current buff @ %p (index 0x%x)", 517 psge, req_idx)); 518 519 /* Start the SGE for the next buffer 520 */ 521 psge = (char *) (ioc->ChainBuffer + chain_dma_off); 522 sgeOffset = 0; 523 sg_done = 0; 524 525 dsgprintk((KERN_INFO " Chain buff @ %p (index 0x%x)\n", 526 psge, chain_idx)); 527 528 /* Start the SGE for the next buffer 529 */ 530 531 goto nextSGEset; 532 } 533 534 return SUCCESS; 535 } /* mptscsih_AddSGE() */ 536 537 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 538 /* 539 * mptscsih_io_done - Main SCSI IO callback routine registered to 540 * Fusion MPT (base) driver 541 * @ioc: Pointer to MPT_ADAPTER structure 542 * @mf: Pointer to original MPT request frame 543 * @r: Pointer to MPT reply frame (NULL if TurboReply) 544 * 545 * This routine is called from mpt.c::mpt_interrupt() at the completion 546 * of any SCSI IO request. 547 * This routine is registered with the Fusion MPT (base) driver at driver 548 * load/init time via the mpt_register() API call. 549 * 550 * Returns 1 indicating alloc'd request frame ptr should be freed. 551 */ 552 int 553 mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) 554 { 555 struct scsi_cmnd *sc; 556 MPT_SCSI_HOST *hd; 557 SCSIIORequest_t *pScsiReq; 558 SCSIIOReply_t *pScsiReply; 559 u16 req_idx; 560 561 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata; 562 563 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 564 sc = hd->ScsiLookup[req_idx]; 565 if (sc == NULL) { 566 MPIHeader_t *hdr = (MPIHeader_t *)mf; 567 568 /* Remark: writeSDP1 will use the ScsiDoneCtx 569 * If a SCSI I/O cmd, device disabled by OS and 570 * completion done. Cannot touch sc struct. Just free mem. 571 */ 572 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST) 573 printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n", 574 ioc->name); 575 576 mptscsih_freeChainBuffers(ioc, req_idx); 577 return 1; 578 } 579 580 dmfprintk((MYIOC_s_INFO_FMT 581 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n", 582 ioc->name, mf, mr, sc, req_idx)); 583 584 sc->result = DID_OK << 16; /* Set default reply as OK */ 585 pScsiReq = (SCSIIORequest_t *) mf; 586 pScsiReply = (SCSIIOReply_t *) mr; 587 588 if (pScsiReply == NULL) { 589 /* special context reply handling */ 590 ; 591 } else { 592 u32 xfer_cnt; 593 u16 status; 594 u8 scsi_state, scsi_status; 595 596 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK; 597 scsi_state = pScsiReply->SCSIState; 598 scsi_status = pScsiReply->SCSIStatus; 599 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount); 600 sc->resid = sc->request_bufflen - xfer_cnt; 601 602 dreplyprintk((KERN_NOTICE "Reply ha=%d id=%d lun=%d:\n" 603 "IOCStatus=%04xh SCSIState=%02xh SCSIStatus=%02xh\n" 604 "resid=%d bufflen=%d xfer_cnt=%d\n", 605 ioc->id, pScsiReq->TargetID, pScsiReq->LUN[1], 606 status, scsi_state, scsi_status, sc->resid, 607 sc->request_bufflen, xfer_cnt)); 608 609 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) 610 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply); 611 612 /* 613 * Look for + dump FCP ResponseInfo[]! 614 */ 615 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID) { 616 printk(KERN_NOTICE " FCP_ResponseInfo=%08xh\n", 617 le32_to_cpu(pScsiReply->ResponseInfo)); 618 } 619 620 switch(status) { 621 case MPI_IOCSTATUS_BUSY: /* 0x0002 */ 622 /* CHECKME! 623 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry) 624 * But not: DID_BUS_BUSY lest one risk 625 * killing interrupt handler:-( 626 */ 627 sc->result = SAM_STAT_BUSY; 628 break; 629 630 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */ 631 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */ 632 sc->result = DID_BAD_TARGET << 16; 633 break; 634 635 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */ 636 /* Spoof to SCSI Selection Timeout! */ 637 sc->result = DID_NO_CONNECT << 16; 638 639 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF) 640 hd->sel_timeout[pScsiReq->TargetID]++; 641 break; 642 643 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */ 644 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */ 645 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */ 646 /* Linux handles an unsolicited DID_RESET better 647 * than an unsolicited DID_ABORT. 648 */ 649 sc->result = DID_RESET << 16; 650 651 /* GEM Workaround. */ 652 if (ioc->bus_type == SCSI) 653 mptscsih_no_negotiate(hd, sc->device->id); 654 break; 655 656 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */ 657 if ( xfer_cnt >= sc->underflow ) { 658 /* Sufficient data transfer occurred */ 659 sc->result = (DID_OK << 16) | scsi_status; 660 } else if ( xfer_cnt == 0 ) { 661 /* A CRC Error causes this condition; retry */ 662 sc->result = (DRIVER_SENSE << 24) | (DID_OK << 16) | 663 (CHECK_CONDITION << 1); 664 sc->sense_buffer[0] = 0x70; 665 sc->sense_buffer[2] = NO_SENSE; 666 sc->sense_buffer[12] = 0; 667 sc->sense_buffer[13] = 0; 668 } else { 669 sc->result = DID_SOFT_ERROR << 16; 670 } 671 dreplyprintk((KERN_NOTICE "RESIDUAL_MISMATCH: result=%x on id=%d\n", sc->result, sc->target)); 672 break; 673 674 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */ 675 /* 676 * Do upfront check for valid SenseData and give it 677 * precedence! 678 */ 679 sc->result = (DID_OK << 16) | scsi_status; 680 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) { 681 /* Have already saved the status and sense data 682 */ 683 ; 684 } else { 685 if (xfer_cnt < sc->underflow) { 686 sc->result = DID_SOFT_ERROR << 16; 687 } 688 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) { 689 /* What to do? 690 */ 691 sc->result = DID_SOFT_ERROR << 16; 692 } 693 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) { 694 /* Not real sure here either... */ 695 sc->result = DID_RESET << 16; 696 } 697 } 698 699 dreplyprintk((KERN_NOTICE " sc->underflow={report ERR if < %02xh bytes xfer'd}\n", 700 sc->underflow)); 701 dreplyprintk((KERN_NOTICE " ActBytesXferd=%02xh\n", xfer_cnt)); 702 /* Report Queue Full 703 */ 704 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL) 705 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq); 706 707 break; 708 709 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */ 710 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */ 711 scsi_status = pScsiReply->SCSIStatus; 712 sc->result = (DID_OK << 16) | scsi_status; 713 if (scsi_state == 0) { 714 ; 715 } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) { 716 /* 717 * If running against circa 200003dd 909 MPT f/w, 718 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL 719 * (QUEUE_FULL) returned from device! --> get 0x0000?128 720 * and with SenseBytes set to 0. 721 */ 722 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL) 723 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq); 724 725 } 726 else if (scsi_state & 727 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS) 728 ) { 729 /* 730 * What to do? 731 */ 732 sc->result = DID_SOFT_ERROR << 16; 733 } 734 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) { 735 /* Not real sure here either... */ 736 sc->result = DID_RESET << 16; 737 } 738 else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) { 739 /* Device Inq. data indicates that it supports 740 * QTags, but rejects QTag messages. 741 * This command completed OK. 742 * 743 * Not real sure here either so do nothing... */ 744 } 745 746 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL) 747 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq); 748 749 /* Add handling of: 750 * Reservation Conflict, Busy, 751 * Command Terminated, CHECK 752 */ 753 break; 754 755 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */ 756 sc->result = DID_SOFT_ERROR << 16; 757 break; 758 759 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */ 760 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */ 761 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */ 762 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */ 763 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */ 764 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */ 765 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */ 766 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */ 767 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */ 768 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */ 769 default: 770 /* 771 * What to do? 772 */ 773 sc->result = DID_SOFT_ERROR << 16; 774 break; 775 776 } /* switch(status) */ 777 778 dreplyprintk((KERN_NOTICE " sc->result is %08xh\n", sc->result)); 779 } /* end of address reply case */ 780 781 /* Unmap the DMA buffers, if any. */ 782 if (sc->use_sg) { 783 pci_unmap_sg(ioc->pcidev, (struct scatterlist *) sc->request_buffer, 784 sc->use_sg, sc->sc_data_direction); 785 } else if (sc->request_bufflen) { 786 pci_unmap_single(ioc->pcidev, sc->SCp.dma_handle, 787 sc->request_bufflen, sc->sc_data_direction); 788 } 789 790 hd->ScsiLookup[req_idx] = NULL; 791 792 sc->scsi_done(sc); /* Issue the command callback */ 793 794 /* Free Chain buffers */ 795 mptscsih_freeChainBuffers(ioc, req_idx); 796 return 1; 797 } 798 799 800 /* 801 * mptscsih_flush_running_cmds - For each command found, search 802 * Scsi_Host instance taskQ and reply to OS. 803 * Called only if recovering from a FW reload. 804 * @hd: Pointer to a SCSI HOST structure 805 * 806 * Returns: None. 807 * 808 * Must be called while new I/Os are being queued. 809 */ 810 static void 811 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd) 812 { 813 MPT_ADAPTER *ioc = hd->ioc; 814 struct scsi_cmnd *SCpnt; 815 MPT_FRAME_HDR *mf; 816 int ii; 817 int max = ioc->req_depth; 818 819 dprintk((KERN_INFO MYNAM ": flush_ScsiLookup called\n")); 820 for (ii= 0; ii < max; ii++) { 821 if ((SCpnt = hd->ScsiLookup[ii]) != NULL) { 822 823 /* Command found. 824 */ 825 826 /* Null ScsiLookup index 827 */ 828 hd->ScsiLookup[ii] = NULL; 829 830 mf = MPT_INDEX_2_MFPTR(ioc, ii); 831 dmfprintk(( "flush: ScsiDone (mf=%p,sc=%p)\n", 832 mf, SCpnt)); 833 834 /* Set status, free OS resources (SG DMA buffers) 835 * Do OS callback 836 * Free driver resources (chain, msg buffers) 837 */ 838 if (SCpnt->use_sg) { 839 pci_unmap_sg(ioc->pcidev, 840 (struct scatterlist *) SCpnt->request_buffer, 841 SCpnt->use_sg, 842 SCpnt->sc_data_direction); 843 } else if (SCpnt->request_bufflen) { 844 pci_unmap_single(ioc->pcidev, 845 SCpnt->SCp.dma_handle, 846 SCpnt->request_bufflen, 847 SCpnt->sc_data_direction); 848 } 849 SCpnt->result = DID_RESET << 16; 850 SCpnt->host_scribble = NULL; 851 852 /* Free Chain buffers */ 853 mptscsih_freeChainBuffers(ioc, ii); 854 855 /* Free Message frames */ 856 mpt_free_msg_frame(ioc, mf); 857 858 SCpnt->scsi_done(SCpnt); /* Issue the command callback */ 859 } 860 } 861 862 return; 863 } 864 865 /* 866 * mptscsih_search_running_cmds - Delete any commands associated 867 * with the specified target and lun. Function called only 868 * when a lun is disable by mid-layer. 869 * Do NOT access the referenced scsi_cmnd structure or 870 * members. Will cause either a paging or NULL ptr error. 871 * @hd: Pointer to a SCSI HOST structure 872 * @target: target id 873 * @lun: lun 874 * 875 * Returns: None. 876 * 877 * Called from slave_destroy. 878 */ 879 static void 880 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, uint target, uint lun) 881 { 882 SCSIIORequest_t *mf = NULL; 883 int ii; 884 int max = hd->ioc->req_depth; 885 886 dsprintk((KERN_INFO MYNAM ": search_running target %d lun %d max %d\n", 887 target, lun, max)); 888 889 for (ii=0; ii < max; ii++) { 890 if (hd->ScsiLookup[ii] != NULL) { 891 892 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(hd->ioc, ii); 893 894 dsprintk(( "search_running: found (sc=%p, mf = %p) target %d, lun %d \n", 895 hd->ScsiLookup[ii], mf, mf->TargetID, mf->LUN[1])); 896 897 if ((mf->TargetID != ((u8)target)) || (mf->LUN[1] != ((u8) lun))) 898 continue; 899 900 /* Cleanup 901 */ 902 hd->ScsiLookup[ii] = NULL; 903 mptscsih_freeChainBuffers(hd->ioc, ii); 904 mpt_free_msg_frame(hd->ioc, (MPT_FRAME_HDR *)mf); 905 } 906 } 907 908 return; 909 } 910 911 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 912 913 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 914 /* 915 * mptscsih_report_queue_full - Report QUEUE_FULL status returned 916 * from a SCSI target device. 917 * @sc: Pointer to scsi_cmnd structure 918 * @pScsiReply: Pointer to SCSIIOReply_t 919 * @pScsiReq: Pointer to original SCSI request 920 * 921 * This routine periodically reports QUEUE_FULL status returned from a 922 * SCSI target device. It reports this to the console via kernel 923 * printk() API call, not more than once every 10 seconds. 924 */ 925 static void 926 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq) 927 { 928 long time = jiffies; 929 MPT_SCSI_HOST *hd; 930 931 if (sc->device == NULL) 932 return; 933 if (sc->device->host == NULL) 934 return; 935 if ((hd = (MPT_SCSI_HOST *)sc->device->host->hostdata) == NULL) 936 return; 937 938 if (time - hd->last_queue_full > 10 * HZ) { 939 dprintk((MYIOC_s_WARN_FMT "Device (%d:%d:%d) reported QUEUE_FULL!\n", 940 hd->ioc->name, 0, sc->device->id, sc->device->lun)); 941 hd->last_queue_full = time; 942 } 943 } 944 945 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 946 /* 947 * mptscsih_remove - Removed scsi devices 948 * @pdev: Pointer to pci_dev structure 949 * 950 * 951 */ 952 void 953 mptscsih_remove(struct pci_dev *pdev) 954 { 955 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 956 struct Scsi_Host *host = ioc->sh; 957 MPT_SCSI_HOST *hd; 958 int count; 959 unsigned long flags; 960 int sz1; 961 962 if(!host) 963 return; 964 965 scsi_remove_host(host); 966 967 if((hd = (MPT_SCSI_HOST *)host->hostdata) == NULL) 968 return; 969 970 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 971 /* Check DV thread active */ 972 count = 10 * HZ; 973 spin_lock_irqsave(&dvtaskQ_lock, flags); 974 if (dvtaskQ_active) { 975 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 976 while(dvtaskQ_active && --count) { 977 set_current_state(TASK_INTERRUPTIBLE); 978 schedule_timeout(1); 979 } 980 } else { 981 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 982 } 983 if (!count) 984 printk(KERN_ERR MYNAM ": ERROR - DV thread still active!\n"); 985 #if defined(MPT_DEBUG_DV) || defined(MPT_DEBUG_DV_TINY) 986 else 987 printk(KERN_ERR MYNAM ": DV thread orig %d, count %d\n", 10 * HZ, count); 988 #endif 989 #endif 990 991 mptscsih_shutdown(pdev); 992 993 sz1=0; 994 995 if (hd->ScsiLookup != NULL) { 996 sz1 = hd->ioc->req_depth * sizeof(void *); 997 kfree(hd->ScsiLookup); 998 hd->ScsiLookup = NULL; 999 } 1000 1001 /* 1002 * Free pointer array. 1003 */ 1004 kfree(hd->Targets); 1005 hd->Targets = NULL; 1006 1007 dprintk((MYIOC_s_INFO_FMT 1008 "Free'd ScsiLookup (%d) memory\n", 1009 hd->ioc->name, sz1)); 1010 1011 kfree(hd->info_kbuf); 1012 1013 /* NULL the Scsi_Host pointer 1014 */ 1015 hd->ioc->sh = NULL; 1016 1017 scsi_host_put(host); 1018 1019 mpt_detach(pdev); 1020 1021 } 1022 1023 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1024 /* 1025 * mptscsih_shutdown - reboot notifier 1026 * 1027 */ 1028 void 1029 mptscsih_shutdown(struct pci_dev *pdev) 1030 { 1031 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1032 struct Scsi_Host *host = ioc->sh; 1033 MPT_SCSI_HOST *hd; 1034 1035 if(!host) 1036 return; 1037 1038 hd = (MPT_SCSI_HOST *)host->hostdata; 1039 1040 /* Flush the cache of this adapter 1041 */ 1042 if(hd != NULL) 1043 mptscsih_synchronize_cache(hd, 0); 1044 1045 } 1046 1047 #ifdef CONFIG_PM 1048 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1049 /* 1050 * mptscsih_suspend - Fusion MPT scsi driver suspend routine. 1051 * 1052 * 1053 */ 1054 int 1055 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state) 1056 { 1057 mptscsih_shutdown(pdev); 1058 return mpt_suspend(pdev,state); 1059 } 1060 1061 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1062 /* 1063 * mptscsih_resume - Fusion MPT scsi driver resume routine. 1064 * 1065 * 1066 */ 1067 int 1068 mptscsih_resume(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 1074 mpt_resume(pdev); 1075 1076 if(!host) 1077 return 0; 1078 1079 hd = (MPT_SCSI_HOST *)host->hostdata; 1080 if(!hd) 1081 return 0; 1082 1083 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 1084 { 1085 unsigned long lflags; 1086 spin_lock_irqsave(&dvtaskQ_lock, lflags); 1087 if (!dvtaskQ_active) { 1088 dvtaskQ_active = 1; 1089 spin_unlock_irqrestore(&dvtaskQ_lock, lflags); 1090 INIT_WORK(&dvTaskQ_task, 1091 mptscsih_domainValidation, (void *) hd); 1092 schedule_work(&dvTaskQ_task); 1093 } else { 1094 spin_unlock_irqrestore(&dvtaskQ_lock, lflags); 1095 } 1096 } 1097 #endif 1098 return 0; 1099 } 1100 1101 #endif 1102 1103 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1104 /** 1105 * mptscsih_info - Return information about MPT adapter 1106 * @SChost: Pointer to Scsi_Host structure 1107 * 1108 * (linux scsi_host_template.info routine) 1109 * 1110 * Returns pointer to buffer where information was written. 1111 */ 1112 const char * 1113 mptscsih_info(struct Scsi_Host *SChost) 1114 { 1115 MPT_SCSI_HOST *h; 1116 int size = 0; 1117 1118 h = (MPT_SCSI_HOST *)SChost->hostdata; 1119 1120 if (h) { 1121 if (h->info_kbuf == NULL) 1122 if ((h->info_kbuf = kmalloc(0x1000 /* 4Kb */, GFP_KERNEL)) == NULL) 1123 return h->info_kbuf; 1124 h->info_kbuf[0] = '\0'; 1125 1126 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0); 1127 h->info_kbuf[size-1] = '\0'; 1128 } 1129 1130 return h->info_kbuf; 1131 } 1132 1133 struct info_str { 1134 char *buffer; 1135 int length; 1136 int offset; 1137 int pos; 1138 }; 1139 1140 static void 1141 mptscsih_copy_mem_info(struct info_str *info, char *data, int len) 1142 { 1143 if (info->pos + len > info->length) 1144 len = info->length - info->pos; 1145 1146 if (info->pos + len < info->offset) { 1147 info->pos += len; 1148 return; 1149 } 1150 1151 if (info->pos < info->offset) { 1152 data += (info->offset - info->pos); 1153 len -= (info->offset - info->pos); 1154 } 1155 1156 if (len > 0) { 1157 memcpy(info->buffer + info->pos, data, len); 1158 info->pos += len; 1159 } 1160 } 1161 1162 static int 1163 mptscsih_copy_info(struct info_str *info, char *fmt, ...) 1164 { 1165 va_list args; 1166 char buf[81]; 1167 int len; 1168 1169 va_start(args, fmt); 1170 len = vsprintf(buf, fmt, args); 1171 va_end(args); 1172 1173 mptscsih_copy_mem_info(info, buf, len); 1174 return len; 1175 } 1176 1177 static int 1178 mptscsih_host_info(MPT_ADAPTER *ioc, char *pbuf, off_t offset, int len) 1179 { 1180 struct info_str info; 1181 1182 info.buffer = pbuf; 1183 info.length = len; 1184 info.offset = offset; 1185 info.pos = 0; 1186 1187 mptscsih_copy_info(&info, "%s: %s, ", ioc->name, ioc->prod_name); 1188 mptscsih_copy_info(&info, "%s%08xh, ", MPT_FW_REV_MAGIC_ID_STRING, ioc->facts.FWVersion.Word); 1189 mptscsih_copy_info(&info, "Ports=%d, ", ioc->facts.NumberOfPorts); 1190 mptscsih_copy_info(&info, "MaxQ=%d\n", ioc->req_depth); 1191 1192 return ((info.pos > info.offset) ? info.pos - info.offset : 0); 1193 } 1194 1195 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1196 /** 1197 * mptscsih_proc_info - Return information about MPT adapter 1198 * 1199 * (linux scsi_host_template.info routine) 1200 * 1201 * buffer: if write, user data; if read, buffer for user 1202 * length: if write, return length; 1203 * offset: if write, 0; if read, the current offset into the buffer from 1204 * the previous read. 1205 * hostno: scsi host number 1206 * func: if write = 1; if read = 0 1207 */ 1208 int 1209 mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, 1210 int length, int func) 1211 { 1212 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 1213 MPT_ADAPTER *ioc = hd->ioc; 1214 int size = 0; 1215 1216 if (func) { 1217 /* 1218 * write is not supported 1219 */ 1220 } else { 1221 if (start) 1222 *start = buffer; 1223 1224 size = mptscsih_host_info(ioc, buffer, offset, length); 1225 } 1226 1227 return size; 1228 } 1229 1230 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1231 #define ADD_INDEX_LOG(req_ent) do { } while(0) 1232 1233 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1234 /** 1235 * mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine. 1236 * @SCpnt: Pointer to scsi_cmnd structure 1237 * @done: Pointer SCSI mid-layer IO completion function 1238 * 1239 * (linux scsi_host_template.queuecommand routine) 1240 * This is the primary SCSI IO start routine. Create a MPI SCSIIORequest 1241 * from a linux scsi_cmnd request and send it to the IOC. 1242 * 1243 * Returns 0. (rtn value discarded by linux scsi mid-layer) 1244 */ 1245 int 1246 mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 1247 { 1248 MPT_SCSI_HOST *hd; 1249 MPT_FRAME_HDR *mf; 1250 SCSIIORequest_t *pScsiReq; 1251 VirtDevice *pTarget; 1252 int target; 1253 int lun; 1254 u32 datalen; 1255 u32 scsictl; 1256 u32 scsidir; 1257 u32 cmd_len; 1258 int my_idx; 1259 int ii; 1260 1261 hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata; 1262 target = SCpnt->device->id; 1263 lun = SCpnt->device->lun; 1264 SCpnt->scsi_done = done; 1265 1266 pTarget = hd->Targets[target]; 1267 1268 dmfprintk((MYIOC_s_INFO_FMT "qcmd: SCpnt=%p, done()=%p\n", 1269 (hd && hd->ioc) ? hd->ioc->name : "ioc?", SCpnt, done)); 1270 1271 if (hd->resetPending) { 1272 dtmprintk((MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n", 1273 (hd && hd->ioc) ? hd->ioc->name : "ioc?", SCpnt)); 1274 return SCSI_MLQUEUE_HOST_BUSY; 1275 } 1276 1277 /* 1278 * Put together a MPT SCSI request... 1279 */ 1280 if ((mf = mpt_get_msg_frame(hd->ioc->DoneCtx, hd->ioc)) == NULL) { 1281 dprintk((MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n", 1282 hd->ioc->name)); 1283 return SCSI_MLQUEUE_HOST_BUSY; 1284 } 1285 1286 pScsiReq = (SCSIIORequest_t *) mf; 1287 1288 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 1289 1290 ADD_INDEX_LOG(my_idx); 1291 1292 /* TUR's being issued with scsictl=0x02000000 (DATA_IN)! 1293 * Seems we may receive a buffer (datalen>0) even when there 1294 * will be no data transfer! GRRRRR... 1295 */ 1296 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 1297 datalen = SCpnt->request_bufflen; 1298 scsidir = MPI_SCSIIO_CONTROL_READ; /* DATA IN (host<--ioc<--dev) */ 1299 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) { 1300 datalen = SCpnt->request_bufflen; 1301 scsidir = MPI_SCSIIO_CONTROL_WRITE; /* DATA OUT (host-->ioc-->dev) */ 1302 } else { 1303 datalen = 0; 1304 scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER; 1305 } 1306 1307 /* Default to untagged. Once a target structure has been allocated, 1308 * use the Inquiry data to determine if device supports tagged. 1309 */ 1310 if ( pTarget 1311 && (pTarget->tflags & MPT_TARGET_FLAGS_Q_YES) 1312 && (SCpnt->device->tagged_supported)) { 1313 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ; 1314 } else { 1315 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED; 1316 } 1317 1318 /* Use the above information to set up the message frame 1319 */ 1320 pScsiReq->TargetID = (u8) target; 1321 pScsiReq->Bus = (u8) SCpnt->device->channel; 1322 pScsiReq->ChainOffset = 0; 1323 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST; 1324 pScsiReq->CDBLength = SCpnt->cmd_len; 1325 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE; 1326 pScsiReq->Reserved = 0; 1327 pScsiReq->MsgFlags = mpt_msg_flags(); 1328 pScsiReq->LUN[0] = 0; 1329 pScsiReq->LUN[1] = lun; 1330 pScsiReq->LUN[2] = 0; 1331 pScsiReq->LUN[3] = 0; 1332 pScsiReq->LUN[4] = 0; 1333 pScsiReq->LUN[5] = 0; 1334 pScsiReq->LUN[6] = 0; 1335 pScsiReq->LUN[7] = 0; 1336 pScsiReq->Control = cpu_to_le32(scsictl); 1337 1338 /* 1339 * Write SCSI CDB into the message 1340 */ 1341 cmd_len = SCpnt->cmd_len; 1342 for (ii=0; ii < cmd_len; ii++) 1343 pScsiReq->CDB[ii] = SCpnt->cmnd[ii]; 1344 1345 for (ii=cmd_len; ii < 16; ii++) 1346 pScsiReq->CDB[ii] = 0; 1347 1348 /* DataLength */ 1349 pScsiReq->DataLength = cpu_to_le32(datalen); 1350 1351 /* SenseBuffer low address */ 1352 pScsiReq->SenseBufferLowAddr = cpu_to_le32(hd->ioc->sense_buf_low_dma 1353 + (my_idx * MPT_SENSE_BUFFER_ALLOC)); 1354 1355 /* Now add the SG list 1356 * Always have a SGE even if null length. 1357 */ 1358 if (datalen == 0) { 1359 /* Add a NULL SGE */ 1360 mptscsih_add_sge((char *)&pScsiReq->SGL, MPT_SGE_FLAGS_SSIMPLE_READ | 0, 1361 (dma_addr_t) -1); 1362 } else { 1363 /* Add a 32 or 64 bit SGE */ 1364 if (mptscsih_AddSGE(hd->ioc, SCpnt, pScsiReq, my_idx) != SUCCESS) 1365 goto fail; 1366 } 1367 1368 hd->ScsiLookup[my_idx] = SCpnt; 1369 SCpnt->host_scribble = NULL; 1370 1371 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 1372 if (hd->ioc->bus_type == SCSI) { 1373 int dvStatus = hd->ioc->spi_data.dvStatus[target]; 1374 int issueCmd = 1; 1375 1376 if (dvStatus || hd->ioc->spi_data.forceDv) { 1377 1378 if ((dvStatus & MPT_SCSICFG_NEED_DV) || 1379 (hd->ioc->spi_data.forceDv & MPT_SCSICFG_NEED_DV)) { 1380 unsigned long lflags; 1381 /* Schedule DV if necessary */ 1382 spin_lock_irqsave(&dvtaskQ_lock, lflags); 1383 if (!dvtaskQ_active) { 1384 dvtaskQ_active = 1; 1385 spin_unlock_irqrestore(&dvtaskQ_lock, lflags); 1386 INIT_WORK(&dvTaskQ_task, mptscsih_domainValidation, (void *) hd); 1387 1388 schedule_work(&dvTaskQ_task); 1389 } else { 1390 spin_unlock_irqrestore(&dvtaskQ_lock, lflags); 1391 } 1392 hd->ioc->spi_data.forceDv &= ~MPT_SCSICFG_NEED_DV; 1393 } 1394 1395 /* Trying to do DV to this target, extend timeout. 1396 * Wait to issue until flag is clear 1397 */ 1398 if (dvStatus & MPT_SCSICFG_DV_PENDING) { 1399 mod_timer(&SCpnt->eh_timeout, jiffies + 40 * HZ); 1400 issueCmd = 0; 1401 } 1402 1403 /* Set the DV flags. 1404 */ 1405 if (dvStatus & MPT_SCSICFG_DV_NOT_DONE) 1406 mptscsih_set_dvflags(hd, pScsiReq); 1407 1408 if (!issueCmd) 1409 goto fail; 1410 } 1411 } 1412 #endif 1413 1414 mpt_put_msg_frame(hd->ioc->DoneCtx, hd->ioc, mf); 1415 dmfprintk((MYIOC_s_INFO_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n", 1416 hd->ioc->name, SCpnt, mf, my_idx)); 1417 DBG_DUMP_REQUEST_FRAME(mf) 1418 return 0; 1419 1420 fail: 1421 mptscsih_freeChainBuffers(hd->ioc, my_idx); 1422 mpt_free_msg_frame(hd->ioc, mf); 1423 return SCSI_MLQUEUE_HOST_BUSY; 1424 } 1425 1426 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1427 /* 1428 * mptscsih_freeChainBuffers - Function to free chain buffers associated 1429 * with a SCSI IO request 1430 * @hd: Pointer to the MPT_SCSI_HOST instance 1431 * @req_idx: Index of the SCSI IO request frame. 1432 * 1433 * Called if SG chain buffer allocation fails and mptscsih callbacks. 1434 * No return. 1435 */ 1436 static void 1437 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx) 1438 { 1439 MPT_FRAME_HDR *chain; 1440 unsigned long flags; 1441 int chain_idx; 1442 int next; 1443 1444 /* Get the first chain index and reset 1445 * tracker state. 1446 */ 1447 chain_idx = ioc->ReqToChain[req_idx]; 1448 ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN; 1449 1450 while (chain_idx != MPT_HOST_NO_CHAIN) { 1451 1452 /* Save the next chain buffer index */ 1453 next = ioc->ChainToChain[chain_idx]; 1454 1455 /* Free this chain buffer and reset 1456 * tracker 1457 */ 1458 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN; 1459 1460 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer 1461 + (chain_idx * ioc->req_sz)); 1462 1463 spin_lock_irqsave(&ioc->FreeQlock, flags); 1464 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ); 1465 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 1466 1467 dmfprintk((MYIOC_s_INFO_FMT "FreeChainBuffers (index %d)\n", 1468 ioc->name, chain_idx)); 1469 1470 /* handle next */ 1471 chain_idx = next; 1472 } 1473 return; 1474 } 1475 1476 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1477 /* 1478 * Reset Handling 1479 */ 1480 1481 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1482 /* 1483 * mptscsih_TMHandler - Generic handler for SCSI Task Management. 1484 * Fall through to mpt_HardResetHandler if: not operational, too many 1485 * failed TM requests or handshake failure. 1486 * 1487 * @ioc: Pointer to MPT_ADAPTER structure 1488 * @type: Task Management type 1489 * @target: Logical Target ID for reset (if appropriate) 1490 * @lun: Logical Unit for reset (if appropriate) 1491 * @ctx2abort: Context for the task to be aborted (if appropriate) 1492 * 1493 * Remark: Currently invoked from a non-interrupt thread (_bh). 1494 * 1495 * Remark: With old EH code, at most 1 SCSI TaskMgmt function per IOC 1496 * will be active. 1497 * 1498 * Returns 0 for SUCCESS or -1 if FAILED. 1499 */ 1500 static int 1501 mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout) 1502 { 1503 MPT_ADAPTER *ioc; 1504 int rc = -1; 1505 int doTask = 1; 1506 u32 ioc_raw_state; 1507 unsigned long flags; 1508 1509 /* If FW is being reloaded currently, return success to 1510 * the calling function. 1511 */ 1512 if (hd == NULL) 1513 return 0; 1514 1515 ioc = hd->ioc; 1516 if (ioc == NULL) { 1517 printk(KERN_ERR MYNAM " TMHandler" " NULL ioc!\n"); 1518 return FAILED; 1519 } 1520 dtmprintk((MYIOC_s_INFO_FMT "TMHandler Entered!\n", ioc->name)); 1521 1522 // SJR - CHECKME - Can we avoid this here? 1523 // (mpt_HardResetHandler has this check...) 1524 spin_lock_irqsave(&ioc->diagLock, flags); 1525 if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)) { 1526 spin_unlock_irqrestore(&ioc->diagLock, flags); 1527 return FAILED; 1528 } 1529 spin_unlock_irqrestore(&ioc->diagLock, flags); 1530 1531 /* Wait a fixed amount of time for the TM pending flag to be cleared. 1532 * If we time out and not bus reset, then we return a FAILED status to the caller. 1533 * The call to mptscsih_tm_pending_wait() will set the pending flag if we are 1534 * successful. Otherwise, reload the FW. 1535 */ 1536 if (mptscsih_tm_pending_wait(hd) == FAILED) { 1537 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) { 1538 dtmprintk((KERN_WARNING MYNAM ": %s: TMHandler abort: " 1539 "Timed out waiting for last TM (%d) to complete! \n", 1540 hd->ioc->name, hd->tmPending)); 1541 return FAILED; 1542 } else if (type == MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET) { 1543 dtmprintk((KERN_WARNING MYNAM ": %s: TMHandler target reset: " 1544 "Timed out waiting for last TM (%d) to complete! \n", 1545 hd->ioc->name, hd->tmPending)); 1546 return FAILED; 1547 } else if (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) { 1548 dtmprintk((KERN_WARNING MYNAM ": %s: TMHandler bus reset: " 1549 "Timed out waiting for last TM (%d) to complete! \n", 1550 hd->ioc->name, hd->tmPending)); 1551 if (hd->tmPending & (1 << MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)) 1552 return FAILED; 1553 1554 doTask = 0; 1555 } 1556 } else { 1557 spin_lock_irqsave(&hd->ioc->FreeQlock, flags); 1558 hd->tmPending |= (1 << type); 1559 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags); 1560 } 1561 1562 /* Is operational? 1563 */ 1564 ioc_raw_state = mpt_GetIocState(hd->ioc, 0); 1565 1566 #ifdef MPT_DEBUG_RESET 1567 if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) { 1568 printk(MYIOC_s_WARN_FMT 1569 "TM Handler: IOC Not operational(0x%x)!\n", 1570 hd->ioc->name, ioc_raw_state); 1571 } 1572 #endif 1573 1574 if (doTask && ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) 1575 && !(ioc_raw_state & MPI_DOORBELL_ACTIVE)) { 1576 1577 /* Isse the Task Mgmt request. 1578 */ 1579 if (hd->hard_resets < -1) 1580 hd->hard_resets++; 1581 rc = mptscsih_IssueTaskMgmt(hd, type, channel, target, lun, ctx2abort, timeout); 1582 if (rc) { 1583 printk(MYIOC_s_INFO_FMT "Issue of TaskMgmt failed!\n", hd->ioc->name); 1584 } else { 1585 dtmprintk((MYIOC_s_INFO_FMT "Issue of TaskMgmt Successful!\n", hd->ioc->name)); 1586 } 1587 } 1588 1589 /* Only fall through to the HRH if this is a bus reset 1590 */ 1591 if ((type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) && (rc || 1592 ioc->reload_fw || (ioc->alt_ioc && ioc->alt_ioc->reload_fw))) { 1593 dtmprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n", 1594 hd->ioc->name)); 1595 rc = mpt_HardResetHandler(hd->ioc, CAN_SLEEP); 1596 } 1597 1598 dtmprintk((MYIOC_s_INFO_FMT "TMHandler rc = %d!\n", hd->ioc->name, rc)); 1599 1600 return rc; 1601 } 1602 1603 1604 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1605 /* 1606 * mptscsih_IssueTaskMgmt - Generic send Task Management function. 1607 * @hd: Pointer to MPT_SCSI_HOST structure 1608 * @type: Task Management type 1609 * @target: Logical Target ID for reset (if appropriate) 1610 * @lun: Logical Unit for reset (if appropriate) 1611 * @ctx2abort: Context for the task to be aborted (if appropriate) 1612 * 1613 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer) 1614 * or a non-interrupt thread. In the former, must not call schedule(). 1615 * 1616 * Not all fields are meaningfull for all task types. 1617 * 1618 * Returns 0 for SUCCESS, -999 for "no msg frames", 1619 * else other non-zero value returned. 1620 */ 1621 static int 1622 mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout) 1623 { 1624 MPT_FRAME_HDR *mf; 1625 SCSITaskMgmt_t *pScsiTm; 1626 int ii; 1627 int retval; 1628 1629 /* Return Fail to calling function if no message frames available. 1630 */ 1631 if ((mf = mpt_get_msg_frame(hd->ioc->TaskCtx, hd->ioc)) == NULL) { 1632 dfailprintk((MYIOC_s_ERR_FMT "IssueTaskMgmt, no msg frames!!\n", 1633 hd->ioc->name)); 1634 //return FAILED; 1635 return -999; 1636 } 1637 dtmprintk((MYIOC_s_INFO_FMT "IssueTaskMgmt request @ %p\n", 1638 hd->ioc->name, mf)); 1639 1640 /* Format the Request 1641 */ 1642 pScsiTm = (SCSITaskMgmt_t *) mf; 1643 pScsiTm->TargetID = target; 1644 pScsiTm->Bus = channel; 1645 pScsiTm->ChainOffset = 0; 1646 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT; 1647 1648 pScsiTm->Reserved = 0; 1649 pScsiTm->TaskType = type; 1650 pScsiTm->Reserved1 = 0; 1651 pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) 1652 ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0; 1653 1654 for (ii= 0; ii < 8; ii++) { 1655 pScsiTm->LUN[ii] = 0; 1656 } 1657 pScsiTm->LUN[1] = lun; 1658 1659 for (ii=0; ii < 7; ii++) 1660 pScsiTm->Reserved2[ii] = 0; 1661 1662 pScsiTm->TaskMsgContext = ctx2abort; 1663 1664 dtmprintk((MYIOC_s_INFO_FMT 1665 "IssueTaskMgmt: ctx2abort (0x%08x) type=%d\n", 1666 hd->ioc->name, ctx2abort, type)); 1667 1668 DBG_DUMP_TM_REQUEST_FRAME((u32 *)pScsiTm); 1669 1670 if ((retval = mpt_send_handshake_request(hd->ioc->TaskCtx, hd->ioc, 1671 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, 1672 CAN_SLEEP)) != 0) { 1673 dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!" 1674 " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd, 1675 hd->ioc, mf)); 1676 mpt_free_msg_frame(hd->ioc, mf); 1677 return retval; 1678 } 1679 1680 if(mptscsih_tm_wait_for_completion(hd, timeout) == FAILED) { 1681 dfailprintk((MYIOC_s_ERR_FMT "_wait_for_completion FAILED!" 1682 " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd, 1683 hd->ioc, mf)); 1684 mpt_free_msg_frame(hd->ioc, mf); 1685 dtmprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n", 1686 hd->ioc->name)); 1687 retval = mpt_HardResetHandler(hd->ioc, CAN_SLEEP); 1688 } 1689 1690 return retval; 1691 } 1692 1693 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1694 /** 1695 * mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant 1696 * @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted 1697 * 1698 * (linux scsi_host_template.eh_abort_handler routine) 1699 * 1700 * Returns SUCCESS or FAILED. 1701 */ 1702 int 1703 mptscsih_abort(struct scsi_cmnd * SCpnt) 1704 { 1705 MPT_SCSI_HOST *hd; 1706 MPT_ADAPTER *ioc; 1707 MPT_FRAME_HDR *mf; 1708 u32 ctx2abort; 1709 int scpnt_idx; 1710 1711 /* If we can't locate our host adapter structure, return FAILED status. 1712 */ 1713 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL) { 1714 SCpnt->result = DID_RESET << 16; 1715 SCpnt->scsi_done(SCpnt); 1716 dfailprintk((KERN_WARNING MYNAM ": mptscsih_abort: " 1717 "Can't locate host! (sc=%p)\n", 1718 SCpnt)); 1719 return FAILED; 1720 } 1721 1722 ioc = hd->ioc; 1723 if (hd->resetPending) 1724 return FAILED; 1725 1726 printk(KERN_WARNING MYNAM ": %s: >> Attempting task abort! (sc=%p)\n", 1727 hd->ioc->name, SCpnt); 1728 1729 if (hd->timeouts < -1) 1730 hd->timeouts++; 1731 1732 /* Find this command 1733 */ 1734 if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(SCpnt)) < 0) { 1735 /* Cmd not found in ScsiLookup. 1736 * Do OS callback. 1737 */ 1738 SCpnt->result = DID_RESET << 16; 1739 dtmprintk((KERN_WARNING MYNAM ": %s: mptscsih_abort: " 1740 "Command not in the active list! (sc=%p)\n", 1741 hd->ioc->name, SCpnt)); 1742 return SUCCESS; 1743 } 1744 1745 /* Most important! Set TaskMsgContext to SCpnt's MsgContext! 1746 * (the IO to be ABORT'd) 1747 * 1748 * NOTE: Since we do not byteswap MsgContext, we do not 1749 * swap it here either. It is an opaque cookie to 1750 * the controller, so it does not matter. -DaveM 1751 */ 1752 mf = MPT_INDEX_2_MFPTR(hd->ioc, scpnt_idx); 1753 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext; 1754 1755 hd->abortSCpnt = SCpnt; 1756 1757 if (mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK, 1758 SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, 1759 ctx2abort, 2 /* 2 second timeout */) 1760 < 0) { 1761 1762 /* The TM request failed and the subsequent FW-reload failed! 1763 * Fatal error case. 1764 */ 1765 printk(MYIOC_s_WARN_FMT "Error issuing abort task! (sc=%p)\n", 1766 hd->ioc->name, SCpnt); 1767 1768 /* We must clear our pending flag before clearing our state. 1769 */ 1770 hd->tmPending = 0; 1771 hd->tmState = TM_STATE_NONE; 1772 1773 /* Unmap the DMA buffers, if any. */ 1774 if (SCpnt->use_sg) { 1775 pci_unmap_sg(ioc->pcidev, (struct scatterlist *) SCpnt->request_buffer, 1776 SCpnt->use_sg, SCpnt->sc_data_direction); 1777 } else if (SCpnt->request_bufflen) { 1778 pci_unmap_single(ioc->pcidev, SCpnt->SCp.dma_handle, 1779 SCpnt->request_bufflen, SCpnt->sc_data_direction); 1780 } 1781 hd->ScsiLookup[scpnt_idx] = NULL; 1782 SCpnt->result = DID_RESET << 16; 1783 SCpnt->scsi_done(SCpnt); /* Issue the command callback */ 1784 mptscsih_freeChainBuffers(ioc, scpnt_idx); 1785 mpt_free_msg_frame(ioc, mf); 1786 return FAILED; 1787 } 1788 return SUCCESS; 1789 } 1790 1791 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1792 /** 1793 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant 1794 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to 1795 * 1796 * (linux scsi_host_template.eh_dev_reset_handler routine) 1797 * 1798 * Returns SUCCESS or FAILED. 1799 */ 1800 int 1801 mptscsih_dev_reset(struct scsi_cmnd * SCpnt) 1802 { 1803 MPT_SCSI_HOST *hd; 1804 1805 /* If we can't locate our host adapter structure, return FAILED status. 1806 */ 1807 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){ 1808 dtmprintk((KERN_WARNING MYNAM ": mptscsih_dev_reset: " 1809 "Can't locate host! (sc=%p)\n", 1810 SCpnt)); 1811 return FAILED; 1812 } 1813 1814 if (hd->resetPending) 1815 return FAILED; 1816 1817 printk(KERN_WARNING MYNAM ": %s: >> Attempting target reset! (sc=%p)\n", 1818 hd->ioc->name, SCpnt); 1819 1820 if (mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 1821 SCpnt->device->channel, SCpnt->device->id, 1822 0, 0, 5 /* 5 second timeout */) 1823 < 0){ 1824 /* The TM request failed and the subsequent FW-reload failed! 1825 * Fatal error case. 1826 */ 1827 printk(MYIOC_s_WARN_FMT "Error processing TaskMgmt request (sc=%p)\n", 1828 hd->ioc->name, SCpnt); 1829 hd->tmPending = 0; 1830 hd->tmState = TM_STATE_NONE; 1831 return FAILED; 1832 } 1833 1834 return SUCCESS; 1835 } 1836 1837 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1838 /** 1839 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant 1840 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to 1841 * 1842 * (linux scsi_host_template.eh_bus_reset_handler routine) 1843 * 1844 * Returns SUCCESS or FAILED. 1845 */ 1846 int 1847 mptscsih_bus_reset(struct scsi_cmnd * SCpnt) 1848 { 1849 MPT_SCSI_HOST *hd; 1850 spinlock_t *host_lock = SCpnt->device->host->host_lock; 1851 1852 /* If we can't locate our host adapter structure, return FAILED status. 1853 */ 1854 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){ 1855 dtmprintk((KERN_WARNING MYNAM ": mptscsih_bus_reset: " 1856 "Can't locate host! (sc=%p)\n", 1857 SCpnt ) ); 1858 return FAILED; 1859 } 1860 1861 printk(KERN_WARNING MYNAM ": %s: >> Attempting bus reset! (sc=%p)\n", 1862 hd->ioc->name, SCpnt); 1863 1864 if (hd->timeouts < -1) 1865 hd->timeouts++; 1866 1867 /* We are now ready to execute the task management request. */ 1868 if (mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, 1869 SCpnt->device->channel, 0, 0, 0, 5 /* 5 second timeout */) 1870 < 0){ 1871 1872 /* The TM request failed and the subsequent FW-reload failed! 1873 * Fatal error case. 1874 */ 1875 printk(MYIOC_s_WARN_FMT 1876 "Error processing TaskMgmt request (sc=%p)\n", 1877 hd->ioc->name, SCpnt); 1878 hd->tmPending = 0; 1879 hd->tmState = TM_STATE_NONE; 1880 spin_lock_irq(host_lock); 1881 return FAILED; 1882 } 1883 1884 return SUCCESS; 1885 } 1886 1887 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1888 /** 1889 * mptscsih_host_reset - Perform a SCSI host adapter RESET! 1890 * new_eh variant 1891 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to 1892 * 1893 * (linux scsi_host_template.eh_host_reset_handler routine) 1894 * 1895 * Returns SUCCESS or FAILED. 1896 */ 1897 int 1898 mptscsih_host_reset(struct scsi_cmnd *SCpnt) 1899 { 1900 MPT_SCSI_HOST * hd; 1901 int status = SUCCESS; 1902 1903 /* If we can't locate the host to reset, then we failed. */ 1904 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){ 1905 dtmprintk( ( KERN_WARNING MYNAM ": mptscsih_host_reset: " 1906 "Can't locate host! (sc=%p)\n", 1907 SCpnt ) ); 1908 return FAILED; 1909 } 1910 1911 printk(KERN_WARNING MYNAM ": %s: >> Attempting host reset! (sc=%p)\n", 1912 hd->ioc->name, SCpnt); 1913 1914 /* If our attempts to reset the host failed, then return a failed 1915 * status. The host will be taken off line by the SCSI mid-layer. 1916 */ 1917 if (mpt_HardResetHandler(hd->ioc, CAN_SLEEP) < 0){ 1918 status = FAILED; 1919 } else { 1920 /* Make sure TM pending is cleared and TM state is set to 1921 * NONE. 1922 */ 1923 hd->tmPending = 0; 1924 hd->tmState = TM_STATE_NONE; 1925 } 1926 1927 dtmprintk( ( KERN_WARNING MYNAM ": mptscsih_host_reset: " 1928 "Status = %s\n", 1929 (status == SUCCESS) ? "SUCCESS" : "FAILED" ) ); 1930 1931 return status; 1932 } 1933 1934 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1935 /** 1936 * mptscsih_tm_pending_wait - wait for pending task management request to 1937 * complete. 1938 * @hd: Pointer to MPT host structure. 1939 * 1940 * Returns {SUCCESS,FAILED}. 1941 */ 1942 static int 1943 mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd) 1944 { 1945 unsigned long flags; 1946 int loop_count = 4 * 10; /* Wait 10 seconds */ 1947 int status = FAILED; 1948 1949 do { 1950 spin_lock_irqsave(&hd->ioc->FreeQlock, flags); 1951 if (hd->tmState == TM_STATE_NONE) { 1952 hd->tmState = TM_STATE_IN_PROGRESS; 1953 hd->tmPending = 1; 1954 status = SUCCESS; 1955 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags); 1956 break; 1957 } 1958 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags); 1959 msleep(250); 1960 } while (--loop_count); 1961 1962 return status; 1963 } 1964 1965 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1966 /** 1967 * mptscsih_tm_wait_for_completion - wait for completion of TM task 1968 * @hd: Pointer to MPT host structure. 1969 * 1970 * Returns {SUCCESS,FAILED}. 1971 */ 1972 static int 1973 mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout ) 1974 { 1975 unsigned long flags; 1976 int loop_count = 4 * timeout; 1977 int status = FAILED; 1978 1979 do { 1980 spin_lock_irqsave(&hd->ioc->FreeQlock, flags); 1981 if(hd->tmPending == 0) { 1982 status = SUCCESS; 1983 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags); 1984 break; 1985 } 1986 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags); 1987 msleep_interruptible(250); 1988 } while (--loop_count); 1989 1990 return status; 1991 } 1992 1993 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1994 /** 1995 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver 1996 * @ioc: Pointer to MPT_ADAPTER structure 1997 * @mf: Pointer to SCSI task mgmt request frame 1998 * @mr: Pointer to SCSI task mgmt reply frame 1999 * 2000 * This routine is called from mptbase.c::mpt_interrupt() at the completion 2001 * of any SCSI task management request. 2002 * This routine is registered with the MPT (base) driver at driver 2003 * load/init time via the mpt_register() API call. 2004 * 2005 * Returns 1 indicating alloc'd request frame ptr should be freed. 2006 */ 2007 int 2008 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) 2009 { 2010 SCSITaskMgmtReply_t *pScsiTmReply; 2011 SCSITaskMgmt_t *pScsiTmReq; 2012 MPT_SCSI_HOST *hd; 2013 unsigned long flags; 2014 u16 iocstatus; 2015 u8 tmType; 2016 2017 dtmprintk((MYIOC_s_WARN_FMT "TaskMgmt completed (mf=%p,mr=%p)\n", 2018 ioc->name, mf, mr)); 2019 if (ioc->sh) { 2020 /* Depending on the thread, a timer is activated for 2021 * the TM request. Delete this timer on completion of TM. 2022 * Decrement count of outstanding TM requests. 2023 */ 2024 hd = (MPT_SCSI_HOST *)ioc->sh->hostdata; 2025 } else { 2026 dtmprintk((MYIOC_s_WARN_FMT "TaskMgmt Complete: NULL Scsi Host Ptr\n", 2027 ioc->name)); 2028 return 1; 2029 } 2030 2031 if (mr == NULL) { 2032 dtmprintk((MYIOC_s_WARN_FMT "ERROR! TaskMgmt Reply: NULL Request %p\n", 2033 ioc->name, mf)); 2034 return 1; 2035 } else { 2036 pScsiTmReply = (SCSITaskMgmtReply_t*)mr; 2037 pScsiTmReq = (SCSITaskMgmt_t*)mf; 2038 2039 /* Figure out if this was ABORT_TASK, TARGET_RESET, or BUS_RESET! */ 2040 tmType = pScsiTmReq->TaskType; 2041 2042 dtmprintk((MYIOC_s_WARN_FMT " TaskType = %d, TerminationCount=%d\n", 2043 ioc->name, tmType, le32_to_cpu(pScsiTmReply->TerminationCount))); 2044 DBG_DUMP_TM_REPLY_FRAME((u32 *)pScsiTmReply); 2045 2046 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK; 2047 dtmprintk((MYIOC_s_WARN_FMT " SCSI TaskMgmt (%d) IOCStatus=%04x IOCLogInfo=%08x\n", 2048 ioc->name, tmType, iocstatus, le32_to_cpu(pScsiTmReply->IOCLogInfo))); 2049 /* Error? (anything non-zero?) */ 2050 if (iocstatus) { 2051 2052 /* clear flags and continue. 2053 */ 2054 if (tmType == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) 2055 hd->abortSCpnt = NULL; 2056 2057 /* If an internal command is present 2058 * or the TM failed - reload the FW. 2059 * FC FW may respond FAILED to an ABORT 2060 */ 2061 if (tmType == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) { 2062 if ((hd->cmdPtr) || 2063 (iocstatus == MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED)) { 2064 if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0) { 2065 printk((KERN_WARNING 2066 " Firmware Reload FAILED!!\n")); 2067 } 2068 } 2069 } 2070 } else { 2071 dtmprintk((MYIOC_s_WARN_FMT " TaskMgmt SUCCESS\n", ioc->name)); 2072 2073 hd->abortSCpnt = NULL; 2074 2075 } 2076 } 2077 2078 spin_lock_irqsave(&ioc->FreeQlock, flags); 2079 hd->tmPending = 0; 2080 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 2081 hd->tmState = TM_STATE_NONE; 2082 2083 return 1; 2084 } 2085 2086 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2087 /* 2088 * This is anyones guess quite frankly. 2089 */ 2090 int 2091 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev, 2092 sector_t capacity, int geom[]) 2093 { 2094 int heads; 2095 int sectors; 2096 sector_t cylinders; 2097 ulong dummy; 2098 2099 heads = 64; 2100 sectors = 32; 2101 2102 dummy = heads * sectors; 2103 cylinders = capacity; 2104 sector_div(cylinders,dummy); 2105 2106 /* 2107 * Handle extended translation size for logical drives 2108 * > 1Gb 2109 */ 2110 if ((ulong)capacity >= 0x200000) { 2111 heads = 255; 2112 sectors = 63; 2113 dummy = heads * sectors; 2114 cylinders = capacity; 2115 sector_div(cylinders,dummy); 2116 } 2117 2118 /* return result */ 2119 geom[0] = heads; 2120 geom[1] = sectors; 2121 geom[2] = cylinders; 2122 2123 dprintk((KERN_NOTICE 2124 ": bios_param: Id=%i Lun=%i Channel=%i CHS=%i/%i/%i\n", 2125 sdev->id, sdev->lun,sdev->channel,(int)cylinders,heads,sectors)); 2126 2127 return 0; 2128 } 2129 2130 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2131 /* 2132 * OS entry point to allow host driver to alloc memory 2133 * for each scsi device. Called once per device the bus scan. 2134 * Return non-zero if allocation fails. 2135 * Init memory once per id (not LUN). 2136 */ 2137 int 2138 mptscsih_slave_alloc(struct scsi_device *device) 2139 { 2140 struct Scsi_Host *host = device->host; 2141 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 2142 VirtDevice *vdev; 2143 uint target = device->id; 2144 2145 if (hd == NULL) 2146 return -ENODEV; 2147 2148 if ((vdev = hd->Targets[target]) != NULL) 2149 goto out; 2150 2151 vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL); 2152 if (!vdev) { 2153 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n", 2154 hd->ioc->name, sizeof(VirtDevice)); 2155 return -ENOMEM; 2156 } 2157 2158 memset(vdev, 0, sizeof(VirtDevice)); 2159 vdev->tflags = MPT_TARGET_FLAGS_Q_YES; 2160 vdev->ioc_id = hd->ioc->id; 2161 vdev->target_id = device->id; 2162 vdev->bus_id = device->channel; 2163 vdev->raidVolume = 0; 2164 hd->Targets[device->id] = vdev; 2165 if (hd->ioc->bus_type == SCSI) { 2166 if (hd->ioc->spi_data.isRaid & (1 << device->id)) { 2167 vdev->raidVolume = 1; 2168 ddvtprintk((KERN_INFO 2169 "RAID Volume @ id %d\n", device->id)); 2170 } 2171 } else { 2172 vdev->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; 2173 } 2174 2175 out: 2176 vdev->num_luns++; 2177 return 0; 2178 } 2179 2180 static int 2181 mptscsih_is_raid_volume(MPT_SCSI_HOST *hd, uint id) 2182 { 2183 int i; 2184 2185 if (!hd->ioc->spi_data.isRaid || !hd->ioc->spi_data.pIocPg3) 2186 return 0; 2187 2188 for (i = 0; i < hd->ioc->spi_data.pIocPg3->NumPhysDisks; i++) { 2189 if (id == hd->ioc->spi_data.pIocPg3->PhysDisk[i].PhysDiskID) 2190 return 1; 2191 } 2192 2193 return 0; 2194 } 2195 2196 /* 2197 * OS entry point to allow for host driver to free allocated memory 2198 * Called if no device present or device being unloaded 2199 */ 2200 void 2201 mptscsih_slave_destroy(struct scsi_device *device) 2202 { 2203 struct Scsi_Host *host = device->host; 2204 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 2205 VirtDevice *vdev; 2206 uint target = device->id; 2207 uint lun = device->lun; 2208 2209 if (hd == NULL) 2210 return; 2211 2212 mptscsih_search_running_cmds(hd, target, lun); 2213 2214 vdev = hd->Targets[target]; 2215 vdev->luns[0] &= ~(1 << lun); 2216 if (--vdev->num_luns) 2217 return; 2218 2219 kfree(hd->Targets[target]); 2220 hd->Targets[target] = NULL; 2221 2222 if (hd->ioc->bus_type == SCSI) { 2223 if (mptscsih_is_raid_volume(hd, target)) { 2224 hd->ioc->spi_data.forceDv |= MPT_SCSICFG_RELOAD_IOC_PG3; 2225 } else { 2226 hd->ioc->spi_data.dvStatus[target] = 2227 MPT_SCSICFG_NEGOTIATE; 2228 2229 if (!hd->negoNvram) { 2230 hd->ioc->spi_data.dvStatus[target] |= 2231 MPT_SCSICFG_DV_NOT_DONE; 2232 } 2233 } 2234 } 2235 } 2236 2237 static void 2238 mptscsih_set_queue_depth(struct scsi_device *device, MPT_SCSI_HOST *hd, 2239 VirtDevice *pTarget, int qdepth) 2240 { 2241 int max_depth; 2242 int tagged; 2243 2244 if (hd->ioc->bus_type == SCSI) { 2245 if (pTarget->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY) { 2246 if (!(pTarget->tflags & MPT_TARGET_FLAGS_Q_YES)) 2247 max_depth = 1; 2248 else if (((pTarget->inq_data[0] & 0x1f) == 0x00) && 2249 (pTarget->minSyncFactor <= MPT_ULTRA160 )) 2250 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH; 2251 else 2252 max_depth = MPT_SCSI_CMD_PER_DEV_LOW; 2253 } else { 2254 /* error case - No Inq. Data */ 2255 max_depth = 1; 2256 } 2257 } else 2258 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH; 2259 2260 if (qdepth > max_depth) 2261 qdepth = max_depth; 2262 if (qdepth == 1) 2263 tagged = 0; 2264 else 2265 tagged = MSG_SIMPLE_TAG; 2266 2267 scsi_adjust_queue_depth(device, tagged, qdepth); 2268 } 2269 2270 2271 /* 2272 * OS entry point to adjust the queue_depths on a per-device basis. 2273 * Called once per device the bus scan. Use it to force the queue_depth 2274 * member to 1 if a device does not support Q tags. 2275 * Return non-zero if fails. 2276 */ 2277 int 2278 mptscsih_slave_configure(struct scsi_device *device) 2279 { 2280 struct Scsi_Host *sh = device->host; 2281 VirtDevice *pTarget; 2282 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sh->hostdata; 2283 2284 if ((hd == NULL) || (hd->Targets == NULL)) { 2285 return 0; 2286 } 2287 2288 dsprintk((MYIOC_s_INFO_FMT 2289 "device @ %p, id=%d, LUN=%d, channel=%d\n", 2290 hd->ioc->name, device, device->id, device->lun, device->channel)); 2291 dsprintk((MYIOC_s_INFO_FMT 2292 "sdtr %d wdtr %d ppr %d inq length=%d\n", 2293 hd->ioc->name, device->sdtr, device->wdtr, 2294 device->ppr, device->inquiry_len)); 2295 2296 if (device->id > sh->max_id) { 2297 /* error case, should never happen */ 2298 scsi_adjust_queue_depth(device, 0, 1); 2299 goto slave_configure_exit; 2300 } 2301 2302 pTarget = hd->Targets[device->id]; 2303 2304 if (pTarget == NULL) { 2305 /* Driver doesn't know about this device. 2306 * Kernel may generate a "Dummy Lun 0" which 2307 * may become a real Lun if a 2308 * "scsi add-single-device" command is executed 2309 * while the driver is active (hot-plug a 2310 * device). LSI Raid controllers need 2311 * queue_depth set to DEV_HIGH for this reason. 2312 */ 2313 scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG, 2314 MPT_SCSI_CMD_PER_DEV_HIGH); 2315 goto slave_configure_exit; 2316 } 2317 2318 mptscsih_initTarget(hd, device->channel, device->id, device->lun, 2319 device->inquiry, device->inquiry_len ); 2320 mptscsih_set_queue_depth(device, hd, pTarget, MPT_SCSI_CMD_PER_DEV_HIGH); 2321 2322 dsprintk((MYIOC_s_INFO_FMT 2323 "Queue depth=%d, tflags=%x\n", 2324 hd->ioc->name, device->queue_depth, pTarget->tflags)); 2325 2326 dsprintk((MYIOC_s_INFO_FMT 2327 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n", 2328 hd->ioc->name, pTarget->negoFlags, pTarget->maxOffset, pTarget->minSyncFactor)); 2329 2330 slave_configure_exit: 2331 2332 dsprintk((MYIOC_s_INFO_FMT 2333 "tagged %d, simple %d, ordered %d\n", 2334 hd->ioc->name,device->tagged_supported, device->simple_tags, 2335 device->ordered_tags)); 2336 2337 return 0; 2338 } 2339 2340 ssize_t 2341 mptscsih_store_queue_depth(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 2342 { 2343 int depth; 2344 struct scsi_device *sdev = to_scsi_device(dev); 2345 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) sdev->host->hostdata; 2346 VirtDevice *pTarget; 2347 2348 depth = simple_strtoul(buf, NULL, 0); 2349 if (depth == 0) 2350 return -EINVAL; 2351 pTarget = hd->Targets[sdev->id]; 2352 if (pTarget == NULL) 2353 return -EINVAL; 2354 mptscsih_set_queue_depth(sdev, (MPT_SCSI_HOST *) sdev->host->hostdata, 2355 pTarget, depth); 2356 return count; 2357 } 2358 2359 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2360 /* 2361 * Private routines... 2362 */ 2363 2364 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2365 /* Utility function to copy sense data from the scsi_cmnd buffer 2366 * to the FC and SCSI target structures. 2367 * 2368 */ 2369 static void 2370 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply) 2371 { 2372 VirtDevice *target; 2373 SCSIIORequest_t *pReq; 2374 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount); 2375 int index; 2376 2377 /* Get target structure 2378 */ 2379 pReq = (SCSIIORequest_t *) mf; 2380 index = (int) pReq->TargetID; 2381 target = hd->Targets[index]; 2382 2383 if (sense_count) { 2384 u8 *sense_data; 2385 int req_index; 2386 2387 /* Copy the sense received into the scsi command block. */ 2388 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 2389 sense_data = ((u8 *)hd->ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC)); 2390 memcpy(sc->sense_buffer, sense_data, SNS_LEN(sc)); 2391 2392 /* Log SMART data (asc = 0x5D, non-IM case only) if required. 2393 */ 2394 if ((hd->ioc->events) && (hd->ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) { 2395 if ((sense_data[12] == 0x5D) && (target->raidVolume == 0)) { 2396 int idx; 2397 MPT_ADAPTER *ioc = hd->ioc; 2398 2399 idx = ioc->eventContext % ioc->eventLogSize; 2400 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE; 2401 ioc->events[idx].eventContext = ioc->eventContext; 2402 2403 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) || 2404 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) || 2405 (pReq->Bus << 8) || pReq->TargetID; 2406 2407 ioc->events[idx].data[1] = (sense_data[13] << 8) || sense_data[12]; 2408 2409 ioc->eventContext++; 2410 } 2411 } 2412 } else { 2413 dprintk((MYIOC_s_INFO_FMT "Hmmm... SenseData len=0! (?)\n", 2414 hd->ioc->name)); 2415 } 2416 } 2417 2418 static u32 2419 SCPNT_TO_LOOKUP_IDX(struct scsi_cmnd *sc) 2420 { 2421 MPT_SCSI_HOST *hd; 2422 int i; 2423 2424 hd = (MPT_SCSI_HOST *) sc->device->host->hostdata; 2425 2426 for (i = 0; i < hd->ioc->req_depth; i++) { 2427 if (hd->ScsiLookup[i] == sc) { 2428 return i; 2429 } 2430 } 2431 2432 return -1; 2433 } 2434 2435 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2436 int 2437 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 2438 { 2439 MPT_SCSI_HOST *hd; 2440 unsigned long flags; 2441 2442 dtmprintk((KERN_WARNING MYNAM 2443 ": IOC %s_reset routed to SCSI host driver!\n", 2444 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : ( 2445 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post"))); 2446 2447 /* If a FW reload request arrives after base installed but 2448 * before all scsi hosts have been attached, then an alt_ioc 2449 * may have a NULL sh pointer. 2450 */ 2451 if ((ioc->sh == NULL) || (ioc->sh->hostdata == NULL)) 2452 return 0; 2453 else 2454 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata; 2455 2456 if (reset_phase == MPT_IOC_SETUP_RESET) { 2457 dtmprintk((MYIOC_s_WARN_FMT "Setup-Diag Reset\n", ioc->name)); 2458 2459 /* Clean Up: 2460 * 1. Set Hard Reset Pending Flag 2461 * All new commands go to doneQ 2462 */ 2463 hd->resetPending = 1; 2464 2465 } else if (reset_phase == MPT_IOC_PRE_RESET) { 2466 dtmprintk((MYIOC_s_WARN_FMT "Pre-Diag Reset\n", ioc->name)); 2467 2468 /* 2. Flush running commands 2469 * Clean ScsiLookup (and associated memory) 2470 * AND clean mytaskQ 2471 */ 2472 2473 /* 2b. Reply to OS all known outstanding I/O commands. 2474 */ 2475 mptscsih_flush_running_cmds(hd); 2476 2477 /* 2c. If there was an internal command that 2478 * has not completed, configuration or io request, 2479 * free these resources. 2480 */ 2481 if (hd->cmdPtr) { 2482 del_timer(&hd->timer); 2483 mpt_free_msg_frame(ioc, hd->cmdPtr); 2484 } 2485 2486 dtmprintk((MYIOC_s_WARN_FMT "Pre-Reset complete.\n", ioc->name)); 2487 2488 } else { 2489 dtmprintk((MYIOC_s_WARN_FMT "Post-Diag Reset\n", ioc->name)); 2490 2491 /* Once a FW reload begins, all new OS commands are 2492 * redirected to the doneQ w/ a reset status. 2493 * Init all control structures. 2494 */ 2495 2496 /* ScsiLookup initialization 2497 */ 2498 { 2499 int ii; 2500 for (ii=0; ii < hd->ioc->req_depth; ii++) 2501 hd->ScsiLookup[ii] = NULL; 2502 } 2503 2504 /* 2. Chain Buffer initialization 2505 */ 2506 2507 /* 4. Renegotiate to all devices, if SCSI 2508 */ 2509 if (ioc->bus_type == SCSI) { 2510 dnegoprintk(("writeSDP1: ALL_IDS USE_NVRAM\n")); 2511 mptscsih_writeSDP1(hd, 0, 0, MPT_SCSICFG_ALL_IDS | MPT_SCSICFG_USE_NVRAM); 2512 } 2513 2514 /* 5. Enable new commands to be posted 2515 */ 2516 spin_lock_irqsave(&ioc->FreeQlock, flags); 2517 hd->tmPending = 0; 2518 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 2519 hd->resetPending = 0; 2520 hd->tmState = TM_STATE_NONE; 2521 2522 /* 6. If there was an internal command, 2523 * wake this process up. 2524 */ 2525 if (hd->cmdPtr) { 2526 /* 2527 * Wake up the original calling thread 2528 */ 2529 hd->pLocal = &hd->localReply; 2530 hd->pLocal->completion = MPT_SCANDV_DID_RESET; 2531 hd->scandv_wait_done = 1; 2532 wake_up(&hd->scandv_waitq); 2533 hd->cmdPtr = NULL; 2534 } 2535 2536 /* 7. Set flag to force DV and re-read IOC Page 3 2537 */ 2538 if (ioc->bus_type == SCSI) { 2539 ioc->spi_data.forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3; 2540 ddvtprintk(("Set reload IOC Pg3 Flag\n")); 2541 } 2542 2543 dtmprintk((MYIOC_s_WARN_FMT "Post-Reset complete.\n", ioc->name)); 2544 2545 } 2546 2547 return 1; /* currently means nothing really */ 2548 } 2549 2550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2551 int 2552 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) 2553 { 2554 MPT_SCSI_HOST *hd; 2555 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF; 2556 2557 devtprintk((MYIOC_s_INFO_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n", 2558 ioc->name, event)); 2559 2560 switch (event) { 2561 case MPI_EVENT_UNIT_ATTENTION: /* 03 */ 2562 /* FIXME! */ 2563 break; 2564 case MPI_EVENT_IOC_BUS_RESET: /* 04 */ 2565 case MPI_EVENT_EXT_BUS_RESET: /* 05 */ 2566 hd = NULL; 2567 if (ioc->sh) { 2568 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata; 2569 if (hd && (ioc->bus_type == SCSI) && (hd->soft_resets < -1)) 2570 hd->soft_resets++; 2571 } 2572 break; 2573 case MPI_EVENT_LOGOUT: /* 09 */ 2574 /* FIXME! */ 2575 break; 2576 2577 /* 2578 * CHECKME! Don't think we need to do 2579 * anything for these, but... 2580 */ 2581 case MPI_EVENT_RESCAN: /* 06 */ 2582 case MPI_EVENT_LINK_STATUS_CHANGE: /* 07 */ 2583 case MPI_EVENT_LOOP_STATE_CHANGE: /* 08 */ 2584 /* 2585 * CHECKME! Falling thru... 2586 */ 2587 break; 2588 2589 case MPI_EVENT_INTEGRATED_RAID: /* 0B */ 2590 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 2591 /* negoNvram set to 0 if DV enabled and to USE_NVRAM if 2592 * if DV disabled. Need to check for target mode. 2593 */ 2594 hd = NULL; 2595 if (ioc->sh) 2596 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata; 2597 2598 if (hd && (ioc->bus_type == SCSI) && (hd->negoNvram == 0)) { 2599 ScsiCfgData *pSpi; 2600 Ioc3PhysDisk_t *pPDisk; 2601 int numPDisk; 2602 u8 reason; 2603 u8 physDiskNum; 2604 2605 reason = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16; 2606 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) { 2607 /* New or replaced disk. 2608 * Set DV flag and schedule DV. 2609 */ 2610 pSpi = &ioc->spi_data; 2611 physDiskNum = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24; 2612 ddvtprintk(("DV requested for phys disk id %d\n", physDiskNum)); 2613 if (pSpi->pIocPg3) { 2614 pPDisk = pSpi->pIocPg3->PhysDisk; 2615 numPDisk =pSpi->pIocPg3->NumPhysDisks; 2616 2617 while (numPDisk) { 2618 if (physDiskNum == pPDisk->PhysDiskNum) { 2619 pSpi->dvStatus[pPDisk->PhysDiskID] = (MPT_SCSICFG_NEED_DV | MPT_SCSICFG_DV_NOT_DONE); 2620 pSpi->forceDv = MPT_SCSICFG_NEED_DV; 2621 ddvtprintk(("NEED_DV set for phys disk id %d\n", pPDisk->PhysDiskID)); 2622 break; 2623 } 2624 pPDisk++; 2625 numPDisk--; 2626 } 2627 2628 if (numPDisk == 0) { 2629 /* The physical disk that needs DV was not found 2630 * in the stored IOC Page 3. The driver must reload 2631 * this page. DV routine will set the NEED_DV flag for 2632 * all phys disks that have DV_NOT_DONE set. 2633 */ 2634 pSpi->forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3; 2635 ddvtprintk(("phys disk %d not found. Setting reload IOC Pg3 Flag\n", physDiskNum)); 2636 } 2637 } 2638 } 2639 } 2640 #endif 2641 2642 #if defined(MPT_DEBUG_DV) || defined(MPT_DEBUG_DV_TINY) 2643 printk("Raid Event RF: "); 2644 { 2645 u32 *m = (u32 *)pEvReply; 2646 int ii; 2647 int n = (int)pEvReply->MsgLength; 2648 for (ii=6; ii < n; ii++) 2649 printk(" %08x", le32_to_cpu(m[ii])); 2650 printk("\n"); 2651 } 2652 #endif 2653 break; 2654 2655 case MPI_EVENT_NONE: /* 00 */ 2656 case MPI_EVENT_LOG_DATA: /* 01 */ 2657 case MPI_EVENT_STATE_CHANGE: /* 02 */ 2658 case MPI_EVENT_EVENT_CHANGE: /* 0A */ 2659 default: 2660 dprintk((KERN_INFO " Ignoring event (=%02Xh)\n", event)); 2661 break; 2662 } 2663 2664 return 1; /* currently means nothing really */ 2665 } 2666 2667 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2668 /* 2669 * mptscsih_initTarget - Target, LUN alloc/free functionality. 2670 * @hd: Pointer to MPT_SCSI_HOST structure 2671 * @bus_id: Bus number (?) 2672 * @target_id: SCSI target id 2673 * @lun: SCSI LUN id 2674 * @data: Pointer to data 2675 * @dlen: Number of INQUIRY bytes 2676 * 2677 * NOTE: It's only SAFE to call this routine if data points to 2678 * sane & valid STANDARD INQUIRY data! 2679 * 2680 * Allocate and initialize memory for this target. 2681 * Save inquiry data. 2682 * 2683 */ 2684 static void 2685 mptscsih_initTarget(MPT_SCSI_HOST *hd, int bus_id, int target_id, u8 lun, char *data, int dlen) 2686 { 2687 int indexed_lun, lun_index; 2688 VirtDevice *vdev; 2689 ScsiCfgData *pSpi; 2690 char data_56; 2691 2692 dinitprintk((MYIOC_s_INFO_FMT "initTarget bus=%d id=%d lun=%d hd=%p\n", 2693 hd->ioc->name, bus_id, target_id, lun, hd)); 2694 2695 /* 2696 * If the peripheral qualifier filter is enabled then if the target reports a 0x1 2697 * (i.e. The targer is capable of supporting the specified peripheral device type 2698 * on this logical unit; however, the physical device is not currently connected 2699 * to this logical unit) it will be converted to a 0x3 (i.e. The target is not 2700 * capable of supporting a physical device on this logical unit). This is to work 2701 * around a bug in th emid-layer in some distributions in which the mid-layer will 2702 * continue to try to communicate to the LUN and evntually create a dummy LUN. 2703 */ 2704 if (hd->mpt_pq_filter && dlen && (data[0] & 0xE0)) 2705 data[0] |= 0x40; 2706 2707 /* Is LUN supported? If so, upper 2 bits will be 0 2708 * in first byte of inquiry data. 2709 */ 2710 if (data[0] & 0xe0) 2711 return; 2712 2713 if ((vdev = hd->Targets[target_id]) == NULL) { 2714 return; 2715 } 2716 2717 lun_index = (lun >> 5); /* 32 luns per lun_index */ 2718 indexed_lun = (lun % 32); 2719 vdev->luns[lun_index] |= (1 << indexed_lun); 2720 2721 if (hd->ioc->bus_type == SCSI) { 2722 if ((data[0] == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) { 2723 /* Treat all Processors as SAF-TE if 2724 * command line option is set */ 2725 vdev->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; 2726 mptscsih_writeIOCPage4(hd, target_id, bus_id); 2727 }else if ((data[0] == TYPE_PROCESSOR) && 2728 !(vdev->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) { 2729 if ( dlen > 49 ) { 2730 vdev->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; 2731 if ( data[44] == 'S' && 2732 data[45] == 'A' && 2733 data[46] == 'F' && 2734 data[47] == '-' && 2735 data[48] == 'T' && 2736 data[49] == 'E' ) { 2737 vdev->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; 2738 mptscsih_writeIOCPage4(hd, target_id, bus_id); 2739 } 2740 } 2741 } 2742 if (!(vdev->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY)) { 2743 if ( dlen > 8 ) { 2744 memcpy (vdev->inq_data, data, 8); 2745 } else { 2746 memcpy (vdev->inq_data, data, dlen); 2747 } 2748 2749 /* If have not done DV, set the DV flag. 2750 */ 2751 pSpi = &hd->ioc->spi_data; 2752 if ((data[0] == TYPE_TAPE) || (data[0] == TYPE_PROCESSOR)) { 2753 if (pSpi->dvStatus[target_id] & MPT_SCSICFG_DV_NOT_DONE) 2754 pSpi->dvStatus[target_id] |= MPT_SCSICFG_NEED_DV; 2755 } 2756 2757 vdev->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; 2758 2759 2760 data_56 = 0x0F; /* Default to full capabilities if Inq data length is < 57 */ 2761 if (dlen > 56) { 2762 if ( (!(vdev->tflags & MPT_TARGET_FLAGS_VALID_56))) { 2763 /* Update the target capabilities 2764 */ 2765 data_56 = data[56]; 2766 vdev->tflags |= MPT_TARGET_FLAGS_VALID_56; 2767 } 2768 } 2769 mptscsih_setTargetNegoParms(hd, vdev, data_56); 2770 } else { 2771 /* Initial Inquiry may not request enough data bytes to 2772 * obtain byte 57. DV will; if target doesn't return 2773 * at least 57 bytes, data[56] will be zero. */ 2774 if (dlen > 56) { 2775 if ( (!(vdev->tflags & MPT_TARGET_FLAGS_VALID_56))) { 2776 /* Update the target capabilities 2777 */ 2778 data_56 = data[56]; 2779 vdev->tflags |= MPT_TARGET_FLAGS_VALID_56; 2780 mptscsih_setTargetNegoParms(hd, vdev, data_56); 2781 } 2782 } 2783 } 2784 } 2785 } 2786 2787 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2788 /* 2789 * Update the target negotiation parameters based on the 2790 * the Inquiry data, adapter capabilities, and NVRAM settings. 2791 * 2792 */ 2793 static void 2794 mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtDevice *target, char byte56) 2795 { 2796 ScsiCfgData *pspi_data = &hd->ioc->spi_data; 2797 int id = (int) target->target_id; 2798 int nvram; 2799 VirtDevice *vdev; 2800 int ii; 2801 u8 width = MPT_NARROW; 2802 u8 factor = MPT_ASYNC; 2803 u8 offset = 0; 2804 u8 version, nfactor; 2805 u8 noQas = 1; 2806 2807 target->negoFlags = pspi_data->noQas; 2808 2809 /* noQas == 0 => device supports QAS. Need byte 56 of Inq to determine 2810 * support. If available, default QAS to off and allow enabling. 2811 * If not available, default QAS to on, turn off for non-disks. 2812 */ 2813 2814 /* Set flags based on Inquiry data 2815 */ 2816 version = target->inq_data[2] & 0x07; 2817 if (version < 2) { 2818 width = 0; 2819 factor = MPT_ULTRA2; 2820 offset = pspi_data->maxSyncOffset; 2821 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES; 2822 } else { 2823 if (target->inq_data[7] & 0x20) { 2824 width = 1; 2825 } 2826 2827 if (target->inq_data[7] & 0x10) { 2828 factor = pspi_data->minSyncFactor; 2829 if (target->tflags & MPT_TARGET_FLAGS_VALID_56) { 2830 /* bits 2 & 3 show Clocking support */ 2831 if ((byte56 & 0x0C) == 0) 2832 factor = MPT_ULTRA2; 2833 else { 2834 if ((byte56 & 0x03) == 0) 2835 factor = MPT_ULTRA160; 2836 else { 2837 factor = MPT_ULTRA320; 2838 if (byte56 & 0x02) 2839 { 2840 ddvtprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", byte56, id)); 2841 noQas = 0; 2842 } 2843 if (target->inq_data[0] == TYPE_TAPE) { 2844 if (byte56 & 0x01) 2845 target->negoFlags |= MPT_TAPE_NEGO_IDP; 2846 } 2847 } 2848 } 2849 } else { 2850 ddvtprintk((KERN_INFO "Enabling QAS on id=%d due to ~TARGET_FLAGS_VALID_56!\n", id)); 2851 noQas = 0; 2852 } 2853 2854 offset = pspi_data->maxSyncOffset; 2855 2856 /* If RAID, never disable QAS 2857 * else if non RAID, do not disable 2858 * QAS if bit 1 is set 2859 * bit 1 QAS support, non-raid only 2860 * bit 0 IU support 2861 */ 2862 if (target->raidVolume == 1) { 2863 noQas = 0; 2864 } 2865 } else { 2866 factor = MPT_ASYNC; 2867 offset = 0; 2868 } 2869 } 2870 2871 if ( (target->inq_data[7] & 0x02) == 0) { 2872 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES; 2873 } 2874 2875 /* Update tflags based on NVRAM settings. (SCSI only) 2876 */ 2877 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) { 2878 nvram = pspi_data->nvram[id]; 2879 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8; 2880 2881 if (width) 2882 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1; 2883 2884 if (offset > 0) { 2885 /* Ensure factor is set to the 2886 * maximum of: adapter, nvram, inquiry 2887 */ 2888 if (nfactor) { 2889 if (nfactor < pspi_data->minSyncFactor ) 2890 nfactor = pspi_data->minSyncFactor; 2891 2892 factor = max(factor, nfactor); 2893 if (factor == MPT_ASYNC) 2894 offset = 0; 2895 } else { 2896 offset = 0; 2897 factor = MPT_ASYNC; 2898 } 2899 } else { 2900 factor = MPT_ASYNC; 2901 } 2902 } 2903 2904 /* Make sure data is consistent 2905 */ 2906 if ((!width) && (factor < MPT_ULTRA2)) { 2907 factor = MPT_ULTRA2; 2908 } 2909 2910 /* Save the data to the target structure. 2911 */ 2912 target->minSyncFactor = factor; 2913 target->maxOffset = offset; 2914 target->maxWidth = width; 2915 2916 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO; 2917 2918 /* Disable unused features. 2919 */ 2920 if (!width) 2921 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE; 2922 2923 if (!offset) 2924 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC; 2925 2926 if ( factor > MPT_ULTRA320 ) 2927 noQas = 0; 2928 2929 /* GEM, processor WORKAROUND 2930 */ 2931 if ((target->inq_data[0] == TYPE_PROCESSOR) || (target->inq_data[0] > 0x08)) { 2932 target->negoFlags |= (MPT_TARGET_NO_NEGO_WIDE | MPT_TARGET_NO_NEGO_SYNC); 2933 pspi_data->dvStatus[id] |= MPT_SCSICFG_BLK_NEGO; 2934 } else { 2935 if (noQas && (pspi_data->noQas == 0)) { 2936 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS; 2937 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS; 2938 2939 /* Disable QAS in a mixed configuration case 2940 */ 2941 2942 ddvtprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id)); 2943 for (ii = 0; ii < id; ii++) { 2944 if ( (vdev = hd->Targets[ii]) ) { 2945 vdev->negoFlags |= MPT_TARGET_NO_NEGO_QAS; 2946 mptscsih_writeSDP1(hd, 0, ii, vdev->negoFlags); 2947 } 2948 } 2949 } 2950 } 2951 2952 /* Write SDP1 on this I/O to this target */ 2953 if (pspi_data->dvStatus[id] & MPT_SCSICFG_NEGOTIATE) { 2954 ddvtprintk((KERN_INFO "MPT_SCSICFG_NEGOTIATE on id=%d!\n", id)); 2955 mptscsih_writeSDP1(hd, 0, id, hd->negoNvram); 2956 pspi_data->dvStatus[id] &= ~MPT_SCSICFG_NEGOTIATE; 2957 } else if (pspi_data->dvStatus[id] & MPT_SCSICFG_BLK_NEGO) { 2958 ddvtprintk((KERN_INFO "MPT_SCSICFG_BLK_NEGO on id=%d!\n", id)); 2959 mptscsih_writeSDP1(hd, 0, id, MPT_SCSICFG_BLK_NEGO); 2960 pspi_data->dvStatus[id] &= ~MPT_SCSICFG_BLK_NEGO; 2961 } 2962 } 2963 2964 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 2965 /* If DV disabled (negoNvram set to USE_NVARM) or if not LUN 0, return. 2966 * Else set the NEED_DV flag after Read Capacity Issued (disks) 2967 * or Mode Sense (cdroms). 2968 * 2969 * Tapes, initTarget will set this flag on completion of Inquiry command. 2970 * Called only if DV_NOT_DONE flag is set 2971 */ 2972 static void 2973 mptscsih_set_dvflags(MPT_SCSI_HOST *hd, SCSIIORequest_t *pReq) 2974 { 2975 u8 cmd; 2976 ScsiCfgData *pSpi; 2977 2978 ddvtprintk((" set_dvflags: id=%d lun=%d negoNvram=%x cmd=%x\n", 2979 pReq->TargetID, pReq->LUN[1], hd->negoNvram, pReq->CDB[0])); 2980 2981 if ((pReq->LUN[1] != 0) || (hd->negoNvram != 0)) 2982 return; 2983 2984 cmd = pReq->CDB[0]; 2985 2986 if ((cmd == READ_CAPACITY) || (cmd == MODE_SENSE)) { 2987 pSpi = &hd->ioc->spi_data; 2988 if ((pSpi->isRaid & (1 << pReq->TargetID)) && pSpi->pIocPg3) { 2989 /* Set NEED_DV for all hidden disks 2990 */ 2991 Ioc3PhysDisk_t *pPDisk = pSpi->pIocPg3->PhysDisk; 2992 int numPDisk = pSpi->pIocPg3->NumPhysDisks; 2993 2994 while (numPDisk) { 2995 pSpi->dvStatus[pPDisk->PhysDiskID] |= MPT_SCSICFG_NEED_DV; 2996 ddvtprintk(("NEED_DV set for phys disk id %d\n", pPDisk->PhysDiskID)); 2997 pPDisk++; 2998 numPDisk--; 2999 } 3000 } 3001 pSpi->dvStatus[pReq->TargetID] |= MPT_SCSICFG_NEED_DV; 3002 ddvtprintk(("NEED_DV set for visible disk id %d\n", pReq->TargetID)); 3003 } 3004 } 3005 3006 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3007 /* 3008 * If no Target, bus reset on 1st I/O. Set the flag to 3009 * prevent any future negotiations to this device. 3010 */ 3011 static void 3012 mptscsih_no_negotiate(MPT_SCSI_HOST *hd, int target_id) 3013 { 3014 3015 if ((hd->Targets) && (hd->Targets[target_id] == NULL)) 3016 hd->ioc->spi_data.dvStatus[target_id] |= MPT_SCSICFG_BLK_NEGO; 3017 3018 return; 3019 } 3020 3021 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3022 /* 3023 * SCSI Config Page functionality ... 3024 */ 3025 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3026 /* mptscsih_setDevicePage1Flags - add Requested and Configuration fields flags 3027 * based on width, factor and offset parameters. 3028 * @width: bus width 3029 * @factor: sync factor 3030 * @offset: sync offset 3031 * @requestedPtr: pointer to requested values (updated) 3032 * @configurationPtr: pointer to configuration values (updated) 3033 * @flags: flags to block WDTR or SDTR negotiation 3034 * 3035 * Return: None. 3036 * 3037 * Remark: Called by writeSDP1 and _dv_params 3038 */ 3039 static void 3040 mptscsih_setDevicePage1Flags (u8 width, u8 factor, u8 offset, int *requestedPtr, int *configurationPtr, u8 flags) 3041 { 3042 u8 nowide = flags & MPT_TARGET_NO_NEGO_WIDE; 3043 u8 nosync = flags & MPT_TARGET_NO_NEGO_SYNC; 3044 3045 *configurationPtr = 0; 3046 *requestedPtr = width ? MPI_SCSIDEVPAGE1_RP_WIDE : 0; 3047 *requestedPtr |= (offset << 16) | (factor << 8); 3048 3049 if (width && offset && !nowide && !nosync) { 3050 if (factor < MPT_ULTRA160) { 3051 *requestedPtr |= (MPI_SCSIDEVPAGE1_RP_IU + MPI_SCSIDEVPAGE1_RP_DT); 3052 if ((flags & MPT_TARGET_NO_NEGO_QAS) == 0) 3053 *requestedPtr |= MPI_SCSIDEVPAGE1_RP_QAS; 3054 if (flags & MPT_TAPE_NEGO_IDP) 3055 *requestedPtr |= 0x08000000; 3056 } else if (factor < MPT_ULTRA2) { 3057 *requestedPtr |= MPI_SCSIDEVPAGE1_RP_DT; 3058 } 3059 } 3060 3061 if (nowide) 3062 *configurationPtr |= MPI_SCSIDEVPAGE1_CONF_WDTR_DISALLOWED; 3063 3064 if (nosync) 3065 *configurationPtr |= MPI_SCSIDEVPAGE1_CONF_SDTR_DISALLOWED; 3066 3067 return; 3068 } 3069 3070 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3071 /* mptscsih_writeSDP1 - write SCSI Device Page 1 3072 * @hd: Pointer to a SCSI Host Strucutre 3073 * @portnum: IOC port number 3074 * @target_id: writeSDP1 for single ID 3075 * @flags: MPT_SCSICFG_ALL_IDS, MPT_SCSICFG_USE_NVRAM, MPT_SCSICFG_BLK_NEGO 3076 * 3077 * Return: -EFAULT if read of config page header fails 3078 * or 0 if success. 3079 * 3080 * Remark: If a target has been found, the settings from the 3081 * target structure are used, else the device is set 3082 * to async/narrow. 3083 * 3084 * Remark: Called during init and after a FW reload. 3085 * Remark: We do not wait for a return, write pages sequentially. 3086 */ 3087 static int 3088 mptscsih_writeSDP1(MPT_SCSI_HOST *hd, int portnum, int target_id, int flags) 3089 { 3090 MPT_ADAPTER *ioc = hd->ioc; 3091 Config_t *pReq; 3092 SCSIDevicePage1_t *pData; 3093 VirtDevice *pTarget; 3094 MPT_FRAME_HDR *mf; 3095 dma_addr_t dataDma; 3096 u16 req_idx; 3097 u32 frameOffset; 3098 u32 requested, configuration, flagsLength; 3099 int ii, nvram; 3100 int id = 0, maxid = 0; 3101 u8 width; 3102 u8 factor; 3103 u8 offset; 3104 u8 bus = 0; 3105 u8 negoFlags; 3106 u8 maxwidth, maxoffset, maxfactor; 3107 3108 if (ioc->spi_data.sdp1length == 0) 3109 return 0; 3110 3111 if (flags & MPT_SCSICFG_ALL_IDS) { 3112 id = 0; 3113 maxid = ioc->sh->max_id - 1; 3114 } else if (ioc->sh) { 3115 id = target_id; 3116 maxid = min_t(int, id, ioc->sh->max_id - 1); 3117 } 3118 3119 for (; id <= maxid; id++) { 3120 3121 if (id == ioc->pfacts[portnum].PortSCSIID) 3122 continue; 3123 3124 /* Use NVRAM to get adapter and target maximums 3125 * Data over-riden by target structure information, if present 3126 */ 3127 maxwidth = ioc->spi_data.maxBusWidth; 3128 maxoffset = ioc->spi_data.maxSyncOffset; 3129 maxfactor = ioc->spi_data.minSyncFactor; 3130 if (ioc->spi_data.nvram && (ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) { 3131 nvram = ioc->spi_data.nvram[id]; 3132 3133 if (maxwidth) 3134 maxwidth = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1; 3135 3136 if (maxoffset > 0) { 3137 maxfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8; 3138 if (maxfactor == 0) { 3139 /* Key for async */ 3140 maxfactor = MPT_ASYNC; 3141 maxoffset = 0; 3142 } else if (maxfactor < ioc->spi_data.minSyncFactor) { 3143 maxfactor = ioc->spi_data.minSyncFactor; 3144 } 3145 } else 3146 maxfactor = MPT_ASYNC; 3147 } 3148 3149 /* Set the negotiation flags. 3150 */ 3151 negoFlags = ioc->spi_data.noQas; 3152 if (!maxwidth) 3153 negoFlags |= MPT_TARGET_NO_NEGO_WIDE; 3154 3155 if (!maxoffset) 3156 negoFlags |= MPT_TARGET_NO_NEGO_SYNC; 3157 3158 if (flags & MPT_SCSICFG_USE_NVRAM) { 3159 width = maxwidth; 3160 factor = maxfactor; 3161 offset = maxoffset; 3162 } else { 3163 width = 0; 3164 factor = MPT_ASYNC; 3165 offset = 0; 3166 //negoFlags = 0; 3167 //negoFlags = MPT_TARGET_NO_NEGO_SYNC; 3168 } 3169 3170 /* If id is not a raid volume, get the updated 3171 * transmission settings from the target structure. 3172 */ 3173 if (hd->Targets && (pTarget = hd->Targets[id]) && !pTarget->raidVolume) { 3174 width = pTarget->maxWidth; 3175 factor = pTarget->minSyncFactor; 3176 offset = pTarget->maxOffset; 3177 negoFlags = pTarget->negoFlags; 3178 } 3179 3180 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 3181 /* Force to async and narrow if DV has not been executed 3182 * for this ID 3183 */ 3184 if ((hd->ioc->spi_data.dvStatus[id] & MPT_SCSICFG_DV_NOT_DONE) != 0) { 3185 width = 0; 3186 factor = MPT_ASYNC; 3187 offset = 0; 3188 } 3189 #endif 3190 3191 if (flags & MPT_SCSICFG_BLK_NEGO) 3192 negoFlags = MPT_TARGET_NO_NEGO_WIDE | MPT_TARGET_NO_NEGO_SYNC; 3193 3194 mptscsih_setDevicePage1Flags(width, factor, offset, 3195 &requested, &configuration, negoFlags); 3196 dnegoprintk(("writeSDP1: id=%d width=%d factor=%x offset=%x negoFlags=%x request=%x config=%x\n", 3197 target_id, width, factor, offset, negoFlags, requested, configuration)); 3198 3199 /* Get a MF for this command. 3200 */ 3201 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) { 3202 dprintk((MYIOC_s_WARN_FMT "write SDP1: no msg frames!\n", 3203 ioc->name)); 3204 return -EAGAIN; 3205 } 3206 3207 ddvprintk((MYIOC_s_INFO_FMT "WriteSDP1 (mf=%p, id=%d, req=0x%x, cfg=0x%x)\n", 3208 hd->ioc->name, mf, id, requested, configuration)); 3209 3210 3211 /* Set the request and the data pointers. 3212 * Request takes: 36 bytes (32 bit SGE) 3213 * SCSI Device Page 1 requires 16 bytes 3214 * 40 + 16 <= size of SCSI IO Request = 56 bytes 3215 * and MF size >= 64 bytes. 3216 * Place data at end of MF. 3217 */ 3218 pReq = (Config_t *)mf; 3219 3220 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 3221 frameOffset = ioc->req_sz - sizeof(SCSIDevicePage1_t); 3222 3223 pData = (SCSIDevicePage1_t *)((u8 *) mf + frameOffset); 3224 dataDma = ioc->req_frames_dma + (req_idx * ioc->req_sz) + frameOffset; 3225 3226 /* Complete the request frame (same for all requests). 3227 */ 3228 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 3229 pReq->Reserved = 0; 3230 pReq->ChainOffset = 0; 3231 pReq->Function = MPI_FUNCTION_CONFIG; 3232 pReq->ExtPageLength = 0; 3233 pReq->ExtPageType = 0; 3234 pReq->MsgFlags = 0; 3235 for (ii=0; ii < 8; ii++) { 3236 pReq->Reserved2[ii] = 0; 3237 } 3238 pReq->Header.PageVersion = ioc->spi_data.sdp1version; 3239 pReq->Header.PageLength = ioc->spi_data.sdp1length; 3240 pReq->Header.PageNumber = 1; 3241 pReq->Header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 3242 pReq->PageAddress = cpu_to_le32(id | (bus << 8 )); 3243 3244 /* Add a SGE to the config request. 3245 */ 3246 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE | ioc->spi_data.sdp1length * 4; 3247 3248 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma); 3249 3250 /* Set up the common data portion 3251 */ 3252 pData->Header.PageVersion = pReq->Header.PageVersion; 3253 pData->Header.PageLength = pReq->Header.PageLength; 3254 pData->Header.PageNumber = pReq->Header.PageNumber; 3255 pData->Header.PageType = pReq->Header.PageType; 3256 pData->RequestedParameters = cpu_to_le32(requested); 3257 pData->Reserved = 0; 3258 pData->Configuration = cpu_to_le32(configuration); 3259 3260 dprintk((MYIOC_s_INFO_FMT 3261 "write SDP1: id %d pgaddr 0x%x req 0x%x config 0x%x\n", 3262 ioc->name, id, (id | (bus<<8)), 3263 requested, configuration)); 3264 3265 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf); 3266 } 3267 3268 return 0; 3269 } 3270 3271 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3272 /* mptscsih_writeIOCPage4 - write IOC Page 4 3273 * @hd: Pointer to a SCSI Host Structure 3274 * @target_id: write IOC Page4 for this ID & Bus 3275 * 3276 * Return: -EAGAIN if unable to obtain a Message Frame 3277 * or 0 if success. 3278 * 3279 * Remark: We do not wait for a return, write pages sequentially. 3280 */ 3281 static int 3282 mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus) 3283 { 3284 MPT_ADAPTER *ioc = hd->ioc; 3285 Config_t *pReq; 3286 IOCPage4_t *IOCPage4Ptr; 3287 MPT_FRAME_HDR *mf; 3288 dma_addr_t dataDma; 3289 u16 req_idx; 3290 u32 frameOffset; 3291 u32 flagsLength; 3292 int ii; 3293 3294 /* Get a MF for this command. 3295 */ 3296 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) { 3297 dprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n", 3298 ioc->name)); 3299 return -EAGAIN; 3300 } 3301 3302 /* Set the request and the data pointers. 3303 * Place data at end of MF. 3304 */ 3305 pReq = (Config_t *)mf; 3306 3307 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 3308 frameOffset = ioc->req_sz - sizeof(IOCPage4_t); 3309 3310 /* Complete the request frame (same for all requests). 3311 */ 3312 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 3313 pReq->Reserved = 0; 3314 pReq->ChainOffset = 0; 3315 pReq->Function = MPI_FUNCTION_CONFIG; 3316 pReq->ExtPageLength = 0; 3317 pReq->ExtPageType = 0; 3318 pReq->MsgFlags = 0; 3319 for (ii=0; ii < 8; ii++) { 3320 pReq->Reserved2[ii] = 0; 3321 } 3322 3323 IOCPage4Ptr = ioc->spi_data.pIocPg4; 3324 dataDma = ioc->spi_data.IocPg4_dma; 3325 ii = IOCPage4Ptr->ActiveSEP++; 3326 IOCPage4Ptr->SEP[ii].SEPTargetID = target_id; 3327 IOCPage4Ptr->SEP[ii].SEPBus = bus; 3328 pReq->Header = IOCPage4Ptr->Header; 3329 pReq->PageAddress = cpu_to_le32(target_id | (bus << 8 )); 3330 3331 /* Add a SGE to the config request. 3332 */ 3333 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE | 3334 (IOCPage4Ptr->Header.PageLength + ii) * 4; 3335 3336 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma); 3337 3338 dinitprintk((MYIOC_s_INFO_FMT 3339 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n", 3340 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, target_id, bus)); 3341 3342 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf); 3343 3344 return 0; 3345 } 3346 3347 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3348 /* 3349 * Bus Scan and Domain Validation functionality ... 3350 */ 3351 3352 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3353 /* 3354 * mptscsih_scandv_complete - Scan and DV callback routine registered 3355 * to Fustion MPT (base) driver. 3356 * 3357 * @ioc: Pointer to MPT_ADAPTER structure 3358 * @mf: Pointer to original MPT request frame 3359 * @mr: Pointer to MPT reply frame (NULL if TurboReply) 3360 * 3361 * This routine is called from mpt.c::mpt_interrupt() at the completion 3362 * of any SCSI IO request. 3363 * This routine is registered with the Fusion MPT (base) driver at driver 3364 * load/init time via the mpt_register() API call. 3365 * 3366 * Returns 1 indicating alloc'd request frame ptr should be freed. 3367 * 3368 * Remark: Sets a completion code and (possibly) saves sense data 3369 * in the IOC member localReply structure. 3370 * Used ONLY for DV and other internal commands. 3371 */ 3372 int 3373 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) 3374 { 3375 MPT_SCSI_HOST *hd; 3376 SCSIIORequest_t *pReq; 3377 int completionCode; 3378 u16 req_idx; 3379 3380 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata; 3381 3382 if ((mf == NULL) || 3383 (mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))) { 3384 printk(MYIOC_s_ERR_FMT 3385 "ScanDvComplete, %s req frame ptr! (=%p)\n", 3386 ioc->name, mf?"BAD":"NULL", (void *) mf); 3387 goto wakeup; 3388 } 3389 3390 del_timer(&hd->timer); 3391 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 3392 hd->ScsiLookup[req_idx] = NULL; 3393 pReq = (SCSIIORequest_t *) mf; 3394 3395 if (mf != hd->cmdPtr) { 3396 printk(MYIOC_s_WARN_FMT "ScanDvComplete (mf=%p, cmdPtr=%p, idx=%d)\n", 3397 hd->ioc->name, (void *)mf, (void *) hd->cmdPtr, req_idx); 3398 } 3399 hd->cmdPtr = NULL; 3400 3401 ddvprintk((MYIOC_s_INFO_FMT "ScanDvComplete (mf=%p,mr=%p,idx=%d)\n", 3402 hd->ioc->name, mf, mr, req_idx)); 3403 3404 hd->pLocal = &hd->localReply; 3405 hd->pLocal->scsiStatus = 0; 3406 3407 /* If target struct exists, clear sense valid flag. 3408 */ 3409 if (mr == NULL) { 3410 completionCode = MPT_SCANDV_GOOD; 3411 } else { 3412 SCSIIOReply_t *pReply; 3413 u16 status; 3414 u8 scsi_status; 3415 3416 pReply = (SCSIIOReply_t *) mr; 3417 3418 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK; 3419 scsi_status = pReply->SCSIStatus; 3420 3421 ddvtprintk((KERN_NOTICE " IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh, IOCLogInfo=%08xh\n", 3422 status, pReply->SCSIState, scsi_status, 3423 le32_to_cpu(pReply->IOCLogInfo))); 3424 3425 switch(status) { 3426 3427 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */ 3428 completionCode = MPT_SCANDV_SELECTION_TIMEOUT; 3429 break; 3430 3431 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */ 3432 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */ 3433 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */ 3434 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */ 3435 completionCode = MPT_SCANDV_DID_RESET; 3436 break; 3437 3438 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */ 3439 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */ 3440 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */ 3441 if (pReply->Function == MPI_FUNCTION_CONFIG) { 3442 ConfigReply_t *pr = (ConfigReply_t *)mr; 3443 completionCode = MPT_SCANDV_GOOD; 3444 hd->pLocal->header.PageVersion = pr->Header.PageVersion; 3445 hd->pLocal->header.PageLength = pr->Header.PageLength; 3446 hd->pLocal->header.PageNumber = pr->Header.PageNumber; 3447 hd->pLocal->header.PageType = pr->Header.PageType; 3448 3449 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) { 3450 /* If the RAID Volume request is successful, 3451 * return GOOD, else indicate that 3452 * some type of error occurred. 3453 */ 3454 MpiRaidActionReply_t *pr = (MpiRaidActionReply_t *)mr; 3455 if (pr->ActionStatus == MPI_RAID_ACTION_ASTATUS_SUCCESS) 3456 completionCode = MPT_SCANDV_GOOD; 3457 else 3458 completionCode = MPT_SCANDV_SOME_ERROR; 3459 3460 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) { 3461 u8 *sense_data; 3462 int sz; 3463 3464 /* save sense data in global structure 3465 */ 3466 completionCode = MPT_SCANDV_SENSE; 3467 hd->pLocal->scsiStatus = scsi_status; 3468 sense_data = ((u8 *)hd->ioc->sense_buf_pool + 3469 (req_idx * MPT_SENSE_BUFFER_ALLOC)); 3470 3471 sz = min_t(int, pReq->SenseBufferLength, 3472 SCSI_STD_SENSE_BYTES); 3473 memcpy(hd->pLocal->sense, sense_data, sz); 3474 3475 ddvprintk((KERN_NOTICE " Check Condition, sense ptr %p\n", 3476 sense_data)); 3477 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) { 3478 if (pReq->CDB[0] == INQUIRY) 3479 completionCode = MPT_SCANDV_ISSUE_SENSE; 3480 else 3481 completionCode = MPT_SCANDV_DID_RESET; 3482 } 3483 else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS) 3484 completionCode = MPT_SCANDV_DID_RESET; 3485 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED) 3486 completionCode = MPT_SCANDV_DID_RESET; 3487 else { 3488 completionCode = MPT_SCANDV_GOOD; 3489 hd->pLocal->scsiStatus = scsi_status; 3490 } 3491 break; 3492 3493 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */ 3494 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED) 3495 completionCode = MPT_SCANDV_DID_RESET; 3496 else 3497 completionCode = MPT_SCANDV_SOME_ERROR; 3498 break; 3499 3500 default: 3501 completionCode = MPT_SCANDV_SOME_ERROR; 3502 break; 3503 3504 } /* switch(status) */ 3505 3506 ddvtprintk((KERN_NOTICE " completionCode set to %08xh\n", 3507 completionCode)); 3508 } /* end of address reply case */ 3509 3510 hd->pLocal->completion = completionCode; 3511 3512 /* MF and RF are freed in mpt_interrupt 3513 */ 3514 wakeup: 3515 /* Free Chain buffers (will never chain) in scan or dv */ 3516 //mptscsih_freeChainBuffers(ioc, req_idx); 3517 3518 /* 3519 * Wake up the original calling thread 3520 */ 3521 hd->scandv_wait_done = 1; 3522 wake_up(&hd->scandv_waitq); 3523 3524 return 1; 3525 } 3526 3527 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3528 /* mptscsih_timer_expired - Call back for timer process. 3529 * Used only for dv functionality. 3530 * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long 3531 * 3532 */ 3533 void 3534 mptscsih_timer_expired(unsigned long data) 3535 { 3536 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) data; 3537 3538 ddvprintk((MYIOC_s_WARN_FMT "Timer Expired! Cmd %p\n", hd->ioc->name, hd->cmdPtr)); 3539 3540 if (hd->cmdPtr) { 3541 MPIHeader_t *cmd = (MPIHeader_t *)hd->cmdPtr; 3542 3543 if (cmd->Function == MPI_FUNCTION_SCSI_IO_REQUEST) { 3544 /* Desire to issue a task management request here. 3545 * TM requests MUST be single threaded. 3546 * If old eh code and no TM current, issue request. 3547 * If new eh code, do nothing. Wait for OS cmd timeout 3548 * for bus reset. 3549 */ 3550 ddvtprintk((MYIOC_s_NOTE_FMT "DV Cmd Timeout: NoOp\n", hd->ioc->name)); 3551 } else { 3552 /* Perform a FW reload */ 3553 if (mpt_HardResetHandler(hd->ioc, NO_SLEEP) < 0) { 3554 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", hd->ioc->name); 3555 } 3556 } 3557 } else { 3558 /* This should NEVER happen */ 3559 printk(MYIOC_s_WARN_FMT "Null cmdPtr!!!!\n", hd->ioc->name); 3560 } 3561 3562 /* No more processing. 3563 * TM call will generate an interrupt for SCSI TM Management. 3564 * The FW will reply to all outstanding commands, callback will finish cleanup. 3565 * Hard reset clean-up will free all resources. 3566 */ 3567 ddvprintk((MYIOC_s_WARN_FMT "Timer Expired Complete!\n", hd->ioc->name)); 3568 3569 return; 3570 } 3571 3572 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 3573 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3574 /* mptscsih_do_raid - Format and Issue a RAID volume request message. 3575 * @hd: Pointer to scsi host structure 3576 * @action: What do be done. 3577 * @id: Logical target id. 3578 * @bus: Target locations bus. 3579 * 3580 * Returns: < 0 on a fatal error 3581 * 0 on success 3582 * 3583 * Remark: Wait to return until reply processed by the ISR. 3584 */ 3585 static int 3586 mptscsih_do_raid(MPT_SCSI_HOST *hd, u8 action, INTERNAL_CMD *io) 3587 { 3588 MpiRaidActionRequest_t *pReq; 3589 MPT_FRAME_HDR *mf; 3590 int in_isr; 3591 3592 in_isr = in_interrupt(); 3593 if (in_isr) { 3594 dprintk((MYIOC_s_WARN_FMT "Internal raid request not allowed in ISR context!\n", 3595 hd->ioc->name)); 3596 return -EPERM; 3597 } 3598 3599 /* Get and Populate a free Frame 3600 */ 3601 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) { 3602 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n", 3603 hd->ioc->name)); 3604 return -EAGAIN; 3605 } 3606 pReq = (MpiRaidActionRequest_t *)mf; 3607 pReq->Action = action; 3608 pReq->Reserved1 = 0; 3609 pReq->ChainOffset = 0; 3610 pReq->Function = MPI_FUNCTION_RAID_ACTION; 3611 pReq->VolumeID = io->id; 3612 pReq->VolumeBus = io->bus; 3613 pReq->PhysDiskNum = io->physDiskNum; 3614 pReq->MsgFlags = 0; 3615 pReq->Reserved2 = 0; 3616 pReq->ActionDataWord = 0; /* Reserved for this action */ 3617 //pReq->ActionDataSGE = 0; 3618 3619 mpt_add_sge((char *)&pReq->ActionDataSGE, 3620 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1); 3621 3622 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action %x id %d\n", 3623 hd->ioc->name, action, io->id)); 3624 3625 hd->pLocal = NULL; 3626 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */ 3627 hd->scandv_wait_done = 0; 3628 3629 /* Save cmd pointer, for resource free if timeout or 3630 * FW reload occurs 3631 */ 3632 hd->cmdPtr = mf; 3633 3634 add_timer(&hd->timer); 3635 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf); 3636 wait_event(hd->scandv_waitq, hd->scandv_wait_done); 3637 3638 if ((hd->pLocal == NULL) || (hd->pLocal->completion != MPT_SCANDV_GOOD)) 3639 return -1; 3640 3641 return 0; 3642 } 3643 #endif /* ~MPTSCSIH_ENABLE_DOMAIN_VALIDATION */ 3644 3645 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3646 /** 3647 * mptscsih_do_cmd - Do internal command. 3648 * @hd: MPT_SCSI_HOST pointer 3649 * @io: INTERNAL_CMD pointer. 3650 * 3651 * Issue the specified internally generated command and do command 3652 * specific cleanup. For bus scan / DV only. 3653 * NOTES: If command is Inquiry and status is good, 3654 * initialize a target structure, save the data 3655 * 3656 * Remark: Single threaded access only. 3657 * 3658 * Return: 3659 * < 0 if an illegal command or no resources 3660 * 3661 * 0 if good 3662 * 3663 * > 0 if command complete but some type of completion error. 3664 */ 3665 static int 3666 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io) 3667 { 3668 MPT_FRAME_HDR *mf; 3669 SCSIIORequest_t *pScsiReq; 3670 SCSIIORequest_t ReqCopy; 3671 int my_idx, ii, dir; 3672 int rc, cmdTimeout; 3673 int in_isr; 3674 char cmdLen; 3675 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 3676 char cmd = io->cmd; 3677 3678 in_isr = in_interrupt(); 3679 if (in_isr) { 3680 dprintk((MYIOC_s_WARN_FMT "Internal SCSI IO request not allowed in ISR context!\n", 3681 hd->ioc->name)); 3682 return -EPERM; 3683 } 3684 3685 3686 /* Set command specific information 3687 */ 3688 switch (cmd) { 3689 case INQUIRY: 3690 cmdLen = 6; 3691 dir = MPI_SCSIIO_CONTROL_READ; 3692 CDB[0] = cmd; 3693 CDB[4] = io->size; 3694 cmdTimeout = 10; 3695 break; 3696 3697 case TEST_UNIT_READY: 3698 cmdLen = 6; 3699 dir = MPI_SCSIIO_CONTROL_READ; 3700 cmdTimeout = 10; 3701 break; 3702 3703 case START_STOP: 3704 cmdLen = 6; 3705 dir = MPI_SCSIIO_CONTROL_READ; 3706 CDB[0] = cmd; 3707 CDB[4] = 1; /*Spin up the disk */ 3708 cmdTimeout = 15; 3709 break; 3710 3711 case REQUEST_SENSE: 3712 cmdLen = 6; 3713 CDB[0] = cmd; 3714 CDB[4] = io->size; 3715 dir = MPI_SCSIIO_CONTROL_READ; 3716 cmdTimeout = 10; 3717 break; 3718 3719 case READ_BUFFER: 3720 cmdLen = 10; 3721 dir = MPI_SCSIIO_CONTROL_READ; 3722 CDB[0] = cmd; 3723 if (io->flags & MPT_ICFLAG_ECHO) { 3724 CDB[1] = 0x0A; 3725 } else { 3726 CDB[1] = 0x02; 3727 } 3728 3729 if (io->flags & MPT_ICFLAG_BUF_CAP) { 3730 CDB[1] |= 0x01; 3731 } 3732 CDB[6] = (io->size >> 16) & 0xFF; 3733 CDB[7] = (io->size >> 8) & 0xFF; 3734 CDB[8] = io->size & 0xFF; 3735 cmdTimeout = 10; 3736 break; 3737 3738 case WRITE_BUFFER: 3739 cmdLen = 10; 3740 dir = MPI_SCSIIO_CONTROL_WRITE; 3741 CDB[0] = cmd; 3742 if (io->flags & MPT_ICFLAG_ECHO) { 3743 CDB[1] = 0x0A; 3744 } else { 3745 CDB[1] = 0x02; 3746 } 3747 CDB[6] = (io->size >> 16) & 0xFF; 3748 CDB[7] = (io->size >> 8) & 0xFF; 3749 CDB[8] = io->size & 0xFF; 3750 cmdTimeout = 10; 3751 break; 3752 3753 case RESERVE: 3754 cmdLen = 6; 3755 dir = MPI_SCSIIO_CONTROL_READ; 3756 CDB[0] = cmd; 3757 cmdTimeout = 10; 3758 break; 3759 3760 case RELEASE: 3761 cmdLen = 6; 3762 dir = MPI_SCSIIO_CONTROL_READ; 3763 CDB[0] = cmd; 3764 cmdTimeout = 10; 3765 break; 3766 3767 case SYNCHRONIZE_CACHE: 3768 cmdLen = 10; 3769 dir = MPI_SCSIIO_CONTROL_READ; 3770 CDB[0] = cmd; 3771 // CDB[1] = 0x02; /* set immediate bit */ 3772 cmdTimeout = 10; 3773 break; 3774 3775 default: 3776 /* Error Case */ 3777 return -EFAULT; 3778 } 3779 3780 /* Get and Populate a free Frame 3781 */ 3782 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) { 3783 ddvprintk((MYIOC_s_WARN_FMT "No msg frames!\n", 3784 hd->ioc->name)); 3785 return -EBUSY; 3786 } 3787 3788 pScsiReq = (SCSIIORequest_t *) mf; 3789 3790 /* Get the request index */ 3791 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx); 3792 ADD_INDEX_LOG(my_idx); /* for debug */ 3793 3794 if (io->flags & MPT_ICFLAG_PHYS_DISK) { 3795 pScsiReq->TargetID = io->physDiskNum; 3796 pScsiReq->Bus = 0; 3797 pScsiReq->ChainOffset = 0; 3798 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH; 3799 } else { 3800 pScsiReq->TargetID = io->id; 3801 pScsiReq->Bus = io->bus; 3802 pScsiReq->ChainOffset = 0; 3803 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST; 3804 } 3805 3806 pScsiReq->CDBLength = cmdLen; 3807 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE; 3808 3809 pScsiReq->Reserved = 0; 3810 3811 pScsiReq->MsgFlags = mpt_msg_flags(); 3812 /* MsgContext set in mpt_get_msg_fram call */ 3813 3814 for (ii=0; ii < 8; ii++) 3815 pScsiReq->LUN[ii] = 0; 3816 pScsiReq->LUN[1] = io->lun; 3817 3818 if (io->flags & MPT_ICFLAG_TAGGED_CMD) 3819 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ); 3820 else 3821 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED); 3822 3823 if (cmd == REQUEST_SENSE) { 3824 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED); 3825 ddvprintk((MYIOC_s_INFO_FMT "Untagged! 0x%2x\n", 3826 hd->ioc->name, cmd)); 3827 } 3828 3829 for (ii=0; ii < 16; ii++) 3830 pScsiReq->CDB[ii] = CDB[ii]; 3831 3832 pScsiReq->DataLength = cpu_to_le32(io->size); 3833 pScsiReq->SenseBufferLowAddr = cpu_to_le32(hd->ioc->sense_buf_low_dma 3834 + (my_idx * MPT_SENSE_BUFFER_ALLOC)); 3835 3836 ddvprintk((MYIOC_s_INFO_FMT "Sending Command 0x%x for (%d:%d:%d)\n", 3837 hd->ioc->name, cmd, io->bus, io->id, io->lun)); 3838 3839 if (dir == MPI_SCSIIO_CONTROL_READ) { 3840 mpt_add_sge((char *) &pScsiReq->SGL, 3841 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, 3842 io->data_dma); 3843 } else { 3844 mpt_add_sge((char *) &pScsiReq->SGL, 3845 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, 3846 io->data_dma); 3847 } 3848 3849 /* The ISR will free the request frame, but we need 3850 * the information to initialize the target. Duplicate. 3851 */ 3852 memcpy(&ReqCopy, pScsiReq, sizeof(SCSIIORequest_t)); 3853 3854 /* Issue this command after: 3855 * finish init 3856 * add timer 3857 * Wait until the reply has been received 3858 * ScsiScanDvCtx callback function will 3859 * set hd->pLocal; 3860 * set scandv_wait_done and call wake_up 3861 */ 3862 hd->pLocal = NULL; 3863 hd->timer.expires = jiffies + HZ*cmdTimeout; 3864 hd->scandv_wait_done = 0; 3865 3866 /* Save cmd pointer, for resource free if timeout or 3867 * FW reload occurs 3868 */ 3869 hd->cmdPtr = mf; 3870 3871 add_timer(&hd->timer); 3872 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf); 3873 wait_event(hd->scandv_waitq, hd->scandv_wait_done); 3874 3875 if (hd->pLocal) { 3876 rc = hd->pLocal->completion; 3877 hd->pLocal->skip = 0; 3878 3879 /* Always set fatal error codes in some cases. 3880 */ 3881 if (rc == MPT_SCANDV_SELECTION_TIMEOUT) 3882 rc = -ENXIO; 3883 else if (rc == MPT_SCANDV_SOME_ERROR) 3884 rc = -rc; 3885 } else { 3886 rc = -EFAULT; 3887 /* This should never happen. */ 3888 ddvprintk((MYIOC_s_INFO_FMT "_do_cmd: Null pLocal!!!\n", 3889 hd->ioc->name)); 3890 } 3891 3892 return rc; 3893 } 3894 3895 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 3896 /** 3897 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks. 3898 * @hd: Pointer to MPT_SCSI_HOST structure 3899 * @portnum: IOC port number 3900 * 3901 * Uses the ISR, but with special processing. 3902 * MUST be single-threaded. 3903 * 3904 * Return: 0 on completion 3905 */ 3906 static int 3907 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, int portnum) 3908 { 3909 MPT_ADAPTER *ioc= hd->ioc; 3910 VirtDevice *pTarget; 3911 SCSIDevicePage1_t *pcfg1Data = NULL; 3912 INTERNAL_CMD iocmd; 3913 CONFIGPARMS cfg; 3914 dma_addr_t cfg1_dma_addr = -1; 3915 ConfigPageHeader_t header1; 3916 int bus = 0; 3917 int id = 0; 3918 int lun; 3919 int indexed_lun, lun_index; 3920 int hostId = ioc->pfacts[portnum].PortSCSIID; 3921 int max_id; 3922 int requested, configuration, data; 3923 int doConfig = 0; 3924 u8 flags, factor; 3925 3926 max_id = ioc->sh->max_id - 1; 3927 3928 /* Following parameters will not change 3929 * in this routine. 3930 */ 3931 iocmd.cmd = SYNCHRONIZE_CACHE; 3932 iocmd.flags = 0; 3933 iocmd.physDiskNum = -1; 3934 iocmd.data = NULL; 3935 iocmd.data_dma = -1; 3936 iocmd.size = 0; 3937 iocmd.rsvd = iocmd.rsvd2 = 0; 3938 3939 /* No SCSI hosts 3940 */ 3941 if (hd->Targets == NULL) 3942 return 0; 3943 3944 /* Skip the host 3945 */ 3946 if (id == hostId) 3947 id++; 3948 3949 /* Write SDP1 for all SCSI devices 3950 * Alloc memory and set up config buffer 3951 */ 3952 if (ioc->bus_type == SCSI) { 3953 if (ioc->spi_data.sdp1length > 0) { 3954 pcfg1Data = (SCSIDevicePage1_t *)pci_alloc_consistent(ioc->pcidev, 3955 ioc->spi_data.sdp1length * 4, &cfg1_dma_addr); 3956 3957 if (pcfg1Data != NULL) { 3958 doConfig = 1; 3959 header1.PageVersion = ioc->spi_data.sdp1version; 3960 header1.PageLength = ioc->spi_data.sdp1length; 3961 header1.PageNumber = 1; 3962 header1.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 3963 cfg.hdr = &header1; 3964 cfg.physAddr = cfg1_dma_addr; 3965 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 3966 cfg.dir = 1; 3967 cfg.timeout = 0; 3968 } 3969 } 3970 } 3971 3972 /* loop through all devices on this port 3973 */ 3974 while (bus < MPT_MAX_BUS) { 3975 iocmd.bus = bus; 3976 iocmd.id = id; 3977 pTarget = hd->Targets[(int)id]; 3978 3979 if (doConfig) { 3980 3981 /* Set the negotiation flags */ 3982 if (pTarget && (pTarget = hd->Targets[id]) && !pTarget->raidVolume) { 3983 flags = pTarget->negoFlags; 3984 } else { 3985 flags = hd->ioc->spi_data.noQas; 3986 if (hd->ioc->spi_data.nvram && (hd->ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) { 3987 data = hd->ioc->spi_data.nvram[id]; 3988 3989 if (data & MPT_NVRAM_WIDE_DISABLE) 3990 flags |= MPT_TARGET_NO_NEGO_WIDE; 3991 3992 factor = (data & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT; 3993 if ((factor == 0) || (factor == MPT_ASYNC)) 3994 flags |= MPT_TARGET_NO_NEGO_SYNC; 3995 } 3996 } 3997 3998 /* Force to async, narrow */ 3999 mptscsih_setDevicePage1Flags(0, MPT_ASYNC, 0, &requested, 4000 &configuration, flags); 4001 dnegoprintk(("syncronize cache: id=%d width=0 factor=MPT_ASYNC " 4002 "offset=0 negoFlags=%x request=%x config=%x\n", 4003 id, flags, requested, configuration)); 4004 pcfg1Data->RequestedParameters = le32_to_cpu(requested); 4005 pcfg1Data->Reserved = 0; 4006 pcfg1Data->Configuration = le32_to_cpu(configuration); 4007 cfg.pageAddr = (bus<<8) | id; 4008 mpt_config(hd->ioc, &cfg); 4009 } 4010 4011 /* If target Ptr NULL or if this target is NOT a disk, skip. 4012 */ 4013 if ((pTarget) && (pTarget->tflags & MPT_TARGET_FLAGS_Q_YES)){ 4014 for (lun=0; lun <= MPT_LAST_LUN; lun++) { 4015 /* If LUN present, issue the command 4016 */ 4017 lun_index = (lun >> 5); /* 32 luns per lun_index */ 4018 indexed_lun = (lun % 32); 4019 if (pTarget->luns[lun_index] & (1<<indexed_lun)) { 4020 iocmd.lun = lun; 4021 (void) mptscsih_do_cmd(hd, &iocmd); 4022 } 4023 } 4024 } 4025 4026 /* get next relevant device */ 4027 id++; 4028 4029 if (id == hostId) 4030 id++; 4031 4032 if (id > max_id) { 4033 id = 0; 4034 bus++; 4035 } 4036 } 4037 4038 if (pcfg1Data) { 4039 pci_free_consistent(ioc->pcidev, header1.PageLength * 4, pcfg1Data, cfg1_dma_addr); 4040 } 4041 4042 return 0; 4043 } 4044 4045 #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION 4046 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 4047 /** 4048 * mptscsih_domainValidation - Top level handler for domain validation. 4049 * @hd: Pointer to MPT_SCSI_HOST structure. 4050 * 4051 * Uses the ISR, but with special processing. 4052 * Called from schedule, should not be in interrupt mode. 4053 * While thread alive, do dv for all devices needing dv 4054 * 4055 * Return: None. 4056 */ 4057 static void 4058 mptscsih_domainValidation(void *arg) 4059 { 4060 MPT_SCSI_HOST *hd; 4061 MPT_ADAPTER *ioc; 4062 unsigned long flags; 4063 int id, maxid, dvStatus, did; 4064 int ii, isPhysDisk; 4065 4066 spin_lock_irqsave(&dvtaskQ_lock, flags); 4067 dvtaskQ_active = 1; 4068 if (dvtaskQ_release) { 4069 dvtaskQ_active = 0; 4070 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 4071 return; 4072 } 4073 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 4074 4075 /* For this ioc, loop through all devices and do dv to each device. 4076 * When complete with this ioc, search through the ioc list, and 4077 * for each scsi ioc found, do dv for all devices. Exit when no 4078 * device needs dv. 4079 */ 4080 did = 1; 4081 while (did) { 4082 did = 0; 4083 list_for_each_entry(ioc, &ioc_list, list) { 4084 spin_lock_irqsave(&dvtaskQ_lock, flags); 4085 if (dvtaskQ_release) { 4086 dvtaskQ_active = 0; 4087 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 4088 return; 4089 } 4090 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 4091 4092 msleep(250); 4093 4094 /* DV only to SCSI adapters */ 4095 if (ioc->bus_type != SCSI) 4096 continue; 4097 4098 /* Make sure everything looks ok */ 4099 if (ioc->sh == NULL) 4100 continue; 4101 4102 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata; 4103 if (hd == NULL) 4104 continue; 4105 4106 if ((ioc->spi_data.forceDv & MPT_SCSICFG_RELOAD_IOC_PG3) != 0) { 4107 mpt_read_ioc_pg_3(ioc); 4108 if (ioc->spi_data.pIocPg3) { 4109 Ioc3PhysDisk_t *pPDisk = ioc->spi_data.pIocPg3->PhysDisk; 4110 int numPDisk = ioc->spi_data.pIocPg3->NumPhysDisks; 4111 4112 while (numPDisk) { 4113 if (ioc->spi_data.dvStatus[pPDisk->PhysDiskID] & MPT_SCSICFG_DV_NOT_DONE) 4114 ioc->spi_data.dvStatus[pPDisk->PhysDiskID] |= MPT_SCSICFG_NEED_DV; 4115 4116 pPDisk++; 4117 numPDisk--; 4118 } 4119 } 4120 ioc->spi_data.forceDv &= ~MPT_SCSICFG_RELOAD_IOC_PG3; 4121 } 4122 4123 maxid = min_t(int, ioc->sh->max_id, MPT_MAX_SCSI_DEVICES); 4124 4125 for (id = 0; id < maxid; id++) { 4126 spin_lock_irqsave(&dvtaskQ_lock, flags); 4127 if (dvtaskQ_release) { 4128 dvtaskQ_active = 0; 4129 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 4130 return; 4131 } 4132 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 4133 dvStatus = hd->ioc->spi_data.dvStatus[id]; 4134 4135 if (dvStatus & MPT_SCSICFG_NEED_DV) { 4136 did++; 4137 hd->ioc->spi_data.dvStatus[id] |= MPT_SCSICFG_DV_PENDING; 4138 hd->ioc->spi_data.dvStatus[id] &= ~MPT_SCSICFG_NEED_DV; 4139 4140 msleep(250); 4141 4142 /* If hidden phys disk, block IO's to all 4143 * raid volumes 4144 * else, process normally 4145 */ 4146 isPhysDisk = mptscsih_is_phys_disk(ioc, id); 4147 if (isPhysDisk) { 4148 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) { 4149 if (hd->ioc->spi_data.isRaid & (1 << ii)) { 4150 hd->ioc->spi_data.dvStatus[ii] |= MPT_SCSICFG_DV_PENDING; 4151 } 4152 } 4153 } 4154 4155 if (mptscsih_doDv(hd, 0, id) == 1) { 4156 /* Untagged device was busy, try again 4157 */ 4158 hd->ioc->spi_data.dvStatus[id] |= MPT_SCSICFG_NEED_DV; 4159 hd->ioc->spi_data.dvStatus[id] &= ~MPT_SCSICFG_DV_PENDING; 4160 } else { 4161 /* DV is complete. Clear flags. 4162 */ 4163 hd->ioc->spi_data.dvStatus[id] &= ~(MPT_SCSICFG_DV_NOT_DONE | MPT_SCSICFG_DV_PENDING); 4164 } 4165 4166 if (isPhysDisk) { 4167 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) { 4168 if (hd->ioc->spi_data.isRaid & (1 << ii)) { 4169 hd->ioc->spi_data.dvStatus[ii] &= ~MPT_SCSICFG_DV_PENDING; 4170 } 4171 } 4172 } 4173 4174 if (hd->ioc->spi_data.noQas) 4175 mptscsih_qas_check(hd, id); 4176 } 4177 } 4178 } 4179 } 4180 4181 spin_lock_irqsave(&dvtaskQ_lock, flags); 4182 dvtaskQ_active = 0; 4183 spin_unlock_irqrestore(&dvtaskQ_lock, flags); 4184 4185 return; 4186 } 4187 4188 /* Search IOC page 3 to determine if this is hidden physical disk 4189 */ 4190 static int 4191 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id) 4192 { 4193 if (ioc->spi_data.pIocPg3) { 4194 Ioc3PhysDisk_t *pPDisk = ioc->spi_data.pIocPg3->PhysDisk; 4195 int numPDisk = ioc->spi_data.pIocPg3->NumPhysDisks; 4196 4197 while (numPDisk) { 4198 if (pPDisk->PhysDiskID == id) { 4199 return 1; 4200 } 4201 pPDisk++; 4202 numPDisk--; 4203 } 4204 } 4205 return 0; 4206 } 4207 4208 /* Write SDP1 if no QAS has been enabled 4209 */ 4210 static void 4211 mptscsih_qas_check(MPT_SCSI_HOST *hd, int id) 4212 { 4213 VirtDevice *pTarget; 4214 int ii; 4215 4216 if (hd->Targets == NULL) 4217 return; 4218 4219 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) { 4220 if (ii == id) 4221 continue; 4222 4223 if ((hd->ioc->spi_data.dvStatus[ii] & MPT_SCSICFG_DV_NOT_DONE) != 0) 4224 continue; 4225 4226 pTarget = hd->Targets[ii]; 4227 4228 if ((pTarget != NULL) && (!pTarget->raidVolume)) { 4229 if ((pTarget->negoFlags & hd->ioc->spi_data.noQas) == 0) { 4230 pTarget->negoFlags |= hd->ioc->spi_data.noQas; 4231 dnegoprintk(("writeSDP1: id=%d flags=0\n", id)); 4232 mptscsih_writeSDP1(hd, 0, ii, 0); 4233 } 4234 } else { 4235 if (mptscsih_is_phys_disk(hd->ioc, ii) == 1) { 4236 dnegoprintk(("writeSDP1: id=%d SCSICFG_USE_NVRAM\n", id)); 4237 mptscsih_writeSDP1(hd, 0, ii, MPT_SCSICFG_USE_NVRAM); 4238 } 4239 } 4240 } 4241 return; 4242 } 4243 4244 4245 4246 #define MPT_GET_NVRAM_VALS 0x01 4247 #define MPT_UPDATE_MAX 0x02 4248 #define MPT_SET_MAX 0x04 4249 #define MPT_SET_MIN 0x08 4250 #define MPT_FALLBACK 0x10 4251 #define MPT_SAVE 0x20 4252 4253 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 4254 /** 4255 * mptscsih_doDv - Perform domain validation to a target. 4256 * @hd: Pointer to MPT_SCSI_HOST structure. 4257 * @portnum: IOC port number. 4258 * @target: Physical ID of this target 4259 * 4260 * Uses the ISR, but with special processing. 4261 * MUST be single-threaded. 4262 * Test will exit if target is at async & narrow. 4263 * 4264 * Return: None. 4265 */ 4266 static int 4267 mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) 4268 { 4269 MPT_ADAPTER *ioc = hd->ioc; 4270 VirtDevice *pTarget; 4271 SCSIDevicePage1_t *pcfg1Data; 4272 SCSIDevicePage0_t *pcfg0Data; 4273 u8 *pbuf1; 4274 u8 *pbuf2; 4275 u8 *pDvBuf; 4276 dma_addr_t dvbuf_dma = -1; 4277 dma_addr_t buf1_dma = -1; 4278 dma_addr_t buf2_dma = -1; 4279 dma_addr_t cfg1_dma_addr = -1; 4280 dma_addr_t cfg0_dma_addr = -1; 4281 ConfigPageHeader_t header1; 4282 ConfigPageHeader_t header0; 4283 DVPARAMETERS dv; 4284 INTERNAL_CMD iocmd; 4285 CONFIGPARMS cfg; 4286 int dv_alloc = 0; 4287 int rc, sz = 0; 4288 int bufsize = 0; 4289 int dataBufSize = 0; 4290 int echoBufSize = 0; 4291 int notDone; 4292 int patt; 4293 int repeat; 4294 int retcode = 0; 4295 int nfactor = MPT_ULTRA320; 4296 char firstPass = 1; 4297 char doFallback = 0; 4298 char readPage0; 4299 char bus, lun; 4300 char inq0 = 0; 4301 4302 if (ioc->spi_data.sdp1length == 0) 4303 return 0; 4304 4305 if (ioc->spi_data.sdp0length == 0) 4306 return 0; 4307 4308 /* If multiple buses are used, require that the initiator 4309 * id be the same on all buses. 4310 */ 4311 if (id == ioc->pfacts[0].PortSCSIID) 4312 return 0; 4313 4314 lun = 0; 4315 bus = (u8) bus_number; 4316 ddvtprintk((MYIOC_s_NOTE_FMT 4317 "DV started: bus=%d, id=%d dv @ %p\n", 4318 ioc->name, bus, id, &dv)); 4319 4320 /* Prep DV structure 4321 */ 4322 memset (&dv, 0, sizeof(DVPARAMETERS)); 4323 dv.id = id; 4324 4325 /* Populate tmax with the current maximum 4326 * transfer parameters for this target. 4327 * Exit if narrow and async. 4328 */ 4329 dv.cmd = MPT_GET_NVRAM_VALS; 4330 mptscsih_dv_parms(hd, &dv, NULL); 4331 4332 /* Prep SCSI IO structure 4333 */ 4334 iocmd.id = id; 4335 iocmd.bus = bus; 4336 iocmd.lun = lun; 4337 iocmd.flags = 0; 4338 iocmd.physDiskNum = -1; 4339 iocmd.rsvd = iocmd.rsvd2 = 0; 4340 4341 pTarget = hd->Targets[id]; 4342 4343 /* Use tagged commands if possible. 4344 */ 4345 if (pTarget) { 4346 if (pTarget->tflags & MPT_TARGET_FLAGS_Q_YES) 4347 iocmd.flags |= MPT_ICFLAG_TAGGED_CMD; 4348 else { 4349 if (hd->ioc->facts.FWVersion.Word < 0x01000600) 4350 return 0; 4351 4352 if ((hd->ioc->facts.FWVersion.Word >= 0x01010000) && 4353 (hd->ioc->facts.FWVersion.Word < 0x01010B00)) 4354 return 0; 4355 } 4356 } 4357 4358 /* Prep cfg structure 4359 */ 4360 cfg.pageAddr = (bus<<8) | id; 4361 cfg.hdr = NULL; 4362 4363 /* Prep SDP0 header 4364 */ 4365 header0.PageVersion = ioc->spi_data.sdp0version; 4366 header0.PageLength = ioc->spi_data.sdp0length; 4367 header0.PageNumber = 0; 4368 header0.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 4369 4370 /* Prep SDP1 header 4371 */ 4372 header1.PageVersion = ioc->spi_data.sdp1version; 4373 header1.PageLength = ioc->spi_data.sdp1length; 4374 header1.PageNumber = 1; 4375 header1.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; 4376 4377 if (header0.PageLength & 1) 4378 dv_alloc = (header0.PageLength * 4) + 4; 4379 4380 dv_alloc += (2048 + (header1.PageLength * 4)); 4381 4382 pDvBuf = pci_alloc_consistent(ioc->pcidev, dv_alloc, &dvbuf_dma); 4383 if (pDvBuf == NULL) 4384 return 0; 4385 4386 sz = 0; 4387 pbuf1 = (u8 *)pDvBuf; 4388 buf1_dma = dvbuf_dma; 4389 sz +=1024; 4390 4391 pbuf2 = (u8 *) (pDvBuf + sz); 4392 buf2_dma = dvbuf_dma + sz; 4393 sz +=1024; 4394 4395 pcfg0Data = (SCSIDevicePage0_t *) (pDvBuf + sz); 4396 cfg0_dma_addr = dvbuf_dma + sz; 4397 sz += header0.PageLength * 4; 4398 4399 /* 8-byte alignment 4400 */ 4401 if (header0.PageLength & 1) 4402 sz += 4; 4403 4404 pcfg1Data = (SCSIDevicePage1_t *) (pDvBuf + sz); 4405 cfg1_dma_addr = dvbuf_dma + sz; 4406 4407 /* Skip this ID? Set cfg.hdr to force config page write 4408 */ 4409 { 4410 ScsiCfgData *pspi_data = &hd->ioc->spi_data; 4411 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) { 4412 /* Set the factor from nvram */ 4413 nfactor = (pspi_data->nvram[id] & MPT_NVRAM_SYNC_MASK) >> 8; 4414 if (nfactor < pspi_data->minSyncFactor ) 4415 nfactor = pspi_data->minSyncFactor; 4416 4417 if (!(pspi_data->nvram[id] & MPT_NVRAM_ID_SCAN_ENABLE) || 4418 (pspi_data->PortFlags == MPI_SCSIPORTPAGE2_PORT_FLAGS_OFF_DV) ) { 4419 4420 ddvprintk((MYIOC_s_NOTE_FMT "DV Skipped: bus, id, lun (%d, %d, %d)\n", 4421 ioc->name, bus, id, lun)); 4422 4423 dv.cmd = MPT_SET_MAX; 4424 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data); 4425 cfg.hdr = &header1; 4426 4427 /* Save the final negotiated settings to 4428 * SCSI device page 1. 4429 */ 4430 cfg.physAddr = cfg1_dma_addr; 4431 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 4432 cfg.dir = 1; 4433 mpt_config(hd->ioc, &cfg); 4434 goto target_done; 4435 } 4436 } 4437 } 4438 4439 /* Finish iocmd inititialization - hidden or visible disk? */ 4440 if (ioc->spi_data.pIocPg3) { 4441 /* Search IOC page 3 for matching id 4442 */ 4443 Ioc3PhysDisk_t *pPDisk = ioc->spi_data.pIocPg3->PhysDisk; 4444 int numPDisk = ioc->spi_data.pIocPg3->NumPhysDisks; 4445 4446 while (numPDisk) { 4447 if (pPDisk->PhysDiskID == id) { 4448 /* match */ 4449 iocmd.flags |= MPT_ICFLAG_PHYS_DISK; 4450 iocmd.physDiskNum = pPDisk->PhysDiskNum; 4451 4452 /* Quiesce the IM 4453 */ 4454 if (mptscsih_do_raid(hd, MPI_RAID_ACTION_QUIESCE_PHYS_IO, &iocmd) < 0) { 4455 ddvprintk((MYIOC_s_ERR_FMT "RAID Queisce FAILED!\n", ioc->name)); 4456 goto target_done; 4457 } 4458 break; 4459 } 4460 pPDisk++; 4461 numPDisk--; 4462 } 4463 } 4464 4465 /* RAID Volume ID's may double for a physical device. If RAID but 4466 * not a physical ID as well, skip DV. 4467 */ 4468 if ((hd->ioc->spi_data.isRaid & (1 << id)) && !(iocmd.flags & MPT_ICFLAG_PHYS_DISK)) 4469 goto target_done; 4470 4471 4472 /* Basic Test. 4473 * Async & Narrow - Inquiry 4474 * Async & Narrow - Inquiry 4475 * Maximum transfer rate - Inquiry 4476 * Compare buffers: 4477 * If compare, test complete. 4478 * If miscompare and first pass, repeat 4479 * If miscompare and not first pass, fall back and repeat 4480 */ 4481 hd->pLocal = NULL; 4482 readPage0 = 0; 4483 sz = SCSI_MAX_INQUIRY_BYTES; 4484 rc = MPT_SCANDV_GOOD; 4485 while (1) { 4486 ddvprintk((MYIOC_s_NOTE_FMT "DV: Start Basic test on id=%d\n", ioc->name, id)); 4487 retcode = 0; 4488 dv.cmd = MPT_SET_MIN; 4489 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data); 4490 4491 cfg.hdr = &header1; 4492 cfg.physAddr = cfg1_dma_addr; 4493 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 4494 cfg.dir = 1; 4495 if (mpt_config(hd->ioc, &cfg) != 0) 4496 goto target_done; 4497 4498 /* Wide - narrow - wide workaround case 4499 */ 4500 if ((rc == MPT_SCANDV_ISSUE_SENSE) && dv.max.width) { 4501 /* Send an untagged command to reset disk Qs corrupted 4502 * when a parity error occurs on a Request Sense. 4503 */ 4504 if ((hd->ioc->facts.FWVersion.Word >= 0x01000600) || 4505 ((hd->ioc->facts.FWVersion.Word >= 0x01010000) && 4506 (hd->ioc->facts.FWVersion.Word < 0x01010B00)) ) { 4507 4508 iocmd.cmd = REQUEST_SENSE; 4509 iocmd.data_dma = buf1_dma; 4510 iocmd.data = pbuf1; 4511 iocmd.size = 0x12; 4512 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4513 goto target_done; 4514 else { 4515 if (hd->pLocal == NULL) 4516 goto target_done; 4517 rc = hd->pLocal->completion; 4518 if ((rc == MPT_SCANDV_GOOD) || (rc == MPT_SCANDV_SENSE)) { 4519 dv.max.width = 0; 4520 doFallback = 0; 4521 } else 4522 goto target_done; 4523 } 4524 } else 4525 goto target_done; 4526 } 4527 4528 iocmd.cmd = INQUIRY; 4529 iocmd.data_dma = buf1_dma; 4530 iocmd.data = pbuf1; 4531 iocmd.size = sz; 4532 memset(pbuf1, 0x00, sz); 4533 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4534 goto target_done; 4535 else { 4536 if (hd->pLocal == NULL) 4537 goto target_done; 4538 rc = hd->pLocal->completion; 4539 if (rc == MPT_SCANDV_GOOD) { 4540 if (hd->pLocal->scsiStatus == SAM_STAT_BUSY) { 4541 if ((iocmd.flags & MPT_ICFLAG_TAGGED_CMD) == 0) 4542 retcode = 1; 4543 else 4544 retcode = 0; 4545 4546 goto target_done; 4547 } 4548 } else if (rc == MPT_SCANDV_SENSE) { 4549 ; 4550 } else { 4551 /* If first command doesn't complete 4552 * with a good status or with a check condition, 4553 * exit. 4554 */ 4555 goto target_done; 4556 } 4557 } 4558 4559 /* Reset the size for disks 4560 */ 4561 inq0 = (*pbuf1) & 0x1F; 4562 if ((inq0 == 0) && pTarget && !pTarget->raidVolume) { 4563 sz = 0x40; 4564 iocmd.size = sz; 4565 } 4566 4567 /* Another GEM workaround. Check peripheral device type, 4568 * if PROCESSOR, quit DV. 4569 */ 4570 if (inq0 == TYPE_PROCESSOR) { 4571 mptscsih_initTarget(hd, 4572 bus, 4573 id, 4574 lun, 4575 pbuf1, 4576 sz); 4577 goto target_done; 4578 } 4579 4580 if (inq0 > 0x08) 4581 goto target_done; 4582 4583 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4584 goto target_done; 4585 4586 if (sz == 0x40) { 4587 if ((pTarget->maxWidth == 1) && (pTarget->maxOffset) && (nfactor < 0x0A) 4588 && (pTarget->minSyncFactor > 0x09)) { 4589 if ((pbuf1[56] & 0x04) == 0) 4590 ; 4591 else if ((pbuf1[56] & 0x01) == 1) { 4592 pTarget->minSyncFactor = 4593 nfactor > MPT_ULTRA320 ? nfactor : MPT_ULTRA320; 4594 } else { 4595 pTarget->minSyncFactor = 4596 nfactor > MPT_ULTRA160 ? nfactor : MPT_ULTRA160; 4597 } 4598 4599 dv.max.factor = pTarget->minSyncFactor; 4600 4601 if ((pbuf1[56] & 0x02) == 0) { 4602 pTarget->negoFlags |= MPT_TARGET_NO_NEGO_QAS; 4603 hd->ioc->spi_data.noQas = MPT_TARGET_NO_NEGO_QAS; 4604 ddvprintk((MYIOC_s_NOTE_FMT 4605 "DV: Start Basic noQas on id=%d due to pbuf1[56]=%x\n", 4606 ioc->name, id, pbuf1[56])); 4607 } 4608 } 4609 } 4610 4611 if (doFallback) 4612 dv.cmd = MPT_FALLBACK; 4613 else 4614 dv.cmd = MPT_SET_MAX; 4615 4616 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data); 4617 if (mpt_config(hd->ioc, &cfg) != 0) 4618 goto target_done; 4619 4620 if ((!dv.now.width) && (!dv.now.offset)) 4621 goto target_done; 4622 4623 iocmd.cmd = INQUIRY; 4624 iocmd.data_dma = buf2_dma; 4625 iocmd.data = pbuf2; 4626 iocmd.size = sz; 4627 memset(pbuf2, 0x00, sz); 4628 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4629 goto target_done; 4630 else if (hd->pLocal == NULL) 4631 goto target_done; 4632 else { 4633 /* Save the return code. 4634 * If this is the first pass, 4635 * read SCSI Device Page 0 4636 * and update the target max parameters. 4637 */ 4638 rc = hd->pLocal->completion; 4639 doFallback = 0; 4640 if (rc == MPT_SCANDV_GOOD) { 4641 if (!readPage0) { 4642 u32 sdp0_info; 4643 u32 sdp0_nego; 4644 4645 cfg.hdr = &header0; 4646 cfg.physAddr = cfg0_dma_addr; 4647 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 4648 cfg.dir = 0; 4649 4650 if (mpt_config(hd->ioc, &cfg) != 0) 4651 goto target_done; 4652 4653 sdp0_info = le32_to_cpu(pcfg0Data->Information) & 0x0E; 4654 sdp0_nego = (le32_to_cpu(pcfg0Data->NegotiatedParameters) & 0xFF00 ) >> 8; 4655 4656 /* Quantum and Fujitsu workarounds. 4657 * Quantum: PPR U320 -> PPR reply with Ultra2 and wide 4658 * Fujitsu: PPR U320 -> Msg Reject and Ultra2 and wide 4659 * Resetart with a request for U160. 4660 */ 4661 if ((dv.now.factor == MPT_ULTRA320) && (sdp0_nego == MPT_ULTRA2)) { 4662 doFallback = 1; 4663 } else { 4664 dv.cmd = MPT_UPDATE_MAX; 4665 mptscsih_dv_parms(hd, &dv, (void *)pcfg0Data); 4666 /* Update the SCSI device page 1 area 4667 */ 4668 pcfg1Data->RequestedParameters = pcfg0Data->NegotiatedParameters; 4669 readPage0 = 1; 4670 } 4671 } 4672 4673 /* Quantum workaround. Restart this test will the fallback 4674 * flag set. 4675 */ 4676 if (doFallback == 0) { 4677 if (memcmp(pbuf1, pbuf2, sz) != 0) { 4678 if (!firstPass) 4679 doFallback = 1; 4680 } else { 4681 ddvprintk((MYIOC_s_NOTE_FMT 4682 "DV:Inquiry compared id=%d, calling initTarget\n", ioc->name, id)); 4683 hd->ioc->spi_data.dvStatus[id] &= ~MPT_SCSICFG_DV_NOT_DONE; 4684 mptscsih_initTarget(hd, 4685 bus, 4686 id, 4687 lun, 4688 pbuf1, 4689 sz); 4690 break; /* test complete */ 4691 } 4692 } 4693 4694 4695 } else if (rc == MPT_SCANDV_ISSUE_SENSE) 4696 doFallback = 1; /* set fallback flag */ 4697 else if ((rc == MPT_SCANDV_DID_RESET) || 4698 (rc == MPT_SCANDV_SENSE) || 4699 (rc == MPT_SCANDV_FALLBACK)) 4700 doFallback = 1; /* set fallback flag */ 4701 else 4702 goto target_done; 4703 4704 firstPass = 0; 4705 } 4706 } 4707 ddvprintk((MYIOC_s_NOTE_FMT "DV: Basic test on id=%d completed OK.\n", ioc->name, id)); 4708 4709 if (ioc->spi_data.mpt_dv == 0) 4710 goto target_done; 4711 4712 inq0 = (*pbuf1) & 0x1F; 4713 4714 /* Continue only for disks 4715 */ 4716 if (inq0 != 0) 4717 goto target_done; 4718 4719 if ( ioc->spi_data.PortFlags == MPI_SCSIPORTPAGE2_PORT_FLAGS_BASIC_DV_ONLY ) 4720 goto target_done; 4721 4722 /* Start the Enhanced Test. 4723 * 0) issue TUR to clear out check conditions 4724 * 1) read capacity of echo (regular) buffer 4725 * 2) reserve device 4726 * 3) do write-read-compare data pattern test 4727 * 4) release 4728 * 5) update nego parms to target struct 4729 */ 4730 cfg.hdr = &header1; 4731 cfg.physAddr = cfg1_dma_addr; 4732 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 4733 cfg.dir = 1; 4734 4735 iocmd.cmd = TEST_UNIT_READY; 4736 iocmd.data_dma = -1; 4737 iocmd.data = NULL; 4738 iocmd.size = 0; 4739 notDone = 1; 4740 while (notDone) { 4741 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4742 goto target_done; 4743 4744 if (hd->pLocal == NULL) 4745 goto target_done; 4746 4747 rc = hd->pLocal->completion; 4748 if (rc == MPT_SCANDV_GOOD) 4749 notDone = 0; 4750 else if (rc == MPT_SCANDV_SENSE) { 4751 u8 skey = hd->pLocal->sense[2] & 0x0F; 4752 u8 asc = hd->pLocal->sense[12]; 4753 u8 ascq = hd->pLocal->sense[13]; 4754 ddvprintk((MYIOC_s_INFO_FMT 4755 "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n", 4756 ioc->name, skey, asc, ascq)); 4757 4758 if (skey == UNIT_ATTENTION) 4759 notDone++; /* repeat */ 4760 else if ((skey == NOT_READY) && 4761 (asc == 0x04)&&(ascq == 0x01)) { 4762 /* wait then repeat */ 4763 mdelay (2000); 4764 notDone++; 4765 } else if ((skey == NOT_READY) && (asc == 0x3A)) { 4766 /* no medium, try read test anyway */ 4767 notDone = 0; 4768 } else { 4769 /* All other errors are fatal. 4770 */ 4771 ddvprintk((MYIOC_s_INFO_FMT "DV: fatal error.", 4772 ioc->name)); 4773 goto target_done; 4774 } 4775 } else 4776 goto target_done; 4777 } 4778 4779 iocmd.cmd = READ_BUFFER; 4780 iocmd.data_dma = buf1_dma; 4781 iocmd.data = pbuf1; 4782 iocmd.size = 4; 4783 iocmd.flags |= MPT_ICFLAG_BUF_CAP; 4784 4785 dataBufSize = 0; 4786 echoBufSize = 0; 4787 for (patt = 0; patt < 2; patt++) { 4788 if (patt == 0) 4789 iocmd.flags |= MPT_ICFLAG_ECHO; 4790 else 4791 iocmd.flags &= ~MPT_ICFLAG_ECHO; 4792 4793 notDone = 1; 4794 while (notDone) { 4795 bufsize = 0; 4796 4797 /* If not ready after 8 trials, 4798 * give up on this device. 4799 */ 4800 if (notDone > 8) 4801 goto target_done; 4802 4803 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4804 goto target_done; 4805 else if (hd->pLocal == NULL) 4806 goto target_done; 4807 else { 4808 rc = hd->pLocal->completion; 4809 ddvprintk(("ReadBuffer Comp Code %d", rc)); 4810 ddvprintk((" buff: %0x %0x %0x %0x\n", 4811 pbuf1[0], pbuf1[1], pbuf1[2], pbuf1[3])); 4812 4813 if (rc == MPT_SCANDV_GOOD) { 4814 notDone = 0; 4815 if (iocmd.flags & MPT_ICFLAG_ECHO) { 4816 bufsize = ((pbuf1[2] & 0x1F) <<8) | pbuf1[3]; 4817 } else { 4818 bufsize = pbuf1[1]<<16 | pbuf1[2]<<8 | pbuf1[3]; 4819 } 4820 } else if (rc == MPT_SCANDV_SENSE) { 4821 u8 skey = hd->pLocal->sense[2] & 0x0F; 4822 u8 asc = hd->pLocal->sense[12]; 4823 u8 ascq = hd->pLocal->sense[13]; 4824 ddvprintk((MYIOC_s_INFO_FMT 4825 "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n", 4826 ioc->name, skey, asc, ascq)); 4827 if (skey == ILLEGAL_REQUEST) { 4828 notDone = 0; 4829 } else if (skey == UNIT_ATTENTION) { 4830 notDone++; /* repeat */ 4831 } else if ((skey == NOT_READY) && 4832 (asc == 0x04)&&(ascq == 0x01)) { 4833 /* wait then repeat */ 4834 mdelay (2000); 4835 notDone++; 4836 } else { 4837 /* All other errors are fatal. 4838 */ 4839 ddvprintk((MYIOC_s_INFO_FMT "DV: fatal error.", 4840 ioc->name)); 4841 goto target_done; 4842 } 4843 } else { 4844 /* All other errors are fatal 4845 */ 4846 goto target_done; 4847 } 4848 } 4849 } 4850 4851 if (iocmd.flags & MPT_ICFLAG_ECHO) 4852 echoBufSize = bufsize; 4853 else 4854 dataBufSize = bufsize; 4855 } 4856 sz = 0; 4857 iocmd.flags &= ~MPT_ICFLAG_BUF_CAP; 4858 4859 /* Use echo buffers if possible, 4860 * Exit if both buffers are 0. 4861 */ 4862 if (echoBufSize > 0) { 4863 iocmd.flags |= MPT_ICFLAG_ECHO; 4864 if (dataBufSize > 0) 4865 bufsize = min(echoBufSize, dataBufSize); 4866 else 4867 bufsize = echoBufSize; 4868 } else if (dataBufSize == 0) 4869 goto target_done; 4870 4871 ddvprintk((MYIOC_s_INFO_FMT "%s Buffer Capacity %d\n", ioc->name, 4872 (iocmd.flags & MPT_ICFLAG_ECHO) ? "Echo" : " ", bufsize)); 4873 4874 /* Data buffers for write-read-compare test max 1K. 4875 */ 4876 sz = min(bufsize, 1024); 4877 4878 /* --- loop ---- 4879 * On first pass, always issue a reserve. 4880 * On additional loops, only if a reset has occurred. 4881 * iocmd.flags indicates if echo or regular buffer 4882 */ 4883 for (patt = 0; patt < 4; patt++) { 4884 ddvprintk(("Pattern %d\n", patt)); 4885 if ((iocmd.flags & MPT_ICFLAG_RESERVED) && (iocmd.flags & MPT_ICFLAG_DID_RESET)) { 4886 iocmd.cmd = TEST_UNIT_READY; 4887 iocmd.data_dma = -1; 4888 iocmd.data = NULL; 4889 iocmd.size = 0; 4890 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4891 goto target_done; 4892 4893 iocmd.cmd = RELEASE; 4894 iocmd.data_dma = -1; 4895 iocmd.data = NULL; 4896 iocmd.size = 0; 4897 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4898 goto target_done; 4899 else if (hd->pLocal == NULL) 4900 goto target_done; 4901 else { 4902 rc = hd->pLocal->completion; 4903 ddvprintk(("Release rc %d\n", rc)); 4904 if (rc == MPT_SCANDV_GOOD) 4905 iocmd.flags &= ~MPT_ICFLAG_RESERVED; 4906 else 4907 goto target_done; 4908 } 4909 iocmd.flags &= ~MPT_ICFLAG_RESERVED; 4910 } 4911 iocmd.flags &= ~MPT_ICFLAG_DID_RESET; 4912 4913 repeat = 5; 4914 while (repeat && (!(iocmd.flags & MPT_ICFLAG_RESERVED))) { 4915 iocmd.cmd = RESERVE; 4916 iocmd.data_dma = -1; 4917 iocmd.data = NULL; 4918 iocmd.size = 0; 4919 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4920 goto target_done; 4921 else if (hd->pLocal == NULL) 4922 goto target_done; 4923 else { 4924 rc = hd->pLocal->completion; 4925 if (rc == MPT_SCANDV_GOOD) { 4926 iocmd.flags |= MPT_ICFLAG_RESERVED; 4927 } else if (rc == MPT_SCANDV_SENSE) { 4928 /* Wait if coming ready 4929 */ 4930 u8 skey = hd->pLocal->sense[2] & 0x0F; 4931 u8 asc = hd->pLocal->sense[12]; 4932 u8 ascq = hd->pLocal->sense[13]; 4933 ddvprintk((MYIOC_s_INFO_FMT 4934 "DV: Reserve Failed: ", ioc->name)); 4935 ddvprintk(("SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n", 4936 skey, asc, ascq)); 4937 4938 if ((skey == NOT_READY) && (asc == 0x04)&& 4939 (ascq == 0x01)) { 4940 /* wait then repeat */ 4941 mdelay (2000); 4942 notDone++; 4943 } else { 4944 ddvprintk((MYIOC_s_INFO_FMT 4945 "DV: Reserved Failed.", ioc->name)); 4946 goto target_done; 4947 } 4948 } else { 4949 ddvprintk((MYIOC_s_INFO_FMT "DV: Reserved Failed.", 4950 ioc->name)); 4951 goto target_done; 4952 } 4953 } 4954 } 4955 4956 mptscsih_fillbuf(pbuf1, sz, patt, 1); 4957 iocmd.cmd = WRITE_BUFFER; 4958 iocmd.data_dma = buf1_dma; 4959 iocmd.data = pbuf1; 4960 iocmd.size = sz; 4961 if (mptscsih_do_cmd(hd, &iocmd) < 0) 4962 goto target_done; 4963 else if (hd->pLocal == NULL) 4964 goto target_done; 4965 else { 4966 rc = hd->pLocal->completion; 4967 if (rc == MPT_SCANDV_GOOD) 4968 ; /* Issue read buffer */ 4969 else if (rc == MPT_SCANDV_DID_RESET) { 4970 /* If using echo buffers, reset to data buffers. 4971 * Else do Fallback and restart 4972 * this test (re-issue reserve 4973 * because of bus reset). 4974 */ 4975 if ((iocmd.flags & MPT_ICFLAG_ECHO) && (dataBufSize >= bufsize)) { 4976 iocmd.flags &= ~MPT_ICFLAG_ECHO; 4977 } else { 4978 dv.cmd = MPT_FALLBACK; 4979 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data); 4980 4981 if (mpt_config(hd->ioc, &cfg) != 0) 4982 goto target_done; 4983 4984 if ((!dv.now.width) && (!dv.now.offset)) 4985 goto target_done; 4986 } 4987 4988 iocmd.flags |= MPT_ICFLAG_DID_RESET; 4989 patt = -1; 4990 continue; 4991 } else if (rc == MPT_SCANDV_SENSE) { 4992 /* Restart data test if UA, else quit. 4993 */ 4994 u8 skey = hd->pLocal->sense[2] & 0x0F; 4995 ddvprintk((MYIOC_s_INFO_FMT 4996 "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n", ioc->name, skey, 4997 hd->pLocal->sense[12], hd->pLocal->sense[13])); 4998 if (skey == UNIT_ATTENTION) { 4999 patt = -1; 5000 continue; 5001 } else if (skey == ILLEGAL_REQUEST) { 5002 if (iocmd.flags & MPT_ICFLAG_ECHO) { 5003 if (dataBufSize >= bufsize) { 5004 iocmd.flags &= ~MPT_ICFLAG_ECHO; 5005 patt = -1; 5006 continue; 5007 } 5008 } 5009 goto target_done; 5010 } 5011 else 5012 goto target_done; 5013 } else { 5014 /* fatal error */ 5015 goto target_done; 5016 } 5017 } 5018 5019 iocmd.cmd = READ_BUFFER; 5020 iocmd.data_dma = buf2_dma; 5021 iocmd.data = pbuf2; 5022 iocmd.size = sz; 5023 if (mptscsih_do_cmd(hd, &iocmd) < 0) 5024 goto target_done; 5025 else if (hd->pLocal == NULL) 5026 goto target_done; 5027 else { 5028 rc = hd->pLocal->completion; 5029 if (rc == MPT_SCANDV_GOOD) { 5030 /* If buffers compare, 5031 * go to next pattern, 5032 * else, do a fallback and restart 5033 * data transfer test. 5034 */ 5035 if (memcmp (pbuf1, pbuf2, sz) == 0) { 5036 ; /* goto next pattern */ 5037 } else { 5038 /* Miscompare with Echo buffer, go to data buffer, 5039 * if that buffer exists. 5040 * Miscompare with Data buffer, check first 4 bytes, 5041 * some devices return capacity. Exit in this case. 5042 */ 5043 if (iocmd.flags & MPT_ICFLAG_ECHO) { 5044 if (dataBufSize >= bufsize) 5045 iocmd.flags &= ~MPT_ICFLAG_ECHO; 5046 else 5047 goto target_done; 5048 } else { 5049 if (dataBufSize == (pbuf2[1]<<16 | pbuf2[2]<<8 | pbuf2[3])) { 5050 /* Argh. Device returning wrong data. 5051 * Quit DV for this device. 5052 */ 5053 goto target_done; 5054 } 5055 5056 /* Had an actual miscompare. Slow down.*/ 5057 dv.cmd = MPT_FALLBACK; 5058 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data); 5059 5060 if (mpt_config(hd->ioc, &cfg) != 0) 5061 goto target_done; 5062 5063 if ((!dv.now.width) && (!dv.now.offset)) 5064 goto target_done; 5065 } 5066 5067 patt = -1; 5068 continue; 5069 } 5070 } else if (rc == MPT_SCANDV_DID_RESET) { 5071 /* Do Fallback and restart 5072 * this test (re-issue reserve 5073 * because of bus reset). 5074 */ 5075 dv.cmd = MPT_FALLBACK; 5076 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data); 5077 5078 if (mpt_config(hd->ioc, &cfg) != 0) 5079 goto target_done; 5080 5081 if ((!dv.now.width) && (!dv.now.offset)) 5082 goto target_done; 5083 5084 iocmd.flags |= MPT_ICFLAG_DID_RESET; 5085 patt = -1; 5086 continue; 5087 } else if (rc == MPT_SCANDV_SENSE) { 5088 /* Restart data test if UA, else quit. 5089 */ 5090 u8 skey = hd->pLocal->sense[2] & 0x0F; 5091 ddvprintk((MYIOC_s_INFO_FMT 5092 "SenseKey:ASC:ASCQ = (%x:%02x:%02x)\n", ioc->name, skey, 5093 hd->pLocal->sense[12], hd->pLocal->sense[13])); 5094 if (skey == UNIT_ATTENTION) { 5095 patt = -1; 5096 continue; 5097 } 5098 else 5099 goto target_done; 5100 } else { 5101 /* fatal error */ 5102 goto target_done; 5103 } 5104 } 5105 5106 } /* --- end of patt loop ---- */ 5107 5108 target_done: 5109 if (iocmd.flags & MPT_ICFLAG_RESERVED) { 5110 iocmd.cmd = RELEASE; 5111 iocmd.data_dma = -1; 5112 iocmd.data = NULL; 5113 iocmd.size = 0; 5114 if (mptscsih_do_cmd(hd, &iocmd) < 0) 5115 printk(MYIOC_s_INFO_FMT "DV: Release failed. id %d", 5116 ioc->name, id); 5117 else if (hd->pLocal) { 5118 if (hd->pLocal->completion == MPT_SCANDV_GOOD) 5119 iocmd.flags &= ~MPT_ICFLAG_RESERVED; 5120 } else { 5121 printk(MYIOC_s_INFO_FMT "DV: Release failed. id %d", 5122 ioc->name, id); 5123 } 5124 } 5125 5126 5127 /* Set if cfg1_dma_addr contents is valid 5128 */ 5129 if ((cfg.hdr != NULL) && (retcode == 0)){ 5130 /* If disk, not U320, disable QAS 5131 */ 5132 if ((inq0 == 0) && (dv.now.factor > MPT_ULTRA320)) { 5133 hd->ioc->spi_data.noQas = MPT_TARGET_NO_NEGO_QAS; 5134 ddvprintk((MYIOC_s_NOTE_FMT 5135 "noQas set due to id=%d has factor=%x\n", ioc->name, id, dv.now.factor)); 5136 } 5137 5138 dv.cmd = MPT_SAVE; 5139 mptscsih_dv_parms(hd, &dv, (void *)pcfg1Data); 5140 5141 /* Double writes to SDP1 can cause problems, 5142 * skip save of the final negotiated settings to 5143 * SCSI device page 1. 5144 * 5145 cfg.hdr = &header1; 5146 cfg.physAddr = cfg1_dma_addr; 5147 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 5148 cfg.dir = 1; 5149 mpt_config(hd->ioc, &cfg); 5150 */ 5151 } 5152 5153 /* If this is a RAID Passthrough, enable internal IOs 5154 */ 5155 if (iocmd.flags & MPT_ICFLAG_PHYS_DISK) { 5156 if (mptscsih_do_raid(hd, MPI_RAID_ACTION_ENABLE_PHYS_IO, &iocmd) < 0) 5157 ddvprintk((MYIOC_s_ERR_FMT "RAID Enable FAILED!\n", ioc->name)); 5158 } 5159 5160 /* Done with the DV scan of the current target 5161 */ 5162 if (pDvBuf) 5163 pci_free_consistent(ioc->pcidev, dv_alloc, pDvBuf, dvbuf_dma); 5164 5165 ddvtprintk((MYIOC_s_INFO_FMT "DV Done id=%d\n", 5166 ioc->name, id)); 5167 5168 return retcode; 5169 } 5170 5171 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 5172 /* mptscsih_dv_parms - perform a variety of operations on the 5173 * parameters used for negotiation. 5174 * @hd: Pointer to a SCSI host. 5175 * @dv: Pointer to a structure that contains the maximum and current 5176 * negotiated parameters. 5177 */ 5178 static void 5179 mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage) 5180 { 5181 VirtDevice *pTarget; 5182 SCSIDevicePage0_t *pPage0; 5183 SCSIDevicePage1_t *pPage1; 5184 int val = 0, data, configuration; 5185 u8 width = 0; 5186 u8 offset = 0; 5187 u8 factor = 0; 5188 u8 negoFlags = 0; 5189 u8 cmd = dv->cmd; 5190 u8 id = dv->id; 5191 5192 switch (cmd) { 5193 case MPT_GET_NVRAM_VALS: 5194 ddvprintk((MYIOC_s_NOTE_FMT "Getting NVRAM: ", 5195 hd->ioc->name)); 5196 /* Get the NVRAM values and save in tmax 5197 * If not an LVD bus, the adapter minSyncFactor has been 5198 * already throttled back. 5199 */ 5200 if ((hd->Targets)&&((pTarget = hd->Targets[(int)id]) != NULL) && !pTarget->raidVolume) { 5201 width = pTarget->maxWidth; 5202 offset = pTarget->maxOffset; 5203 factor = pTarget->minSyncFactor; 5204 negoFlags = pTarget->negoFlags; 5205 } else { 5206 if (hd->ioc->spi_data.nvram && (hd->ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) { 5207 data = hd->ioc->spi_data.nvram[id]; 5208 width = data & MPT_NVRAM_WIDE_DISABLE ? 0 : 1; 5209 if ((offset = hd->ioc->spi_data.maxSyncOffset) == 0) 5210 factor = MPT_ASYNC; 5211 else { 5212 factor = (data & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT; 5213 if ((factor == 0) || (factor == MPT_ASYNC)){ 5214 factor = MPT_ASYNC; 5215 offset = 0; 5216 } 5217 } 5218 } else { 5219 width = MPT_NARROW; 5220 offset = 0; 5221 factor = MPT_ASYNC; 5222 } 5223 5224 /* Set the negotiation flags */ 5225 negoFlags = hd->ioc->spi_data.noQas; 5226 if (!width) 5227 negoFlags |= MPT_TARGET_NO_NEGO_WIDE; 5228 5229 if (!offset) 5230 negoFlags |= MPT_TARGET_NO_NEGO_SYNC; 5231 } 5232 5233 /* limit by adapter capabilities */ 5234 width = min(width, hd->ioc->spi_data.maxBusWidth); 5235 offset = min(offset, hd->ioc->spi_data.maxSyncOffset); 5236 factor = max(factor, hd->ioc->spi_data.minSyncFactor); 5237 5238 /* Check Consistency */ 5239 if (offset && (factor < MPT_ULTRA2) && !width) 5240 factor = MPT_ULTRA2; 5241 5242 dv->max.width = width; 5243 dv->max.offset = offset; 5244 dv->max.factor = factor; 5245 dv->max.flags = negoFlags; 5246 ddvprintk((" id=%d width=%d factor=%x offset=%x flags=%x\n", 5247 id, width, factor, offset, negoFlags)); 5248 break; 5249 5250 case MPT_UPDATE_MAX: 5251 ddvprintk((MYIOC_s_NOTE_FMT 5252 "Updating with SDP0 Data: ", hd->ioc->name)); 5253 /* Update tmax values with those from Device Page 0.*/ 5254 pPage0 = (SCSIDevicePage0_t *) pPage; 5255 if (pPage0) { 5256 val = cpu_to_le32(pPage0->NegotiatedParameters); 5257 dv->max.width = val & MPI_SCSIDEVPAGE0_NP_WIDE ? 1 : 0; 5258 dv->max.offset = (val&MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> 16; 5259 dv->max.factor = (val&MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> 8; 5260 } 5261 5262 dv->now.width = dv->max.width; 5263 dv->now.offset = dv->max.offset; 5264 dv->now.factor = dv->max.factor; 5265 ddvprintk(("id=%d width=%d factor=%x offset=%x flags=%x\n", 5266 id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags)); 5267 break; 5268 5269 case MPT_SET_MAX: 5270 ddvprintk((MYIOC_s_NOTE_FMT "Setting Max: ", 5271 hd->ioc->name)); 5272 /* Set current to the max values. Update the config page.*/ 5273 dv->now.width = dv->max.width; 5274 dv->now.offset = dv->max.offset; 5275 dv->now.factor = dv->max.factor; 5276 dv->now.flags = dv->max.flags; 5277 5278 pPage1 = (SCSIDevicePage1_t *)pPage; 5279 if (pPage1) { 5280 mptscsih_setDevicePage1Flags (dv->now.width, dv->now.factor, 5281 dv->now.offset, &val, &configuration, dv->now.flags); 5282 dnegoprintk(("Setting Max: id=%d width=%d factor=%x offset=%x negoFlags=%x request=%x config=%x\n", 5283 id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags, val, configuration)); 5284 pPage1->RequestedParameters = le32_to_cpu(val); 5285 pPage1->Reserved = 0; 5286 pPage1->Configuration = le32_to_cpu(configuration); 5287 } 5288 5289 ddvprintk(("id=%d width=%d factor=%x offset=%x flags=%x request=%x configuration=%x\n", 5290 id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags, val, configuration)); 5291 break; 5292 5293 case MPT_SET_MIN: 5294 ddvprintk((MYIOC_s_NOTE_FMT "Setting Min: ", 5295 hd->ioc->name)); 5296 /* Set page to asynchronous and narrow 5297 * Do not update now, breaks fallback routine. */ 5298 width = MPT_NARROW; 5299 offset = 0; 5300 factor = MPT_ASYNC; 5301 negoFlags = dv->max.flags; 5302 5303 pPage1 = (SCSIDevicePage1_t *)pPage; 5304 if (pPage1) { 5305 mptscsih_setDevicePage1Flags (width, factor, 5306 offset, &val, &configuration, negoFlags); 5307 dnegoprintk(("Setting Min: id=%d width=%d factor=%x offset=%x negoFlags=%x request=%x config=%x\n", 5308 id, width, factor, offset, negoFlags, val, configuration)); 5309 pPage1->RequestedParameters = le32_to_cpu(val); 5310 pPage1->Reserved = 0; 5311 pPage1->Configuration = le32_to_cpu(configuration); 5312 } 5313 ddvprintk(("id=%d width=%d factor=%x offset=%x request=%x config=%x negoFlags=%x\n", 5314 id, width, factor, offset, val, configuration, negoFlags)); 5315 break; 5316 5317 case MPT_FALLBACK: 5318 ddvprintk((MYIOC_s_NOTE_FMT 5319 "Fallback: Start: offset %d, factor %x, width %d \n", 5320 hd->ioc->name, dv->now.offset, 5321 dv->now.factor, dv->now.width)); 5322 width = dv->now.width; 5323 offset = dv->now.offset; 5324 factor = dv->now.factor; 5325 if ((offset) && (dv->max.width)) { 5326 if (factor < MPT_ULTRA160) 5327 factor = MPT_ULTRA160; 5328 else if (factor < MPT_ULTRA2) { 5329 factor = MPT_ULTRA2; 5330 width = MPT_WIDE; 5331 } else if ((factor == MPT_ULTRA2) && width) { 5332 factor = MPT_ULTRA2; 5333 width = MPT_NARROW; 5334 } else if (factor < MPT_ULTRA) { 5335 factor = MPT_ULTRA; 5336 width = MPT_WIDE; 5337 } else if ((factor == MPT_ULTRA) && width) { 5338 width = MPT_NARROW; 5339 } else if (factor < MPT_FAST) { 5340 factor = MPT_FAST; 5341 width = MPT_WIDE; 5342 } else if ((factor == MPT_FAST) && width) { 5343 factor = MPT_FAST; 5344 width = MPT_NARROW; 5345 } else if (factor < MPT_SCSI) { 5346 factor = MPT_SCSI; 5347 width = MPT_WIDE; 5348 } else if ((factor == MPT_SCSI) && width) { 5349 factor = MPT_SCSI; 5350 width = MPT_NARROW; 5351 } else { 5352 factor = MPT_ASYNC; 5353 offset = 0; 5354 } 5355 5356 } else if (offset) { 5357 width = MPT_NARROW; 5358 if (factor < MPT_ULTRA) 5359 factor = MPT_ULTRA; 5360 else if (factor < MPT_FAST) 5361 factor = MPT_FAST; 5362 else if (factor < MPT_SCSI) 5363 factor = MPT_SCSI; 5364 else { 5365 factor = MPT_ASYNC; 5366 offset = 0; 5367 } 5368 5369 } else { 5370 width = MPT_NARROW; 5371 factor = MPT_ASYNC; 5372 } 5373 dv->max.flags |= MPT_TARGET_NO_NEGO_QAS; 5374 dv->max.flags &= ~MPT_TAPE_NEGO_IDP; 5375 5376 dv->now.width = width; 5377 dv->now.offset = offset; 5378 dv->now.factor = factor; 5379 dv->now.flags = dv->max.flags; 5380 5381 pPage1 = (SCSIDevicePage1_t *)pPage; 5382 if (pPage1) { 5383 mptscsih_setDevicePage1Flags (width, factor, offset, &val, 5384 &configuration, dv->now.flags); 5385 dnegoprintk(("Finish: id=%d width=%d offset=%d factor=%x flags=%x request=%x config=%x\n", 5386 id, width, offset, factor, dv->now.flags, val, configuration)); 5387 5388 pPage1->RequestedParameters = le32_to_cpu(val); 5389 pPage1->Reserved = 0; 5390 pPage1->Configuration = le32_to_cpu(configuration); 5391 } 5392 5393 ddvprintk(("Finish: id=%d offset=%d factor=%x width=%d request=%x config=%x\n", 5394 id, dv->now.offset, dv->now.factor, dv->now.width, val, configuration)); 5395 break; 5396 5397 case MPT_SAVE: 5398 ddvprintk((MYIOC_s_NOTE_FMT 5399 "Saving to Target structure: ", hd->ioc->name)); 5400 ddvprintk(("id=%d width=%x factor=%x offset=%d flags=%x\n", 5401 id, dv->now.width, dv->now.factor, dv->now.offset, dv->now.flags)); 5402 5403 /* Save these values to target structures 5404 * or overwrite nvram (phys disks only). 5405 */ 5406 5407 if ((hd->Targets)&&((pTarget = hd->Targets[(int)id]) != NULL) && !pTarget->raidVolume ) { 5408 pTarget->maxWidth = dv->now.width; 5409 pTarget->maxOffset = dv->now.offset; 5410 pTarget->minSyncFactor = dv->now.factor; 5411 pTarget->negoFlags = dv->now.flags; 5412 } else { 5413 /* Preserv all flags, use 5414 * read-modify-write algorithm 5415 */ 5416 if (hd->ioc->spi_data.nvram) { 5417 data = hd->ioc->spi_data.nvram[id]; 5418 5419 if (dv->now.width) 5420 data &= ~MPT_NVRAM_WIDE_DISABLE; 5421 else 5422 data |= MPT_NVRAM_WIDE_DISABLE; 5423 5424 if (!dv->now.offset) 5425 factor = MPT_ASYNC; 5426 5427 data &= ~MPT_NVRAM_SYNC_MASK; 5428 data |= (dv->now.factor << MPT_NVRAM_SYNC_SHIFT) & MPT_NVRAM_SYNC_MASK; 5429 5430 hd->ioc->spi_data.nvram[id] = data; 5431 } 5432 } 5433 break; 5434 } 5435 } 5436 5437 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 5438 /* mptscsih_fillbuf - fill a buffer with a special data pattern 5439 * cleanup. For bus scan only. 5440 * 5441 * @buffer: Pointer to data buffer to be filled. 5442 * @size: Number of bytes to fill 5443 * @index: Pattern index 5444 * @width: bus width, 0 (8 bits) or 1 (16 bits) 5445 */ 5446 static void 5447 mptscsih_fillbuf(char *buffer, int size, int index, int width) 5448 { 5449 char *ptr = buffer; 5450 int ii; 5451 char byte; 5452 short val; 5453 5454 switch (index) { 5455 case 0: 5456 5457 if (width) { 5458 /* Pattern: 0000 FFFF 0000 FFFF 5459 */ 5460 for (ii=0; ii < size; ii++, ptr++) { 5461 if (ii & 0x02) 5462 *ptr = 0xFF; 5463 else 5464 *ptr = 0x00; 5465 } 5466 } else { 5467 /* Pattern: 00 FF 00 FF 5468 */ 5469 for (ii=0; ii < size; ii++, ptr++) { 5470 if (ii & 0x01) 5471 *ptr = 0xFF; 5472 else 5473 *ptr = 0x00; 5474 } 5475 } 5476 break; 5477 5478 case 1: 5479 if (width) { 5480 /* Pattern: 5555 AAAA 5555 AAAA 5555 5481 */ 5482 for (ii=0; ii < size; ii++, ptr++) { 5483 if (ii & 0x02) 5484 *ptr = 0xAA; 5485 else 5486 *ptr = 0x55; 5487 } 5488 } else { 5489 /* Pattern: 55 AA 55 AA 55 5490 */ 5491 for (ii=0; ii < size; ii++, ptr++) { 5492 if (ii & 0x01) 5493 *ptr = 0xAA; 5494 else 5495 *ptr = 0x55; 5496 } 5497 } 5498 break; 5499 5500 case 2: 5501 /* Pattern: 00 01 02 03 04 05 5502 * ... FE FF 00 01.. 5503 */ 5504 for (ii=0; ii < size; ii++, ptr++) 5505 *ptr = (char) ii; 5506 break; 5507 5508 case 3: 5509 if (width) { 5510 /* Wide Pattern: FFFE 0001 FFFD 0002 5511 * ... 4000 DFFF 8000 EFFF 5512 */ 5513 byte = 0; 5514 for (ii=0; ii < size/2; ii++) { 5515 /* Create the base pattern 5516 */ 5517 val = (1 << byte); 5518 /* every 64 (0x40) bytes flip the pattern 5519 * since we fill 2 bytes / iteration, 5520 * test for ii = 0x20 5521 */ 5522 if (ii & 0x20) 5523 val = ~(val); 5524 5525 if (ii & 0x01) { 5526 *ptr = (char)( (val & 0xFF00) >> 8); 5527 ptr++; 5528 *ptr = (char)(val & 0xFF); 5529 byte++; 5530 byte &= 0x0F; 5531 } else { 5532 val = ~val; 5533 *ptr = (char)( (val & 0xFF00) >> 8); 5534 ptr++; 5535 *ptr = (char)(val & 0xFF); 5536 } 5537 5538 ptr++; 5539 } 5540 } else { 5541 /* Narrow Pattern: FE 01 FD 02 FB 04 5542 * .. 7F 80 01 FE 02 FD ... 80 7F 5543 */ 5544 byte = 0; 5545 for (ii=0; ii < size; ii++, ptr++) { 5546 /* Base pattern - first 32 bytes 5547 */ 5548 if (ii & 0x01) { 5549 *ptr = (1 << byte); 5550 byte++; 5551 byte &= 0x07; 5552 } else { 5553 *ptr = (char) (~(1 << byte)); 5554 } 5555 5556 /* Flip the pattern every 32 bytes 5557 */ 5558 if (ii & 0x20) 5559 *ptr = ~(*ptr); 5560 } 5561 } 5562 break; 5563 } 5564 } 5565 #endif /* ~MPTSCSIH_ENABLE_DOMAIN_VALIDATION */ 5566 5567 EXPORT_SYMBOL(mptscsih_remove); 5568 EXPORT_SYMBOL(mptscsih_shutdown); 5569 #ifdef CONFIG_PM 5570 EXPORT_SYMBOL(mptscsih_suspend); 5571 EXPORT_SYMBOL(mptscsih_resume); 5572 #endif 5573 EXPORT_SYMBOL(mptscsih_proc_info); 5574 EXPORT_SYMBOL(mptscsih_info); 5575 EXPORT_SYMBOL(mptscsih_qcmd); 5576 EXPORT_SYMBOL(mptscsih_slave_alloc); 5577 EXPORT_SYMBOL(mptscsih_slave_destroy); 5578 EXPORT_SYMBOL(mptscsih_slave_configure); 5579 EXPORT_SYMBOL(mptscsih_abort); 5580 EXPORT_SYMBOL(mptscsih_dev_reset); 5581 EXPORT_SYMBOL(mptscsih_bus_reset); 5582 EXPORT_SYMBOL(mptscsih_host_reset); 5583 EXPORT_SYMBOL(mptscsih_bios_param); 5584 EXPORT_SYMBOL(mptscsih_io_done); 5585 EXPORT_SYMBOL(mptscsih_taskmgmt_complete); 5586 EXPORT_SYMBOL(mptscsih_scandv_complete); 5587 EXPORT_SYMBOL(mptscsih_event_process); 5588 EXPORT_SYMBOL(mptscsih_ioc_reset); 5589 EXPORT_SYMBOL(mptscsih_store_queue_depth); 5590 EXPORT_SYMBOL(mptscsih_timer_expired); 5591 5592 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 5593