1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2011 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 *******************************************************************/
21 #include <linux/pci.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/export.h>
25 #include <linux/delay.h>
26 #include <asm/unaligned.h>
28 #include <scsi/scsi.h>
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_eh.h>
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_tcq.h>
33 #include <scsi/scsi_transport_fc.h>
35 #include "lpfc_version.h"
39 #include "lpfc_sli4.h"
41 #include "lpfc_disc.h"
42 #include "lpfc_scsi.h"
44 #include "lpfc_logmsg.h"
45 #include "lpfc_crtn.h"
46 #include "lpfc_vport.h"
48 #define LPFC_RESET_WAIT 2
49 #define LPFC_ABORT_WAIT 2
53 static char *dif_op_str
[] = {
55 "SCSI_PROT_READ_INSERT",
56 "SCSI_PROT_WRITE_STRIP",
57 "SCSI_PROT_READ_STRIP",
58 "SCSI_PROT_WRITE_INSERT",
59 "SCSI_PROT_READ_PASS",
60 "SCSI_PROT_WRITE_PASS",
63 struct scsi_dif_tuple
{
64 __be16 guard_tag
; /* Checksum */
65 __be16 app_tag
; /* Opaque storage */
66 __be32 ref_tag
; /* Target LBA or indirect LBA */
70 lpfc_release_scsi_buf_s4(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*psb
);
72 lpfc_release_scsi_buf_s3(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*psb
);
75 lpfc_debug_save_data(struct lpfc_hba
*phba
, struct scsi_cmnd
*cmnd
)
78 struct scatterlist
*sgde
= scsi_sglist(cmnd
);
80 if (!_dump_buf_data
) {
81 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
82 "9050 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
89 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
90 "9051 BLKGRD: ERROR: data scatterlist is null\n");
94 dst
= (void *) _dump_buf_data
;
97 memcpy(dst
, src
, sgde
->length
);
104 lpfc_debug_save_dif(struct lpfc_hba
*phba
, struct scsi_cmnd
*cmnd
)
107 struct scatterlist
*sgde
= scsi_prot_sglist(cmnd
);
109 if (!_dump_buf_dif
) {
110 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
111 "9052 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
117 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
118 "9053 BLKGRD: ERROR: prot scatterlist is null\n");
125 memcpy(dst
, src
, sgde
->length
);
127 sgde
= sg_next(sgde
);
132 * lpfc_sli4_set_rsp_sgl_last - Set the last bit in the response sge.
133 * @phba: Pointer to HBA object.
134 * @lpfc_cmd: lpfc scsi command object pointer.
136 * This function is called from the lpfc_prep_task_mgmt_cmd function to
137 * set the last bit in the response sge entry.
140 lpfc_sli4_set_rsp_sgl_last(struct lpfc_hba
*phba
,
141 struct lpfc_scsi_buf
*lpfc_cmd
)
143 struct sli4_sge
*sgl
= (struct sli4_sge
*)lpfc_cmd
->fcp_bpl
;
146 sgl
->word2
= le32_to_cpu(sgl
->word2
);
147 bf_set(lpfc_sli4_sge_last
, sgl
, 1);
148 sgl
->word2
= cpu_to_le32(sgl
->word2
);
153 * lpfc_update_stats - Update statistical data for the command completion
154 * @phba: Pointer to HBA object.
155 * @lpfc_cmd: lpfc scsi command object pointer.
157 * This function is called when there is a command completion and this
158 * function updates the statistical data for the command completion.
161 lpfc_update_stats(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*lpfc_cmd
)
163 struct lpfc_rport_data
*rdata
= lpfc_cmd
->rdata
;
164 struct lpfc_nodelist
*pnode
= rdata
->pnode
;
165 struct scsi_cmnd
*cmd
= lpfc_cmd
->pCmd
;
167 struct Scsi_Host
*shost
= cmd
->device
->host
;
168 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
169 unsigned long latency
;
175 latency
= jiffies_to_msecs((long)jiffies
- (long)lpfc_cmd
->start_time
);
177 spin_lock_irqsave(shost
->host_lock
, flags
);
178 if (!vport
->stat_data_enabled
||
179 vport
->stat_data_blocked
||
182 (phba
->bucket_type
== LPFC_NO_BUCKET
)) {
183 spin_unlock_irqrestore(shost
->host_lock
, flags
);
187 if (phba
->bucket_type
== LPFC_LINEAR_BUCKET
) {
188 i
= (latency
+ phba
->bucket_step
- 1 - phba
->bucket_base
)/
190 /* check array subscript bounds */
193 else if (i
>= LPFC_MAX_BUCKET_COUNT
)
194 i
= LPFC_MAX_BUCKET_COUNT
- 1;
196 for (i
= 0; i
< LPFC_MAX_BUCKET_COUNT
-1; i
++)
197 if (latency
<= (phba
->bucket_base
+
198 ((1<<i
)*phba
->bucket_step
)))
202 pnode
->lat_data
[i
].cmd_count
++;
203 spin_unlock_irqrestore(shost
->host_lock
, flags
);
207 * lpfc_send_sdev_queuedepth_change_event - Posts a queuedepth change event
208 * @phba: Pointer to HBA context object.
209 * @vport: Pointer to vport object.
210 * @ndlp: Pointer to FC node associated with the target.
211 * @lun: Lun number of the scsi device.
212 * @old_val: Old value of the queue depth.
213 * @new_val: New value of the queue depth.
215 * This function sends an event to the mgmt application indicating
216 * there is a change in the scsi device queue depth.
219 lpfc_send_sdev_queuedepth_change_event(struct lpfc_hba
*phba
,
220 struct lpfc_vport
*vport
,
221 struct lpfc_nodelist
*ndlp
,
226 struct lpfc_fast_path_event
*fast_path_evt
;
229 fast_path_evt
= lpfc_alloc_fast_evt(phba
);
233 fast_path_evt
->un
.queue_depth_evt
.scsi_event
.event_type
=
235 fast_path_evt
->un
.queue_depth_evt
.scsi_event
.subcategory
=
236 LPFC_EVENT_VARQUEDEPTH
;
238 /* Report all luns with change in queue depth */
239 fast_path_evt
->un
.queue_depth_evt
.scsi_event
.lun
= lun
;
240 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
)) {
241 memcpy(&fast_path_evt
->un
.queue_depth_evt
.scsi_event
.wwpn
,
242 &ndlp
->nlp_portname
, sizeof(struct lpfc_name
));
243 memcpy(&fast_path_evt
->un
.queue_depth_evt
.scsi_event
.wwnn
,
244 &ndlp
->nlp_nodename
, sizeof(struct lpfc_name
));
247 fast_path_evt
->un
.queue_depth_evt
.oldval
= old_val
;
248 fast_path_evt
->un
.queue_depth_evt
.newval
= new_val
;
249 fast_path_evt
->vport
= vport
;
251 fast_path_evt
->work_evt
.evt
= LPFC_EVT_FASTPATH_MGMT_EVT
;
252 spin_lock_irqsave(&phba
->hbalock
, flags
);
253 list_add_tail(&fast_path_evt
->work_evt
.evt_listp
, &phba
->work_list
);
254 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
255 lpfc_worker_wake_up(phba
);
261 * lpfc_change_queue_depth - Alter scsi device queue depth
262 * @sdev: Pointer the scsi device on which to change the queue depth.
263 * @qdepth: New queue depth to set the sdev to.
264 * @reason: The reason for the queue depth change.
266 * This function is called by the midlayer and the LLD to alter the queue
267 * depth for a scsi device. This function sets the queue depth to the new
268 * value and sends an event out to log the queue depth change.
271 lpfc_change_queue_depth(struct scsi_device
*sdev
, int qdepth
, int reason
)
273 struct lpfc_vport
*vport
= (struct lpfc_vport
*) sdev
->host
->hostdata
;
274 struct lpfc_hba
*phba
= vport
->phba
;
275 struct lpfc_rport_data
*rdata
;
276 unsigned long new_queue_depth
, old_queue_depth
;
278 old_queue_depth
= sdev
->queue_depth
;
279 scsi_adjust_queue_depth(sdev
, scsi_get_tag_type(sdev
), qdepth
);
280 new_queue_depth
= sdev
->queue_depth
;
281 rdata
= sdev
->hostdata
;
283 lpfc_send_sdev_queuedepth_change_event(phba
, vport
,
284 rdata
->pnode
, sdev
->lun
,
287 return sdev
->queue_depth
;
291 * lpfc_rampdown_queue_depth - Post RAMP_DOWN_QUEUE event to worker thread
292 * @phba: The Hba for which this call is being executed.
294 * This routine is called when there is resource error in driver or firmware.
295 * This routine posts WORKER_RAMP_DOWN_QUEUE event for @phba. This routine
296 * posts at most 1 event each second. This routine wakes up worker thread of
297 * @phba to process WORKER_RAM_DOWN_EVENT event.
299 * This routine should be called with no lock held.
302 lpfc_rampdown_queue_depth(struct lpfc_hba
*phba
)
307 spin_lock_irqsave(&phba
->hbalock
, flags
);
308 atomic_inc(&phba
->num_rsrc_err
);
309 phba
->last_rsrc_error_time
= jiffies
;
311 if ((phba
->last_ramp_down_time
+ QUEUE_RAMP_DOWN_INTERVAL
) > jiffies
) {
312 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
316 phba
->last_ramp_down_time
= jiffies
;
318 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
320 spin_lock_irqsave(&phba
->pport
->work_port_lock
, flags
);
321 evt_posted
= phba
->pport
->work_port_events
& WORKER_RAMP_DOWN_QUEUE
;
323 phba
->pport
->work_port_events
|= WORKER_RAMP_DOWN_QUEUE
;
324 spin_unlock_irqrestore(&phba
->pport
->work_port_lock
, flags
);
327 lpfc_worker_wake_up(phba
);
332 * lpfc_rampup_queue_depth - Post RAMP_UP_QUEUE event for worker thread
333 * @phba: The Hba for which this call is being executed.
335 * This routine post WORKER_RAMP_UP_QUEUE event for @phba vport. This routine
336 * post at most 1 event every 5 minute after last_ramp_up_time or
337 * last_rsrc_error_time. This routine wakes up worker thread of @phba
338 * to process WORKER_RAM_DOWN_EVENT event.
340 * This routine should be called with no lock held.
343 lpfc_rampup_queue_depth(struct lpfc_vport
*vport
,
344 uint32_t queue_depth
)
347 struct lpfc_hba
*phba
= vport
->phba
;
349 atomic_inc(&phba
->num_cmd_success
);
351 if (vport
->cfg_lun_queue_depth
<= queue_depth
)
353 spin_lock_irqsave(&phba
->hbalock
, flags
);
354 if (time_before(jiffies
,
355 phba
->last_ramp_up_time
+ QUEUE_RAMP_UP_INTERVAL
) ||
357 phba
->last_rsrc_error_time
+ QUEUE_RAMP_UP_INTERVAL
)) {
358 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
361 phba
->last_ramp_up_time
= jiffies
;
362 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
364 spin_lock_irqsave(&phba
->pport
->work_port_lock
, flags
);
365 evt_posted
= phba
->pport
->work_port_events
& WORKER_RAMP_UP_QUEUE
;
367 phba
->pport
->work_port_events
|= WORKER_RAMP_UP_QUEUE
;
368 spin_unlock_irqrestore(&phba
->pport
->work_port_lock
, flags
);
371 lpfc_worker_wake_up(phba
);
376 * lpfc_ramp_down_queue_handler - WORKER_RAMP_DOWN_QUEUE event handler
377 * @phba: The Hba for which this call is being executed.
379 * This routine is called to process WORKER_RAMP_DOWN_QUEUE event for worker
380 * thread.This routine reduces queue depth for all scsi device on each vport
381 * associated with @phba.
384 lpfc_ramp_down_queue_handler(struct lpfc_hba
*phba
)
386 struct lpfc_vport
**vports
;
387 struct Scsi_Host
*shost
;
388 struct scsi_device
*sdev
;
389 unsigned long new_queue_depth
;
390 unsigned long num_rsrc_err
, num_cmd_success
;
393 num_rsrc_err
= atomic_read(&phba
->num_rsrc_err
);
394 num_cmd_success
= atomic_read(&phba
->num_cmd_success
);
396 vports
= lpfc_create_vport_work_array(phba
);
398 for (i
= 0; i
<= phba
->max_vports
&& vports
[i
] != NULL
; i
++) {
399 shost
= lpfc_shost_from_vport(vports
[i
]);
400 shost_for_each_device(sdev
, shost
) {
402 sdev
->queue_depth
* num_rsrc_err
/
403 (num_rsrc_err
+ num_cmd_success
);
404 if (!new_queue_depth
)
405 new_queue_depth
= sdev
->queue_depth
- 1;
407 new_queue_depth
= sdev
->queue_depth
-
409 lpfc_change_queue_depth(sdev
, new_queue_depth
,
410 SCSI_QDEPTH_DEFAULT
);
413 lpfc_destroy_vport_work_array(phba
, vports
);
414 atomic_set(&phba
->num_rsrc_err
, 0);
415 atomic_set(&phba
->num_cmd_success
, 0);
419 * lpfc_ramp_up_queue_handler - WORKER_RAMP_UP_QUEUE event handler
420 * @phba: The Hba for which this call is being executed.
422 * This routine is called to process WORKER_RAMP_UP_QUEUE event for worker
423 * thread.This routine increases queue depth for all scsi device on each vport
424 * associated with @phba by 1. This routine also sets @phba num_rsrc_err and
425 * num_cmd_success to zero.
428 lpfc_ramp_up_queue_handler(struct lpfc_hba
*phba
)
430 struct lpfc_vport
**vports
;
431 struct Scsi_Host
*shost
;
432 struct scsi_device
*sdev
;
435 vports
= lpfc_create_vport_work_array(phba
);
437 for (i
= 0; i
<= phba
->max_vports
&& vports
[i
] != NULL
; i
++) {
438 shost
= lpfc_shost_from_vport(vports
[i
]);
439 shost_for_each_device(sdev
, shost
) {
440 if (vports
[i
]->cfg_lun_queue_depth
<=
443 lpfc_change_queue_depth(sdev
,
445 SCSI_QDEPTH_RAMP_UP
);
448 lpfc_destroy_vport_work_array(phba
, vports
);
449 atomic_set(&phba
->num_rsrc_err
, 0);
450 atomic_set(&phba
->num_cmd_success
, 0);
454 * lpfc_scsi_dev_block - set all scsi hosts to block state
455 * @phba: Pointer to HBA context object.
457 * This function walks vport list and set each SCSI host to block state
458 * by invoking fc_remote_port_delete() routine. This function is invoked
459 * with EEH when device's PCI slot has been permanently disabled.
462 lpfc_scsi_dev_block(struct lpfc_hba
*phba
)
464 struct lpfc_vport
**vports
;
465 struct Scsi_Host
*shost
;
466 struct scsi_device
*sdev
;
467 struct fc_rport
*rport
;
470 vports
= lpfc_create_vport_work_array(phba
);
472 for (i
= 0; i
<= phba
->max_vports
&& vports
[i
] != NULL
; i
++) {
473 shost
= lpfc_shost_from_vport(vports
[i
]);
474 shost_for_each_device(sdev
, shost
) {
475 rport
= starget_to_rport(scsi_target(sdev
));
476 fc_remote_port_delete(rport
);
479 lpfc_destroy_vport_work_array(phba
, vports
);
483 * lpfc_new_scsi_buf_s3 - Scsi buffer allocator for HBA with SLI3 IF spec
484 * @vport: The virtual port for which this call being executed.
485 * @num_to_allocate: The requested number of buffers to allocate.
487 * This routine allocates a scsi buffer for device with SLI-3 interface spec,
488 * the scsi buffer contains all the necessary information needed to initiate
489 * a SCSI I/O. The non-DMAable buffer region contains information to build
490 * the IOCB. The DMAable region contains memory for the FCP CMND, FCP RSP,
491 * and the initial BPL. In addition to allocating memory, the FCP CMND and
492 * FCP RSP BDEs are setup in the BPL and the BPL BDE is setup in the IOCB.
495 * int - number of scsi buffers that were allocated.
496 * 0 = failure, less than num_to_alloc is a partial failure.
499 lpfc_new_scsi_buf_s3(struct lpfc_vport
*vport
, int num_to_alloc
)
501 struct lpfc_hba
*phba
= vport
->phba
;
502 struct lpfc_scsi_buf
*psb
;
503 struct ulp_bde64
*bpl
;
505 dma_addr_t pdma_phys_fcp_cmd
;
506 dma_addr_t pdma_phys_fcp_rsp
;
507 dma_addr_t pdma_phys_bpl
;
511 for (bcnt
= 0; bcnt
< num_to_alloc
; bcnt
++) {
512 psb
= kzalloc(sizeof(struct lpfc_scsi_buf
), GFP_KERNEL
);
517 * Get memory from the pci pool to map the virt space to pci
518 * bus space for an I/O. The DMA buffer includes space for the
519 * struct fcp_cmnd, struct fcp_rsp and the number of bde's
520 * necessary to support the sg_tablesize.
522 psb
->data
= pci_pool_alloc(phba
->lpfc_scsi_dma_buf_pool
,
523 GFP_KERNEL
, &psb
->dma_handle
);
529 /* Initialize virtual ptrs to dma_buf region. */
530 memset(psb
->data
, 0, phba
->cfg_sg_dma_buf_size
);
532 /* Allocate iotag for psb->cur_iocbq. */
533 iotag
= lpfc_sli_next_iotag(phba
, &psb
->cur_iocbq
);
535 pci_pool_free(phba
->lpfc_scsi_dma_buf_pool
,
536 psb
->data
, psb
->dma_handle
);
540 psb
->cur_iocbq
.iocb_flag
|= LPFC_IO_FCP
;
542 psb
->fcp_cmnd
= psb
->data
;
543 psb
->fcp_rsp
= psb
->data
+ sizeof(struct fcp_cmnd
);
544 psb
->fcp_bpl
= psb
->data
+ sizeof(struct fcp_cmnd
) +
545 sizeof(struct fcp_rsp
);
547 /* Initialize local short-hand pointers. */
549 pdma_phys_fcp_cmd
= psb
->dma_handle
;
550 pdma_phys_fcp_rsp
= psb
->dma_handle
+ sizeof(struct fcp_cmnd
);
551 pdma_phys_bpl
= psb
->dma_handle
+ sizeof(struct fcp_cmnd
) +
552 sizeof(struct fcp_rsp
);
555 * The first two bdes are the FCP_CMD and FCP_RSP. The balance
556 * are sg list bdes. Initialize the first two and leave the
557 * rest for queuecommand.
559 bpl
[0].addrHigh
= le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd
));
560 bpl
[0].addrLow
= le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd
));
561 bpl
[0].tus
.f
.bdeSize
= sizeof(struct fcp_cmnd
);
562 bpl
[0].tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
563 bpl
[0].tus
.w
= le32_to_cpu(bpl
[0].tus
.w
);
565 /* Setup the physical region for the FCP RSP */
566 bpl
[1].addrHigh
= le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp
));
567 bpl
[1].addrLow
= le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp
));
568 bpl
[1].tus
.f
.bdeSize
= sizeof(struct fcp_rsp
);
569 bpl
[1].tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
570 bpl
[1].tus
.w
= le32_to_cpu(bpl
[1].tus
.w
);
573 * Since the IOCB for the FCP I/O is built into this
574 * lpfc_scsi_buf, initialize it with all known data now.
576 iocb
= &psb
->cur_iocbq
.iocb
;
577 iocb
->un
.fcpi64
.bdl
.ulpIoTag32
= 0;
578 if ((phba
->sli_rev
== 3) &&
579 !(phba
->sli3_options
& LPFC_SLI3_BG_ENABLED
)) {
580 /* fill in immediate fcp command BDE */
581 iocb
->un
.fcpi64
.bdl
.bdeFlags
= BUFF_TYPE_BDE_IMMED
;
582 iocb
->un
.fcpi64
.bdl
.bdeSize
= sizeof(struct fcp_cmnd
);
583 iocb
->un
.fcpi64
.bdl
.addrLow
= offsetof(IOCB_t
,
585 iocb
->un
.fcpi64
.bdl
.addrHigh
= 0;
586 iocb
->ulpBdeCount
= 0;
588 /* fill in response BDE */
589 iocb
->unsli3
.fcp_ext
.rbde
.tus
.f
.bdeFlags
=
591 iocb
->unsli3
.fcp_ext
.rbde
.tus
.f
.bdeSize
=
592 sizeof(struct fcp_rsp
);
593 iocb
->unsli3
.fcp_ext
.rbde
.addrLow
=
594 putPaddrLow(pdma_phys_fcp_rsp
);
595 iocb
->unsli3
.fcp_ext
.rbde
.addrHigh
=
596 putPaddrHigh(pdma_phys_fcp_rsp
);
598 iocb
->un
.fcpi64
.bdl
.bdeFlags
= BUFF_TYPE_BLP_64
;
599 iocb
->un
.fcpi64
.bdl
.bdeSize
=
600 (2 * sizeof(struct ulp_bde64
));
601 iocb
->un
.fcpi64
.bdl
.addrLow
=
602 putPaddrLow(pdma_phys_bpl
);
603 iocb
->un
.fcpi64
.bdl
.addrHigh
=
604 putPaddrHigh(pdma_phys_bpl
);
605 iocb
->ulpBdeCount
= 1;
608 iocb
->ulpClass
= CLASS3
;
609 psb
->status
= IOSTAT_SUCCESS
;
610 /* Put it back into the SCSI buffer list */
611 psb
->cur_iocbq
.context1
= psb
;
612 lpfc_release_scsi_buf_s3(phba
, psb
);
620 * lpfc_sli4_vport_delete_fcp_xri_aborted -Remove all ndlp references for vport
621 * @vport: pointer to lpfc vport data structure.
623 * This routine is invoked by the vport cleanup for deletions and the cleanup
624 * for an ndlp on removal.
627 lpfc_sli4_vport_delete_fcp_xri_aborted(struct lpfc_vport
*vport
)
629 struct lpfc_hba
*phba
= vport
->phba
;
630 struct lpfc_scsi_buf
*psb
, *next_psb
;
631 unsigned long iflag
= 0;
633 spin_lock_irqsave(&phba
->hbalock
, iflag
);
634 spin_lock(&phba
->sli4_hba
.abts_scsi_buf_list_lock
);
635 list_for_each_entry_safe(psb
, next_psb
,
636 &phba
->sli4_hba
.lpfc_abts_scsi_buf_list
, list
) {
637 if (psb
->rdata
&& psb
->rdata
->pnode
638 && psb
->rdata
->pnode
->vport
== vport
)
641 spin_unlock(&phba
->sli4_hba
.abts_scsi_buf_list_lock
);
642 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
646 * lpfc_sli4_fcp_xri_aborted - Fast-path process of fcp xri abort
647 * @phba: pointer to lpfc hba data structure.
648 * @axri: pointer to the fcp xri abort wcqe structure.
650 * This routine is invoked by the worker thread to process a SLI4 fast-path
654 lpfc_sli4_fcp_xri_aborted(struct lpfc_hba
*phba
,
655 struct sli4_wcqe_xri_aborted
*axri
)
657 uint16_t xri
= bf_get(lpfc_wcqe_xa_xri
, axri
);
658 uint16_t rxid
= bf_get(lpfc_wcqe_xa_remote_xid
, axri
);
659 struct lpfc_scsi_buf
*psb
, *next_psb
;
660 unsigned long iflag
= 0;
661 struct lpfc_iocbq
*iocbq
;
663 struct lpfc_nodelist
*ndlp
;
665 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
667 spin_lock_irqsave(&phba
->hbalock
, iflag
);
668 spin_lock(&phba
->sli4_hba
.abts_scsi_buf_list_lock
);
669 list_for_each_entry_safe(psb
, next_psb
,
670 &phba
->sli4_hba
.lpfc_abts_scsi_buf_list
, list
) {
671 if (psb
->cur_iocbq
.sli4_xritag
== xri
) {
672 list_del(&psb
->list
);
674 psb
->status
= IOSTAT_SUCCESS
;
676 &phba
->sli4_hba
.abts_scsi_buf_list_lock
);
677 if (psb
->rdata
&& psb
->rdata
->pnode
)
678 ndlp
= psb
->rdata
->pnode
;
682 rrq_empty
= list_empty(&phba
->active_rrq_list
);
683 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
685 lpfc_set_rrq_active(phba
, ndlp
, xri
, rxid
, 1);
686 lpfc_release_scsi_buf_s4(phba
, psb
);
688 lpfc_worker_wake_up(phba
);
692 spin_unlock(&phba
->sli4_hba
.abts_scsi_buf_list_lock
);
693 for (i
= 1; i
<= phba
->sli
.last_iotag
; i
++) {
694 iocbq
= phba
->sli
.iocbq_lookup
[i
];
696 if (!(iocbq
->iocb_flag
& LPFC_IO_FCP
) ||
697 (iocbq
->iocb_flag
& LPFC_IO_LIBDFC
))
699 if (iocbq
->sli4_xritag
!= xri
)
701 psb
= container_of(iocbq
, struct lpfc_scsi_buf
, cur_iocbq
);
703 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
705 lpfc_worker_wake_up(phba
);
709 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
713 * lpfc_sli4_repost_scsi_sgl_list - Repsot the Scsi buffers sgl pages as block
714 * @phba: pointer to lpfc hba data structure.
716 * This routine walks the list of scsi buffers that have been allocated and
717 * repost them to the HBA by using SGL block post. This is needed after a
718 * pci_function_reset/warm_start or start. The lpfc_hba_down_post_s4 routine
719 * is responsible for moving all scsi buffers on the lpfc_abts_scsi_sgl_list
720 * to the lpfc_scsi_buf_list. If the repost fails, reject all scsi buffers.
722 * Returns: 0 = success, non-zero failure.
725 lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba
*phba
)
727 struct lpfc_scsi_buf
*psb
;
728 int index
, status
, bcnt
= 0, rcnt
= 0, rc
= 0;
731 for (index
= 0; index
< phba
->sli4_hba
.scsi_xri_cnt
; index
++) {
732 psb
= phba
->sli4_hba
.lpfc_scsi_psb_array
[index
];
734 /* Remove from SCSI buffer list */
735 list_del(&psb
->list
);
736 /* Add it to a local SCSI buffer list */
737 list_add_tail(&psb
->list
, &sblist
);
738 if (++rcnt
== LPFC_NEMBED_MBOX_SGL_CNT
) {
743 /* A hole present in the XRI array, need to skip */
746 if (index
== phba
->sli4_hba
.scsi_xri_cnt
- 1)
747 /* End of XRI array for SCSI buffer, complete */
750 /* Continue until collect up to a nembed page worth of sgls */
753 /* Now, post the SCSI buffer list sgls as a block */
754 if (!phba
->sli4_hba
.extents_in_use
)
755 status
= lpfc_sli4_post_scsi_sgl_block(phba
,
759 status
= lpfc_sli4_post_scsi_sgl_blk_ext(phba
,
762 /* Reset SCSI buffer count for next round of posting */
764 while (!list_empty(&sblist
)) {
765 list_remove_head(&sblist
, psb
, struct lpfc_scsi_buf
,
768 /* Put this back on the abort scsi list */
773 psb
->status
= IOSTAT_SUCCESS
;
775 /* Put it back into the SCSI buffer list */
776 lpfc_release_scsi_buf_s4(phba
, psb
);
783 * lpfc_new_scsi_buf_s4 - Scsi buffer allocator for HBA with SLI4 IF spec
784 * @vport: The virtual port for which this call being executed.
785 * @num_to_allocate: The requested number of buffers to allocate.
787 * This routine allocates a scsi buffer for device with SLI-4 interface spec,
788 * the scsi buffer contains all the necessary information needed to initiate
792 * int - number of scsi buffers that were allocated.
793 * 0 = failure, less than num_to_alloc is a partial failure.
796 lpfc_new_scsi_buf_s4(struct lpfc_vport
*vport
, int num_to_alloc
)
798 struct lpfc_hba
*phba
= vport
->phba
;
799 struct lpfc_scsi_buf
*psb
;
800 struct sli4_sge
*sgl
;
802 dma_addr_t pdma_phys_fcp_cmd
;
803 dma_addr_t pdma_phys_fcp_rsp
;
804 dma_addr_t pdma_phys_bpl
, pdma_phys_bpl1
;
805 uint16_t iotag
, last_xritag
= NO_XRI
, lxri
= 0;
806 int status
= 0, index
;
808 int non_sequential_xri
= 0;
811 for (bcnt
= 0; bcnt
< num_to_alloc
; bcnt
++) {
812 psb
= kzalloc(sizeof(struct lpfc_scsi_buf
), GFP_KERNEL
);
817 * Get memory from the pci pool to map the virt space to pci bus
818 * space for an I/O. The DMA buffer includes space for the
819 * struct fcp_cmnd, struct fcp_rsp and the number of bde's
820 * necessary to support the sg_tablesize.
822 psb
->data
= pci_pool_alloc(phba
->lpfc_scsi_dma_buf_pool
,
823 GFP_KERNEL
, &psb
->dma_handle
);
829 /* Initialize virtual ptrs to dma_buf region. */
830 memset(psb
->data
, 0, phba
->cfg_sg_dma_buf_size
);
832 /* Allocate iotag for psb->cur_iocbq. */
833 iotag
= lpfc_sli_next_iotag(phba
, &psb
->cur_iocbq
);
835 pci_pool_free(phba
->lpfc_scsi_dma_buf_pool
,
836 psb
->data
, psb
->dma_handle
);
841 lxri
= lpfc_sli4_next_xritag(phba
);
842 if (lxri
== NO_XRI
) {
843 pci_pool_free(phba
->lpfc_scsi_dma_buf_pool
,
844 psb
->data
, psb
->dma_handle
);
848 psb
->cur_iocbq
.sli4_lxritag
= lxri
;
849 psb
->cur_iocbq
.sli4_xritag
= phba
->sli4_hba
.xri_ids
[lxri
];
850 if (last_xritag
!= NO_XRI
851 && psb
->cur_iocbq
.sli4_xritag
!= (last_xritag
+1)) {
852 non_sequential_xri
= 1;
854 list_add_tail(&psb
->list
, &sblist
);
855 last_xritag
= psb
->cur_iocbq
.sli4_xritag
;
857 index
= phba
->sli4_hba
.scsi_xri_cnt
++;
858 psb
->cur_iocbq
.iocb_flag
|= LPFC_IO_FCP
;
860 psb
->fcp_bpl
= psb
->data
;
861 psb
->fcp_cmnd
= (psb
->data
+ phba
->cfg_sg_dma_buf_size
)
862 - (sizeof(struct fcp_cmnd
) + sizeof(struct fcp_rsp
));
863 psb
->fcp_rsp
= (struct fcp_rsp
*)((uint8_t *)psb
->fcp_cmnd
+
864 sizeof(struct fcp_cmnd
));
866 /* Initialize local short-hand pointers. */
867 sgl
= (struct sli4_sge
*)psb
->fcp_bpl
;
868 pdma_phys_bpl
= psb
->dma_handle
;
870 (psb
->dma_handle
+ phba
->cfg_sg_dma_buf_size
)
871 - (sizeof(struct fcp_cmnd
) + sizeof(struct fcp_rsp
));
872 pdma_phys_fcp_rsp
= pdma_phys_fcp_cmd
+ sizeof(struct fcp_cmnd
);
875 * The first two bdes are the FCP_CMD and FCP_RSP. The balance
876 * are sg list bdes. Initialize the first two and leave the
877 * rest for queuecommand.
879 sgl
->addr_hi
= cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd
));
880 sgl
->addr_lo
= cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd
));
881 sgl
->word2
= le32_to_cpu(sgl
->word2
);
882 bf_set(lpfc_sli4_sge_last
, sgl
, 0);
883 sgl
->word2
= cpu_to_le32(sgl
->word2
);
884 sgl
->sge_len
= cpu_to_le32(sizeof(struct fcp_cmnd
));
887 /* Setup the physical region for the FCP RSP */
888 sgl
->addr_hi
= cpu_to_le32(putPaddrHigh(pdma_phys_fcp_rsp
));
889 sgl
->addr_lo
= cpu_to_le32(putPaddrLow(pdma_phys_fcp_rsp
));
890 sgl
->word2
= le32_to_cpu(sgl
->word2
);
891 bf_set(lpfc_sli4_sge_last
, sgl
, 1);
892 sgl
->word2
= cpu_to_le32(sgl
->word2
);
893 sgl
->sge_len
= cpu_to_le32(sizeof(struct fcp_rsp
));
896 * Since the IOCB for the FCP I/O is built into this
897 * lpfc_scsi_buf, initialize it with all known data now.
899 iocb
= &psb
->cur_iocbq
.iocb
;
900 iocb
->un
.fcpi64
.bdl
.ulpIoTag32
= 0;
901 iocb
->un
.fcpi64
.bdl
.bdeFlags
= BUFF_TYPE_BDE_64
;
902 /* setting the BLP size to 2 * sizeof BDE may not be correct.
903 * We are setting the bpl to point to out sgl. An sgl's
904 * entries are 16 bytes, a bpl entries are 12 bytes.
906 iocb
->un
.fcpi64
.bdl
.bdeSize
= sizeof(struct fcp_cmnd
);
907 iocb
->un
.fcpi64
.bdl
.addrLow
= putPaddrLow(pdma_phys_fcp_cmd
);
908 iocb
->un
.fcpi64
.bdl
.addrHigh
= putPaddrHigh(pdma_phys_fcp_cmd
);
909 iocb
->ulpBdeCount
= 1;
911 iocb
->ulpClass
= CLASS3
;
912 psb
->cur_iocbq
.context1
= psb
;
913 if (phba
->cfg_sg_dma_buf_size
> SGL_PAGE_SIZE
)
914 pdma_phys_bpl1
= pdma_phys_bpl
+ SGL_PAGE_SIZE
;
917 psb
->dma_phys_bpl
= pdma_phys_bpl
;
918 phba
->sli4_hba
.lpfc_scsi_psb_array
[index
] = psb
;
919 if (non_sequential_xri
) {
920 status
= lpfc_sli4_post_sgl(phba
, pdma_phys_bpl
,
922 psb
->cur_iocbq
.sli4_xritag
);
924 /* Put this back on the abort scsi list */
928 psb
->status
= IOSTAT_SUCCESS
;
930 /* Put it back into the SCSI buffer list */
931 lpfc_release_scsi_buf_s4(phba
, psb
);
936 if (!phba
->sli4_hba
.extents_in_use
)
937 status
= lpfc_sli4_post_scsi_sgl_block(phba
,
941 status
= lpfc_sli4_post_scsi_sgl_blk_ext(phba
,
946 lpfc_printf_log(phba
, KERN_ERR
, LOG_MBOX
| LOG_SLI
,
947 "3021 SCSI SGL post error %d\n",
951 /* Reset SCSI buffer count for next round of posting */
952 while (!list_empty(&sblist
)) {
953 list_remove_head(&sblist
, psb
, struct lpfc_scsi_buf
,
956 /* Put this back on the abort scsi list */
960 psb
->status
= IOSTAT_SUCCESS
;
962 /* Put it back into the SCSI buffer list */
963 lpfc_release_scsi_buf_s4(phba
, psb
);
967 return bcnt
+ non_sequential_xri
;
971 * lpfc_new_scsi_buf - Wrapper funciton for scsi buffer allocator
972 * @vport: The virtual port for which this call being executed.
973 * @num_to_allocate: The requested number of buffers to allocate.
975 * This routine wraps the actual SCSI buffer allocator function pointer from
976 * the lpfc_hba struct.
979 * int - number of scsi buffers that were allocated.
980 * 0 = failure, less than num_to_alloc is a partial failure.
983 lpfc_new_scsi_buf(struct lpfc_vport
*vport
, int num_to_alloc
)
985 return vport
->phba
->lpfc_new_scsi_buf(vport
, num_to_alloc
);
989 * lpfc_get_scsi_buf_s3 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
990 * @phba: The HBA for which this call is being executed.
992 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
993 * and returns to caller.
997 * Pointer to lpfc_scsi_buf - Success
999 static struct lpfc_scsi_buf
*
1000 lpfc_get_scsi_buf_s3(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
)
1002 struct lpfc_scsi_buf
* lpfc_cmd
= NULL
;
1003 struct list_head
*scsi_buf_list
= &phba
->lpfc_scsi_buf_list
;
1004 unsigned long iflag
= 0;
1006 spin_lock_irqsave(&phba
->scsi_buf_list_lock
, iflag
);
1007 list_remove_head(scsi_buf_list
, lpfc_cmd
, struct lpfc_scsi_buf
, list
);
1009 lpfc_cmd
->seg_cnt
= 0;
1010 lpfc_cmd
->nonsg_phys
= 0;
1011 lpfc_cmd
->prot_seg_cnt
= 0;
1013 spin_unlock_irqrestore(&phba
->scsi_buf_list_lock
, iflag
);
1017 * lpfc_get_scsi_buf_s4 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
1018 * @phba: The HBA for which this call is being executed.
1020 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
1021 * and returns to caller.
1025 * Pointer to lpfc_scsi_buf - Success
1027 static struct lpfc_scsi_buf
*
1028 lpfc_get_scsi_buf_s4(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
)
1030 struct lpfc_scsi_buf
*lpfc_cmd
;
1031 unsigned long iflag
= 0;
1034 spin_lock_irqsave(&phba
->scsi_buf_list_lock
, iflag
);
1035 list_for_each_entry(lpfc_cmd
, &phba
->lpfc_scsi_buf_list
,
1037 if (lpfc_test_rrq_active(phba
, ndlp
,
1038 lpfc_cmd
->cur_iocbq
.sli4_xritag
))
1040 list_del(&lpfc_cmd
->list
);
1042 lpfc_cmd
->seg_cnt
= 0;
1043 lpfc_cmd
->nonsg_phys
= 0;
1044 lpfc_cmd
->prot_seg_cnt
= 0;
1047 spin_unlock_irqrestore(&phba
->scsi_buf_list_lock
,
1055 * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
1056 * @phba: The HBA for which this call is being executed.
1058 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
1059 * and returns to caller.
1063 * Pointer to lpfc_scsi_buf - Success
1065 static struct lpfc_scsi_buf
*
1066 lpfc_get_scsi_buf(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
)
1068 return phba
->lpfc_get_scsi_buf(phba
, ndlp
);
1072 * lpfc_release_scsi_buf - Return a scsi buffer back to hba scsi buf list
1073 * @phba: The Hba for which this call is being executed.
1074 * @psb: The scsi buffer which is being released.
1076 * This routine releases @psb scsi buffer by adding it to tail of @phba
1077 * lpfc_scsi_buf_list list.
1080 lpfc_release_scsi_buf_s3(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*psb
)
1082 unsigned long iflag
= 0;
1084 spin_lock_irqsave(&phba
->scsi_buf_list_lock
, iflag
);
1086 list_add_tail(&psb
->list
, &phba
->lpfc_scsi_buf_list
);
1087 spin_unlock_irqrestore(&phba
->scsi_buf_list_lock
, iflag
);
1091 * lpfc_release_scsi_buf_s4: Return a scsi buffer back to hba scsi buf list.
1092 * @phba: The Hba for which this call is being executed.
1093 * @psb: The scsi buffer which is being released.
1095 * This routine releases @psb scsi buffer by adding it to tail of @phba
1096 * lpfc_scsi_buf_list list. For SLI4 XRI's are tied to the scsi buffer
1097 * and cannot be reused for at least RA_TOV amount of time if it was
1101 lpfc_release_scsi_buf_s4(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*psb
)
1103 unsigned long iflag
= 0;
1105 if (psb
->exch_busy
) {
1106 spin_lock_irqsave(&phba
->sli4_hba
.abts_scsi_buf_list_lock
,
1109 list_add_tail(&psb
->list
,
1110 &phba
->sli4_hba
.lpfc_abts_scsi_buf_list
);
1111 spin_unlock_irqrestore(&phba
->sli4_hba
.abts_scsi_buf_list_lock
,
1115 spin_lock_irqsave(&phba
->scsi_buf_list_lock
, iflag
);
1117 list_add_tail(&psb
->list
, &phba
->lpfc_scsi_buf_list
);
1118 spin_unlock_irqrestore(&phba
->scsi_buf_list_lock
, iflag
);
1123 * lpfc_release_scsi_buf: Return a scsi buffer back to hba scsi buf list.
1124 * @phba: The Hba for which this call is being executed.
1125 * @psb: The scsi buffer which is being released.
1127 * This routine releases @psb scsi buffer by adding it to tail of @phba
1128 * lpfc_scsi_buf_list list.
1131 lpfc_release_scsi_buf(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*psb
)
1134 phba
->lpfc_release_scsi_buf(phba
, psb
);
1138 * lpfc_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec
1139 * @phba: The Hba for which this call is being executed.
1140 * @lpfc_cmd: The scsi buffer which is going to be mapped.
1142 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
1143 * field of @lpfc_cmd for device with SLI-3 interface spec. This routine scans
1144 * through sg elements and format the bdea. This routine also initializes all
1145 * IOCB fields which are dependent on scsi command request buffer.
1152 lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*lpfc_cmd
)
1154 struct scsi_cmnd
*scsi_cmnd
= lpfc_cmd
->pCmd
;
1155 struct scatterlist
*sgel
= NULL
;
1156 struct fcp_cmnd
*fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
1157 struct ulp_bde64
*bpl
= lpfc_cmd
->fcp_bpl
;
1158 struct lpfc_iocbq
*iocbq
= &lpfc_cmd
->cur_iocbq
;
1159 IOCB_t
*iocb_cmd
= &lpfc_cmd
->cur_iocbq
.iocb
;
1160 struct ulp_bde64
*data_bde
= iocb_cmd
->unsli3
.fcp_ext
.dbde
;
1161 dma_addr_t physaddr
;
1162 uint32_t num_bde
= 0;
1163 int nseg
, datadir
= scsi_cmnd
->sc_data_direction
;
1166 * There are three possibilities here - use scatter-gather segment, use
1167 * the single mapping, or neither. Start the lpfc command prep by
1168 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
1172 if (scsi_sg_count(scsi_cmnd
)) {
1174 * The driver stores the segment count returned from pci_map_sg
1175 * because this a count of dma-mappings used to map the use_sg
1176 * pages. They are not guaranteed to be the same for those
1177 * architectures that implement an IOMMU.
1180 nseg
= dma_map_sg(&phba
->pcidev
->dev
, scsi_sglist(scsi_cmnd
),
1181 scsi_sg_count(scsi_cmnd
), datadir
);
1182 if (unlikely(!nseg
))
1185 lpfc_cmd
->seg_cnt
= nseg
;
1186 if (lpfc_cmd
->seg_cnt
> phba
->cfg_sg_seg_cnt
) {
1187 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1188 "9064 BLKGRD: %s: Too many sg segments from "
1189 "dma_map_sg. Config %d, seg_cnt %d\n",
1190 __func__
, phba
->cfg_sg_seg_cnt
,
1192 scsi_dma_unmap(scsi_cmnd
);
1197 * The driver established a maximum scatter-gather segment count
1198 * during probe that limits the number of sg elements in any
1199 * single scsi command. Just run through the seg_cnt and format
1201 * When using SLI-3 the driver will try to fit all the BDEs into
1202 * the IOCB. If it can't then the BDEs get added to a BPL as it
1203 * does for SLI-2 mode.
1205 scsi_for_each_sg(scsi_cmnd
, sgel
, nseg
, num_bde
) {
1206 physaddr
= sg_dma_address(sgel
);
1207 if (phba
->sli_rev
== 3 &&
1208 !(phba
->sli3_options
& LPFC_SLI3_BG_ENABLED
) &&
1209 !(iocbq
->iocb_flag
& DSS_SECURITY_OP
) &&
1210 nseg
<= LPFC_EXT_DATA_BDE_COUNT
) {
1211 data_bde
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
1212 data_bde
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
1213 data_bde
->addrLow
= putPaddrLow(physaddr
);
1214 data_bde
->addrHigh
= putPaddrHigh(physaddr
);
1217 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
1218 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
1219 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
1221 le32_to_cpu(putPaddrLow(physaddr
));
1223 le32_to_cpu(putPaddrHigh(physaddr
));
1230 * Finish initializing those IOCB fields that are dependent on the
1231 * scsi_cmnd request_buffer. Note that for SLI-2 the bdeSize is
1232 * explicitly reinitialized and for SLI-3 the extended bde count is
1233 * explicitly reinitialized since all iocb memory resources are reused.
1235 if (phba
->sli_rev
== 3 &&
1236 !(phba
->sli3_options
& LPFC_SLI3_BG_ENABLED
) &&
1237 !(iocbq
->iocb_flag
& DSS_SECURITY_OP
)) {
1238 if (num_bde
> LPFC_EXT_DATA_BDE_COUNT
) {
1240 * The extended IOCB format can only fit 3 BDE or a BPL.
1241 * This I/O has more than 3 BDE so the 1st data bde will
1242 * be a BPL that is filled in here.
1244 physaddr
= lpfc_cmd
->dma_handle
;
1245 data_bde
->tus
.f
.bdeFlags
= BUFF_TYPE_BLP_64
;
1246 data_bde
->tus
.f
.bdeSize
= (num_bde
*
1247 sizeof(struct ulp_bde64
));
1248 physaddr
+= (sizeof(struct fcp_cmnd
) +
1249 sizeof(struct fcp_rsp
) +
1250 (2 * sizeof(struct ulp_bde64
)));
1251 data_bde
->addrHigh
= putPaddrHigh(physaddr
);
1252 data_bde
->addrLow
= putPaddrLow(physaddr
);
1253 /* ebde count includes the response bde and data bpl */
1254 iocb_cmd
->unsli3
.fcp_ext
.ebde_count
= 2;
1256 /* ebde count includes the response bde and data bdes */
1257 iocb_cmd
->unsli3
.fcp_ext
.ebde_count
= (num_bde
+ 1);
1260 iocb_cmd
->un
.fcpi64
.bdl
.bdeSize
=
1261 ((num_bde
+ 2) * sizeof(struct ulp_bde64
));
1262 iocb_cmd
->unsli3
.fcp_ext
.ebde_count
= (num_bde
+ 1);
1264 fcp_cmnd
->fcpDl
= cpu_to_be32(scsi_bufflen(scsi_cmnd
));
1267 * Due to difference in data length between DIF/non-DIF paths,
1268 * we need to set word 4 of IOCB here
1270 iocb_cmd
->un
.fcpi
.fcpi_parm
= scsi_bufflen(scsi_cmnd
);
1274 static inline unsigned
1275 lpfc_cmd_blksize(struct scsi_cmnd
*sc
)
1277 return sc
->device
->sector_size
;
1280 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1282 * Given a scsi cmnd, determine the BlockGuard tags to be used with it
1283 * @sc: The SCSI command to examine
1284 * @reftag: (out) BlockGuard reference tag for transmitted data
1285 * @apptag: (out) BlockGuard application tag for transmitted data
1286 * @new_guard (in) Value to replace CRC with if needed
1288 * Returns (1) if error injection was performed, (0) otherwise
1291 lpfc_bg_err_inject(struct lpfc_hba
*phba
, struct scsi_cmnd
*sc
,
1292 uint32_t *reftag
, uint16_t *apptag
, uint32_t new_guard
)
1294 struct scatterlist
*sgpe
; /* s/g prot entry */
1295 struct scatterlist
*sgde
; /* s/g data entry */
1296 struct scsi_dif_tuple
*src
;
1297 uint32_t op
= scsi_get_prot_op(sc
);
1303 if (op
== SCSI_PROT_NORMAL
)
1306 lba
= scsi_get_lba(sc
);
1307 if (phba
->lpfc_injerr_lba
!= LPFC_INJERR_LBA_OFF
) {
1308 blksize
= lpfc_cmd_blksize(sc
);
1309 numblks
= (scsi_bufflen(sc
) + blksize
- 1) / blksize
;
1311 /* Make sure we have the right LBA if one is specified */
1312 if ((phba
->lpfc_injerr_lba
< lba
) ||
1313 (phba
->lpfc_injerr_lba
>= (lba
+ numblks
)))
1317 sgpe
= scsi_prot_sglist(sc
);
1318 sgde
= scsi_sglist(sc
);
1320 /* Should we change the Reference Tag */
1323 * If we are SCSI_PROT_WRITE_STRIP, the protection data is
1324 * being stripped from the wire, thus it doesn't matter.
1326 if ((op
== SCSI_PROT_WRITE_PASS
) ||
1327 (op
== SCSI_PROT_WRITE_INSERT
)) {
1328 if (phba
->lpfc_injerr_wref_cnt
) {
1330 /* DEADBEEF will be the reftag on the wire */
1331 *reftag
= 0xDEADBEEF;
1332 phba
->lpfc_injerr_wref_cnt
--;
1333 phba
->lpfc_injerr_lba
= LPFC_INJERR_LBA_OFF
;
1336 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1337 "9081 BLKGRD: Injecting reftag error: "
1338 "write lba x%lx\n", (unsigned long)lba
);
1341 if (phba
->lpfc_injerr_rref_cnt
) {
1342 *reftag
= 0xDEADBEEF;
1343 phba
->lpfc_injerr_rref_cnt
--;
1344 phba
->lpfc_injerr_lba
= LPFC_INJERR_LBA_OFF
;
1347 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1348 "9076 BLKGRD: Injecting reftag error: "
1349 "read lba x%lx\n", (unsigned long)lba
);
1354 /* Should we change the Application Tag */
1357 * If we are SCSI_PROT_WRITE_STRIP, the protection data is
1358 * being stripped from the wire, thus it doesn't matter.
1360 if ((op
== SCSI_PROT_WRITE_PASS
) ||
1361 (op
== SCSI_PROT_WRITE_INSERT
)) {
1362 if (phba
->lpfc_injerr_wapp_cnt
) {
1364 /* DEAD will be the apptag on the wire */
1366 phba
->lpfc_injerr_wapp_cnt
--;
1367 phba
->lpfc_injerr_lba
= LPFC_INJERR_LBA_OFF
;
1370 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1371 "9077 BLKGRD: Injecting apptag error: "
1372 "write lba x%lx\n", (unsigned long)lba
);
1375 if (phba
->lpfc_injerr_rapp_cnt
) {
1377 phba
->lpfc_injerr_rapp_cnt
--;
1378 phba
->lpfc_injerr_lba
= LPFC_INJERR_LBA_OFF
;
1381 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1382 "9078 BLKGRD: Injecting apptag error: "
1383 "read lba x%lx\n", (unsigned long)lba
);
1388 /* Should we change the Guard Tag */
1391 * If we are SCSI_PROT_WRITE_INSERT, the protection data is
1392 * being on the wire is being fully generated on the HBA.
1393 * The host cannot change it or force an error.
1395 if (((op
== SCSI_PROT_WRITE_STRIP
) ||
1396 (op
== SCSI_PROT_WRITE_PASS
)) &&
1397 phba
->lpfc_injerr_wgrd_cnt
) {
1399 src
= (struct scsi_dif_tuple
*)sg_virt(sgpe
);
1401 * Just inject an error in the first
1404 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1405 "9079 BLKGRD: Injecting guard error: "
1406 "write lba x%lx oldGuard x%x refTag x%x\n",
1407 (unsigned long)lba
, src
->guard_tag
,
1410 src
->guard_tag
= (uint16_t)new_guard
;
1411 phba
->lpfc_injerr_wgrd_cnt
--;
1412 phba
->lpfc_injerr_lba
= LPFC_INJERR_LBA_OFF
;
1416 blksize
= lpfc_cmd_blksize(sc
);
1418 * Jump past the first data block
1419 * and inject an error in the
1420 * prot data. The prot data is already
1421 * embedded after the regular data.
1423 src
= (struct scsi_dif_tuple
*)
1424 (sg_virt(sgde
) + blksize
);
1426 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1427 "9080 BLKGRD: Injecting guard error: "
1428 "write lba x%lx oldGuard x%x refTag x%x\n",
1429 (unsigned long)lba
, src
->guard_tag
,
1432 src
->guard_tag
= (uint16_t)new_guard
;
1433 phba
->lpfc_injerr_wgrd_cnt
--;
1434 phba
->lpfc_injerr_lba
= LPFC_INJERR_LBA_OFF
;
1443 * Given a scsi cmnd, determine the BlockGuard opcodes to be used with it
1444 * @sc: The SCSI command to examine
1445 * @txopt: (out) BlockGuard operation for transmitted data
1446 * @rxopt: (out) BlockGuard operation for received data
1448 * Returns: zero on success; non-zero if tx and/or rx op cannot be determined
1452 lpfc_sc_to_bg_opcodes(struct lpfc_hba
*phba
, struct scsi_cmnd
*sc
,
1453 uint8_t *txop
, uint8_t *rxop
)
1455 uint8_t guard_type
= scsi_host_get_guard(sc
->device
->host
);
1458 if (guard_type
== SHOST_DIX_GUARD_IP
) {
1459 switch (scsi_get_prot_op(sc
)) {
1460 case SCSI_PROT_READ_INSERT
:
1461 case SCSI_PROT_WRITE_STRIP
:
1462 *txop
= BG_OP_IN_CSUM_OUT_NODIF
;
1463 *rxop
= BG_OP_IN_NODIF_OUT_CSUM
;
1466 case SCSI_PROT_READ_STRIP
:
1467 case SCSI_PROT_WRITE_INSERT
:
1468 *txop
= BG_OP_IN_NODIF_OUT_CRC
;
1469 *rxop
= BG_OP_IN_CRC_OUT_NODIF
;
1472 case SCSI_PROT_READ_PASS
:
1473 case SCSI_PROT_WRITE_PASS
:
1474 *txop
= BG_OP_IN_CSUM_OUT_CRC
;
1475 *rxop
= BG_OP_IN_CRC_OUT_CSUM
;
1478 case SCSI_PROT_NORMAL
:
1480 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1481 "9063 BLKGRD: Bad op/guard:%d/IP combination\n",
1482 scsi_get_prot_op(sc
));
1488 switch (scsi_get_prot_op(sc
)) {
1489 case SCSI_PROT_READ_STRIP
:
1490 case SCSI_PROT_WRITE_INSERT
:
1491 *txop
= BG_OP_IN_NODIF_OUT_CRC
;
1492 *rxop
= BG_OP_IN_CRC_OUT_NODIF
;
1495 case SCSI_PROT_READ_PASS
:
1496 case SCSI_PROT_WRITE_PASS
:
1497 *txop
= BG_OP_IN_CRC_OUT_CRC
;
1498 *rxop
= BG_OP_IN_CRC_OUT_CRC
;
1501 case SCSI_PROT_READ_INSERT
:
1502 case SCSI_PROT_WRITE_STRIP
:
1503 *txop
= BG_OP_IN_CRC_OUT_NODIF
;
1504 *rxop
= BG_OP_IN_NODIF_OUT_CRC
;
1507 case SCSI_PROT_NORMAL
:
1509 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1510 "9075 BLKGRD: Bad op/guard:%d/CRC combination\n",
1511 scsi_get_prot_op(sc
));
1521 * This function sets up buffer list for protection groups of
1522 * type LPFC_PG_TYPE_NO_DIF
1524 * This is usually used when the HBA is instructed to generate
1525 * DIFs and insert them into data stream (or strip DIF from
1526 * incoming data stream)
1528 * The buffer list consists of just one protection group described
1530 * +-------------------------+
1531 * start of prot group --> | PDE_5 |
1532 * +-------------------------+
1534 * +-------------------------+
1536 * +-------------------------+
1537 * |more Data BDE's ... (opt)|
1538 * +-------------------------+
1540 * @sc: pointer to scsi command we're working on
1541 * @bpl: pointer to buffer list for protection groups
1542 * @datacnt: number of segments of data that have been dma mapped
1544 * Note: Data s/g buffers have been dma mapped
1547 lpfc_bg_setup_bpl(struct lpfc_hba
*phba
, struct scsi_cmnd
*sc
,
1548 struct ulp_bde64
*bpl
, int datasegcnt
)
1550 struct scatterlist
*sgde
= NULL
; /* s/g data entry */
1551 struct lpfc_pde5
*pde5
= NULL
;
1552 struct lpfc_pde6
*pde6
= NULL
;
1553 dma_addr_t physaddr
;
1554 int i
= 0, num_bde
= 0, status
;
1555 int datadir
= sc
->sc_data_direction
;
1560 status
= lpfc_sc_to_bg_opcodes(phba
, sc
, &txop
, &rxop
);
1564 /* extract some info from the scsi command for pde*/
1565 blksize
= lpfc_cmd_blksize(sc
);
1566 reftag
= scsi_get_lba(sc
) & 0xffffffff;
1568 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1569 /* reftag is the only error we can inject here */
1570 lpfc_bg_err_inject(phba
, sc
, &reftag
, 0, 0);
1573 /* setup PDE5 with what we have */
1574 pde5
= (struct lpfc_pde5
*) bpl
;
1575 memset(pde5
, 0, sizeof(struct lpfc_pde5
));
1576 bf_set(pde5_type
, pde5
, LPFC_PDE5_DESCRIPTOR
);
1578 /* Endianness conversion if necessary for PDE5 */
1579 pde5
->word0
= cpu_to_le32(pde5
->word0
);
1580 pde5
->reftag
= cpu_to_le32(reftag
);
1582 /* advance bpl and increment bde count */
1585 pde6
= (struct lpfc_pde6
*) bpl
;
1587 /* setup PDE6 with the rest of the info */
1588 memset(pde6
, 0, sizeof(struct lpfc_pde6
));
1589 bf_set(pde6_type
, pde6
, LPFC_PDE6_DESCRIPTOR
);
1590 bf_set(pde6_optx
, pde6
, txop
);
1591 bf_set(pde6_oprx
, pde6
, rxop
);
1592 if (datadir
== DMA_FROM_DEVICE
) {
1593 bf_set(pde6_ce
, pde6
, 1);
1594 bf_set(pde6_re
, pde6
, 1);
1596 bf_set(pde6_ai
, pde6
, 1);
1597 bf_set(pde6_ae
, pde6
, 0);
1598 bf_set(pde6_apptagval
, pde6
, 0);
1600 /* Endianness conversion if necessary for PDE6 */
1601 pde6
->word0
= cpu_to_le32(pde6
->word0
);
1602 pde6
->word1
= cpu_to_le32(pde6
->word1
);
1603 pde6
->word2
= cpu_to_le32(pde6
->word2
);
1605 /* advance bpl and increment bde count */
1609 /* assumption: caller has already run dma_map_sg on command data */
1610 scsi_for_each_sg(sc
, sgde
, datasegcnt
, i
) {
1611 physaddr
= sg_dma_address(sgde
);
1612 bpl
->addrLow
= le32_to_cpu(putPaddrLow(physaddr
));
1613 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(physaddr
));
1614 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgde
);
1615 if (datadir
== DMA_TO_DEVICE
)
1616 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
1618 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64I
;
1619 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
1629 * This function sets up buffer list for protection groups of
1630 * type LPFC_PG_TYPE_DIF_BUF
1632 * This is usually used when DIFs are in their own buffers,
1633 * separate from the data. The HBA can then by instructed
1634 * to place the DIFs in the outgoing stream. For read operations,
1635 * The HBA could extract the DIFs and place it in DIF buffers.
1637 * The buffer list for this type consists of one or more of the
1638 * protection groups described below:
1639 * +-------------------------+
1640 * start of first prot group --> | PDE_5 |
1641 * +-------------------------+
1643 * +-------------------------+
1644 * | PDE_7 (Prot BDE) |
1645 * +-------------------------+
1647 * +-------------------------+
1648 * |more Data BDE's ... (opt)|
1649 * +-------------------------+
1650 * start of new prot group --> | PDE_5 |
1651 * +-------------------------+
1653 * +-------------------------+
1655 * @sc: pointer to scsi command we're working on
1656 * @bpl: pointer to buffer list for protection groups
1657 * @datacnt: number of segments of data that have been dma mapped
1658 * @protcnt: number of segment of protection data that have been dma mapped
1660 * Note: It is assumed that both data and protection s/g buffers have been
1664 lpfc_bg_setup_bpl_prot(struct lpfc_hba
*phba
, struct scsi_cmnd
*sc
,
1665 struct ulp_bde64
*bpl
, int datacnt
, int protcnt
)
1667 struct scatterlist
*sgde
= NULL
; /* s/g data entry */
1668 struct scatterlist
*sgpe
= NULL
; /* s/g prot entry */
1669 struct lpfc_pde5
*pde5
= NULL
;
1670 struct lpfc_pde6
*pde6
= NULL
;
1671 struct lpfc_pde7
*pde7
= NULL
;
1672 dma_addr_t dataphysaddr
, protphysaddr
;
1673 unsigned short curr_data
= 0, curr_prot
= 0;
1674 unsigned int split_offset
;
1675 unsigned int protgroup_len
, protgroup_offset
= 0, protgroup_remainder
;
1676 unsigned int protgrp_blks
, protgrp_bytes
;
1677 unsigned int remainder
, subtotal
;
1679 int datadir
= sc
->sc_data_direction
;
1680 unsigned char pgdone
= 0, alldone
= 0;
1686 sgpe
= scsi_prot_sglist(sc
);
1687 sgde
= scsi_sglist(sc
);
1689 if (!sgpe
|| !sgde
) {
1690 lpfc_printf_log(phba
, KERN_ERR
, LOG_FCP
,
1691 "9020 Invalid s/g entry: data=0x%p prot=0x%p\n",
1696 status
= lpfc_sc_to_bg_opcodes(phba
, sc
, &txop
, &rxop
);
1700 /* extract some info from the scsi command */
1701 blksize
= lpfc_cmd_blksize(sc
);
1702 reftag
= scsi_get_lba(sc
) & 0xffffffff;
1704 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1705 /* reftag / guard tag are the only errors we can inject here */
1706 lpfc_bg_err_inject(phba
, sc
, &reftag
, 0, 0xDEAD);
1711 /* setup PDE5 with what we have */
1712 pde5
= (struct lpfc_pde5
*) bpl
;
1713 memset(pde5
, 0, sizeof(struct lpfc_pde5
));
1714 bf_set(pde5_type
, pde5
, LPFC_PDE5_DESCRIPTOR
);
1716 /* Endianness conversion if necessary for PDE5 */
1717 pde5
->word0
= cpu_to_le32(pde5
->word0
);
1718 pde5
->reftag
= cpu_to_le32(reftag
);
1720 /* advance bpl and increment bde count */
1723 pde6
= (struct lpfc_pde6
*) bpl
;
1725 /* setup PDE6 with the rest of the info */
1726 memset(pde6
, 0, sizeof(struct lpfc_pde6
));
1727 bf_set(pde6_type
, pde6
, LPFC_PDE6_DESCRIPTOR
);
1728 bf_set(pde6_optx
, pde6
, txop
);
1729 bf_set(pde6_oprx
, pde6
, rxop
);
1730 bf_set(pde6_ce
, pde6
, 1);
1731 bf_set(pde6_re
, pde6
, 1);
1732 bf_set(pde6_ai
, pde6
, 1);
1733 bf_set(pde6_ae
, pde6
, 0);
1734 bf_set(pde6_apptagval
, pde6
, 0);
1736 /* Endianness conversion if necessary for PDE6 */
1737 pde6
->word0
= cpu_to_le32(pde6
->word0
);
1738 pde6
->word1
= cpu_to_le32(pde6
->word1
);
1739 pde6
->word2
= cpu_to_le32(pde6
->word2
);
1741 /* advance bpl and increment bde count */
1745 /* setup the first BDE that points to protection buffer */
1746 protphysaddr
= sg_dma_address(sgpe
) + protgroup_offset
;
1747 protgroup_len
= sg_dma_len(sgpe
) - protgroup_offset
;
1749 /* must be integer multiple of the DIF block length */
1750 BUG_ON(protgroup_len
% 8);
1752 pde7
= (struct lpfc_pde7
*) bpl
;
1753 memset(pde7
, 0, sizeof(struct lpfc_pde7
));
1754 bf_set(pde7_type
, pde7
, LPFC_PDE7_DESCRIPTOR
);
1756 pde7
->addrHigh
= le32_to_cpu(putPaddrHigh(protphysaddr
));
1757 pde7
->addrLow
= le32_to_cpu(putPaddrLow(protphysaddr
));
1759 protgrp_blks
= protgroup_len
/ 8;
1760 protgrp_bytes
= protgrp_blks
* blksize
;
1762 /* check if this pde is crossing the 4K boundary; if so split */
1763 if ((pde7
->addrLow
& 0xfff) + protgroup_len
> 0x1000) {
1764 protgroup_remainder
= 0x1000 - (pde7
->addrLow
& 0xfff);
1765 protgroup_offset
+= protgroup_remainder
;
1766 protgrp_blks
= protgroup_remainder
/ 8;
1767 protgrp_bytes
= protgrp_blks
* blksize
;
1769 protgroup_offset
= 0;
1775 /* setup BDE's for data blocks associated with DIF data */
1777 subtotal
= 0; /* total bytes processed for current prot grp */
1780 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1781 "9065 BLKGRD:%s Invalid data segment\n",
1786 dataphysaddr
= sg_dma_address(sgde
) + split_offset
;
1787 bpl
->addrLow
= le32_to_cpu(putPaddrLow(dataphysaddr
));
1788 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(dataphysaddr
));
1790 remainder
= sg_dma_len(sgde
) - split_offset
;
1792 if ((subtotal
+ remainder
) <= protgrp_bytes
) {
1793 /* we can use this whole buffer */
1794 bpl
->tus
.f
.bdeSize
= remainder
;
1797 if ((subtotal
+ remainder
) == protgrp_bytes
)
1800 /* must split this buffer with next prot grp */
1801 bpl
->tus
.f
.bdeSize
= protgrp_bytes
- subtotal
;
1802 split_offset
+= bpl
->tus
.f
.bdeSize
;
1805 subtotal
+= bpl
->tus
.f
.bdeSize
;
1807 if (datadir
== DMA_TO_DEVICE
)
1808 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
1810 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64I
;
1811 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
1819 /* Move to the next s/g segment if possible */
1820 sgde
= sg_next(sgde
);
1824 if (protgroup_offset
) {
1825 /* update the reference tag */
1826 reftag
+= protgrp_blks
;
1832 if (curr_prot
== protcnt
) {
1834 } else if (curr_prot
< protcnt
) {
1835 /* advance to next prot buffer */
1836 sgpe
= sg_next(sgpe
);
1839 /* update the reference tag */
1840 reftag
+= protgrp_blks
;
1842 /* if we're here, we have a bug */
1843 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1844 "9054 BLKGRD: bug in %s\n", __func__
);
1854 * Given a SCSI command that supports DIF, determine composition of protection
1855 * groups involved in setting up buffer lists
1858 * for DIF (for both read and write)
1861 lpfc_prot_group_type(struct lpfc_hba
*phba
, struct scsi_cmnd
*sc
)
1863 int ret
= LPFC_PG_TYPE_INVALID
;
1864 unsigned char op
= scsi_get_prot_op(sc
);
1867 case SCSI_PROT_READ_STRIP
:
1868 case SCSI_PROT_WRITE_INSERT
:
1869 ret
= LPFC_PG_TYPE_NO_DIF
;
1871 case SCSI_PROT_READ_INSERT
:
1872 case SCSI_PROT_WRITE_STRIP
:
1873 case SCSI_PROT_READ_PASS
:
1874 case SCSI_PROT_WRITE_PASS
:
1875 ret
= LPFC_PG_TYPE_DIF_BUF
;
1878 lpfc_printf_log(phba
, KERN_ERR
, LOG_FCP
,
1879 "9021 Unsupported protection op:%d\n", op
);
1887 * This is the protection/DIF aware version of
1888 * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the
1889 * two functions eventually, but for now, it's here
1892 lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba
*phba
,
1893 struct lpfc_scsi_buf
*lpfc_cmd
)
1895 struct scsi_cmnd
*scsi_cmnd
= lpfc_cmd
->pCmd
;
1896 struct fcp_cmnd
*fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
1897 struct ulp_bde64
*bpl
= lpfc_cmd
->fcp_bpl
;
1898 IOCB_t
*iocb_cmd
= &lpfc_cmd
->cur_iocbq
.iocb
;
1899 uint32_t num_bde
= 0;
1900 int datasegcnt
, protsegcnt
, datadir
= scsi_cmnd
->sc_data_direction
;
1901 int prot_group_type
= 0;
1906 * Start the lpfc command prep by bumping the bpl beyond fcp_cmnd
1907 * fcp_rsp regions to the first data bde entry
1910 if (scsi_sg_count(scsi_cmnd
)) {
1912 * The driver stores the segment count returned from pci_map_sg
1913 * because this a count of dma-mappings used to map the use_sg
1914 * pages. They are not guaranteed to be the same for those
1915 * architectures that implement an IOMMU.
1917 datasegcnt
= dma_map_sg(&phba
->pcidev
->dev
,
1918 scsi_sglist(scsi_cmnd
),
1919 scsi_sg_count(scsi_cmnd
), datadir
);
1920 if (unlikely(!datasegcnt
))
1923 lpfc_cmd
->seg_cnt
= datasegcnt
;
1924 if (lpfc_cmd
->seg_cnt
> phba
->cfg_sg_seg_cnt
) {
1925 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1926 "9067 BLKGRD: %s: Too many sg segments"
1927 " from dma_map_sg. Config %d, seg_cnt"
1929 __func__
, phba
->cfg_sg_seg_cnt
,
1931 scsi_dma_unmap(scsi_cmnd
);
1935 prot_group_type
= lpfc_prot_group_type(phba
, scsi_cmnd
);
1937 switch (prot_group_type
) {
1938 case LPFC_PG_TYPE_NO_DIF
:
1939 num_bde
= lpfc_bg_setup_bpl(phba
, scsi_cmnd
, bpl
,
1941 /* we should have 2 or more entries in buffer list */
1945 case LPFC_PG_TYPE_DIF_BUF
:{
1947 * This type indicates that protection buffers are
1948 * passed to the driver, so that needs to be prepared
1951 protsegcnt
= dma_map_sg(&phba
->pcidev
->dev
,
1952 scsi_prot_sglist(scsi_cmnd
),
1953 scsi_prot_sg_count(scsi_cmnd
), datadir
);
1954 if (unlikely(!protsegcnt
)) {
1955 scsi_dma_unmap(scsi_cmnd
);
1959 lpfc_cmd
->prot_seg_cnt
= protsegcnt
;
1960 if (lpfc_cmd
->prot_seg_cnt
1961 > phba
->cfg_prot_sg_seg_cnt
) {
1962 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
1963 "9068 BLKGRD: %s: Too many prot sg "
1964 "segments from dma_map_sg. Config %d,"
1965 "prot_seg_cnt %d\n", __func__
,
1966 phba
->cfg_prot_sg_seg_cnt
,
1967 lpfc_cmd
->prot_seg_cnt
);
1968 dma_unmap_sg(&phba
->pcidev
->dev
,
1969 scsi_prot_sglist(scsi_cmnd
),
1970 scsi_prot_sg_count(scsi_cmnd
),
1972 scsi_dma_unmap(scsi_cmnd
);
1976 num_bde
= lpfc_bg_setup_bpl_prot(phba
, scsi_cmnd
, bpl
,
1977 datasegcnt
, protsegcnt
);
1978 /* we should have 3 or more entries in buffer list */
1983 case LPFC_PG_TYPE_INVALID
:
1985 lpfc_printf_log(phba
, KERN_ERR
, LOG_FCP
,
1986 "9022 Unexpected protection group %i\n",
1993 * Finish initializing those IOCB fields that are dependent on the
1994 * scsi_cmnd request_buffer. Note that the bdeSize is explicitly
1995 * reinitialized since all iocb memory resources are used many times
1996 * for transmit, receive, and continuation bpl's.
1998 iocb_cmd
->un
.fcpi64
.bdl
.bdeSize
= (2 * sizeof(struct ulp_bde64
));
1999 iocb_cmd
->un
.fcpi64
.bdl
.bdeSize
+= (num_bde
* sizeof(struct ulp_bde64
));
2000 iocb_cmd
->ulpBdeCount
= 1;
2001 iocb_cmd
->ulpLe
= 1;
2003 fcpdl
= scsi_bufflen(scsi_cmnd
);
2005 if (scsi_get_prot_type(scsi_cmnd
) == SCSI_PROT_DIF_TYPE1
) {
2007 * We are in DIF Type 1 mode
2008 * Every data block has a 8 byte DIF (trailer)
2009 * attached to it. Must ajust FCP data length
2011 blksize
= lpfc_cmd_blksize(scsi_cmnd
);
2012 diflen
= (fcpdl
/ blksize
) * 8;
2015 fcp_cmnd
->fcpDl
= be32_to_cpu(fcpdl
);
2018 * Due to difference in data length between DIF/non-DIF paths,
2019 * we need to set word 4 of IOCB here
2021 iocb_cmd
->un
.fcpi
.fcpi_parm
= fcpdl
;
2025 lpfc_printf_log(phba
, KERN_ERR
, LOG_FCP
,
2026 "9023 Could not setup all needed BDE's"
2027 "prot_group_type=%d, num_bde=%d\n",
2028 prot_group_type
, num_bde
);
2033 * This function checks for BlockGuard errors detected by
2034 * the HBA. In case of errors, the ASC/ASCQ fields in the
2035 * sense buffer will be set accordingly, paired with
2036 * ILLEGAL_REQUEST to signal to the kernel that the HBA
2037 * detected corruption.
2040 * 0 - No error found
2041 * 1 - BlockGuard error found
2042 * -1 - Internal error (bad profile, ...etc)
2045 lpfc_parse_bg_err(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*lpfc_cmd
,
2046 struct lpfc_iocbq
*pIocbOut
)
2048 struct scsi_cmnd
*cmd
= lpfc_cmd
->pCmd
;
2049 struct sli3_bg_fields
*bgf
= &pIocbOut
->iocb
.unsli3
.sli3_bg
;
2051 uint32_t bghm
= bgf
->bghm
;
2052 uint32_t bgstat
= bgf
->bgstat
;
2053 uint64_t failing_sector
= 0;
2055 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
, "9069 BLKGRD: BG ERROR in cmd"
2056 " 0x%x lba 0x%llx blk cnt 0x%x "
2057 "bgstat=0x%x bghm=0x%x\n",
2058 cmd
->cmnd
[0], (unsigned long long)scsi_get_lba(cmd
),
2059 blk_rq_sectors(cmd
->request
), bgstat
, bghm
);
2061 spin_lock(&_dump_buf_lock
);
2062 if (!_dump_buf_done
) {
2063 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
, "9070 BLKGRD: Saving"
2064 " Data for %u blocks to debugfs\n",
2065 (cmd
->cmnd
[7] << 8 | cmd
->cmnd
[8]));
2066 lpfc_debug_save_data(phba
, cmd
);
2068 /* If we have a prot sgl, save the DIF buffer */
2069 if (lpfc_prot_group_type(phba
, cmd
) ==
2070 LPFC_PG_TYPE_DIF_BUF
) {
2071 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
, "9071 BLKGRD: "
2072 "Saving DIF for %u blocks to debugfs\n",
2073 (cmd
->cmnd
[7] << 8 | cmd
->cmnd
[8]));
2074 lpfc_debug_save_dif(phba
, cmd
);
2079 spin_unlock(&_dump_buf_lock
);
2081 if (lpfc_bgs_get_invalid_prof(bgstat
)) {
2082 cmd
->result
= ScsiResult(DID_ERROR
, 0);
2083 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
, "9072 BLKGRD: Invalid"
2084 " BlockGuard profile. bgstat:0x%x\n",
2090 if (lpfc_bgs_get_uninit_dif_block(bgstat
)) {
2091 cmd
->result
= ScsiResult(DID_ERROR
, 0);
2092 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
, "9073 BLKGRD: "
2093 "Invalid BlockGuard DIF Block. bgstat:0x%x\n",
2099 if (lpfc_bgs_get_guard_err(bgstat
)) {
2102 scsi_build_sense_buffer(1, cmd
->sense_buffer
, ILLEGAL_REQUEST
,
2104 cmd
->result
= DRIVER_SENSE
<< 24
2105 | ScsiResult(DID_ABORT
, SAM_STAT_CHECK_CONDITION
);
2106 phba
->bg_guard_err_cnt
++;
2107 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
2108 "9055 BLKGRD: guard_tag error\n");
2111 if (lpfc_bgs_get_reftag_err(bgstat
)) {
2114 scsi_build_sense_buffer(1, cmd
->sense_buffer
, ILLEGAL_REQUEST
,
2116 cmd
->result
= DRIVER_SENSE
<< 24
2117 | ScsiResult(DID_ABORT
, SAM_STAT_CHECK_CONDITION
);
2119 phba
->bg_reftag_err_cnt
++;
2120 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
2121 "9056 BLKGRD: ref_tag error\n");
2124 if (lpfc_bgs_get_apptag_err(bgstat
)) {
2127 scsi_build_sense_buffer(1, cmd
->sense_buffer
, ILLEGAL_REQUEST
,
2129 cmd
->result
= DRIVER_SENSE
<< 24
2130 | ScsiResult(DID_ABORT
, SAM_STAT_CHECK_CONDITION
);
2132 phba
->bg_apptag_err_cnt
++;
2133 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
2134 "9061 BLKGRD: app_tag error\n");
2137 if (lpfc_bgs_get_hi_water_mark_present(bgstat
)) {
2139 * setup sense data descriptor 0 per SPC-4 as an information
2140 * field, and put the failing LBA in it.
2141 * This code assumes there was also a guard/app/ref tag error
2144 cmd
->sense_buffer
[7] = 0xc; /* Additional sense length */
2145 cmd
->sense_buffer
[8] = 0; /* Information descriptor type */
2146 cmd
->sense_buffer
[9] = 0xa; /* Additional descriptor length */
2147 cmd
->sense_buffer
[10] = 0x80; /* Validity bit */
2148 bghm
/= cmd
->device
->sector_size
;
2150 failing_sector
= scsi_get_lba(cmd
);
2151 failing_sector
+= bghm
;
2153 /* Descriptor Information */
2154 put_unaligned_be64(failing_sector
, &cmd
->sense_buffer
[12]);
2158 /* No error was reported - problem in FW? */
2159 cmd
->result
= ScsiResult(DID_ERROR
, 0);
2160 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
2161 "9057 BLKGRD: no errors reported!\n");
2169 * lpfc_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec
2170 * @phba: The Hba for which this call is being executed.
2171 * @lpfc_cmd: The scsi buffer which is going to be mapped.
2173 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
2174 * field of @lpfc_cmd for device with SLI-4 interface spec.
2181 lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*lpfc_cmd
)
2183 struct scsi_cmnd
*scsi_cmnd
= lpfc_cmd
->pCmd
;
2184 struct scatterlist
*sgel
= NULL
;
2185 struct fcp_cmnd
*fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
2186 struct sli4_sge
*sgl
= (struct sli4_sge
*)lpfc_cmd
->fcp_bpl
;
2187 struct sli4_sge
*first_data_sgl
;
2188 IOCB_t
*iocb_cmd
= &lpfc_cmd
->cur_iocbq
.iocb
;
2189 dma_addr_t physaddr
;
2190 uint32_t num_bde
= 0;
2192 uint32_t dma_offset
= 0;
2194 struct ulp_bde64
*bde
;
2197 * There are three possibilities here - use scatter-gather segment, use
2198 * the single mapping, or neither. Start the lpfc command prep by
2199 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
2202 if (scsi_sg_count(scsi_cmnd
)) {
2204 * The driver stores the segment count returned from pci_map_sg
2205 * because this a count of dma-mappings used to map the use_sg
2206 * pages. They are not guaranteed to be the same for those
2207 * architectures that implement an IOMMU.
2210 nseg
= scsi_dma_map(scsi_cmnd
);
2211 if (unlikely(!nseg
))
2214 /* clear the last flag in the fcp_rsp map entry */
2215 sgl
->word2
= le32_to_cpu(sgl
->word2
);
2216 bf_set(lpfc_sli4_sge_last
, sgl
, 0);
2217 sgl
->word2
= cpu_to_le32(sgl
->word2
);
2219 first_data_sgl
= sgl
;
2220 lpfc_cmd
->seg_cnt
= nseg
;
2221 if (lpfc_cmd
->seg_cnt
> phba
->cfg_sg_seg_cnt
) {
2222 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
, "9074 BLKGRD:"
2223 " %s: Too many sg segments from "
2224 "dma_map_sg. Config %d, seg_cnt %d\n",
2225 __func__
, phba
->cfg_sg_seg_cnt
,
2227 scsi_dma_unmap(scsi_cmnd
);
2232 * The driver established a maximum scatter-gather segment count
2233 * during probe that limits the number of sg elements in any
2234 * single scsi command. Just run through the seg_cnt and format
2236 * When using SLI-3 the driver will try to fit all the BDEs into
2237 * the IOCB. If it can't then the BDEs get added to a BPL as it
2238 * does for SLI-2 mode.
2240 scsi_for_each_sg(scsi_cmnd
, sgel
, nseg
, num_bde
) {
2241 physaddr
= sg_dma_address(sgel
);
2242 dma_len
= sg_dma_len(sgel
);
2243 sgl
->addr_lo
= cpu_to_le32(putPaddrLow(physaddr
));
2244 sgl
->addr_hi
= cpu_to_le32(putPaddrHigh(physaddr
));
2245 sgl
->word2
= le32_to_cpu(sgl
->word2
);
2246 if ((num_bde
+ 1) == nseg
)
2247 bf_set(lpfc_sli4_sge_last
, sgl
, 1);
2249 bf_set(lpfc_sli4_sge_last
, sgl
, 0);
2250 bf_set(lpfc_sli4_sge_offset
, sgl
, dma_offset
);
2251 bf_set(lpfc_sli4_sge_type
, sgl
, LPFC_SGE_TYPE_DATA
);
2252 sgl
->word2
= cpu_to_le32(sgl
->word2
);
2253 sgl
->sge_len
= cpu_to_le32(dma_len
);
2254 dma_offset
+= dma_len
;
2257 /* setup the performance hint (first data BDE) if enabled */
2258 if (phba
->sli3_options
& LPFC_SLI4_PERFH_ENABLED
) {
2259 bde
= (struct ulp_bde64
*)
2260 &(iocb_cmd
->unsli3
.sli3Words
[5]);
2261 bde
->addrLow
= first_data_sgl
->addr_lo
;
2262 bde
->addrHigh
= first_data_sgl
->addr_hi
;
2263 bde
->tus
.f
.bdeSize
=
2264 le32_to_cpu(first_data_sgl
->sge_len
);
2265 bde
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
2266 bde
->tus
.w
= cpu_to_le32(bde
->tus
.w
);
2270 /* clear the last flag in the fcp_rsp map entry */
2271 sgl
->word2
= le32_to_cpu(sgl
->word2
);
2272 bf_set(lpfc_sli4_sge_last
, sgl
, 1);
2273 sgl
->word2
= cpu_to_le32(sgl
->word2
);
2277 * Finish initializing those IOCB fields that are dependent on the
2278 * scsi_cmnd request_buffer. Note that for SLI-2 the bdeSize is
2279 * explicitly reinitialized.
2280 * all iocb memory resources are reused.
2282 fcp_cmnd
->fcpDl
= cpu_to_be32(scsi_bufflen(scsi_cmnd
));
2285 * Due to difference in data length between DIF/non-DIF paths,
2286 * we need to set word 4 of IOCB here
2288 iocb_cmd
->un
.fcpi
.fcpi_parm
= scsi_bufflen(scsi_cmnd
);
2293 * lpfc_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer
2294 * @phba: The Hba for which this call is being executed.
2295 * @lpfc_cmd: The scsi buffer which is going to be mapped.
2297 * This routine wraps the actual DMA mapping function pointer from the
2305 lpfc_scsi_prep_dma_buf(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*lpfc_cmd
)
2307 return phba
->lpfc_scsi_prep_dma_buf(phba
, lpfc_cmd
);
2311 * lpfc_send_scsi_error_event - Posts an event when there is SCSI error
2312 * @phba: Pointer to hba context object.
2313 * @vport: Pointer to vport object.
2314 * @lpfc_cmd: Pointer to lpfc scsi command which reported the error.
2315 * @rsp_iocb: Pointer to response iocb object which reported error.
2317 * This function posts an event when there is a SCSI command reporting
2318 * error from the scsi device.
2321 lpfc_send_scsi_error_event(struct lpfc_hba
*phba
, struct lpfc_vport
*vport
,
2322 struct lpfc_scsi_buf
*lpfc_cmd
, struct lpfc_iocbq
*rsp_iocb
) {
2323 struct scsi_cmnd
*cmnd
= lpfc_cmd
->pCmd
;
2324 struct fcp_rsp
*fcprsp
= lpfc_cmd
->fcp_rsp
;
2325 uint32_t resp_info
= fcprsp
->rspStatus2
;
2326 uint32_t scsi_status
= fcprsp
->rspStatus3
;
2327 uint32_t fcpi_parm
= rsp_iocb
->iocb
.un
.fcpi
.fcpi_parm
;
2328 struct lpfc_fast_path_event
*fast_path_evt
= NULL
;
2329 struct lpfc_nodelist
*pnode
= lpfc_cmd
->rdata
->pnode
;
2330 unsigned long flags
;
2332 if (!pnode
|| !NLP_CHK_NODE_ACT(pnode
))
2335 /* If there is queuefull or busy condition send a scsi event */
2336 if ((cmnd
->result
== SAM_STAT_TASK_SET_FULL
) ||
2337 (cmnd
->result
== SAM_STAT_BUSY
)) {
2338 fast_path_evt
= lpfc_alloc_fast_evt(phba
);
2341 fast_path_evt
->un
.scsi_evt
.event_type
=
2343 fast_path_evt
->un
.scsi_evt
.subcategory
=
2344 (cmnd
->result
== SAM_STAT_TASK_SET_FULL
) ?
2345 LPFC_EVENT_QFULL
: LPFC_EVENT_DEVBSY
;
2346 fast_path_evt
->un
.scsi_evt
.lun
= cmnd
->device
->lun
;
2347 memcpy(&fast_path_evt
->un
.scsi_evt
.wwpn
,
2348 &pnode
->nlp_portname
, sizeof(struct lpfc_name
));
2349 memcpy(&fast_path_evt
->un
.scsi_evt
.wwnn
,
2350 &pnode
->nlp_nodename
, sizeof(struct lpfc_name
));
2351 } else if ((resp_info
& SNS_LEN_VALID
) && fcprsp
->rspSnsLen
&&
2352 ((cmnd
->cmnd
[0] == READ_10
) || (cmnd
->cmnd
[0] == WRITE_10
))) {
2353 fast_path_evt
= lpfc_alloc_fast_evt(phba
);
2356 fast_path_evt
->un
.check_cond_evt
.scsi_event
.event_type
=
2358 fast_path_evt
->un
.check_cond_evt
.scsi_event
.subcategory
=
2359 LPFC_EVENT_CHECK_COND
;
2360 fast_path_evt
->un
.check_cond_evt
.scsi_event
.lun
=
2362 memcpy(&fast_path_evt
->un
.check_cond_evt
.scsi_event
.wwpn
,
2363 &pnode
->nlp_portname
, sizeof(struct lpfc_name
));
2364 memcpy(&fast_path_evt
->un
.check_cond_evt
.scsi_event
.wwnn
,
2365 &pnode
->nlp_nodename
, sizeof(struct lpfc_name
));
2366 fast_path_evt
->un
.check_cond_evt
.sense_key
=
2367 cmnd
->sense_buffer
[2] & 0xf;
2368 fast_path_evt
->un
.check_cond_evt
.asc
= cmnd
->sense_buffer
[12];
2369 fast_path_evt
->un
.check_cond_evt
.ascq
= cmnd
->sense_buffer
[13];
2370 } else if ((cmnd
->sc_data_direction
== DMA_FROM_DEVICE
) &&
2372 ((be32_to_cpu(fcprsp
->rspResId
) != fcpi_parm
) ||
2373 ((scsi_status
== SAM_STAT_GOOD
) &&
2374 !(resp_info
& (RESID_UNDER
| RESID_OVER
))))) {
2376 * If status is good or resid does not match with fcp_param and
2377 * there is valid fcpi_parm, then there is a read_check error
2379 fast_path_evt
= lpfc_alloc_fast_evt(phba
);
2382 fast_path_evt
->un
.read_check_error
.header
.event_type
=
2383 FC_REG_FABRIC_EVENT
;
2384 fast_path_evt
->un
.read_check_error
.header
.subcategory
=
2385 LPFC_EVENT_FCPRDCHKERR
;
2386 memcpy(&fast_path_evt
->un
.read_check_error
.header
.wwpn
,
2387 &pnode
->nlp_portname
, sizeof(struct lpfc_name
));
2388 memcpy(&fast_path_evt
->un
.read_check_error
.header
.wwnn
,
2389 &pnode
->nlp_nodename
, sizeof(struct lpfc_name
));
2390 fast_path_evt
->un
.read_check_error
.lun
= cmnd
->device
->lun
;
2391 fast_path_evt
->un
.read_check_error
.opcode
= cmnd
->cmnd
[0];
2392 fast_path_evt
->un
.read_check_error
.fcpiparam
=
2397 fast_path_evt
->vport
= vport
;
2398 spin_lock_irqsave(&phba
->hbalock
, flags
);
2399 list_add_tail(&fast_path_evt
->work_evt
.evt_listp
, &phba
->work_list
);
2400 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
2401 lpfc_worker_wake_up(phba
);
2406 * lpfc_scsi_unprep_dma_buf - Un-map DMA mapping of SG-list for dev
2407 * @phba: The HBA for which this call is being executed.
2408 * @psb: The scsi buffer which is going to be un-mapped.
2410 * This routine does DMA un-mapping of scatter gather list of scsi command
2411 * field of @lpfc_cmd for device with SLI-3 interface spec.
2414 lpfc_scsi_unprep_dma_buf(struct lpfc_hba
*phba
, struct lpfc_scsi_buf
*psb
)
2417 * There are only two special cases to consider. (1) the scsi command
2418 * requested scatter-gather usage or (2) the scsi command allocated
2419 * a request buffer, but did not request use_sg. There is a third
2420 * case, but it does not require resource deallocation.
2422 if (psb
->seg_cnt
> 0)
2423 scsi_dma_unmap(psb
->pCmd
);
2424 if (psb
->prot_seg_cnt
> 0)
2425 dma_unmap_sg(&phba
->pcidev
->dev
, scsi_prot_sglist(psb
->pCmd
),
2426 scsi_prot_sg_count(psb
->pCmd
),
2427 psb
->pCmd
->sc_data_direction
);
2431 * lpfc_handler_fcp_err - FCP response handler
2432 * @vport: The virtual port for which this call is being executed.
2433 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
2434 * @rsp_iocb: The response IOCB which contains FCP error.
2436 * This routine is called to process response IOCB with status field
2437 * IOSTAT_FCP_RSP_ERROR. This routine sets result field of scsi command
2438 * based upon SCSI and FCP error.
2441 lpfc_handle_fcp_err(struct lpfc_vport
*vport
, struct lpfc_scsi_buf
*lpfc_cmd
,
2442 struct lpfc_iocbq
*rsp_iocb
)
2444 struct scsi_cmnd
*cmnd
= lpfc_cmd
->pCmd
;
2445 struct fcp_cmnd
*fcpcmd
= lpfc_cmd
->fcp_cmnd
;
2446 struct fcp_rsp
*fcprsp
= lpfc_cmd
->fcp_rsp
;
2447 uint32_t fcpi_parm
= rsp_iocb
->iocb
.un
.fcpi
.fcpi_parm
;
2448 uint32_t resp_info
= fcprsp
->rspStatus2
;
2449 uint32_t scsi_status
= fcprsp
->rspStatus3
;
2451 uint32_t host_status
= DID_OK
;
2452 uint32_t rsplen
= 0;
2453 uint32_t logit
= LOG_FCP
| LOG_FCP_ERROR
;
2457 * If this is a task management command, there is no
2458 * scsi packet associated with this lpfc_cmd. The driver
2461 if (fcpcmd
->fcpCntl2
) {
2466 if (resp_info
& RSP_LEN_VALID
) {
2467 rsplen
= be32_to_cpu(fcprsp
->rspRspLen
);
2468 if (rsplen
!= 0 && rsplen
!= 4 && rsplen
!= 8) {
2469 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
2470 "2719 Invalid response length: "
2471 "tgt x%x lun x%x cmnd x%x rsplen x%x\n",
2473 cmnd
->device
->lun
, cmnd
->cmnd
[0],
2475 host_status
= DID_ERROR
;
2478 if (fcprsp
->rspInfo3
!= RSP_NO_FAILURE
) {
2479 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
2480 "2757 Protocol failure detected during "
2481 "processing of FCP I/O op: "
2482 "tgt x%x lun x%x cmnd x%x rspInfo3 x%x\n",
2484 cmnd
->device
->lun
, cmnd
->cmnd
[0],
2486 host_status
= DID_ERROR
;
2491 if ((resp_info
& SNS_LEN_VALID
) && fcprsp
->rspSnsLen
) {
2492 uint32_t snslen
= be32_to_cpu(fcprsp
->rspSnsLen
);
2493 if (snslen
> SCSI_SENSE_BUFFERSIZE
)
2494 snslen
= SCSI_SENSE_BUFFERSIZE
;
2496 if (resp_info
& RSP_LEN_VALID
)
2497 rsplen
= be32_to_cpu(fcprsp
->rspRspLen
);
2498 memcpy(cmnd
->sense_buffer
, &fcprsp
->rspInfo0
+ rsplen
, snslen
);
2500 lp
= (uint32_t *)cmnd
->sense_buffer
;
2502 if (!scsi_status
&& (resp_info
& RESID_UNDER
) &&
2503 vport
->cfg_log_verbose
& LOG_FCP_UNDER
)
2504 logit
= LOG_FCP_UNDER
;
2506 lpfc_printf_vlog(vport
, KERN_WARNING
, logit
,
2507 "9024 FCP command x%x failed: x%x SNS x%x x%x "
2508 "Data: x%x x%x x%x x%x x%x\n",
2509 cmnd
->cmnd
[0], scsi_status
,
2510 be32_to_cpu(*lp
), be32_to_cpu(*(lp
+ 3)), resp_info
,
2511 be32_to_cpu(fcprsp
->rspResId
),
2512 be32_to_cpu(fcprsp
->rspSnsLen
),
2513 be32_to_cpu(fcprsp
->rspRspLen
),
2516 scsi_set_resid(cmnd
, 0);
2517 if (resp_info
& RESID_UNDER
) {
2518 scsi_set_resid(cmnd
, be32_to_cpu(fcprsp
->rspResId
));
2520 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP_UNDER
,
2521 "9025 FCP Read Underrun, expected %d, "
2522 "residual %d Data: x%x x%x x%x\n",
2523 be32_to_cpu(fcpcmd
->fcpDl
),
2524 scsi_get_resid(cmnd
), fcpi_parm
, cmnd
->cmnd
[0],
2528 * If there is an under run check if under run reported by
2529 * storage array is same as the under run reported by HBA.
2530 * If this is not same, there is a dropped frame.
2532 if ((cmnd
->sc_data_direction
== DMA_FROM_DEVICE
) &&
2534 (scsi_get_resid(cmnd
) != fcpi_parm
)) {
2535 lpfc_printf_vlog(vport
, KERN_WARNING
,
2536 LOG_FCP
| LOG_FCP_ERROR
,
2537 "9026 FCP Read Check Error "
2538 "and Underrun Data: x%x x%x x%x x%x\n",
2539 be32_to_cpu(fcpcmd
->fcpDl
),
2540 scsi_get_resid(cmnd
), fcpi_parm
,
2542 scsi_set_resid(cmnd
, scsi_bufflen(cmnd
));
2543 host_status
= DID_ERROR
;
2546 * The cmnd->underflow is the minimum number of bytes that must
2547 * be transferred for this command. Provided a sense condition
2548 * is not present, make sure the actual amount transferred is at
2549 * least the underflow value or fail.
2551 if (!(resp_info
& SNS_LEN_VALID
) &&
2552 (scsi_status
== SAM_STAT_GOOD
) &&
2553 (scsi_bufflen(cmnd
) - scsi_get_resid(cmnd
)
2554 < cmnd
->underflow
)) {
2555 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
2556 "9027 FCP command x%x residual "
2557 "underrun converted to error "
2558 "Data: x%x x%x x%x\n",
2559 cmnd
->cmnd
[0], scsi_bufflen(cmnd
),
2560 scsi_get_resid(cmnd
), cmnd
->underflow
);
2561 host_status
= DID_ERROR
;
2563 } else if (resp_info
& RESID_OVER
) {
2564 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
2565 "9028 FCP command x%x residual overrun error. "
2566 "Data: x%x x%x\n", cmnd
->cmnd
[0],
2567 scsi_bufflen(cmnd
), scsi_get_resid(cmnd
));
2568 host_status
= DID_ERROR
;
2571 * Check SLI validation that all the transfer was actually done
2572 * (fcpi_parm should be zero). Apply check only to reads.
2574 } else if (fcpi_parm
&& (cmnd
->sc_data_direction
== DMA_FROM_DEVICE
)) {
2575 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
| LOG_FCP_ERROR
,
2576 "9029 FCP Read Check Error Data: "
2577 "x%x x%x x%x x%x x%x\n",
2578 be32_to_cpu(fcpcmd
->fcpDl
),
2579 be32_to_cpu(fcprsp
->rspResId
),
2580 fcpi_parm
, cmnd
->cmnd
[0], scsi_status
);
2581 switch (scsi_status
) {
2583 case SAM_STAT_CHECK_CONDITION
:
2584 /* Fabric dropped a data frame. Fail any successful
2585 * command in which we detected dropped frames.
2586 * A status of good or some check conditions could
2587 * be considered a successful command.
2589 host_status
= DID_ERROR
;
2592 scsi_set_resid(cmnd
, scsi_bufflen(cmnd
));
2596 cmnd
->result
= ScsiResult(host_status
, scsi_status
);
2597 lpfc_send_scsi_error_event(vport
->phba
, vport
, lpfc_cmd
, rsp_iocb
);
2601 * lpfc_scsi_cmd_iocb_cmpl - Scsi cmnd IOCB completion routine
2602 * @phba: The Hba for which this call is being executed.
2603 * @pIocbIn: The command IOCBQ for the scsi cmnd.
2604 * @pIocbOut: The response IOCBQ for the scsi cmnd.
2606 * This routine assigns scsi command result by looking into response IOCB
2607 * status field appropriately. This routine handles QUEUE FULL condition as
2608 * well by ramping down device queue depth.
2611 lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba
*phba
, struct lpfc_iocbq
*pIocbIn
,
2612 struct lpfc_iocbq
*pIocbOut
)
2614 struct lpfc_scsi_buf
*lpfc_cmd
=
2615 (struct lpfc_scsi_buf
*) pIocbIn
->context1
;
2616 struct lpfc_vport
*vport
= pIocbIn
->vport
;
2617 struct lpfc_rport_data
*rdata
= lpfc_cmd
->rdata
;
2618 struct lpfc_nodelist
*pnode
= rdata
->pnode
;
2619 struct scsi_cmnd
*cmd
;
2621 struct scsi_device
*tmp_sdev
;
2623 unsigned long flags
;
2624 struct lpfc_fast_path_event
*fast_path_evt
;
2625 struct Scsi_Host
*shost
;
2626 uint32_t queue_depth
, scsi_id
;
2627 uint32_t logit
= LOG_FCP
;
2629 /* Sanity check on return of outstanding command */
2630 if (!(lpfc_cmd
->pCmd
))
2632 cmd
= lpfc_cmd
->pCmd
;
2633 shost
= cmd
->device
->host
;
2635 lpfc_cmd
->result
= pIocbOut
->iocb
.un
.ulpWord
[4];
2636 lpfc_cmd
->status
= pIocbOut
->iocb
.ulpStatus
;
2637 /* pick up SLI4 exhange busy status from HBA */
2638 lpfc_cmd
->exch_busy
= pIocbOut
->iocb_flag
& LPFC_EXCHANGE_BUSY
;
2640 if (pnode
&& NLP_CHK_NODE_ACT(pnode
))
2641 atomic_dec(&pnode
->cmd_pending
);
2643 if (lpfc_cmd
->status
) {
2644 if (lpfc_cmd
->status
== IOSTAT_LOCAL_REJECT
&&
2645 (lpfc_cmd
->result
& IOERR_DRVR_MASK
))
2646 lpfc_cmd
->status
= IOSTAT_DRIVER_REJECT
;
2647 else if (lpfc_cmd
->status
>= IOSTAT_CNT
)
2648 lpfc_cmd
->status
= IOSTAT_DEFAULT
;
2649 if (lpfc_cmd
->status
== IOSTAT_FCP_RSP_ERROR
2650 && !lpfc_cmd
->fcp_rsp
->rspStatus3
2651 && (lpfc_cmd
->fcp_rsp
->rspStatus2
& RESID_UNDER
)
2652 && !(phba
->cfg_log_verbose
& LOG_FCP_UNDER
))
2655 logit
= LOG_FCP
| LOG_FCP_UNDER
;
2656 lpfc_printf_vlog(vport
, KERN_WARNING
, logit
,
2657 "9030 FCP cmd x%x failed <%d/%d> "
2658 "status: x%x result: x%x Data: x%x x%x\n",
2660 cmd
->device
? cmd
->device
->id
: 0xffff,
2661 cmd
->device
? cmd
->device
->lun
: 0xffff,
2662 lpfc_cmd
->status
, lpfc_cmd
->result
,
2663 pIocbOut
->iocb
.ulpContext
,
2664 lpfc_cmd
->cur_iocbq
.iocb
.ulpIoTag
);
2666 switch (lpfc_cmd
->status
) {
2667 case IOSTAT_FCP_RSP_ERROR
:
2668 /* Call FCP RSP handler to determine result */
2669 lpfc_handle_fcp_err(vport
, lpfc_cmd
, pIocbOut
);
2671 case IOSTAT_NPORT_BSY
:
2672 case IOSTAT_FABRIC_BSY
:
2673 cmd
->result
= ScsiResult(DID_TRANSPORT_DISRUPTED
, 0);
2674 fast_path_evt
= lpfc_alloc_fast_evt(phba
);
2677 fast_path_evt
->un
.fabric_evt
.event_type
=
2678 FC_REG_FABRIC_EVENT
;
2679 fast_path_evt
->un
.fabric_evt
.subcategory
=
2680 (lpfc_cmd
->status
== IOSTAT_NPORT_BSY
) ?
2681 LPFC_EVENT_PORT_BUSY
: LPFC_EVENT_FABRIC_BUSY
;
2682 if (pnode
&& NLP_CHK_NODE_ACT(pnode
)) {
2683 memcpy(&fast_path_evt
->un
.fabric_evt
.wwpn
,
2684 &pnode
->nlp_portname
,
2685 sizeof(struct lpfc_name
));
2686 memcpy(&fast_path_evt
->un
.fabric_evt
.wwnn
,
2687 &pnode
->nlp_nodename
,
2688 sizeof(struct lpfc_name
));
2690 fast_path_evt
->vport
= vport
;
2691 fast_path_evt
->work_evt
.evt
=
2692 LPFC_EVT_FASTPATH_MGMT_EVT
;
2693 spin_lock_irqsave(&phba
->hbalock
, flags
);
2694 list_add_tail(&fast_path_evt
->work_evt
.evt_listp
,
2696 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
2697 lpfc_worker_wake_up(phba
);
2699 case IOSTAT_LOCAL_REJECT
:
2700 case IOSTAT_REMOTE_STOP
:
2701 if (lpfc_cmd
->result
== IOERR_ELXSEC_KEY_UNWRAP_ERROR
||
2703 IOERR_ELXSEC_KEY_UNWRAP_COMPARE_ERROR
||
2704 lpfc_cmd
->result
== IOERR_ELXSEC_CRYPTO_ERROR
||
2706 IOERR_ELXSEC_CRYPTO_COMPARE_ERROR
) {
2707 cmd
->result
= ScsiResult(DID_NO_CONNECT
, 0);
2710 if (lpfc_cmd
->result
== IOERR_INVALID_RPI
||
2711 lpfc_cmd
->result
== IOERR_NO_RESOURCES
||
2712 lpfc_cmd
->result
== IOERR_ABORT_REQUESTED
||
2713 lpfc_cmd
->result
== IOERR_SLER_CMD_RCV_FAILURE
) {
2714 cmd
->result
= ScsiResult(DID_REQUEUE
, 0);
2717 if ((lpfc_cmd
->result
== IOERR_RX_DMA_FAILED
||
2718 lpfc_cmd
->result
== IOERR_TX_DMA_FAILED
) &&
2719 pIocbOut
->iocb
.unsli3
.sli3_bg
.bgstat
) {
2720 if (scsi_get_prot_op(cmd
) != SCSI_PROT_NORMAL
) {
2722 * This is a response for a BG enabled
2723 * cmd. Parse BG error
2725 lpfc_parse_bg_err(phba
, lpfc_cmd
,
2729 lpfc_printf_vlog(vport
, KERN_WARNING
,
2731 "9031 non-zero BGSTAT "
2732 "on unprotected cmd\n");
2735 if ((lpfc_cmd
->status
== IOSTAT_REMOTE_STOP
)
2736 && (phba
->sli_rev
== LPFC_SLI_REV4
)
2737 && (pnode
&& NLP_CHK_NODE_ACT(pnode
))) {
2738 /* This IO was aborted by the target, we don't
2739 * know the rxid and because we did not send the
2740 * ABTS we cannot generate and RRQ.
2742 lpfc_set_rrq_active(phba
, pnode
,
2743 lpfc_cmd
->cur_iocbq
.sli4_xritag
,
2746 /* else: fall through */
2748 cmd
->result
= ScsiResult(DID_ERROR
, 0);
2752 if (!pnode
|| !NLP_CHK_NODE_ACT(pnode
)
2753 || (pnode
->nlp_state
!= NLP_STE_MAPPED_NODE
))
2754 cmd
->result
= ScsiResult(DID_TRANSPORT_DISRUPTED
,
2757 cmd
->result
= ScsiResult(DID_OK
, 0);
2759 if (cmd
->result
|| lpfc_cmd
->fcp_rsp
->rspSnsLen
) {
2760 uint32_t *lp
= (uint32_t *)cmd
->sense_buffer
;
2762 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
2763 "0710 Iodone <%d/%d> cmd %p, error "
2764 "x%x SNS x%x x%x Data: x%x x%x\n",
2765 cmd
->device
->id
, cmd
->device
->lun
, cmd
,
2766 cmd
->result
, *lp
, *(lp
+ 3), cmd
->retries
,
2767 scsi_get_resid(cmd
));
2770 lpfc_update_stats(phba
, lpfc_cmd
);
2771 result
= cmd
->result
;
2772 if (vport
->cfg_max_scsicmpl_time
&&
2773 time_after(jiffies
, lpfc_cmd
->start_time
+
2774 msecs_to_jiffies(vport
->cfg_max_scsicmpl_time
))) {
2775 spin_lock_irqsave(shost
->host_lock
, flags
);
2776 if (pnode
&& NLP_CHK_NODE_ACT(pnode
)) {
2777 if (pnode
->cmd_qdepth
>
2778 atomic_read(&pnode
->cmd_pending
) &&
2779 (atomic_read(&pnode
->cmd_pending
) >
2780 LPFC_MIN_TGT_QDEPTH
) &&
2781 ((cmd
->cmnd
[0] == READ_10
) ||
2782 (cmd
->cmnd
[0] == WRITE_10
)))
2784 atomic_read(&pnode
->cmd_pending
);
2786 pnode
->last_change_time
= jiffies
;
2788 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2789 } else if (pnode
&& NLP_CHK_NODE_ACT(pnode
)) {
2790 if ((pnode
->cmd_qdepth
< vport
->cfg_tgt_queue_depth
) &&
2791 time_after(jiffies
, pnode
->last_change_time
+
2792 msecs_to_jiffies(LPFC_TGTQ_INTERVAL
))) {
2793 spin_lock_irqsave(shost
->host_lock
, flags
);
2794 depth
= pnode
->cmd_qdepth
* LPFC_TGTQ_RAMPUP_PCENT
2796 depth
= depth
? depth
: 1;
2797 pnode
->cmd_qdepth
+= depth
;
2798 if (pnode
->cmd_qdepth
> vport
->cfg_tgt_queue_depth
)
2799 pnode
->cmd_qdepth
= vport
->cfg_tgt_queue_depth
;
2800 pnode
->last_change_time
= jiffies
;
2801 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2805 lpfc_scsi_unprep_dma_buf(phba
, lpfc_cmd
);
2807 /* The sdev is not guaranteed to be valid post scsi_done upcall. */
2808 queue_depth
= cmd
->device
->queue_depth
;
2809 scsi_id
= cmd
->device
->id
;
2810 cmd
->scsi_done(cmd
);
2812 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
2814 * If there is a thread waiting for command completion
2815 * wake up the thread.
2817 spin_lock_irqsave(shost
->host_lock
, flags
);
2818 lpfc_cmd
->pCmd
= NULL
;
2819 if (lpfc_cmd
->waitq
)
2820 wake_up(lpfc_cmd
->waitq
);
2821 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2822 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
2827 lpfc_rampup_queue_depth(vport
, queue_depth
);
2830 * Check for queue full. If the lun is reporting queue full, then
2831 * back off the lun queue depth to prevent target overloads.
2833 if (result
== SAM_STAT_TASK_SET_FULL
&& pnode
&&
2834 NLP_CHK_NODE_ACT(pnode
)) {
2835 shost_for_each_device(tmp_sdev
, shost
) {
2836 if (tmp_sdev
->id
!= scsi_id
)
2838 depth
= scsi_track_queue_full(tmp_sdev
,
2839 tmp_sdev
->queue_depth
-1);
2842 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
2843 "0711 detected queue full - lun queue "
2844 "depth adjusted to %d.\n", depth
);
2845 lpfc_send_sdev_queuedepth_change_event(phba
, vport
,
2853 * If there is a thread waiting for command completion
2854 * wake up the thread.
2856 spin_lock_irqsave(shost
->host_lock
, flags
);
2857 lpfc_cmd
->pCmd
= NULL
;
2858 if (lpfc_cmd
->waitq
)
2859 wake_up(lpfc_cmd
->waitq
);
2860 spin_unlock_irqrestore(shost
->host_lock
, flags
);
2862 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
2866 * lpfc_fcpcmd_to_iocb - copy the fcp_cmd data into the IOCB
2867 * @data: A pointer to the immediate command data portion of the IOCB.
2868 * @fcp_cmnd: The FCP Command that is provided by the SCSI layer.
2870 * The routine copies the entire FCP command from @fcp_cmnd to @data while
2871 * byte swapping the data to big endian format for transmission on the wire.
2874 lpfc_fcpcmd_to_iocb(uint8_t *data
, struct fcp_cmnd
*fcp_cmnd
)
2877 for (i
= 0, j
= 0; i
< sizeof(struct fcp_cmnd
);
2878 i
+= sizeof(uint32_t), j
++) {
2879 ((uint32_t *)data
)[j
] = cpu_to_be32(((uint32_t *)fcp_cmnd
)[j
]);
2884 * lpfc_scsi_prep_cmnd - Wrapper func for convert scsi cmnd to FCP info unit
2885 * @vport: The virtual port for which this call is being executed.
2886 * @lpfc_cmd: The scsi command which needs to send.
2887 * @pnode: Pointer to lpfc_nodelist.
2889 * This routine initializes fcp_cmnd and iocb data structure from scsi command
2890 * to transfer for device with SLI3 interface spec.
2893 lpfc_scsi_prep_cmnd(struct lpfc_vport
*vport
, struct lpfc_scsi_buf
*lpfc_cmd
,
2894 struct lpfc_nodelist
*pnode
)
2896 struct lpfc_hba
*phba
= vport
->phba
;
2897 struct scsi_cmnd
*scsi_cmnd
= lpfc_cmd
->pCmd
;
2898 struct fcp_cmnd
*fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
2899 IOCB_t
*iocb_cmd
= &lpfc_cmd
->cur_iocbq
.iocb
;
2900 struct lpfc_iocbq
*piocbq
= &(lpfc_cmd
->cur_iocbq
);
2901 int datadir
= scsi_cmnd
->sc_data_direction
;
2904 if (!pnode
|| !NLP_CHK_NODE_ACT(pnode
))
2907 lpfc_cmd
->fcp_rsp
->rspSnsLen
= 0;
2908 /* clear task management bits */
2909 lpfc_cmd
->fcp_cmnd
->fcpCntl2
= 0;
2911 int_to_scsilun(lpfc_cmd
->pCmd
->device
->lun
,
2912 &lpfc_cmd
->fcp_cmnd
->fcp_lun
);
2914 memcpy(&fcp_cmnd
->fcpCdb
[0], scsi_cmnd
->cmnd
, 16);
2916 if (scsi_populate_tag_msg(scsi_cmnd
, tag
)) {
2918 case HEAD_OF_QUEUE_TAG
:
2919 fcp_cmnd
->fcpCntl1
= HEAD_OF_Q
;
2921 case ORDERED_QUEUE_TAG
:
2922 fcp_cmnd
->fcpCntl1
= ORDERED_Q
;
2925 fcp_cmnd
->fcpCntl1
= SIMPLE_Q
;
2929 fcp_cmnd
->fcpCntl1
= 0;
2932 * There are three possibilities here - use scatter-gather segment, use
2933 * the single mapping, or neither. Start the lpfc command prep by
2934 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
2937 if (scsi_sg_count(scsi_cmnd
)) {
2938 if (datadir
== DMA_TO_DEVICE
) {
2939 iocb_cmd
->ulpCommand
= CMD_FCP_IWRITE64_CR
;
2940 if (phba
->sli_rev
< LPFC_SLI_REV4
) {
2941 iocb_cmd
->un
.fcpi
.fcpi_parm
= 0;
2942 iocb_cmd
->ulpPU
= 0;
2944 iocb_cmd
->ulpPU
= PARM_READ_CHECK
;
2945 fcp_cmnd
->fcpCntl3
= WRITE_DATA
;
2946 phba
->fc4OutputRequests
++;
2948 iocb_cmd
->ulpCommand
= CMD_FCP_IREAD64_CR
;
2949 iocb_cmd
->ulpPU
= PARM_READ_CHECK
;
2950 fcp_cmnd
->fcpCntl3
= READ_DATA
;
2951 phba
->fc4InputRequests
++;
2954 iocb_cmd
->ulpCommand
= CMD_FCP_ICMND64_CR
;
2955 iocb_cmd
->un
.fcpi
.fcpi_parm
= 0;
2956 iocb_cmd
->ulpPU
= 0;
2957 fcp_cmnd
->fcpCntl3
= 0;
2958 phba
->fc4ControlRequests
++;
2960 if (phba
->sli_rev
== 3 &&
2961 !(phba
->sli3_options
& LPFC_SLI3_BG_ENABLED
))
2962 lpfc_fcpcmd_to_iocb(iocb_cmd
->unsli3
.fcp_ext
.icd
, fcp_cmnd
);
2964 * Finish initializing those IOCB fields that are independent
2965 * of the scsi_cmnd request_buffer
2967 piocbq
->iocb
.ulpContext
= pnode
->nlp_rpi
;
2968 if (phba
->sli_rev
== LPFC_SLI_REV4
)
2969 piocbq
->iocb
.ulpContext
=
2970 phba
->sli4_hba
.rpi_ids
[pnode
->nlp_rpi
];
2971 if (pnode
->nlp_fcp_info
& NLP_FCP_2_DEVICE
)
2972 piocbq
->iocb
.ulpFCP2Rcvy
= 1;
2974 piocbq
->iocb
.ulpFCP2Rcvy
= 0;
2976 piocbq
->iocb
.ulpClass
= (pnode
->nlp_fcp_info
& 0x0f);
2977 piocbq
->context1
= lpfc_cmd
;
2978 piocbq
->iocb_cmpl
= lpfc_scsi_cmd_iocb_cmpl
;
2979 piocbq
->iocb
.ulpTimeout
= lpfc_cmd
->timeout
;
2980 piocbq
->vport
= vport
;
2984 * lpfc_scsi_prep_task_mgmt_cmd - Convert SLI3 scsi TM cmd to FCP info unit
2985 * @vport: The virtual port for which this call is being executed.
2986 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
2987 * @lun: Logical unit number.
2988 * @task_mgmt_cmd: SCSI task management command.
2990 * This routine creates FCP information unit corresponding to @task_mgmt_cmd
2991 * for device with SLI-3 interface spec.
2998 lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport
*vport
,
2999 struct lpfc_scsi_buf
*lpfc_cmd
,
3001 uint8_t task_mgmt_cmd
)
3003 struct lpfc_iocbq
*piocbq
;
3005 struct fcp_cmnd
*fcp_cmnd
;
3006 struct lpfc_rport_data
*rdata
= lpfc_cmd
->rdata
;
3007 struct lpfc_nodelist
*ndlp
= rdata
->pnode
;
3009 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
) ||
3010 ndlp
->nlp_state
!= NLP_STE_MAPPED_NODE
)
3013 piocbq
= &(lpfc_cmd
->cur_iocbq
);
3014 piocbq
->vport
= vport
;
3016 piocb
= &piocbq
->iocb
;
3018 fcp_cmnd
= lpfc_cmd
->fcp_cmnd
;
3019 /* Clear out any old data in the FCP command area */
3020 memset(fcp_cmnd
, 0, sizeof(struct fcp_cmnd
));
3021 int_to_scsilun(lun
, &fcp_cmnd
->fcp_lun
);
3022 fcp_cmnd
->fcpCntl2
= task_mgmt_cmd
;
3023 if (vport
->phba
->sli_rev
== 3 &&
3024 !(vport
->phba
->sli3_options
& LPFC_SLI3_BG_ENABLED
))
3025 lpfc_fcpcmd_to_iocb(piocb
->unsli3
.fcp_ext
.icd
, fcp_cmnd
);
3026 piocb
->ulpCommand
= CMD_FCP_ICMND64_CR
;
3027 piocb
->ulpContext
= ndlp
->nlp_rpi
;
3028 if (vport
->phba
->sli_rev
== LPFC_SLI_REV4
) {
3030 vport
->phba
->sli4_hba
.rpi_ids
[ndlp
->nlp_rpi
];
3032 if (ndlp
->nlp_fcp_info
& NLP_FCP_2_DEVICE
) {
3033 piocb
->ulpFCP2Rcvy
= 1;
3035 piocb
->ulpClass
= (ndlp
->nlp_fcp_info
& 0x0f);
3037 /* ulpTimeout is only one byte */
3038 if (lpfc_cmd
->timeout
> 0xff) {
3040 * Do not timeout the command at the firmware level.
3041 * The driver will provide the timeout mechanism.
3043 piocb
->ulpTimeout
= 0;
3045 piocb
->ulpTimeout
= lpfc_cmd
->timeout
;
3047 if (vport
->phba
->sli_rev
== LPFC_SLI_REV4
)
3048 lpfc_sli4_set_rsp_sgl_last(vport
->phba
, lpfc_cmd
);
3054 * lpfc_scsi_api_table_setup - Set up scsi api function jump table
3055 * @phba: The hba struct for which this call is being executed.
3056 * @dev_grp: The HBA PCI-Device group number.
3058 * This routine sets up the SCSI interface API function jump table in @phba
3060 * Returns: 0 - success, -ENODEV - failure.
3063 lpfc_scsi_api_table_setup(struct lpfc_hba
*phba
, uint8_t dev_grp
)
3066 phba
->lpfc_scsi_unprep_dma_buf
= lpfc_scsi_unprep_dma_buf
;
3067 phba
->lpfc_scsi_prep_cmnd
= lpfc_scsi_prep_cmnd
;
3070 case LPFC_PCI_DEV_LP
:
3071 phba
->lpfc_new_scsi_buf
= lpfc_new_scsi_buf_s3
;
3072 phba
->lpfc_scsi_prep_dma_buf
= lpfc_scsi_prep_dma_buf_s3
;
3073 phba
->lpfc_release_scsi_buf
= lpfc_release_scsi_buf_s3
;
3074 phba
->lpfc_get_scsi_buf
= lpfc_get_scsi_buf_s3
;
3076 case LPFC_PCI_DEV_OC
:
3077 phba
->lpfc_new_scsi_buf
= lpfc_new_scsi_buf_s4
;
3078 phba
->lpfc_scsi_prep_dma_buf
= lpfc_scsi_prep_dma_buf_s4
;
3079 phba
->lpfc_release_scsi_buf
= lpfc_release_scsi_buf_s4
;
3080 phba
->lpfc_get_scsi_buf
= lpfc_get_scsi_buf_s4
;
3083 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3084 "1418 Invalid HBA PCI-device group: 0x%x\n",
3089 phba
->lpfc_rampdown_queue_depth
= lpfc_rampdown_queue_depth
;
3090 phba
->lpfc_scsi_cmd_iocb_cmpl
= lpfc_scsi_cmd_iocb_cmpl
;
3095 * lpfc_taskmgmt_def_cmpl - IOCB completion routine for task management command
3096 * @phba: The Hba for which this call is being executed.
3097 * @cmdiocbq: Pointer to lpfc_iocbq data structure.
3098 * @rspiocbq: Pointer to lpfc_iocbq data structure.
3100 * This routine is IOCB completion routine for device reset and target reset
3101 * routine. This routine release scsi buffer associated with lpfc_cmd.
3104 lpfc_tskmgmt_def_cmpl(struct lpfc_hba
*phba
,
3105 struct lpfc_iocbq
*cmdiocbq
,
3106 struct lpfc_iocbq
*rspiocbq
)
3108 struct lpfc_scsi_buf
*lpfc_cmd
=
3109 (struct lpfc_scsi_buf
*) cmdiocbq
->context1
;
3111 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
3116 * lpfc_info - Info entry point of scsi_host_template data structure
3117 * @host: The scsi host for which this call is being executed.
3119 * This routine provides module information about hba.
3122 * Pointer to char - Success.
3125 lpfc_info(struct Scsi_Host
*host
)
3127 struct lpfc_vport
*vport
= (struct lpfc_vport
*) host
->hostdata
;
3128 struct lpfc_hba
*phba
= vport
->phba
;
3130 static char lpfcinfobuf
[384];
3132 memset(lpfcinfobuf
,0,384);
3133 if (phba
&& phba
->pcidev
){
3134 strncpy(lpfcinfobuf
, phba
->ModelDesc
, 256);
3135 len
= strlen(lpfcinfobuf
);
3136 snprintf(lpfcinfobuf
+ len
,
3138 " on PCI bus %02x device %02x irq %d",
3139 phba
->pcidev
->bus
->number
,
3140 phba
->pcidev
->devfn
,
3142 len
= strlen(lpfcinfobuf
);
3143 if (phba
->Port
[0]) {
3144 snprintf(lpfcinfobuf
+ len
,
3149 len
= strlen(lpfcinfobuf
);
3150 if (phba
->sli4_hba
.link_state
.logical_speed
) {
3151 snprintf(lpfcinfobuf
+ len
,
3153 " Logical Link Speed: %d Mbps",
3154 phba
->sli4_hba
.link_state
.logical_speed
* 10);
3161 * lpfc_poll_rearm_time - Routine to modify fcp_poll timer of hba
3162 * @phba: The Hba for which this call is being executed.
3164 * This routine modifies fcp_poll_timer field of @phba by cfg_poll_tmo.
3165 * The default value of cfg_poll_tmo is 10 milliseconds.
3167 static __inline__
void lpfc_poll_rearm_timer(struct lpfc_hba
* phba
)
3169 unsigned long poll_tmo_expires
=
3170 (jiffies
+ msecs_to_jiffies(phba
->cfg_poll_tmo
));
3172 if (phba
->sli
.ring
[LPFC_FCP_RING
].txcmplq_cnt
)
3173 mod_timer(&phba
->fcp_poll_timer
,
3178 * lpfc_poll_start_timer - Routine to start fcp_poll_timer of HBA
3179 * @phba: The Hba for which this call is being executed.
3181 * This routine starts the fcp_poll_timer of @phba.
3183 void lpfc_poll_start_timer(struct lpfc_hba
* phba
)
3185 lpfc_poll_rearm_timer(phba
);
3189 * lpfc_poll_timeout - Restart polling timer
3190 * @ptr: Map to lpfc_hba data structure pointer.
3192 * This routine restarts fcp_poll timer, when FCP ring polling is enable
3193 * and FCP Ring interrupt is disable.
3196 void lpfc_poll_timeout(unsigned long ptr
)
3198 struct lpfc_hba
*phba
= (struct lpfc_hba
*) ptr
;
3200 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
3201 lpfc_sli_handle_fast_ring_event(phba
,
3202 &phba
->sli
.ring
[LPFC_FCP_RING
], HA_R0RE_REQ
);
3204 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
3205 lpfc_poll_rearm_timer(phba
);
3210 * lpfc_queuecommand - scsi_host_template queuecommand entry point
3211 * @cmnd: Pointer to scsi_cmnd data structure.
3212 * @done: Pointer to done routine.
3214 * Driver registers this routine to scsi midlayer to submit a @cmd to process.
3215 * This routine prepares an IOCB from scsi command and provides to firmware.
3216 * The @done callback is invoked after driver finished processing the command.
3220 * SCSI_MLQUEUE_HOST_BUSY - Block all devices served by this host temporarily.
3223 lpfc_queuecommand_lck(struct scsi_cmnd
*cmnd
, void (*done
) (struct scsi_cmnd
*))
3225 struct Scsi_Host
*shost
= cmnd
->device
->host
;
3226 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3227 struct lpfc_hba
*phba
= vport
->phba
;
3228 struct lpfc_rport_data
*rdata
= cmnd
->device
->hostdata
;
3229 struct lpfc_nodelist
*ndlp
;
3230 struct lpfc_scsi_buf
*lpfc_cmd
;
3231 struct fc_rport
*rport
= starget_to_rport(scsi_target(cmnd
->device
));
3234 err
= fc_remote_port_chkready(rport
);
3237 goto out_fail_command
;
3239 ndlp
= rdata
->pnode
;
3241 if ((scsi_get_prot_op(cmnd
) != SCSI_PROT_NORMAL
) &&
3242 (!(phba
->sli3_options
& LPFC_SLI3_BG_ENABLED
) ||
3243 (phba
->sli_rev
== LPFC_SLI_REV4
))) {
3245 lpfc_printf_log(phba
, KERN_ERR
, LOG_BG
,
3246 "9058 BLKGRD: ERROR: rcvd protected cmd:%02x"
3247 " op:%02x str=%s without registering for"
3248 " BlockGuard - Rejecting command\n",
3249 cmnd
->cmnd
[0], scsi_get_prot_op(cmnd
),
3250 dif_op_str
[scsi_get_prot_op(cmnd
)]);
3251 goto out_fail_command
;
3255 * Catch race where our node has transitioned, but the
3256 * transport is still transitioning.
3258 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
)) {
3259 cmnd
->result
= ScsiResult(DID_IMM_RETRY
, 0);
3260 goto out_fail_command
;
3262 if (atomic_read(&ndlp
->cmd_pending
) >= ndlp
->cmd_qdepth
)
3265 lpfc_cmd
= lpfc_get_scsi_buf(phba
, ndlp
);
3266 if (lpfc_cmd
== NULL
) {
3267 lpfc_rampdown_queue_depth(phba
);
3269 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
3270 "0707 driver's buffer pool is empty, "
3276 * Store the midlayer's command structure for the completion phase
3277 * and complete the command initialization.
3279 lpfc_cmd
->pCmd
= cmnd
;
3280 lpfc_cmd
->rdata
= rdata
;
3281 lpfc_cmd
->timeout
= 0;
3282 lpfc_cmd
->start_time
= jiffies
;
3283 cmnd
->host_scribble
= (unsigned char *)lpfc_cmd
;
3284 cmnd
->scsi_done
= done
;
3286 if (scsi_get_prot_op(cmnd
) != SCSI_PROT_NORMAL
) {
3287 if (vport
->phba
->cfg_enable_bg
) {
3288 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3289 "9033 BLKGRD: rcvd protected cmd:%02x op:%02x "
3291 cmnd
->cmnd
[0], scsi_get_prot_op(cmnd
),
3292 dif_op_str
[scsi_get_prot_op(cmnd
)]);
3293 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3294 "9034 BLKGRD: CDB: %02x %02x %02x %02x %02x "
3295 "%02x %02x %02x %02x %02x\n",
3296 cmnd
->cmnd
[0], cmnd
->cmnd
[1], cmnd
->cmnd
[2],
3297 cmnd
->cmnd
[3], cmnd
->cmnd
[4], cmnd
->cmnd
[5],
3298 cmnd
->cmnd
[6], cmnd
->cmnd
[7], cmnd
->cmnd
[8],
3300 if (cmnd
->cmnd
[0] == READ_10
)
3301 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3302 "9035 BLKGRD: READ @ sector %llu, "
3304 (unsigned long long)scsi_get_lba(cmnd
),
3305 blk_rq_sectors(cmnd
->request
));
3306 else if (cmnd
->cmnd
[0] == WRITE_10
)
3307 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3308 "9036 BLKGRD: WRITE @ sector %llu, "
3309 "count %u cmd=%p\n",
3310 (unsigned long long)scsi_get_lba(cmnd
),
3311 blk_rq_sectors(cmnd
->request
),
3315 err
= lpfc_bg_scsi_prep_dma_buf(phba
, lpfc_cmd
);
3317 if (vport
->phba
->cfg_enable_bg
) {
3318 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3319 "9038 BLKGRD: rcvd unprotected cmd:"
3320 "%02x op:%02x str=%s\n",
3321 cmnd
->cmnd
[0], scsi_get_prot_op(cmnd
),
3322 dif_op_str
[scsi_get_prot_op(cmnd
)]);
3323 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3324 "9039 BLKGRD: CDB: %02x %02x %02x "
3325 "%02x %02x %02x %02x %02x %02x %02x\n",
3326 cmnd
->cmnd
[0], cmnd
->cmnd
[1],
3327 cmnd
->cmnd
[2], cmnd
->cmnd
[3],
3328 cmnd
->cmnd
[4], cmnd
->cmnd
[5],
3329 cmnd
->cmnd
[6], cmnd
->cmnd
[7],
3330 cmnd
->cmnd
[8], cmnd
->cmnd
[9]);
3331 if (cmnd
->cmnd
[0] == READ_10
)
3332 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3333 "9040 dbg: READ @ sector %llu, "
3335 (unsigned long long)scsi_get_lba(cmnd
),
3336 blk_rq_sectors(cmnd
->request
));
3337 else if (cmnd
->cmnd
[0] == WRITE_10
)
3338 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3339 "9041 dbg: WRITE @ sector %llu, "
3340 "count %u cmd=%p\n",
3341 (unsigned long long)scsi_get_lba(cmnd
),
3342 blk_rq_sectors(cmnd
->request
), cmnd
);
3344 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_BG
,
3345 "9042 dbg: parser not implemented\n");
3347 err
= lpfc_scsi_prep_dma_buf(phba
, lpfc_cmd
);
3351 goto out_host_busy_free_buf
;
3353 lpfc_scsi_prep_cmnd(vport
, lpfc_cmd
, ndlp
);
3355 atomic_inc(&ndlp
->cmd_pending
);
3356 err
= lpfc_sli_issue_iocb(phba
, LPFC_FCP_RING
,
3357 &lpfc_cmd
->cur_iocbq
, SLI_IOCB_RET_IOCB
);
3359 atomic_dec(&ndlp
->cmd_pending
);
3360 goto out_host_busy_free_buf
;
3362 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
3363 spin_unlock(shost
->host_lock
);
3364 lpfc_sli_handle_fast_ring_event(phba
,
3365 &phba
->sli
.ring
[LPFC_FCP_RING
], HA_R0RE_REQ
);
3367 spin_lock(shost
->host_lock
);
3368 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
3369 lpfc_poll_rearm_timer(phba
);
3374 out_host_busy_free_buf
:
3375 lpfc_scsi_unprep_dma_buf(phba
, lpfc_cmd
);
3376 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
3378 return SCSI_MLQUEUE_HOST_BUSY
;
3381 return SCSI_MLQUEUE_TARGET_BUSY
;
3388 static DEF_SCSI_QCMD(lpfc_queuecommand
)
3391 * lpfc_abort_handler - scsi_host_template eh_abort_handler entry point
3392 * @cmnd: Pointer to scsi_cmnd data structure.
3394 * This routine aborts @cmnd pending in base driver.
3401 lpfc_abort_handler(struct scsi_cmnd
*cmnd
)
3403 struct Scsi_Host
*shost
= cmnd
->device
->host
;
3404 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3405 struct lpfc_hba
*phba
= vport
->phba
;
3406 struct lpfc_iocbq
*iocb
;
3407 struct lpfc_iocbq
*abtsiocb
;
3408 struct lpfc_scsi_buf
*lpfc_cmd
;
3411 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq
);
3413 ret
= fc_block_scsi_eh(cmnd
);
3416 lpfc_cmd
= (struct lpfc_scsi_buf
*)cmnd
->host_scribble
;
3418 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
3419 "2873 SCSI Layer I/O Abort Request IO CMPL Status "
3420 "x%x ID %d LUN %d\n",
3421 ret
, cmnd
->device
->id
, cmnd
->device
->lun
);
3426 * If pCmd field of the corresponding lpfc_scsi_buf structure
3427 * points to a different SCSI command, then the driver has
3428 * already completed this command, but the midlayer did not
3429 * see the completion before the eh fired. Just return
3432 iocb
= &lpfc_cmd
->cur_iocbq
;
3433 if (lpfc_cmd
->pCmd
!= cmnd
)
3436 BUG_ON(iocb
->context1
!= lpfc_cmd
);
3438 abtsiocb
= lpfc_sli_get_iocbq(phba
);
3439 if (abtsiocb
== NULL
) {
3445 * The scsi command can not be in txq and it is in flight because the
3446 * pCmd is still pointig at the SCSI command we have to abort. There
3447 * is no need to search the txcmplq. Just send an abort to the FW.
3451 icmd
= &abtsiocb
->iocb
;
3452 icmd
->un
.acxri
.abortType
= ABORT_TYPE_ABTS
;
3453 icmd
->un
.acxri
.abortContextTag
= cmd
->ulpContext
;
3454 if (phba
->sli_rev
== LPFC_SLI_REV4
)
3455 icmd
->un
.acxri
.abortIoTag
= iocb
->sli4_xritag
;
3457 icmd
->un
.acxri
.abortIoTag
= cmd
->ulpIoTag
;
3460 icmd
->ulpClass
= cmd
->ulpClass
;
3462 /* ABTS WQE must go to the same WQ as the WQE to be aborted */
3463 abtsiocb
->fcp_wqidx
= iocb
->fcp_wqidx
;
3464 abtsiocb
->iocb_flag
|= LPFC_USE_FCPWQIDX
;
3466 if (lpfc_is_link_up(phba
))
3467 icmd
->ulpCommand
= CMD_ABORT_XRI_CN
;
3469 icmd
->ulpCommand
= CMD_CLOSE_XRI_CN
;
3471 abtsiocb
->iocb_cmpl
= lpfc_sli_abort_fcp_cmpl
;
3472 abtsiocb
->vport
= vport
;
3473 if (lpfc_sli_issue_iocb(phba
, LPFC_FCP_RING
, abtsiocb
, 0) ==
3475 lpfc_sli_release_iocbq(phba
, abtsiocb
);
3480 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
3481 lpfc_sli_handle_fast_ring_event(phba
,
3482 &phba
->sli
.ring
[LPFC_FCP_RING
], HA_R0RE_REQ
);
3484 lpfc_cmd
->waitq
= &waitq
;
3485 /* Wait for abort to complete */
3486 wait_event_timeout(waitq
,
3487 (lpfc_cmd
->pCmd
!= cmnd
),
3488 (2*vport
->cfg_devloss_tmo
*HZ
));
3490 spin_lock_irq(shost
->host_lock
);
3491 lpfc_cmd
->waitq
= NULL
;
3492 spin_unlock_irq(shost
->host_lock
);
3494 if (lpfc_cmd
->pCmd
== cmnd
) {
3496 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3497 "0748 abort handler timed out waiting "
3498 "for abort to complete: ret %#x, ID %d, "
3500 ret
, cmnd
->device
->id
, cmnd
->device
->lun
);
3504 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
3505 "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
3506 "LUN %d\n", ret
, cmnd
->device
->id
,
3512 lpfc_taskmgmt_name(uint8_t task_mgmt_cmd
)
3514 switch (task_mgmt_cmd
) {
3515 case FCP_ABORT_TASK_SET
:
3516 return "ABORT_TASK_SET";
3517 case FCP_CLEAR_TASK_SET
:
3518 return "FCP_CLEAR_TASK_SET";
3520 return "FCP_BUS_RESET";
3522 return "FCP_LUN_RESET";
3523 case FCP_TARGET_RESET
:
3524 return "FCP_TARGET_RESET";
3526 return "FCP_CLEAR_ACA";
3527 case FCP_TERMINATE_TASK
:
3528 return "FCP_TERMINATE_TASK";
3535 * lpfc_send_taskmgmt - Generic SCSI Task Mgmt Handler
3536 * @vport: The virtual port for which this call is being executed.
3537 * @rdata: Pointer to remote port local data
3538 * @tgt_id: Target ID of remote device.
3539 * @lun_id: Lun number for the TMF
3540 * @task_mgmt_cmd: type of TMF to send
3542 * This routine builds and sends a TMF (SCSI Task Mgmt Function) to
3550 lpfc_send_taskmgmt(struct lpfc_vport
*vport
, struct lpfc_rport_data
*rdata
,
3551 unsigned tgt_id
, unsigned int lun_id
,
3552 uint8_t task_mgmt_cmd
)
3554 struct lpfc_hba
*phba
= vport
->phba
;
3555 struct lpfc_scsi_buf
*lpfc_cmd
;
3556 struct lpfc_iocbq
*iocbq
;
3557 struct lpfc_iocbq
*iocbqrsp
;
3558 struct lpfc_nodelist
*pnode
= rdata
->pnode
;
3562 if (!pnode
|| !NLP_CHK_NODE_ACT(pnode
))
3565 lpfc_cmd
= lpfc_get_scsi_buf(phba
, rdata
->pnode
);
3566 if (lpfc_cmd
== NULL
)
3568 lpfc_cmd
->timeout
= 60;
3569 lpfc_cmd
->rdata
= rdata
;
3571 status
= lpfc_scsi_prep_task_mgmt_cmd(vport
, lpfc_cmd
, lun_id
,
3574 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
3578 iocbq
= &lpfc_cmd
->cur_iocbq
;
3579 iocbqrsp
= lpfc_sli_get_iocbq(phba
);
3580 if (iocbqrsp
== NULL
) {
3581 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
3585 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
3586 "0702 Issue %s to TGT %d LUN %d "
3587 "rpi x%x nlp_flag x%x Data: x%x x%x\n",
3588 lpfc_taskmgmt_name(task_mgmt_cmd
), tgt_id
, lun_id
,
3589 pnode
->nlp_rpi
, pnode
->nlp_flag
, iocbq
->sli4_xritag
,
3592 status
= lpfc_sli_issue_iocb_wait(phba
, LPFC_FCP_RING
,
3593 iocbq
, iocbqrsp
, lpfc_cmd
->timeout
);
3594 if (status
!= IOCB_SUCCESS
) {
3595 if (status
== IOCB_TIMEDOUT
) {
3596 iocbq
->iocb_cmpl
= lpfc_tskmgmt_def_cmpl
;
3597 ret
= TIMEOUT_ERROR
;
3600 lpfc_cmd
->status
= IOSTAT_DRIVER_REJECT
;
3601 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3602 "0727 TMF %s to TGT %d LUN %d failed (%d, %d) "
3604 lpfc_taskmgmt_name(task_mgmt_cmd
),
3605 tgt_id
, lun_id
, iocbqrsp
->iocb
.ulpStatus
,
3606 iocbqrsp
->iocb
.un
.ulpWord
[4],
3608 } else if (status
== IOCB_BUSY
)
3613 lpfc_sli_release_iocbq(phba
, iocbqrsp
);
3615 if (ret
!= TIMEOUT_ERROR
)
3616 lpfc_release_scsi_buf(phba
, lpfc_cmd
);
3622 * lpfc_chk_tgt_mapped -
3623 * @vport: The virtual port to check on
3624 * @cmnd: Pointer to scsi_cmnd data structure.
3626 * This routine delays until the scsi target (aka rport) for the
3627 * command exists (is present and logged in) or we declare it non-existent.
3634 lpfc_chk_tgt_mapped(struct lpfc_vport
*vport
, struct scsi_cmnd
*cmnd
)
3636 struct lpfc_rport_data
*rdata
= cmnd
->device
->hostdata
;
3637 struct lpfc_nodelist
*pnode
;
3638 unsigned long later
;
3641 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FCP
,
3642 "0797 Tgt Map rport failure: rdata x%p\n", rdata
);
3645 pnode
= rdata
->pnode
;
3647 * If target is not in a MAPPED state, delay until
3648 * target is rediscovered or devloss timeout expires.
3650 later
= msecs_to_jiffies(2 * vport
->cfg_devloss_tmo
* 1000) + jiffies
;
3651 while (time_after(later
, jiffies
)) {
3652 if (!pnode
|| !NLP_CHK_NODE_ACT(pnode
))
3654 if (pnode
->nlp_state
== NLP_STE_MAPPED_NODE
)
3656 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
3657 rdata
= cmnd
->device
->hostdata
;
3660 pnode
= rdata
->pnode
;
3662 if (!pnode
|| !NLP_CHK_NODE_ACT(pnode
) ||
3663 (pnode
->nlp_state
!= NLP_STE_MAPPED_NODE
))
3669 * lpfc_reset_flush_io_context -
3670 * @vport: The virtual port (scsi_host) for the flush context
3671 * @tgt_id: If aborting by Target contect - specifies the target id
3672 * @lun_id: If aborting by Lun context - specifies the lun id
3673 * @context: specifies the context level to flush at.
3675 * After a reset condition via TMF, we need to flush orphaned i/o
3676 * contexts from the adapter. This routine aborts any contexts
3677 * outstanding, then waits for their completions. The wait is
3678 * bounded by devloss_tmo though.
3685 lpfc_reset_flush_io_context(struct lpfc_vport
*vport
, uint16_t tgt_id
,
3686 uint64_t lun_id
, lpfc_ctx_cmd context
)
3688 struct lpfc_hba
*phba
= vport
->phba
;
3689 unsigned long later
;
3692 cnt
= lpfc_sli_sum_iocb(vport
, tgt_id
, lun_id
, context
);
3694 lpfc_sli_abort_iocb(vport
, &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
3695 tgt_id
, lun_id
, context
);
3696 later
= msecs_to_jiffies(2 * vport
->cfg_devloss_tmo
* 1000) + jiffies
;
3697 while (time_after(later
, jiffies
) && cnt
) {
3698 schedule_timeout_uninterruptible(msecs_to_jiffies(20));
3699 cnt
= lpfc_sli_sum_iocb(vport
, tgt_id
, lun_id
, context
);
3702 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3703 "0724 I/O flush failure for context %s : cnt x%x\n",
3704 ((context
== LPFC_CTX_LUN
) ? "LUN" :
3705 ((context
== LPFC_CTX_TGT
) ? "TGT" :
3706 ((context
== LPFC_CTX_HOST
) ? "HOST" : "Unknown"))),
3714 * lpfc_device_reset_handler - scsi_host_template eh_device_reset entry point
3715 * @cmnd: Pointer to scsi_cmnd data structure.
3717 * This routine does a device reset by sending a LUN_RESET task management
3725 lpfc_device_reset_handler(struct scsi_cmnd
*cmnd
)
3727 struct Scsi_Host
*shost
= cmnd
->device
->host
;
3728 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3729 struct lpfc_rport_data
*rdata
= cmnd
->device
->hostdata
;
3730 struct lpfc_nodelist
*pnode
;
3731 unsigned tgt_id
= cmnd
->device
->id
;
3732 unsigned int lun_id
= cmnd
->device
->lun
;
3733 struct lpfc_scsi_event_header scsi_event
;
3737 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3738 "0798 Device Reset rport failure: rdata x%p\n", rdata
);
3741 pnode
= rdata
->pnode
;
3742 status
= fc_block_scsi_eh(cmnd
);
3746 status
= lpfc_chk_tgt_mapped(vport
, cmnd
);
3747 if (status
== FAILED
) {
3748 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3749 "0721 Device Reset rport failure: rdata x%p\n", rdata
);
3753 scsi_event
.event_type
= FC_REG_SCSI_EVENT
;
3754 scsi_event
.subcategory
= LPFC_EVENT_LUNRESET
;
3755 scsi_event
.lun
= lun_id
;
3756 memcpy(scsi_event
.wwpn
, &pnode
->nlp_portname
, sizeof(struct lpfc_name
));
3757 memcpy(scsi_event
.wwnn
, &pnode
->nlp_nodename
, sizeof(struct lpfc_name
));
3759 fc_host_post_vendor_event(shost
, fc_get_event_number(),
3760 sizeof(scsi_event
), (char *)&scsi_event
, LPFC_NL_VENDOR_ID
);
3762 status
= lpfc_send_taskmgmt(vport
, rdata
, tgt_id
, lun_id
,
3765 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3766 "0713 SCSI layer issued Device Reset (%d, %d) "
3767 "return x%x\n", tgt_id
, lun_id
, status
);
3770 * We have to clean up i/o as : they may be orphaned by the TMF;
3771 * or if the TMF failed, they may be in an indeterminate state.
3773 * We will report success if all the i/o aborts successfully.
3775 status
= lpfc_reset_flush_io_context(vport
, tgt_id
, lun_id
,
3781 * lpfc_target_reset_handler - scsi_host_template eh_target_reset entry point
3782 * @cmnd: Pointer to scsi_cmnd data structure.
3784 * This routine does a target reset by sending a TARGET_RESET task management
3792 lpfc_target_reset_handler(struct scsi_cmnd
*cmnd
)
3794 struct Scsi_Host
*shost
= cmnd
->device
->host
;
3795 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3796 struct lpfc_rport_data
*rdata
= cmnd
->device
->hostdata
;
3797 struct lpfc_nodelist
*pnode
;
3798 unsigned tgt_id
= cmnd
->device
->id
;
3799 unsigned int lun_id
= cmnd
->device
->lun
;
3800 struct lpfc_scsi_event_header scsi_event
;
3804 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3805 "0799 Target Reset rport failure: rdata x%p\n", rdata
);
3808 pnode
= rdata
->pnode
;
3809 status
= fc_block_scsi_eh(cmnd
);
3813 status
= lpfc_chk_tgt_mapped(vport
, cmnd
);
3814 if (status
== FAILED
) {
3815 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3816 "0722 Target Reset rport failure: rdata x%p\n", rdata
);
3820 scsi_event
.event_type
= FC_REG_SCSI_EVENT
;
3821 scsi_event
.subcategory
= LPFC_EVENT_TGTRESET
;
3823 memcpy(scsi_event
.wwpn
, &pnode
->nlp_portname
, sizeof(struct lpfc_name
));
3824 memcpy(scsi_event
.wwnn
, &pnode
->nlp_nodename
, sizeof(struct lpfc_name
));
3826 fc_host_post_vendor_event(shost
, fc_get_event_number(),
3827 sizeof(scsi_event
), (char *)&scsi_event
, LPFC_NL_VENDOR_ID
);
3829 status
= lpfc_send_taskmgmt(vport
, rdata
, tgt_id
, lun_id
,
3832 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3833 "0723 SCSI layer issued Target Reset (%d, %d) "
3834 "return x%x\n", tgt_id
, lun_id
, status
);
3837 * We have to clean up i/o as : they may be orphaned by the TMF;
3838 * or if the TMF failed, they may be in an indeterminate state.
3840 * We will report success if all the i/o aborts successfully.
3842 status
= lpfc_reset_flush_io_context(vport
, tgt_id
, lun_id
,
3848 * lpfc_bus_reset_handler - scsi_host_template eh_bus_reset_handler entry point
3849 * @cmnd: Pointer to scsi_cmnd data structure.
3851 * This routine does target reset to all targets on @cmnd->device->host.
3852 * This emulates Parallel SCSI Bus Reset Semantics.
3859 lpfc_bus_reset_handler(struct scsi_cmnd
*cmnd
)
3861 struct Scsi_Host
*shost
= cmnd
->device
->host
;
3862 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3863 struct lpfc_nodelist
*ndlp
= NULL
;
3864 struct lpfc_scsi_event_header scsi_event
;
3866 int ret
= SUCCESS
, status
, i
;
3868 scsi_event
.event_type
= FC_REG_SCSI_EVENT
;
3869 scsi_event
.subcategory
= LPFC_EVENT_BUSRESET
;
3871 memcpy(scsi_event
.wwpn
, &vport
->fc_portname
, sizeof(struct lpfc_name
));
3872 memcpy(scsi_event
.wwnn
, &vport
->fc_nodename
, sizeof(struct lpfc_name
));
3874 fc_host_post_vendor_event(shost
, fc_get_event_number(),
3875 sizeof(scsi_event
), (char *)&scsi_event
, LPFC_NL_VENDOR_ID
);
3877 status
= fc_block_scsi_eh(cmnd
);
3882 * Since the driver manages a single bus device, reset all
3883 * targets known to the driver. Should any target reset
3884 * fail, this routine returns failure to the midlayer.
3886 for (i
= 0; i
< LPFC_MAX_TARGET
; i
++) {
3887 /* Search for mapped node by target ID */
3889 spin_lock_irq(shost
->host_lock
);
3890 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
) {
3891 if (!NLP_CHK_NODE_ACT(ndlp
))
3893 if (ndlp
->nlp_state
== NLP_STE_MAPPED_NODE
&&
3894 ndlp
->nlp_sid
== i
&&
3900 spin_unlock_irq(shost
->host_lock
);
3904 status
= lpfc_send_taskmgmt(vport
, ndlp
->rport
->dd_data
,
3905 i
, 0, FCP_TARGET_RESET
);
3907 if (status
!= SUCCESS
) {
3908 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3909 "0700 Bus Reset on target %d failed\n",
3915 * We have to clean up i/o as : they may be orphaned by the TMFs
3916 * above; or if any of the TMFs failed, they may be in an
3917 * indeterminate state.
3918 * We will report success if all the i/o aborts successfully.
3921 status
= lpfc_reset_flush_io_context(vport
, 0, 0, LPFC_CTX_HOST
);
3922 if (status
!= SUCCESS
)
3925 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_FCP
,
3926 "0714 SCSI layer issued Bus Reset Data: x%x\n", ret
);
3931 * lpfc_slave_alloc - scsi_host_template slave_alloc entry point
3932 * @sdev: Pointer to scsi_device.
3934 * This routine populates the cmds_per_lun count + 2 scsi_bufs into this host's
3935 * globally available list of scsi buffers. This routine also makes sure scsi
3936 * buffer is not allocated more than HBA limit conveyed to midlayer. This list
3937 * of scsi buffer exists for the lifetime of the driver.
3944 lpfc_slave_alloc(struct scsi_device
*sdev
)
3946 struct lpfc_vport
*vport
= (struct lpfc_vport
*) sdev
->host
->hostdata
;
3947 struct lpfc_hba
*phba
= vport
->phba
;
3948 struct fc_rport
*rport
= starget_to_rport(scsi_target(sdev
));
3950 uint32_t num_to_alloc
= 0;
3951 int num_allocated
= 0;
3954 if (!rport
|| fc_remote_port_chkready(rport
))
3957 sdev
->hostdata
= rport
->dd_data
;
3958 sdev_cnt
= atomic_inc_return(&phba
->sdev_cnt
);
3961 * Populate the cmds_per_lun count scsi_bufs into this host's globally
3962 * available list of scsi buffers. Don't allocate more than the
3963 * HBA limit conveyed to the midlayer via the host structure. The
3964 * formula accounts for the lun_queue_depth + error handlers + 1
3965 * extra. This list of scsi bufs exists for the lifetime of the driver.
3967 total
= phba
->total_scsi_bufs
;
3968 num_to_alloc
= vport
->cfg_lun_queue_depth
+ 2;
3970 /* If allocated buffers are enough do nothing */
3971 if ((sdev_cnt
* (vport
->cfg_lun_queue_depth
+ 2)) < total
)
3974 /* Allow some exchanges to be available always to complete discovery */
3975 if (total
>= phba
->cfg_hba_queue_depth
- LPFC_DISC_IOCB_BUFF_COUNT
) {
3976 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
3977 "0704 At limitation of %d preallocated "
3978 "command buffers\n", total
);
3980 /* Allow some exchanges to be available always to complete discovery */
3981 } else if (total
+ num_to_alloc
>
3982 phba
->cfg_hba_queue_depth
- LPFC_DISC_IOCB_BUFF_COUNT
) {
3983 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
3984 "0705 Allocation request of %d "
3985 "command buffers will exceed max of %d. "
3986 "Reducing allocation request to %d.\n",
3987 num_to_alloc
, phba
->cfg_hba_queue_depth
,
3988 (phba
->cfg_hba_queue_depth
- total
));
3989 num_to_alloc
= phba
->cfg_hba_queue_depth
- total
;
3991 num_allocated
= lpfc_new_scsi_buf(vport
, num_to_alloc
);
3992 if (num_to_alloc
!= num_allocated
) {
3993 lpfc_printf_vlog(vport
, KERN_WARNING
, LOG_FCP
,
3994 "0708 Allocation request of %d "
3995 "command buffers did not succeed. "
3996 "Allocated %d buffers.\n",
3997 num_to_alloc
, num_allocated
);
3999 if (num_allocated
> 0)
4000 phba
->total_scsi_bufs
+= num_allocated
;
4005 * lpfc_slave_configure - scsi_host_template slave_configure entry point
4006 * @sdev: Pointer to scsi_device.
4008 * This routine configures following items
4009 * - Tag command queuing support for @sdev if supported.
4010 * - Enable SLI polling for fcp ring if ENABLE_FCP_RING_POLLING flag is set.
4016 lpfc_slave_configure(struct scsi_device
*sdev
)
4018 struct lpfc_vport
*vport
= (struct lpfc_vport
*) sdev
->host
->hostdata
;
4019 struct lpfc_hba
*phba
= vport
->phba
;
4021 if (sdev
->tagged_supported
)
4022 scsi_activate_tcq(sdev
, vport
->cfg_lun_queue_depth
);
4024 scsi_deactivate_tcq(sdev
, vport
->cfg_lun_queue_depth
);
4026 if (phba
->cfg_poll
& ENABLE_FCP_RING_POLLING
) {
4027 lpfc_sli_handle_fast_ring_event(phba
,
4028 &phba
->sli
.ring
[LPFC_FCP_RING
], HA_R0RE_REQ
);
4029 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
)
4030 lpfc_poll_rearm_timer(phba
);
4037 * lpfc_slave_destroy - slave_destroy entry point of SHT data structure
4038 * @sdev: Pointer to scsi_device.
4040 * This routine sets @sdev hostatdata filed to null.
4043 lpfc_slave_destroy(struct scsi_device
*sdev
)
4045 struct lpfc_vport
*vport
= (struct lpfc_vport
*) sdev
->host
->hostdata
;
4046 struct lpfc_hba
*phba
= vport
->phba
;
4047 atomic_dec(&phba
->sdev_cnt
);
4048 sdev
->hostdata
= NULL
;
4053 struct scsi_host_template lpfc_template
= {
4054 .module
= THIS_MODULE
,
4055 .name
= LPFC_DRIVER_NAME
,
4057 .queuecommand
= lpfc_queuecommand
,
4058 .eh_abort_handler
= lpfc_abort_handler
,
4059 .eh_device_reset_handler
= lpfc_device_reset_handler
,
4060 .eh_target_reset_handler
= lpfc_target_reset_handler
,
4061 .eh_bus_reset_handler
= lpfc_bus_reset_handler
,
4062 .slave_alloc
= lpfc_slave_alloc
,
4063 .slave_configure
= lpfc_slave_configure
,
4064 .slave_destroy
= lpfc_slave_destroy
,
4065 .scan_finished
= lpfc_scan_finished
,
4067 .sg_tablesize
= LPFC_DEFAULT_SG_SEG_CNT
,
4068 .cmd_per_lun
= LPFC_CMD_PER_LUN
,
4069 .use_clustering
= ENABLE_CLUSTERING
,
4070 .shost_attrs
= lpfc_hba_attrs
,
4071 .max_sectors
= 0xFFFF,
4072 .vendor_id
= LPFC_NL_VENDOR_ID
,
4073 .change_queue_depth
= lpfc_change_queue_depth
,
4076 struct scsi_host_template lpfc_vport_template
= {
4077 .module
= THIS_MODULE
,
4078 .name
= LPFC_DRIVER_NAME
,
4080 .queuecommand
= lpfc_queuecommand
,
4081 .eh_abort_handler
= lpfc_abort_handler
,
4082 .eh_device_reset_handler
= lpfc_device_reset_handler
,
4083 .eh_target_reset_handler
= lpfc_target_reset_handler
,
4084 .eh_bus_reset_handler
= lpfc_bus_reset_handler
,
4085 .slave_alloc
= lpfc_slave_alloc
,
4086 .slave_configure
= lpfc_slave_configure
,
4087 .slave_destroy
= lpfc_slave_destroy
,
4088 .scan_finished
= lpfc_scan_finished
,
4090 .sg_tablesize
= LPFC_DEFAULT_SG_SEG_CNT
,
4091 .cmd_per_lun
= LPFC_CMD_PER_LUN
,
4092 .use_clustering
= ENABLE_CLUSTERING
,
4093 .shost_attrs
= lpfc_vport_attrs
,
4094 .max_sectors
= 0xFFFF,
4095 .change_queue_depth
= lpfc_change_queue_depth
,