projects / deliverable / linux.git / blob
? search:


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