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