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