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