?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.18.8
[linux-2.6/suspend2-2.6.18.git] / drivers / message / fusion / mptscsih.c
blob30524dc54b16b720dea158f45c5f477ff446cf19
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 #include "lsi/mpi_log_sas.h"
70
71 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
72 #define my_NAME "Fusion MPT SCSI Host driver"
73 #define my_VERSION MPT_LINUX_VERSION_COMMON
74 #define MYNAM "mptscsih"
75
76 MODULE_AUTHOR(MODULEAUTHOR);
77 MODULE_DESCRIPTION(my_NAME);
78 MODULE_LICENSE("GPL");
79
80 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
81
82 typedef struct _BIG_SENSE_BUF {
83 u8 data[MPT_SENSE_BUFFER_ALLOC];
84 } BIG_SENSE_BUF;
85
86 #define MPT_SCANDV_GOOD (0x00000000) /* must be 0 */
87 #define MPT_SCANDV_DID_RESET (0x00000001)
88 #define MPT_SCANDV_SENSE (0x00000002)
89 #define MPT_SCANDV_SOME_ERROR (0x00000004)
90 #define MPT_SCANDV_SELECTION_TIMEOUT (0x00000008)
91 #define MPT_SCANDV_ISSUE_SENSE (0x00000010)
92 #define MPT_SCANDV_FALLBACK (0x00000020)
93
94 #define MPT_SCANDV_MAX_RETRIES (10)
95
96 #define MPT_ICFLAG_BUF_CAP 0x01 /* ReadBuffer Read Capacity format */
97 #define MPT_ICFLAG_ECHO 0x02 /* ReadBuffer Echo buffer format */
98 #define MPT_ICFLAG_EBOS 0x04 /* ReadBuffer Echo buffer has EBOS */
99 #define MPT_ICFLAG_PHYS_DISK 0x08 /* Any SCSI IO but do Phys Disk Format */
100 #define MPT_ICFLAG_TAGGED_CMD 0x10 /* Do tagged IO */
101 #define MPT_ICFLAG_DID_RESET 0x20 /* Bus Reset occurred with this command */
102 #define MPT_ICFLAG_RESERVED 0x40 /* Reserved has been issued */
103
104 typedef struct _internal_cmd {
105 char *data; /* data pointer */
106 dma_addr_t data_dma; /* data dma address */
107 int size; /* transfer size */
108 u8 cmd; /* SCSI Op Code */
109 u8 bus; /* bus number */
110 u8 id; /* SCSI ID (virtual) */
111 u8 lun;
112 u8 flags; /* Bit Field - See above */
113 u8 physDiskNum; /* Phys disk number, -1 else */
114 u8 rsvd2;
115 u8 rsvd;
116 } INTERNAL_CMD;
117
118 /*
119 * Other private/forward protos...
120 */
121 int mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
122 static void mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq);
123 int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
124
125 static int mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
126 SCSIIORequest_t *pReq, int req_idx);
127 static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
128 static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
129 static int mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd);
130 static int mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout );
131 static int SCPNT_TO_LOOKUP_IDX(struct scsi_cmnd *sc);
132
133 static int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout);
134
135 int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
136 int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
137
138 static void mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, struct scsi_device *sdev);
139 static void mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *vtarget, struct scsi_device *sdev);
140 static int mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus);
141 int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
142 static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
143 static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
144
145 void mptscsih_remove(struct pci_dev *);
146 void mptscsih_shutdown(struct pci_dev *);
147 #ifdef CONFIG_PM
148 int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
149 int mptscsih_resume(struct pci_dev *pdev);
150 #endif
151
152 #define SNS_LEN(scp) sizeof((scp)->sense_buffer)
153
154 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
155 /**
156 * mptscsih_add_sge - Place a simple SGE at address pAddr.
157 * @pAddr: virtual address for SGE
158 * @flagslength: SGE flags and data transfer length
159 * @dma_addr: Physical address
160 *
161 * This routine places a MPT request frame back on the MPT adapter's
162 * FreeQ.
163 */
164 static inline void
165 mptscsih_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
166 {
167 if (sizeof(dma_addr_t) == sizeof(u64)) {
168 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
169 u32 tmp = dma_addr & 0xFFFFFFFF;
170
171 pSge->FlagsLength = cpu_to_le32(flagslength);
172 pSge->Address.Low = cpu_to_le32(tmp);
173 tmp = (u32) ((u64)dma_addr >> 32);
174 pSge->Address.High = cpu_to_le32(tmp);
175
176 } else {
177 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
178 pSge->FlagsLength = cpu_to_le32(flagslength);
179 pSge->Address = cpu_to_le32(dma_addr);
180 }
181 } /* mptscsih_add_sge() */
182
183 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
184 /**
185 * mptscsih_add_chain - Place a chain SGE at address pAddr.
186 * @pAddr: virtual address for SGE
187 * @next: nextChainOffset value (u32's)
188 * @length: length of next SGL segment
189 * @dma_addr: Physical address
190 *
191 * This routine places a MPT request frame back on the MPT adapter's
192 * FreeQ.
193 */
194 static inline void
195 mptscsih_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
196 {
197 if (sizeof(dma_addr_t) == sizeof(u64)) {
198 SGEChain64_t *pChain = (SGEChain64_t *) pAddr;
199 u32 tmp = dma_addr & 0xFFFFFFFF;
200
201 pChain->Length = cpu_to_le16(length);
202 pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
203
204 pChain->NextChainOffset = next;
205
206 pChain->Address.Low = cpu_to_le32(tmp);
207 tmp = (u32) ((u64)dma_addr >> 32);
208 pChain->Address.High = cpu_to_le32(tmp);
209 } else {
210 SGEChain32_t *pChain = (SGEChain32_t *) pAddr;
211 pChain->Length = cpu_to_le16(length);
212 pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
213 pChain->NextChainOffset = next;
214 pChain->Address = cpu_to_le32(dma_addr);
215 }
216 } /* mptscsih_add_chain() */
217
218 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
219 /*
220 * mptscsih_getFreeChainBuffer - Function to get a free chain
221 * from the MPT_SCSI_HOST FreeChainQ.
222 * @ioc: Pointer to MPT_ADAPTER structure
223 * @req_idx: Index of the SCSI IO request frame. (output)
224 *
225 * return SUCCESS or FAILED
226 */
227 static inline int
228 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
229 {
230 MPT_FRAME_HDR *chainBuf;
231 unsigned long flags;
232 int rc;
233 int chain_idx;
234
235 dsgprintk((MYIOC_s_INFO_FMT "getFreeChainBuffer called\n",
236 ioc->name));
237 spin_lock_irqsave(&ioc->FreeQlock, flags);
238 if (!list_empty(&ioc->FreeChainQ)) {
239 int offset;
240
241 chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR,
242 u.frame.linkage.list);
243 list_del(&chainBuf->u.frame.linkage.list);
244 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
245 chain_idx = offset / ioc->req_sz;
246 rc = SUCCESS;
247 dsgprintk((MYIOC_s_ERR_FMT "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
248 ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
249 } else {
250 rc = FAILED;
251 chain_idx = MPT_HOST_NO_CHAIN;
252 dfailprintk((MYIOC_s_INFO_FMT "getFreeChainBuffer failed\n",
253 ioc->name));
254 }
255 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
256
257 *retIndex = chain_idx;
258 return rc;
259 } /* mptscsih_getFreeChainBuffer() */
260
261 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
262 /*
263 * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
264 * SCSIIORequest_t Message Frame.
265 * @ioc: Pointer to MPT_ADAPTER structure
266 * @SCpnt: Pointer to scsi_cmnd structure
267 * @pReq: Pointer to SCSIIORequest_t structure
268 *
269 * Returns ...
270 */
271 static int
272 mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
273 SCSIIORequest_t *pReq, int req_idx)
274 {
275 char *psge;
276 char *chainSge;
277 struct scatterlist *sg;
278 int frm_sz;
279 int sges_left, sg_done;
280 int chain_idx = MPT_HOST_NO_CHAIN;
281 int sgeOffset;
282 int numSgeSlots, numSgeThisFrame;
283 u32 sgflags, sgdir, thisxfer = 0;
284 int chain_dma_off = 0;
285 int newIndex;
286 int ii;
287 dma_addr_t v2;
288 u32 RequestNB;
289
290 sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK;
291 if (sgdir == MPI_SCSIIO_CONTROL_WRITE) {
292 sgdir = MPT_TRANSFER_HOST_TO_IOC;
293 } else {
294 sgdir = MPT_TRANSFER_IOC_TO_HOST;
295 }
296
297 psge = (char *) &pReq->SGL;
298 frm_sz = ioc->req_sz;
299
300 /* Map the data portion, if any.
301 * sges_left = 0 if no data transfer.
302 */
303 if ( (sges_left = SCpnt->use_sg) ) {
304 sges_left = pci_map_sg(ioc->pcidev,
305 (struct scatterlist *) SCpnt->request_buffer,
306 SCpnt->use_sg,
307 SCpnt->sc_data_direction);
308 if (sges_left == 0)
309 return FAILED;
310 } else if (SCpnt->request_bufflen) {
311 SCpnt->SCp.dma_handle = pci_map_single(ioc->pcidev,
312 SCpnt->request_buffer,
313 SCpnt->request_bufflen,
314 SCpnt->sc_data_direction);
315 dsgprintk((MYIOC_s_INFO_FMT "SG: non-SG for %p, len=%d\n",
316 ioc->name, SCpnt, SCpnt->request_bufflen));
317 mptscsih_add_sge((char *) &pReq->SGL,
318 0xD1000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|SCpnt->request_bufflen,
319 SCpnt->SCp.dma_handle);
320
321 return SUCCESS;
322 }
323
324 /* Handle the SG case.
325 */
326 sg = (struct scatterlist *) SCpnt->request_buffer;
327 sg_done = 0;
328 sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION);
329 chainSge = NULL;
330
331 /* Prior to entering this loop - the following must be set
332 * current MF: sgeOffset (bytes)
333 * chainSge (Null if original MF is not a chain buffer)
334 * sg_done (num SGE done for this MF)
335 */
336
337 nextSGEset:
338 numSgeSlots = ((frm_sz - sgeOffset) / (sizeof(u32) + sizeof(dma_addr_t)) );
339 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
340
341 sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | MPT_SGE_FLAGS_ADDRESSING | sgdir;
342
343 /* Get first (num - 1) SG elements
344 * Skip any SG entries with a length of 0
345 * NOTE: at finish, sg and psge pointed to NEXT data/location positions
346 */
347 for (ii=0; ii < (numSgeThisFrame-1); ii++) {
348 thisxfer = sg_dma_len(sg);
349 if (thisxfer == 0) {
350 sg ++; /* Get next SG element from the OS */
351 sg_done++;
352 continue;
353 }
354
355 v2 = sg_dma_address(sg);
356 mptscsih_add_sge(psge, sgflags | thisxfer, v2);
357
358 sg++; /* Get next SG element from the OS */
359 psge += (sizeof(u32) + sizeof(dma_addr_t));
360 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
361 sg_done++;
362 }
363
364 if (numSgeThisFrame == sges_left) {
365 /* Add last element, end of buffer and end of list flags.
366 */
367 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT |
368 MPT_SGE_FLAGS_END_OF_BUFFER |
369 MPT_SGE_FLAGS_END_OF_LIST;
370
371 /* Add last SGE and set termination flags.
372 * Note: Last SGE may have a length of 0 - which should be ok.
373 */
374 thisxfer = sg_dma_len(sg);
375
376 v2 = sg_dma_address(sg);
377 mptscsih_add_sge(psge, sgflags | thisxfer, v2);
378 /*
379 sg++;
380 psge += (sizeof(u32) + sizeof(dma_addr_t));
381 */
382 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
383 sg_done++;
384
385 if (chainSge) {
386 /* The current buffer is a chain buffer,
387 * but there is not another one.
388 * Update the chain element
389 * Offset and Length fields.
390 */
391 mptscsih_add_chain((char *)chainSge, 0, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
392 } else {
393 /* The current buffer is the original MF
394 * and there is no Chain buffer.
395 */
396 pReq->ChainOffset = 0;
397 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
398 dsgprintk((MYIOC_s_INFO_FMT
399 "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
400 ioc->RequestNB[req_idx] = RequestNB;
401 }
402 } else {
403 /* At least one chain buffer is needed.
404 * Complete the first MF
405 * - last SGE element, set the LastElement bit
406 * - set ChainOffset (words) for orig MF
407 * (OR finish previous MF chain buffer)
408 * - update MFStructPtr ChainIndex
409 * - Populate chain element
410 * Also
411 * Loop until done.
412 */
413
414 dsgprintk((MYIOC_s_INFO_FMT "SG: Chain Required! sg done %d\n",
415 ioc->name, sg_done));
416
417 /* Set LAST_ELEMENT flag for last non-chain element
418 * in the buffer. Since psge points at the NEXT
419 * SGE element, go back one SGE element, update the flags
420 * and reset the pointer. (Note: sgflags & thisxfer are already
421 * set properly).
422 */
423 if (sg_done) {
424 u32 *ptmp = (u32 *) (psge - (sizeof(u32) + sizeof(dma_addr_t)));
425 sgflags = le32_to_cpu(*ptmp);
426 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
427 *ptmp = cpu_to_le32(sgflags);
428 }
429
430 if (chainSge) {
431 /* The current buffer is a chain buffer.
432 * chainSge points to the previous Chain Element.
433 * Update its chain element Offset and Length (must
434 * include chain element size) fields.
435 * Old chain element is now complete.
436 */
437 u8 nextChain = (u8) (sgeOffset >> 2);
438 sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
439 mptscsih_add_chain((char *)chainSge, nextChain, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
440 } else {
441 /* The original MF buffer requires a chain buffer -
442 * set the offset.
443 * Last element in this MF is a chain element.
444 */
445 pReq->ChainOffset = (u8) (sgeOffset >> 2);
446 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
447 dsgprintk((MYIOC_s_ERR_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
448 ioc->RequestNB[req_idx] = RequestNB;
449 }
450
451 sges_left -= sg_done;
452
453
454 /* NOTE: psge points to the beginning of the chain element
455 * in current buffer. Get a chain buffer.
456 */
457 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) {
458 dfailprintk((MYIOC_s_INFO_FMT
459 "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n",
460 ioc->name, pReq->CDB[0], SCpnt));
461 return FAILED;
462 }
463
464 /* Update the tracking arrays.
465 * If chainSge == NULL, update ReqToChain, else ChainToChain
466 */
467 if (chainSge) {
468 ioc->ChainToChain[chain_idx] = newIndex;
469 } else {
470 ioc->ReqToChain[req_idx] = newIndex;
471 }
472 chain_idx = newIndex;
473 chain_dma_off = ioc->req_sz * chain_idx;
474
475 /* Populate the chainSGE for the current buffer.
476 * - Set chain buffer pointer to psge and fill
477 * out the Address and Flags fields.
478 */
479 chainSge = (char *) psge;
480 dsgprintk((KERN_INFO " Current buff @ %p (index 0x%x)",
481 psge, req_idx));
482
483 /* Start the SGE for the next buffer
484 */
485 psge = (char *) (ioc->ChainBuffer + chain_dma_off);
486 sgeOffset = 0;
487 sg_done = 0;
488
489 dsgprintk((KERN_INFO " Chain buff @ %p (index 0x%x)\n",
490 psge, chain_idx));
491
492 /* Start the SGE for the next buffer
493 */
494
495 goto nextSGEset;
496 }
497
498 return SUCCESS;
499 } /* mptscsih_AddSGE() */
500
501 static void
502 mptscsih_issue_sep_command(MPT_ADAPTER *ioc, VirtTarget *vtarget,
503 U32 SlotStatus)
504 {
505 MPT_FRAME_HDR *mf;
506 SEPRequest_t *SEPMsg;
507
508 if (ioc->bus_type == FC)
509 return;
510
511 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
512 dfailprintk((MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
513 ioc->name,__FUNCTION__));
514 return;
515 }
516
517 SEPMsg = (SEPRequest_t *)mf;
518 SEPMsg->Function = MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
519 SEPMsg->Bus = vtarget->bus_id;
520 SEPMsg->TargetID = vtarget->target_id;
521 SEPMsg->Action = MPI_SEP_REQ_ACTION_WRITE_STATUS;
522 SEPMsg->SlotStatus = SlotStatus;
523 devtverboseprintk((MYIOC_s_WARN_FMT
524 "Sending SEP cmd=%x id=%d bus=%d\n",
525 ioc->name, SlotStatus, SEPMsg->TargetID, SEPMsg->Bus));
526 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
527 }
528
529 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
530 /*
531 * mptscsih_io_done - Main SCSI IO callback routine registered to
532 * Fusion MPT (base) driver
533 * @ioc: Pointer to MPT_ADAPTER structure
534 * @mf: Pointer to original MPT request frame
535 * @r: Pointer to MPT reply frame (NULL if TurboReply)
536 *
537 * This routine is called from mpt.c::mpt_interrupt() at the completion
538 * of any SCSI IO request.
539 * This routine is registered with the Fusion MPT (base) driver at driver
540 * load/init time via the mpt_register() API call.
541 *
542 * Returns 1 indicating alloc'd request frame ptr should be freed.
543 */
544 int
545 mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
546 {
547 struct scsi_cmnd *sc;
548 MPT_SCSI_HOST *hd;
549 SCSIIORequest_t *pScsiReq;
550 SCSIIOReply_t *pScsiReply;
551 u16 req_idx, req_idx_MR;
552 VirtDevice *vdev;
553 VirtTarget *vtarget;
554
555 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
556
557 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
558 req_idx_MR = (mr != NULL) ?
559 le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
560 if ((req_idx != req_idx_MR) ||
561 (mf->u.frame.linkage.arg1 == 0xdeadbeaf)) {
562 printk(MYIOC_s_ERR_FMT "Received a mf that was already freed\n",
563 ioc->name);
564 printk (MYIOC_s_ERR_FMT
565 "req_idx=%x req_idx_MR=%x mf=%p mr=%p sc=%p\n",
566 ioc->name, req_idx, req_idx_MR, mf, mr,
567 hd->ScsiLookup[req_idx_MR]);
568 return 0;
569 }
570
571 sc = hd->ScsiLookup[req_idx];
572 hd->ScsiLookup[req_idx] = NULL;
573 if (sc == NULL) {
574 MPIHeader_t *hdr = (MPIHeader_t *)mf;
575
576 /* Remark: writeSDP1 will use the ScsiDoneCtx
577 * If a SCSI I/O cmd, device disabled by OS and
578 * completion done. Cannot touch sc struct. Just free mem.
579 */
580 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST)
581 printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n",
582 ioc->name);
583
584 mptscsih_freeChainBuffers(ioc, req_idx);
585 return 1;
586 }
587
588 if ((unsigned char *)mf != sc->host_scribble) {
589 mptscsih_freeChainBuffers(ioc, req_idx);
590 return 1;
591 }
592
593 sc->host_scribble = NULL;
594 sc->result = DID_OK << 16; /* Set default reply as OK */
595 pScsiReq = (SCSIIORequest_t *) mf;
596 pScsiReply = (SCSIIOReply_t *) mr;
597
598 if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
599 dmfprintk((MYIOC_s_INFO_FMT
600 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
601 ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
602 }else{
603 dmfprintk((MYIOC_s_INFO_FMT
604 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n",
605 ioc->name, mf, mr, sc, req_idx));
606 }
607
608 if (pScsiReply == NULL) {
609 /* special context reply handling */
610 ;
611 } else {
612 u32 xfer_cnt;
613 u16 status;
614 u8 scsi_state, scsi_status;
615
616 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
617 scsi_state = pScsiReply->SCSIState;
618 scsi_status = pScsiReply->SCSIStatus;
619 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
620 sc->resid = sc->request_bufflen - xfer_cnt;
621
622 /*
623 * if we get a data underrun indication, yet no data was
624 * transferred and the SCSI status indicates that the
625 * command was never started, change the data underrun
626 * to success
627 */
628 if (status == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
629 (scsi_status == MPI_SCSI_STATUS_BUSY ||
630 scsi_status == MPI_SCSI_STATUS_RESERVATION_CONFLICT ||
631 scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)) {
632 status = MPI_IOCSTATUS_SUCCESS;
633 }
634
635 dreplyprintk((KERN_NOTICE "Reply ha=%d id=%d lun=%d:\n"
636 "IOCStatus=%04xh SCSIState=%02xh SCSIStatus=%02xh\n"
637 "resid=%d bufflen=%d xfer_cnt=%d\n",
638 ioc->id, sc->device->id, sc->device->lun,
639 status, scsi_state, scsi_status, sc->resid,
640 sc->request_bufflen, xfer_cnt));
641
642 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
643 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
644
645 /*
646 * Look for + dump FCP ResponseInfo[]!
647 */
648 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
649 pScsiReply->ResponseInfo) {
650 printk(KERN_NOTICE "ha=%d id=%d lun=%d: "
651 "FCP_ResponseInfo=%08xh\n",
652 ioc->id, sc->device->id, sc->device->lun,
653 le32_to_cpu(pScsiReply->ResponseInfo));
654 }
655
656 switch(status) {
657 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
658 /* CHECKME!
659 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
660 * But not: DID_BUS_BUSY lest one risk
661 * killing interrupt handler:-(
662 */
663 sc->result = SAM_STAT_BUSY;
664 break;
665
666 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
667 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
668 sc->result = DID_BAD_TARGET << 16;
669 break;
670
671 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
672 /* Spoof to SCSI Selection Timeout! */
673 if (ioc->bus_type != FC)
674 sc->result = DID_NO_CONNECT << 16;
675 /* else fibre, just stall until rescan event */
676 else
677 sc->result = DID_REQUEUE << 16;
678
679 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
680 hd->sel_timeout[pScsiReq->TargetID]++;
681
682 vdev = sc->device->hostdata;
683 if (!vdev)
684 break;
685 vtarget = vdev->vtarget;
686 if (vtarget->tflags & MPT_TARGET_FLAGS_LED_ON) {
687 mptscsih_issue_sep_command(ioc, vtarget,
688 MPI_SEP_REQ_SLOTSTATUS_UNCONFIGURED);
689 vtarget->tflags &= ~MPT_TARGET_FLAGS_LED_ON;
690 }
691 break;
692
693 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
694 if ( ioc->bus_type == SAS ) {
695 u16 ioc_status = le16_to_cpu(pScsiReply->IOCStatus);
696 if (ioc_status & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
697 u32 log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
698 log_info &=SAS_LOGINFO_MASK;
699 if (log_info == SAS_LOGINFO_NEXUS_LOSS) {
700 sc->result = (DID_BUS_BUSY << 16);
701 break;
702 }
703 }
704 }
705
706 /*
707 * Allow non-SAS & non-NEXUS_LOSS to drop into below code
708 */
709
710 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
711 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
712 /* Linux handles an unsolicited DID_RESET better
713 * than an unsolicited DID_ABORT.
714 */
715 sc->result = DID_RESET << 16;
716
717 break;
718
719 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
720 sc->resid = sc->request_bufflen - xfer_cnt;
721 if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
722 sc->result=DID_SOFT_ERROR << 16;
723 else /* Sufficient data transfer occurred */
724 sc->result = (DID_OK << 16) | scsi_status;
725 dreplyprintk((KERN_NOTICE
726 "RESIDUAL_MISMATCH: result=%x on id=%d\n", sc->result, sc->device->id));
727 break;
728
729 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
730 /*
731 * Do upfront check for valid SenseData and give it
732 * precedence!
733 */
734 sc->result = (DID_OK << 16) | scsi_status;
735 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
736 /* Have already saved the status and sense data
737 */
738 ;
739 } else {
740 if (xfer_cnt < sc->underflow) {
741 if (scsi_status == SAM_STAT_BUSY)
742 sc->result = SAM_STAT_BUSY;
743 else
744 sc->result = DID_SOFT_ERROR << 16;
745 }
746 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
747 /* What to do?
748 */
749 sc->result = DID_SOFT_ERROR << 16;
750 }
751 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
752 /* Not real sure here either... */
753 sc->result = DID_RESET << 16;
754 }
755 }
756
757 dreplyprintk((KERN_NOTICE " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
758 sc->underflow));
759 dreplyprintk((KERN_NOTICE " ActBytesXferd=%02xh\n", xfer_cnt));
760 /* Report Queue Full
761 */
762 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
763 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
764
765 break;
766
767 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
768 sc->resid=0;
769 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
770 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
771 if (scsi_status == MPI_SCSI_STATUS_BUSY)
772 sc->result = (DID_BUS_BUSY << 16) | scsi_status;
773 else
774 sc->result = (DID_OK << 16) | scsi_status;
775 if (scsi_state == 0) {
776 ;
777 } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
778 /*
779 * If running against circa 200003dd 909 MPT f/w,
780 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
781 * (QUEUE_FULL) returned from device! --> get 0x0000?128
782 * and with SenseBytes set to 0.
783 */
784 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
785 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
786
787 }
788 else if (scsi_state &
789 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
790 ) {
791 /*
792 * What to do?
793 */
794 sc->result = DID_SOFT_ERROR << 16;
795 }
796 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
797 /* Not real sure here either... */
798 sc->result = DID_RESET << 16;
799 }
800 else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) {
801 /* Device Inq. data indicates that it supports
802 * QTags, but rejects QTag messages.
803 * This command completed OK.
804 *
805 * Not real sure here either so do nothing... */
806 }
807
808 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
809 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
810
811 /* Add handling of:
812 * Reservation Conflict, Busy,
813 * Command Terminated, CHECK
814 */
815 break;
816
817 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
818 sc->result = DID_SOFT_ERROR << 16;
819 break;
820
821 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
822 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
823 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
824 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
825 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
826 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
827 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
828 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
829 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
830 default:
831 /*
832 * What to do?
833 */
834 sc->result = DID_SOFT_ERROR << 16;
835 break;
836
837 } /* switch(status) */
838
839 dreplyprintk((KERN_NOTICE " sc->result is %08xh\n", sc->result));
840 } /* end of address reply case */
841
842 /* Unmap the DMA buffers, if any. */
843 if (sc->use_sg) {
844 pci_unmap_sg(ioc->pcidev, (struct scatterlist *) sc->request_buffer,
845 sc->use_sg, sc->sc_data_direction);
846 } else if (sc->request_bufflen) {
847 pci_unmap_single(ioc->pcidev, sc->SCp.dma_handle,
848 sc->request_bufflen, sc->sc_data_direction);
849 }
850
851 sc->scsi_done(sc); /* Issue the command callback */
852
853 /* Free Chain buffers */
854 mptscsih_freeChainBuffers(ioc, req_idx);
855 return 1;
856 }
857
858 /*
859 * mptscsih_flush_running_cmds - For each command found, search
860 * Scsi_Host instance taskQ and reply to OS.
861 * Called only if recovering from a FW reload.
862 * @hd: Pointer to a SCSI HOST structure
863 *
864 * Returns: None.
865 *
866 * Must be called while new I/Os are being queued.
867 */
868 static void
869 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
870 {
871 MPT_ADAPTER *ioc = hd->ioc;
872 struct scsi_cmnd *SCpnt;
873 MPT_FRAME_HDR *mf;
874 int ii;
875 int max = ioc->req_depth;
876
877 dprintk((KERN_INFO MYNAM ": flush_ScsiLookup called\n"));
878 for (ii= 0; ii < max; ii++) {
879 if ((SCpnt = hd->ScsiLookup[ii]) != NULL) {
880
881 /* Command found.
882 */
883
884 /* Null ScsiLookup index
885 */
886 hd->ScsiLookup[ii] = NULL;
887
888 mf = MPT_INDEX_2_MFPTR(ioc, ii);
889 dmfprintk(( "flush: ScsiDone (mf=%p,sc=%p)\n",
890 mf, SCpnt));
891
892 /* Free Chain buffers */
893 mptscsih_freeChainBuffers(ioc, ii);
894
895 /* Free Message frames */
896 mpt_free_msg_frame(ioc, mf);
897
898 if ((unsigned char *)mf != SCpnt->host_scribble)
899 continue;
900
901 /* Set status, free OS resources (SG DMA buffers)
902 * Do OS callback
903 */
904 if (SCpnt->use_sg) {
905 pci_unmap_sg(ioc->pcidev,
906 (struct scatterlist *) SCpnt->request_buffer,
907 SCpnt->use_sg,
908 SCpnt->sc_data_direction);
909 } else if (SCpnt->request_bufflen) {
910 pci_unmap_single(ioc->pcidev,
911 SCpnt->SCp.dma_handle,
912 SCpnt->request_bufflen,
913 SCpnt->sc_data_direction);
914 }
915 SCpnt->result = DID_RESET << 16;
916 SCpnt->host_scribble = NULL;
917
918 SCpnt->scsi_done(SCpnt); /* Issue the command callback */
919 }
920 }
921
922 return;
923 }
924
925 /*
926 * mptscsih_search_running_cmds - Delete any commands associated
927 * with the specified target and lun. Function called only
928 * when a lun is disable by mid-layer.
929 * Do NOT access the referenced scsi_cmnd structure or
930 * members. Will cause either a paging or NULL ptr error.
931 * (BUT, BUT, BUT, the code does reference it! - mdr)
932 * @hd: Pointer to a SCSI HOST structure
933 * @vdevice: per device private data
934 *
935 * Returns: None.
936 *
937 * Called from slave_destroy.
938 */
939 static void
940 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
941 {
942 SCSIIORequest_t *mf = NULL;
943 int ii;
944 int max = hd->ioc->req_depth;
945 struct scsi_cmnd *sc;
946
947 dsprintk((KERN_INFO MYNAM ": search_running target %d lun %d max %d\n",
948 vdevice->vtarget->target_id, vdevice->lun, max));
949
950 for (ii=0; ii < max; ii++) {
951 if ((sc = hd->ScsiLookup[ii]) != NULL) {
952
953 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(hd->ioc, ii);
954 if (mf == NULL)
955 continue;
956 dsprintk(( "search_running: found (sc=%p, mf = %p) target %d, lun %d \n",
957 hd->ScsiLookup[ii], mf, mf->TargetID, mf->LUN[1]));
958 if ((mf->TargetID != ((u8)vdevice->vtarget->target_id)) || (mf->LUN[1] != ((u8) vdevice->lun)))
959 continue;
960
961 /* Cleanup
962 */
963 hd->ScsiLookup[ii] = NULL;
964 mptscsih_freeChainBuffers(hd->ioc, ii);
965 mpt_free_msg_frame(hd->ioc, (MPT_FRAME_HDR *)mf);
966 if ((unsigned char *)mf != sc->host_scribble)
967 continue;
968 if (sc->use_sg) {
969 pci_unmap_sg(hd->ioc->pcidev,
970 (struct scatterlist *) sc->request_buffer,
971 sc->use_sg,
972 sc->sc_data_direction);
973 } else if (sc->request_bufflen) {
974 pci_unmap_single(hd->ioc->pcidev,
975 sc->SCp.dma_handle,
976 sc->request_bufflen,
977 sc->sc_data_direction);
978 }
979 sc->host_scribble = NULL;
980 sc->result = DID_NO_CONNECT << 16;
981 sc->scsi_done(sc);
982 }
983 }
984 return;
985 }
986
987 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
988
989 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
990 /*
991 * mptscsih_report_queue_full - Report QUEUE_FULL status returned
992 * from a SCSI target device.
993 * @sc: Pointer to scsi_cmnd structure
994 * @pScsiReply: Pointer to SCSIIOReply_t
995 * @pScsiReq: Pointer to original SCSI request
996 *
997 * This routine periodically reports QUEUE_FULL status returned from a
998 * SCSI target device. It reports this to the console via kernel
999 * printk() API call, not more than once every 10 seconds.
1000 */
1001 static void
1002 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
1003 {
1004 long time = jiffies;
1005 MPT_SCSI_HOST *hd;
1006
1007 if (sc->device == NULL)
1008 return;
1009 if (sc->device->host == NULL)
1010 return;
1011 if ((hd = (MPT_SCSI_HOST *)sc->device->host->hostdata) == NULL)
1012 return;
1013
1014 if (time - hd->last_queue_full > 10 * HZ) {
1015 dprintk((MYIOC_s_WARN_FMT "Device (%d:%d:%d) reported QUEUE_FULL!\n",
1016 hd->ioc->name, 0, sc->device->id, sc->device->lun));
1017 hd->last_queue_full = time;
1018 }
1019 }
1020
1021 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1022 /*
1023 * mptscsih_remove - Removed scsi devices
1024 * @pdev: Pointer to pci_dev structure
1025 *
1026 *
1027 */
1028 void
1029 mptscsih_remove(struct pci_dev *pdev)
1030 {
1031 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1032 struct Scsi_Host *host = ioc->sh;
1033 MPT_SCSI_HOST *hd;
1034 int sz1;
1035
1036 if(!host) {
1037 mpt_detach(pdev);
1038 return;
1039 }
1040
1041 scsi_remove_host(host);
1042
1043 if((hd = (MPT_SCSI_HOST *)host->hostdata) == NULL)
1044 return;
1045
1046 mptscsih_shutdown(pdev);
1047
1048 sz1=0;
1049
1050 if (hd->ScsiLookup != NULL) {
1051 sz1 = hd->ioc->req_depth * sizeof(void *);
1052 kfree(hd->ScsiLookup);
1053 hd->ScsiLookup = NULL;
1054 }
1055
1056 /*
1057 * Free pointer array.
1058 */
1059 kfree(hd->Targets);
1060 hd->Targets = NULL;
1061
1062 dprintk((MYIOC_s_INFO_FMT
1063 "Free'd ScsiLookup (%d) memory\n",
1064 hd->ioc->name, sz1));
1065
1066 kfree(hd->info_kbuf);
1067
1068 /* NULL the Scsi_Host pointer
1069 */
1070 hd->ioc->sh = NULL;
1071
1072 scsi_host_put(host);
1073
1074 mpt_detach(pdev);
1075
1076 }
1077
1078 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1079 /*
1080 * mptscsih_shutdown - reboot notifier
1081 *
1082 */
1083 void
1084 mptscsih_shutdown(struct pci_dev *pdev)
1085 {
1086 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1087 struct Scsi_Host *host = ioc->sh;
1088 MPT_SCSI_HOST *hd;
1089
1090 if(!host)
1091 return;
1092
1093 hd = (MPT_SCSI_HOST *)host->hostdata;
1094
1095 }
1096
1097 #ifdef CONFIG_PM
1098 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1099 /*
1100 * mptscsih_suspend - Fusion MPT scsi driver suspend routine.
1101 *
1102 *
1103 */
1104 int
1105 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
1106 {
1107 mptscsih_shutdown(pdev);
1108 return mpt_suspend(pdev,state);
1109 }
1110
1111 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1112 /*
1113 * mptscsih_resume - Fusion MPT scsi driver resume routine.
1114 *
1115 *
1116 */
1117 int
1118 mptscsih_resume(struct pci_dev *pdev)
1119 {
1120 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1121 struct Scsi_Host *host = ioc->sh;
1122 MPT_SCSI_HOST *hd;
1123
1124 mpt_resume(pdev);
1125
1126 if(!host)
1127 return 0;
1128
1129 hd = (MPT_SCSI_HOST *)host->hostdata;
1130 if(!hd)
1131 return 0;
1132
1133 return 0;
1134 }
1135
1136 #endif
1137
1138 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1139 /**
1140 * mptscsih_info - Return information about MPT adapter
1141 * @SChost: Pointer to Scsi_Host structure
1142 *
1143 * (linux scsi_host_template.info routine)
1144 *
1145 * Returns pointer to buffer where information was written.
1146 */
1147 const char *
1148 mptscsih_info(struct Scsi_Host *SChost)
1149 {
1150 MPT_SCSI_HOST *h;
1151 int size = 0;
1152
1153 h = (MPT_SCSI_HOST *)SChost->hostdata;
1154
1155 if (h) {
1156 if (h->info_kbuf == NULL)
1157 if ((h->info_kbuf = kmalloc(0x1000 /* 4Kb */, GFP_KERNEL)) == NULL)
1158 return h->info_kbuf;
1159 h->info_kbuf[0] = '\0';
1160
1161 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0);
1162 h->info_kbuf[size-1] = '\0';
1163 }
1164
1165 return h->info_kbuf;
1166 }
1167
1168 struct info_str {
1169 char *buffer;
1170 int length;
1171 int offset;
1172 int pos;
1173 };
1174
1175 static void
1176 mptscsih_copy_mem_info(struct info_str *info, char *data, int len)
1177 {
1178 if (info->pos + len > info->length)
1179 len = info->length - info->pos;
1180
1181 if (info->pos + len < info->offset) {
1182 info->pos += len;
1183 return;
1184 }
1185
1186 if (info->pos < info->offset) {
1187 data += (info->offset - info->pos);
1188 len -= (info->offset - info->pos);
1189 }
1190
1191 if (len > 0) {
1192 memcpy(info->buffer + info->pos, data, len);
1193 info->pos += len;
1194 }
1195 }
1196
1197 static int
1198 mptscsih_copy_info(struct info_str *info, char *fmt, ...)
1199 {
1200 va_list args;
1201 char buf[81];
1202 int len;
1203
1204 va_start(args, fmt);
1205 len = vsprintf(buf, fmt, args);
1206 va_end(args);
1207
1208 mptscsih_copy_mem_info(info, buf, len);
1209 return len;
1210 }
1211
1212 static int
1213 mptscsih_host_info(MPT_ADAPTER *ioc, char *pbuf, off_t offset, int len)
1214 {
1215 struct info_str info;
1216
1217 info.buffer = pbuf;
1218 info.length = len;
1219 info.offset = offset;
1220 info.pos = 0;
1221
1222 mptscsih_copy_info(&info, "%s: %s, ", ioc->name, ioc->prod_name);
1223 mptscsih_copy_info(&info, "%s%08xh, ", MPT_FW_REV_MAGIC_ID_STRING, ioc->facts.FWVersion.Word);
1224 mptscsih_copy_info(&info, "Ports=%d, ", ioc->facts.NumberOfPorts);
1225 mptscsih_copy_info(&info, "MaxQ=%d\n", ioc->req_depth);
1226
1227 return ((info.pos > info.offset) ? info.pos - info.offset : 0);
1228 }
1229
1230 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1231 /**
1232 * mptscsih_proc_info - Return information about MPT adapter
1233 *
1234 * (linux scsi_host_template.info routine)
1235 *
1236 * buffer: if write, user data; if read, buffer for user
1237 * length: if write, return length;
1238 * offset: if write, 0; if read, the current offset into the buffer from
1239 * the previous read.
1240 * hostno: scsi host number
1241 * func: if write = 1; if read = 0
1242 */
1243 int
1244 mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1245 int length, int func)
1246 {
1247 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
1248 MPT_ADAPTER *ioc = hd->ioc;
1249 int size = 0;
1250
1251 if (func) {
1252 /*
1253 * write is not supported
1254 */
1255 } else {
1256 if (start)
1257 *start = buffer;
1258
1259 size = mptscsih_host_info(ioc, buffer, offset, length);
1260 }
1261
1262 return size;
1263 }
1264
1265 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1266 #define ADD_INDEX_LOG(req_ent) do { } while(0)
1267
1268 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1269 /**
1270 * mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine.
1271 * @SCpnt: Pointer to scsi_cmnd structure
1272 * @done: Pointer SCSI mid-layer IO completion function
1273 *
1274 * (linux scsi_host_template.queuecommand routine)
1275 * This is the primary SCSI IO start routine. Create a MPI SCSIIORequest
1276 * from a linux scsi_cmnd request and send it to the IOC.
1277 *
1278 * Returns 0. (rtn value discarded by linux scsi mid-layer)
1279 */
1280 int
1281 mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1282 {
1283 MPT_SCSI_HOST *hd;
1284 MPT_FRAME_HDR *mf;
1285 SCSIIORequest_t *pScsiReq;
1286 VirtDevice *vdev = SCpnt->device->hostdata;
1287 int lun;
1288 u32 datalen;
1289 u32 scsictl;
1290 u32 scsidir;
1291 u32 cmd_len;
1292 int my_idx;
1293 int ii;
1294
1295 hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
1296 lun = SCpnt->device->lun;
1297 SCpnt->scsi_done = done;
1298
1299 dmfprintk((MYIOC_s_INFO_FMT "qcmd: SCpnt=%p, done()=%p\n",
1300 (hd && hd->ioc) ? hd->ioc->name : "ioc?", SCpnt, done));
1301
1302 if (hd->resetPending) {
1303 dtmprintk((MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n",
1304 (hd && hd->ioc) ? hd->ioc->name : "ioc?", SCpnt));
1305 return SCSI_MLQUEUE_HOST_BUSY;
1306 }
1307
1308 if ((hd->ioc->bus_type == SPI) &&
1309 vdev->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT &&
1310 mptscsih_raid_id_to_num(hd, SCpnt->device->id) < 0) {
1311 SCpnt->result = DID_NO_CONNECT << 16;
1312 done(SCpnt);
1313 return 0;
1314 }
1315
1316 /*
1317 * Put together a MPT SCSI request...
1318 */
1319 if ((mf = mpt_get_msg_frame(hd->ioc->DoneCtx, hd->ioc)) == NULL) {
1320 dprintk((MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
1321 hd->ioc->name));
1322 return SCSI_MLQUEUE_HOST_BUSY;
1323 }
1324
1325 pScsiReq = (SCSIIORequest_t *) mf;
1326
1327 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1328
1329 ADD_INDEX_LOG(my_idx);
1330
1331 /* TUR's being issued with scsictl=0x02000000 (DATA_IN)!
1332 * Seems we may receive a buffer (datalen>0) even when there
1333 * will be no data transfer! GRRRRR...
1334 */
1335 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1336 datalen = SCpnt->request_bufflen;
1337 scsidir = MPI_SCSIIO_CONTROL_READ; /* DATA IN (host<--ioc<--dev) */
1338 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1339 datalen = SCpnt->request_bufflen;
1340 scsidir = MPI_SCSIIO_CONTROL_WRITE; /* DATA OUT (host-->ioc-->dev) */
1341 } else {
1342 datalen = 0;
1343 scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER;
1344 }
1345
1346 /* Default to untagged. Once a target structure has been allocated,
1347 * use the Inquiry data to determine if device supports tagged.
1348 */
1349 if (vdev
1350 && (vdev->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
1351 && (SCpnt->device->tagged_supported)) {
1352 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
1353 } else {
1354 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
1355 }
1356
1357 /* Use the above information to set up the message frame
1358 */
1359 pScsiReq->TargetID = (u8) vdev->vtarget->target_id;
1360 pScsiReq->Bus = vdev->vtarget->bus_id;
1361 pScsiReq->ChainOffset = 0;
1362 if (vdev->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
1363 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
1364 else
1365 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
1366 pScsiReq->CDBLength = SCpnt->cmd_len;
1367 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1368 pScsiReq->Reserved = 0;
1369 pScsiReq->MsgFlags = mpt_msg_flags();
1370 pScsiReq->LUN[0] = 0;
1371 pScsiReq->LUN[1] = lun;
1372 pScsiReq->LUN[2] = 0;
1373 pScsiReq->LUN[3] = 0;
1374 pScsiReq->LUN[4] = 0;
1375 pScsiReq->LUN[5] = 0;
1376 pScsiReq->LUN[6] = 0;
1377 pScsiReq->LUN[7] = 0;
1378 pScsiReq->Control = cpu_to_le32(scsictl);
1379
1380 /*
1381 * Write SCSI CDB into the message
1382 */
1383 cmd_len = SCpnt->cmd_len;
1384 for (ii=0; ii < cmd_len; ii++)
1385 pScsiReq->CDB[ii] = SCpnt->cmnd[ii];
1386
1387 for (ii=cmd_len; ii < 16; ii++)
1388 pScsiReq->CDB[ii] = 0;
1389
1390 /* DataLength */
1391 pScsiReq->DataLength = cpu_to_le32(datalen);
1392
1393 /* SenseBuffer low address */
1394 pScsiReq->SenseBufferLowAddr = cpu_to_le32(hd->ioc->sense_buf_low_dma
1395 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
1396
1397 /* Now add the SG list
1398 * Always have a SGE even if null length.
1399 */
1400 if (datalen == 0) {
1401 /* Add a NULL SGE */
1402 mptscsih_add_sge((char *)&pScsiReq->SGL, MPT_SGE_FLAGS_SSIMPLE_READ | 0,
1403 (dma_addr_t) -1);
1404 } else {
1405 /* Add a 32 or 64 bit SGE */
1406 if (mptscsih_AddSGE(hd->ioc, SCpnt, pScsiReq, my_idx) != SUCCESS)
1407 goto fail;
1408 }
1409
1410 SCpnt->host_scribble = (unsigned char *)mf;
1411 hd->ScsiLookup[my_idx] = SCpnt;
1412
1413 mpt_put_msg_frame(hd->ioc->DoneCtx, hd->ioc, mf);
1414 dmfprintk((MYIOC_s_INFO_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n",
1415 hd->ioc->name, SCpnt, mf, my_idx));
1416 DBG_DUMP_REQUEST_FRAME(mf)
1417 return 0;
1418
1419 fail:
1420 hd->ScsiLookup[my_idx] = NULL;
1421 mptscsih_freeChainBuffers(hd->ioc, my_idx);
1422 mpt_free_msg_frame(hd->ioc, mf);
1423 return SCSI_MLQUEUE_HOST_BUSY;
1424 }
1425
1426 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1427 /*
1428 * mptscsih_freeChainBuffers - Function to free chain buffers associated
1429 * with a SCSI IO request
1430 * @hd: Pointer to the MPT_SCSI_HOST instance
1431 * @req_idx: Index of the SCSI IO request frame.
1432 *
1433 * Called if SG chain buffer allocation fails and mptscsih callbacks.
1434 * No return.
1435 */
1436 static void
1437 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
1438 {
1439 MPT_FRAME_HDR *chain;
1440 unsigned long flags;
1441 int chain_idx;
1442 int next;
1443
1444 /* Get the first chain index and reset
1445 * tracker state.
1446 */
1447 chain_idx = ioc->ReqToChain[req_idx];
1448 ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN;
1449
1450 while (chain_idx != MPT_HOST_NO_CHAIN) {
1451
1452 /* Save the next chain buffer index */
1453 next = ioc->ChainToChain[chain_idx];
1454
1455 /* Free this chain buffer and reset
1456 * tracker
1457 */
1458 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN;
1459
1460 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer
1461 + (chain_idx * ioc->req_sz));
1462
1463 spin_lock_irqsave(&ioc->FreeQlock, flags);
1464 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);
1465 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1466
1467 dmfprintk((MYIOC_s_INFO_FMT "FreeChainBuffers (index %d)\n",
1468 ioc->name, chain_idx));
1469
1470 /* handle next */
1471 chain_idx = next;
1472 }
1473 return;
1474 }
1475
1476 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1477 /*
1478 * Reset Handling
1479 */
1480
1481 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1482 /*
1483 * mptscsih_TMHandler - Generic handler for SCSI Task Management.
1484 * Fall through to mpt_HardResetHandler if: not operational, too many
1485 * failed TM requests or handshake failure.
1486 *
1487 * @ioc: Pointer to MPT_ADAPTER structure
1488 * @type: Task Management type
1489 * @target: Logical Target ID for reset (if appropriate)
1490 * @lun: Logical Unit for reset (if appropriate)
1491 * @ctx2abort: Context for the task to be aborted (if appropriate)
1492 *
1493 * Remark: Currently invoked from a non-interrupt thread (_bh).
1494 *
1495 * Remark: With old EH code, at most 1 SCSI TaskMgmt function per IOC
1496 * will be active.
1497 *
1498 * Returns 0 for SUCCESS or -1 if FAILED.
1499 */
1500 int
1501 mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout)
1502 {
1503 MPT_ADAPTER *ioc;
1504 int rc = -1;
1505 int doTask = 1;
1506 u32 ioc_raw_state;
1507 unsigned long flags;
1508
1509 /* If FW is being reloaded currently, return success to
1510 * the calling function.
1511 */
1512 if (hd == NULL)
1513 return 0;
1514
1515 ioc = hd->ioc;
1516 if (ioc == NULL) {
1517 printk(KERN_ERR MYNAM " TMHandler" " NULL ioc!\n");
1518 return FAILED;
1519 }
1520 dtmprintk((MYIOC_s_INFO_FMT "TMHandler Entered!\n", ioc->name));
1521
1522 // SJR - CHECKME - Can we avoid this here?
1523 // (mpt_HardResetHandler has this check...)
1524 spin_lock_irqsave(&ioc->diagLock, flags);
1525 if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)) {
1526 spin_unlock_irqrestore(&ioc->diagLock, flags);
1527 return FAILED;
1528 }
1529 spin_unlock_irqrestore(&ioc->diagLock, flags);
1530
1531 /* Wait a fixed amount of time for the TM pending flag to be cleared.
1532 * If we time out and not bus reset, then we return a FAILED status to the caller.
1533 * The call to mptscsih_tm_pending_wait() will set the pending flag if we are
1534 * successful. Otherwise, reload the FW.
1535 */
1536 if (mptscsih_tm_pending_wait(hd) == FAILED) {
1537 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
1538 dtmprintk((KERN_INFO MYNAM ": %s: TMHandler abort: "
1539 "Timed out waiting for last TM (%d) to complete! \n",
1540 hd->ioc->name, hd->tmPending));
1541 return FAILED;
1542 } else if (type == MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET) {
1543 dtmprintk((KERN_INFO MYNAM ": %s: TMHandler target reset: "
1544 "Timed out waiting for last TM (%d) to complete! \n",
1545 hd->ioc->name, hd->tmPending));
1546 return FAILED;
1547 } else if (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) {
1548 dtmprintk((KERN_INFO MYNAM ": %s: TMHandler bus reset: "
1549 "Timed out waiting for last TM (%d) to complete! \n",
1550 hd->ioc->name, hd->tmPending));
1551 if (hd->tmPending & (1 << MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS))
1552 return FAILED;
1553
1554 doTask = 0;
1555 }
1556 } else {
1557 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
1558 hd->tmPending |= (1 << type);
1559 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
1560 }
1561
1562 /* Is operational?
1563 */
1564 ioc_raw_state = mpt_GetIocState(hd->ioc, 0);
1565
1566 #ifdef MPT_DEBUG_RESET
1567 if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
1568 printk(MYIOC_s_WARN_FMT
1569 "TM Handler: IOC Not operational(0x%x)!\n",
1570 hd->ioc->name, ioc_raw_state);
1571 }
1572 #endif
1573
1574 if (doTask && ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL)
1575 && !(ioc_raw_state & MPI_DOORBELL_ACTIVE)) {
1576
1577 /* Isse the Task Mgmt request.
1578 */
1579 if (hd->hard_resets < -1)
1580 hd->hard_resets++;
1581 rc = mptscsih_IssueTaskMgmt(hd, type, channel, target, lun, ctx2abort, timeout);
1582 if (rc) {
1583 printk(MYIOC_s_INFO_FMT "Issue of TaskMgmt failed!\n", hd->ioc->name);
1584 } else {
1585 dtmprintk((MYIOC_s_INFO_FMT "Issue of TaskMgmt Successful!\n", hd->ioc->name));
1586 }
1587 }
1588
1589 /* Only fall through to the HRH if this is a bus reset
1590 */
1591 if ((type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) && (rc ||
1592 ioc->reload_fw || (ioc->alt_ioc && ioc->alt_ioc->reload_fw))) {
1593 dtmprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n",
1594 hd->ioc->name));
1595 rc = mpt_HardResetHandler(hd->ioc, CAN_SLEEP);
1596 }
1597
1598 /*
1599 * Check IOCStatus from TM reply message
1600 */
1601 if (hd->tm_iocstatus != MPI_IOCSTATUS_SUCCESS)
1602 rc = FAILED;
1603
1604 dtmprintk((MYIOC_s_INFO_FMT "TMHandler rc = %d!\n", hd->ioc->name, rc));
1605
1606 return rc;
1607 }
1608
1609
1610 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1611 /*
1612 * mptscsih_IssueTaskMgmt - Generic send Task Management function.
1613 * @hd: Pointer to MPT_SCSI_HOST structure
1614 * @type: Task Management type
1615 * @target: Logical Target ID for reset (if appropriate)
1616 * @lun: Logical Unit for reset (if appropriate)
1617 * @ctx2abort: Context for the task to be aborted (if appropriate)
1618 *
1619 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
1620 * or a non-interrupt thread. In the former, must not call schedule().
1621 *
1622 * Not all fields are meaningfull for all task types.
1623 *
1624 * Returns 0 for SUCCESS, -999 for "no msg frames",
1625 * else other non-zero value returned.
1626 */
1627 static int
1628 mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 target, u8 lun, int ctx2abort, ulong timeout)
1629 {
1630 MPT_FRAME_HDR *mf;
1631 SCSITaskMgmt_t *pScsiTm;
1632 int ii;
1633 int retval;
1634
1635 /* Return Fail to calling function if no message frames available.
1636 */
1637 if ((mf = mpt_get_msg_frame(hd->ioc->TaskCtx, hd->ioc)) == NULL) {
1638 dfailprintk((MYIOC_s_ERR_FMT "IssueTaskMgmt, no msg frames!!\n",
1639 hd->ioc->name));
1640 return FAILED;
1641 }
1642 dtmprintk((MYIOC_s_INFO_FMT "IssueTaskMgmt request @ %p\n",
1643 hd->ioc->name, mf));
1644
1645 /* Format the Request
1646 */
1647 pScsiTm = (SCSITaskMgmt_t *) mf;
1648 pScsiTm->TargetID = target;
1649 pScsiTm->Bus = channel;
1650 pScsiTm->ChainOffset = 0;
1651 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1652
1653 pScsiTm->Reserved = 0;
1654 pScsiTm->TaskType = type;
1655 pScsiTm->Reserved1 = 0;
1656 pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
1657 ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
1658
1659 for (ii= 0; ii < 8; ii++) {
1660 pScsiTm->LUN[ii] = 0;
1661 }
1662 pScsiTm->LUN[1] = lun;
1663
1664 for (ii=0; ii < 7; ii++)
1665 pScsiTm->Reserved2[ii] = 0;
1666
1667 pScsiTm->TaskMsgContext = ctx2abort;
1668
1669 dtmprintk((MYIOC_s_INFO_FMT "IssueTaskMgmt: ctx2abort (0x%08x) type=%d\n",
1670 hd->ioc->name, ctx2abort, type));
1671
1672 DBG_DUMP_TM_REQUEST_FRAME((u32 *)pScsiTm);
1673
1674 if ((retval = mpt_send_handshake_request(hd->ioc->TaskCtx, hd->ioc,
1675 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm,
1676 CAN_SLEEP)) != 0) {
1677 dfailprintk((MYIOC_s_ERR_FMT "_send_handshake FAILED!"
1678 " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
1679 hd->ioc, mf));
1680 mpt_free_msg_frame(hd->ioc, mf);
1681 return retval;
1682 }
1683
1684 if(mptscsih_tm_wait_for_completion(hd, timeout) == FAILED) {
1685 dfailprintk((MYIOC_s_ERR_FMT "_wait_for_completion FAILED!"
1686 " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
1687 hd->ioc, mf));
1688 mpt_free_msg_frame(hd->ioc, mf);
1689 dtmprintk((MYIOC_s_INFO_FMT "Calling HardReset! \n",
1690 hd->ioc->name));
1691 retval = mpt_HardResetHandler(hd->ioc, CAN_SLEEP);
1692 }
1693
1694 return retval;
1695 }
1696
1697 static int
1698 mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
1699 {
1700 switch (ioc->bus_type) {
1701 case FC:
1702 return 40;
1703 case SAS:
1704 return 10;
1705 case SPI:
1706 default:
1707 return 2;
1708 }
1709 }
1710
1711 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1712 /**
1713 * mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant
1714 * @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted
1715 *
1716 * (linux scsi_host_template.eh_abort_handler routine)
1717 *
1718 * Returns SUCCESS or FAILED.
1719 */
1720 int
1721 mptscsih_abort(struct scsi_cmnd * SCpnt)
1722 {
1723 MPT_SCSI_HOST *hd;
1724 MPT_FRAME_HDR *mf;
1725 u32 ctx2abort;
1726 int scpnt_idx;
1727 int retval;
1728 VirtDevice *vdev;
1729 ulong sn = SCpnt->serial_number;
1730
1731 /* If we can't locate our host adapter structure, return FAILED status.
1732 */
1733 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL) {
1734 SCpnt->result = DID_RESET << 16;
1735 SCpnt->scsi_done(SCpnt);
1736 dfailprintk((KERN_INFO MYNAM ": mptscsih_abort: "
1737 "Can't locate host! (sc=%p)\n",
1738 SCpnt));
1739 return FAILED;
1740 }
1741
1742 /* Find this command
1743 */
1744 if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(SCpnt)) < 0) {
1745 /* Cmd not found in ScsiLookup.
1746 * Do OS callback.
1747 */
1748 SCpnt->result = DID_RESET << 16;
1749 dtmprintk((KERN_INFO MYNAM ": %s: mptscsih_abort: "
1750 "Command not in the active list! (sc=%p)\n",
1751 hd->ioc->name, SCpnt));
1752 return SUCCESS;
1753 }
1754
1755 if (hd->resetPending) {
1756 return FAILED;
1757 }
1758
1759 if (hd->timeouts < -1)
1760 hd->timeouts++;
1761
1762 printk(KERN_WARNING MYNAM ": %s: attempting task abort! (sc=%p)\n",
1763 hd->ioc->name, SCpnt);
1764 scsi_print_command(SCpnt);
1765
1766 /* Most important! Set TaskMsgContext to SCpnt's MsgContext!
1767 * (the IO to be ABORT'd)
1768 *
1769 * NOTE: Since we do not byteswap MsgContext, we do not
1770 * swap it here either. It is an opaque cookie to
1771 * the controller, so it does not matter. -DaveM
1772 */
1773 mf = MPT_INDEX_2_MFPTR(hd->ioc, scpnt_idx);
1774 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
1775
1776 hd->abortSCpnt = SCpnt;
1777
1778 vdev = SCpnt->device->hostdata;
1779 retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1780 vdev->vtarget->bus_id, vdev->vtarget->target_id, vdev->lun,
1781 ctx2abort, mptscsih_get_tm_timeout(hd->ioc));
1782
1783 if (SCPNT_TO_LOOKUP_IDX(SCpnt) == scpnt_idx &&
1784 SCpnt->serial_number == sn) {
1785 retval = FAILED;
1786 }
1787
1788 printk (KERN_WARNING MYNAM ": %s: task abort: %s (sc=%p)\n",
1789 hd->ioc->name,
1790 ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1791
1792 if (retval == 0)
1793 return SUCCESS;
1794
1795 if(retval != FAILED ) {
1796 hd->tmPending = 0;
1797 hd->tmState = TM_STATE_NONE;
1798 }
1799 return FAILED;
1800 }
1801
1802 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1803 /**
1804 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant
1805 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1806 *
1807 * (linux scsi_host_template.eh_dev_reset_handler routine)
1808 *
1809 * Returns SUCCESS or FAILED.
1810 */
1811 int
1812 mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1813 {
1814 MPT_SCSI_HOST *hd;
1815 int retval;
1816 VirtDevice *vdev;
1817
1818 /* If we can't locate our host adapter structure, return FAILED status.
1819 */
1820 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){
1821 dtmprintk((KERN_INFO MYNAM ": mptscsih_dev_reset: "
1822 "Can't locate host! (sc=%p)\n",
1823 SCpnt));
1824 return FAILED;
1825 }
1826
1827 if (hd->resetPending)
1828 return FAILED;
1829
1830 printk(KERN_WARNING MYNAM ": %s: attempting target reset! (sc=%p)\n",
1831 hd->ioc->name, SCpnt);
1832 scsi_print_command(SCpnt);
1833
1834 vdev = SCpnt->device->hostdata;
1835 retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1836 vdev->vtarget->bus_id, vdev->vtarget->target_id,
1837 0, 0, mptscsih_get_tm_timeout(hd->ioc));
1838
1839 printk (KERN_WARNING MYNAM ": %s: target reset: %s (sc=%p)\n",
1840 hd->ioc->name,
1841 ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1842
1843 if (retval == 0)
1844 return SUCCESS;
1845
1846 if(retval != FAILED ) {
1847 hd->tmPending = 0;
1848 hd->tmState = TM_STATE_NONE;
1849 }
1850 return FAILED;
1851 }
1852
1853 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1854 /**
1855 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant
1856 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1857 *
1858 * (linux scsi_host_template.eh_bus_reset_handler routine)
1859 *
1860 * Returns SUCCESS or FAILED.
1861 */
1862 int
1863 mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1864 {
1865 MPT_SCSI_HOST *hd;
1866 int retval;
1867 VirtDevice *vdev;
1868
1869 /* If we can't locate our host adapter structure, return FAILED status.
1870 */
1871 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){
1872 dtmprintk((KERN_INFO MYNAM ": mptscsih_bus_reset: "
1873 "Can't locate host! (sc=%p)\n",
1874 SCpnt ) );
1875 return FAILED;
1876 }
1877
1878 printk(KERN_WARNING MYNAM ": %s: attempting bus reset! (sc=%p)\n",
1879 hd->ioc->name, SCpnt);
1880 scsi_print_command(SCpnt);
1881
1882 if (hd->timeouts < -1)
1883 hd->timeouts++;
1884
1885 vdev = SCpnt->device->hostdata;
1886 retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1887 vdev->vtarget->bus_id, 0, 0, 0, mptscsih_get_tm_timeout(hd->ioc));
1888
1889 printk (KERN_WARNING MYNAM ": %s: bus reset: %s (sc=%p)\n",
1890 hd->ioc->name,
1891 ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
1892
1893 if (retval == 0)
1894 return SUCCESS;
1895
1896 if(retval != FAILED ) {
1897 hd->tmPending = 0;
1898 hd->tmState = TM_STATE_NONE;
1899 }
1900 return FAILED;
1901 }
1902
1903 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1904 /**
1905 * mptscsih_host_reset - Perform a SCSI host adapter RESET!
1906 * new_eh variant
1907 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1908 *
1909 * (linux scsi_host_template.eh_host_reset_handler routine)
1910 *
1911 * Returns SUCCESS or FAILED.
1912 */
1913 int
1914 mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1915 {
1916 MPT_SCSI_HOST * hd;
1917 int status = SUCCESS;
1918
1919 /* If we can't locate the host to reset, then we failed. */
1920 if ((hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata) == NULL){
1921 dtmprintk( ( KERN_INFO MYNAM ": mptscsih_host_reset: "
1922 "Can't locate host! (sc=%p)\n",
1923 SCpnt ) );
1924 return FAILED;
1925 }
1926
1927 printk(KERN_WARNING MYNAM ": %s: Attempting host reset! (sc=%p)\n",
1928 hd->ioc->name, SCpnt);
1929
1930 /* If our attempts to reset the host failed, then return a failed
1931 * status. The host will be taken off line by the SCSI mid-layer.
1932 */
1933 if (mpt_HardResetHandler(hd->ioc, CAN_SLEEP) < 0){
1934 status = FAILED;
1935 } else {
1936 /* Make sure TM pending is cleared and TM state is set to
1937 * NONE.
1938 */
1939 hd->tmPending = 0;
1940 hd->tmState = TM_STATE_NONE;
1941 }
1942
1943 dtmprintk( ( KERN_INFO MYNAM ": mptscsih_host_reset: "
1944 "Status = %s\n",
1945 (status == SUCCESS) ? "SUCCESS" : "FAILED" ) );
1946
1947 return status;
1948 }
1949
1950 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1951 /**
1952 * mptscsih_tm_pending_wait - wait for pending task management request to
1953 * complete.
1954 * @hd: Pointer to MPT host structure.
1955 *
1956 * Returns {SUCCESS,FAILED}.
1957 */
1958 static int
1959 mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd)
1960 {
1961 unsigned long flags;
1962 int loop_count = 4 * 10; /* Wait 10 seconds */
1963 int status = FAILED;
1964
1965 do {
1966 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
1967 if (hd->tmState == TM_STATE_NONE) {
1968 hd->tmState = TM_STATE_IN_PROGRESS;
1969 hd->tmPending = 1;
1970 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
1971 status = SUCCESS;
1972 break;
1973 }
1974 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
1975 msleep(250);
1976 } while (--loop_count);
1977
1978 return status;
1979 }
1980
1981 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1982 /**
1983 * mptscsih_tm_wait_for_completion - wait for completion of TM task
1984 * @hd: Pointer to MPT host structure.
1985 *
1986 * Returns {SUCCESS,FAILED}.
1987 */
1988 static int
1989 mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout )
1990 {
1991 unsigned long flags;
1992 int loop_count = 4 * timeout;
1993 int status = FAILED;
1994
1995 do {
1996 spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
1997 if(hd->tmPending == 0) {
1998 status = SUCCESS;
1999 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
2000 break;
2001 }
2002 spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
2003 msleep(250);
2004 } while (--loop_count);
2005
2006 return status;
2007 }
2008
2009 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2010 static void
2011 mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
2012 {
2013 char *desc;
2014
2015 switch (response_code) {
2016 case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
2017 desc = "The task completed.";
2018 break;
2019 case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
2020 desc = "The IOC received an invalid frame status.";
2021 break;
2022 case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2023 desc = "The task type is not supported.";
2024 break;
2025 case MPI_SCSITASKMGMT_RSP_TM_FAILED:
2026 desc = "The requested task failed.";
2027 break;
2028 case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2029 desc = "The task completed successfully.";
2030 break;
2031 case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2032 desc = "The LUN request is invalid.";
2033 break;
2034 case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2035 desc = "The task is in the IOC queue and has not been sent to target.";
2036 break;
2037 default:
2038 desc = "unknown";
2039 break;
2040 }
2041 printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
2042 ioc->name, response_code, desc);
2043 }
2044
2045 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2046 /**
2047 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2048 * @ioc: Pointer to MPT_ADAPTER structure
2049 * @mf: Pointer to SCSI task mgmt request frame
2050 * @mr: Pointer to SCSI task mgmt reply frame
2051 *
2052 * This routine is called from mptbase.c::mpt_interrupt() at the completion
2053 * of any SCSI task management request.
2054 * This routine is registered with the MPT (base) driver at driver
2055 * load/init time via the mpt_register() API call.
2056 *
2057 * Returns 1 indicating alloc'd request frame ptr should be freed.
2058 */
2059 int
2060 mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
2061 {
2062 SCSITaskMgmtReply_t *pScsiTmReply;
2063 SCSITaskMgmt_t *pScsiTmReq;
2064 MPT_SCSI_HOST *hd;
2065 unsigned long flags;
2066 u16 iocstatus;
2067 u8 tmType;
2068
2069 dtmprintk((MYIOC_s_WARN_FMT "TaskMgmt completed (mf=%p,mr=%p)\n",
2070 ioc->name, mf, mr));
2071 if (ioc->sh) {
2072 /* Depending on the thread, a timer is activated for
2073 * the TM request. Delete this timer on completion of TM.
2074 * Decrement count of outstanding TM requests.
2075 */
2076 hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
2077 } else {
2078 dtmprintk((MYIOC_s_WARN_FMT "TaskMgmt Complete: NULL Scsi Host Ptr\n",
2079 ioc->name));
2080 return 1;
2081 }
2082
2083 if (mr == NULL) {
2084 dtmprintk((MYIOC_s_WARN_FMT "ERROR! TaskMgmt Reply: NULL Request %p\n",
2085 ioc->name, mf));
2086 return 1;
2087 } else {
2088 pScsiTmReply = (SCSITaskMgmtReply_t*)mr;
2089 pScsiTmReq = (SCSITaskMgmt_t*)mf;
2090
2091 /* Figure out if this was ABORT_TASK, TARGET_RESET, or BUS_RESET! */
2092 tmType = pScsiTmReq->TaskType;
2093
2094 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
2095 pScsiTmReply->ResponseCode)
2096 mptscsih_taskmgmt_response_code(ioc,
2097 pScsiTmReply->ResponseCode);
2098
2099 dtmprintk((MYIOC_s_WARN_FMT " TaskType = %d, TerminationCount=%d\n",
2100 ioc->name, tmType, le32_to_cpu(pScsiTmReply->TerminationCount)));
2101 DBG_DUMP_TM_REPLY_FRAME((u32 *)pScsiTmReply);
2102
2103 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2104 hd->tm_iocstatus = iocstatus;
2105 dtmprintk((MYIOC_s_WARN_FMT " SCSI TaskMgmt (%d) IOCStatus=%04x IOCLogInfo=%08x\n",
2106 ioc->name, tmType, iocstatus, le32_to_cpu(pScsiTmReply->IOCLogInfo)));
2107 /* Error? (anything non-zero?) */
2108 if (iocstatus) {
2109
2110 /* clear flags and continue.
2111 */
2112 if (tmType == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
2113 hd->abortSCpnt = NULL;
2114
2115 /* If an internal command is present
2116 * or the TM failed - reload the FW.
2117 * FC FW may respond FAILED to an ABORT
2118 */
2119 if (tmType == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) {
2120 if ((hd->cmdPtr) ||
2121 (iocstatus == MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED)) {
2122 if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0) {
2123 printk((KERN_WARNING
2124 " Firmware Reload FAILED!!\n"));
2125 }
2126 }
2127 }
2128 } else {
2129 dtmprintk((MYIOC_s_WARN_FMT " TaskMgmt SUCCESS\n", ioc->name));
2130
2131 hd->abortSCpnt = NULL;
2132
2133 }
2134 }
2135
2136 spin_lock_irqsave(&ioc->FreeQlock, flags);
2137 hd->tmPending = 0;
2138 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
2139 hd->tmState = TM_STATE_NONE;
2140
2141 return 1;
2142 }
2143
2144 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2145 /*
2146 * This is anyones guess quite frankly.
2147 */
2148 int
2149 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2150 sector_t capacity, int geom[])
2151 {
2152 int heads;
2153 int sectors;
2154 sector_t cylinders;
2155 ulong dummy;
2156
2157 heads = 64;
2158 sectors = 32;
2159
2160 dummy = heads * sectors;
2161 cylinders = capacity;
2162 sector_div(cylinders,dummy);
2163
2164 /*
2165 * Handle extended translation size for logical drives
2166 * > 1Gb
2167 */
2168 if ((ulong)capacity >= 0x200000) {
2169 heads = 255;
2170 sectors = 63;
2171 dummy = heads * sectors;
2172 cylinders = capacity;
2173 sector_div(cylinders,dummy);
2174 }
2175
2176 /* return result */
2177 geom[0] = heads;
2178 geom[1] = sectors;
2179 geom[2] = cylinders;
2180
2181 dprintk((KERN_NOTICE
2182 ": bios_param: Id=%i Lun=%i Channel=%i CHS=%i/%i/%i\n",
2183 sdev->id, sdev->lun,sdev->channel,(int)cylinders,heads,sectors));
2184
2185 return 0;
2186 }
2187
2188 /* Search IOC page 3 to determine if this is hidden physical disk
2189 *
2190 */
2191 int
2192 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id)
2193 {
2194 int i;
2195
2196 if (!ioc->raid_data.isRaid || !ioc->raid_data.pIocPg3)
2197 return 0;
2198 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2199 if (id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID)
2200 return 1;
2201 }
2202 return 0;
2203 }
2204 EXPORT_SYMBOL(mptscsih_is_phys_disk);
2205
2206 int
2207 mptscsih_raid_id_to_num(MPT_SCSI_HOST *hd, uint physdiskid)
2208 {
2209 int i;
2210
2211 if (!hd->ioc->raid_data.isRaid || !hd->ioc->raid_data.pIocPg3)
2212 return -ENXIO;
2213
2214 for (i = 0; i < hd->ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2215 if (physdiskid ==
2216 hd->ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID)
2217 return hd->ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
2218 }
2219
2220 return -ENXIO;
2221 }
2222 EXPORT_SYMBOL(mptscsih_raid_id_to_num);
2223
2224 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2225 /*
2226 * OS entry point to allow host driver to alloc memory
2227 * for each scsi target. Called once per device the bus scan.
2228 * Return non-zero if allocation fails.
2229 */
2230 int
2231 mptscsih_target_alloc(struct scsi_target *starget)
2232 {
2233 VirtTarget *vtarget;
2234
2235 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
2236 if (!vtarget)
2237 return -ENOMEM;
2238 starget->hostdata = vtarget;
2239 vtarget->starget = starget;
2240 return 0;
2241 }
2242
2243 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2244 /*
2245 * OS entry point to allow host driver to alloc memory
2246 * for each scsi device. Called once per device the bus scan.
2247 * Return non-zero if allocation fails.
2248 */
2249 int
2250 mptscsih_slave_alloc(struct scsi_device *sdev)
2251 {
2252 struct Scsi_Host *host = sdev->host;
2253 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
2254 VirtTarget *vtarget;
2255 VirtDevice *vdev;
2256 struct scsi_target *starget;
2257
2258 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
2259 if (!vdev) {
2260 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
2261 hd->ioc->name, sizeof(VirtDevice));
2262 return -ENOMEM;
2263 }
2264
2265 vdev->lun = sdev->lun;
2266 sdev->hostdata = vdev;
2267
2268 starget = scsi_target(sdev);
2269 vtarget = starget->hostdata;
2270
2271 vdev->vtarget = vtarget;
2272
2273 if (vtarget->num_luns == 0) {
2274 hd->Targets[sdev->id] = vtarget;
2275 vtarget->ioc_id = hd->ioc->id;
2276 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
2277 vtarget->target_id = sdev->id;
2278 vtarget->bus_id = sdev->channel;
2279 if (hd->ioc->bus_type == SPI && sdev->channel == 0 &&
2280 hd->ioc->raid_data.isRaid & (1 << sdev->id)) {
2281 vtarget->raidVolume = 1;
2282 ddvtprintk((KERN_INFO
2283 "RAID Volume @ id %d\n", sdev->id));
2284 }
2285 }
2286 vtarget->num_luns++;
2287 return 0;
2288 }
2289
2290 /*
2291 * OS entry point to allow for host driver to free allocated memory
2292 * Called if no device present or device being unloaded
2293 */
2294 void
2295 mptscsih_target_destroy(struct scsi_target *starget)
2296 {
2297 if (starget->hostdata)
2298 kfree(starget->hostdata);
2299 starget->hostdata = NULL;
2300 }
2301
2302 /*
2303 * OS entry point to allow for host driver to free allocated memory
2304 * Called if no device present or device being unloaded
2305 */
2306 void
2307 mptscsih_slave_destroy(struct scsi_device *sdev)
2308 {
2309 struct Scsi_Host *host = sdev->host;
2310 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
2311 VirtTarget *vtarget;
2312 VirtDevice *vdevice;
2313 struct scsi_target *starget;
2314
2315 starget = scsi_target(sdev);
2316 vtarget = starget->hostdata;
2317 vdevice = sdev->hostdata;
2318
2319 mptscsih_search_running_cmds(hd, vdevice);
2320 vtarget->luns[0] &= ~(1 << vdevice->lun);
2321 vtarget->num_luns--;
2322 if (vtarget->num_luns == 0) {
2323 hd->Targets[sdev->id] = NULL;
2324 }
2325 mptscsih_synchronize_cache(hd, vdevice);
2326 kfree(vdevice);
2327 sdev->hostdata = NULL;
2328 }
2329
2330 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2331 /*
2332 * mptscsih_change_queue_depth - This function will set a devices queue depth
2333 * @sdev: per scsi_device pointer
2334 * @qdepth: requested queue depth
2335 *
2336 * Adding support for new 'change_queue_depth' api.
2337 */
2338 int
2339 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
2340 {
2341 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
2342 VirtTarget *vtarget;
2343 struct scsi_target *starget;
2344 int max_depth;
2345 int tagged;
2346
2347 starget = scsi_target(sdev);
2348 vtarget = starget->hostdata;
2349
2350 if (hd->ioc->bus_type == SPI) {
2351 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
2352 max_depth = 1;
2353 else if (sdev->type == TYPE_DISK &&
2354 vtarget->minSyncFactor <= MPT_ULTRA160)
2355 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2356 else
2357 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
2358 } else
2359 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2360
2361 if (qdepth > max_depth)
2362 qdepth = max_depth;
2363 if (qdepth == 1)
2364 tagged = 0;
2365 else
2366 tagged = MSG_SIMPLE_TAG;
2367
2368 scsi_adjust_queue_depth(sdev, tagged, qdepth);
2369 return sdev->queue_depth;
2370 }
2371
2372 /*
2373 * OS entry point to adjust the queue_depths on a per-device basis.
2374 * Called once per device the bus scan. Use it to force the queue_depth
2375 * member to 1 if a device does not support Q tags.
2376 * Return non-zero if fails.
2377 */
2378 int
2379 mptscsih_slave_configure(struct scsi_device *sdev)
2380 {
2381 struct Scsi_Host *sh = sdev->host;
2382 VirtTarget *vtarget;
2383 VirtDevice *vdevice;
2384 struct scsi_target *starget;
2385 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sh->hostdata;
2386 int indexed_lun, lun_index;
2387
2388 starget = scsi_target(sdev);
2389 vtarget = starget->hostdata;
2390 vdevice = sdev->hostdata;
2391
2392 dsprintk((MYIOC_s_INFO_FMT
2393 "device @ %p, id=%d, LUN=%d, channel=%d\n",
2394 hd->ioc->name, sdev, sdev->id, sdev->lun, sdev->channel));
2395 if (hd->ioc->bus_type == SPI)
2396 dsprintk((MYIOC_s_INFO_FMT
2397 "sdtr %d wdtr %d ppr %d inq length=%d\n",
2398 hd->ioc->name, sdev->sdtr, sdev->wdtr,
2399 sdev->ppr, sdev->inquiry_len));
2400
2401 if (sdev->id > sh->max_id) {
2402 /* error case, should never happen */
2403 scsi_adjust_queue_depth(sdev, 0, 1);
2404 goto slave_configure_exit;
2405 }
2406
2407 vdevice->configured_lun=1;
2408 lun_index = (vdevice->lun >> 5); /* 32 luns per lun_index */
2409 indexed_lun = (vdevice->lun % 32);
2410 vtarget->luns[lun_index] |= (1 << indexed_lun);
2411 mptscsih_initTarget(hd, vtarget, sdev);
2412 mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
2413
2414 dsprintk((MYIOC_s_INFO_FMT
2415 "Queue depth=%d, tflags=%x\n",
2416 hd->ioc->name, sdev->queue_depth, vtarget->tflags));
2417
2418 if (hd->ioc->bus_type == SPI)
2419 dsprintk((MYIOC_s_INFO_FMT
2420 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
2421 hd->ioc->name, vtarget->negoFlags, vtarget->maxOffset,
2422 vtarget->minSyncFactor));
2423
2424 slave_configure_exit:
2425
2426 dsprintk((MYIOC_s_INFO_FMT
2427 "tagged %d, simple %d, ordered %d\n",
2428 hd->ioc->name,sdev->tagged_supported, sdev->simple_tags,
2429 sdev->ordered_tags));
2430
2431 return 0;
2432 }
2433
2434 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2435 /*
2436 * Private routines...
2437 */
2438
2439 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2440 /* Utility function to copy sense data from the scsi_cmnd buffer
2441 * to the FC and SCSI target structures.
2442 *
2443 */
2444 static void
2445 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
2446 {
2447 VirtDevice *vdev;
2448 SCSIIORequest_t *pReq;
2449 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount);
2450
2451 /* Get target structure
2452 */
2453 pReq = (SCSIIORequest_t *) mf;
2454 vdev = sc->device->hostdata;
2455
2456 if (sense_count) {
2457 u8 *sense_data;
2458 int req_index;
2459
2460 /* Copy the sense received into the scsi command block. */
2461 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2462 sense_data = ((u8 *)hd->ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
2463 memcpy(sc->sense_buffer, sense_data, SNS_LEN(sc));
2464
2465 /* Log SMART data (asc = 0x5D, non-IM case only) if required.
2466 */
2467 if ((hd->ioc->events) && (hd->ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
2468 if ((sense_data[12] == 0x5D) && (vdev->vtarget->raidVolume == 0)) {
2469 int idx;
2470 MPT_ADAPTER *ioc = hd->ioc;
2471
2472 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
2473 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2474 ioc->events[idx].eventContext = ioc->eventContext;
2475
2476 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) ||
2477 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) ||
2478 (sc->device->channel << 8) || sc->device->id;
2479
2480 ioc->events[idx].data[1] = (sense_data[13] << 8) || sense_data[12];
2481
2482 ioc->eventContext++;
2483 if (hd->ioc->pcidev->vendor ==
2484 PCI_VENDOR_ID_IBM) {
2485 mptscsih_issue_sep_command(hd->ioc,
2486 vdev->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
2487 vdev->vtarget->tflags |=
2488 MPT_TARGET_FLAGS_LED_ON;
2489 }
2490 }
2491 }
2492 } else {
2493 dprintk((MYIOC_s_INFO_FMT "Hmmm... SenseData len=0! (?)\n",
2494 hd->ioc->name));
2495 }
2496 }
2497
2498 static int
2499 SCPNT_TO_LOOKUP_IDX(struct scsi_cmnd *sc)
2500 {
2501 MPT_SCSI_HOST *hd;
2502 int i;
2503
2504 hd = (MPT_SCSI_HOST *) sc->device->host->hostdata;
2505
2506 for (i = 0; i < hd->ioc->req_depth; i++) {
2507 if (hd->ScsiLookup[i] == sc) {
2508 return i;
2509 }
2510 }
2511
2512 return -1;
2513 }
2514
2515 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2516 int
2517 mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2518 {
2519 MPT_SCSI_HOST *hd;
2520 unsigned long flags;
2521 int ii;
2522
2523 dtmprintk((KERN_WARNING MYNAM
2524 ": IOC %s_reset routed to SCSI host driver!\n",
2525 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
2526 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
2527
2528 /* If a FW reload request arrives after base installed but
2529 * before all scsi hosts have been attached, then an alt_ioc
2530 * may have a NULL sh pointer.
2531 */
2532 if ((ioc->sh == NULL) || (ioc->sh->hostdata == NULL))
2533 return 0;
2534 else
2535 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2536
2537 if (reset_phase == MPT_IOC_SETUP_RESET) {
2538 dtmprintk((MYIOC_s_WARN_FMT "Setup-Diag Reset\n", ioc->name));
2539
2540 /* Clean Up:
2541 * 1. Set Hard Reset Pending Flag
2542 * All new commands go to doneQ
2543 */
2544 hd->resetPending = 1;
2545
2546 } else if (reset_phase == MPT_IOC_PRE_RESET) {
2547 dtmprintk((MYIOC_s_WARN_FMT "Pre-Diag Reset\n", ioc->name));
2548
2549 /* 2. Flush running commands
2550 * Clean ScsiLookup (and associated memory)
2551 * AND clean mytaskQ
2552 */
2553
2554 /* 2b. Reply to OS all known outstanding I/O commands.
2555 */
2556 mptscsih_flush_running_cmds(hd);
2557
2558 /* 2c. If there was an internal command that
2559 * has not completed, configuration or io request,
2560 * free these resources.
2561 */
2562 if (hd->cmdPtr) {
2563 del_timer(&hd->timer);
2564 mpt_free_msg_frame(ioc, hd->cmdPtr);
2565 }
2566
2567 dtmprintk((MYIOC_s_WARN_FMT "Pre-Reset complete.\n", ioc->name));
2568
2569 } else {
2570 dtmprintk((MYIOC_s_WARN_FMT "Post-Diag Reset\n", ioc->name));
2571
2572 /* Once a FW reload begins, all new OS commands are
2573 * redirected to the doneQ w/ a reset status.
2574 * Init all control structures.
2575 */
2576
2577 /* ScsiLookup initialization
2578 */
2579 for (ii=0; ii < hd->ioc->req_depth; ii++)
2580 hd->ScsiLookup[ii] = NULL;
2581
2582 /* 2. Chain Buffer initialization
2583 */
2584
2585 /* 4. Renegotiate to all devices, if SPI
2586 */
2587
2588 /* 5. Enable new commands to be posted
2589 */
2590 spin_lock_irqsave(&ioc->FreeQlock, flags);
2591 hd->tmPending = 0;
2592 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
2593 hd->resetPending = 0;
2594 hd->tmState = TM_STATE_NONE;
2595
2596 /* 6. If there was an internal command,
2597 * wake this process up.
2598 */
2599 if (hd->cmdPtr) {
2600 /*
2601 * Wake up the original calling thread
2602 */
2603 hd->pLocal = &hd->localReply;
2604 hd->pLocal->completion = MPT_SCANDV_DID_RESET;
2605 hd->scandv_wait_done = 1;
2606 wake_up(&hd->scandv_waitq);
2607 hd->cmdPtr = NULL;
2608 }
2609
2610 dtmprintk((MYIOC_s_WARN_FMT "Post-Reset complete.\n", ioc->name));
2611
2612 }
2613
2614 return 1; /* currently means nothing really */
2615 }
2616
2617 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2618 int
2619 mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2620 {
2621 MPT_SCSI_HOST *hd;
2622 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2623
2624 devtverboseprintk((MYIOC_s_INFO_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
2625 ioc->name, event));
2626
2627 if (ioc->sh == NULL ||
2628 ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL))
2629 return 1;
2630
2631 switch (event) {
2632 case MPI_EVENT_UNIT_ATTENTION: /* 03 */
2633 /* FIXME! */
2634 break;
2635 case MPI_EVENT_IOC_BUS_RESET: /* 04 */
2636 case MPI_EVENT_EXT_BUS_RESET: /* 05 */
2637 if (hd && (ioc->bus_type == SPI) && (hd->soft_resets < -1))
2638 hd->soft_resets++;
2639 break;
2640 case MPI_EVENT_LOGOUT: /* 09 */
2641 /* FIXME! */
2642 break;
2643
2644 case MPI_EVENT_RESCAN: /* 06 */
2645 break;
2646
2647 /*
2648 * CHECKME! Don't think we need to do
2649 * anything for these, but...
2650 */
2651 case MPI_EVENT_LINK_STATUS_CHANGE: /* 07 */
2652 case MPI_EVENT_LOOP_STATE_CHANGE: /* 08 */
2653 /*
2654 * CHECKME! Falling thru...
2655 */
2656 break;
2657
2658 case MPI_EVENT_INTEGRATED_RAID: /* 0B */
2659 break;
2660
2661 case MPI_EVENT_NONE: /* 00 */
2662 case MPI_EVENT_LOG_DATA: /* 01 */
2663 case MPI_EVENT_STATE_CHANGE: /* 02 */
2664 case MPI_EVENT_EVENT_CHANGE: /* 0A */
2665 default:
2666 dprintk((KERN_INFO " Ignoring event (=%02Xh)\n", event));
2667 break;
2668 }
2669
2670 return 1; /* currently means nothing really */
2671 }
2672
2673 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2674 /*
2675 * mptscsih_initTarget - Target, LUN alloc/free functionality.
2676 * @hd: Pointer to MPT_SCSI_HOST structure
2677 * @vtarget: per target private data
2678 * @sdev: SCSI device
2679 *
2680 * NOTE: It's only SAFE to call this routine if data points to
2681 * sane & valid STANDARD INQUIRY data!
2682 *
2683 * Allocate and initialize memory for this target.
2684 * Save inquiry data.
2685 *
2686 */
2687 static void
2688 mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
2689 struct scsi_device *sdev)
2690 {
2691 dinitprintk((MYIOC_s_INFO_FMT "initTarget bus=%d id=%d lun=%d hd=%p\n",
2692 hd->ioc->name, vtarget->bus_id, vtarget->target_id, lun, hd));
2693
2694 /* Is LUN supported? If so, upper 2 bits will be 0
2695 * in first byte of inquiry data.
2696 */
2697 if (sdev->inq_periph_qual != 0)
2698 return;
2699
2700 if (vtarget == NULL)
2701 return;
2702
2703 vtarget->type = sdev->type;
2704
2705 if (hd->ioc->bus_type != SPI)
2706 return;
2707
2708 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
2709 /* Treat all Processors as SAF-TE if
2710 * command line option is set */
2711 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
2712 mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id);
2713 }else if ((sdev->type == TYPE_PROCESSOR) &&
2714 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
2715 if (sdev->inquiry_len > 49 ) {
2716 if (sdev->inquiry[44] == 'S' &&
2717 sdev->inquiry[45] == 'A' &&
2718 sdev->inquiry[46] == 'F' &&
2719 sdev->inquiry[47] == '-' &&
2720 sdev->inquiry[48] == 'T' &&
2721 sdev->inquiry[49] == 'E' ) {
2722 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
2723 mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id);
2724 }
2725 }
2726 }
2727 mptscsih_setTargetNegoParms(hd, vtarget, sdev);
2728 }
2729
2730 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2731 /*
2732 * Update the target negotiation parameters based on the
2733 * the Inquiry data, adapter capabilities, and NVRAM settings.
2734 *
2735 */
2736 static void
2737 mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
2738 struct scsi_device *sdev)
2739 {
2740 SpiCfgData *pspi_data = &hd->ioc->spi_data;
2741 int id = (int) target->target_id;
2742 int nvram;
2743 u8 width = MPT_NARROW;
2744 u8 factor = MPT_ASYNC;
2745 u8 offset = 0;
2746 u8 nfactor;
2747 u8 noQas = 1;
2748
2749 target->negoFlags = pspi_data->noQas;
2750
2751 /* noQas == 0 => device supports QAS. */
2752
2753 if (sdev->scsi_level < SCSI_2) {
2754 width = 0;
2755 factor = MPT_ULTRA2;
2756 offset = pspi_data->maxSyncOffset;
2757 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
2758 } else {
2759 if (scsi_device_wide(sdev)) {
2760 width = 1;
2761 }
2762
2763 if (scsi_device_sync(sdev)) {
2764 factor = pspi_data->minSyncFactor;
2765 if (!scsi_device_dt(sdev))
2766 factor = MPT_ULTRA2;
2767 else {
2768 if (!scsi_device_ius(sdev) &&
2769 !scsi_device_qas(sdev))
2770 factor = MPT_ULTRA160;
2771 else {
2772 factor = MPT_ULTRA320;
2773 if (scsi_device_qas(sdev)) {
2774 ddvtprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", byte56, id));
2775 noQas = 0;
2776 }
2777 if (sdev->type == TYPE_TAPE &&
2778 scsi_device_ius(sdev))
2779 target->negoFlags |= MPT_TAPE_NEGO_IDP;
2780 }
2781 }
2782 offset = pspi_data->maxSyncOffset;
2783
2784 /* If RAID, never disable QAS
2785 * else if non RAID, do not disable
2786 * QAS if bit 1 is set
2787 * bit 1 QAS support, non-raid only
2788 * bit 0 IU support
2789 */
2790 if (target->raidVolume == 1) {
2791 noQas = 0;
2792 }
2793 } else {
2794 factor = MPT_ASYNC;
2795 offset = 0;
2796 }
2797 }
2798
2799 if (!sdev->tagged_supported) {
2800 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
2801 }
2802
2803 /* Update tflags based on NVRAM settings. (SCSI only)
2804 */
2805 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
2806 nvram = pspi_data->nvram[id];
2807 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
2808
2809 if (width)
2810 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
2811
2812 if (offset > 0) {
2813 /* Ensure factor is set to the
2814 * maximum of: adapter, nvram, inquiry
2815 */
2816 if (nfactor) {
2817 if (nfactor < pspi_data->minSyncFactor )
2818 nfactor = pspi_data->minSyncFactor;
2819
2820 factor = max(factor, nfactor);
2821 if (factor == MPT_ASYNC)
2822 offset = 0;
2823 } else {
2824 offset = 0;
2825 factor = MPT_ASYNC;
2826 }
2827 } else {
2828 factor = MPT_ASYNC;
2829 }
2830 }
2831
2832 /* Make sure data is consistent
2833 */
2834 if ((!width) && (factor < MPT_ULTRA2)) {
2835 factor = MPT_ULTRA2;
2836 }
2837
2838 /* Save the data to the target structure.
2839 */
2840 target->minSyncFactor = factor;
2841 target->maxOffset = offset;
2842 target->maxWidth = width;
2843
2844 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
2845
2846 /* Disable unused features.
2847 */
2848 if (!width)
2849 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
2850
2851 if (!offset)
2852 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
2853
2854 if ( factor > MPT_ULTRA320 )
2855 noQas = 0;
2856
2857 if (noQas && (pspi_data->noQas == 0)) {
2858 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
2859 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
2860
2861 /* Disable QAS in a mixed configuration case
2862 */
2863
2864 ddvtprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
2865 }
2866 }
2867
2868 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2869
2870 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2871 /*
2872 * SCSI Config Page functionality ...
2873 */
2874
2875 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2876 /* mptscsih_writeIOCPage4 - write IOC Page 4
2877 * @hd: Pointer to a SCSI Host Structure
2878 * @target_id: write IOC Page4 for this ID & Bus
2879 *
2880 * Return: -EAGAIN if unable to obtain a Message Frame
2881 * or 0 if success.
2882 *
2883 * Remark: We do not wait for a return, write pages sequentially.
2884 */
2885 static int
2886 mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus)
2887 {
2888 MPT_ADAPTER *ioc = hd->ioc;
2889 Config_t *pReq;
2890 IOCPage4_t *IOCPage4Ptr;
2891 MPT_FRAME_HDR *mf;
2892 dma_addr_t dataDma;
2893 u16 req_idx;
2894 u32 frameOffset;
2895 u32 flagsLength;
2896 int ii;
2897
2898 /* Get a MF for this command.
2899 */
2900 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
2901 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
2902 ioc->name));
2903 return -EAGAIN;
2904 }
2905
2906 /* Set the request and the data pointers.
2907 * Place data at end of MF.
2908 */
2909 pReq = (Config_t *)mf;
2910
2911 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2912 frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
2913
2914 /* Complete the request frame (same for all requests).
2915 */
2916 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
2917 pReq->Reserved = 0;
2918 pReq->ChainOffset = 0;
2919 pReq->Function = MPI_FUNCTION_CONFIG;
2920 pReq->ExtPageLength = 0;
2921 pReq->ExtPageType = 0;
2922 pReq->MsgFlags = 0;
2923 for (ii=0; ii < 8; ii++) {
2924 pReq->Reserved2[ii] = 0;
2925 }
2926
2927 IOCPage4Ptr = ioc->spi_data.pIocPg4;
2928 dataDma = ioc->spi_data.IocPg4_dma;
2929 ii = IOCPage4Ptr->ActiveSEP++;
2930 IOCPage4Ptr->SEP[ii].SEPTargetID = target_id;
2931 IOCPage4Ptr->SEP[ii].SEPBus = bus;
2932 pReq->Header = IOCPage4Ptr->Header;
2933 pReq->PageAddress = cpu_to_le32(target_id | (bus << 8 ));
2934
2935 /* Add a SGE to the config request.
2936 */
2937 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
2938 (IOCPage4Ptr->Header.PageLength + ii) * 4;
2939
2940 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
2941
2942 dinitprintk((MYIOC_s_INFO_FMT
2943 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
2944 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, target_id, bus));
2945
2946 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
2947
2948 return 0;
2949 }
2950
2951 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2952 /*
2953 * Bus Scan and Domain Validation functionality ...
2954 */
2955
2956 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2957 /*
2958 * mptscsih_scandv_complete - Scan and DV callback routine registered
2959 * to Fustion MPT (base) driver.
2960 *
2961 * @ioc: Pointer to MPT_ADAPTER structure
2962 * @mf: Pointer to original MPT request frame
2963 * @mr: Pointer to MPT reply frame (NULL if TurboReply)
2964 *
2965 * This routine is called from mpt.c::mpt_interrupt() at the completion
2966 * of any SCSI IO request.
2967 * This routine is registered with the Fusion MPT (base) driver at driver
2968 * load/init time via the mpt_register() API call.
2969 *
2970 * Returns 1 indicating alloc'd request frame ptr should be freed.
2971 *
2972 * Remark: Sets a completion code and (possibly) saves sense data
2973 * in the IOC member localReply structure.
2974 * Used ONLY for DV and other internal commands.
2975 */
2976 int
2977 mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
2978 {
2979 MPT_SCSI_HOST *hd;
2980 SCSIIORequest_t *pReq;
2981 int completionCode;
2982 u16 req_idx;
2983
2984 hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
2985
2986 if ((mf == NULL) ||
2987 (mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))) {
2988 printk(MYIOC_s_ERR_FMT
2989 "ScanDvComplete, %s req frame ptr! (=%p)\n",
2990 ioc->name, mf?"BAD":"NULL", (void *) mf);
2991 goto wakeup;
2992 }
2993
2994 del_timer(&hd->timer);
2995 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2996 hd->ScsiLookup[req_idx] = NULL;
2997 pReq = (SCSIIORequest_t *) mf;
2998
2999 if (mf != hd->cmdPtr) {
3000 printk(MYIOC_s_WARN_FMT "ScanDvComplete (mf=%p, cmdPtr=%p, idx=%d)\n",
3001 hd->ioc->name, (void *)mf, (void *) hd->cmdPtr, req_idx);
3002 }
3003 hd->cmdPtr = NULL;
3004
3005 ddvprintk((MYIOC_s_INFO_FMT "ScanDvComplete (mf=%p,mr=%p,idx=%d)\n",
3006 hd->ioc->name, mf, mr, req_idx));
3007
3008 hd->pLocal = &hd->localReply;
3009 hd->pLocal->scsiStatus = 0;
3010
3011 /* If target struct exists, clear sense valid flag.
3012 */
3013 if (mr == NULL) {
3014 completionCode = MPT_SCANDV_GOOD;
3015 } else {
3016 SCSIIOReply_t *pReply;
3017 u16 status;
3018 u8 scsi_status;
3019
3020 pReply = (SCSIIOReply_t *) mr;
3021
3022 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
3023 scsi_status = pReply->SCSIStatus;
3024
3025 ddvtprintk((KERN_NOTICE " IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh, IOCLogInfo=%08xh\n",
3026 status, pReply->SCSIState, scsi_status,
3027 le32_to_cpu(pReply->IOCLogInfo)));
3028
3029 switch(status) {
3030
3031 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
3032 completionCode = MPT_SCANDV_SELECTION_TIMEOUT;
3033 break;
3034
3035 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
3036 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
3037 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
3038 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
3039 completionCode = MPT_SCANDV_DID_RESET;
3040 break;
3041
3042 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
3043 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
3044 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
3045 if (pReply->Function == MPI_FUNCTION_CONFIG) {
3046 ConfigReply_t *pr = (ConfigReply_t *)mr;
3047 completionCode = MPT_SCANDV_GOOD;
3048 hd->pLocal->header.PageVersion = pr->Header.PageVersion;
3049 hd->pLocal->header.PageLength = pr->Header.PageLength;
3050 hd->pLocal->header.PageNumber = pr->Header.PageNumber;
3051 hd->pLocal->header.PageType = pr->Header.PageType;
3052
3053 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
3054 /* If the RAID Volume request is successful,
3055 * return GOOD, else indicate that
3056 * some type of error occurred.
3057 */
3058 MpiRaidActionReply_t *pr = (MpiRaidActionReply_t *)mr;
3059 if (le16_to_cpu(pr->ActionStatus) == MPI_RAID_ACTION_ASTATUS_SUCCESS)
3060 completionCode = MPT_SCANDV_GOOD;
3061 else
3062 completionCode = MPT_SCANDV_SOME_ERROR;
3063 memcpy(hd->pLocal->sense, pr, sizeof(hd->pLocal->sense));
3064
3065 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
3066 u8 *sense_data;
3067 int sz;
3068
3069 /* save sense data in global structure
3070 */
3071 completionCode = MPT_SCANDV_SENSE;
3072 hd->pLocal->scsiStatus = scsi_status;
3073 sense_data = ((u8 *)hd->ioc->sense_buf_pool +
3074 (req_idx * MPT_SENSE_BUFFER_ALLOC));
3075
3076 sz = min_t(int, pReq->SenseBufferLength,
3077 SCSI_STD_SENSE_BYTES);
3078 memcpy(hd->pLocal->sense, sense_data, sz);
3079
3080 ddvprintk((KERN_NOTICE " Check Condition, sense ptr %p\n",
3081 sense_data));
3082 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
3083 if (pReq->CDB[0] == INQUIRY)
3084 completionCode = MPT_SCANDV_ISSUE_SENSE;
3085 else
3086 completionCode = MPT_SCANDV_DID_RESET;
3087 }
3088 else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
3089 completionCode = MPT_SCANDV_DID_RESET;
3090 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
3091 completionCode = MPT_SCANDV_DID_RESET;
3092 else {
3093 completionCode = MPT_SCANDV_GOOD;
3094 hd->pLocal->scsiStatus = scsi_status;
3095 }
3096 break;
3097
3098 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
3099 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
3100 completionCode = MPT_SCANDV_DID_RESET;
3101 else
3102 completionCode = MPT_SCANDV_SOME_ERROR;
3103 break;
3104
3105 default:
3106 completionCode = MPT_SCANDV_SOME_ERROR;
3107 break;
3108
3109 } /* switch(status) */
3110
3111 ddvtprintk((KERN_NOTICE " completionCode set to %08xh\n",
3112 completionCode));
3113 } /* end of address reply case */
3114
3115 hd->pLocal->completion = completionCode;
3116
3117 /* MF and RF are freed in mpt_interrupt
3118 */
3119 wakeup:
3120 /* Free Chain buffers (will never chain) in scan or dv */
3121 //mptscsih_freeChainBuffers(ioc, req_idx);
3122
3123 /*
3124 * Wake up the original calling thread
3125 */
3126 hd->scandv_wait_done = 1;
3127 wake_up(&hd->scandv_waitq);
3128
3129 return 1;
3130 }
3131
3132 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3133 /* mptscsih_timer_expired - Call back for timer process.
3134 * Used only for dv functionality.
3135 * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
3136 *
3137 */
3138 void
3139 mptscsih_timer_expired(unsigned long data)
3140 {
3141 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) data;
3142
3143 ddvprintk((MYIOC_s_WARN_FMT "Timer Expired! Cmd %p\n", hd->ioc->name, hd->cmdPtr));
3144
3145 if (hd->cmdPtr) {
3146 MPIHeader_t *cmd = (MPIHeader_t *)hd->cmdPtr;
3147
3148 if (cmd->Function == MPI_FUNCTION_SCSI_IO_REQUEST) {
3149 /* Desire to issue a task management request here.
3150 * TM requests MUST be single threaded.
3151 * If old eh code and no TM current, issue request.
3152 * If new eh code, do nothing. Wait for OS cmd timeout
3153 * for bus reset.
3154 */
3155 ddvtprintk((MYIOC_s_NOTE_FMT "DV Cmd Timeout: NoOp\n", hd->ioc->name));
3156 } else {
3157 /* Perform a FW reload */
3158 if (mpt_HardResetHandler(hd->ioc, NO_SLEEP) < 0) {
3159 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", hd->ioc->name);
3160 }
3161 }
3162 } else {
3163 /* This should NEVER happen */
3164 printk(MYIOC_s_WARN_FMT "Null cmdPtr!!!!\n", hd->ioc->name);
3165 }
3166
3167 /* No more processing.
3168 * TM call will generate an interrupt for SCSI TM Management.
3169 * The FW will reply to all outstanding commands, callback will finish cleanup.
3170 * Hard reset clean-up will free all resources.
3171 */
3172 ddvprintk((MYIOC_s_WARN_FMT "Timer Expired Complete!\n", hd->ioc->name));
3173
3174 return;
3175 }
3176
3177
3178 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3179 /**
3180 * mptscsih_do_cmd - Do internal command.
3181 * @hd: MPT_SCSI_HOST pointer
3182 * @io: INTERNAL_CMD pointer.
3183 *
3184 * Issue the specified internally generated command and do command
3185 * specific cleanup. For bus scan / DV only.
3186 * NOTES: If command is Inquiry and status is good,
3187 * initialize a target structure, save the data
3188 *
3189 * Remark: Single threaded access only.
3190 *
3191 * Return:
3192 * < 0 if an illegal command or no resources
3193 *
3194 * 0 if good
3195 *
3196 * > 0 if command complete but some type of completion error.
3197 */
3198 static int
3199 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
3200 {
3201 MPT_FRAME_HDR *mf;
3202 SCSIIORequest_t *pScsiReq;
3203 SCSIIORequest_t ReqCopy;
3204 int my_idx, ii, dir;
3205 int rc, cmdTimeout;
3206 int in_isr;
3207 char cmdLen;
3208 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
3209 char cmd = io->cmd;
3210
3211 in_isr = in_interrupt();
3212 if (in_isr) {
3213 dprintk((MYIOC_s_WARN_FMT "Internal SCSI IO request not allowed in ISR context!\n",
3214 hd->ioc->name));
3215 return -EPERM;
3216 }
3217
3218
3219 /* Set command specific information
3220 */
3221 switch (cmd) {
3222 case INQUIRY:
3223 cmdLen = 6;
3224 dir = MPI_SCSIIO_CONTROL_READ;
3225 CDB[0] = cmd;
3226 CDB[4] = io->size;
3227 cmdTimeout = 10;
3228 break;
3229
3230 case TEST_UNIT_READY:
3231 cmdLen = 6;
3232 dir = MPI_SCSIIO_CONTROL_READ;
3233 cmdTimeout = 10;
3234 break;
3235
3236 case START_STOP:
3237 cmdLen = 6;
3238 dir = MPI_SCSIIO_CONTROL_READ;
3239 CDB[0] = cmd;
3240 CDB[4] = 1; /*Spin up the disk */
3241 cmdTimeout = 15;
3242 break;
3243
3244 case REQUEST_SENSE:
3245 cmdLen = 6;
3246 CDB[0] = cmd;
3247 CDB[4] = io->size;
3248 dir = MPI_SCSIIO_CONTROL_READ;
3249 cmdTimeout = 10;
3250 break;
3251
3252 case READ_BUFFER:
3253 cmdLen = 10;
3254 dir = MPI_SCSIIO_CONTROL_READ;
3255 CDB[0] = cmd;
3256 if (io->flags & MPT_ICFLAG_ECHO) {
3257 CDB[1] = 0x0A;
3258 } else {
3259 CDB[1] = 0x02;
3260 }
3261
3262 if (io->flags & MPT_ICFLAG_BUF_CAP) {
3263 CDB[1] |= 0x01;
3264 }
3265 CDB[6] = (io->size >> 16) & 0xFF;
3266 CDB[7] = (io->size >> 8) & 0xFF;
3267 CDB[8] = io->size & 0xFF;
3268 cmdTimeout = 10;
3269 break;
3270
3271 case WRITE_BUFFER:
3272 cmdLen = 10;
3273 dir = MPI_SCSIIO_CONTROL_WRITE;
3274 CDB[0] = cmd;
3275 if (io->flags & MPT_ICFLAG_ECHO) {
3276 CDB[1] = 0x0A;
3277 } else {
3278 CDB[1] = 0x02;
3279 }
3280 CDB[6] = (io->size >> 16) & 0xFF;
3281 CDB[7] = (io->size >> 8) & 0xFF;
3282 CDB[8] = io->size & 0xFF;
3283 cmdTimeout = 10;
3284 break;
3285
3286 case RESERVE:
3287 cmdLen = 6;
3288 dir = MPI_SCSIIO_CONTROL_READ;
3289 CDB[0] = cmd;
3290 cmdTimeout = 10;
3291 break;
3292
3293 case RELEASE:
3294 cmdLen = 6;
3295 dir = MPI_SCSIIO_CONTROL_READ;
3296 CDB[0] = cmd;
3297 cmdTimeout = 10;
3298 break;
3299
3300 case SYNCHRONIZE_CACHE:
3301 cmdLen = 10;
3302 dir = MPI_SCSIIO_CONTROL_READ;
3303 CDB[0] = cmd;
3304 // CDB[1] = 0x02; /* set immediate bit */
3305 cmdTimeout = 10;
3306 break;
3307
3308 default:
3309 /* Error Case */
3310 return -EFAULT;
3311 }
3312
3313 /* Get and Populate a free Frame
3314 */
3315 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
3316 ddvprintk((MYIOC_s_WARN_FMT "No msg frames!\n",
3317 hd->ioc->name));
3318 return -EBUSY;
3319 }
3320
3321 pScsiReq = (SCSIIORequest_t *) mf;
3322
3323 /* Get the request index */
3324 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3325 ADD_INDEX_LOG(my_idx); /* for debug */
3326
3327 if (io->flags & MPT_ICFLAG_PHYS_DISK) {
3328 pScsiReq->TargetID = io->physDiskNum;
3329 pScsiReq->Bus = 0;
3330 pScsiReq->ChainOffset = 0;
3331 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
3332 } else {
3333 pScsiReq->TargetID = io->id;
3334 pScsiReq->Bus = io->bus;
3335 pScsiReq->ChainOffset = 0;
3336 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
3337 }
3338
3339 pScsiReq->CDBLength = cmdLen;
3340 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
3341
3342 pScsiReq->Reserved = 0;
3343
3344 pScsiReq->MsgFlags = mpt_msg_flags();
3345 /* MsgContext set in mpt_get_msg_fram call */
3346
3347 for (ii=0; ii < 8; ii++)
3348 pScsiReq->LUN[ii] = 0;
3349 pScsiReq->LUN[1] = io->lun;
3350
3351 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
3352 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
3353 else
3354 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
3355
3356 if (cmd == REQUEST_SENSE) {
3357 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
3358 ddvprintk((MYIOC_s_INFO_FMT "Untagged! 0x%2x\n",
3359 hd->ioc->name, cmd));
3360 }
3361
3362 for (ii=0; ii < 16; ii++)
3363 pScsiReq->CDB[ii] = CDB[ii];
3364
3365 pScsiReq->DataLength = cpu_to_le32(io->size);
3366 pScsiReq->SenseBufferLowAddr = cpu_to_le32(hd->ioc->sense_buf_low_dma
3367 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
3368
3369 ddvprintk((MYIOC_s_INFO_FMT "Sending Command 0x%x for (%d:%d:%d)\n",
3370 hd->ioc->name, cmd, io->bus, io->id, io->lun));
3371
3372 if (dir == MPI_SCSIIO_CONTROL_READ) {
3373 mpt_add_sge((char *) &pScsiReq->SGL,
3374 MPT_SGE_FLAGS_SSIMPLE_READ | io->size,
3375 io->data_dma);
3376 } else {
3377 mpt_add_sge((char *) &pScsiReq->SGL,
3378 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size,
3379 io->data_dma);
3380 }
3381
3382 /* The ISR will free the request frame, but we need
3383 * the information to initialize the target. Duplicate.
3384 */
3385 memcpy(&ReqCopy, pScsiReq, sizeof(SCSIIORequest_t));
3386
3387 /* Issue this command after:
3388 * finish init
3389 * add timer
3390 * Wait until the reply has been received
3391 * ScsiScanDvCtx callback function will
3392 * set hd->pLocal;
3393 * set scandv_wait_done and call wake_up
3394 */
3395 hd->pLocal = NULL;
3396 hd->timer.expires = jiffies + HZ*cmdTimeout;
3397 hd->scandv_wait_done = 0;
3398
3399 /* Save cmd pointer, for resource free if timeout or
3400 * FW reload occurs
3401 */
3402 hd->cmdPtr = mf;
3403
3404 add_timer(&hd->timer);
3405 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
3406 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
3407
3408 if (hd->pLocal) {
3409 rc = hd->pLocal->completion;
3410 hd->pLocal->skip = 0;
3411
3412 /* Always set fatal error codes in some cases.
3413 */
3414 if (rc == MPT_SCANDV_SELECTION_TIMEOUT)
3415 rc = -ENXIO;
3416 else if (rc == MPT_SCANDV_SOME_ERROR)
3417 rc = -rc;
3418 } else {
3419 rc = -EFAULT;
3420 /* This should never happen. */
3421 ddvprintk((MYIOC_s_INFO_FMT "_do_cmd: Null pLocal!!!\n",
3422 hd->ioc->name));
3423 }
3424
3425 return rc;
3426 }
3427
3428 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3429 /**
3430 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3431 * @hd: Pointer to a SCSI HOST structure
3432 * @vtarget: per device private data
3433 * @lun: lun
3434 *
3435 * Uses the ISR, but with special processing.
3436 * MUST be single-threaded.
3437 *
3438 */
3439 static void
3440 mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3441 {
3442 INTERNAL_CMD iocmd;
3443
3444 /* Following parameters will not change
3445 * in this routine.
3446 */
3447 iocmd.cmd = SYNCHRONIZE_CACHE;
3448 iocmd.flags = 0;
3449 iocmd.physDiskNum = -1;
3450 iocmd.data = NULL;
3451 iocmd.data_dma = -1;
3452 iocmd.size = 0;
3453 iocmd.rsvd = iocmd.rsvd2 = 0;
3454 iocmd.bus = vdevice->vtarget->bus_id;
3455 iocmd.id = vdevice->vtarget->target_id;
3456 iocmd.lun = (u8)vdevice->lun;
3457
3458 if ((vdevice->vtarget->type == TYPE_DISK) &&
3459 (vdevice->configured_lun))
3460 mptscsih_do_cmd(hd, &iocmd);
3461 }
3462
3463 EXPORT_SYMBOL(mptscsih_remove);
3464 EXPORT_SYMBOL(mptscsih_shutdown);
3465 #ifdef CONFIG_PM
3466 EXPORT_SYMBOL(mptscsih_suspend);
3467 EXPORT_SYMBOL(mptscsih_resume);
3468 #endif
3469 EXPORT_SYMBOL(mptscsih_proc_info);
3470 EXPORT_SYMBOL(mptscsih_info);
3471 EXPORT_SYMBOL(mptscsih_qcmd);
3472 EXPORT_SYMBOL(mptscsih_target_alloc);
3473 EXPORT_SYMBOL(mptscsih_slave_alloc);
3474 EXPORT_SYMBOL(mptscsih_target_destroy);
3475 EXPORT_SYMBOL(mptscsih_slave_destroy);
3476 EXPORT_SYMBOL(mptscsih_slave_configure);
3477 EXPORT_SYMBOL(mptscsih_abort);
3478 EXPORT_SYMBOL(mptscsih_dev_reset);
3479 EXPORT_SYMBOL(mptscsih_bus_reset);
3480 EXPORT_SYMBOL(mptscsih_host_reset);
3481 EXPORT_SYMBOL(mptscsih_bios_param);
3482 EXPORT_SYMBOL(mptscsih_io_done);
3483 EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3484 EXPORT_SYMBOL(mptscsih_scandv_complete);
3485 EXPORT_SYMBOL(mptscsih_event_process);
3486 EXPORT_SYMBOL(mptscsih_ioc_reset);
3487 EXPORT_SYMBOL(mptscsih_change_queue_depth);
3488 EXPORT_SYMBOL(mptscsih_timer_expired);
3489 EXPORT_SYMBOL(mptscsih_TMHandler);
3490
3491 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Software Suspend 2 for 2.6.18.y (mirror)