blob: 90a1dff7eb84f74deae202ed2abeb273d417a636 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/message/fusion/mptscsih.c
Prakash, Sathyaf36789e2007-08-14 16:22:54 +05303 * For use with LSI PCI chip/adapter(s)
4 * running LSI Fusion MPT (Message Passing Technology) firmware.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
Prakash, Sathyacddc0ab2008-05-21 00:56:41 +05306 * Copyright (c) 1999-2008 LSI Corporation
Eric Moore16d20102007-06-13 16:31:07 -06007 * (mailto:DL-MPTFusionLinux@lsi.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/module.h>
48#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090049#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <linux/workqueue.h>
58
59#include <scsi/scsi.h>
60#include <scsi/scsi_cmnd.h>
61#include <scsi/scsi_device.h>
62#include <scsi/scsi_host.h>
63#include <scsi/scsi_tcq.h>
Moore, Eric Deane0fc15b2005-09-15 13:17:14 -060064#include <scsi/scsi_dbg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66#include "mptbase.h"
67#include "mptscsih.h"
Eric Moorebf451522006-07-11 17:25:35 -060068#include "lsi/mpi_log_sas.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
71#define my_NAME "Fusion MPT SCSI Host driver"
72#define my_VERSION MPT_LINUX_VERSION_COMMON
73#define MYNAM "mptscsih"
74
75MODULE_AUTHOR(MODULEAUTHOR);
76MODULE_DESCRIPTION(my_NAME);
77MODULE_LICENSE("GPL");
Eric Moore9f4203b2007-01-04 20:47:47 -070078MODULE_VERSION(my_VERSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Linus Torvalds1da177e2005-04-16 15:20:36 -070080/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linus Torvalds1da177e2005-04-16 15:20:36 -070081/*
82 * Other private/forward protos...
83 */
Kashyap, Desaidb7051b2009-05-29 16:56:59 +053084struct scsi_cmnd *mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
Eric Mooree8206382007-09-29 10:16:53 -060085static struct scsi_cmnd * mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i);
86static void mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd);
87static int SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *scmd);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -040088int mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089static void mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -040090int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92static int mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
93 SCSIIORequest_t *pReq, int req_idx);
94static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -040095static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +053097int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id,
98 int lun, int ctx2abort, ulong timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400100int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
101int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Kashyap, Desaie7deff32009-05-29 16:46:07 +0530103void
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +0530104mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code);
Kashyap, Desai37c60f32009-05-29 16:44:06 +0530105static int mptscsih_get_completion_code(MPT_ADAPTER *ioc,
106 MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400107int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -0700109static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +0530111static int
112mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
113 SCSITaskMgmtReply_t *pScsiTmReply);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400114void mptscsih_remove(struct pci_dev *);
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -0700115void mptscsih_shutdown(struct pci_dev *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116#ifdef CONFIG_PM
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400117int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
118int mptscsih_resume(struct pci_dev *pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119#endif
120
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +0900121#define SNS_LEN(scp) SCSI_SENSE_BUFFERSIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
125/*
126 * mptscsih_getFreeChainBuffer - Function to get a free chain
127 * from the MPT_SCSI_HOST FreeChainQ.
128 * @ioc: Pointer to MPT_ADAPTER structure
129 * @req_idx: Index of the SCSI IO request frame. (output)
130 *
131 * return SUCCESS or FAILED
132 */
133static inline int
134mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
135{
136 MPT_FRAME_HDR *chainBuf;
137 unsigned long flags;
138 int rc;
139 int chain_idx;
140
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530141 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n",
Eric Moore29dd3602007-09-14 18:46:51 -0600142 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 spin_lock_irqsave(&ioc->FreeQlock, flags);
144 if (!list_empty(&ioc->FreeChainQ)) {
145 int offset;
146
147 chainBuf = list_entry(ioc->FreeChainQ.next, MPT_FRAME_HDR,
148 u.frame.linkage.list);
149 list_del(&chainBuf->u.frame.linkage.list);
150 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
151 chain_idx = offset / ioc->req_sz;
152 rc = SUCCESS;
Eric Moore29dd3602007-09-14 18:46:51 -0600153 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
154 "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
155 ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 } else {
157 rc = FAILED;
158 chain_idx = MPT_HOST_NO_CHAIN;
Eric Moore29dd3602007-09-14 18:46:51 -0600159 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n",
160 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 }
162 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
163
164 *retIndex = chain_idx;
165 return rc;
166} /* mptscsih_getFreeChainBuffer() */
167
168/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
169/*
170 * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
171 * SCSIIORequest_t Message Frame.
172 * @ioc: Pointer to MPT_ADAPTER structure
173 * @SCpnt: Pointer to scsi_cmnd structure
174 * @pReq: Pointer to SCSIIORequest_t structure
175 *
176 * Returns ...
177 */
178static int
179mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
180 SCSIIORequest_t *pReq, int req_idx)
181{
182 char *psge;
183 char *chainSge;
184 struct scatterlist *sg;
185 int frm_sz;
186 int sges_left, sg_done;
187 int chain_idx = MPT_HOST_NO_CHAIN;
188 int sgeOffset;
189 int numSgeSlots, numSgeThisFrame;
190 u32 sgflags, sgdir, thisxfer = 0;
191 int chain_dma_off = 0;
192 int newIndex;
193 int ii;
194 dma_addr_t v2;
195 u32 RequestNB;
196
197 sgdir = le32_to_cpu(pReq->Control) & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK;
198 if (sgdir == MPI_SCSIIO_CONTROL_WRITE) {
199 sgdir = MPT_TRANSFER_HOST_TO_IOC;
200 } else {
201 sgdir = MPT_TRANSFER_IOC_TO_HOST;
202 }
203
204 psge = (char *) &pReq->SGL;
205 frm_sz = ioc->req_sz;
206
207 /* Map the data portion, if any.
208 * sges_left = 0 if no data transfer.
209 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900210 sges_left = scsi_dma_map(SCpnt);
211 if (sges_left < 0)
212 return FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 /* Handle the SG case.
215 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900216 sg = scsi_sglist(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 sg_done = 0;
218 sgeOffset = sizeof(SCSIIORequest_t) - sizeof(SGE_IO_UNION);
219 chainSge = NULL;
220
221 /* Prior to entering this loop - the following must be set
222 * current MF: sgeOffset (bytes)
223 * chainSge (Null if original MF is not a chain buffer)
224 * sg_done (num SGE done for this MF)
225 */
226
227nextSGEset:
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530228 numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
230
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530231 sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233 /* Get first (num - 1) SG elements
234 * Skip any SG entries with a length of 0
235 * NOTE: at finish, sg and psge pointed to NEXT data/location positions
236 */
237 for (ii=0; ii < (numSgeThisFrame-1); ii++) {
238 thisxfer = sg_dma_len(sg);
239 if (thisxfer == 0) {
Kashyap, Desai2f187862009-05-29 16:52:37 +0530240 /* Get next SG element from the OS */
241 sg = sg_next(sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 sg_done++;
243 continue;
244 }
245
246 v2 = sg_dma_address(sg);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530247 ioc->add_sge(psge, sgflags | thisxfer, v2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Kashyap, Desai2f187862009-05-29 16:52:37 +0530249 /* Get next SG element from the OS */
250 sg = sg_next(sg);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530251 psge += ioc->SGE_size;
252 sgeOffset += ioc->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 sg_done++;
254 }
255
256 if (numSgeThisFrame == sges_left) {
257 /* Add last element, end of buffer and end of list flags.
258 */
259 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT |
260 MPT_SGE_FLAGS_END_OF_BUFFER |
261 MPT_SGE_FLAGS_END_OF_LIST;
262
263 /* Add last SGE and set termination flags.
264 * Note: Last SGE may have a length of 0 - which should be ok.
265 */
266 thisxfer = sg_dma_len(sg);
267
268 v2 = sg_dma_address(sg);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530269 ioc->add_sge(psge, sgflags | thisxfer, v2);
270 sgeOffset += ioc->SGE_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 sg_done++;
272
273 if (chainSge) {
274 /* The current buffer is a chain buffer,
275 * but there is not another one.
276 * Update the chain element
277 * Offset and Length fields.
278 */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530279 ioc->add_chain((char *)chainSge, 0, sgeOffset,
280 ioc->ChainBufferDMA + chain_dma_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 } else {
282 /* The current buffer is the original MF
283 * and there is no Chain buffer.
284 */
285 pReq->ChainOffset = 0;
286 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530287 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 "Single Buffer RequestNB=%x, sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
289 ioc->RequestNB[req_idx] = RequestNB;
290 }
291 } else {
292 /* At least one chain buffer is needed.
293 * Complete the first MF
294 * - last SGE element, set the LastElement bit
295 * - set ChainOffset (words) for orig MF
296 * (OR finish previous MF chain buffer)
297 * - update MFStructPtr ChainIndex
298 * - Populate chain element
299 * Also
300 * Loop until done.
301 */
302
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530303 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SG: Chain Required! sg done %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 ioc->name, sg_done));
305
306 /* Set LAST_ELEMENT flag for last non-chain element
307 * in the buffer. Since psge points at the NEXT
308 * SGE element, go back one SGE element, update the flags
309 * and reset the pointer. (Note: sgflags & thisxfer are already
310 * set properly).
311 */
312 if (sg_done) {
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530313 u32 *ptmp = (u32 *) (psge - ioc->SGE_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 sgflags = le32_to_cpu(*ptmp);
315 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
316 *ptmp = cpu_to_le32(sgflags);
317 }
318
319 if (chainSge) {
320 /* The current buffer is a chain buffer.
321 * chainSge points to the previous Chain Element.
322 * Update its chain element Offset and Length (must
323 * include chain element size) fields.
324 * Old chain element is now complete.
325 */
326 u8 nextChain = (u8) (sgeOffset >> 2);
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +0530327 sgeOffset += ioc->SGE_size;
328 ioc->add_chain((char *)chainSge, nextChain, sgeOffset,
329 ioc->ChainBufferDMA + chain_dma_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 } else {
331 /* The original MF buffer requires a chain buffer -
332 * set the offset.
333 * Last element in this MF is a chain element.
334 */
335 pReq->ChainOffset = (u8) (sgeOffset >> 2);
336 RequestNB = (((sgeOffset - 1) >> ioc->NBShiftFactor) + 1) & 0x03;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530337 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Chain Buffer Needed, RequestNB=%x sgeOffset=%d\n", ioc->name, RequestNB, sgeOffset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 ioc->RequestNB[req_idx] = RequestNB;
339 }
340
341 sges_left -= sg_done;
342
343
344 /* NOTE: psge points to the beginning of the chain element
345 * in current buffer. Get a chain buffer.
346 */
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200347 if ((mptscsih_getFreeChainBuffer(ioc, &newIndex)) == FAILED) {
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530348 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200349 "getFreeChainBuffer FAILED SCSI cmd=%02x (%p)\n",
350 ioc->name, pReq->CDB[0], SCpnt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 return FAILED;
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 /* Update the tracking arrays.
355 * If chainSge == NULL, update ReqToChain, else ChainToChain
356 */
357 if (chainSge) {
358 ioc->ChainToChain[chain_idx] = newIndex;
359 } else {
360 ioc->ReqToChain[req_idx] = newIndex;
361 }
362 chain_idx = newIndex;
363 chain_dma_off = ioc->req_sz * chain_idx;
364
365 /* Populate the chainSGE for the current buffer.
366 * - Set chain buffer pointer to psge and fill
367 * out the Address and Flags fields.
368 */
369 chainSge = (char *) psge;
Eric Moore29dd3602007-09-14 18:46:51 -0600370 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Current buff @ %p (index 0x%x)",
371 ioc->name, psge, req_idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
373 /* Start the SGE for the next buffer
374 */
375 psge = (char *) (ioc->ChainBuffer + chain_dma_off);
376 sgeOffset = 0;
377 sg_done = 0;
378
Eric Moore29dd3602007-09-14 18:46:51 -0600379 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Chain buff @ %p (index 0x%x)\n",
380 ioc->name, psge, chain_idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382 /* Start the SGE for the next buffer
383 */
384
385 goto nextSGEset;
386 }
387
388 return SUCCESS;
389} /* mptscsih_AddSGE() */
390
Eric Moore786899b2006-07-11 17:22:22 -0600391static void
392mptscsih_issue_sep_command(MPT_ADAPTER *ioc, VirtTarget *vtarget,
393 U32 SlotStatus)
394{
395 MPT_FRAME_HDR *mf;
396 SEPRequest_t *SEPMsg;
397
Eric Moorecc78d302007-06-15 17:27:21 -0600398 if (ioc->bus_type != SAS)
399 return;
400
401 /* Not supported for hidden raid components
402 */
403 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
Eric Moore786899b2006-07-11 17:22:22 -0600404 return;
405
406 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530407 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -0700408 ioc->name,__func__));
Eric Moore786899b2006-07-11 17:22:22 -0600409 return;
410 }
411
412 SEPMsg = (SEPRequest_t *)mf;
413 SEPMsg->Function = MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
Eric Moore793955f2007-01-29 09:42:20 -0700414 SEPMsg->Bus = vtarget->channel;
415 SEPMsg->TargetID = vtarget->id;
Eric Moore786899b2006-07-11 17:22:22 -0600416 SEPMsg->Action = MPI_SEP_REQ_ACTION_WRITE_STATUS;
417 SEPMsg->SlotStatus = SlotStatus;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530418 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Eric Moore793955f2007-01-29 09:42:20 -0700419 "Sending SEP cmd=%x channel=%d id=%d\n",
420 ioc->name, SlotStatus, SEPMsg->Bus, SEPMsg->TargetID));
Eric Moore786899b2006-07-11 17:22:22 -0600421 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
422}
423
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530424#ifdef CONFIG_FUSION_LOGGING
Eric Moorec6c727a2007-01-29 09:44:54 -0700425/**
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530426 * mptscsih_info_scsiio - debug print info on reply frame
Eric Moorec6c727a2007-01-29 09:44:54 -0700427 * @ioc: Pointer to MPT_ADAPTER structure
Eric Moorec6c727a2007-01-29 09:44:54 -0700428 * @sc: original scsi cmnd pointer
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530429 * @pScsiReply: Pointer to MPT reply frame
430 *
431 * MPT_DEBUG_REPLY needs to be enabled to obtain this info
Eric Moorec6c727a2007-01-29 09:44:54 -0700432 *
433 * Refer to lsi/mpi.h.
434 **/
435static void
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530436mptscsih_info_scsiio(MPT_ADAPTER *ioc, struct scsi_cmnd *sc, SCSIIOReply_t * pScsiReply)
Eric Moorec6c727a2007-01-29 09:44:54 -0700437{
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530438 char *desc = NULL;
439 char *desc1 = NULL;
440 u16 ioc_status;
441 u8 skey, asc, ascq;
442
443 ioc_status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
Eric Moorec6c727a2007-01-29 09:44:54 -0700444
445 switch (ioc_status) {
446
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530447 case MPI_IOCSTATUS_SUCCESS:
448 desc = "success";
Eric Moorec6c727a2007-01-29 09:44:54 -0700449 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530450 case MPI_IOCSTATUS_SCSI_INVALID_BUS:
451 desc = "invalid bus";
Eric Moorec6c727a2007-01-29 09:44:54 -0700452 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530453 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID:
454 desc = "invalid target_id";
Eric Moorec6c727a2007-01-29 09:44:54 -0700455 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530456 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
457 desc = "device not there";
Eric Moorec6c727a2007-01-29 09:44:54 -0700458 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530459 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN:
460 desc = "data overrun";
Eric Moorec6c727a2007-01-29 09:44:54 -0700461 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530462 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN:
463 desc = "data underrun";
Eric Moorec6c727a2007-01-29 09:44:54 -0700464 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530465 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR:
466 desc = "I/O data error";
Eric Moorec6c727a2007-01-29 09:44:54 -0700467 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530468 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR:
469 desc = "protocol error";
Eric Moorec6c727a2007-01-29 09:44:54 -0700470 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530471 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED:
472 desc = "task terminated";
Eric Moorec6c727a2007-01-29 09:44:54 -0700473 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530474 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
475 desc = "residual mismatch";
Eric Moorec6c727a2007-01-29 09:44:54 -0700476 break;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530477 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
478 desc = "task management failed";
479 break;
480 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED:
481 desc = "IOC terminated";
482 break;
483 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED:
484 desc = "ext terminated";
485 break;
486 default:
487 desc = "";
Eric Moorec6c727a2007-01-29 09:44:54 -0700488 break;
489 }
490
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530491 switch (pScsiReply->SCSIStatus)
492 {
Eric Moorec6c727a2007-01-29 09:44:54 -0700493
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530494 case MPI_SCSI_STATUS_SUCCESS:
495 desc1 = "success";
496 break;
497 case MPI_SCSI_STATUS_CHECK_CONDITION:
498 desc1 = "check condition";
499 break;
500 case MPI_SCSI_STATUS_CONDITION_MET:
501 desc1 = "condition met";
502 break;
503 case MPI_SCSI_STATUS_BUSY:
504 desc1 = "busy";
505 break;
506 case MPI_SCSI_STATUS_INTERMEDIATE:
507 desc1 = "intermediate";
508 break;
509 case MPI_SCSI_STATUS_INTERMEDIATE_CONDMET:
510 desc1 = "intermediate condmet";
511 break;
512 case MPI_SCSI_STATUS_RESERVATION_CONFLICT:
513 desc1 = "reservation conflict";
514 break;
515 case MPI_SCSI_STATUS_COMMAND_TERMINATED:
516 desc1 = "command terminated";
517 break;
518 case MPI_SCSI_STATUS_TASK_SET_FULL:
519 desc1 = "task set full";
520 break;
521 case MPI_SCSI_STATUS_ACA_ACTIVE:
522 desc1 = "aca active";
523 break;
524 case MPI_SCSI_STATUS_FCPEXT_DEVICE_LOGGED_OUT:
525 desc1 = "fcpext device logged out";
526 break;
527 case MPI_SCSI_STATUS_FCPEXT_NO_LINK:
528 desc1 = "fcpext no link";
529 break;
530 case MPI_SCSI_STATUS_FCPEXT_UNASSIGNED:
531 desc1 = "fcpext unassigned";
532 break;
533 default:
534 desc1 = "";
535 break;
536 }
Eric Moorec6c727a2007-01-29 09:44:54 -0700537
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530538 scsi_print_command(sc);
Kashyap, Desai2f187862009-05-29 16:52:37 +0530539 printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %d\n",
540 ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun);
Eric Moore29dd3602007-09-14 18:46:51 -0600541 printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, "
542 "resid = %d\n", ioc->name, scsi_bufflen(sc), sc->underflow,
543 scsi_get_resid(sc));
544 printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, "
545 "sc->result = %08X\n", ioc->name, le16_to_cpu(pScsiReply->TaskTag),
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530546 le32_to_cpu(pScsiReply->TransferCount), sc->result);
Kashyap, Desai2f187862009-05-29 16:52:37 +0530547
Eric Moore29dd3602007-09-14 18:46:51 -0600548 printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), "
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530549 "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n",
Eric Moore29dd3602007-09-14 18:46:51 -0600550 ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus,
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530551 pScsiReply->SCSIState);
552
553 if (pScsiReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
554 skey = sc->sense_buffer[2] & 0x0F;
555 asc = sc->sense_buffer[12];
556 ascq = sc->sense_buffer[13];
557
Eric Moore29dd3602007-09-14 18:46:51 -0600558 printk(MYIOC_s_DEBUG_FMT "\t[sense_key,asc,ascq]: "
559 "[0x%02x,0x%02x,0x%02x]\n", ioc->name, skey, asc, ascq);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530560 }
561
562 /*
563 * Look for + dump FCP ResponseInfo[]!
564 */
565 if (pScsiReply->SCSIState & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
566 pScsiReply->ResponseInfo)
Eric Moore29dd3602007-09-14 18:46:51 -0600567 printk(MYIOC_s_DEBUG_FMT "response_info = %08xh\n",
568 ioc->name, le32_to_cpu(pScsiReply->ResponseInfo));
Eric Moorec6c727a2007-01-29 09:44:54 -0700569}
570#endif
571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
573/*
574 * mptscsih_io_done - Main SCSI IO callback routine registered to
575 * Fusion MPT (base) driver
576 * @ioc: Pointer to MPT_ADAPTER structure
577 * @mf: Pointer to original MPT request frame
578 * @r: Pointer to MPT reply frame (NULL if TurboReply)
579 *
580 * This routine is called from mpt.c::mpt_interrupt() at the completion
581 * of any SCSI IO request.
582 * This routine is registered with the Fusion MPT (base) driver at driver
583 * load/init time via the mpt_register() API call.
584 *
585 * Returns 1 indicating alloc'd request frame ptr should be freed.
586 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400587int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
589{
590 struct scsi_cmnd *sc;
591 MPT_SCSI_HOST *hd;
592 SCSIIORequest_t *pScsiReq;
593 SCSIIOReply_t *pScsiReply;
Moore, Eric2254c862006-01-17 17:06:29 -0700594 u16 req_idx, req_idx_MR;
Eric Moorea69de502007-09-14 18:48:19 -0600595 VirtDevice *vdevice;
Eric Moore786899b2006-07-11 17:22:22 -0600596 VirtTarget *vtarget;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
Eric Mooree7eae9f2007-09-29 10:15:59 -0600598 hd = shost_priv(ioc->sh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
Moore, Eric2254c862006-01-17 17:06:29 -0700600 req_idx_MR = (mr != NULL) ?
601 le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
Kashyap, Desai2f187862009-05-29 16:52:37 +0530602
603 /* Special case, where already freed message frame is received from
604 * Firmware. It happens with Resetting IOC.
605 * Return immediately. Do not care
606 */
Moore, Eric2254c862006-01-17 17:06:29 -0700607 if ((req_idx != req_idx_MR) ||
Kashyap, Desai2f187862009-05-29 16:52:37 +0530608 (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf))
Moore, Eric2254c862006-01-17 17:06:29 -0700609 return 0;
Moore, Eric2254c862006-01-17 17:06:29 -0700610
Eric Mooree8206382007-09-29 10:16:53 -0600611 sc = mptscsih_getclear_scsi_lookup(ioc, req_idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (sc == NULL) {
613 MPIHeader_t *hdr = (MPIHeader_t *)mf;
614
615 /* Remark: writeSDP1 will use the ScsiDoneCtx
616 * If a SCSI I/O cmd, device disabled by OS and
617 * completion done. Cannot touch sc struct. Just free mem.
618 */
619 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST)
620 printk(MYIOC_s_ERR_FMT "NULL ScsiCmd ptr!\n",
621 ioc->name);
622
623 mptscsih_freeChainBuffers(ioc, req_idx);
624 return 1;
625 }
626
Eric Moore3dc0b032006-07-11 17:32:33 -0600627 if ((unsigned char *)mf != sc->host_scribble) {
628 mptscsih_freeChainBuffers(ioc, req_idx);
629 return 1;
630 }
631
Kashyap, Desaifea98402009-09-02 11:45:53 +0530632 if (ioc->bus_type == SAS) {
633 VirtDevice *vdevice = sc->device->hostdata;
634
635 if (!vdevice || !vdevice->vtarget ||
636 vdevice->vtarget->deleted) {
637 sc->result = DID_NO_CONNECT << 16;
638 goto out;
639 }
640 }
641
Eric Moore3dc0b032006-07-11 17:32:33 -0600642 sc->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 sc->result = DID_OK << 16; /* Set default reply as OK */
644 pScsiReq = (SCSIIORequest_t *) mf;
645 pScsiReply = (SCSIIOReply_t *) mr;
646
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200647 if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530648 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200649 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
650 ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
651 }else{
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530652 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Christoph Hellwigc6678e02005-08-18 16:24:53 +0200653 "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d)\n",
654 ioc->name, mf, mr, sc, req_idx));
655 }
656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (pScsiReply == NULL) {
658 /* special context reply handling */
659 ;
660 } else {
661 u32 xfer_cnt;
662 u16 status;
663 u8 scsi_state, scsi_status;
Eric Moorec6c727a2007-01-29 09:44:54 -0700664 u32 log_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
666 status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
667 scsi_state = pScsiReply->SCSIState;
668 scsi_status = pScsiReply->SCSIStatus;
669 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900670 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
Eric Moorec6c727a2007-01-29 09:44:54 -0700671 log_info = le32_to_cpu(pScsiReply->IOCLogInfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600673 /*
674 * if we get a data underrun indication, yet no data was
675 * transferred and the SCSI status indicates that the
676 * command was never started, change the data underrun
677 * to success
678 */
679 if (status == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
680 (scsi_status == MPI_SCSI_STATUS_BUSY ||
681 scsi_status == MPI_SCSI_STATUS_RESERVATION_CONFLICT ||
682 scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)) {
683 status = MPI_IOCSTATUS_SUCCESS;
684 }
685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400687 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
688
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 /*
690 * Look for + dump FCP ResponseInfo[]!
691 */
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600692 if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
693 pScsiReply->ResponseInfo) {
Eric Moore29dd3602007-09-14 18:46:51 -0600694 printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%d] "
695 "FCP_ResponseInfo=%08xh\n", ioc->name,
Eric Moorec6c727a2007-01-29 09:44:54 -0700696 sc->device->host->host_no, sc->device->channel,
697 sc->device->id, sc->device->lun,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 le32_to_cpu(pScsiReply->ResponseInfo));
699 }
700
701 switch(status) {
702 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
Kashyap, Desaid23321b2009-08-05 12:51:25 +0530703 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 /* CHECKME!
705 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
706 * But not: DID_BUS_BUSY lest one risk
707 * killing interrupt handler:-(
708 */
709 sc->result = SAM_STAT_BUSY;
710 break;
711
712 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
713 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
714 sc->result = DID_BAD_TARGET << 16;
715 break;
716
717 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
718 /* Spoof to SCSI Selection Timeout! */
Moore, Eric65207fe2006-04-21 16:14:35 -0600719 if (ioc->bus_type != FC)
720 sc->result = DID_NO_CONNECT << 16;
721 /* else fibre, just stall until rescan event */
722 else
723 sc->result = DID_REQUEUE << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
725 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
726 hd->sel_timeout[pScsiReq->TargetID]++;
Eric Moore786899b2006-07-11 17:22:22 -0600727
Eric Moorea69de502007-09-14 18:48:19 -0600728 vdevice = sc->device->hostdata;
729 if (!vdevice)
Eric Moore786899b2006-07-11 17:22:22 -0600730 break;
Eric Moorea69de502007-09-14 18:48:19 -0600731 vtarget = vdevice->vtarget;
Eric Moore786899b2006-07-11 17:22:22 -0600732 if (vtarget->tflags & MPT_TARGET_FLAGS_LED_ON) {
733 mptscsih_issue_sep_command(ioc, vtarget,
734 MPI_SEP_REQ_SLOTSTATUS_UNCONFIGURED);
735 vtarget->tflags &= ~MPT_TARGET_FLAGS_LED_ON;
736 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 break;
738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
Eric Moorebf451522006-07-11 17:25:35 -0600740 if ( ioc->bus_type == SAS ) {
741 u16 ioc_status = le16_to_cpu(pScsiReply->IOCStatus);
742 if (ioc_status & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
Eric Moorec6c727a2007-01-29 09:44:54 -0700743 if ((log_info & SAS_LOGINFO_MASK)
744 == SAS_LOGINFO_NEXUS_LOSS) {
Eric Moorebf451522006-07-11 17:25:35 -0600745 sc->result = (DID_BUS_BUSY << 16);
746 break;
747 }
748 }
Eric Moore86dd4242007-01-04 20:44:01 -0700749 } else if (ioc->bus_type == FC) {
750 /*
751 * The FC IOC may kill a request for variety of
752 * reasons, some of which may be recovered by a
753 * retry, some which are unlikely to be
754 * recovered. Return DID_ERROR instead of
755 * DID_RESET to permit retry of the command,
756 * just not an infinite number of them
757 */
758 sc->result = DID_ERROR << 16;
759 break;
Eric Moorebf451522006-07-11 17:25:35 -0600760 }
761
762 /*
763 * Allow non-SAS & non-NEXUS_LOSS to drop into below code
764 */
765
766 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 /* Linux handles an unsolicited DID_RESET better
768 * than an unsolicited DID_ABORT.
769 */
770 sc->result = DID_RESET << 16;
771
Kashyap, Desai2f187862009-05-29 16:52:37 +0530772 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
773 if (ioc->bus_type == FC)
774 sc->result = DID_ERROR << 16;
775 else
776 sc->result = DID_RESET << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 break;
778
779 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900780 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600781 if((xfer_cnt==0)||(sc->underflow > xfer_cnt))
782 sc->result=DID_SOFT_ERROR << 16;
783 else /* Sufficient data transfer occurred */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 sc->result = (DID_OK << 16) | scsi_status;
Eric Moore29dd3602007-09-14 18:46:51 -0600785 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Eric Moorec6c727a2007-01-29 09:44:54 -0700786 "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
Eric Moore29dd3602007-09-14 18:46:51 -0600787 ioc->name, sc->result, sc->device->channel, sc->device->id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 break;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400789
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
791 /*
792 * Do upfront check for valid SenseData and give it
793 * precedence!
794 */
795 sc->result = (DID_OK << 16) | scsi_status;
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530796 if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
797
798 /*
799 * For an Errata on LSI53C1030
800 * When the length of request data
801 * and transfer data are different
802 * with result of command (READ or VERIFY),
803 * DID_SOFT_ERROR is set.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 */
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530805 if (ioc->bus_type == SPI) {
806 if (pScsiReq->CDB[0] == READ_6 ||
807 pScsiReq->CDB[0] == READ_10 ||
808 pScsiReq->CDB[0] == READ_12 ||
809 pScsiReq->CDB[0] == READ_16 ||
810 pScsiReq->CDB[0] == VERIFY ||
811 pScsiReq->CDB[0] == VERIFY_16) {
812 if (scsi_bufflen(sc) !=
813 xfer_cnt) {
814 sc->result =
815 DID_SOFT_ERROR << 16;
816 printk(KERN_WARNING "Errata"
817 "on LSI53C1030 occurred."
818 "sc->req_bufflen=0x%02x,"
819 "xfer_cnt=0x%02x\n",
820 scsi_bufflen(sc),
821 xfer_cnt);
822 }
823 }
824 }
825
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 if (xfer_cnt < sc->underflow) {
Moore, Eric Dean466544d2005-09-14 18:09:10 -0600827 if (scsi_status == SAM_STAT_BUSY)
828 sc->result = SAM_STAT_BUSY;
829 else
830 sc->result = DID_SOFT_ERROR << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 }
832 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
833 /* What to do?
834 */
835 sc->result = DID_SOFT_ERROR << 16;
836 }
837 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
838 /* Not real sure here either... */
839 sc->result = DID_RESET << 16;
840 }
841 }
842
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530843
Eric Moore29dd3602007-09-14 18:46:51 -0600844 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
845 " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
846 ioc->name, sc->underflow));
847 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
848 " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 /* Report Queue Full
851 */
852 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
853 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -0400854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 break;
856
Moore, Eric7e551472006-01-16 18:53:21 -0700857 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900858 scsi_set_resid(sc, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
860 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
Eric Mooread8c31b2007-03-19 10:31:51 -0600861 sc->result = (DID_OK << 16) | scsi_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 if (scsi_state == 0) {
863 ;
Kashyap, Desai9b53b392009-10-07 11:27:40 +0530864 } else if (scsi_state &
865 MPI_SCSI_STATE_AUTOSENSE_VALID) {
866
867 /*
868 * For potential trouble on LSI53C1030.
869 * (date:2007.xx.)
870 * It is checked whether the length of
871 * request data is equal to
872 * the length of transfer and residual.
873 * MEDIUM_ERROR is set by incorrect data.
874 */
875 if ((ioc->bus_type == SPI) &&
876 (sc->sense_buffer[2] & 0x20)) {
877 u32 difftransfer;
878 difftransfer =
879 sc->sense_buffer[3] << 24 |
880 sc->sense_buffer[4] << 16 |
881 sc->sense_buffer[5] << 8 |
882 sc->sense_buffer[6];
883 if (((sc->sense_buffer[3] & 0x80) ==
884 0x80) && (scsi_bufflen(sc)
885 != xfer_cnt)) {
886 sc->sense_buffer[2] =
887 MEDIUM_ERROR;
888 sc->sense_buffer[12] = 0xff;
889 sc->sense_buffer[13] = 0xff;
890 printk(KERN_WARNING"Errata"
891 "on LSI53C1030 occurred."
892 "sc->req_bufflen=0x%02x,"
893 "xfer_cnt=0x%02x\n" ,
894 scsi_bufflen(sc),
895 xfer_cnt);
896 }
897 if (((sc->sense_buffer[3] & 0x80)
898 != 0x80) &&
899 (scsi_bufflen(sc) !=
900 xfer_cnt + difftransfer)) {
901 sc->sense_buffer[2] =
902 MEDIUM_ERROR;
903 sc->sense_buffer[12] = 0xff;
904 sc->sense_buffer[13] = 0xff;
905 printk(KERN_WARNING
906 "Errata on LSI53C1030 occurred"
907 "sc->req_bufflen=0x%02x,"
908 " xfer_cnt=0x%02x,"
909 "difftransfer=0x%02x\n",
910 scsi_bufflen(sc),
911 xfer_cnt,
912 difftransfer);
913 }
914 }
915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 /*
917 * If running against circa 200003dd 909 MPT f/w,
918 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
919 * (QUEUE_FULL) returned from device! --> get 0x0000?128
920 * and with SenseBytes set to 0.
921 */
922 if (pScsiReply->SCSIStatus == MPI_SCSI_STATUS_TASK_SET_FULL)
923 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
924
925 }
926 else if (scsi_state &
927 (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
928 ) {
929 /*
930 * What to do?
931 */
932 sc->result = DID_SOFT_ERROR << 16;
933 }
934 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
935 /* Not real sure here either... */
936 sc->result = DID_RESET << 16;
937 }
938 else if (scsi_state & MPI_SCSI_STATE_QUEUE_TAG_REJECTED) {
939 /* Device Inq. data indicates that it supports
940 * QTags, but rejects QTag messages.
941 * This command completed OK.
942 *
943 * Not real sure here either so do nothing... */
944 }
945
946 if (sc->result == MPI_SCSI_STATUS_TASK_SET_FULL)
947 mptscsih_report_queue_full(sc, pScsiReply, pScsiReq);
948
949 /* Add handling of:
950 * Reservation Conflict, Busy,
951 * Command Terminated, CHECK
952 */
953 break;
954
955 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
956 sc->result = DID_SOFT_ERROR << 16;
957 break;
958
959 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
960 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
961 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
962 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
964 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
966 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
967 default:
968 /*
969 * What to do?
970 */
971 sc->result = DID_SOFT_ERROR << 16;
972 break;
973
974 } /* switch(status) */
975
Prakash, Sathya6757d6b2007-07-25 11:14:01 +0530976#ifdef CONFIG_FUSION_LOGGING
977 if (sc->result && (ioc->debug_level & MPT_DEBUG_REPLY))
978 mptscsih_info_scsiio(ioc, sc, pScsiReply);
Eric Moorec6c727a2007-01-29 09:44:54 -0700979#endif
980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 } /* end of address reply case */
Kashyap, Desaifea98402009-09-02 11:45:53 +0530982out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 /* Unmap the DMA buffers, if any. */
FUJITA Tomonori1928d732007-05-26 00:37:15 +0900984 scsi_dma_unmap(sc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 sc->scsi_done(sc); /* Issue the command callback */
987
988 /* Free Chain buffers */
989 mptscsih_freeChainBuffers(ioc, req_idx);
990 return 1;
991}
992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993/*
994 * mptscsih_flush_running_cmds - For each command found, search
995 * Scsi_Host instance taskQ and reply to OS.
996 * Called only if recovering from a FW reload.
997 * @hd: Pointer to a SCSI HOST structure
998 *
999 * Returns: None.
1000 *
1001 * Must be called while new I/Os are being queued.
1002 */
1003static void
1004mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
1005{
1006 MPT_ADAPTER *ioc = hd->ioc;
Eric Mooree8206382007-09-29 10:16:53 -06001007 struct scsi_cmnd *sc;
1008 SCSIIORequest_t *mf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 int ii;
Eric Mooree8206382007-09-29 10:16:53 -06001010 int channel, id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
Eric Mooree8206382007-09-29 10:16:53 -06001012 for (ii= 0; ii < ioc->req_depth; ii++) {
1013 sc = mptscsih_getclear_scsi_lookup(ioc, ii);
1014 if (!sc)
1015 continue;
1016 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
1017 if (!mf)
1018 continue;
1019 channel = mf->Bus;
1020 id = mf->TargetID;
1021 mptscsih_freeChainBuffers(ioc, ii);
1022 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
1023 if ((unsigned char *)mf != sc->host_scribble)
1024 continue;
1025 scsi_dma_unmap(sc);
1026 sc->result = DID_RESET << 16;
1027 sc->host_scribble = NULL;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301028 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
1029 "completing cmds: fw_channel %d, fw_id %d, sc=%p, mf = %p, "
1030 "idx=%x\n", ioc->name, channel, id, sc, mf, ii));
Eric Mooree8206382007-09-29 10:16:53 -06001031 sc->scsi_done(sc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033}
1034
1035/*
1036 * mptscsih_search_running_cmds - Delete any commands associated
1037 * with the specified target and lun. Function called only
1038 * when a lun is disable by mid-layer.
1039 * Do NOT access the referenced scsi_cmnd structure or
1040 * members. Will cause either a paging or NULL ptr error.
Michael Reed05e8ec12006-01-13 14:31:54 -06001041 * (BUT, BUT, BUT, the code does reference it! - mdr)
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07001042 * @hd: Pointer to a SCSI HOST structure
1043 * @vdevice: per device private data
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 *
1045 * Returns: None.
1046 *
1047 * Called from slave_destroy.
1048 */
1049static void
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07001050mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051{
1052 SCSIIORequest_t *mf = NULL;
1053 int ii;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001054 struct scsi_cmnd *sc;
Eric Moore793955f2007-01-29 09:42:20 -07001055 struct scsi_lun lun;
Eric Mooree80b0022007-09-14 18:49:03 -06001056 MPT_ADAPTER *ioc = hd->ioc;
Eric Mooree8206382007-09-29 10:16:53 -06001057 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
Eric Mooree8206382007-09-29 10:16:53 -06001059 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
1060 for (ii = 0; ii < ioc->req_depth; ii++) {
1061 if ((sc = ioc->ScsiLookup[ii]) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
Eric Mooree80b0022007-09-14 18:49:03 -06001063 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
Eric Moore3dc0b032006-07-11 17:32:33 -06001064 if (mf == NULL)
1065 continue;
Eric Moorecc78d302007-06-15 17:27:21 -06001066 /* If the device is a hidden raid component, then its
1067 * expected that the mf->function will be RAID_SCSI_IO
1068 */
1069 if (vdevice->vtarget->tflags &
1070 MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function !=
1071 MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
1072 continue;
1073
Eric Moore793955f2007-01-29 09:42:20 -07001074 int_to_scsilun(vdevice->lun, &lun);
1075 if ((mf->Bus != vdevice->vtarget->channel) ||
1076 (mf->TargetID != vdevice->vtarget->id) ||
1077 memcmp(lun.scsi_lun, mf->LUN, 8))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 continue;
1079
Eric Moore3dc0b032006-07-11 17:32:33 -06001080 if ((unsigned char *)mf != sc->host_scribble)
1081 continue;
Eric Mooree8206382007-09-29 10:16:53 -06001082 ioc->ScsiLookup[ii] = NULL;
1083 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
1084 mptscsih_freeChainBuffers(ioc, ii);
1085 mpt_free_msg_frame(ioc, (MPT_FRAME_HDR *)mf);
FUJITA Tomonori1928d732007-05-26 00:37:15 +09001086 scsi_dma_unmap(sc);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001087 sc->host_scribble = NULL;
1088 sc->result = DID_NO_CONNECT << 16;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301089 dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device,
1090 MYIOC_s_FMT "completing cmds: fw_channel %d, "
1091 "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name,
1092 vdevice->vtarget->channel, vdevice->vtarget->id,
1093 sc, mf, ii));
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001094 sc->scsi_done(sc);
Eric Mooree8206382007-09-29 10:16:53 -06001095 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 }
1097 }
Eric Mooree8206382007-09-29 10:16:53 -06001098 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 return;
1100}
1101
1102/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
1104/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1105/*
1106 * mptscsih_report_queue_full - Report QUEUE_FULL status returned
1107 * from a SCSI target device.
1108 * @sc: Pointer to scsi_cmnd structure
1109 * @pScsiReply: Pointer to SCSIIOReply_t
1110 * @pScsiReq: Pointer to original SCSI request
1111 *
1112 * This routine periodically reports QUEUE_FULL status returned from a
1113 * SCSI target device. It reports this to the console via kernel
1114 * printk() API call, not more than once every 10 seconds.
1115 */
1116static void
1117mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
1118{
1119 long time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 MPT_SCSI_HOST *hd;
Eric Mooree80b0022007-09-14 18:49:03 -06001121 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001123 if (sc->device == NULL)
1124 return;
1125 if (sc->device->host == NULL)
1126 return;
Eric Mooree7eae9f2007-09-29 10:15:59 -06001127 if ((hd = shost_priv(sc->device->host)) == NULL)
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001128 return;
Eric Mooree80b0022007-09-14 18:49:03 -06001129 ioc = hd->ioc;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001130 if (time - hd->last_queue_full > 10 * HZ) {
Eric Mooree80b0022007-09-14 18:49:03 -06001131 dprintk(ioc, printk(MYIOC_s_WARN_FMT "Device (%d:%d:%d) reported QUEUE_FULL!\n",
1132 ioc->name, 0, sc->device->id, sc->device->lun));
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001133 hd->last_queue_full = time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135}
1136
1137/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1138/*
1139 * mptscsih_remove - Removed scsi devices
1140 * @pdev: Pointer to pci_dev structure
1141 *
1142 *
1143 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001144void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145mptscsih_remove(struct pci_dev *pdev)
1146{
1147 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1148 struct Scsi_Host *host = ioc->sh;
1149 MPT_SCSI_HOST *hd;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001150 int sz1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 scsi_remove_host(host);
1153
Eric Mooree7eae9f2007-09-29 10:15:59 -06001154 if((hd = shost_priv(host)) == NULL)
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001155 return;
1156
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001157 mptscsih_shutdown(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001159 sz1=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
Eric Mooree8206382007-09-29 10:16:53 -06001161 if (ioc->ScsiLookup != NULL) {
Eric Mooree80b0022007-09-14 18:49:03 -06001162 sz1 = ioc->req_depth * sizeof(void *);
Eric Mooree8206382007-09-29 10:16:53 -06001163 kfree(ioc->ScsiLookup);
1164 ioc->ScsiLookup = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 }
1166
Eric Mooree80b0022007-09-14 18:49:03 -06001167 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001168 "Free'd ScsiLookup (%d) memory\n",
Eric Mooree80b0022007-09-14 18:49:03 -06001169 ioc->name, sz1));
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001170
Moore, Eric Dean d485eb82005-05-11 17:37:26 -06001171 kfree(hd->info_kbuf);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001172
1173 /* NULL the Scsi_Host pointer
1174 */
Eric Mooree80b0022007-09-14 18:49:03 -06001175 ioc->sh = NULL;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001176
1177 scsi_host_put(host);
1178
1179 mpt_detach(pdev);
Christoph Hellwigc6678e02005-08-18 16:24:53 +02001180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181}
1182
1183/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1184/*
1185 * mptscsih_shutdown - reboot notifier
1186 *
1187 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001188void
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001189mptscsih_shutdown(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191}
1192
1193#ifdef CONFIG_PM
1194/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1195/*
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001196 * mptscsih_suspend - Fusion MPT scsi driver suspend routine.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 *
1198 *
1199 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001200int
Pavel Machek8d189f72005-04-16 15:25:28 -07001201mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202{
Prakash, Sathya4d4109d2008-03-07 16:19:50 +05301203 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1204
1205 scsi_block_requests(ioc->sh);
1206 flush_scheduled_work();
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001207 mptscsih_shutdown(pdev);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001208 return mpt_suspend(pdev,state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209}
1210
1211/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1212/*
1213 * mptscsih_resume - Fusion MPT scsi driver resume routine.
1214 *
1215 *
1216 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001217int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218mptscsih_resume(struct pci_dev *pdev)
1219{
Prakash, Sathya4d4109d2008-03-07 16:19:50 +05301220 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1221 int rc;
1222
1223 rc = mpt_resume(pdev);
1224 scsi_unblock_requests(ioc->sh);
1225 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226}
1227
1228#endif
1229
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1231/**
1232 * mptscsih_info - Return information about MPT adapter
1233 * @SChost: Pointer to Scsi_Host structure
1234 *
1235 * (linux scsi_host_template.info routine)
1236 *
1237 * Returns pointer to buffer where information was written.
1238 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001239const char *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240mptscsih_info(struct Scsi_Host *SChost)
1241{
1242 MPT_SCSI_HOST *h;
1243 int size = 0;
1244
Eric Mooree7eae9f2007-09-29 10:15:59 -06001245 h = shost_priv(SChost);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001246
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 if (h) {
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001248 if (h->info_kbuf == NULL)
1249 if ((h->info_kbuf = kmalloc(0x1000 /* 4Kb */, GFP_KERNEL)) == NULL)
1250 return h->info_kbuf;
1251 h->info_kbuf[0] = '\0';
1252
1253 mpt_print_ioc_summary(h->ioc, h->info_kbuf, &size, 0, 0);
1254 h->info_kbuf[size-1] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 }
1256
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001257 return h->info_kbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258}
1259
1260struct info_str {
1261 char *buffer;
1262 int length;
1263 int offset;
1264 int pos;
1265};
1266
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001267static void
1268mptscsih_copy_mem_info(struct info_str *info, char *data, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269{
1270 if (info->pos + len > info->length)
1271 len = info->length - info->pos;
1272
1273 if (info->pos + len < info->offset) {
1274 info->pos += len;
1275 return;
1276 }
1277
1278 if (info->pos < info->offset) {
1279 data += (info->offset - info->pos);
1280 len -= (info->offset - info->pos);
1281 }
1282
1283 if (len > 0) {
1284 memcpy(info->buffer + info->pos, data, len);
1285 info->pos += len;
1286 }
1287}
1288
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001289static int
1290mptscsih_copy_info(struct info_str *info, char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291{
1292 va_list args;
1293 char buf[81];
1294 int len;
1295
1296 va_start(args, fmt);
1297 len = vsprintf(buf, fmt, args);
1298 va_end(args);
1299
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001300 mptscsih_copy_mem_info(info, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 return len;
1302}
1303
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001304static int
1305mptscsih_host_info(MPT_ADAPTER *ioc, char *pbuf, off_t offset, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306{
1307 struct info_str info;
1308
1309 info.buffer = pbuf;
1310 info.length = len;
1311 info.offset = offset;
1312 info.pos = 0;
1313
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001314 mptscsih_copy_info(&info, "%s: %s, ", ioc->name, ioc->prod_name);
1315 mptscsih_copy_info(&info, "%s%08xh, ", MPT_FW_REV_MAGIC_ID_STRING, ioc->facts.FWVersion.Word);
1316 mptscsih_copy_info(&info, "Ports=%d, ", ioc->facts.NumberOfPorts);
1317 mptscsih_copy_info(&info, "MaxQ=%d\n", ioc->req_depth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
1319 return ((info.pos > info.offset) ? info.pos - info.offset : 0);
1320}
1321
1322/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1323/**
1324 * mptscsih_proc_info - Return information about MPT adapter
Randy Dunlapd9489fb2006-12-06 20:38:43 -08001325 * @host: scsi host struct
1326 * @buffer: if write, user data; if read, buffer for user
1327 * @start: returns the buffer address
1328 * @offset: if write, 0; if read, the current offset into the buffer from
1329 * the previous read.
1330 * @length: if write, return length;
1331 * @func: write = 1; read = 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 *
1333 * (linux scsi_host_template.info routine)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001335int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1337 int length, int func)
1338{
Eric Mooree7eae9f2007-09-29 10:15:59 -06001339 MPT_SCSI_HOST *hd = shost_priv(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 MPT_ADAPTER *ioc = hd->ioc;
1341 int size = 0;
1342
1343 if (func) {
Christoph Hellwigc6678e02005-08-18 16:24:53 +02001344 /*
1345 * write is not supported
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 */
1347 } else {
1348 if (start)
1349 *start = buffer;
1350
1351 size = mptscsih_host_info(ioc, buffer, offset, length);
1352 }
1353
1354 return size;
1355}
1356
1357/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1358#define ADD_INDEX_LOG(req_ent) do { } while(0)
1359
1360/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1361/**
1362 * mptscsih_qcmd - Primary Fusion MPT SCSI initiator IO start routine.
1363 * @SCpnt: Pointer to scsi_cmnd structure
1364 * @done: Pointer SCSI mid-layer IO completion function
1365 *
1366 * (linux scsi_host_template.queuecommand routine)
1367 * This is the primary SCSI IO start routine. Create a MPI SCSIIORequest
1368 * from a linux scsi_cmnd request and send it to the IOC.
1369 *
1370 * Returns 0. (rtn value discarded by linux scsi mid-layer)
1371 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001372int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1374{
1375 MPT_SCSI_HOST *hd;
1376 MPT_FRAME_HDR *mf;
1377 SCSIIORequest_t *pScsiReq;
Eric Moorea69de502007-09-14 18:48:19 -06001378 VirtDevice *vdevice = SCpnt->device->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 u32 datalen;
1380 u32 scsictl;
1381 u32 scsidir;
1382 u32 cmd_len;
1383 int my_idx;
1384 int ii;
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301385 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
Eric Mooree7eae9f2007-09-29 10:15:59 -06001387 hd = shost_priv(SCpnt->device->host);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301388 ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 SCpnt->scsi_done = done;
1390
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301391 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p, done()=%p\n",
1392 ioc->name, SCpnt, done));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Kashyap, Desaie7deff32009-05-29 16:46:07 +05301394 if (ioc->taskmgmt_quiesce_io) {
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301395 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n",
1396 ioc->name, SCpnt));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 return SCSI_MLQUEUE_HOST_BUSY;
1398 }
1399
1400 /*
1401 * Put together a MPT SCSI request...
1402 */
Eric Mooree80b0022007-09-14 18:49:03 -06001403 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301404 dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
1405 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 return SCSI_MLQUEUE_HOST_BUSY;
1407 }
1408
1409 pScsiReq = (SCSIIORequest_t *) mf;
1410
1411 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1412
1413 ADD_INDEX_LOG(my_idx);
1414
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001415 /* TUR's being issued with scsictl=0x02000000 (DATA_IN)!
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 * Seems we may receive a buffer (datalen>0) even when there
1417 * will be no data transfer! GRRRRR...
1418 */
1419 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
FUJITA Tomonori1928d732007-05-26 00:37:15 +09001420 datalen = scsi_bufflen(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 scsidir = MPI_SCSIIO_CONTROL_READ; /* DATA IN (host<--ioc<--dev) */
1422 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
FUJITA Tomonori1928d732007-05-26 00:37:15 +09001423 datalen = scsi_bufflen(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 scsidir = MPI_SCSIIO_CONTROL_WRITE; /* DATA OUT (host-->ioc-->dev) */
1425 } else {
1426 datalen = 0;
1427 scsidir = MPI_SCSIIO_CONTROL_NODATATRANSFER;
1428 }
1429
1430 /* Default to untagged. Once a target structure has been allocated,
1431 * use the Inquiry data to determine if device supports tagged.
1432 */
Eric Moorea69de502007-09-14 18:48:19 -06001433 if (vdevice
1434 && (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 && (SCpnt->device->tagged_supported)) {
1436 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
Kashyap, Desai65f89c22009-12-16 19:01:13 +05301437 if (SCpnt->request && SCpnt->request->ioprio) {
1438 if (((SCpnt->request->ioprio & 0x7) == 1) ||
1439 !(SCpnt->request->ioprio & 0x7))
1440 scsictl |= MPI_SCSIIO_CONTROL_HEADOFQ;
1441 }
1442 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
Kashyap, Desai65f89c22009-12-16 19:01:13 +05301444
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
1446 /* Use the above information to set up the message frame
1447 */
Eric Moorea69de502007-09-14 18:48:19 -06001448 pScsiReq->TargetID = (u8) vdevice->vtarget->id;
1449 pScsiReq->Bus = vdevice->vtarget->channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 pScsiReq->ChainOffset = 0;
Eric Moorea69de502007-09-14 18:48:19 -06001451 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
James Bottomleyc92f2222006-03-01 09:02:49 -06001452 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
1453 else
1454 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 pScsiReq->CDBLength = SCpnt->cmd_len;
1456 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
1457 pScsiReq->Reserved = 0;
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301458 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
Eric Moore793955f2007-01-29 09:42:20 -07001459 int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 pScsiReq->Control = cpu_to_le32(scsictl);
1461
1462 /*
1463 * Write SCSI CDB into the message
1464 */
1465 cmd_len = SCpnt->cmd_len;
1466 for (ii=0; ii < cmd_len; ii++)
1467 pScsiReq->CDB[ii] = SCpnt->cmnd[ii];
1468
1469 for (ii=cmd_len; ii < 16; ii++)
1470 pScsiReq->CDB[ii] = 0;
1471
1472 /* DataLength */
1473 pScsiReq->DataLength = cpu_to_le32(datalen);
1474
1475 /* SenseBuffer low address */
Eric Mooree80b0022007-09-14 18:49:03 -06001476 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
1478
1479 /* Now add the SG list
1480 * Always have a SGE even if null length.
1481 */
1482 if (datalen == 0) {
1483 /* Add a NULL SGE */
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05301484 ioc->add_sge((char *)&pScsiReq->SGL,
1485 MPT_SGE_FLAGS_SSIMPLE_READ | 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 (dma_addr_t) -1);
1487 } else {
1488 /* Add a 32 or 64 bit SGE */
Eric Mooree80b0022007-09-14 18:49:03 -06001489 if (mptscsih_AddSGE(ioc, SCpnt, pScsiReq, my_idx) != SUCCESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 goto fail;
1491 }
1492
Eric Moore3dc0b032006-07-11 17:32:33 -06001493 SCpnt->host_scribble = (unsigned char *)mf;
Eric Mooree8206382007-09-29 10:16:53 -06001494 mptscsih_set_scsi_lookup(ioc, my_idx, SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
Eric Mooree80b0022007-09-14 18:49:03 -06001496 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301497 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issued SCSI cmd (%p) mf=%p idx=%d\n",
1498 ioc->name, SCpnt, mf, my_idx));
Eric Moore29dd3602007-09-14 18:46:51 -06001499 DBG_DUMP_REQUEST_FRAME(ioc, (u32 *)mf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 return 0;
1501
1502 fail:
Eric Mooree80b0022007-09-14 18:49:03 -06001503 mptscsih_freeChainBuffers(ioc, my_idx);
1504 mpt_free_msg_frame(ioc, mf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 return SCSI_MLQUEUE_HOST_BUSY;
1506}
1507
1508/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1509/*
1510 * mptscsih_freeChainBuffers - Function to free chain buffers associated
1511 * with a SCSI IO request
1512 * @hd: Pointer to the MPT_SCSI_HOST instance
1513 * @req_idx: Index of the SCSI IO request frame.
1514 *
1515 * Called if SG chain buffer allocation fails and mptscsih callbacks.
1516 * No return.
1517 */
1518static void
1519mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
1520{
1521 MPT_FRAME_HDR *chain;
1522 unsigned long flags;
1523 int chain_idx;
1524 int next;
1525
1526 /* Get the first chain index and reset
1527 * tracker state.
1528 */
1529 chain_idx = ioc->ReqToChain[req_idx];
1530 ioc->ReqToChain[req_idx] = MPT_HOST_NO_CHAIN;
1531
1532 while (chain_idx != MPT_HOST_NO_CHAIN) {
1533
1534 /* Save the next chain buffer index */
1535 next = ioc->ChainToChain[chain_idx];
1536
1537 /* Free this chain buffer and reset
1538 * tracker
1539 */
1540 ioc->ChainToChain[chain_idx] = MPT_HOST_NO_CHAIN;
1541
1542 chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer
1543 + (chain_idx * ioc->req_sz));
1544
1545 spin_lock_irqsave(&ioc->FreeQlock, flags);
1546 list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);
1547 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1548
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301549 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FreeChainBuffers (index %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 ioc->name, chain_idx));
1551
1552 /* handle next */
1553 chain_idx = next;
1554 }
1555 return;
1556}
1557
1558/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1559/*
1560 * Reset Handling
1561 */
1562
1563/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Eric Moorecd2c6192007-01-29 09:47:47 -07001564/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 * mptscsih_IssueTaskMgmt - Generic send Task Management function.
1566 * @hd: Pointer to MPT_SCSI_HOST structure
1567 * @type: Task Management type
Randy Dunlap1544d672007-02-20 11:17:03 -08001568 * @channel: channel number for task management
Eric Moore793955f2007-01-29 09:42:20 -07001569 * @id: Logical Target ID for reset (if appropriate)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 * @lun: Logical Unit for reset (if appropriate)
1571 * @ctx2abort: Context for the task to be aborted (if appropriate)
Randy Dunlap1544d672007-02-20 11:17:03 -08001572 * @timeout: timeout for task management control
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 *
1574 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
1575 * or a non-interrupt thread. In the former, must not call schedule().
1576 *
1577 * Not all fields are meaningfull for all task types.
1578 *
Eric Moorecd2c6192007-01-29 09:47:47 -07001579 * Returns 0 for SUCCESS, or FAILED.
1580 *
1581 **/
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301582int
1583mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun,
1584 int ctx2abort, ulong timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585{
1586 MPT_FRAME_HDR *mf;
1587 SCSITaskMgmt_t *pScsiTm;
1588 int ii;
1589 int retval;
Eric Mooree80b0022007-09-14 18:49:03 -06001590 MPT_ADAPTER *ioc = hd->ioc;
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301591 unsigned long timeleft;
1592 u8 issue_hard_reset;
1593 u32 ioc_raw_state;
1594 unsigned long time_count;
1595
1596 issue_hard_reset = 0;
1597 ioc_raw_state = mpt_GetIocState(ioc, 0);
1598
1599 if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
1600 printk(MYIOC_s_WARN_FMT
1601 "TaskMgmt type=%x: IOC Not operational (0x%x)!\n",
1602 ioc->name, type, ioc_raw_state);
1603 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
1604 ioc->name, __func__);
1605 if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
1606 printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset "
1607 "FAILED!!\n", ioc->name);
1608 return 0;
1609 }
1610
1611 if (ioc_raw_state & MPI_DOORBELL_ACTIVE) {
1612 printk(MYIOC_s_WARN_FMT
1613 "TaskMgmt type=%x: ioc_state: "
1614 "DOORBELL_ACTIVE (0x%x)!\n",
1615 ioc->name, type, ioc_raw_state);
1616 return FAILED;
1617 }
1618
1619 mutex_lock(&ioc->taskmgmt_cmds.mutex);
1620 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
1621 mf = NULL;
1622 retval = FAILED;
1623 goto out;
1624 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
1626 /* Return Fail to calling function if no message frames available.
1627 */
Eric Mooree80b0022007-09-14 18:49:03 -06001628 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301629 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1630 "TaskMgmt no msg frames!!\n", ioc->name));
1631 retval = FAILED;
1632 mpt_clear_taskmgmt_in_progress_flag(ioc);
1633 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 }
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301635 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
Eric Mooree80b0022007-09-14 18:49:03 -06001636 ioc->name, mf));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
1638 /* Format the Request
1639 */
1640 pScsiTm = (SCSITaskMgmt_t *) mf;
Eric Moore793955f2007-01-29 09:42:20 -07001641 pScsiTm->TargetID = id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 pScsiTm->Bus = channel;
1643 pScsiTm->ChainOffset = 0;
1644 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1645
1646 pScsiTm->Reserved = 0;
1647 pScsiTm->TaskType = type;
1648 pScsiTm->Reserved1 = 0;
1649 pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
1650 ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
1651
Eric Moore793955f2007-01-29 09:42:20 -07001652 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654 for (ii=0; ii < 7; ii++)
1655 pScsiTm->Reserved2[ii] = 0;
1656
1657 pScsiTm->TaskMsgContext = ctx2abort;
1658
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301659 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) "
1660 "task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort,
1661 type, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05301663 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301665 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1666 time_count = jiffies;
Eric Mooree80b0022007-09-14 18:49:03 -06001667 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
1668 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
1669 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
Prakash, Sathya7a195f42007-08-14 16:08:40 +05301670 else {
Eric Mooree80b0022007-09-14 18:49:03 -06001671 retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
Prakash, Sathya7a195f42007-08-14 16:08:40 +05301672 sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
1673 if (retval) {
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301674 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1675 "TaskMgmt handshake FAILED!(mf=%p, rc=%d) \n",
1676 ioc->name, mf, retval));
1677 mpt_free_msg_frame(ioc, mf);
1678 mpt_clear_taskmgmt_in_progress_flag(ioc);
1679 goto out;
Prakash, Sathya7a195f42007-08-14 16:08:40 +05301680 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 }
1682
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301683 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
1684 timeout*HZ);
1685 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
1686 retval = FAILED;
1687 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
1688 "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf));
1689 mpt_clear_taskmgmt_in_progress_flag(ioc);
1690 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
1691 goto out;
1692 issue_hard_reset = 1;
1693 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 }
1695
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301696 retval = mptscsih_taskmgmt_reply(ioc, type,
1697 (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply);
Eric Moorecd2c6192007-01-29 09:47:47 -07001698
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301699 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1700 "TaskMgmt completed (%d seconds)\n",
1701 ioc->name, jiffies_to_msecs(jiffies - time_count)/1000));
1702
1703 out:
1704
1705 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
1706 if (issue_hard_reset) {
1707 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
1708 ioc->name, __func__);
Kashyap, Desaid0f698c2010-03-18 19:12:17 +05301709 retval = mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301710 mpt_free_msg_frame(ioc, mf);
1711 }
1712
1713 retval = (retval == 0) ? 0 : FAILED;
1714 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 return retval;
1716}
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301717EXPORT_SYMBOL(mptscsih_IssueTaskMgmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
Christoph Hellwigd66c7a02006-01-17 13:43:14 +00001719static int
1720mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
1721{
1722 switch (ioc->bus_type) {
1723 case FC:
1724 return 40;
1725 case SAS:
Christoph Hellwigd66c7a02006-01-17 13:43:14 +00001726 case SPI:
1727 default:
Bernd Schubert22ab0192008-09-23 15:28:58 +02001728 return 10;
Christoph Hellwigd66c7a02006-01-17 13:43:14 +00001729 }
1730}
1731
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1733/**
1734 * mptscsih_abort - Abort linux scsi_cmnd routine, new_eh variant
1735 * @SCpnt: Pointer to scsi_cmnd structure, IO to be aborted
1736 *
1737 * (linux scsi_host_template.eh_abort_handler routine)
1738 *
1739 * Returns SUCCESS or FAILED.
Eric Moorecd2c6192007-01-29 09:47:47 -07001740 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001741int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742mptscsih_abort(struct scsi_cmnd * SCpnt)
1743{
1744 MPT_SCSI_HOST *hd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 MPT_FRAME_HDR *mf;
1746 u32 ctx2abort;
1747 int scpnt_idx;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001748 int retval;
Eric Moore958d4a32007-06-15 17:24:14 -06001749 VirtDevice *vdevice;
Eric Moore3dc0b032006-07-11 17:32:33 -06001750 ulong sn = SCpnt->serial_number;
Eric Moore958d4a32007-06-15 17:24:14 -06001751 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
1753 /* If we can't locate our host adapter structure, return FAILED status.
1754 */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001755 if ((hd = shost_priv(SCpnt->device->host)) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 SCpnt->result = DID_RESET << 16;
1757 SCpnt->scsi_done(SCpnt);
Eric Moore29dd3602007-09-14 18:46:51 -06001758 printk(KERN_ERR MYNAM ": task abort: "
1759 "can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 return FAILED;
1761 }
1762
Eric Moore958d4a32007-06-15 17:24:14 -06001763 ioc = hd->ioc;
1764 printk(MYIOC_s_INFO_FMT "attempting task abort! (sc=%p)\n",
1765 ioc->name, SCpnt);
1766 scsi_print_command(SCpnt);
1767
1768 vdevice = SCpnt->device->hostdata;
1769 if (!vdevice || !vdevice->vtarget) {
Eric Moore29dd3602007-09-14 18:46:51 -06001770 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1771 "task abort: device has been deleted (sc=%p)\n",
1772 ioc->name, SCpnt));
Eric Moore958d4a32007-06-15 17:24:14 -06001773 SCpnt->result = DID_NO_CONNECT << 16;
1774 SCpnt->scsi_done(SCpnt);
1775 retval = 0;
1776 goto out;
1777 }
1778
Eric Moorecc78d302007-06-15 17:27:21 -06001779 /* Task aborts are not supported for hidden raid components.
1780 */
1781 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
Eric Moore29dd3602007-09-14 18:46:51 -06001782 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1783 "task abort: hidden raid component (sc=%p)\n",
1784 ioc->name, SCpnt));
Eric Moorecc78d302007-06-15 17:27:21 -06001785 SCpnt->result = DID_RESET << 16;
1786 retval = FAILED;
1787 goto out;
1788 }
1789
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 /* Find this command
1791 */
Eric Mooree8206382007-09-29 10:16:53 -06001792 if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001793 /* Cmd not found in ScsiLookup.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 * Do OS callback.
1795 */
1796 SCpnt->result = DID_RESET << 16;
Eric Moore29dd3602007-09-14 18:46:51 -06001797 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
Eric Moore958d4a32007-06-15 17:24:14 -06001798 "Command not in the active list! (sc=%p)\n", ioc->name,
1799 SCpnt));
Kashyap, Desai9858ae32010-01-25 16:20:52 +05301800 retval = SUCCESS;
Eric Moore958d4a32007-06-15 17:24:14 -06001801 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 }
1803
Kashyap, Desai2f187862009-05-29 16:52:37 +05301804 if (ioc->timeouts < -1)
1805 ioc->timeouts++;
Moore, Eric65207fe2006-04-21 16:14:35 -06001806
Kashyap, Desai2f4c7822009-01-06 15:03:37 +05301807 if (mpt_fwfault_debug)
1808 mpt_halt_firmware(ioc);
1809
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 /* Most important! Set TaskMsgContext to SCpnt's MsgContext!
1811 * (the IO to be ABORT'd)
1812 *
1813 * NOTE: Since we do not byteswap MsgContext, we do not
1814 * swap it here either. It is an opaque cookie to
1815 * the controller, so it does not matter. -DaveM
1816 */
Eric Mooree80b0022007-09-14 18:49:03 -06001817 mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301819 retval = mptscsih_IssueTaskMgmt(hd,
1820 MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
1821 vdevice->vtarget->channel,
1822 vdevice->vtarget->id, vdevice->lun,
1823 ctx2abort, mptscsih_get_tm_timeout(ioc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824
Eric Mooree8206382007-09-29 10:16:53 -06001825 if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx &&
Kashyap, Desai2f187862009-05-29 16:52:37 +05301826 SCpnt->serial_number == sn) {
1827 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1828 "task abort: command still in active list! (sc=%p)\n",
1829 ioc->name, SCpnt));
Eric Moore3dc0b032006-07-11 17:32:33 -06001830 retval = FAILED;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301831 } else {
1832 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1833 "task abort: command cleared from active list! (sc=%p)\n",
1834 ioc->name, SCpnt));
1835 retval = SUCCESS;
1836 }
Eric Moore3dc0b032006-07-11 17:32:33 -06001837
Eric Moore958d4a32007-06-15 17:24:14 -06001838 out:
1839 printk(MYIOC_s_INFO_FMT "task abort: %s (sc=%p)\n",
Kashyap, Desai2f187862009-05-29 16:52:37 +05301840 ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841
Kashyap, Desai2f187862009-05-29 16:52:37 +05301842 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843}
1844
1845/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1846/**
1847 * mptscsih_dev_reset - Perform a SCSI TARGET_RESET! new_eh variant
1848 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1849 *
1850 * (linux scsi_host_template.eh_dev_reset_handler routine)
1851 *
1852 * Returns SUCCESS or FAILED.
Eric Moorecd2c6192007-01-29 09:47:47 -07001853 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001854int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855mptscsih_dev_reset(struct scsi_cmnd * SCpnt)
1856{
1857 MPT_SCSI_HOST *hd;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001858 int retval;
Eric Moore958d4a32007-06-15 17:24:14 -06001859 VirtDevice *vdevice;
1860 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862 /* If we can't locate our host adapter structure, return FAILED status.
1863 */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001864 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
Eric Moore29dd3602007-09-14 18:46:51 -06001865 printk(KERN_ERR MYNAM ": target reset: "
1866 "Can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 return FAILED;
1868 }
1869
Eric Moore958d4a32007-06-15 17:24:14 -06001870 ioc = hd->ioc;
1871 printk(MYIOC_s_INFO_FMT "attempting target reset! (sc=%p)\n",
1872 ioc->name, SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001873 scsi_print_command(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874
Eric Moore958d4a32007-06-15 17:24:14 -06001875 vdevice = SCpnt->device->hostdata;
1876 if (!vdevice || !vdevice->vtarget) {
Kashyap, Desai2f187862009-05-29 16:52:37 +05301877 retval = SUCCESS;
Eric Moore958d4a32007-06-15 17:24:14 -06001878 goto out;
1879 }
1880
Eric Moorecc78d302007-06-15 17:27:21 -06001881 /* Target reset to hidden raid component is not supported
1882 */
1883 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
1884 retval = FAILED;
1885 goto out;
1886 }
1887
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301888 retval = mptscsih_IssueTaskMgmt(hd,
1889 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
1890 vdevice->vtarget->channel,
1891 vdevice->vtarget->id, 0, 0,
1892 mptscsih_get_tm_timeout(ioc));
Eric Moore958d4a32007-06-15 17:24:14 -06001893
1894 out:
1895 printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
1896 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001897
1898 if (retval == 0)
1899 return SUCCESS;
Eric Moorecd2c6192007-01-29 09:47:47 -07001900 else
1901 return FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902}
1903
Eric Moorecd2c6192007-01-29 09:47:47 -07001904
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1906/**
1907 * mptscsih_bus_reset - Perform a SCSI BUS_RESET! new_eh variant
1908 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1909 *
1910 * (linux scsi_host_template.eh_bus_reset_handler routine)
1911 *
1912 * Returns SUCCESS or FAILED.
Eric Moorecd2c6192007-01-29 09:47:47 -07001913 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001914int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915mptscsih_bus_reset(struct scsi_cmnd * SCpnt)
1916{
1917 MPT_SCSI_HOST *hd;
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001918 int retval;
Eric Moorea69de502007-09-14 18:48:19 -06001919 VirtDevice *vdevice;
Eric Moore958d4a32007-06-15 17:24:14 -06001920 MPT_ADAPTER *ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
1922 /* If we can't locate our host adapter structure, return FAILED status.
1923 */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001924 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
Eric Moore29dd3602007-09-14 18:46:51 -06001925 printk(KERN_ERR MYNAM ": bus reset: "
1926 "Can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 return FAILED;
1928 }
1929
Eric Moore958d4a32007-06-15 17:24:14 -06001930 ioc = hd->ioc;
1931 printk(MYIOC_s_INFO_FMT "attempting bus reset! (sc=%p)\n",
1932 ioc->name, SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001933 scsi_print_command(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934
Kashyap, Desai2f187862009-05-29 16:52:37 +05301935 if (ioc->timeouts < -1)
1936 ioc->timeouts++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
Eric Moorea69de502007-09-14 18:48:19 -06001938 vdevice = SCpnt->device->hostdata;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301939 if (!vdevice || !vdevice->vtarget)
1940 return SUCCESS;
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05301941 retval = mptscsih_IssueTaskMgmt(hd,
1942 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1943 vdevice->vtarget->channel, 0, 0, 0,
1944 mptscsih_get_tm_timeout(ioc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945
Eric Moore958d4a32007-06-15 17:24:14 -06001946 printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
1947 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001948
1949 if (retval == 0)
1950 return SUCCESS;
Eric Moorecd2c6192007-01-29 09:47:47 -07001951 else
1952 return FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953}
1954
1955/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1956/**
Randy Dunlapd9489fb2006-12-06 20:38:43 -08001957 * mptscsih_host_reset - Perform a SCSI host adapter RESET (new_eh variant)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 * @SCpnt: Pointer to scsi_cmnd structure, IO which reset is due to
1959 *
1960 * (linux scsi_host_template.eh_host_reset_handler routine)
1961 *
1962 * Returns SUCCESS or FAILED.
1963 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04001964int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965mptscsih_host_reset(struct scsi_cmnd *SCpnt)
1966{
1967 MPT_SCSI_HOST * hd;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301968 int status = SUCCESS;
Eric Moore958d4a32007-06-15 17:24:14 -06001969 MPT_ADAPTER *ioc;
Kashyap, Desai2f187862009-05-29 16:52:37 +05301970 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971
1972 /* If we can't locate the host to reset, then we failed. */
Eric Mooree7eae9f2007-09-29 10:15:59 -06001973 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
Eric Moore29dd3602007-09-14 18:46:51 -06001974 printk(KERN_ERR MYNAM ": host reset: "
1975 "Can't locate host! (sc=%p)\n", SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 return FAILED;
1977 }
1978
James Bottomleya6da74c2008-12-15 14:13:27 -06001979 /* make sure we have no outstanding commands at this stage */
1980 mptscsih_flush_running_cmds(hd);
1981
Eric Moore958d4a32007-06-15 17:24:14 -06001982 ioc = hd->ioc;
1983 printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
1984 ioc->name, SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985
1986 /* If our attempts to reset the host failed, then return a failed
1987 * status. The host will be taken off line by the SCSI mid-layer.
1988 */
Kashyap, Desaid0f698c2010-03-18 19:12:17 +05301989 retval = mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
Kashyap, Desai2f187862009-05-29 16:52:37 +05301990 if (retval < 0)
1991 status = FAILED;
1992 else
1993 status = SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994
Eric Moore958d4a32007-06-15 17:24:14 -06001995 printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
1996 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997
Kashyap, Desai2f187862009-05-29 16:52:37 +05301998 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999}
2000
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001static int
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302002mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type,
2003 SCSITaskMgmtReply_t *pScsiTmReply)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004{
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302005 u16 iocstatus;
2006 u32 termination_count;
2007 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302009 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
2010 retval = FAILED;
2011 goto out;
2012 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302014 DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302016 iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2017 termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302019 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2020 "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
2021 "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
2022 "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
2023 pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
2024 le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
2025 termination_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302027 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
2028 pScsiTmReply->ResponseCode)
2029 mptscsih_taskmgmt_response_code(ioc,
2030 pScsiTmReply->ResponseCode);
2031
2032 if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
2033 retval = 0;
2034 goto out;
2035 }
2036
2037 retval = FAILED;
2038 if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
2039 if (termination_count == 1)
2040 retval = 0;
2041 goto out;
2042 }
2043
2044 if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
2045 iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
2046 retval = 0;
2047
2048 out:
2049 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050}
2051
2052/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Kashyap, Desaie7deff32009-05-29 16:46:07 +05302053void
Moore, Eric9f63bb72006-01-16 18:53:26 -07002054mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
2055{
2056 char *desc;
2057
2058 switch (response_code) {
2059 case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
2060 desc = "The task completed.";
2061 break;
2062 case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
2063 desc = "The IOC received an invalid frame status.";
2064 break;
2065 case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
2066 desc = "The task type is not supported.";
2067 break;
2068 case MPI_SCSITASKMGMT_RSP_TM_FAILED:
2069 desc = "The requested task failed.";
2070 break;
2071 case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
2072 desc = "The task completed successfully.";
2073 break;
2074 case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
2075 desc = "The LUN request is invalid.";
2076 break;
2077 case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
2078 desc = "The task is in the IOC queue and has not been sent to target.";
2079 break;
2080 default:
2081 desc = "unknown";
2082 break;
2083 }
2084 printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
2085 ioc->name, response_code, desc);
2086}
Kashyap, Desaie7deff32009-05-29 16:46:07 +05302087EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
Moore, Eric9f63bb72006-01-16 18:53:26 -07002088
2089/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090/**
2091 * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
2092 * @ioc: Pointer to MPT_ADAPTER structure
2093 * @mf: Pointer to SCSI task mgmt request frame
2094 * @mr: Pointer to SCSI task mgmt reply frame
2095 *
2096 * This routine is called from mptbase.c::mpt_interrupt() at the completion
2097 * of any SCSI task management request.
2098 * This routine is registered with the MPT (base) driver at driver
2099 * load/init time via the mpt_register() API call.
2100 *
2101 * Returns 1 indicating alloc'd request frame ptr should be freed.
Eric Moorecd2c6192007-01-29 09:47:47 -07002102 **/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002103int
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302104mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
2105 MPT_FRAME_HDR *mr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106{
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302107 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2108 "TaskMgmt completed (mf=%p, mr=%p)\n", ioc->name, mf, mr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302110 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302112 if (!mr)
Eric Moorecd2c6192007-01-29 09:47:47 -07002113 goto out;
Eric Moorecd2c6192007-01-29 09:47:47 -07002114
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302115 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2116 memcpy(ioc->taskmgmt_cmds.reply, mr,
2117 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
Eric Moorecd2c6192007-01-29 09:47:47 -07002118 out:
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302119 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
2120 mpt_clear_taskmgmt_in_progress_flag(ioc);
2121 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2122 complete(&ioc->taskmgmt_cmds.done);
2123 return 1;
2124 }
2125 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126}
2127
2128/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2129/*
2130 * This is anyones guess quite frankly.
2131 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002132int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2134 sector_t capacity, int geom[])
2135{
2136 int heads;
2137 int sectors;
2138 sector_t cylinders;
2139 ulong dummy;
2140
2141 heads = 64;
2142 sectors = 32;
2143
2144 dummy = heads * sectors;
2145 cylinders = capacity;
2146 sector_div(cylinders,dummy);
2147
2148 /*
2149 * Handle extended translation size for logical drives
2150 * > 1Gb
2151 */
2152 if ((ulong)capacity >= 0x200000) {
2153 heads = 255;
2154 sectors = 63;
2155 dummy = heads * sectors;
2156 cylinders = capacity;
2157 sector_div(cylinders,dummy);
2158 }
2159
2160 /* return result */
2161 geom[0] = heads;
2162 geom[1] = sectors;
2163 geom[2] = cylinders;
2164
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 return 0;
2166}
2167
Moore, Ericf44e5462006-03-14 09:14:21 -07002168/* Search IOC page 3 to determine if this is hidden physical disk
2169 *
2170 */
2171int
Eric Moore793955f2007-01-29 09:42:20 -07002172mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
Moore, Ericf44e5462006-03-14 09:14:21 -07002173{
Eric Mooreb506ade2007-01-29 09:45:37 -07002174 struct inactive_raid_component_info *component_info;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302175 int i, j;
2176 RaidPhysDiskPage1_t *phys_disk;
Eric Moore793955f2007-01-29 09:42:20 -07002177 int rc = 0;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302178 int num_paths;
Moore, Ericf44e5462006-03-14 09:14:21 -07002179
Eric Moore793955f2007-01-29 09:42:20 -07002180 if (!ioc->raid_data.pIocPg3)
2181 goto out;
Moore, Ericf44e5462006-03-14 09:14:21 -07002182 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
Eric Moore793955f2007-01-29 09:42:20 -07002183 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2184 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2185 rc = 1;
2186 goto out;
2187 }
2188 }
2189
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302190 if (ioc->bus_type != SAS)
2191 goto out;
2192
2193 /*
2194 * Check if dual path
2195 */
2196 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2197 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2198 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2199 if (num_paths < 2)
2200 continue;
2201 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2202 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2203 if (!phys_disk)
2204 continue;
2205 if ((mpt_raid_phys_disk_pg1(ioc,
2206 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2207 phys_disk))) {
2208 kfree(phys_disk);
2209 continue;
2210 }
2211 for (j = 0; j < num_paths; j++) {
2212 if ((phys_disk->Path[j].Flags &
2213 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2214 continue;
2215 if ((phys_disk->Path[j].Flags &
2216 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2217 continue;
2218 if ((id == phys_disk->Path[j].PhysDiskID) &&
2219 (channel == phys_disk->Path[j].PhysDiskBus)) {
2220 rc = 1;
2221 kfree(phys_disk);
2222 goto out;
2223 }
2224 }
2225 kfree(phys_disk);
2226 }
2227
2228
Eric Mooreb506ade2007-01-29 09:45:37 -07002229 /*
2230 * Check inactive list for matching phys disks
2231 */
2232 if (list_empty(&ioc->raid_data.inactive_list))
2233 goto out;
2234
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002235 mutex_lock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002236 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2237 list) {
2238 if ((component_info->d.PhysDiskID == id) &&
2239 (component_info->d.PhysDiskBus == channel))
2240 rc = 1;
2241 }
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002242 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002243
Eric Moore793955f2007-01-29 09:42:20 -07002244 out:
2245 return rc;
Moore, Ericf44e5462006-03-14 09:14:21 -07002246}
2247EXPORT_SYMBOL(mptscsih_is_phys_disk);
2248
Eric Moore793955f2007-01-29 09:42:20 -07002249u8
2250mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
James Bottomleyc92f2222006-03-01 09:02:49 -06002251{
Eric Mooreb506ade2007-01-29 09:45:37 -07002252 struct inactive_raid_component_info *component_info;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302253 int i, j;
2254 RaidPhysDiskPage1_t *phys_disk;
Eric Moore793955f2007-01-29 09:42:20 -07002255 int rc = -ENXIO;
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302256 int num_paths;
James Bottomleyc92f2222006-03-01 09:02:49 -06002257
Eric Moore793955f2007-01-29 09:42:20 -07002258 if (!ioc->raid_data.pIocPg3)
2259 goto out;
2260 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2261 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
2262 (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
2263 rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
2264 goto out;
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002265 }
2266 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267
Kashyap, Desaia7938b02009-05-29 16:53:56 +05302268 if (ioc->bus_type != SAS)
2269 goto out;
2270
2271 /*
2272 * Check if dual path
2273 */
2274 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
2275 num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
2276 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
2277 if (num_paths < 2)
2278 continue;
2279 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
2280 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
2281 if (!phys_disk)
2282 continue;
2283 if ((mpt_raid_phys_disk_pg1(ioc,
2284 ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
2285 phys_disk))) {
2286 kfree(phys_disk);
2287 continue;
2288 }
2289 for (j = 0; j < num_paths; j++) {
2290 if ((phys_disk->Path[j].Flags &
2291 MPI_RAID_PHYSDISK1_FLAG_INVALID))
2292 continue;
2293 if ((phys_disk->Path[j].Flags &
2294 MPI_RAID_PHYSDISK1_FLAG_BROKEN))
2295 continue;
2296 if ((id == phys_disk->Path[j].PhysDiskID) &&
2297 (channel == phys_disk->Path[j].PhysDiskBus)) {
2298 rc = phys_disk->PhysDiskNum;
2299 kfree(phys_disk);
2300 goto out;
2301 }
2302 }
2303 kfree(phys_disk);
2304 }
2305
Eric Mooreb506ade2007-01-29 09:45:37 -07002306 /*
2307 * Check inactive list for matching phys disks
2308 */
2309 if (list_empty(&ioc->raid_data.inactive_list))
2310 goto out;
2311
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002312 mutex_lock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002313 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
2314 list) {
2315 if ((component_info->d.PhysDiskID == id) &&
2316 (component_info->d.PhysDiskBus == channel))
2317 rc = component_info->d.PhysDiskNum;
2318 }
Matthias Kaehlckeed5f6062008-03-09 12:16:27 +01002319 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
Eric Mooreb506ade2007-01-29 09:45:37 -07002320
Eric Moore793955f2007-01-29 09:42:20 -07002321 out:
2322 return rc;
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002323}
Eric Moore793955f2007-01-29 09:42:20 -07002324EXPORT_SYMBOL(mptscsih_raid_id_to_num);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002325
2326/*
2327 * OS entry point to allow for host driver to free allocated memory
2328 * Called if no device present or device being unloaded
2329 */
2330void
2331mptscsih_slave_destroy(struct scsi_device *sdev)
2332{
2333 struct Scsi_Host *host = sdev->host;
Eric Mooree7eae9f2007-09-29 10:15:59 -06002334 MPT_SCSI_HOST *hd = shost_priv(host);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002335 VirtTarget *vtarget;
2336 VirtDevice *vdevice;
2337 struct scsi_target *starget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002339 starget = scsi_target(sdev);
2340 vtarget = starget->hostdata;
2341 vdevice = sdev->hostdata;
Kashyap, Desai08f5c5c2010-03-18 19:22:45 +05302342 if (!vdevice)
2343 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002345 mptscsih_search_running_cmds(hd, vdevice);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002346 vtarget->num_luns--;
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002347 mptscsih_synchronize_cache(hd, vdevice);
2348 kfree(vdevice);
2349 sdev->hostdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350}
2351
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06002352/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2353/*
2354 * mptscsih_change_queue_depth - This function will set a devices queue depth
2355 * @sdev: per scsi_device pointer
2356 * @qdepth: requested queue depth
Mike Christiee881a172009-10-15 17:46:39 -07002357 * @reason: calling context
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06002358 *
2359 * Adding support for new 'change_queue_depth' api.
2360*/
2361int
Mike Christiee881a172009-10-15 17:46:39 -07002362mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363{
Eric Mooree7eae9f2007-09-29 10:15:59 -06002364 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002365 VirtTarget *vtarget;
2366 struct scsi_target *starget;
2367 int max_depth;
2368 int tagged;
Eric Mooree80b0022007-09-14 18:49:03 -06002369 MPT_ADAPTER *ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002371 starget = scsi_target(sdev);
2372 vtarget = starget->hostdata;
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06002373
Mike Christiee881a172009-10-15 17:46:39 -07002374 if (reason != SCSI_QDEPTH_DEFAULT)
2375 return -EOPNOTSUPP;
2376
Eric Mooree80b0022007-09-14 18:49:03 -06002377 if (ioc->bus_type == SPI) {
James Bottomleyc92f2222006-03-01 09:02:49 -06002378 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379 max_depth = 1;
James Bottomleyc92f2222006-03-01 09:02:49 -06002380 else if (sdev->type == TYPE_DISK &&
2381 vtarget->minSyncFactor <= MPT_ULTRA160)
2382 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
2383 else
2384 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 } else
Kashyap, Desai79a3ec12009-08-05 12:52:58 +05302386 max_depth = ioc->sh->can_queue;
2387
2388 if (!sdev->tagged_supported)
2389 max_depth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
2391 if (qdepth > max_depth)
2392 qdepth = max_depth;
2393 if (qdepth == 1)
2394 tagged = 0;
2395 else
2396 tagged = MSG_SIMPLE_TAG;
2397
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06002398 scsi_adjust_queue_depth(sdev, tagged, qdepth);
2399 return sdev->queue_depth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400}
2401
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402/*
2403 * OS entry point to adjust the queue_depths on a per-device basis.
2404 * Called once per device the bus scan. Use it to force the queue_depth
2405 * member to 1 if a device does not support Q tags.
2406 * Return non-zero if fails.
2407 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002408int
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002409mptscsih_slave_configure(struct scsi_device *sdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410{
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002411 struct Scsi_Host *sh = sdev->host;
2412 VirtTarget *vtarget;
2413 VirtDevice *vdevice;
2414 struct scsi_target *starget;
Eric Mooree7eae9f2007-09-29 10:15:59 -06002415 MPT_SCSI_HOST *hd = shost_priv(sh);
Eric Mooree80b0022007-09-14 18:49:03 -06002416 MPT_ADAPTER *ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002418 starget = scsi_target(sdev);
2419 vtarget = starget->hostdata;
2420 vdevice = sdev->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421
Eric Mooree80b0022007-09-14 18:49:03 -06002422 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Eric Moore793955f2007-01-29 09:42:20 -07002423 "device @ %p, channel=%d, id=%d, lun=%d\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002424 ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
2425 if (ioc->bus_type == SPI)
2426 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002427 "sdtr %d wdtr %d ppr %d inq length=%d\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002428 ioc->name, sdev->sdtr, sdev->wdtr,
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002429 sdev->ppr, sdev->inquiry_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430
Eric Moore793955f2007-01-29 09:42:20 -07002431 vdevice->configured_lun = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432
Eric Mooree80b0022007-09-14 18:49:03 -06002433 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 "Queue depth=%d, tflags=%x\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002435 ioc->name, sdev->queue_depth, vtarget->tflags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
Eric Mooree80b0022007-09-14 18:49:03 -06002437 if (ioc->bus_type == SPI)
2438 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002439 "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002440 ioc->name, vtarget->negoFlags, vtarget->maxOffset,
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002441 vtarget->minSyncFactor));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442
Mike Christiee881a172009-10-15 17:46:39 -07002443 mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH,
2444 SCSI_QDEPTH_DEFAULT);
Eric Mooree80b0022007-09-14 18:49:03 -06002445 dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 "tagged %d, simple %d, ordered %d\n",
Eric Mooree80b0022007-09-14 18:49:03 -06002447 ioc->name,sdev->tagged_supported, sdev->simple_tags,
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07002448 sdev->ordered_tags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449
2450 return 0;
2451}
2452
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2454/*
2455 * Private routines...
2456 */
2457
2458/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2459/* Utility function to copy sense data from the scsi_cmnd buffer
2460 * to the FC and SCSI target structures.
2461 *
2462 */
2463static void
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002464mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465{
Eric Moorea69de502007-09-14 18:48:19 -06002466 VirtDevice *vdevice;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 SCSIIORequest_t *pReq;
2468 u32 sense_count = le32_to_cpu(pScsiReply->SenseCount);
Eric Mooree80b0022007-09-14 18:49:03 -06002469 MPT_ADAPTER *ioc = hd->ioc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470
2471 /* Get target structure
2472 */
2473 pReq = (SCSIIORequest_t *) mf;
Eric Moorea69de502007-09-14 18:48:19 -06002474 vdevice = sc->device->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475
2476 if (sense_count) {
2477 u8 *sense_data;
2478 int req_index;
2479
2480 /* Copy the sense received into the scsi command block. */
2481 req_index = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
Eric Mooree80b0022007-09-14 18:49:03 -06002482 sense_data = ((u8 *)ioc->sense_buf_pool + (req_index * MPT_SENSE_BUFFER_ALLOC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 memcpy(sc->sense_buffer, sense_data, SNS_LEN(sc));
2484
2485 /* Log SMART data (asc = 0x5D, non-IM case only) if required.
2486 */
Eric Mooree80b0022007-09-14 18:49:03 -06002487 if ((ioc->events) && (ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) {
Eric Moorea69de502007-09-14 18:48:19 -06002488 if ((sense_data[12] == 0x5D) && (vdevice->vtarget->raidVolume == 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490
Moore, Eric5b5ef4f2006-02-02 17:19:40 -07002491 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492 ioc->events[idx].event = MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE;
2493 ioc->events[idx].eventContext = ioc->eventContext;
2494
Dave Jones3d9780b2007-05-21 20:59:47 -04002495 ioc->events[idx].data[0] = (pReq->LUN[1] << 24) |
2496 (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) |
2497 (sc->device->channel << 8) | sc->device->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498
Dave Jones3d9780b2007-05-21 20:59:47 -04002499 ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500
2501 ioc->eventContext++;
Eric Mooree80b0022007-09-14 18:49:03 -06002502 if (ioc->pcidev->vendor ==
Eric Moore786899b2006-07-11 17:22:22 -06002503 PCI_VENDOR_ID_IBM) {
Eric Mooree80b0022007-09-14 18:49:03 -06002504 mptscsih_issue_sep_command(ioc,
Eric Moorea69de502007-09-14 18:48:19 -06002505 vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
2506 vdevice->vtarget->tflags |=
Eric Moore786899b2006-07-11 17:22:22 -06002507 MPT_TARGET_FLAGS_LED_ON;
2508 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 }
2510 }
2511 } else {
Eric Mooree80b0022007-09-14 18:49:03 -06002512 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
2513 ioc->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514 }
2515}
2516
Kashyap, Desaidb7051b2009-05-29 16:56:59 +05302517/**
2518 * mptscsih_get_scsi_lookup - retrieves scmd entry
2519 * @ioc: Pointer to MPT_ADAPTER structure
2520 * @i: index into the array
2521 *
2522 * Returns the scsi_cmd pointer
2523 */
2524struct scsi_cmnd *
2525mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
2526{
2527 unsigned long flags;
2528 struct scsi_cmnd *scmd;
2529
2530 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2531 scmd = ioc->ScsiLookup[i];
2532 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2533
2534 return scmd;
2535}
2536EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
Eric Mooree8206382007-09-29 10:16:53 -06002537
2538/**
James Bottomleyfc847ab2009-06-09 23:01:01 +00002539 * mptscsih_getclear_scsi_lookup - retrieves and clears scmd entry from ScsiLookup[] array list
Kashyap, Desai2f187862009-05-29 16:52:37 +05302540 * @ioc: Pointer to MPT_ADAPTER structure
2541 * @i: index into the array
2542 *
Randy Dunlap7105a382008-02-29 22:03:27 -08002543 * Returns the scsi_cmd pointer
Kashyap, Desai2f187862009-05-29 16:52:37 +05302544 *
Eric Mooree8206382007-09-29 10:16:53 -06002545 **/
2546static struct scsi_cmnd *
2547mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
2548{
2549 unsigned long flags;
2550 struct scsi_cmnd *scmd;
2551
2552 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2553 scmd = ioc->ScsiLookup[i];
2554 ioc->ScsiLookup[i] = NULL;
2555 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2556
2557 return scmd;
2558}
2559
2560/**
2561 * mptscsih_set_scsi_lookup
2562 *
2563 * writes a scmd entry into the ScsiLookup[] array list
2564 *
2565 * @ioc: Pointer to MPT_ADAPTER structure
2566 * @i: index into the array
2567 * @scmd: scsi_cmnd pointer
2568 *
2569 **/
2570static void
2571mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd)
2572{
2573 unsigned long flags;
2574
2575 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2576 ioc->ScsiLookup[i] = scmd;
2577 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2578}
2579
2580/**
Randy Dunlap23f9b752007-10-15 17:29:33 -07002581 * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
Eric Mooree8206382007-09-29 10:16:53 -06002582 * @ioc: Pointer to MPT_ADAPTER structure
Randy Dunlap23f9b752007-10-15 17:29:33 -07002583 * @sc: scsi_cmnd pointer
2584 */
Eric Mooree8206382007-09-29 10:16:53 -06002585static int
2586SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
2587{
2588 unsigned long flags;
2589 int i, index=-1;
2590
2591 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
2592 for (i = 0; i < ioc->req_depth; i++) {
2593 if (ioc->ScsiLookup[i] == sc) {
2594 index = i;
2595 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 }
2597 }
2598
Eric Mooree8206382007-09-29 10:16:53 -06002599 out:
2600 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
2601 return index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602}
2603
2604/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002605int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
2607{
2608 MPT_SCSI_HOST *hd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609
Eric Mooree7eae9f2007-09-29 10:15:59 -06002610 if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302613 hd = shost_priv(ioc->sh);
2614 switch (reset_phase) {
2615 case MPT_IOC_SETUP_RESET:
2616 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2617 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302618 break;
2619 case MPT_IOC_PRE_RESET:
2620 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2621 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302622 mptscsih_flush_running_cmds(hd);
2623 break;
2624 case MPT_IOC_POST_RESET:
2625 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2626 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
2627 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
2628 ioc->internal_cmds.status |=
2629 MPT_MGMT_STATUS_DID_IOCRESET;
2630 complete(&ioc->internal_cmds.done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 }
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302632 break;
2633 default:
2634 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 return 1; /* currently means nothing really */
2637}
2638
2639/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002640int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
2642{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
2644
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302645 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2646 "MPT event (=%02Xh) routed to SCSI host driver!\n",
2647 ioc->name, event));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648
Kashyap, Desai2f187862009-05-29 16:52:37 +05302649 if ((event == MPI_EVENT_IOC_BUS_RESET ||
2650 event == MPI_EVENT_EXT_BUS_RESET) &&
2651 (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
2652 ioc->soft_resets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653
2654 return 1; /* currently means nothing really */
2655}
2656
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2658/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 * Bus Scan and Domain Validation functionality ...
2660 */
2661
2662/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2663/*
2664 * mptscsih_scandv_complete - Scan and DV callback routine registered
2665 * to Fustion MPT (base) driver.
2666 *
2667 * @ioc: Pointer to MPT_ADAPTER structure
2668 * @mf: Pointer to original MPT request frame
2669 * @mr: Pointer to MPT reply frame (NULL if TurboReply)
2670 *
2671 * This routine is called from mpt.c::mpt_interrupt() at the completion
2672 * of any SCSI IO request.
2673 * This routine is registered with the Fusion MPT (base) driver at driver
2674 * load/init time via the mpt_register() API call.
2675 *
2676 * Returns 1 indicating alloc'd request frame ptr should be freed.
2677 *
2678 * Remark: Sets a completion code and (possibly) saves sense data
2679 * in the IOC member localReply structure.
2680 * Used ONLY for DV and other internal commands.
2681 */
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002682int
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302683mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2684 MPT_FRAME_HDR *reply)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 SCSIIORequest_t *pReq;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302687 SCSIIOReply_t *pReply;
2688 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689 u16 req_idx;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302690 u8 *sense_data;
2691 int sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302693 ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2694 ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
2695 if (!reply)
2696 goto out;
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04002697
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302698 pReply = (SCSIIOReply_t *) reply;
2699 pReq = (SCSIIORequest_t *) req;
2700 ioc->internal_cmds.completion_code =
2701 mptscsih_get_completion_code(ioc, req, reply);
2702 ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
2703 memcpy(ioc->internal_cmds.reply, reply,
2704 min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
2705 cmd = reply->u.hdr.Function;
2706 if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
2707 (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
2708 (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
2709 req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
2710 sense_data = ((u8 *)ioc->sense_buf_pool +
2711 (req_idx * MPT_SENSE_BUFFER_ALLOC));
2712 sz = min_t(int, pReq->SenseBufferLength,
2713 MPT_SENSE_BUFFER_ALLOC);
2714 memcpy(ioc->internal_cmds.sense, sense_data, sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 }
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302716 out:
2717 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
2718 return 0;
2719 ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
2720 complete(&ioc->internal_cmds.done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 return 1;
2722}
2723
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302725/**
2726 * mptscsih_get_completion_code -
2727 * @ioc: Pointer to MPT_ADAPTER structure
Randy Dunlap9cf46a32009-06-13 19:37:18 -07002728 * @req: Pointer to original MPT request frame
2729 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302730 *
2731 **/
2732static int
2733mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2734 MPT_FRAME_HDR *reply)
2735{
2736 SCSIIOReply_t *pReply;
2737 MpiRaidActionReply_t *pr;
2738 u8 scsi_status;
2739 u16 status;
2740 int completion_code;
2741
2742 pReply = (SCSIIOReply_t *)reply;
2743 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2744 scsi_status = pReply->SCSIStatus;
2745
2746 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2747 "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh,"
2748 "IOCLogInfo=%08xh\n", ioc->name, status, pReply->SCSIState,
2749 scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
2750
2751 switch (status) {
2752
2753 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
2754 completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
2755 break;
2756
2757 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
2758 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
2759 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
2760 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
2761 completion_code = MPT_SCANDV_DID_RESET;
2762 break;
2763
2764 case MPI_IOCSTATUS_BUSY:
2765 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
2766 completion_code = MPT_SCANDV_BUSY;
2767 break;
2768
2769 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
2770 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
2771 case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
2772 if (pReply->Function == MPI_FUNCTION_CONFIG) {
2773 completion_code = MPT_SCANDV_GOOD;
2774 } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
2775 pr = (MpiRaidActionReply_t *)reply;
2776 if (le16_to_cpu(pr->ActionStatus) ==
2777 MPI_RAID_ACTION_ASTATUS_SUCCESS)
2778 completion_code = MPT_SCANDV_GOOD;
2779 else
2780 completion_code = MPT_SCANDV_SOME_ERROR;
2781 } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
2782 completion_code = MPT_SCANDV_SENSE;
2783 else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
2784 if (req->u.scsireq.CDB[0] == INQUIRY)
2785 completion_code = MPT_SCANDV_ISSUE_SENSE;
2786 else
2787 completion_code = MPT_SCANDV_DID_RESET;
2788 } else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
2789 completion_code = MPT_SCANDV_DID_RESET;
2790 else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2791 completion_code = MPT_SCANDV_DID_RESET;
2792 else if (scsi_status == MPI_SCSI_STATUS_BUSY)
2793 completion_code = MPT_SCANDV_BUSY;
2794 else
2795 completion_code = MPT_SCANDV_GOOD;
2796 break;
2797
2798 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
2799 if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
2800 completion_code = MPT_SCANDV_DID_RESET;
2801 else
2802 completion_code = MPT_SCANDV_SOME_ERROR;
2803 break;
2804 default:
2805 completion_code = MPT_SCANDV_SOME_ERROR;
2806 break;
2807
2808 } /* switch(status) */
2809
2810 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2811 " completionCode set to %08xh\n", ioc->name, completion_code));
2812 return completion_code;
2813}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814
2815/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2816/**
2817 * mptscsih_do_cmd - Do internal command.
2818 * @hd: MPT_SCSI_HOST pointer
2819 * @io: INTERNAL_CMD pointer.
2820 *
2821 * Issue the specified internally generated command and do command
2822 * specific cleanup. For bus scan / DV only.
2823 * NOTES: If command is Inquiry and status is good,
2824 * initialize a target structure, save the data
2825 *
2826 * Remark: Single threaded access only.
2827 *
2828 * Return:
2829 * < 0 if an illegal command or no resources
2830 *
2831 * 0 if good
2832 *
2833 * > 0 if command complete but some type of completion error.
2834 */
2835static int
2836mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
2837{
2838 MPT_FRAME_HDR *mf;
2839 SCSIIORequest_t *pScsiReq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 int my_idx, ii, dir;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302841 int timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 char cmdLen;
2843 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302844 u8 cmd = io->cmd;
2845 MPT_ADAPTER *ioc = hd->ioc;
2846 int ret = 0;
2847 unsigned long timeleft;
2848 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849
Kashyap, Desai1ba9ab22009-05-29 16:44:48 +05302850 /* don't send internal command during diag reset */
2851 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2852 if (ioc->ioc_reset_in_progress) {
2853 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2854 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2855 "%s: busy with host reset\n", ioc->name, __func__));
2856 return MPT_SCANDV_BUSY;
2857 }
2858 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2859
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302860 mutex_lock(&ioc->internal_cmds.mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861
2862 /* Set command specific information
2863 */
2864 switch (cmd) {
2865 case INQUIRY:
2866 cmdLen = 6;
2867 dir = MPI_SCSIIO_CONTROL_READ;
2868 CDB[0] = cmd;
2869 CDB[4] = io->size;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302870 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 break;
2872
2873 case TEST_UNIT_READY:
2874 cmdLen = 6;
2875 dir = MPI_SCSIIO_CONTROL_READ;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302876 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 break;
2878
2879 case START_STOP:
2880 cmdLen = 6;
2881 dir = MPI_SCSIIO_CONTROL_READ;
2882 CDB[0] = cmd;
2883 CDB[4] = 1; /*Spin up the disk */
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302884 timeout = 15;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885 break;
2886
2887 case REQUEST_SENSE:
2888 cmdLen = 6;
2889 CDB[0] = cmd;
2890 CDB[4] = io->size;
2891 dir = MPI_SCSIIO_CONTROL_READ;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302892 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 break;
2894
2895 case READ_BUFFER:
2896 cmdLen = 10;
2897 dir = MPI_SCSIIO_CONTROL_READ;
2898 CDB[0] = cmd;
2899 if (io->flags & MPT_ICFLAG_ECHO) {
2900 CDB[1] = 0x0A;
2901 } else {
2902 CDB[1] = 0x02;
2903 }
2904
2905 if (io->flags & MPT_ICFLAG_BUF_CAP) {
2906 CDB[1] |= 0x01;
2907 }
2908 CDB[6] = (io->size >> 16) & 0xFF;
2909 CDB[7] = (io->size >> 8) & 0xFF;
2910 CDB[8] = io->size & 0xFF;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302911 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 break;
2913
2914 case WRITE_BUFFER:
2915 cmdLen = 10;
2916 dir = MPI_SCSIIO_CONTROL_WRITE;
2917 CDB[0] = cmd;
2918 if (io->flags & MPT_ICFLAG_ECHO) {
2919 CDB[1] = 0x0A;
2920 } else {
2921 CDB[1] = 0x02;
2922 }
2923 CDB[6] = (io->size >> 16) & 0xFF;
2924 CDB[7] = (io->size >> 8) & 0xFF;
2925 CDB[8] = io->size & 0xFF;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302926 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 break;
2928
2929 case RESERVE:
2930 cmdLen = 6;
2931 dir = MPI_SCSIIO_CONTROL_READ;
2932 CDB[0] = cmd;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302933 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934 break;
2935
2936 case RELEASE:
2937 cmdLen = 6;
2938 dir = MPI_SCSIIO_CONTROL_READ;
2939 CDB[0] = cmd;
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302940 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 break;
2942
2943 case SYNCHRONIZE_CACHE:
2944 cmdLen = 10;
2945 dir = MPI_SCSIIO_CONTROL_READ;
2946 CDB[0] = cmd;
2947// CDB[1] = 0x02; /* set immediate bit */
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302948 timeout = 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 break;
2950
2951 default:
2952 /* Error Case */
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302953 ret = -EFAULT;
2954 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 }
2956
2957 /* Get and Populate a free Frame
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302958 * MsgContext set in mpt_get_msg_frame call
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 */
Eric Mooree80b0022007-09-14 18:49:03 -06002960 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
Kashyap, Desai37c60f32009-05-29 16:44:06 +05302961 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
2962 ioc->name, __func__));
2963 ret = MPT_SCANDV_BUSY;
2964 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965 }
2966
2967 pScsiReq = (SCSIIORequest_t *) mf;
2968
2969 /* Get the request index */
2970 my_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2971 ADD_INDEX_LOG(my_idx); /* for debug */
2972
2973 if (io->flags & MPT_ICFLAG_PHYS_DISK) {
2974 pScsiReq->TargetID = io->physDiskNum;
2975 pScsiReq->Bus = 0;
2976 pScsiReq->ChainOffset = 0;
2977 pScsiReq->Function = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH;
2978 } else {
2979 pScsiReq->TargetID = io->id;
Eric Moore793955f2007-01-29 09:42:20 -07002980 pScsiReq->Bus = io->channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981 pScsiReq->ChainOffset = 0;
2982 pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST;
2983 }
2984
2985 pScsiReq->CDBLength = cmdLen;
2986 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2987
2988 pScsiReq->Reserved = 0;
2989
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05302990 pScsiReq->MsgFlags = mpt_msg_flags(ioc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 /* MsgContext set in mpt_get_msg_fram call */
2992
Eric Moore793955f2007-01-29 09:42:20 -07002993 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994
2995 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
2996 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
2997 else
2998 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
2999
3000 if (cmd == REQUEST_SENSE) {
3001 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303002 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3003 "%s: Untagged! 0x%02x\n", ioc->name, __func__, cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 }
3005
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303006 for (ii = 0; ii < 16; ii++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 pScsiReq->CDB[ii] = CDB[ii];
3008
3009 pScsiReq->DataLength = cpu_to_le32(io->size);
Eric Mooree80b0022007-09-14 18:49:03 -06003010 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
3012
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303013 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3014 "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%d\n",
3015 ioc->name, __func__, cmd, io->channel, io->id, io->lun));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303017 if (dir == MPI_SCSIIO_CONTROL_READ)
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05303018 ioc->add_sge((char *) &pScsiReq->SGL,
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303019 MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
3020 else
Kashyap, Desai14d0f0b2009-05-29 16:37:04 +05303021 ioc->add_sge((char *) &pScsiReq->SGL,
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303022 MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303024 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
Eric Mooree80b0022007-09-14 18:49:03 -06003025 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303026 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
3027 timeout*HZ);
3028 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
3029 ret = MPT_SCANDV_DID_RESET;
3030 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3031 "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __func__,
3032 cmd));
3033 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
3034 mpt_free_msg_frame(ioc, mf);
3035 goto out;
3036 }
3037 if (!timeleft) {
3038 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
3039 ioc->name, __func__);
Kashyap, Desaid0f698c2010-03-18 19:12:17 +05303040 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303041 mpt_free_msg_frame(ioc, mf);
3042 }
3043 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 }
3045
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303046 ret = ioc->internal_cmds.completion_code;
3047 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
3048 ioc->name, __func__, ret));
3049
3050 out:
3051 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
3052 mutex_unlock(&ioc->internal_cmds.mutex);
3053 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054}
3055
3056/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3057/**
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07003058 * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks.
3059 * @hd: Pointer to a SCSI HOST structure
Randy Dunlapd9489fb2006-12-06 20:38:43 -08003060 * @vdevice: virtual target device
Moore, Eric Deanc7c82982005-11-16 18:54:25 -07003061 *
3062 * Uses the ISR, but with special processing.
3063 * MUST be single-threaded.
3064 *
3065 */
3066static void
3067mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
3068{
3069 INTERNAL_CMD iocmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070
Eric Moorecc78d302007-06-15 17:27:21 -06003071 /* Ignore hidden raid components, this is handled when the command
3072 * is sent to the volume
3073 */
3074 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
3075 return;
3076
3077 if (vdevice->vtarget->type != TYPE_DISK || vdevice->vtarget->deleted ||
3078 !vdevice->configured_lun)
3079 return;
3080
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081 /* Following parameters will not change
3082 * in this routine.
3083 */
3084 iocmd.cmd = SYNCHRONIZE_CACHE;
3085 iocmd.flags = 0;
3086 iocmd.physDiskNum = -1;
3087 iocmd.data = NULL;
3088 iocmd.data_dma = -1;
3089 iocmd.size = 0;
3090 iocmd.rsvd = iocmd.rsvd2 = 0;
Eric Moore793955f2007-01-29 09:42:20 -07003091 iocmd.channel = vdevice->vtarget->channel;
3092 iocmd.id = vdevice->vtarget->id;
3093 iocmd.lun = vdevice->lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094
Eric Moorecc78d302007-06-15 17:27:21 -06003095 mptscsih_do_cmd(hd, &iocmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096}
3097
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303098static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003099mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
3100 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303101{
Tony Jonesee959b02008-02-22 00:13:36 +01003102 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003103 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303104 MPT_ADAPTER *ioc = hd->ioc;
3105
3106 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
3107 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3108 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3109 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3110 ioc->facts.FWVersion.Word & 0x000000FF);
3111}
Tony Jonesee959b02008-02-22 00:13:36 +01003112static DEVICE_ATTR(version_fw, S_IRUGO, mptscsih_version_fw_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303113
3114static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003115mptscsih_version_bios_show(struct device *dev, struct device_attribute *attr,
3116 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303117{
Tony Jonesee959b02008-02-22 00:13:36 +01003118 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003119 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303120 MPT_ADAPTER *ioc = hd->ioc;
3121
3122 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
3123 (ioc->biosVersion & 0xFF000000) >> 24,
3124 (ioc->biosVersion & 0x00FF0000) >> 16,
3125 (ioc->biosVersion & 0x0000FF00) >> 8,
3126 ioc->biosVersion & 0x000000FF);
3127}
Tony Jonesee959b02008-02-22 00:13:36 +01003128static DEVICE_ATTR(version_bios, S_IRUGO, mptscsih_version_bios_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303129
3130static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003131mptscsih_version_mpi_show(struct device *dev, struct device_attribute *attr,
3132 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303133{
Tony Jonesee959b02008-02-22 00:13:36 +01003134 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003135 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303136 MPT_ADAPTER *ioc = hd->ioc;
3137
3138 return snprintf(buf, PAGE_SIZE, "%03x\n", ioc->facts.MsgVersion);
3139}
Tony Jonesee959b02008-02-22 00:13:36 +01003140static DEVICE_ATTR(version_mpi, S_IRUGO, mptscsih_version_mpi_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303141
3142static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003143mptscsih_version_product_show(struct device *dev,
3144 struct device_attribute *attr,
3145char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303146{
Tony Jonesee959b02008-02-22 00:13:36 +01003147 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003148 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303149 MPT_ADAPTER *ioc = hd->ioc;
3150
3151 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->prod_name);
3152}
Tony Jonesee959b02008-02-22 00:13:36 +01003153static DEVICE_ATTR(version_product, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303154 mptscsih_version_product_show, NULL);
3155
3156static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003157mptscsih_version_nvdata_persistent_show(struct device *dev,
3158 struct device_attribute *attr,
3159 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303160{
Tony Jonesee959b02008-02-22 00:13:36 +01003161 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003162 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303163 MPT_ADAPTER *ioc = hd->ioc;
3164
3165 return snprintf(buf, PAGE_SIZE, "%02xh\n",
3166 ioc->nvdata_version_persistent);
3167}
Tony Jonesee959b02008-02-22 00:13:36 +01003168static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303169 mptscsih_version_nvdata_persistent_show, NULL);
3170
3171static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003172mptscsih_version_nvdata_default_show(struct device *dev,
3173 struct device_attribute *attr, char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303174{
Tony Jonesee959b02008-02-22 00:13:36 +01003175 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003176 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303177 MPT_ADAPTER *ioc = hd->ioc;
3178
3179 return snprintf(buf, PAGE_SIZE, "%02xh\n",ioc->nvdata_version_default);
3180}
Tony Jonesee959b02008-02-22 00:13:36 +01003181static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303182 mptscsih_version_nvdata_default_show, NULL);
3183
3184static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003185mptscsih_board_name_show(struct device *dev, struct device_attribute *attr,
3186 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303187{
Tony Jonesee959b02008-02-22 00:13:36 +01003188 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003189 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303190 MPT_ADAPTER *ioc = hd->ioc;
3191
3192 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_name);
3193}
Tony Jonesee959b02008-02-22 00:13:36 +01003194static DEVICE_ATTR(board_name, S_IRUGO, mptscsih_board_name_show, NULL);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303195
3196static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003197mptscsih_board_assembly_show(struct device *dev,
3198 struct device_attribute *attr, char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303199{
Tony Jonesee959b02008-02-22 00:13:36 +01003200 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003201 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303202 MPT_ADAPTER *ioc = hd->ioc;
3203
3204 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_assembly);
3205}
Tony Jonesee959b02008-02-22 00:13:36 +01003206static DEVICE_ATTR(board_assembly, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303207 mptscsih_board_assembly_show, NULL);
3208
3209static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003210mptscsih_board_tracer_show(struct device *dev, struct device_attribute *attr,
3211 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303212{
Tony Jonesee959b02008-02-22 00:13:36 +01003213 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003214 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303215 MPT_ADAPTER *ioc = hd->ioc;
3216
3217 return snprintf(buf, PAGE_SIZE, "%s\n", ioc->board_tracer);
3218}
Tony Jonesee959b02008-02-22 00:13:36 +01003219static DEVICE_ATTR(board_tracer, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303220 mptscsih_board_tracer_show, NULL);
3221
3222static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003223mptscsih_io_delay_show(struct device *dev, struct device_attribute *attr,
3224 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303225{
Tony Jonesee959b02008-02-22 00:13:36 +01003226 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003227 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303228 MPT_ADAPTER *ioc = hd->ioc;
3229
3230 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
3231}
Tony Jonesee959b02008-02-22 00:13:36 +01003232static DEVICE_ATTR(io_delay, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303233 mptscsih_io_delay_show, NULL);
3234
3235static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003236mptscsih_device_delay_show(struct device *dev, struct device_attribute *attr,
3237 char *buf)
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303238{
Tony Jonesee959b02008-02-22 00:13:36 +01003239 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003240 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303241 MPT_ADAPTER *ioc = hd->ioc;
3242
3243 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
3244}
Tony Jonesee959b02008-02-22 00:13:36 +01003245static DEVICE_ATTR(device_delay, S_IRUGO,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303246 mptscsih_device_delay_show, NULL);
3247
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303248static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003249mptscsih_debug_level_show(struct device *dev, struct device_attribute *attr,
3250 char *buf)
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303251{
Tony Jonesee959b02008-02-22 00:13:36 +01003252 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003253 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303254 MPT_ADAPTER *ioc = hd->ioc;
3255
3256 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->debug_level);
3257}
3258static ssize_t
Tony Jonesee959b02008-02-22 00:13:36 +01003259mptscsih_debug_level_store(struct device *dev, struct device_attribute *attr,
3260 const char *buf, size_t count)
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303261{
Tony Jonesee959b02008-02-22 00:13:36 +01003262 struct Scsi_Host *host = class_to_shost(dev);
Eric Mooree7eae9f2007-09-29 10:15:59 -06003263 MPT_SCSI_HOST *hd = shost_priv(host);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303264 MPT_ADAPTER *ioc = hd->ioc;
3265 int val = 0;
3266
3267 if (sscanf(buf, "%x", &val) != 1)
3268 return -EINVAL;
3269
3270 ioc->debug_level = val;
3271 printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
3272 ioc->name, ioc->debug_level);
3273 return strlen(buf);
3274}
Tony Jonesee959b02008-02-22 00:13:36 +01003275static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
3276 mptscsih_debug_level_show, mptscsih_debug_level_store);
Prakash, Sathya6757d6b2007-07-25 11:14:01 +05303277
Tony Jonesee959b02008-02-22 00:13:36 +01003278struct device_attribute *mptscsih_host_attrs[] = {
3279 &dev_attr_version_fw,
3280 &dev_attr_version_bios,
3281 &dev_attr_version_mpi,
3282 &dev_attr_version_product,
3283 &dev_attr_version_nvdata_persistent,
3284 &dev_attr_version_nvdata_default,
3285 &dev_attr_board_name,
3286 &dev_attr_board_assembly,
3287 &dev_attr_board_tracer,
3288 &dev_attr_io_delay,
3289 &dev_attr_device_delay,
3290 &dev_attr_debug_level,
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303291 NULL,
3292};
Kashyap, Desai37c60f32009-05-29 16:44:06 +05303293
Prakash, Sathyaedb90682007-07-17 14:39:14 +05303294EXPORT_SYMBOL(mptscsih_host_attrs);
3295
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04003296EXPORT_SYMBOL(mptscsih_remove);
3297EXPORT_SYMBOL(mptscsih_shutdown);
3298#ifdef CONFIG_PM
3299EXPORT_SYMBOL(mptscsih_suspend);
3300EXPORT_SYMBOL(mptscsih_resume);
3301#endif
3302EXPORT_SYMBOL(mptscsih_proc_info);
3303EXPORT_SYMBOL(mptscsih_info);
3304EXPORT_SYMBOL(mptscsih_qcmd);
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04003305EXPORT_SYMBOL(mptscsih_slave_destroy);
3306EXPORT_SYMBOL(mptscsih_slave_configure);
3307EXPORT_SYMBOL(mptscsih_abort);
3308EXPORT_SYMBOL(mptscsih_dev_reset);
3309EXPORT_SYMBOL(mptscsih_bus_reset);
3310EXPORT_SYMBOL(mptscsih_host_reset);
3311EXPORT_SYMBOL(mptscsih_bios_param);
3312EXPORT_SYMBOL(mptscsih_io_done);
3313EXPORT_SYMBOL(mptscsih_taskmgmt_complete);
3314EXPORT_SYMBOL(mptscsih_scandv_complete);
3315EXPORT_SYMBOL(mptscsih_event_process);
3316EXPORT_SYMBOL(mptscsih_ioc_reset);
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -06003317EXPORT_SYMBOL(mptscsih_change_queue_depth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003318
Moore, Eric Dean 0d0c7972005-04-22 18:02:09 -04003319/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/