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