1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2007 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/pci.h>
23 #include <linux/interrupt.h>
24 #include <linux/delay.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_tcq.h>
30 #include <scsi/scsi_transport_fc.h>
32 #include "lpfc_version.h"
35 #include "lpfc_disc.h"
36 #include "lpfc_scsi.h"
38 #include "lpfc_logmsg.h"
39 #include "lpfc_crtn.h"
40 #include "lpfc_vport.h"
42 #define LPFC_RESET_WAIT 2
43 #define LPFC_ABORT_WAIT 2
46 * This function is called with no lock held when there is a resource
47 * error in driver or in firmware.
50 lpfc_adjust_queue_depth(struct lpfc_hba
*phba
)
54 spin_lock_irqsave(&phba
->hbalock
, flags
);
55 atomic_inc(&phba
->num_rsrc_err
);
56 phba
->last_rsrc_error_time
= jiffies
;
58 if ((phba
->last_ramp_down_time
+ QUEUE_RAMP_DOWN_INTERVAL
) > jiffies
) {
59 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
63 phba
->last_ramp_down_time
= jiffies
;
65 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
67 spin_lock_irqsave(&phba
->pport
->work_port_lock
, flags
);
68 if ((phba
->pport
->work_port_events
&
69 WORKER_RAMP_DOWN_QUEUE
) == 0) {
70 phba
->pport
->work_port_events
|= WORKER_RAMP_DOWN_QUEUE
;
72 spin_unlock_irqrestore(&phba
->pport
->work_port_lock
, flags
);
74 spin_lock_irqsave(&phba
->hbalock
, flags
);
76 wake_up(phba
->work_wait
);
77 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
83 * This function is called with no lock held when there is a successful
84 * SCSI command completion.
87 lpfc_rampup_queue_depth(struct lpfc_vport
*vport
,
88 struct scsi_device
*sdev
)
91 struct lpfc_hba
*phba
= vport
->phba
;
92 atomic_inc(&phba
->num_cmd_success
);
94 if (vport
->cfg_lun_queue_depth
<= sdev
->queue_depth
)
96 spin_lock_irqsave(&phba
->hbalock
, flags
);
97 if (((phba
->last_ramp_up_time
+ QUEUE_RAMP_UP_INTERVAL
) > jiffies
) ||
98 ((phba
->last_rsrc_error_time
+ QUEUE_RAMP_UP_INTERVAL
) > jiffies
)) {
99 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
102 phba
->last_ramp_up_time
= jiffies
;
103 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
105 spin_lock_irqsave(&phba
->pport
->work_port_lock
, flags
);
106 if ((phba
->pport
->work_port_events
&
107 WORKER_RAMP_UP_QUEUE
) == 0) {
108 phba
->pport
->work_port_events
|= WORKER_RAMP_UP_QUEUE
;
110 spin_unlock_irqrestore(&phba
->pport
->work_port_lock
, flags
);
112 spin_lock_irqsave(&phba
->hbalock
, flags
);
114 wake_up(phba
->work_wait
);
115 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
119 lpfc_ramp_down_queue_handler(struct lpfc_hba
*phba
)
121 struct lpfc_vport
**vports
;
122 struct Scsi_Host
*shost
;
123 struct scsi_device
*sdev
;
124 unsigned long new_queue_depth
;
125 unsigned long num_rsrc_err
, num_cmd_success
;
128 num_rsrc_err
= atomic_read(&phba
->num_rsrc_err
);
129 num_cmd_success
= atomic_read(&phba
->num_cmd_success
);
131 vports
= lpfc_create_vport_work_array(phba
);
133 for(i
= 0; i
< LPFC_MAX_VPORTS
&& vports
[i
] != NULL
; i
++) {
134 shost
= lpfc_shost_from_vport(vports
[i
]);
135 shost_for_each_device(sdev
, shost
) {
137 sdev
->queue_depth
* num_rsrc_err
/
138 (num_rsrc_err
+ num_cmd_success
);
139 if (!new_queue_depth
)
140 new_queue_depth
= sdev
->queue_depth
- 1;
142 new_queue_depth
= sdev
->queue_depth
-
144 if (sdev
->ordered_tags
)
145 scsi_adjust_queue_depth(sdev
,
149 scsi_adjust_queue_depth(sdev
,
154 lpfc_destroy_vport_work_array(vports
);
155 spin_unlock_irq(&phba
->hbalock
);
156 atomic_set(&phba
->num_rsrc_err
, 0);
157 atomic_set(&phba
->num_cmd_success
, 0);
161 lpfc_ramp_up_queue_handler(struct lpfc_hba
*phba
)
163 struct lpfc_vport
**vports
;
164 struct Scsi_Host
*shost
;
165 struct scsi_device
*sdev
;
168 vports
= lpfc_create_vport_work_array(phba
);
170 for(i
= 0; i
< LPFC_MAX_VPORTS
&& vports
[i
] != NULL
; i
++) {
171 shost
= lpfc_shost_from_vport(vports
[i
]);
172 shost_for_each_device(sdev
, shost
) {
173 if (sdev
->ordered_tags
)
174 scsi_adjust_queue_depth(sdev
,
176 sdev
->queue_depth
+1);
178 scsi_adjust_queue_depth(sdev
,
180 sdev
->queue_depth
+1);
183 lpfc_destroy_vport_work_array(vports
);
184 atomic_set(&phba
->num_rsrc_err
, 0);
185 atomic_set(&phba
->num_cmd_success
, 0);
189 * This routine allocates a scsi buffer, which contains all the necessary
190 * information needed to initiate a SCSI I/O. The non-DMAable buffer region
191 * contains information to build the IOCB. The DMAable region contains
192 * memory for the FCP CMND, FCP RSP, and the inital BPL. In addition to
193 * allocating memeory, the FCP CMND and FCP RSP BDEs are setup in the BPL
194 * and the BPL BDE is setup in the IOCB.
196 static struct lpfc_scsi_buf
*
197 lpfc_new_scsi_buf(struct lpfc_vport
*vport
)
199 struct lpfc_hba
*phba
= vport
->phba
;
200 struct lpfc_scsi_buf
*psb
;
201 struct ulp_bde64
*bpl
;
203 dma_addr_t pdma_phys
;
206 psb
= kmalloc(sizeof(struct lpfc_scsi_buf
), GFP_KERNEL
);
209 memset(psb
, 0, sizeof (struct lpfc_scsi_buf
));
212 * Get memory from the pci pool to map the virt space to pci bus space
213 * for an I/O. The DMA buffer includes space for the struct fcp_cmnd,
214 * struct fcp_rsp and the number of bde's necessary to support the
217 psb
->data
= pci_pool_alloc(phba
->lpfc_scsi_dma_buf_pool
, GFP_KERNEL
,
224 /* Initialize virtual ptrs to dma_buf region. */
225 memset(psb
->data
, 0, phba
->cfg_sg_dma_buf_size
);
227 /* Allocate iotag for psb->cur_iocbq. */
228 iotag
= lpfc_sli_next_iotag(phba
, &psb
->cur_iocbq
);
230 pci_pool_free(phba
->lpfc_scsi_dma_buf_pool
,
231 psb
->data
, psb
->dma_handle
);
235 psb
->cur_iocbq
.iocb_flag
|= LPFC_IO_FCP
;
237 psb
->fcp_cmnd
= psb
->data
;
238 psb
->fcp_rsp
= psb
->data
+ sizeof(struct fcp_cmnd
);
239 psb
->fcp_bpl
= psb
->data
+ sizeof(struct fcp_cmnd
) +
240 sizeof(struct fcp_rsp
);
242 /* Initialize local short-hand pointers. */
244 pdma_phys
= psb
->dma_handle
;
247 * The first two bdes are the FCP_CMD and FCP_RSP. The balance are sg
248 * list bdes. Initialize the first two and leave the rest for
251 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(pdma_phys
));
252 bpl
->addrLow
= le32_to_cpu(putPaddrLow(pdma_phys
));
253 bpl
->tus
.f
.bdeSize
= sizeof (struct fcp_cmnd
);
254 bpl
->tus
.f
.bdeFlags
= BUFF_USE_CMND
;
255 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
258 /* Setup the physical region for the FCP RSP */
259 pdma_phys
+= sizeof (struct fcp_cmnd
);
260 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(pdma_phys
));
261 bpl
->addrLow
= le32_to_cpu(putPaddrLow(pdma_phys
));
262 bpl
->tus
.f
.bdeSize
= sizeof (struct fcp_rsp
);
263 bpl
->tus
.f
.bdeFlags
= (BUFF_USE_CMND
| BUFF_USE_RCV
);
264 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
267 * Since the IOCB for the FCP I/O is built into this lpfc_scsi_buf,
268 * initialize it with all known data now.
270 pdma_phys
+= (sizeof (struct fcp_rsp
));
271 iocb
= &psb
->cur_iocbq
.iocb
;
272 iocb
->un
.fcpi64
.bdl
.ulpIoTag32
= 0;
273 iocb
->un
.fcpi64
.bdl
.addrHigh
= putPaddrHigh(pdma_phys
);
274 iocb
->un
.fcpi64
.bdl
.addrLow
= putPaddrLow(pdma_phys
);
275 iocb
->un
.fcpi64
.bdl
.bdeSize
= (2 * sizeof (struct ulp_bde64
));
276 iocb
->un
.fcpi64
.bdl
.bdeFlags
= BUFF_TYPE_BDL
;
277 iocb
->ulpBdeCount
= 1;
278 iocb
->ulpClass
= CLASS3
;
283 static struct lpfc_scsi_buf
*
284 lpfc_get_scsi_buf(struct lpfc_hba
* phba
)
286 struct lpfc_scsi_buf
* lpfc_cmd
= NULL
;
287 struct list_head
*scsi_buf_list
= &phba
->lpfc_scsi_buf_list
;
288 unsigned long iflag
= 0;
290 spin_lock_irqsave(&phba
->scsi_buf_list_lock
, iflag
);
291 list_remove_head(scsi_buf_list
, lpfc_cmd
, struct lpfc_scsi_buf
, list
);
293 lpfc_cmd
->seg_cnt
= 0;
294 lpfc_cmd
->nonsg_phys
= 0;
296 spin_unlock_irqrestore(&phba
->scsi_buf_list_lock
, iflag
);
301 lpfc_release_scsi_buf(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*psb
)
303 unsigned long iflag
= 0;
305 spin_lock_irqsave(&phba
->scsi_buf_list_lock
, iflag
);
307 list_add_tail(&psb
->list
, &phba
->lpfc_scsi_buf_list
);
308 spin_unlock_irqrestore(&phba
->scsi_buf_list_lock
, iflag
);
312 lpfc_scsi_prep_dma_buf(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*lpfc_cmd
)
314 struct scsi_cmnd
*scsi_cmnd
= lpfc_cmd
->pCmd
;
315 struct scatterlist
*sgel
= NULL
;
316 struct fcp_cmnd
*fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
317 struct ulp_bde64
*bpl
= lpfc_cmd
->fcp_bpl
;
318 IOCB_t
*iocb_cmd
= &lpfc_cmd
->cur_iocbq
.iocb
;
320 uint32_t i
, num_bde
= 0;
321 int nseg
, datadir
= scsi_cmnd
->sc_data_direction
;
324 * There are three possibilities here - use scatter-gather segment, use
325 * the single mapping, or neither. Start the lpfc command prep by
326 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
330 if (scsi_sg_count(scsi_cmnd
)) {
332 * The driver stores the segment count returned from pci_map_sg
333 * because this a count of dma-mappings used to map the use_sg
334 * pages. They are not guaranteed to be the same for those
335 * architectures that implement an IOMMU.
338 nseg
= dma_map_sg(&phba
->pcidev
->dev
, scsi_sglist(scsi_cmnd
),
339 scsi_sg_count(scsi_cmnd
), datadir
);
343 lpfc_cmd
->seg_cnt
= nseg
;
344 if (lpfc_cmd
->seg_cnt
> phba
->cfg_sg_seg_cnt
) {
345 printk(KERN_ERR
"%s: Too many sg segments from "
346 "dma_map_sg. Config %d, seg_cnt %d",
347 __FUNCTION__
, phba
->cfg_sg_seg_cnt
,
349 scsi_dma_unmap(scsi_cmnd
);
354 * The driver established a maximum scatter-gather segment count
355 * during probe that limits the number of sg elements in any
356 * single scsi command. Just run through the seg_cnt and format
359 scsi_for_each_sg(scsi_cmnd
, sgel
, nseg
, i
) {
360 physaddr
= sg_dma_address(sgel
);
361 bpl
->addrLow
= le32_to_cpu(putPaddrLow(physaddr
));
362 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(physaddr
));
363 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
364 if (datadir
== DMA_TO_DEVICE
)
365 bpl
->tus
.f
.bdeFlags
= 0;
367 bpl
->tus
.f
.bdeFlags
= BUFF_USE_RCV
;
368 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
375 * Finish initializing those IOCB fields that are dependent on the
376 * scsi_cmnd request_buffer. Note that the bdeSize is explicitly
377 * reinitialized since all iocb memory resources are used many times
378 * for transmit, receive, and continuation bpl's.
380 iocb_cmd
->un
.fcpi64
.bdl
.bdeSize
= (2 * sizeof (struct ulp_bde64
));
381 iocb_cmd
->un
.fcpi64
.bdl
.bdeSize
+=
382 (num_bde
* sizeof (struct ulp_bde64
));
383 iocb_cmd
->ulpBdeCount
= 1;
385 fcp_cmnd
->fcpDl
= be32_to_cpu(scsi_bufflen(scsi_cmnd
));
390 lpfc_scsi_unprep_dma_buf(struct lpfc_hba
* phba
, struct lpfc_scsi_buf
* psb
)
393 * There are only two special cases to consider. (1) the scsi command
394 * requested scatter-gather usage or (2) the scsi command allocated
395 * a request buffer, but did not request use_sg. There is a third
396 * case, but it does not require resource deallocation.
398 if (psb
->seg_cnt
> 0)
399 scsi_dma_unmap(psb
->pCmd
);
403 lpfc_handle_fcp_err(struct lpfc_vport
*vport
, struct lpfc_scsi_buf
*lpfc_cmd
,
404 struct lpfc_iocbq
*rsp_iocb
)
406 struct scsi_cmnd
*cmnd
= lpfc_cmd
->pCmd
;
407 struct fcp_cmnd
*fcpcmd
= lpfc_cmd
->fcp_cmnd
;
408 struct fcp_rsp
*fcprsp
= lpfc_cmd
->fcp_rsp
;
409 uint32_t fcpi_parm
= rsp_iocb
->iocb
.un
.fcpi
.fcpi_parm
;
410 uint32_t resp_info
= fcprsp
->rspStatus2
;
411 uint32_t scsi_status
= fcprsp
->rspStatus3
;
413 uint32_t host_status
= DID_OK
;
415 uint32_t logit
= LOG_FCP
| LOG_FCP_ERROR
;
418 * If this is a task management command, there is no
419 * scsi packet associated with this lpfc_cmd. The driver
422 if (fcpcmd
->fcpCntl2
) {
427 if ((resp_info
& SNS_LEN_VALID
) && fcprsp
->rspSnsLen
) {
428 uint32_t snslen
= be32_to_cpu(fcprsp
->rspSnsLen
);
429 if (snslen
> SCSI_SENSE_BUFFERSIZE
)
430 snslen
= SCSI_SENSE_BUFFERSIZE
;
432 if (resp_info
& RSP_LEN_VALID
)
433 rsplen
= be32_to_cpu(fcprsp
->rspRspLen
);
434 memcpy(cmnd
->sense_buffer
, &fcprsp
->rspInfo0
+ rsplen
, snslen
);
436 lp
= (uint32_t *)cmnd
->sense_buffer
;
438 if (!scsi_status
&& (resp_info
& RESID_UNDER
))
441 lpfc_printf_vlog(vport
, KERN_WARNING
, logit
,
442 "0730 FCP command x%x failed: x%x SNS x%x x%x "
443 "Data: x%x x%x x%x x%x x%x\n",
444 cmnd
->cmnd
[0], scsi_status
,
445 be32_to_cpu(*lp
), be32_to_cpu(*(lp
+ 3)), resp_info
,
446 be32_to_cpu(fcprsp
->rspResId
),
447 be32_to_cpu(fcprsp
->rspSnsLen
),
448 be32_to_cpu(fcprsp
->rspRspLen
),
451 if (resp_info
& RSP_LEN_VALID
) {
452 rsplen
= be32_to_cpu(fcprsp
->rspRspLen
);
453 if ((rsplen
!= 0 && rsplen
!= 4 && rsplen
!= 8) ||
454 (fcprsp
->rspInfo3
!= RSP_NO_FAILURE
)) {
455 host_status
= DID_ERROR
;
460 scsi_set_resid(cmnd
, 0);
461 if (resp_info
& RESID_UNDER
) {
462 scsi_set_resid(cmnd
, be32_to_cpu(fcprsp
->rspResId
));
464 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
465 "0716 FCP Read Underrun, expected %d, "
466 "residual %d Data: x%x x%x x%x\n",
467 be32_to_cpu(fcpcmd
->fcpDl
),
468 scsi_get_resid(cmnd
), fcpi_parm
, cmnd
->cmnd
[0],
472 * If there is an under run check if under run reported by
473 * storage array is same as the under run reported by HBA.
474 * If this is not same, there is a dropped frame.
476 if ((cmnd
->sc_data_direction
== DMA_FROM_DEVICE
) &&
478 (scsi_get_resid(cmnd
) != fcpi_parm
)) {
479 lpfc_printf_vlog(vport
, KERN_WARNING
,
480 LOG_FCP
| LOG_FCP_ERROR
,
481 "0735 FCP Read Check Error "
482 "and Underrun Data: x%x x%x x%x x%x\n",
483 be32_to_cpu(fcpcmd
->fcpDl
),
484 scsi_get_resid(cmnd
), fcpi_parm
,
486 scsi_set_resid(cmnd
, scsi_bufflen(cmnd
));
487 host_status
= DID_ERROR
;
490 * The cmnd->underflow is the minimum number of bytes that must
491 * be transfered for this command. Provided a sense condition
492 * is not present, make sure the actual amount transferred is at
493 * least the underflow value or fail.
495 if (!(resp_info
& SNS_LEN_VALID
) &&
496 (scsi_status
== SAM_STAT_GOOD
) &&
497 (scsi_bufflen(cmnd
) - scsi_get_resid(cmnd
)
498 < cmnd
->underflow
)) {
499 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
500 "0717 FCP command x%x residual "
501 "underrun converted to error "
502 "Data: x%x x%x x%x\n",
503 cmnd
->cmnd
[0], cmnd
->request_bufflen
,
504 scsi_get_resid(cmnd
), cmnd
->underflow
);
505 host_status
= DID_ERROR
;
507 } else if (resp_info
& RESID_OVER
) {
508 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
509 "0720 FCP command x%x residual overrun error. "
510 "Data: x%x x%x \n", cmnd
->cmnd
[0],
511 scsi_bufflen(cmnd
), scsi_get_resid(cmnd
));
512 host_status
= DID_ERROR
;
515 * Check SLI validation that all the transfer was actually done
516 * (fcpi_parm should be zero). Apply check only to reads.
518 } else if ((scsi_status
== SAM_STAT_GOOD
) && fcpi_parm
&&
519 (cmnd
->sc_data_direction
== DMA_FROM_DEVICE
)) {
520 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
| LOG_FCP_ERROR
,
521 "0734 FCP Read Check Error Data: "
523 be32_to_cpu(fcpcmd
->fcpDl
),
524 be32_to_cpu(fcprsp
->rspResId
),
525 fcpi_parm
, cmnd
->cmnd
[0]);
526 host_status
= DID_ERROR
;
527 scsi_set_resid(cmnd
, scsi_bufflen(cmnd
));
531 cmnd
->result
= ScsiResult(host_status
, scsi_status
);
535 lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba
*phba
, struct lpfc_iocbq
*pIocbIn
,
536 struct lpfc_iocbq
*pIocbOut
)
538 struct lpfc_scsi_buf
*lpfc_cmd
=
539 (struct lpfc_scsi_buf
*) pIocbIn
->context1
;
540 struct lpfc_vport
*vport
= pIocbIn
->vport
;
541 struct lpfc_rport_data
*rdata
= lpfc_cmd
->rdata
;
542 struct lpfc_nodelist
*pnode
= rdata
->pnode
;
543 struct scsi_cmnd
*cmd
= lpfc_cmd
->pCmd
;
545 struct scsi_device
*sdev
, *tmp_sdev
;
548 lpfc_cmd
->result
= pIocbOut
->iocb
.un
.ulpWord
[4];
549 lpfc_cmd
->status
= pIocbOut
->iocb
.ulpStatus
;
551 if (lpfc_cmd
->status
) {
552 if (lpfc_cmd
->status
== IOSTAT_LOCAL_REJECT
&&
553 (lpfc_cmd
->result
& IOERR_DRVR_MASK
))
554 lpfc_cmd
->status
= IOSTAT_DRIVER_REJECT
;
555 else if (lpfc_cmd
->status
>= IOSTAT_CNT
)
556 lpfc_cmd
->status
= IOSTAT_DEFAULT
;
558 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
559 "0729 FCP cmd x%x failed <%d/%d> "
560 "status: x%x result: x%x Data: x%x x%x\n",
562 cmd
->device
? cmd
->device
->id
: 0xffff,
563 cmd
->device
? cmd
->device
->lun
: 0xffff,
564 lpfc_cmd
->status
, lpfc_cmd
->result
,
565 pIocbOut
->iocb
.ulpContext
,
566 lpfc_cmd
->cur_iocbq
.iocb
.ulpIoTag
);
568 switch (lpfc_cmd
->status
) {
569 case IOSTAT_FCP_RSP_ERROR
:
570 /* Call FCP RSP handler to determine result */
571 lpfc_handle_fcp_err(vport
, lpfc_cmd
, pIocbOut
);
573 case IOSTAT_NPORT_BSY
:
574 case IOSTAT_FABRIC_BSY
:
575 cmd
->result
= ScsiResult(DID_BUS_BUSY
, 0);
577 case IOSTAT_LOCAL_REJECT
:
578 if (lpfc_cmd
->result
== RJT_UNAVAIL_PERM
||
579 lpfc_cmd
->result
== IOERR_NO_RESOURCES
||
580 lpfc_cmd
->result
== RJT_LOGIN_REQUIRED
) {
581 cmd
->result
= ScsiResult(DID_REQUEUE
, 0);
583 } /* else: fall through */
585 cmd
->result
= ScsiResult(DID_ERROR
, 0);
590 || (pnode
->nlp_state
!= NLP_STE_MAPPED_NODE
))
591 cmd
->result
= ScsiResult(DID_BUS_BUSY
, SAM_STAT_BUSY
);
593 cmd
->result
= ScsiResult(DID_OK
, 0);
596 if (cmd
->result
|| lpfc_cmd
->fcp_rsp
->rspSnsLen
) {
597 uint32_t *lp
= (uint32_t *)cmd
->sense_buffer
;
599 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
600 "0710 Iodone <%d/%d> cmd %p, error "
601 "x%x SNS x%x x%x Data: x%x x%x\n",
602 cmd
->device
->id
, cmd
->device
->lun
, cmd
,
603 cmd
->result
, *lp
, *(lp
+ 3), cmd
->retries
,
604 scsi_get_resid(cmd
));
607 result
= cmd
->result
;
609 lpfc_scsi_unprep_dma_buf(phba
, lpfc_cmd
);
612 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
613 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
619 lpfc_rampup_queue_depth(vport
, sdev
);
621 if (!result
&& pnode
!= NULL
&&
622 ((jiffies
- pnode
->last_ramp_up_time
) >
623 LPFC_Q_RAMP_UP_INTERVAL
* HZ
) &&
624 ((jiffies
- pnode
->last_q_full_time
) >
625 LPFC_Q_RAMP_UP_INTERVAL
* HZ
) &&
626 (vport
->cfg_lun_queue_depth
> sdev
->queue_depth
)) {
627 shost_for_each_device(tmp_sdev
, sdev
->host
) {
628 if (vport
->cfg_lun_queue_depth
> tmp_sdev
->queue_depth
){
629 if (tmp_sdev
->id
!= sdev
->id
)
631 if (tmp_sdev
->ordered_tags
)
632 scsi_adjust_queue_depth(tmp_sdev
,
634 tmp_sdev
->queue_depth
+1);
636 scsi_adjust_queue_depth(tmp_sdev
,
638 tmp_sdev
->queue_depth
+1);
640 pnode
->last_ramp_up_time
= jiffies
;
646 * Check for queue full. If the lun is reporting queue full, then
647 * back off the lun queue depth to prevent target overloads.
649 if (result
== SAM_STAT_TASK_SET_FULL
&& pnode
!= NULL
) {
650 pnode
->last_q_full_time
= jiffies
;
652 shost_for_each_device(tmp_sdev
, sdev
->host
) {
653 if (tmp_sdev
->id
!= sdev
->id
)
655 depth
= scsi_track_queue_full(tmp_sdev
,
656 tmp_sdev
->queue_depth
- 1);
659 * The queue depth cannot be lowered any more.
660 * Modify the returned error code to store
661 * the final depth value set by
662 * scsi_track_queue_full.
665 depth
= sdev
->host
->cmd_per_lun
;
668 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
669 "0711 detected queue full - lun queue "
670 "depth adjusted to %d.\n", depth
);
674 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
678 lpfc_scsi_prep_cmnd(struct lpfc_vport
*vport
, struct lpfc_scsi_buf
*lpfc_cmd
,
679 struct lpfc_nodelist
*pnode
)
681 struct lpfc_hba
*phba
= vport
->phba
;
682 struct scsi_cmnd
*scsi_cmnd
= lpfc_cmd
->pCmd
;
683 struct fcp_cmnd
*fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
684 IOCB_t
*iocb_cmd
= &lpfc_cmd
->cur_iocbq
.iocb
;
685 struct lpfc_iocbq
*piocbq
= &(lpfc_cmd
->cur_iocbq
);
686 int datadir
= scsi_cmnd
->sc_data_direction
;
688 lpfc_cmd
->fcp_rsp
->rspSnsLen
= 0;
689 /* clear task management bits */
690 lpfc_cmd
->fcp_cmnd
->fcpCntl2
= 0;
692 int_to_scsilun(lpfc_cmd
->pCmd
->device
->lun
,
693 &lpfc_cmd
->fcp_cmnd
->fcp_lun
);
695 memcpy(&fcp_cmnd
->fcpCdb
[0], scsi_cmnd
->cmnd
, 16);
697 if (scsi_cmnd
->device
->tagged_supported
) {
698 switch (scsi_cmnd
->tag
) {
699 case HEAD_OF_QUEUE_TAG
:
700 fcp_cmnd
->fcpCntl1
= HEAD_OF_Q
;
702 case ORDERED_QUEUE_TAG
:
703 fcp_cmnd
->fcpCntl1
= ORDERED_Q
;
706 fcp_cmnd
->fcpCntl1
= SIMPLE_Q
;
710 fcp_cmnd
->fcpCntl1
= 0;
713 * There are three possibilities here - use scatter-gather segment, use
714 * the single mapping, or neither. Start the lpfc command prep by
715 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
718 if (scsi_sg_count(scsi_cmnd
)) {
719 if (datadir
== DMA_TO_DEVICE
) {
720 iocb_cmd
->ulpCommand
= CMD_FCP_IWRITE64_CR
;
721 iocb_cmd
->un
.fcpi
.fcpi_parm
= 0;
723 fcp_cmnd
->fcpCntl3
= WRITE_DATA
;
724 phba
->fc4OutputRequests
++;
726 iocb_cmd
->ulpCommand
= CMD_FCP_IREAD64_CR
;
727 iocb_cmd
->ulpPU
= PARM_READ_CHECK
;
728 iocb_cmd
->un
.fcpi
.fcpi_parm
= scsi_bufflen(scsi_cmnd
);
729 fcp_cmnd
->fcpCntl3
= READ_DATA
;
730 phba
->fc4InputRequests
++;
733 iocb_cmd
->ulpCommand
= CMD_FCP_ICMND64_CR
;
734 iocb_cmd
->un
.fcpi
.fcpi_parm
= 0;
736 fcp_cmnd
->fcpCntl3
= 0;
737 phba
->fc4ControlRequests
++;
741 * Finish initializing those IOCB fields that are independent
742 * of the scsi_cmnd request_buffer
744 piocbq
->iocb
.ulpContext
= pnode
->nlp_rpi
;
745 if (pnode
->nlp_fcp_info
& NLP_FCP_2_DEVICE
)
746 piocbq
->iocb
.ulpFCP2Rcvy
= 1;
748 piocbq
->iocb
.ulpClass
= (pnode
->nlp_fcp_info
& 0x0f);
749 piocbq
->context1
= lpfc_cmd
;
750 piocbq
->iocb_cmpl
= lpfc_scsi_cmd_iocb_cmpl
;
751 piocbq
->iocb
.ulpTimeout
= lpfc_cmd
->timeout
;
752 piocbq
->vport
= vport
;
756 lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport
*vport
,
757 struct lpfc_scsi_buf
*lpfc_cmd
,
759 uint8_t task_mgmt_cmd
)
761 struct lpfc_iocbq
*piocbq
;
763 struct fcp_cmnd
*fcp_cmnd
;
764 struct lpfc_rport_data
*rdata
= lpfc_cmd
->rdata
;
765 struct lpfc_nodelist
*ndlp
= rdata
->pnode
;
767 if ((ndlp
== NULL
) || (ndlp
->nlp_state
!= NLP_STE_MAPPED_NODE
)) {
771 piocbq
= &(lpfc_cmd
->cur_iocbq
);
772 piocbq
->vport
= vport
;
774 piocb
= &piocbq
->iocb
;
776 fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
777 int_to_scsilun(lun
, &lpfc_cmd
->fcp_cmnd
->fcp_lun
);
778 fcp_cmnd
->fcpCntl2
= task_mgmt_cmd
;
780 piocb
->ulpCommand
= CMD_FCP_ICMND64_CR
;
782 piocb
->ulpContext
= ndlp
->nlp_rpi
;
783 if (ndlp
->nlp_fcp_info
& NLP_FCP_2_DEVICE
) {
784 piocb
->ulpFCP2Rcvy
= 1;
786 piocb
->ulpClass
= (ndlp
->nlp_fcp_info
& 0x0f);
788 /* ulpTimeout is only one byte */
789 if (lpfc_cmd
->timeout
> 0xff) {
791 * Do not timeout the command at the firmware level.
792 * The driver will provide the timeout mechanism.
794 piocb
->ulpTimeout
= 0;
796 piocb
->ulpTimeout
= lpfc_cmd
->timeout
;
803 lpfc_tskmgmt_def_cmpl(struct lpfc_hba
*phba
,
804 struct lpfc_iocbq
*cmdiocbq
,
805 struct lpfc_iocbq
*rspiocbq
)
807 struct lpfc_scsi_buf
*lpfc_cmd
=
808 (struct lpfc_scsi_buf
*) cmdiocbq
->context1
;
810 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
815 lpfc_scsi_tgt_reset(struct lpfc_scsi_buf
*lpfc_cmd
, struct lpfc_vport
*vport
,
816 unsigned tgt_id
, unsigned int lun
,
817 struct lpfc_rport_data
*rdata
)
819 struct lpfc_hba
*phba
= vport
->phba
;
820 struct lpfc_iocbq
*iocbq
;
821 struct lpfc_iocbq
*iocbqrsp
;
827 lpfc_cmd
->rdata
= rdata
;
828 ret
= lpfc_scsi_prep_task_mgmt_cmd(vport
, lpfc_cmd
, lun
,
833 iocbq
= &lpfc_cmd
->cur_iocbq
;
834 iocbqrsp
= lpfc_sli_get_iocbq(phba
);
839 /* Issue Target Reset to TGT <num> */
840 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
841 "0702 Issue Target Reset to TGT %d Data: x%x x%x\n",
842 tgt_id
, rdata
->pnode
->nlp_rpi
, rdata
->pnode
->nlp_flag
);
843 ret
= lpfc_sli_issue_iocb_wait(phba
,
844 &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
845 iocbq
, iocbqrsp
, lpfc_cmd
->timeout
);
846 if (ret
!= IOCB_SUCCESS
) {
847 if (ret
== IOCB_TIMEDOUT
)
848 iocbq
->iocb_cmpl
= lpfc_tskmgmt_def_cmpl
;
849 lpfc_cmd
->status
= IOSTAT_DRIVER_REJECT
;
852 lpfc_cmd
->result
= iocbqrsp
->iocb
.un
.ulpWord
[4];
853 lpfc_cmd
->status
= iocbqrsp
->iocb
.ulpStatus
;
854 if (lpfc_cmd
->status
== IOSTAT_LOCAL_REJECT
&&
855 (lpfc_cmd
->result
& IOERR_DRVR_MASK
))
856 lpfc_cmd
->status
= IOSTAT_DRIVER_REJECT
;
859 lpfc_sli_release_iocbq(phba
, iocbqrsp
);
864 lpfc_info(struct Scsi_Host
*host
)
866 struct lpfc_vport
*vport
= (struct lpfc_vport
*) host
->hostdata
;
867 struct lpfc_hba
*phba
= vport
->phba
;
869 static char lpfcinfobuf
[384];
871 memset(lpfcinfobuf
,0,384);
872 if (phba
&& phba
->pcidev
){
873 strncpy(lpfcinfobuf
, phba
->ModelDesc
, 256);
874 len
= strlen(lpfcinfobuf
);
875 snprintf(lpfcinfobuf
+ len
,
877 " on PCI bus %02x device %02x irq %d",
878 phba
->pcidev
->bus
->number
,
881 len
= strlen(lpfcinfobuf
);
883 snprintf(lpfcinfobuf
+ len
,
892 static __inline__
void lpfc_poll_rearm_timer(struct lpfc_hba
* phba
)
894 unsigned long poll_tmo_expires
=
895 (jiffies
+ msecs_to_jiffies(phba
->cfg_poll_tmo
));
897 if (phba
->sli
.ring
[LPFC_FCP_RING
].txcmplq_cnt
)
898 mod_timer(&phba
->fcp_poll_timer
,
902 void lpfc_poll_start_timer(struct lpfc_hba
* phba
)
904 lpfc_poll_rearm_timer(phba
);
907 void lpfc_poll_timeout(unsigned long ptr
)
909 struct lpfc_hba
*phba
= (struct lpfc_hba
*) ptr
;
911 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
912 lpfc_sli_poll_fcp_ring (phba
);
913 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
914 lpfc_poll_rearm_timer(phba
);
919 lpfc_queuecommand(struct scsi_cmnd
*cmnd
, void (*done
) (struct scsi_cmnd
*))
921 struct Scsi_Host
*shost
= cmnd
->device
->host
;
922 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
923 struct lpfc_hba
*phba
= vport
->phba
;
924 struct lpfc_sli
*psli
= &phba
->sli
;
925 struct lpfc_rport_data
*rdata
= cmnd
->device
->hostdata
;
926 struct lpfc_nodelist
*ndlp
= rdata
->pnode
;
927 struct lpfc_scsi_buf
*lpfc_cmd
;
928 struct fc_rport
*rport
= starget_to_rport(scsi_target(cmnd
->device
));
931 err
= fc_remote_port_chkready(rport
);
934 goto out_fail_command
;
938 * Catch race where our node has transitioned, but the
939 * transport is still transitioning.
942 cmnd
->result
= ScsiResult(DID_BUS_BUSY
, 0);
943 goto out_fail_command
;
945 lpfc_cmd
= lpfc_get_scsi_buf(phba
);
946 if (lpfc_cmd
== NULL
) {
947 lpfc_adjust_queue_depth(phba
);
949 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
950 "0707 driver's buffer pool is empty, "
956 * Store the midlayer's command structure for the completion phase
957 * and complete the command initialization.
959 lpfc_cmd
->pCmd
= cmnd
;
960 lpfc_cmd
->rdata
= rdata
;
961 lpfc_cmd
->timeout
= 0;
962 cmnd
->host_scribble
= (unsigned char *)lpfc_cmd
;
963 cmnd
->scsi_done
= done
;
965 err
= lpfc_scsi_prep_dma_buf(phba
, lpfc_cmd
);
967 goto out_host_busy_free_buf
;
969 lpfc_scsi_prep_cmnd(vport
, lpfc_cmd
, ndlp
);
971 err
= lpfc_sli_issue_iocb(phba
, &phba
->sli
.ring
[psli
->fcp_ring
],
972 &lpfc_cmd
->cur_iocbq
, SLI_IOCB_RET_IOCB
);
974 goto out_host_busy_free_buf
;
976 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
977 lpfc_sli_poll_fcp_ring(phba
);
978 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
979 lpfc_poll_rearm_timer(phba
);
984 out_host_busy_free_buf
:
985 lpfc_scsi_unprep_dma_buf(phba
, lpfc_cmd
);
986 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
988 return SCSI_MLQUEUE_HOST_BUSY
;
996 lpfc_block_error_handler(struct scsi_cmnd
*cmnd
)
998 struct Scsi_Host
*shost
= cmnd
->device
->host
;
999 struct fc_rport
*rport
= starget_to_rport(scsi_target(cmnd
->device
));
1001 spin_lock_irq(shost
->host_lock
);
1002 while (rport
->port_state
== FC_PORTSTATE_BLOCKED
) {
1003 spin_unlock_irq(shost
->host_lock
);
1005 spin_lock_irq(shost
->host_lock
);
1007 spin_unlock_irq(shost
->host_lock
);
1012 lpfc_abort_handler(struct scsi_cmnd
*cmnd
)
1014 struct Scsi_Host
*shost
= cmnd
->device
->host
;
1015 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1016 struct lpfc_hba
*phba
= vport
->phba
;
1017 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[phba
->sli
.fcp_ring
];
1018 struct lpfc_iocbq
*iocb
;
1019 struct lpfc_iocbq
*abtsiocb
;
1020 struct lpfc_scsi_buf
*lpfc_cmd
;
1022 unsigned int loop_count
= 0;
1025 lpfc_block_error_handler(cmnd
);
1026 lpfc_cmd
= (struct lpfc_scsi_buf
*)cmnd
->host_scribble
;
1030 * If pCmd field of the corresponding lpfc_scsi_buf structure
1031 * points to a different SCSI command, then the driver has
1032 * already completed this command, but the midlayer did not
1033 * see the completion before the eh fired. Just return
1036 iocb
= &lpfc_cmd
->cur_iocbq
;
1037 if (lpfc_cmd
->pCmd
!= cmnd
)
1040 BUG_ON(iocb
->context1
!= lpfc_cmd
);
1042 abtsiocb
= lpfc_sli_get_iocbq(phba
);
1043 if (abtsiocb
== NULL
) {
1049 * The scsi command can not be in txq and it is in flight because the
1050 * pCmd is still pointig at the SCSI command we have to abort. There
1051 * is no need to search the txcmplq. Just send an abort to the FW.
1055 icmd
= &abtsiocb
->iocb
;
1056 icmd
->un
.acxri
.abortType
= ABORT_TYPE_ABTS
;
1057 icmd
->un
.acxri
.abortContextTag
= cmd
->ulpContext
;
1058 icmd
->un
.acxri
.abortIoTag
= cmd
->ulpIoTag
;
1061 icmd
->ulpClass
= cmd
->ulpClass
;
1062 if (lpfc_is_link_up(phba
))
1063 icmd
->ulpCommand
= CMD_ABORT_XRI_CN
;
1065 icmd
->ulpCommand
= CMD_CLOSE_XRI_CN
;
1067 abtsiocb
->iocb_cmpl
= lpfc_sli_abort_fcp_cmpl
;
1068 abtsiocb
->vport
= vport
;
1069 if (lpfc_sli_issue_iocb(phba
, pring
, abtsiocb
, 0) == IOCB_ERROR
) {
1070 lpfc_sli_release_iocbq(phba
, abtsiocb
);
1075 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
1076 lpfc_sli_poll_fcp_ring (phba
);
1078 /* Wait for abort to complete */
1079 while (lpfc_cmd
->pCmd
== cmnd
)
1081 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
1082 lpfc_sli_poll_fcp_ring (phba
);
1084 schedule_timeout_uninterruptible(LPFC_ABORT_WAIT
* HZ
);
1086 > (2 * vport
->cfg_devloss_tmo
)/LPFC_ABORT_WAIT
)
1090 if (lpfc_cmd
->pCmd
== cmnd
) {
1092 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1093 "0748 abort handler timed out waiting "
1094 "for abort to complete: ret %#x, ID %d, "
1095 "LUN %d, snum %#lx\n",
1096 ret
, cmnd
->device
->id
, cmnd
->device
->lun
,
1097 cmnd
->serial_number
);
1101 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
1102 "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
1103 "LUN %d snum %#lx\n", ret
, cmnd
->device
->id
,
1104 cmnd
->device
->lun
, cmnd
->serial_number
);
1109 lpfc_device_reset_handler(struct scsi_cmnd
*cmnd
)
1111 struct Scsi_Host
*shost
= cmnd
->device
->host
;
1112 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1113 struct lpfc_hba
*phba
= vport
->phba
;
1114 struct lpfc_scsi_buf
*lpfc_cmd
;
1115 struct lpfc_iocbq
*iocbq
, *iocbqrsp
;
1116 struct lpfc_rport_data
*rdata
= cmnd
->device
->hostdata
;
1117 struct lpfc_nodelist
*pnode
= rdata
->pnode
;
1118 uint32_t cmd_result
= 0, cmd_status
= 0;
1120 int iocb_status
= IOCB_SUCCESS
;
1123 lpfc_block_error_handler(cmnd
);
1126 * If target is not in a MAPPED state, delay the reset until
1127 * target is rediscovered or devloss timeout expires.
1133 if (pnode
->nlp_state
!= NLP_STE_MAPPED_NODE
) {
1134 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
1136 rdata
= cmnd
->device
->hostdata
;
1138 (loopcnt
> ((vport
->cfg_devloss_tmo
* 2) + 1))){
1139 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1140 "0721 LUN Reset rport "
1141 "failure: cnt x%x rdata x%p\n",
1145 pnode
= rdata
->pnode
;
1149 if (pnode
->nlp_state
== NLP_STE_MAPPED_NODE
)
1153 lpfc_cmd
= lpfc_get_scsi_buf(phba
);
1154 if (lpfc_cmd
== NULL
)
1157 lpfc_cmd
->timeout
= 60;
1158 lpfc_cmd
->rdata
= rdata
;
1160 ret
= lpfc_scsi_prep_task_mgmt_cmd(vport
, lpfc_cmd
, cmnd
->device
->lun
,
1163 goto out_free_scsi_buf
;
1165 iocbq
= &lpfc_cmd
->cur_iocbq
;
1167 /* get a buffer for this IOCB command response */
1168 iocbqrsp
= lpfc_sli_get_iocbq(phba
);
1169 if (iocbqrsp
== NULL
)
1170 goto out_free_scsi_buf
;
1172 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
1173 "0703 Issue target reset to TGT %d LUN %d "
1174 "rpi x%x nlp_flag x%x\n", cmnd
->device
->id
,
1175 cmnd
->device
->lun
, pnode
->nlp_rpi
, pnode
->nlp_flag
);
1176 iocb_status
= lpfc_sli_issue_iocb_wait(phba
,
1177 &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1178 iocbq
, iocbqrsp
, lpfc_cmd
->timeout
);
1180 if (iocb_status
== IOCB_TIMEDOUT
)
1181 iocbq
->iocb_cmpl
= lpfc_tskmgmt_def_cmpl
;
1183 if (iocb_status
== IOCB_SUCCESS
)
1188 cmd_result
= iocbqrsp
->iocb
.un
.ulpWord
[4];
1189 cmd_status
= iocbqrsp
->iocb
.ulpStatus
;
1191 lpfc_sli_release_iocbq(phba
, iocbqrsp
);
1194 * All outstanding txcmplq I/Os should have been aborted by the device.
1195 * Unfortunately, some targets do not abide by this forcing the driver
1198 cnt
= lpfc_sli_sum_iocb(phba
, &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1199 cmnd
->device
->id
, cmnd
->device
->lun
,
1202 lpfc_sli_abort_iocb(phba
,
1203 &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1204 cmnd
->device
->id
, cmnd
->device
->lun
,
1208 schedule_timeout_uninterruptible(LPFC_RESET_WAIT
*HZ
);
1211 > (2 * vport
->cfg_devloss_tmo
)/LPFC_RESET_WAIT
)
1214 cnt
= lpfc_sli_sum_iocb(phba
,
1215 &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1216 cmnd
->device
->id
, cmnd
->device
->lun
,
1221 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1222 "0719 device reset I/O flush failure: "
1228 if (iocb_status
!= IOCB_TIMEDOUT
) {
1229 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
1231 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1232 "0713 SCSI layer issued device reset (%d, %d) "
1233 "return x%x status x%x result x%x\n",
1234 cmnd
->device
->id
, cmnd
->device
->lun
, ret
,
1235 cmd_status
, cmd_result
);
1241 lpfc_bus_reset_handler(struct scsi_cmnd
*cmnd
)
1243 struct Scsi_Host
*shost
= cmnd
->device
->host
;
1244 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1245 struct lpfc_hba
*phba
= vport
->phba
;
1246 struct lpfc_nodelist
*ndlp
= NULL
;
1248 int ret
= FAILED
, i
, err_count
= 0;
1250 struct lpfc_scsi_buf
* lpfc_cmd
;
1252 lpfc_block_error_handler(cmnd
);
1254 lpfc_cmd
= lpfc_get_scsi_buf(phba
);
1255 if (lpfc_cmd
== NULL
)
1258 /* The lpfc_cmd storage is reused. Set all loop invariants. */
1259 lpfc_cmd
->timeout
= 60;
1262 * Since the driver manages a single bus device, reset all
1263 * targets known to the driver. Should any target reset
1264 * fail, this routine returns failure to the midlayer.
1266 for (i
= 0; i
< LPFC_MAX_TARGET
; i
++) {
1267 /* Search for mapped node by target ID */
1269 spin_lock_irq(shost
->host_lock
);
1270 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
) {
1271 if (ndlp
->nlp_state
== NLP_STE_MAPPED_NODE
&&
1272 i
== ndlp
->nlp_sid
&&
1278 spin_unlock_irq(shost
->host_lock
);
1282 ret
= lpfc_scsi_tgt_reset(lpfc_cmd
, vport
, i
,
1284 ndlp
->rport
->dd_data
);
1285 if (ret
!= SUCCESS
) {
1286 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1287 "0700 Bus Reset on target %d failed\n",
1294 if (ret
!= IOCB_TIMEDOUT
)
1295 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
1303 * All outstanding txcmplq I/Os should have been aborted by
1304 * the targets. Unfortunately, some targets do not abide by
1305 * this forcing the driver to double check.
1307 cnt
= lpfc_sli_sum_iocb(phba
, &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1308 0, 0, LPFC_CTX_HOST
);
1310 lpfc_sli_abort_iocb(phba
, &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1311 0, 0, 0, LPFC_CTX_HOST
);
1314 schedule_timeout_uninterruptible(LPFC_RESET_WAIT
*HZ
);
1317 > (2 * vport
->cfg_devloss_tmo
)/LPFC_RESET_WAIT
)
1320 cnt
= lpfc_sli_sum_iocb(phba
,
1321 &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1322 0, 0, LPFC_CTX_HOST
);
1326 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1327 "0715 Bus Reset I/O flush failure: "
1328 "cnt x%x left x%x\n", cnt
, i
);
1332 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1333 "0714 SCSI layer issued Bus Reset Data: x%x\n", ret
);
1339 lpfc_slave_alloc(struct scsi_device
*sdev
)
1341 struct lpfc_vport
*vport
= (struct lpfc_vport
*) sdev
->host
->hostdata
;
1342 struct lpfc_hba
*phba
= vport
->phba
;
1343 struct lpfc_scsi_buf
*scsi_buf
= NULL
;
1344 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
1345 uint32_t total
= 0, i
;
1346 uint32_t num_to_alloc
= 0;
1347 unsigned long flags
;
1349 if (!rport
|| fc_remote_port_chkready(rport
))
1352 sdev
->hostdata
= rport
->dd_data
;
1355 * Populate the cmds_per_lun count scsi_bufs into this host's globally
1356 * available list of scsi buffers. Don't allocate more than the
1357 * HBA limit conveyed to the midlayer via the host structure. The
1358 * formula accounts for the lun_queue_depth + error handlers + 1
1359 * extra. This list of scsi bufs exists for the lifetime of the driver.
1361 total
= phba
->total_scsi_bufs
;
1362 num_to_alloc
= vport
->cfg_lun_queue_depth
+ 2;
1364 /* Allow some exchanges to be available always to complete discovery */
1365 if (total
>= phba
->cfg_hba_queue_depth
- LPFC_DISC_IOCB_BUFF_COUNT
) {
1366 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
1367 "0704 At limitation of %d preallocated "
1368 "command buffers\n", total
);
1370 /* Allow some exchanges to be available always to complete discovery */
1371 } else if (total
+ num_to_alloc
>
1372 phba
->cfg_hba_queue_depth
- LPFC_DISC_IOCB_BUFF_COUNT
) {
1373 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
1374 "0705 Allocation request of %d "
1375 "command buffers will exceed max of %d. "
1376 "Reducing allocation request to %d.\n",
1377 num_to_alloc
, phba
->cfg_hba_queue_depth
,
1378 (phba
->cfg_hba_queue_depth
- total
));
1379 num_to_alloc
= phba
->cfg_hba_queue_depth
- total
;
1382 for (i
= 0; i
< num_to_alloc
; i
++) {
1383 scsi_buf
= lpfc_new_scsi_buf(vport
);
1385 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
1386 "0706 Failed to allocate "
1387 "command buffer\n");
1391 spin_lock_irqsave(&phba
->scsi_buf_list_lock
, flags
);
1392 phba
->total_scsi_bufs
++;
1393 list_add_tail(&scsi_buf
->list
, &phba
->lpfc_scsi_buf_list
);
1394 spin_unlock_irqrestore(&phba
->scsi_buf_list_lock
, flags
);
1400 lpfc_slave_configure(struct scsi_device
*sdev
)
1402 struct lpfc_vport
*vport
= (struct lpfc_vport
*) sdev
->host
->hostdata
;
1403 struct lpfc_hba
*phba
= vport
->phba
;
1404 struct fc_rport
*rport
= starget_to_rport(sdev
->sdev_target
);
1406 if (sdev
->tagged_supported
)
1407 scsi_activate_tcq(sdev
, vport
->cfg_lun_queue_depth
);
1409 scsi_deactivate_tcq(sdev
, vport
->cfg_lun_queue_depth
);
1412 * Initialize the fc transport attributes for the target
1413 * containing this scsi device. Also note that the driver's
1414 * target pointer is stored in the starget_data for the
1415 * driver's sysfs entry point functions.
1417 rport
->dev_loss_tmo
= vport
->cfg_devloss_tmo
;
1419 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
1420 lpfc_sli_poll_fcp_ring(phba
);
1421 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
1422 lpfc_poll_rearm_timer(phba
);
1429 lpfc_slave_destroy(struct scsi_device
*sdev
)
1431 sdev
->hostdata
= NULL
;
1436 struct scsi_host_template lpfc_template
= {
1437 .module
= THIS_MODULE
,
1438 .name
= LPFC_DRIVER_NAME
,
1440 .queuecommand
= lpfc_queuecommand
,
1441 .eh_abort_handler
= lpfc_abort_handler
,
1442 .eh_device_reset_handler
= lpfc_device_reset_handler
,
1443 .eh_bus_reset_handler
= lpfc_bus_reset_handler
,
1444 .slave_alloc
= lpfc_slave_alloc
,
1445 .slave_configure
= lpfc_slave_configure
,
1446 .slave_destroy
= lpfc_slave_destroy
,
1447 .scan_finished
= lpfc_scan_finished
,
1449 .sg_tablesize
= LPFC_SG_SEG_CNT
,
1450 .cmd_per_lun
= LPFC_CMD_PER_LUN
,
1451 .use_clustering
= ENABLE_CLUSTERING
,
1452 .shost_attrs
= lpfc_hba_attrs
,
1453 .max_sectors
= 0xFFFF,
1456 struct scsi_host_template lpfc_vport_template
= {
1457 .module
= THIS_MODULE
,
1458 .name
= LPFC_DRIVER_NAME
,
1460 .queuecommand
= lpfc_queuecommand
,
1461 .eh_abort_handler
= lpfc_abort_handler
,
1462 .eh_device_reset_handler
= lpfc_device_reset_handler
,
1463 .eh_bus_reset_handler
= lpfc_bus_reset_handler
,
1464 .slave_alloc
= lpfc_slave_alloc
,
1465 .slave_configure
= lpfc_slave_configure
,
1466 .slave_destroy
= lpfc_slave_destroy
,
1467 .scan_finished
= lpfc_scan_finished
,
1469 .sg_tablesize
= LPFC_SG_SEG_CNT
,
1470 .cmd_per_lun
= LPFC_CMD_PER_LUN
,
1471 .use_clustering
= ENABLE_CLUSTERING
,
1472 .shost_attrs
= lpfc_vport_attrs
,
1473 .max_sectors
= 0xFFFF,