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