1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017-2019 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. *
6 * Copyright (C) 2004-2016 Emulex. All rights reserved. *
7 * EMULEX and SLI are trademarks of Emulex. *
9 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
11 * This program is free software; you can redistribute it and/or *
12 * modify it under the terms of version 2 of the GNU General *
13 * Public License as published by the Free Software Foundation. *
14 * This program is distributed in the hope that it will be useful. *
15 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
16 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
17 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
18 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
19 * TO BE LEGALLY INVALID. See the GNU General Public License for *
20 * more details, a copy of which can be found in the file COPYING *
21 * included with this package. *
22 *******************************************************************/
23 #include <linux/pci.h>
24 #include <linux/slab.h>
25 #include <linux/interrupt.h>
26 #include <linux/export.h>
27 #include <linux/delay.h>
28 #include <asm/unaligned.h>
29 #include <linux/t10-pi.h>
30 #include <linux/crc-t10dif.h>
31 #include <net/checksum.h>
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_eh.h>
36 #include <scsi/scsi_host.h>
37 #include <scsi/scsi_tcq.h>
38 #include <scsi/scsi_transport_fc.h>
40 #include "lpfc_version.h"
44 #include "lpfc_sli4.h"
46 #include "lpfc_disc.h"
48 #include "lpfc_scsi.h"
49 #include "lpfc_logmsg.h"
50 #include "lpfc_crtn.h"
51 #include "lpfc_vport.h"
53 #define LPFC_RESET_WAIT 2
54 #define LPFC_ABORT_WAIT 2
56 int _dump_buf_done = 1;
58 static char *dif_op_str[] = {
68 struct scsi_dif_tuple {
69 __be16 guard_tag; /* Checksum */
70 __be16 app_tag; /* Opaque storage */
71 __be32 ref_tag; /* Target LBA or indirect LBA */
74 static struct lpfc_rport_data *
75 lpfc_rport_data_from_scsi_device(struct scsi_device *sdev)
77 struct lpfc_vport *vport = (struct lpfc_vport *)sdev->host->hostdata;
79 if (vport->phba->cfg_fof)
80 return ((struct lpfc_device_data *)sdev->hostdata)->rport_data;
82 return (struct lpfc_rport_data *)sdev->hostdata;
86 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_io_buf *psb);
88 lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_io_buf *psb);
90 lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc);
93 lpfc_debug_save_data(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
96 struct scatterlist *sgde = scsi_sglist(cmnd);
98 if (!_dump_buf_data) {
99 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
100 "9050 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
107 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
108 "9051 BLKGRD: ERROR: data scatterlist is null\n");
112 dst = (void *) _dump_buf_data;
115 memcpy(dst, src, sgde->length);
117 sgde = sg_next(sgde);
122 lpfc_debug_save_dif(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
125 struct scatterlist *sgde = scsi_prot_sglist(cmnd);
127 if (!_dump_buf_dif) {
128 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
129 "9052 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
135 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
136 "9053 BLKGRD: ERROR: prot scatterlist is null\n");
143 memcpy(dst, src, sgde->length);
145 sgde = sg_next(sgde);
149 static inline unsigned
150 lpfc_cmd_blksize(struct scsi_cmnd *sc)
152 return sc->device->sector_size;
155 #define LPFC_CHECK_PROTECT_GUARD 1
156 #define LPFC_CHECK_PROTECT_REF 2
157 static inline unsigned
158 lpfc_cmd_protect(struct scsi_cmnd *sc, int flag)
163 static inline unsigned
164 lpfc_cmd_guard_csum(struct scsi_cmnd *sc)
166 if (lpfc_prot_group_type(NULL, sc) == LPFC_PG_TYPE_NO_DIF)
168 if (scsi_host_get_guard(sc->device->host) == SHOST_DIX_GUARD_IP)
174 * lpfc_sli4_set_rsp_sgl_last - Set the last bit in the response sge.
175 * @phba: Pointer to HBA object.
176 * @lpfc_cmd: lpfc scsi command object pointer.
178 * This function is called from the lpfc_prep_task_mgmt_cmd function to
179 * set the last bit in the response sge entry.
182 lpfc_sli4_set_rsp_sgl_last(struct lpfc_hba *phba,
183 struct lpfc_io_buf *lpfc_cmd)
185 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->dma_sgl;
188 sgl->word2 = le32_to_cpu(sgl->word2);
189 bf_set(lpfc_sli4_sge_last, sgl, 1);
190 sgl->word2 = cpu_to_le32(sgl->word2);
195 * lpfc_update_stats - Update statistical data for the command completion
196 * @phba: Pointer to HBA object.
197 * @lpfc_cmd: lpfc scsi command object pointer.
199 * This function is called when there is a command completion and this
200 * function updates the statistical data for the command completion.
203 lpfc_update_stats(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
205 struct lpfc_rport_data *rdata;
206 struct lpfc_nodelist *pnode;
207 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
209 struct Scsi_Host *shost = cmd->device->host;
210 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
211 unsigned long latency;
214 if (!vport->stat_data_enabled ||
215 vport->stat_data_blocked ||
219 latency = jiffies_to_msecs((long)jiffies - (long)lpfc_cmd->start_time);
220 rdata = lpfc_cmd->rdata;
221 pnode = rdata->pnode;
223 spin_lock_irqsave(shost->host_lock, flags);
226 (phba->bucket_type == LPFC_NO_BUCKET)) {
227 spin_unlock_irqrestore(shost->host_lock, flags);
231 if (phba->bucket_type == LPFC_LINEAR_BUCKET) {
232 i = (latency + phba->bucket_step - 1 - phba->bucket_base)/
234 /* check array subscript bounds */
237 else if (i >= LPFC_MAX_BUCKET_COUNT)
238 i = LPFC_MAX_BUCKET_COUNT - 1;
240 for (i = 0; i < LPFC_MAX_BUCKET_COUNT-1; i++)
241 if (latency <= (phba->bucket_base +
242 ((1<<i)*phba->bucket_step)))
246 pnode->lat_data[i].cmd_count++;
247 spin_unlock_irqrestore(shost->host_lock, flags);
251 * lpfc_rampdown_queue_depth - Post RAMP_DOWN_QUEUE event to worker thread
252 * @phba: The Hba for which this call is being executed.
254 * This routine is called when there is resource error in driver or firmware.
255 * This routine posts WORKER_RAMP_DOWN_QUEUE event for @phba. This routine
256 * posts at most 1 event each second. This routine wakes up worker thread of
257 * @phba to process WORKER_RAM_DOWN_EVENT event.
259 * This routine should be called with no lock held.
262 lpfc_rampdown_queue_depth(struct lpfc_hba *phba)
266 unsigned long expires;
268 spin_lock_irqsave(&phba->hbalock, flags);
269 atomic_inc(&phba->num_rsrc_err);
270 phba->last_rsrc_error_time = jiffies;
272 expires = phba->last_ramp_down_time + QUEUE_RAMP_DOWN_INTERVAL;
273 if (time_after(expires, jiffies)) {
274 spin_unlock_irqrestore(&phba->hbalock, flags);
278 phba->last_ramp_down_time = jiffies;
280 spin_unlock_irqrestore(&phba->hbalock, flags);
282 spin_lock_irqsave(&phba->pport->work_port_lock, flags);
283 evt_posted = phba->pport->work_port_events & WORKER_RAMP_DOWN_QUEUE;
285 phba->pport->work_port_events |= WORKER_RAMP_DOWN_QUEUE;
286 spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);
289 lpfc_worker_wake_up(phba);
294 * lpfc_ramp_down_queue_handler - WORKER_RAMP_DOWN_QUEUE event handler
295 * @phba: The Hba for which this call is being executed.
297 * This routine is called to process WORKER_RAMP_DOWN_QUEUE event for worker
298 * thread.This routine reduces queue depth for all scsi device on each vport
299 * associated with @phba.
302 lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
304 struct lpfc_vport **vports;
305 struct Scsi_Host *shost;
306 struct scsi_device *sdev;
307 unsigned long new_queue_depth;
308 unsigned long num_rsrc_err, num_cmd_success;
311 num_rsrc_err = atomic_read(&phba->num_rsrc_err);
312 num_cmd_success = atomic_read(&phba->num_cmd_success);
315 * The error and success command counters are global per
316 * driver instance. If another handler has already
317 * operated on this error event, just exit.
319 if (num_rsrc_err == 0)
322 vports = lpfc_create_vport_work_array(phba);
324 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
325 shost = lpfc_shost_from_vport(vports[i]);
326 shost_for_each_device(sdev, shost) {
328 sdev->queue_depth * num_rsrc_err /
329 (num_rsrc_err + num_cmd_success);
330 if (!new_queue_depth)
331 new_queue_depth = sdev->queue_depth - 1;
333 new_queue_depth = sdev->queue_depth -
335 scsi_change_queue_depth(sdev, new_queue_depth);
338 lpfc_destroy_vport_work_array(phba, vports);
339 atomic_set(&phba->num_rsrc_err, 0);
340 atomic_set(&phba->num_cmd_success, 0);
344 * lpfc_scsi_dev_block - set all scsi hosts to block state
345 * @phba: Pointer to HBA context object.
347 * This function walks vport list and set each SCSI host to block state
348 * by invoking fc_remote_port_delete() routine. This function is invoked
349 * with EEH when device's PCI slot has been permanently disabled.
352 lpfc_scsi_dev_block(struct lpfc_hba *phba)
354 struct lpfc_vport **vports;
355 struct Scsi_Host *shost;
356 struct scsi_device *sdev;
357 struct fc_rport *rport;
360 vports = lpfc_create_vport_work_array(phba);
362 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
363 shost = lpfc_shost_from_vport(vports[i]);
364 shost_for_each_device(sdev, shost) {
365 rport = starget_to_rport(scsi_target(sdev));
366 fc_remote_port_delete(rport);
369 lpfc_destroy_vport_work_array(phba, vports);
373 * lpfc_new_scsi_buf_s3 - Scsi buffer allocator for HBA with SLI3 IF spec
374 * @vport: The virtual port for which this call being executed.
375 * @num_to_allocate: The requested number of buffers to allocate.
377 * This routine allocates a scsi buffer for device with SLI-3 interface spec,
378 * the scsi buffer contains all the necessary information needed to initiate
379 * a SCSI I/O. The non-DMAable buffer region contains information to build
380 * the IOCB. The DMAable region contains memory for the FCP CMND, FCP RSP,
381 * and the initial BPL. In addition to allocating memory, the FCP CMND and
382 * FCP RSP BDEs are setup in the BPL and the BPL BDE is setup in the IOCB.
385 * int - number of scsi buffers that were allocated.
386 * 0 = failure, less than num_to_alloc is a partial failure.
389 lpfc_new_scsi_buf_s3(struct lpfc_vport *vport, int num_to_alloc)
391 struct lpfc_hba *phba = vport->phba;
392 struct lpfc_io_buf *psb;
393 struct ulp_bde64 *bpl;
395 dma_addr_t pdma_phys_fcp_cmd;
396 dma_addr_t pdma_phys_fcp_rsp;
397 dma_addr_t pdma_phys_sgl;
401 bpl_size = phba->cfg_sg_dma_buf_size -
402 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
404 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
405 "9067 ALLOC %d scsi_bufs: %d (%d + %d + %d)\n",
406 num_to_alloc, phba->cfg_sg_dma_buf_size,
407 (int)sizeof(struct fcp_cmnd),
408 (int)sizeof(struct fcp_rsp), bpl_size);
410 for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
411 psb = kzalloc(sizeof(struct lpfc_io_buf), GFP_KERNEL);
416 * Get memory from the pci pool to map the virt space to pci
417 * bus space for an I/O. The DMA buffer includes space for the
418 * struct fcp_cmnd, struct fcp_rsp and the number of bde's
419 * necessary to support the sg_tablesize.
421 psb->data = dma_pool_zalloc(phba->lpfc_sg_dma_buf_pool,
422 GFP_KERNEL, &psb->dma_handle);
429 /* Allocate iotag for psb->cur_iocbq. */
430 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
432 dma_pool_free(phba->lpfc_sg_dma_buf_pool,
433 psb->data, psb->dma_handle);
437 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
439 psb->fcp_cmnd = psb->data;
440 psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd);
441 psb->dma_sgl = psb->data + sizeof(struct fcp_cmnd) +
442 sizeof(struct fcp_rsp);
444 /* Initialize local short-hand pointers. */
445 bpl = (struct ulp_bde64 *)psb->dma_sgl;
446 pdma_phys_fcp_cmd = psb->dma_handle;
447 pdma_phys_fcp_rsp = psb->dma_handle + sizeof(struct fcp_cmnd);
448 pdma_phys_sgl = psb->dma_handle + sizeof(struct fcp_cmnd) +
449 sizeof(struct fcp_rsp);
452 * The first two bdes are the FCP_CMD and FCP_RSP. The balance
453 * are sg list bdes. Initialize the first two and leave the
454 * rest for queuecommand.
456 bpl[0].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd));
457 bpl[0].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd));
458 bpl[0].tus.f.bdeSize = sizeof(struct fcp_cmnd);
459 bpl[0].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
460 bpl[0].tus.w = le32_to_cpu(bpl[0].tus.w);
462 /* Setup the physical region for the FCP RSP */
463 bpl[1].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp));
464 bpl[1].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp));
465 bpl[1].tus.f.bdeSize = sizeof(struct fcp_rsp);
466 bpl[1].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
467 bpl[1].tus.w = le32_to_cpu(bpl[1].tus.w);
470 * Since the IOCB for the FCP I/O is built into this
471 * lpfc_scsi_buf, initialize it with all known data now.
473 iocb = &psb->cur_iocbq.iocb;
474 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
475 if ((phba->sli_rev == 3) &&
476 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
477 /* fill in immediate fcp command BDE */
478 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_IMMED;
479 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
480 iocb->un.fcpi64.bdl.addrLow = offsetof(IOCB_t,
482 iocb->un.fcpi64.bdl.addrHigh = 0;
483 iocb->ulpBdeCount = 0;
485 /* fill in response BDE */
486 iocb->unsli3.fcp_ext.rbde.tus.f.bdeFlags =
488 iocb->unsli3.fcp_ext.rbde.tus.f.bdeSize =
489 sizeof(struct fcp_rsp);
490 iocb->unsli3.fcp_ext.rbde.addrLow =
491 putPaddrLow(pdma_phys_fcp_rsp);
492 iocb->unsli3.fcp_ext.rbde.addrHigh =
493 putPaddrHigh(pdma_phys_fcp_rsp);
495 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
496 iocb->un.fcpi64.bdl.bdeSize =
497 (2 * sizeof(struct ulp_bde64));
498 iocb->un.fcpi64.bdl.addrLow =
499 putPaddrLow(pdma_phys_sgl);
500 iocb->un.fcpi64.bdl.addrHigh =
501 putPaddrHigh(pdma_phys_sgl);
502 iocb->ulpBdeCount = 1;
505 iocb->ulpClass = CLASS3;
506 psb->status = IOSTAT_SUCCESS;
507 /* Put it back into the SCSI buffer list */
508 psb->cur_iocbq.context1 = psb;
509 spin_lock_init(&psb->buf_lock);
510 lpfc_release_scsi_buf_s3(phba, psb);
518 * lpfc_sli4_vport_delete_fcp_xri_aborted -Remove all ndlp references for vport
519 * @vport: pointer to lpfc vport data structure.
521 * This routine is invoked by the vport cleanup for deletions and the cleanup
522 * for an ndlp on removal.
525 lpfc_sli4_vport_delete_fcp_xri_aborted(struct lpfc_vport *vport)
527 struct lpfc_hba *phba = vport->phba;
528 struct lpfc_io_buf *psb, *next_psb;
529 struct lpfc_sli4_hdw_queue *qp;
530 unsigned long iflag = 0;
533 if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
536 spin_lock_irqsave(&phba->hbalock, iflag);
537 for (idx = 0; idx < phba->cfg_hdw_queue; idx++) {
538 qp = &phba->sli4_hba.hdwq[idx];
540 spin_lock(&qp->abts_scsi_buf_list_lock);
541 list_for_each_entry_safe(psb, next_psb,
542 &qp->lpfc_abts_scsi_buf_list, list) {
543 if (psb->rdata && psb->rdata->pnode &&
544 psb->rdata->pnode->vport == vport)
547 spin_unlock(&qp->abts_scsi_buf_list_lock);
549 spin_unlock_irqrestore(&phba->hbalock, iflag);
553 * lpfc_sli4_fcp_xri_aborted - Fast-path process of fcp xri abort
554 * @phba: pointer to lpfc hba data structure.
555 * @axri: pointer to the fcp xri abort wcqe structure.
557 * This routine is invoked by the worker thread to process a SLI4 fast-path
561 lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
562 struct sli4_wcqe_xri_aborted *axri, int idx)
564 uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
565 uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);
566 struct lpfc_io_buf *psb, *next_psb;
567 struct lpfc_sli4_hdw_queue *qp;
568 unsigned long iflag = 0;
569 struct lpfc_iocbq *iocbq;
571 struct lpfc_nodelist *ndlp;
573 struct lpfc_sli_ring *pring = phba->sli4_hba.els_wq->pring;
575 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
578 qp = &phba->sli4_hba.hdwq[idx];
579 spin_lock_irqsave(&phba->hbalock, iflag);
580 spin_lock(&qp->abts_scsi_buf_list_lock);
581 list_for_each_entry_safe(psb, next_psb,
582 &qp->lpfc_abts_scsi_buf_list, list) {
583 if (psb->cur_iocbq.sli4_xritag == xri) {
584 list_del(&psb->list);
585 qp->abts_scsi_io_bufs--;
587 psb->status = IOSTAT_SUCCESS;
589 &qp->abts_scsi_buf_list_lock);
590 if (psb->rdata && psb->rdata->pnode)
591 ndlp = psb->rdata->pnode;
595 rrq_empty = list_empty(&phba->active_rrq_list);
596 spin_unlock_irqrestore(&phba->hbalock, iflag);
598 lpfc_set_rrq_active(phba, ndlp,
599 psb->cur_iocbq.sli4_lxritag, rxid, 1);
600 lpfc_sli4_abts_err_handler(phba, ndlp, axri);
602 lpfc_release_scsi_buf_s4(phba, psb);
604 lpfc_worker_wake_up(phba);
608 spin_unlock(&qp->abts_scsi_buf_list_lock);
609 for (i = 1; i <= phba->sli.last_iotag; i++) {
610 iocbq = phba->sli.iocbq_lookup[i];
612 if (!(iocbq->iocb_flag & LPFC_IO_FCP) ||
613 (iocbq->iocb_flag & LPFC_IO_LIBDFC))
615 if (iocbq->sli4_xritag != xri)
617 psb = container_of(iocbq, struct lpfc_io_buf, cur_iocbq);
619 spin_unlock_irqrestore(&phba->hbalock, iflag);
620 if (!list_empty(&pring->txq))
621 lpfc_worker_wake_up(phba);
625 spin_unlock_irqrestore(&phba->hbalock, iflag);
629 * lpfc_get_scsi_buf_s3 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
630 * @phba: The HBA for which this call is being executed.
632 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
633 * and returns to caller.
637 * Pointer to lpfc_scsi_buf - Success
639 static struct lpfc_io_buf *
640 lpfc_get_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
641 struct scsi_cmnd *cmnd)
643 struct lpfc_io_buf *lpfc_cmd = NULL;
644 struct list_head *scsi_buf_list_get = &phba->lpfc_scsi_buf_list_get;
645 unsigned long iflag = 0;
647 spin_lock_irqsave(&phba->scsi_buf_list_get_lock, iflag);
648 list_remove_head(scsi_buf_list_get, lpfc_cmd, struct lpfc_io_buf,
651 spin_lock(&phba->scsi_buf_list_put_lock);
652 list_splice(&phba->lpfc_scsi_buf_list_put,
653 &phba->lpfc_scsi_buf_list_get);
654 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
655 list_remove_head(scsi_buf_list_get, lpfc_cmd,
656 struct lpfc_io_buf, list);
657 spin_unlock(&phba->scsi_buf_list_put_lock);
659 spin_unlock_irqrestore(&phba->scsi_buf_list_get_lock, iflag);
661 if (lpfc_ndlp_check_qdepth(phba, ndlp) && lpfc_cmd) {
662 atomic_inc(&ndlp->cmd_pending);
663 lpfc_cmd->flags |= LPFC_SBUF_BUMP_QDEPTH;
668 * lpfc_get_scsi_buf_s4 - Get a scsi buffer from io_buf_list of the HBA
669 * @phba: The HBA for which this call is being executed.
671 * This routine removes a scsi buffer from head of @hdwq io_buf_list
672 * and returns to caller.
676 * Pointer to lpfc_scsi_buf - Success
678 static struct lpfc_io_buf *
679 lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
680 struct scsi_cmnd *cmnd)
682 struct lpfc_io_buf *lpfc_cmd;
683 struct lpfc_sli4_hdw_queue *qp;
684 struct sli4_sge *sgl;
686 dma_addr_t pdma_phys_fcp_rsp;
687 dma_addr_t pdma_phys_fcp_cmd;
688 uint32_t sgl_size, cpu, idx;
691 cpu = smp_processor_id();
692 if (cmnd && phba->cfg_fcp_io_sched == LPFC_FCP_SCHED_BY_HDWQ) {
693 tag = blk_mq_unique_tag(cmnd->request);
694 idx = blk_mq_unique_tag_to_hwq(tag);
696 idx = phba->sli4_hba.cpu_map[cpu].hdwq;
699 lpfc_cmd = lpfc_get_io_buf(phba, ndlp, idx,
700 !phba->cfg_xri_rebalancing);
702 qp = &phba->sli4_hba.hdwq[idx];
707 sgl_size = phba->cfg_sg_dma_buf_size -
708 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
710 /* Setup key fields in buffer that may have been changed
711 * if other protocols used this buffer.
713 lpfc_cmd->cur_iocbq.iocb_flag = LPFC_IO_FCP;
714 lpfc_cmd->prot_seg_cnt = 0;
715 lpfc_cmd->seg_cnt = 0;
716 lpfc_cmd->timeout = 0;
718 lpfc_cmd->start_time = jiffies;
719 lpfc_cmd->waitq = NULL;
721 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
722 lpfc_cmd->prot_data_type = 0;
724 lpfc_cmd->fcp_cmnd = (lpfc_cmd->data + sgl_size);
725 lpfc_cmd->fcp_rsp = (struct fcp_rsp *)((uint8_t *)lpfc_cmd->fcp_cmnd +
726 sizeof(struct fcp_cmnd));
729 * The first two SGEs are the FCP_CMD and FCP_RSP.
730 * The balance are sg list bdes. Initialize the
731 * first two and leave the rest for queuecommand.
733 sgl = (struct sli4_sge *)lpfc_cmd->dma_sgl;
734 pdma_phys_fcp_cmd = (lpfc_cmd->dma_handle + sgl_size);
735 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd));
736 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd));
737 sgl->word2 = le32_to_cpu(sgl->word2);
738 bf_set(lpfc_sli4_sge_last, sgl, 0);
739 sgl->word2 = cpu_to_le32(sgl->word2);
740 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_cmnd));
743 /* Setup the physical region for the FCP RSP */
744 pdma_phys_fcp_rsp = pdma_phys_fcp_cmd + sizeof(struct fcp_cmnd);
745 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_rsp));
746 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_rsp));
747 sgl->word2 = le32_to_cpu(sgl->word2);
748 bf_set(lpfc_sli4_sge_last, sgl, 1);
749 sgl->word2 = cpu_to_le32(sgl->word2);
750 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_rsp));
753 * Since the IOCB for the FCP I/O is built into this
754 * lpfc_io_buf, initialize it with all known data now.
756 iocb = &lpfc_cmd->cur_iocbq.iocb;
757 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
758 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_64;
759 /* setting the BLP size to 2 * sizeof BDE may not be correct.
760 * We are setting the bpl to point to out sgl. An sgl's
761 * entries are 16 bytes, a bpl entries are 12 bytes.
763 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
764 iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys_fcp_cmd);
765 iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys_fcp_cmd);
766 iocb->ulpBdeCount = 1;
768 iocb->ulpClass = CLASS3;
770 if (lpfc_ndlp_check_qdepth(phba, ndlp)) {
771 atomic_inc(&ndlp->cmd_pending);
772 lpfc_cmd->flags |= LPFC_SBUF_BUMP_QDEPTH;
777 * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
778 * @phba: The HBA for which this call is being executed.
780 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
781 * and returns to caller.
785 * Pointer to lpfc_scsi_buf - Success
787 static struct lpfc_io_buf*
788 lpfc_get_scsi_buf(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
789 struct scsi_cmnd *cmnd)
791 return phba->lpfc_get_scsi_buf(phba, ndlp, cmnd);
795 * lpfc_release_scsi_buf - Return a scsi buffer back to hba scsi buf list
796 * @phba: The Hba for which this call is being executed.
797 * @psb: The scsi buffer which is being released.
799 * This routine releases @psb scsi buffer by adding it to tail of @phba
800 * lpfc_scsi_buf_list list.
803 lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_io_buf *psb)
805 unsigned long iflag = 0;
808 psb->prot_seg_cnt = 0;
810 spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
812 psb->cur_iocbq.iocb_flag = LPFC_IO_FCP;
813 list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list_put);
814 spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
818 * lpfc_release_scsi_buf_s4: Return a scsi buffer back to hba scsi buf list.
819 * @phba: The Hba for which this call is being executed.
820 * @psb: The scsi buffer which is being released.
822 * This routine releases @psb scsi buffer by adding it to tail of @hdwq
823 * io_buf_list list. For SLI4 XRI's are tied to the scsi buffer
824 * and cannot be reused for at least RA_TOV amount of time if it was
828 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_io_buf *psb)
830 struct lpfc_sli4_hdw_queue *qp;
831 unsigned long iflag = 0;
834 psb->prot_seg_cnt = 0;
837 if (psb->exch_busy) {
838 spin_lock_irqsave(&qp->abts_scsi_buf_list_lock, iflag);
840 list_add_tail(&psb->list, &qp->lpfc_abts_scsi_buf_list);
841 qp->abts_scsi_io_bufs++;
842 spin_unlock_irqrestore(&qp->abts_scsi_buf_list_lock, iflag);
844 lpfc_release_io_buf(phba, (struct lpfc_io_buf *)psb, qp);
849 * lpfc_release_scsi_buf: Return a scsi buffer back to hba scsi buf list.
850 * @phba: The Hba for which this call is being executed.
851 * @psb: The scsi buffer which is being released.
853 * This routine releases @psb scsi buffer by adding it to tail of @phba
854 * lpfc_scsi_buf_list list.
857 lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_io_buf *psb)
859 if ((psb->flags & LPFC_SBUF_BUMP_QDEPTH) && psb->ndlp)
860 atomic_dec(&psb->ndlp->cmd_pending);
862 psb->flags &= ~LPFC_SBUF_BUMP_QDEPTH;
863 phba->lpfc_release_scsi_buf(phba, psb);
867 * lpfc_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec
868 * @phba: The Hba for which this call is being executed.
869 * @lpfc_cmd: The scsi buffer which is going to be mapped.
871 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
872 * field of @lpfc_cmd for device with SLI-3 interface spec. This routine scans
873 * through sg elements and format the bde. This routine also initializes all
874 * IOCB fields which are dependent on scsi command request buffer.
881 lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
883 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
884 struct scatterlist *sgel = NULL;
885 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
886 struct ulp_bde64 *bpl = (struct ulp_bde64 *)lpfc_cmd->dma_sgl;
887 struct lpfc_iocbq *iocbq = &lpfc_cmd->cur_iocbq;
888 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
889 struct ulp_bde64 *data_bde = iocb_cmd->unsli3.fcp_ext.dbde;
891 uint32_t num_bde = 0;
892 int nseg, datadir = scsi_cmnd->sc_data_direction;
895 * There are three possibilities here - use scatter-gather segment, use
896 * the single mapping, or neither. Start the lpfc command prep by
897 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
901 if (scsi_sg_count(scsi_cmnd)) {
903 * The driver stores the segment count returned from pci_map_sg
904 * because this a count of dma-mappings used to map the use_sg
905 * pages. They are not guaranteed to be the same for those
906 * architectures that implement an IOMMU.
909 nseg = dma_map_sg(&phba->pcidev->dev, scsi_sglist(scsi_cmnd),
910 scsi_sg_count(scsi_cmnd), datadir);
914 lpfc_cmd->seg_cnt = nseg;
915 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
916 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
917 "9064 BLKGRD: %s: Too many sg segments from "
918 "dma_map_sg. Config %d, seg_cnt %d\n",
919 __func__, phba->cfg_sg_seg_cnt,
921 lpfc_cmd->seg_cnt = 0;
922 scsi_dma_unmap(scsi_cmnd);
927 * The driver established a maximum scatter-gather segment count
928 * during probe that limits the number of sg elements in any
929 * single scsi command. Just run through the seg_cnt and format
931 * When using SLI-3 the driver will try to fit all the BDEs into
932 * the IOCB. If it can't then the BDEs get added to a BPL as it
933 * does for SLI-2 mode.
935 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
936 physaddr = sg_dma_address(sgel);
937 if (phba->sli_rev == 3 &&
938 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
939 !(iocbq->iocb_flag & DSS_SECURITY_OP) &&
940 nseg <= LPFC_EXT_DATA_BDE_COUNT) {
941 data_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
942 data_bde->tus.f.bdeSize = sg_dma_len(sgel);
943 data_bde->addrLow = putPaddrLow(physaddr);
944 data_bde->addrHigh = putPaddrHigh(physaddr);
947 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
948 bpl->tus.f.bdeSize = sg_dma_len(sgel);
949 bpl->tus.w = le32_to_cpu(bpl->tus.w);
951 le32_to_cpu(putPaddrLow(physaddr));
953 le32_to_cpu(putPaddrHigh(physaddr));
960 * Finish initializing those IOCB fields that are dependent on the
961 * scsi_cmnd request_buffer. Note that for SLI-2 the bdeSize is
962 * explicitly reinitialized and for SLI-3 the extended bde count is
963 * explicitly reinitialized since all iocb memory resources are reused.
965 if (phba->sli_rev == 3 &&
966 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
967 !(iocbq->iocb_flag & DSS_SECURITY_OP)) {
968 if (num_bde > LPFC_EXT_DATA_BDE_COUNT) {
970 * The extended IOCB format can only fit 3 BDE or a BPL.
971 * This I/O has more than 3 BDE so the 1st data bde will
972 * be a BPL that is filled in here.
974 physaddr = lpfc_cmd->dma_handle;
975 data_bde->tus.f.bdeFlags = BUFF_TYPE_BLP_64;
976 data_bde->tus.f.bdeSize = (num_bde *
977 sizeof(struct ulp_bde64));
978 physaddr += (sizeof(struct fcp_cmnd) +
979 sizeof(struct fcp_rsp) +
980 (2 * sizeof(struct ulp_bde64)));
981 data_bde->addrHigh = putPaddrHigh(physaddr);
982 data_bde->addrLow = putPaddrLow(physaddr);
983 /* ebde count includes the response bde and data bpl */
984 iocb_cmd->unsli3.fcp_ext.ebde_count = 2;
986 /* ebde count includes the response bde and data bdes */
987 iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
990 iocb_cmd->un.fcpi64.bdl.bdeSize =
991 ((num_bde + 2) * sizeof(struct ulp_bde64));
992 iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
994 fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
997 * Due to difference in data length between DIF/non-DIF paths,
998 * we need to set word 4 of IOCB here
1000 iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
1004 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1006 /* Return BG_ERR_INIT if error injection is detected by Initiator */
1007 #define BG_ERR_INIT 0x1
1008 /* Return BG_ERR_TGT if error injection is detected by Target */
1009 #define BG_ERR_TGT 0x2
1010 /* Return BG_ERR_SWAP if swapping CSUM<-->CRC is required for error injection */
1011 #define BG_ERR_SWAP 0x10
1013 * Return BG_ERR_CHECK if disabling Guard/Ref/App checking is required for
1016 #define BG_ERR_CHECK 0x20
1019 * lpfc_bg_err_inject - Determine if we should inject an error
1020 * @phba: The Hba for which this call is being executed.
1021 * @sc: The SCSI command to examine
1022 * @reftag: (out) BlockGuard reference tag for transmitted data
1023 * @apptag: (out) BlockGuard application tag for transmitted data
1024 * @new_guard (in) Value to replace CRC with if needed
1026 * Returns BG_ERR_* bit mask or 0 if request ignored
1029 lpfc_bg_err_inject(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1030 uint32_t *reftag, uint16_t *apptag, uint32_t new_guard)
1032 struct scatterlist *sgpe; /* s/g prot entry */
1033 struct lpfc_io_buf *lpfc_cmd = NULL;
1034 struct scsi_dif_tuple *src = NULL;
1035 struct lpfc_nodelist *ndlp;
1036 struct lpfc_rport_data *rdata;
1037 uint32_t op = scsi_get_prot_op(sc);
1044 if (op == SCSI_PROT_NORMAL)
1047 sgpe = scsi_prot_sglist(sc);
1048 lba = scsi_get_lba(sc);
1050 /* First check if we need to match the LBA */
1051 if (phba->lpfc_injerr_lba != LPFC_INJERR_LBA_OFF) {
1052 blksize = lpfc_cmd_blksize(sc);
1053 numblks = (scsi_bufflen(sc) + blksize - 1) / blksize;
1055 /* Make sure we have the right LBA if one is specified */
1056 if ((phba->lpfc_injerr_lba < lba) ||
1057 (phba->lpfc_injerr_lba >= (lba + numblks)))
1060 blockoff = phba->lpfc_injerr_lba - lba;
1061 numblks = sg_dma_len(sgpe) /
1062 sizeof(struct scsi_dif_tuple);
1063 if (numblks < blockoff)
1068 /* Next check if we need to match the remote NPortID or WWPN */
1069 rdata = lpfc_rport_data_from_scsi_device(sc->device);
1070 if (rdata && rdata->pnode) {
1071 ndlp = rdata->pnode;
1073 /* Make sure we have the right NPortID if one is specified */
1074 if (phba->lpfc_injerr_nportid &&
1075 (phba->lpfc_injerr_nportid != ndlp->nlp_DID))
1079 * Make sure we have the right WWPN if one is specified.
1080 * wwn[0] should be a non-zero NAA in a good WWPN.
1082 if (phba->lpfc_injerr_wwpn.u.wwn[0] &&
1083 (memcmp(&ndlp->nlp_portname, &phba->lpfc_injerr_wwpn,
1084 sizeof(struct lpfc_name)) != 0))
1088 /* Setup a ptr to the protection data if the SCSI host provides it */
1090 src = (struct scsi_dif_tuple *)sg_virt(sgpe);
1092 lpfc_cmd = (struct lpfc_io_buf *)sc->host_scribble;
1095 /* Should we change the Reference Tag */
1097 if (phba->lpfc_injerr_wref_cnt) {
1099 case SCSI_PROT_WRITE_PASS:
1102 * For WRITE_PASS, force the error
1103 * to be sent on the wire. It should
1104 * be detected by the Target.
1105 * If blockoff != 0 error will be
1106 * inserted in middle of the IO.
1109 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1110 "9076 BLKGRD: Injecting reftag error: "
1111 "write lba x%lx + x%x oldrefTag x%x\n",
1112 (unsigned long)lba, blockoff,
1113 be32_to_cpu(src->ref_tag));
1116 * Save the old ref_tag so we can
1117 * restore it on completion.
1120 lpfc_cmd->prot_data_type =
1122 lpfc_cmd->prot_data_segment =
1124 lpfc_cmd->prot_data =
1127 src->ref_tag = cpu_to_be32(0xDEADBEEF);
1128 phba->lpfc_injerr_wref_cnt--;
1129 if (phba->lpfc_injerr_wref_cnt == 0) {
1130 phba->lpfc_injerr_nportid = 0;
1131 phba->lpfc_injerr_lba =
1132 LPFC_INJERR_LBA_OFF;
1133 memset(&phba->lpfc_injerr_wwpn,
1134 0, sizeof(struct lpfc_name));
1136 rc = BG_ERR_TGT | BG_ERR_CHECK;
1141 case SCSI_PROT_WRITE_INSERT:
1143 * For WRITE_INSERT, force the error
1144 * to be sent on the wire. It should be
1145 * detected by the Target.
1147 /* DEADBEEF will be the reftag on the wire */
1148 *reftag = 0xDEADBEEF;
1149 phba->lpfc_injerr_wref_cnt--;
1150 if (phba->lpfc_injerr_wref_cnt == 0) {
1151 phba->lpfc_injerr_nportid = 0;
1152 phba->lpfc_injerr_lba =
1153 LPFC_INJERR_LBA_OFF;
1154 memset(&phba->lpfc_injerr_wwpn,
1155 0, sizeof(struct lpfc_name));
1157 rc = BG_ERR_TGT | BG_ERR_CHECK;
1159 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1160 "9078 BLKGRD: Injecting reftag error: "
1161 "write lba x%lx\n", (unsigned long)lba);
1163 case SCSI_PROT_WRITE_STRIP:
1165 * For WRITE_STRIP and WRITE_PASS,
1166 * force the error on data
1167 * being copied from SLI-Host to SLI-Port.
1169 *reftag = 0xDEADBEEF;
1170 phba->lpfc_injerr_wref_cnt--;
1171 if (phba->lpfc_injerr_wref_cnt == 0) {
1172 phba->lpfc_injerr_nportid = 0;
1173 phba->lpfc_injerr_lba =
1174 LPFC_INJERR_LBA_OFF;
1175 memset(&phba->lpfc_injerr_wwpn,
1176 0, sizeof(struct lpfc_name));
1180 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1181 "9077 BLKGRD: Injecting reftag error: "
1182 "write lba x%lx\n", (unsigned long)lba);
1186 if (phba->lpfc_injerr_rref_cnt) {
1188 case SCSI_PROT_READ_INSERT:
1189 case SCSI_PROT_READ_STRIP:
1190 case SCSI_PROT_READ_PASS:
1192 * For READ_STRIP and READ_PASS, force the
1193 * error on data being read off the wire. It
1194 * should force an IO error to the driver.
1196 *reftag = 0xDEADBEEF;
1197 phba->lpfc_injerr_rref_cnt--;
1198 if (phba->lpfc_injerr_rref_cnt == 0) {
1199 phba->lpfc_injerr_nportid = 0;
1200 phba->lpfc_injerr_lba =
1201 LPFC_INJERR_LBA_OFF;
1202 memset(&phba->lpfc_injerr_wwpn,
1203 0, sizeof(struct lpfc_name));
1207 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1208 "9079 BLKGRD: Injecting reftag error: "
1209 "read lba x%lx\n", (unsigned long)lba);
1215 /* Should we change the Application Tag */
1217 if (phba->lpfc_injerr_wapp_cnt) {
1219 case SCSI_PROT_WRITE_PASS:
1222 * For WRITE_PASS, force the error
1223 * to be sent on the wire. It should
1224 * be detected by the Target.
1225 * If blockoff != 0 error will be
1226 * inserted in middle of the IO.
1229 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1230 "9080 BLKGRD: Injecting apptag error: "
1231 "write lba x%lx + x%x oldappTag x%x\n",
1232 (unsigned long)lba, blockoff,
1233 be16_to_cpu(src->app_tag));
1236 * Save the old app_tag so we can
1237 * restore it on completion.
1240 lpfc_cmd->prot_data_type =
1242 lpfc_cmd->prot_data_segment =
1244 lpfc_cmd->prot_data =
1247 src->app_tag = cpu_to_be16(0xDEAD);
1248 phba->lpfc_injerr_wapp_cnt--;
1249 if (phba->lpfc_injerr_wapp_cnt == 0) {
1250 phba->lpfc_injerr_nportid = 0;
1251 phba->lpfc_injerr_lba =
1252 LPFC_INJERR_LBA_OFF;
1253 memset(&phba->lpfc_injerr_wwpn,
1254 0, sizeof(struct lpfc_name));
1256 rc = BG_ERR_TGT | BG_ERR_CHECK;
1260 case SCSI_PROT_WRITE_INSERT:
1262 * For WRITE_INSERT, force the
1263 * error to be sent on the wire. It should be
1264 * detected by the Target.
1266 /* DEAD will be the apptag on the wire */
1268 phba->lpfc_injerr_wapp_cnt--;
1269 if (phba->lpfc_injerr_wapp_cnt == 0) {
1270 phba->lpfc_injerr_nportid = 0;
1271 phba->lpfc_injerr_lba =
1272 LPFC_INJERR_LBA_OFF;
1273 memset(&phba->lpfc_injerr_wwpn,
1274 0, sizeof(struct lpfc_name));
1276 rc = BG_ERR_TGT | BG_ERR_CHECK;
1278 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1279 "0813 BLKGRD: Injecting apptag error: "
1280 "write lba x%lx\n", (unsigned long)lba);
1282 case SCSI_PROT_WRITE_STRIP:
1284 * For WRITE_STRIP and WRITE_PASS,
1285 * force the error on data
1286 * being copied from SLI-Host to SLI-Port.
1289 phba->lpfc_injerr_wapp_cnt--;
1290 if (phba->lpfc_injerr_wapp_cnt == 0) {
1291 phba->lpfc_injerr_nportid = 0;
1292 phba->lpfc_injerr_lba =
1293 LPFC_INJERR_LBA_OFF;
1294 memset(&phba->lpfc_injerr_wwpn,
1295 0, sizeof(struct lpfc_name));
1299 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1300 "0812 BLKGRD: Injecting apptag error: "
1301 "write lba x%lx\n", (unsigned long)lba);
1305 if (phba->lpfc_injerr_rapp_cnt) {
1307 case SCSI_PROT_READ_INSERT:
1308 case SCSI_PROT_READ_STRIP:
1309 case SCSI_PROT_READ_PASS:
1311 * For READ_STRIP and READ_PASS, force the
1312 * error on data being read off the wire. It
1313 * should force an IO error to the driver.
1316 phba->lpfc_injerr_rapp_cnt--;
1317 if (phba->lpfc_injerr_rapp_cnt == 0) {
1318 phba->lpfc_injerr_nportid = 0;
1319 phba->lpfc_injerr_lba =
1320 LPFC_INJERR_LBA_OFF;
1321 memset(&phba->lpfc_injerr_wwpn,
1322 0, sizeof(struct lpfc_name));
1326 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1327 "0814 BLKGRD: Injecting apptag error: "
1328 "read lba x%lx\n", (unsigned long)lba);
1335 /* Should we change the Guard Tag */
1337 if (phba->lpfc_injerr_wgrd_cnt) {
1339 case SCSI_PROT_WRITE_PASS:
1343 case SCSI_PROT_WRITE_INSERT:
1345 * For WRITE_INSERT, force the
1346 * error to be sent on the wire. It should be
1347 * detected by the Target.
1349 phba->lpfc_injerr_wgrd_cnt--;
1350 if (phba->lpfc_injerr_wgrd_cnt == 0) {
1351 phba->lpfc_injerr_nportid = 0;
1352 phba->lpfc_injerr_lba =
1353 LPFC_INJERR_LBA_OFF;
1354 memset(&phba->lpfc_injerr_wwpn,
1355 0, sizeof(struct lpfc_name));
1358 rc |= BG_ERR_TGT | BG_ERR_SWAP;
1359 /* Signals the caller to swap CRC->CSUM */
1361 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1362 "0817 BLKGRD: Injecting guard error: "
1363 "write lba x%lx\n", (unsigned long)lba);
1365 case SCSI_PROT_WRITE_STRIP:
1367 * For WRITE_STRIP and WRITE_PASS,
1368 * force the error on data
1369 * being copied from SLI-Host to SLI-Port.
1371 phba->lpfc_injerr_wgrd_cnt--;
1372 if (phba->lpfc_injerr_wgrd_cnt == 0) {
1373 phba->lpfc_injerr_nportid = 0;
1374 phba->lpfc_injerr_lba =
1375 LPFC_INJERR_LBA_OFF;
1376 memset(&phba->lpfc_injerr_wwpn,
1377 0, sizeof(struct lpfc_name));
1380 rc = BG_ERR_INIT | BG_ERR_SWAP;
1381 /* Signals the caller to swap CRC->CSUM */
1383 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1384 "0816 BLKGRD: Injecting guard error: "
1385 "write lba x%lx\n", (unsigned long)lba);
1389 if (phba->lpfc_injerr_rgrd_cnt) {
1391 case SCSI_PROT_READ_INSERT:
1392 case SCSI_PROT_READ_STRIP:
1393 case SCSI_PROT_READ_PASS:
1395 * For READ_STRIP and READ_PASS, force the
1396 * error on data being read off the wire. It
1397 * should force an IO error to the driver.
1399 phba->lpfc_injerr_rgrd_cnt--;
1400 if (phba->lpfc_injerr_rgrd_cnt == 0) {
1401 phba->lpfc_injerr_nportid = 0;
1402 phba->lpfc_injerr_lba =
1403 LPFC_INJERR_LBA_OFF;
1404 memset(&phba->lpfc_injerr_wwpn,
1405 0, sizeof(struct lpfc_name));
1408 rc = BG_ERR_INIT | BG_ERR_SWAP;
1409 /* Signals the caller to swap CRC->CSUM */
1411 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1412 "0818 BLKGRD: Injecting guard error: "
1413 "read lba x%lx\n", (unsigned long)lba);
1423 * lpfc_sc_to_bg_opcodes - Determine the BlockGuard opcodes to be used with
1424 * the specified SCSI command.
1425 * @phba: The Hba for which this call is being executed.
1426 * @sc: The SCSI command to examine
1427 * @txopt: (out) BlockGuard operation for transmitted data
1428 * @rxopt: (out) BlockGuard operation for received data
1430 * Returns: zero on success; non-zero if tx and/or rx op cannot be determined
1434 lpfc_sc_to_bg_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1435 uint8_t *txop, uint8_t *rxop)
1439 if (lpfc_cmd_guard_csum(sc)) {
1440 switch (scsi_get_prot_op(sc)) {
1441 case SCSI_PROT_READ_INSERT:
1442 case SCSI_PROT_WRITE_STRIP:
1443 *rxop = BG_OP_IN_NODIF_OUT_CSUM;
1444 *txop = BG_OP_IN_CSUM_OUT_NODIF;
1447 case SCSI_PROT_READ_STRIP:
1448 case SCSI_PROT_WRITE_INSERT:
1449 *rxop = BG_OP_IN_CRC_OUT_NODIF;
1450 *txop = BG_OP_IN_NODIF_OUT_CRC;
1453 case SCSI_PROT_READ_PASS:
1454 case SCSI_PROT_WRITE_PASS:
1455 *rxop = BG_OP_IN_CRC_OUT_CSUM;
1456 *txop = BG_OP_IN_CSUM_OUT_CRC;
1459 case SCSI_PROT_NORMAL:
1461 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1462 "9063 BLKGRD: Bad op/guard:%d/IP combination\n",
1463 scsi_get_prot_op(sc));
1469 switch (scsi_get_prot_op(sc)) {
1470 case SCSI_PROT_READ_STRIP:
1471 case SCSI_PROT_WRITE_INSERT:
1472 *rxop = BG_OP_IN_CRC_OUT_NODIF;
1473 *txop = BG_OP_IN_NODIF_OUT_CRC;
1476 case SCSI_PROT_READ_PASS:
1477 case SCSI_PROT_WRITE_PASS:
1478 *rxop = BG_OP_IN_CRC_OUT_CRC;
1479 *txop = BG_OP_IN_CRC_OUT_CRC;
1482 case SCSI_PROT_READ_INSERT:
1483 case SCSI_PROT_WRITE_STRIP:
1484 *rxop = BG_OP_IN_NODIF_OUT_CRC;
1485 *txop = BG_OP_IN_CRC_OUT_NODIF;
1488 case SCSI_PROT_NORMAL:
1490 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1491 "9075 BLKGRD: Bad op/guard:%d/CRC combination\n",
1492 scsi_get_prot_op(sc));
1501 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1503 * lpfc_bg_err_opcodes - reDetermine the BlockGuard opcodes to be used with
1504 * the specified SCSI command in order to force a guard tag error.
1505 * @phba: The Hba for which this call is being executed.
1506 * @sc: The SCSI command to examine
1507 * @txopt: (out) BlockGuard operation for transmitted data
1508 * @rxopt: (out) BlockGuard operation for received data
1510 * Returns: zero on success; non-zero if tx and/or rx op cannot be determined
1514 lpfc_bg_err_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1515 uint8_t *txop, uint8_t *rxop)
1519 if (lpfc_cmd_guard_csum(sc)) {
1520 switch (scsi_get_prot_op(sc)) {
1521 case SCSI_PROT_READ_INSERT:
1522 case SCSI_PROT_WRITE_STRIP:
1523 *rxop = BG_OP_IN_NODIF_OUT_CRC;
1524 *txop = BG_OP_IN_CRC_OUT_NODIF;
1527 case SCSI_PROT_READ_STRIP:
1528 case SCSI_PROT_WRITE_INSERT:
1529 *rxop = BG_OP_IN_CSUM_OUT_NODIF;
1530 *txop = BG_OP_IN_NODIF_OUT_CSUM;
1533 case SCSI_PROT_READ_PASS:
1534 case SCSI_PROT_WRITE_PASS:
1535 *rxop = BG_OP_IN_CSUM_OUT_CRC;
1536 *txop = BG_OP_IN_CRC_OUT_CSUM;
1539 case SCSI_PROT_NORMAL:
1545 switch (scsi_get_prot_op(sc)) {
1546 case SCSI_PROT_READ_STRIP:
1547 case SCSI_PROT_WRITE_INSERT:
1548 *rxop = BG_OP_IN_CSUM_OUT_NODIF;
1549 *txop = BG_OP_IN_NODIF_OUT_CSUM;
1552 case SCSI_PROT_READ_PASS:
1553 case SCSI_PROT_WRITE_PASS:
1554 *rxop = BG_OP_IN_CSUM_OUT_CSUM;
1555 *txop = BG_OP_IN_CSUM_OUT_CSUM;
1558 case SCSI_PROT_READ_INSERT:
1559 case SCSI_PROT_WRITE_STRIP:
1560 *rxop = BG_OP_IN_NODIF_OUT_CSUM;
1561 *txop = BG_OP_IN_CSUM_OUT_NODIF;
1564 case SCSI_PROT_NORMAL:
1575 * lpfc_bg_setup_bpl - Setup BlockGuard BPL with no protection data
1576 * @phba: The Hba for which this call is being executed.
1577 * @sc: pointer to scsi command we're working on
1578 * @bpl: pointer to buffer list for protection groups
1579 * @datacnt: number of segments of data that have been dma mapped
1581 * This function sets up BPL buffer list for protection groups of
1582 * type LPFC_PG_TYPE_NO_DIF
1584 * This is usually used when the HBA is instructed to generate
1585 * DIFs and insert them into data stream (or strip DIF from
1586 * incoming data stream)
1588 * The buffer list consists of just one protection group described
1590 * +-------------------------+
1591 * start of prot group --> | PDE_5 |
1592 * +-------------------------+
1594 * +-------------------------+
1596 * +-------------------------+
1597 * |more Data BDE's ... (opt)|
1598 * +-------------------------+
1601 * Note: Data s/g buffers have been dma mapped
1603 * Returns the number of BDEs added to the BPL.
1606 lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1607 struct ulp_bde64 *bpl, int datasegcnt)
1609 struct scatterlist *sgde = NULL; /* s/g data entry */
1610 struct lpfc_pde5 *pde5 = NULL;
1611 struct lpfc_pde6 *pde6 = NULL;
1612 dma_addr_t physaddr;
1613 int i = 0, num_bde = 0, status;
1614 int datadir = sc->sc_data_direction;
1615 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1618 uint32_t checking = 1;
1622 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
1626 /* extract some info from the scsi command for pde*/
1627 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
1629 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1630 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
1632 if (rc & BG_ERR_SWAP)
1633 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
1634 if (rc & BG_ERR_CHECK)
1639 /* setup PDE5 with what we have */
1640 pde5 = (struct lpfc_pde5 *) bpl;
1641 memset(pde5, 0, sizeof(struct lpfc_pde5));
1642 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
1644 /* Endianness conversion if necessary for PDE5 */
1645 pde5->word0 = cpu_to_le32(pde5->word0);
1646 pde5->reftag = cpu_to_le32(reftag);
1648 /* advance bpl and increment bde count */
1651 pde6 = (struct lpfc_pde6 *) bpl;
1653 /* setup PDE6 with the rest of the info */
1654 memset(pde6, 0, sizeof(struct lpfc_pde6));
1655 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
1656 bf_set(pde6_optx, pde6, txop);
1657 bf_set(pde6_oprx, pde6, rxop);
1660 * We only need to check the data on READs, for WRITEs
1661 * protection data is automatically generated, not checked.
1663 if (datadir == DMA_FROM_DEVICE) {
1664 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD))
1665 bf_set(pde6_ce, pde6, checking);
1667 bf_set(pde6_ce, pde6, 0);
1669 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
1670 bf_set(pde6_re, pde6, checking);
1672 bf_set(pde6_re, pde6, 0);
1674 bf_set(pde6_ai, pde6, 1);
1675 bf_set(pde6_ae, pde6, 0);
1676 bf_set(pde6_apptagval, pde6, 0);
1678 /* Endianness conversion if necessary for PDE6 */
1679 pde6->word0 = cpu_to_le32(pde6->word0);
1680 pde6->word1 = cpu_to_le32(pde6->word1);
1681 pde6->word2 = cpu_to_le32(pde6->word2);
1683 /* advance bpl and increment bde count */
1687 /* assumption: caller has already run dma_map_sg on command data */
1688 scsi_for_each_sg(sc, sgde, datasegcnt, i) {
1689 physaddr = sg_dma_address(sgde);
1690 bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr));
1691 bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
1692 bpl->tus.f.bdeSize = sg_dma_len(sgde);
1693 if (datadir == DMA_TO_DEVICE)
1694 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1696 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
1697 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1707 * lpfc_bg_setup_bpl_prot - Setup BlockGuard BPL with protection data
1708 * @phba: The Hba for which this call is being executed.
1709 * @sc: pointer to scsi command we're working on
1710 * @bpl: pointer to buffer list for protection groups
1711 * @datacnt: number of segments of data that have been dma mapped
1712 * @protcnt: number of segment of protection data that have been dma mapped
1714 * This function sets up BPL buffer list for protection groups of
1715 * type LPFC_PG_TYPE_DIF
1717 * This is usually used when DIFs are in their own buffers,
1718 * separate from the data. The HBA can then by instructed
1719 * to place the DIFs in the outgoing stream. For read operations,
1720 * The HBA could extract the DIFs and place it in DIF buffers.
1722 * The buffer list for this type consists of one or more of the
1723 * protection groups described below:
1724 * +-------------------------+
1725 * start of first prot group --> | PDE_5 |
1726 * +-------------------------+
1728 * +-------------------------+
1729 * | PDE_7 (Prot BDE) |
1730 * +-------------------------+
1732 * +-------------------------+
1733 * |more Data BDE's ... (opt)|
1734 * +-------------------------+
1735 * start of new prot group --> | PDE_5 |
1736 * +-------------------------+
1738 * +-------------------------+
1740 * Note: It is assumed that both data and protection s/g buffers have been
1743 * Returns the number of BDEs added to the BPL.
1746 lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1747 struct ulp_bde64 *bpl, int datacnt, int protcnt)
1749 struct scatterlist *sgde = NULL; /* s/g data entry */
1750 struct scatterlist *sgpe = NULL; /* s/g prot entry */
1751 struct lpfc_pde5 *pde5 = NULL;
1752 struct lpfc_pde6 *pde6 = NULL;
1753 struct lpfc_pde7 *pde7 = NULL;
1754 dma_addr_t dataphysaddr, protphysaddr;
1755 unsigned short curr_data = 0, curr_prot = 0;
1756 unsigned int split_offset;
1757 unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder;
1758 unsigned int protgrp_blks, protgrp_bytes;
1759 unsigned int remainder, subtotal;
1761 int datadir = sc->sc_data_direction;
1762 unsigned char pgdone = 0, alldone = 0;
1764 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1767 uint32_t checking = 1;
1772 sgpe = scsi_prot_sglist(sc);
1773 sgde = scsi_sglist(sc);
1775 if (!sgpe || !sgde) {
1776 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1777 "9020 Invalid s/g entry: data=0x%p prot=0x%p\n",
1782 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
1786 /* extract some info from the scsi command */
1787 blksize = lpfc_cmd_blksize(sc);
1788 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
1790 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1791 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
1793 if (rc & BG_ERR_SWAP)
1794 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
1795 if (rc & BG_ERR_CHECK)
1802 /* Check to see if we ran out of space */
1803 if (num_bde >= (phba->cfg_total_seg_cnt - 2))
1806 /* setup PDE5 with what we have */
1807 pde5 = (struct lpfc_pde5 *) bpl;
1808 memset(pde5, 0, sizeof(struct lpfc_pde5));
1809 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
1811 /* Endianness conversion if necessary for PDE5 */
1812 pde5->word0 = cpu_to_le32(pde5->word0);
1813 pde5->reftag = cpu_to_le32(reftag);
1815 /* advance bpl and increment bde count */
1818 pde6 = (struct lpfc_pde6 *) bpl;
1820 /* setup PDE6 with the rest of the info */
1821 memset(pde6, 0, sizeof(struct lpfc_pde6));
1822 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
1823 bf_set(pde6_optx, pde6, txop);
1824 bf_set(pde6_oprx, pde6, rxop);
1826 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD))
1827 bf_set(pde6_ce, pde6, checking);
1829 bf_set(pde6_ce, pde6, 0);
1831 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
1832 bf_set(pde6_re, pde6, checking);
1834 bf_set(pde6_re, pde6, 0);
1836 bf_set(pde6_ai, pde6, 1);
1837 bf_set(pde6_ae, pde6, 0);
1838 bf_set(pde6_apptagval, pde6, 0);
1840 /* Endianness conversion if necessary for PDE6 */
1841 pde6->word0 = cpu_to_le32(pde6->word0);
1842 pde6->word1 = cpu_to_le32(pde6->word1);
1843 pde6->word2 = cpu_to_le32(pde6->word2);
1845 /* advance bpl and increment bde count */
1849 /* setup the first BDE that points to protection buffer */
1850 protphysaddr = sg_dma_address(sgpe) + protgroup_offset;
1851 protgroup_len = sg_dma_len(sgpe) - protgroup_offset;
1853 /* must be integer multiple of the DIF block length */
1854 BUG_ON(protgroup_len % 8);
1856 pde7 = (struct lpfc_pde7 *) bpl;
1857 memset(pde7, 0, sizeof(struct lpfc_pde7));
1858 bf_set(pde7_type, pde7, LPFC_PDE7_DESCRIPTOR);
1860 pde7->addrHigh = le32_to_cpu(putPaddrHigh(protphysaddr));
1861 pde7->addrLow = le32_to_cpu(putPaddrLow(protphysaddr));
1863 protgrp_blks = protgroup_len / 8;
1864 protgrp_bytes = protgrp_blks * blksize;
1866 /* check if this pde is crossing the 4K boundary; if so split */
1867 if ((pde7->addrLow & 0xfff) + protgroup_len > 0x1000) {
1868 protgroup_remainder = 0x1000 - (pde7->addrLow & 0xfff);
1869 protgroup_offset += protgroup_remainder;
1870 protgrp_blks = protgroup_remainder / 8;
1871 protgrp_bytes = protgrp_blks * blksize;
1873 protgroup_offset = 0;
1879 /* setup BDE's for data blocks associated with DIF data */
1881 subtotal = 0; /* total bytes processed for current prot grp */
1883 /* Check to see if we ran out of space */
1884 if (num_bde >= phba->cfg_total_seg_cnt)
1888 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1889 "9065 BLKGRD:%s Invalid data segment\n",
1894 dataphysaddr = sg_dma_address(sgde) + split_offset;
1895 bpl->addrLow = le32_to_cpu(putPaddrLow(dataphysaddr));
1896 bpl->addrHigh = le32_to_cpu(putPaddrHigh(dataphysaddr));
1898 remainder = sg_dma_len(sgde) - split_offset;
1900 if ((subtotal + remainder) <= protgrp_bytes) {
1901 /* we can use this whole buffer */
1902 bpl->tus.f.bdeSize = remainder;
1905 if ((subtotal + remainder) == protgrp_bytes)
1908 /* must split this buffer with next prot grp */
1909 bpl->tus.f.bdeSize = protgrp_bytes - subtotal;
1910 split_offset += bpl->tus.f.bdeSize;
1913 subtotal += bpl->tus.f.bdeSize;
1915 if (datadir == DMA_TO_DEVICE)
1916 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1918 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
1919 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1927 /* Move to the next s/g segment if possible */
1928 sgde = sg_next(sgde);
1932 if (protgroup_offset) {
1933 /* update the reference tag */
1934 reftag += protgrp_blks;
1940 if (curr_prot == protcnt) {
1942 } else if (curr_prot < protcnt) {
1943 /* advance to next prot buffer */
1944 sgpe = sg_next(sgpe);
1947 /* update the reference tag */
1948 reftag += protgrp_blks;
1950 /* if we're here, we have a bug */
1951 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1952 "9054 BLKGRD: bug in %s\n", __func__);
1962 * lpfc_bg_setup_sgl - Setup BlockGuard SGL with no protection data
1963 * @phba: The Hba for which this call is being executed.
1964 * @sc: pointer to scsi command we're working on
1965 * @sgl: pointer to buffer list for protection groups
1966 * @datacnt: number of segments of data that have been dma mapped
1968 * This function sets up SGL buffer list for protection groups of
1969 * type LPFC_PG_TYPE_NO_DIF
1971 * This is usually used when the HBA is instructed to generate
1972 * DIFs and insert them into data stream (or strip DIF from
1973 * incoming data stream)
1975 * The buffer list consists of just one protection group described
1977 * +-------------------------+
1978 * start of prot group --> | DI_SEED |
1979 * +-------------------------+
1981 * +-------------------------+
1982 * |more Data SGE's ... (opt)|
1983 * +-------------------------+
1986 * Note: Data s/g buffers have been dma mapped
1988 * Returns the number of SGEs added to the SGL.
1991 lpfc_bg_setup_sgl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1992 struct sli4_sge *sgl, int datasegcnt)
1994 struct scatterlist *sgde = NULL; /* s/g data entry */
1995 struct sli4_sge_diseed *diseed = NULL;
1996 dma_addr_t physaddr;
1997 int i = 0, num_sge = 0, status;
2000 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2003 uint32_t checking = 1;
2005 uint32_t dma_offset = 0;
2007 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2011 /* extract some info from the scsi command for pde*/
2012 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
2014 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2015 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2017 if (rc & BG_ERR_SWAP)
2018 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2019 if (rc & BG_ERR_CHECK)
2024 /* setup DISEED with what we have */
2025 diseed = (struct sli4_sge_diseed *) sgl;
2026 memset(diseed, 0, sizeof(struct sli4_sge_diseed));
2027 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED);
2029 /* Endianness conversion if necessary */
2030 diseed->ref_tag = cpu_to_le32(reftag);
2031 diseed->ref_tag_tran = diseed->ref_tag;
2034 * We only need to check the data on READs, for WRITEs
2035 * protection data is automatically generated, not checked.
2037 if (sc->sc_data_direction == DMA_FROM_DEVICE) {
2038 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD))
2039 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
2041 bf_set(lpfc_sli4_sge_dif_ce, diseed, 0);
2043 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
2044 bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
2046 bf_set(lpfc_sli4_sge_dif_re, diseed, 0);
2049 /* setup DISEED with the rest of the info */
2050 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
2051 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
2053 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
2054 bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
2056 /* Endianness conversion if necessary for DISEED */
2057 diseed->word2 = cpu_to_le32(diseed->word2);
2058 diseed->word3 = cpu_to_le32(diseed->word3);
2060 /* advance bpl and increment sge count */
2064 /* assumption: caller has already run dma_map_sg on command data */
2065 scsi_for_each_sg(sc, sgde, datasegcnt, i) {
2066 physaddr = sg_dma_address(sgde);
2067 dma_len = sg_dma_len(sgde);
2068 sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
2069 sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
2070 if ((i + 1) == datasegcnt)
2071 bf_set(lpfc_sli4_sge_last, sgl, 1);
2073 bf_set(lpfc_sli4_sge_last, sgl, 0);
2074 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
2075 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
2077 sgl->sge_len = cpu_to_le32(dma_len);
2078 dma_offset += dma_len;
2089 * lpfc_bg_setup_sgl_prot - Setup BlockGuard SGL with protection data
2090 * @phba: The Hba for which this call is being executed.
2091 * @sc: pointer to scsi command we're working on
2092 * @sgl: pointer to buffer list for protection groups
2093 * @datacnt: number of segments of data that have been dma mapped
2094 * @protcnt: number of segment of protection data that have been dma mapped
2096 * This function sets up SGL buffer list for protection groups of
2097 * type LPFC_PG_TYPE_DIF
2099 * This is usually used when DIFs are in their own buffers,
2100 * separate from the data. The HBA can then by instructed
2101 * to place the DIFs in the outgoing stream. For read operations,
2102 * The HBA could extract the DIFs and place it in DIF buffers.
2104 * The buffer list for this type consists of one or more of the
2105 * protection groups described below:
2106 * +-------------------------+
2107 * start of first prot group --> | DISEED |
2108 * +-------------------------+
2109 * | DIF (Prot SGE) |
2110 * +-------------------------+
2112 * +-------------------------+
2113 * |more Data SGE's ... (opt)|
2114 * +-------------------------+
2115 * start of new prot group --> | DISEED |
2116 * +-------------------------+
2118 * +-------------------------+
2120 * Note: It is assumed that both data and protection s/g buffers have been
2123 * Returns the number of SGEs added to the SGL.
2126 lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
2127 struct sli4_sge *sgl, int datacnt, int protcnt)
2129 struct scatterlist *sgde = NULL; /* s/g data entry */
2130 struct scatterlist *sgpe = NULL; /* s/g prot entry */
2131 struct sli4_sge_diseed *diseed = NULL;
2132 dma_addr_t dataphysaddr, protphysaddr;
2133 unsigned short curr_data = 0, curr_prot = 0;
2134 unsigned int split_offset;
2135 unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder;
2136 unsigned int protgrp_blks, protgrp_bytes;
2137 unsigned int remainder, subtotal;
2139 unsigned char pgdone = 0, alldone = 0;
2144 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2147 uint32_t checking = 1;
2148 uint32_t dma_offset = 0;
2151 sgpe = scsi_prot_sglist(sc);
2152 sgde = scsi_sglist(sc);
2154 if (!sgpe || !sgde) {
2155 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2156 "9082 Invalid s/g entry: data=0x%p prot=0x%p\n",
2161 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2165 /* extract some info from the scsi command */
2166 blksize = lpfc_cmd_blksize(sc);
2167 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
2169 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2170 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2172 if (rc & BG_ERR_SWAP)
2173 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2174 if (rc & BG_ERR_CHECK)
2181 /* Check to see if we ran out of space */
2182 if (num_sge >= (phba->cfg_total_seg_cnt - 2))
2185 /* setup DISEED with what we have */
2186 diseed = (struct sli4_sge_diseed *) sgl;
2187 memset(diseed, 0, sizeof(struct sli4_sge_diseed));
2188 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED);
2190 /* Endianness conversion if necessary */
2191 diseed->ref_tag = cpu_to_le32(reftag);
2192 diseed->ref_tag_tran = diseed->ref_tag;
2194 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD)) {
2195 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
2198 bf_set(lpfc_sli4_sge_dif_ce, diseed, 0);
2200 * When in this mode, the hardware will replace
2201 * the guard tag from the host with a
2202 * newly generated good CRC for the wire.
2203 * Switch to raw mode here to avoid this
2204 * behavior. What the host sends gets put on the wire.
2206 if (txop == BG_OP_IN_CRC_OUT_CRC) {
2207 txop = BG_OP_RAW_MODE;
2208 rxop = BG_OP_RAW_MODE;
2213 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
2214 bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
2216 bf_set(lpfc_sli4_sge_dif_re, diseed, 0);
2218 /* setup DISEED with the rest of the info */
2219 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
2220 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
2222 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
2223 bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
2225 /* Endianness conversion if necessary for DISEED */
2226 diseed->word2 = cpu_to_le32(diseed->word2);
2227 diseed->word3 = cpu_to_le32(diseed->word3);
2229 /* advance sgl and increment bde count */
2233 /* setup the first BDE that points to protection buffer */
2234 protphysaddr = sg_dma_address(sgpe) + protgroup_offset;
2235 protgroup_len = sg_dma_len(sgpe) - protgroup_offset;
2237 /* must be integer multiple of the DIF block length */
2238 BUG_ON(protgroup_len % 8);
2240 /* Now setup DIF SGE */
2242 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DIF);
2243 sgl->addr_hi = le32_to_cpu(putPaddrHigh(protphysaddr));
2244 sgl->addr_lo = le32_to_cpu(putPaddrLow(protphysaddr));
2245 sgl->word2 = cpu_to_le32(sgl->word2);
2247 protgrp_blks = protgroup_len / 8;
2248 protgrp_bytes = protgrp_blks * blksize;
2250 /* check if DIF SGE is crossing the 4K boundary; if so split */
2251 if ((sgl->addr_lo & 0xfff) + protgroup_len > 0x1000) {
2252 protgroup_remainder = 0x1000 - (sgl->addr_lo & 0xfff);
2253 protgroup_offset += protgroup_remainder;
2254 protgrp_blks = protgroup_remainder / 8;
2255 protgrp_bytes = protgrp_blks * blksize;
2257 protgroup_offset = 0;
2263 /* setup SGE's for data blocks associated with DIF data */
2265 subtotal = 0; /* total bytes processed for current prot grp */
2267 /* Check to see if we ran out of space */
2268 if (num_sge >= phba->cfg_total_seg_cnt)
2272 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2273 "9086 BLKGRD:%s Invalid data segment\n",
2278 dataphysaddr = sg_dma_address(sgde) + split_offset;
2280 remainder = sg_dma_len(sgde) - split_offset;
2282 if ((subtotal + remainder) <= protgrp_bytes) {
2283 /* we can use this whole buffer */
2284 dma_len = remainder;
2287 if ((subtotal + remainder) == protgrp_bytes)
2290 /* must split this buffer with next prot grp */
2291 dma_len = protgrp_bytes - subtotal;
2292 split_offset += dma_len;
2295 subtotal += dma_len;
2297 sgl->addr_lo = cpu_to_le32(putPaddrLow(dataphysaddr));
2298 sgl->addr_hi = cpu_to_le32(putPaddrHigh(dataphysaddr));
2299 bf_set(lpfc_sli4_sge_last, sgl, 0);
2300 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
2301 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
2303 sgl->sge_len = cpu_to_le32(dma_len);
2304 dma_offset += dma_len;
2312 /* Move to the next s/g segment if possible */
2313 sgde = sg_next(sgde);
2316 if (protgroup_offset) {
2317 /* update the reference tag */
2318 reftag += protgrp_blks;
2324 if (curr_prot == protcnt) {
2325 bf_set(lpfc_sli4_sge_last, sgl, 1);
2327 } else if (curr_prot < protcnt) {
2328 /* advance to next prot buffer */
2329 sgpe = sg_next(sgpe);
2332 /* update the reference tag */
2333 reftag += protgrp_blks;
2335 /* if we're here, we have a bug */
2336 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2337 "9085 BLKGRD: bug in %s\n", __func__);
2348 * lpfc_prot_group_type - Get prtotection group type of SCSI command
2349 * @phba: The Hba for which this call is being executed.
2350 * @sc: pointer to scsi command we're working on
2352 * Given a SCSI command that supports DIF, determine composition of protection
2353 * groups involved in setting up buffer lists
2355 * Returns: Protection group type (with or without DIF)
2359 lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc)
2361 int ret = LPFC_PG_TYPE_INVALID;
2362 unsigned char op = scsi_get_prot_op(sc);
2365 case SCSI_PROT_READ_STRIP:
2366 case SCSI_PROT_WRITE_INSERT:
2367 ret = LPFC_PG_TYPE_NO_DIF;
2369 case SCSI_PROT_READ_INSERT:
2370 case SCSI_PROT_WRITE_STRIP:
2371 case SCSI_PROT_READ_PASS:
2372 case SCSI_PROT_WRITE_PASS:
2373 ret = LPFC_PG_TYPE_DIF_BUF;
2377 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2378 "9021 Unsupported protection op:%d\n",
2386 * lpfc_bg_scsi_adjust_dl - Adjust SCSI data length for BlockGuard
2387 * @phba: The Hba for which this call is being executed.
2388 * @lpfc_cmd: The scsi buffer which is going to be adjusted.
2390 * Adjust the data length to account for how much data
2391 * is actually on the wire.
2393 * returns the adjusted data length
2396 lpfc_bg_scsi_adjust_dl(struct lpfc_hba *phba,
2397 struct lpfc_io_buf *lpfc_cmd)
2399 struct scsi_cmnd *sc = lpfc_cmd->pCmd;
2402 fcpdl = scsi_bufflen(sc);
2404 /* Check if there is protection data on the wire */
2405 if (sc->sc_data_direction == DMA_FROM_DEVICE) {
2406 /* Read check for protection data */
2407 if (scsi_get_prot_op(sc) == SCSI_PROT_READ_INSERT)
2411 /* Write check for protection data */
2412 if (scsi_get_prot_op(sc) == SCSI_PROT_WRITE_STRIP)
2417 * If we are in DIF Type 1 mode every data block has a 8 byte
2418 * DIF (trailer) attached to it. Must ajust FCP data length
2419 * to account for the protection data.
2421 fcpdl += (fcpdl / lpfc_cmd_blksize(sc)) * 8;
2427 * lpfc_bg_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec
2428 * @phba: The Hba for which this call is being executed.
2429 * @lpfc_cmd: The scsi buffer which is going to be prep'ed.
2431 * This is the protection/DIF aware version of
2432 * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the
2433 * two functions eventually, but for now, it's here
2436 lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
2437 struct lpfc_io_buf *lpfc_cmd)
2439 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
2440 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
2441 struct ulp_bde64 *bpl = (struct ulp_bde64 *)lpfc_cmd->dma_sgl;
2442 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
2443 uint32_t num_bde = 0;
2444 int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
2445 int prot_group_type = 0;
2447 struct lpfc_vport *vport = phba->pport;
2450 * Start the lpfc command prep by bumping the bpl beyond fcp_cmnd
2451 * fcp_rsp regions to the first data bde entry
2454 if (scsi_sg_count(scsi_cmnd)) {
2456 * The driver stores the segment count returned from pci_map_sg
2457 * because this a count of dma-mappings used to map the use_sg
2458 * pages. They are not guaranteed to be the same for those
2459 * architectures that implement an IOMMU.
2461 datasegcnt = dma_map_sg(&phba->pcidev->dev,
2462 scsi_sglist(scsi_cmnd),
2463 scsi_sg_count(scsi_cmnd), datadir);
2464 if (unlikely(!datasegcnt))
2467 lpfc_cmd->seg_cnt = datasegcnt;
2469 /* First check if data segment count from SCSI Layer is good */
2470 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt)
2473 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
2475 switch (prot_group_type) {
2476 case LPFC_PG_TYPE_NO_DIF:
2478 /* Here we need to add a PDE5 and PDE6 to the count */
2479 if ((lpfc_cmd->seg_cnt + 2) > phba->cfg_total_seg_cnt)
2482 num_bde = lpfc_bg_setup_bpl(phba, scsi_cmnd, bpl,
2484 /* we should have 2 or more entries in buffer list */
2489 case LPFC_PG_TYPE_DIF_BUF:
2491 * This type indicates that protection buffers are
2492 * passed to the driver, so that needs to be prepared
2495 protsegcnt = dma_map_sg(&phba->pcidev->dev,
2496 scsi_prot_sglist(scsi_cmnd),
2497 scsi_prot_sg_count(scsi_cmnd), datadir);
2498 if (unlikely(!protsegcnt)) {
2499 scsi_dma_unmap(scsi_cmnd);
2503 lpfc_cmd->prot_seg_cnt = protsegcnt;
2506 * There is a minimun of 4 BPLs used for every
2507 * protection data segment.
2509 if ((lpfc_cmd->prot_seg_cnt * 4) >
2510 (phba->cfg_total_seg_cnt - 2))
2513 num_bde = lpfc_bg_setup_bpl_prot(phba, scsi_cmnd, bpl,
2514 datasegcnt, protsegcnt);
2515 /* we should have 3 or more entries in buffer list */
2516 if ((num_bde < 3) ||
2517 (num_bde > phba->cfg_total_seg_cnt))
2521 case LPFC_PG_TYPE_INVALID:
2523 scsi_dma_unmap(scsi_cmnd);
2524 lpfc_cmd->seg_cnt = 0;
2526 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2527 "9022 Unexpected protection group %i\n",
2534 * Finish initializing those IOCB fields that are dependent on the
2535 * scsi_cmnd request_buffer. Note that the bdeSize is explicitly
2536 * reinitialized since all iocb memory resources are used many times
2537 * for transmit, receive, and continuation bpl's.
2539 iocb_cmd->un.fcpi64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
2540 iocb_cmd->un.fcpi64.bdl.bdeSize += (num_bde * sizeof(struct ulp_bde64));
2541 iocb_cmd->ulpBdeCount = 1;
2542 iocb_cmd->ulpLe = 1;
2544 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
2545 fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
2548 * Due to difference in data length between DIF/non-DIF paths,
2549 * we need to set word 4 of IOCB here
2551 iocb_cmd->un.fcpi.fcpi_parm = fcpdl;
2554 * For First burst, we may need to adjust the initial transfer
2557 if (iocb_cmd->un.fcpi.fcpi_XRdy &&
2558 (fcpdl < vport->cfg_first_burst_size))
2559 iocb_cmd->un.fcpi.fcpi_XRdy = fcpdl;
2563 if (lpfc_cmd->seg_cnt)
2564 scsi_dma_unmap(scsi_cmnd);
2565 if (lpfc_cmd->prot_seg_cnt)
2566 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd),
2567 scsi_prot_sg_count(scsi_cmnd),
2568 scsi_cmnd->sc_data_direction);
2570 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2571 "9023 Cannot setup S/G List for HBA"
2572 "IO segs %d/%d BPL %d SCSI %d: %d %d\n",
2573 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
2574 phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt,
2575 prot_group_type, num_bde);
2577 lpfc_cmd->seg_cnt = 0;
2578 lpfc_cmd->prot_seg_cnt = 0;
2583 * This function calcuates the T10 DIF guard tag
2584 * on the specified data using a CRC algorithmn
2588 lpfc_bg_crc(uint8_t *data, int count)
2593 crc = crc_t10dif(data, count);
2594 x = cpu_to_be16(crc);
2599 * This function calcuates the T10 DIF guard tag
2600 * on the specified data using a CSUM algorithmn
2601 * using ip_compute_csum.
2604 lpfc_bg_csum(uint8_t *data, int count)
2608 ret = ip_compute_csum(data, count);
2613 * This function examines the protection data to try to determine
2614 * what type of T10-DIF error occurred.
2617 lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
2619 struct scatterlist *sgpe; /* s/g prot entry */
2620 struct scatterlist *sgde; /* s/g data entry */
2621 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
2622 struct scsi_dif_tuple *src = NULL;
2623 uint8_t *data_src = NULL;
2625 uint16_t start_app_tag, app_tag;
2626 uint32_t start_ref_tag, ref_tag;
2627 int prot, protsegcnt;
2628 int err_type, len, data_len;
2629 int chk_ref, chk_app, chk_guard;
2633 err_type = BGS_GUARD_ERR_MASK;
2637 /* First check to see if there is protection data to examine */
2638 prot = scsi_get_prot_op(cmd);
2639 if ((prot == SCSI_PROT_READ_STRIP) ||
2640 (prot == SCSI_PROT_WRITE_INSERT) ||
2641 (prot == SCSI_PROT_NORMAL))
2644 /* Currently the driver just supports ref_tag and guard_tag checking */
2649 /* Setup a ptr to the protection data provided by the SCSI host */
2650 sgpe = scsi_prot_sglist(cmd);
2651 protsegcnt = lpfc_cmd->prot_seg_cnt;
2653 if (sgpe && protsegcnt) {
2656 * We will only try to verify guard tag if the segment
2657 * data length is a multiple of the blksize.
2659 sgde = scsi_sglist(cmd);
2660 blksize = lpfc_cmd_blksize(cmd);
2661 data_src = (uint8_t *)sg_virt(sgde);
2662 data_len = sgde->length;
2663 if ((data_len & (blksize - 1)) == 0)
2666 src = (struct scsi_dif_tuple *)sg_virt(sgpe);
2667 start_ref_tag = (uint32_t)scsi_get_lba(cmd); /* Truncate LBA */
2668 start_app_tag = src->app_tag;
2670 while (src && protsegcnt) {
2674 * First check to see if a protection data
2677 if ((src->ref_tag == T10_PI_REF_ESCAPE) ||
2678 (src->app_tag == T10_PI_APP_ESCAPE)) {
2683 /* First Guard Tag checking */
2685 guard_tag = src->guard_tag;
2686 if (lpfc_cmd_guard_csum(cmd))
2687 sum = lpfc_bg_csum(data_src,
2690 sum = lpfc_bg_crc(data_src,
2692 if ((guard_tag != sum)) {
2693 err_type = BGS_GUARD_ERR_MASK;
2698 /* Reference Tag checking */
2699 ref_tag = be32_to_cpu(src->ref_tag);
2700 if (chk_ref && (ref_tag != start_ref_tag)) {
2701 err_type = BGS_REFTAG_ERR_MASK;
2706 /* App Tag checking */
2707 app_tag = src->app_tag;
2708 if (chk_app && (app_tag != start_app_tag)) {
2709 err_type = BGS_APPTAG_ERR_MASK;
2713 len -= sizeof(struct scsi_dif_tuple);
2718 data_src += blksize;
2719 data_len -= blksize;
2722 * Are we at the end of the Data segment?
2723 * The data segment is only used for Guard
2726 if (chk_guard && (data_len == 0)) {
2728 sgde = sg_next(sgde);
2732 data_src = (uint8_t *)sg_virt(sgde);
2733 data_len = sgde->length;
2734 if ((data_len & (blksize - 1)) == 0)
2739 /* Goto the next Protection data segment */
2740 sgpe = sg_next(sgpe);
2742 src = (struct scsi_dif_tuple *)sg_virt(sgpe);
2751 if (err_type == BGS_GUARD_ERR_MASK) {
2752 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2754 cmd->result = DRIVER_SENSE << 24 | DID_ABORT << 16 |
2755 SAM_STAT_CHECK_CONDITION;
2756 phba->bg_guard_err_cnt++;
2757 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2758 "9069 BLKGRD: LBA %lx grd_tag error %x != %x\n",
2759 (unsigned long)scsi_get_lba(cmd),
2762 } else if (err_type == BGS_REFTAG_ERR_MASK) {
2763 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2765 cmd->result = DRIVER_SENSE << 24 | DID_ABORT << 16 |
2766 SAM_STAT_CHECK_CONDITION;
2768 phba->bg_reftag_err_cnt++;
2769 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2770 "9066 BLKGRD: LBA %lx ref_tag error %x != %x\n",
2771 (unsigned long)scsi_get_lba(cmd),
2772 ref_tag, start_ref_tag);
2774 } else if (err_type == BGS_APPTAG_ERR_MASK) {
2775 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2777 cmd->result = DRIVER_SENSE << 24 | DID_ABORT << 16 |
2778 SAM_STAT_CHECK_CONDITION;
2780 phba->bg_apptag_err_cnt++;
2781 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2782 "9041 BLKGRD: LBA %lx app_tag error %x != %x\n",
2783 (unsigned long)scsi_get_lba(cmd),
2784 app_tag, start_app_tag);
2790 * This function checks for BlockGuard errors detected by
2791 * the HBA. In case of errors, the ASC/ASCQ fields in the
2792 * sense buffer will be set accordingly, paired with
2793 * ILLEGAL_REQUEST to signal to the kernel that the HBA
2794 * detected corruption.
2797 * 0 - No error found
2798 * 1 - BlockGuard error found
2799 * -1 - Internal error (bad profile, ...etc)
2802 lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
2803 struct lpfc_iocbq *pIocbOut)
2805 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
2806 struct sli3_bg_fields *bgf = &pIocbOut->iocb.unsli3.sli3_bg;
2808 uint32_t bghm = bgf->bghm;
2809 uint32_t bgstat = bgf->bgstat;
2810 uint64_t failing_sector = 0;
2812 spin_lock(&_dump_buf_lock);
2813 if (!_dump_buf_done) {
2814 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9070 BLKGRD: Saving"
2815 " Data for %u blocks to debugfs\n",
2816 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
2817 lpfc_debug_save_data(phba, cmd);
2819 /* If we have a prot sgl, save the DIF buffer */
2820 if (lpfc_prot_group_type(phba, cmd) ==
2821 LPFC_PG_TYPE_DIF_BUF) {
2822 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9071 BLKGRD: "
2823 "Saving DIF for %u blocks to debugfs\n",
2824 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
2825 lpfc_debug_save_dif(phba, cmd);
2830 spin_unlock(&_dump_buf_lock);
2832 if (lpfc_bgs_get_invalid_prof(bgstat)) {
2833 cmd->result = DID_ERROR << 16;
2834 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2835 "9072 BLKGRD: Invalid BG Profile in cmd"
2836 " 0x%x lba 0x%llx blk cnt 0x%x "
2837 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
2838 (unsigned long long)scsi_get_lba(cmd),
2839 blk_rq_sectors(cmd->request), bgstat, bghm);
2844 if (lpfc_bgs_get_uninit_dif_block(bgstat)) {
2845 cmd->result = DID_ERROR << 16;
2846 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2847 "9073 BLKGRD: Invalid BG PDIF Block in cmd"
2848 " 0x%x lba 0x%llx blk cnt 0x%x "
2849 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
2850 (unsigned long long)scsi_get_lba(cmd),
2851 blk_rq_sectors(cmd->request), bgstat, bghm);
2856 if (lpfc_bgs_get_guard_err(bgstat)) {
2859 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2861 cmd->result = DRIVER_SENSE << 24 | DID_ABORT << 16 |
2862 SAM_STAT_CHECK_CONDITION;
2863 phba->bg_guard_err_cnt++;
2864 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2865 "9055 BLKGRD: Guard Tag error in cmd"
2866 " 0x%x lba 0x%llx blk cnt 0x%x "
2867 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
2868 (unsigned long long)scsi_get_lba(cmd),
2869 blk_rq_sectors(cmd->request), bgstat, bghm);
2872 if (lpfc_bgs_get_reftag_err(bgstat)) {
2875 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2877 cmd->result = DRIVER_SENSE << 24 | DID_ABORT << 16 |
2878 SAM_STAT_CHECK_CONDITION;
2880 phba->bg_reftag_err_cnt++;
2881 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2882 "9056 BLKGRD: Ref Tag error in cmd"
2883 " 0x%x lba 0x%llx blk cnt 0x%x "
2884 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
2885 (unsigned long long)scsi_get_lba(cmd),
2886 blk_rq_sectors(cmd->request), bgstat, bghm);
2889 if (lpfc_bgs_get_apptag_err(bgstat)) {
2892 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2894 cmd->result = DRIVER_SENSE << 24 | DID_ABORT << 16 |
2895 SAM_STAT_CHECK_CONDITION;
2897 phba->bg_apptag_err_cnt++;
2898 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2899 "9061 BLKGRD: App Tag error in cmd"
2900 " 0x%x lba 0x%llx blk cnt 0x%x "
2901 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
2902 (unsigned long long)scsi_get_lba(cmd),
2903 blk_rq_sectors(cmd->request), bgstat, bghm);
2906 if (lpfc_bgs_get_hi_water_mark_present(bgstat)) {
2908 * setup sense data descriptor 0 per SPC-4 as an information
2909 * field, and put the failing LBA in it.
2910 * This code assumes there was also a guard/app/ref tag error
2913 cmd->sense_buffer[7] = 0xc; /* Additional sense length */
2914 cmd->sense_buffer[8] = 0; /* Information descriptor type */
2915 cmd->sense_buffer[9] = 0xa; /* Additional descriptor length */
2916 cmd->sense_buffer[10] = 0x80; /* Validity bit */
2918 /* bghm is a "on the wire" FC frame based count */
2919 switch (scsi_get_prot_op(cmd)) {
2920 case SCSI_PROT_READ_INSERT:
2921 case SCSI_PROT_WRITE_STRIP:
2922 bghm /= cmd->device->sector_size;
2924 case SCSI_PROT_READ_STRIP:
2925 case SCSI_PROT_WRITE_INSERT:
2926 case SCSI_PROT_READ_PASS:
2927 case SCSI_PROT_WRITE_PASS:
2928 bghm /= (cmd->device->sector_size +
2929 sizeof(struct scsi_dif_tuple));
2933 failing_sector = scsi_get_lba(cmd);
2934 failing_sector += bghm;
2936 /* Descriptor Information */
2937 put_unaligned_be64(failing_sector, &cmd->sense_buffer[12]);
2941 /* No error was reported - problem in FW? */
2942 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
2943 "9057 BLKGRD: Unknown error in cmd"
2944 " 0x%x lba 0x%llx blk cnt 0x%x "
2945 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
2946 (unsigned long long)scsi_get_lba(cmd),
2947 blk_rq_sectors(cmd->request), bgstat, bghm);
2949 /* Calcuate what type of error it was */
2950 lpfc_calc_bg_err(phba, lpfc_cmd);
2957 * lpfc_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec
2958 * @phba: The Hba for which this call is being executed.
2959 * @lpfc_cmd: The scsi buffer which is going to be mapped.
2961 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
2962 * field of @lpfc_cmd for device with SLI-4 interface spec.
2969 lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
2971 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
2972 struct scatterlist *sgel = NULL;
2973 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
2974 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->dma_sgl;
2975 struct sli4_sge *first_data_sgl;
2976 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
2977 dma_addr_t physaddr;
2978 uint32_t num_bde = 0;
2980 uint32_t dma_offset = 0;
2982 struct ulp_bde64 *bde;
2985 * There are three possibilities here - use scatter-gather segment, use
2986 * the single mapping, or neither. Start the lpfc command prep by
2987 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
2990 if (scsi_sg_count(scsi_cmnd)) {
2992 * The driver stores the segment count returned from pci_map_sg
2993 * because this a count of dma-mappings used to map the use_sg
2994 * pages. They are not guaranteed to be the same for those
2995 * architectures that implement an IOMMU.
2998 nseg = scsi_dma_map(scsi_cmnd);
2999 if (unlikely(nseg <= 0))
3002 /* clear the last flag in the fcp_rsp map entry */
3003 sgl->word2 = le32_to_cpu(sgl->word2);
3004 bf_set(lpfc_sli4_sge_last, sgl, 0);
3005 sgl->word2 = cpu_to_le32(sgl->word2);
3007 first_data_sgl = sgl;
3008 lpfc_cmd->seg_cnt = nseg;
3009 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
3010 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9074 BLKGRD:"
3011 " %s: Too many sg segments from "
3012 "dma_map_sg. Config %d, seg_cnt %d\n",
3013 __func__, phba->cfg_sg_seg_cnt,
3015 lpfc_cmd->seg_cnt = 0;
3016 scsi_dma_unmap(scsi_cmnd);
3021 * The driver established a maximum scatter-gather segment count
3022 * during probe that limits the number of sg elements in any
3023 * single scsi command. Just run through the seg_cnt and format
3025 * When using SLI-3 the driver will try to fit all the BDEs into
3026 * the IOCB. If it can't then the BDEs get added to a BPL as it
3027 * does for SLI-2 mode.
3029 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
3030 physaddr = sg_dma_address(sgel);
3031 dma_len = sg_dma_len(sgel);
3032 sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
3033 sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
3034 sgl->word2 = le32_to_cpu(sgl->word2);
3035 if ((num_bde + 1) == nseg)
3036 bf_set(lpfc_sli4_sge_last, sgl, 1);
3038 bf_set(lpfc_sli4_sge_last, sgl, 0);
3039 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
3040 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
3041 sgl->word2 = cpu_to_le32(sgl->word2);
3042 sgl->sge_len = cpu_to_le32(dma_len);
3043 dma_offset += dma_len;
3047 * Setup the first Payload BDE. For FCoE we just key off
3048 * Performance Hints, for FC we use lpfc_enable_pbde.
3049 * We populate words 13-15 of IOCB/WQE.
3051 if ((phba->sli3_options & LPFC_SLI4_PERFH_ENABLED) ||
3052 phba->cfg_enable_pbde) {
3053 bde = (struct ulp_bde64 *)
3054 &(iocb_cmd->unsli3.sli3Words[5]);
3055 bde->addrLow = first_data_sgl->addr_lo;
3056 bde->addrHigh = first_data_sgl->addr_hi;
3057 bde->tus.f.bdeSize =
3058 le32_to_cpu(first_data_sgl->sge_len);
3059 bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
3060 bde->tus.w = cpu_to_le32(bde->tus.w);
3064 /* clear the last flag in the fcp_rsp map entry */
3065 sgl->word2 = le32_to_cpu(sgl->word2);
3066 bf_set(lpfc_sli4_sge_last, sgl, 1);
3067 sgl->word2 = cpu_to_le32(sgl->word2);
3069 if ((phba->sli3_options & LPFC_SLI4_PERFH_ENABLED) ||
3070 phba->cfg_enable_pbde) {
3071 bde = (struct ulp_bde64 *)
3072 &(iocb_cmd->unsli3.sli3Words[5]);
3073 memset(bde, 0, (sizeof(uint32_t) * 3));
3078 * Finish initializing those IOCB fields that are dependent on the
3079 * scsi_cmnd request_buffer. Note that for SLI-2 the bdeSize is
3080 * explicitly reinitialized.
3081 * all iocb memory resources are reused.
3083 fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
3086 * Due to difference in data length between DIF/non-DIF paths,
3087 * we need to set word 4 of IOCB here
3089 iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
3092 * If the OAS driver feature is enabled and the lun is enabled for
3093 * OAS, set the oas iocb related flags.
3095 if ((phba->cfg_fof) && ((struct lpfc_device_data *)
3096 scsi_cmnd->device->hostdata)->oas_enabled) {
3097 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF);
3098 lpfc_cmd->cur_iocbq.priority = ((struct lpfc_device_data *)
3099 scsi_cmnd->device->hostdata)->priority;
3106 * lpfc_bg_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec
3107 * @phba: The Hba for which this call is being executed.
3108 * @lpfc_cmd: The scsi buffer which is going to be mapped.
3110 * This is the protection/DIF aware version of
3111 * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the
3112 * two functions eventually, but for now, it's here
3115 lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
3116 struct lpfc_io_buf *lpfc_cmd)
3118 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3119 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3120 struct sli4_sge *sgl = (struct sli4_sge *)(lpfc_cmd->dma_sgl);
3121 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3122 uint32_t num_sge = 0;
3123 int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
3124 int prot_group_type = 0;
3126 struct lpfc_vport *vport = phba->pport;
3129 * Start the lpfc command prep by bumping the sgl beyond fcp_cmnd
3130 * fcp_rsp regions to the first data sge entry
3132 if (scsi_sg_count(scsi_cmnd)) {
3134 * The driver stores the segment count returned from pci_map_sg
3135 * because this a count of dma-mappings used to map the use_sg
3136 * pages. They are not guaranteed to be the same for those
3137 * architectures that implement an IOMMU.
3139 datasegcnt = dma_map_sg(&phba->pcidev->dev,
3140 scsi_sglist(scsi_cmnd),
3141 scsi_sg_count(scsi_cmnd), datadir);
3142 if (unlikely(!datasegcnt))
3146 /* clear the last flag in the fcp_rsp map entry */
3147 sgl->word2 = le32_to_cpu(sgl->word2);
3148 bf_set(lpfc_sli4_sge_last, sgl, 0);
3149 sgl->word2 = cpu_to_le32(sgl->word2);
3152 lpfc_cmd->seg_cnt = datasegcnt;
3154 /* First check if data segment count from SCSI Layer is good */
3155 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt)
3158 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
3160 switch (prot_group_type) {
3161 case LPFC_PG_TYPE_NO_DIF:
3162 /* Here we need to add a DISEED to the count */
3163 if ((lpfc_cmd->seg_cnt + 1) > phba->cfg_total_seg_cnt)
3166 num_sge = lpfc_bg_setup_sgl(phba, scsi_cmnd, sgl,
3169 /* we should have 2 or more entries in buffer list */
3174 case LPFC_PG_TYPE_DIF_BUF:
3176 * This type indicates that protection buffers are
3177 * passed to the driver, so that needs to be prepared
3180 protsegcnt = dma_map_sg(&phba->pcidev->dev,
3181 scsi_prot_sglist(scsi_cmnd),
3182 scsi_prot_sg_count(scsi_cmnd), datadir);
3183 if (unlikely(!protsegcnt)) {
3184 scsi_dma_unmap(scsi_cmnd);
3188 lpfc_cmd->prot_seg_cnt = protsegcnt;
3190 * There is a minimun of 3 SGEs used for every
3191 * protection data segment.
3193 if ((lpfc_cmd->prot_seg_cnt * 3) >
3194 (phba->cfg_total_seg_cnt - 2))
3197 num_sge = lpfc_bg_setup_sgl_prot(phba, scsi_cmnd, sgl,
3198 datasegcnt, protsegcnt);
3200 /* we should have 3 or more entries in buffer list */
3201 if ((num_sge < 3) ||
3202 (num_sge > phba->cfg_total_seg_cnt))
3206 case LPFC_PG_TYPE_INVALID:
3208 scsi_dma_unmap(scsi_cmnd);
3209 lpfc_cmd->seg_cnt = 0;
3211 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
3212 "9083 Unexpected protection group %i\n",
3218 switch (scsi_get_prot_op(scsi_cmnd)) {
3219 case SCSI_PROT_WRITE_STRIP:
3220 case SCSI_PROT_READ_STRIP:
3221 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_STRIP;
3223 case SCSI_PROT_WRITE_INSERT:
3224 case SCSI_PROT_READ_INSERT:
3225 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_INSERT;
3227 case SCSI_PROT_WRITE_PASS:
3228 case SCSI_PROT_READ_PASS:
3229 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_PASS;
3233 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
3234 fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
3237 * Due to difference in data length between DIF/non-DIF paths,
3238 * we need to set word 4 of IOCB here
3240 iocb_cmd->un.fcpi.fcpi_parm = fcpdl;
3243 * For First burst, we may need to adjust the initial transfer
3246 if (iocb_cmd->un.fcpi.fcpi_XRdy &&
3247 (fcpdl < vport->cfg_first_burst_size))
3248 iocb_cmd->un.fcpi.fcpi_XRdy = fcpdl;
3251 * If the OAS driver feature is enabled and the lun is enabled for
3252 * OAS, set the oas iocb related flags.
3254 if ((phba->cfg_fof) && ((struct lpfc_device_data *)
3255 scsi_cmnd->device->hostdata)->oas_enabled)
3256 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF);
3260 if (lpfc_cmd->seg_cnt)
3261 scsi_dma_unmap(scsi_cmnd);
3262 if (lpfc_cmd->prot_seg_cnt)
3263 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd),
3264 scsi_prot_sg_count(scsi_cmnd),
3265 scsi_cmnd->sc_data_direction);
3267 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
3268 "9084 Cannot setup S/G List for HBA"
3269 "IO segs %d/%d SGL %d SCSI %d: %d %d\n",
3270 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
3271 phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt,
3272 prot_group_type, num_sge);
3274 lpfc_cmd->seg_cnt = 0;
3275 lpfc_cmd->prot_seg_cnt = 0;
3280 * lpfc_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer
3281 * @phba: The Hba for which this call is being executed.
3282 * @lpfc_cmd: The scsi buffer which is going to be mapped.
3284 * This routine wraps the actual DMA mapping function pointer from the
3292 lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
3294 return phba->lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
3298 * lpfc_bg_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer
3300 * @phba: The Hba for which this call is being executed.
3301 * @lpfc_cmd: The scsi buffer which is going to be mapped.
3303 * This routine wraps the actual DMA mapping function pointer from the
3311 lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
3313 return phba->lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
3317 * lpfc_send_scsi_error_event - Posts an event when there is SCSI error
3318 * @phba: Pointer to hba context object.
3319 * @vport: Pointer to vport object.
3320 * @lpfc_cmd: Pointer to lpfc scsi command which reported the error.
3321 * @rsp_iocb: Pointer to response iocb object which reported error.
3323 * This function posts an event when there is a SCSI command reporting
3324 * error from the scsi device.
3327 lpfc_send_scsi_error_event(struct lpfc_hba *phba, struct lpfc_vport *vport,
3328 struct lpfc_io_buf *lpfc_cmd, struct lpfc_iocbq *rsp_iocb) {
3329 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3330 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3331 uint32_t resp_info = fcprsp->rspStatus2;
3332 uint32_t scsi_status = fcprsp->rspStatus3;
3333 uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
3334 struct lpfc_fast_path_event *fast_path_evt = NULL;
3335 struct lpfc_nodelist *pnode = lpfc_cmd->rdata->pnode;
3336 unsigned long flags;
3338 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
3341 /* If there is queuefull or busy condition send a scsi event */
3342 if ((cmnd->result == SAM_STAT_TASK_SET_FULL) ||
3343 (cmnd->result == SAM_STAT_BUSY)) {
3344 fast_path_evt = lpfc_alloc_fast_evt(phba);
3347 fast_path_evt->un.scsi_evt.event_type =
3349 fast_path_evt->un.scsi_evt.subcategory =
3350 (cmnd->result == SAM_STAT_TASK_SET_FULL) ?
3351 LPFC_EVENT_QFULL : LPFC_EVENT_DEVBSY;
3352 fast_path_evt->un.scsi_evt.lun = cmnd->device->lun;
3353 memcpy(&fast_path_evt->un.scsi_evt.wwpn,
3354 &pnode->nlp_portname, sizeof(struct lpfc_name));
3355 memcpy(&fast_path_evt->un.scsi_evt.wwnn,
3356 &pnode->nlp_nodename, sizeof(struct lpfc_name));
3357 } else if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen &&
3358 ((cmnd->cmnd[0] == READ_10) || (cmnd->cmnd[0] == WRITE_10))) {
3359 fast_path_evt = lpfc_alloc_fast_evt(phba);
3362 fast_path_evt->un.check_cond_evt.scsi_event.event_type =
3364 fast_path_evt->un.check_cond_evt.scsi_event.subcategory =
3365 LPFC_EVENT_CHECK_COND;
3366 fast_path_evt->un.check_cond_evt.scsi_event.lun =
3368 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwpn,
3369 &pnode->nlp_portname, sizeof(struct lpfc_name));
3370 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwnn,
3371 &pnode->nlp_nodename, sizeof(struct lpfc_name));
3372 fast_path_evt->un.check_cond_evt.sense_key =
3373 cmnd->sense_buffer[2] & 0xf;
3374 fast_path_evt->un.check_cond_evt.asc = cmnd->sense_buffer[12];
3375 fast_path_evt->un.check_cond_evt.ascq = cmnd->sense_buffer[13];
3376 } else if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
3378 ((be32_to_cpu(fcprsp->rspResId) != fcpi_parm) ||
3379 ((scsi_status == SAM_STAT_GOOD) &&
3380 !(resp_info & (RESID_UNDER | RESID_OVER))))) {
3382 * If status is good or resid does not match with fcp_param and
3383 * there is valid fcpi_parm, then there is a read_check error
3385 fast_path_evt = lpfc_alloc_fast_evt(phba);
3388 fast_path_evt->un.read_check_error.header.event_type =
3389 FC_REG_FABRIC_EVENT;
3390 fast_path_evt->un.read_check_error.header.subcategory =
3391 LPFC_EVENT_FCPRDCHKERR;
3392 memcpy(&fast_path_evt->un.read_check_error.header.wwpn,
3393 &pnode->nlp_portname, sizeof(struct lpfc_name));
3394 memcpy(&fast_path_evt->un.read_check_error.header.wwnn,
3395 &pnode->nlp_nodename, sizeof(struct lpfc_name));
3396 fast_path_evt->un.read_check_error.lun = cmnd->device->lun;
3397 fast_path_evt->un.read_check_error.opcode = cmnd->cmnd[0];
3398 fast_path_evt->un.read_check_error.fcpiparam =
3403 fast_path_evt->vport = vport;
3404 spin_lock_irqsave(&phba->hbalock, flags);
3405 list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list);
3406 spin_unlock_irqrestore(&phba->hbalock, flags);
3407 lpfc_worker_wake_up(phba);
3412 * lpfc_scsi_unprep_dma_buf - Un-map DMA mapping of SG-list for dev
3413 * @phba: The HBA for which this call is being executed.
3414 * @psb: The scsi buffer which is going to be un-mapped.
3416 * This routine does DMA un-mapping of scatter gather list of scsi command
3417 * field of @lpfc_cmd for device with SLI-3 interface spec.
3420 lpfc_scsi_unprep_dma_buf(struct lpfc_hba *phba, struct lpfc_io_buf *psb)
3423 * There are only two special cases to consider. (1) the scsi command
3424 * requested scatter-gather usage or (2) the scsi command allocated
3425 * a request buffer, but did not request use_sg. There is a third
3426 * case, but it does not require resource deallocation.
3428 if (psb->seg_cnt > 0)
3429 scsi_dma_unmap(psb->pCmd);
3430 if (psb->prot_seg_cnt > 0)
3431 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(psb->pCmd),
3432 scsi_prot_sg_count(psb->pCmd),
3433 psb->pCmd->sc_data_direction);
3437 * lpfc_handler_fcp_err - FCP response handler
3438 * @vport: The virtual port for which this call is being executed.
3439 * @lpfc_cmd: Pointer to lpfc_io_buf data structure.
3440 * @rsp_iocb: The response IOCB which contains FCP error.
3442 * This routine is called to process response IOCB with status field
3443 * IOSTAT_FCP_RSP_ERROR. This routine sets result field of scsi command
3444 * based upon SCSI and FCP error.
3447 lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_io_buf *lpfc_cmd,
3448 struct lpfc_iocbq *rsp_iocb)
3450 struct lpfc_hba *phba = vport->phba;
3451 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3452 struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
3453 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3454 uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
3455 uint32_t resp_info = fcprsp->rspStatus2;
3456 uint32_t scsi_status = fcprsp->rspStatus3;
3458 uint32_t host_status = DID_OK;
3459 uint32_t rsplen = 0;
3461 uint32_t logit = LOG_FCP | LOG_FCP_ERROR;
3465 * If this is a task management command, there is no
3466 * scsi packet associated with this lpfc_cmd. The driver
3469 if (fcpcmd->fcpCntl2) {
3474 if (resp_info & RSP_LEN_VALID) {
3475 rsplen = be32_to_cpu(fcprsp->rspRspLen);
3476 if (rsplen != 0 && rsplen != 4 && rsplen != 8) {
3477 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
3478 "2719 Invalid response length: "
3479 "tgt x%x lun x%llx cmnd x%x rsplen x%x\n",
3481 cmnd->device->lun, cmnd->cmnd[0],
3483 host_status = DID_ERROR;
3486 if (fcprsp->rspInfo3 != RSP_NO_FAILURE) {
3487 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
3488 "2757 Protocol failure detected during "
3489 "processing of FCP I/O op: "
3490 "tgt x%x lun x%llx cmnd x%x rspInfo3 x%x\n",
3492 cmnd->device->lun, cmnd->cmnd[0],
3494 host_status = DID_ERROR;
3499 if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) {
3500 uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen);
3501 if (snslen > SCSI_SENSE_BUFFERSIZE)
3502 snslen = SCSI_SENSE_BUFFERSIZE;
3504 if (resp_info & RSP_LEN_VALID)
3505 rsplen = be32_to_cpu(fcprsp->rspRspLen);
3506 memcpy(cmnd->sense_buffer, &fcprsp->rspInfo0 + rsplen, snslen);
3508 lp = (uint32_t *)cmnd->sense_buffer;
3510 /* special handling for under run conditions */
3511 if (!scsi_status && (resp_info & RESID_UNDER)) {
3512 /* don't log under runs if fcp set... */
3513 if (vport->cfg_log_verbose & LOG_FCP)
3514 logit = LOG_FCP_ERROR;
3515 /* unless operator says so */
3516 if (vport->cfg_log_verbose & LOG_FCP_UNDER)
3517 logit = LOG_FCP_UNDER;
3520 lpfc_printf_vlog(vport, KERN_WARNING, logit,
3521 "9024 FCP command x%x failed: x%x SNS x%x x%x "
3522 "Data: x%x x%x x%x x%x x%x\n",
3523 cmnd->cmnd[0], scsi_status,
3524 be32_to_cpu(*lp), be32_to_cpu(*(lp + 3)), resp_info,
3525 be32_to_cpu(fcprsp->rspResId),
3526 be32_to_cpu(fcprsp->rspSnsLen),
3527 be32_to_cpu(fcprsp->rspRspLen),
3530 scsi_set_resid(cmnd, 0);
3531 fcpDl = be32_to_cpu(fcpcmd->fcpDl);
3532 if (resp_info & RESID_UNDER) {
3533 scsi_set_resid(cmnd, be32_to_cpu(fcprsp->rspResId));
3535 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP_UNDER,
3536 "9025 FCP Underrun, expected %d, "
3537 "residual %d Data: x%x x%x x%x\n",
3539 scsi_get_resid(cmnd), fcpi_parm, cmnd->cmnd[0],
3543 * If there is an under run, check if under run reported by
3544 * storage array is same as the under run reported by HBA.
3545 * If this is not same, there is a dropped frame.
3547 if (fcpi_parm && (scsi_get_resid(cmnd) != fcpi_parm)) {
3548 lpfc_printf_vlog(vport, KERN_WARNING,
3549 LOG_FCP | LOG_FCP_ERROR,
3550 "9026 FCP Read Check Error "
3551 "and Underrun Data: x%x x%x x%x x%x\n",
3553 scsi_get_resid(cmnd), fcpi_parm,
3555 scsi_set_resid(cmnd, scsi_bufflen(cmnd));
3556 host_status = DID_ERROR;
3559 * The cmnd->underflow is the minimum number of bytes that must
3560 * be transferred for this command. Provided a sense condition
3561 * is not present, make sure the actual amount transferred is at
3562 * least the underflow value or fail.
3564 if (!(resp_info & SNS_LEN_VALID) &&
3565 (scsi_status == SAM_STAT_GOOD) &&
3566 (scsi_bufflen(cmnd) - scsi_get_resid(cmnd)
3567 < cmnd->underflow)) {
3568 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
3569 "9027 FCP command x%x residual "
3570 "underrun converted to error "
3571 "Data: x%x x%x x%x\n",
3572 cmnd->cmnd[0], scsi_bufflen(cmnd),
3573 scsi_get_resid(cmnd), cmnd->underflow);
3574 host_status = DID_ERROR;
3576 } else if (resp_info & RESID_OVER) {
3577 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
3578 "9028 FCP command x%x residual overrun error. "
3579 "Data: x%x x%x\n", cmnd->cmnd[0],
3580 scsi_bufflen(cmnd), scsi_get_resid(cmnd));
3581 host_status = DID_ERROR;
3584 * Check SLI validation that all the transfer was actually done
3585 * (fcpi_parm should be zero). Apply check only to reads.
3587 } else if (fcpi_parm) {
3588 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP | LOG_FCP_ERROR,
3589 "9029 FCP %s Check Error xri x%x Data: "
3590 "x%x x%x x%x x%x x%x\n",
3591 ((cmnd->sc_data_direction == DMA_FROM_DEVICE) ?
3593 ((phba->sli_rev == LPFC_SLI_REV4) ?
3594 lpfc_cmd->cur_iocbq.sli4_xritag :
3595 rsp_iocb->iocb.ulpContext),
3596 fcpDl, be32_to_cpu(fcprsp->rspResId),
3597 fcpi_parm, cmnd->cmnd[0], scsi_status);
3599 /* There is some issue with the LPe12000 that causes it
3600 * to miscalculate the fcpi_parm and falsely trip this
3601 * recovery logic. Detect this case and don't error when true.
3603 if (fcpi_parm > fcpDl)
3606 switch (scsi_status) {
3608 case SAM_STAT_CHECK_CONDITION:
3609 /* Fabric dropped a data frame. Fail any successful
3610 * command in which we detected dropped frames.
3611 * A status of good or some check conditions could
3612 * be considered a successful command.
3614 host_status = DID_ERROR;
3617 scsi_set_resid(cmnd, scsi_bufflen(cmnd));
3621 cmnd->result = host_status << 16 | scsi_status;
3622 lpfc_send_scsi_error_event(vport->phba, vport, lpfc_cmd, rsp_iocb);
3626 * lpfc_scsi_cmd_iocb_cmpl - Scsi cmnd IOCB completion routine
3627 * @phba: The Hba for which this call is being executed.
3628 * @pIocbIn: The command IOCBQ for the scsi cmnd.
3629 * @pIocbOut: The response IOCBQ for the scsi cmnd.
3631 * This routine assigns scsi command result by looking into response IOCB
3632 * status field appropriately. This routine handles QUEUE FULL condition as
3633 * well by ramping down device queue depth.
3636 lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
3637 struct lpfc_iocbq *pIocbOut)
3639 struct lpfc_io_buf *lpfc_cmd =
3640 (struct lpfc_io_buf *) pIocbIn->context1;
3641 struct lpfc_vport *vport = pIocbIn->vport;
3642 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
3643 struct lpfc_nodelist *pnode = rdata->pnode;
3644 struct scsi_cmnd *cmd;
3645 unsigned long flags;
3646 struct lpfc_fast_path_event *fast_path_evt;
3647 struct Scsi_Host *shost;
3649 uint32_t logit = LOG_FCP;
3650 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
3654 /* Guard against abort handler being called at same time */
3655 spin_lock(&lpfc_cmd->buf_lock);
3657 /* Sanity check on return of outstanding command */
3658 cmd = lpfc_cmd->pCmd;
3660 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3661 "2621 IO completion: Not an active IO\n");
3662 spin_unlock(&lpfc_cmd->buf_lock);
3666 idx = lpfc_cmd->cur_iocbq.hba_wqidx;
3667 if (phba->sli4_hba.hdwq)
3668 phba->sli4_hba.hdwq[idx].scsi_cstat.io_cmpls++;
3670 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
3671 if (phba->cpucheck_on & LPFC_CHECK_SCSI_IO) {
3672 cpu = smp_processor_id();
3673 if (cpu < LPFC_CHECK_CPU_CNT)
3674 phba->sli4_hba.hdwq[idx].cpucheck_cmpl_io[cpu]++;
3677 shost = cmd->device->host;
3679 lpfc_cmd->result = (pIocbOut->iocb.un.ulpWord[4] & IOERR_PARAM_MASK);
3680 lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
3681 /* pick up SLI4 exhange busy status from HBA */
3682 lpfc_cmd->exch_busy = pIocbOut->iocb_flag & LPFC_EXCHANGE_BUSY;
3684 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
3685 if (lpfc_cmd->prot_data_type) {
3686 struct scsi_dif_tuple *src = NULL;
3688 src = (struct scsi_dif_tuple *)lpfc_cmd->prot_data_segment;
3690 * Used to restore any changes to protection
3691 * data for error injection.
3693 switch (lpfc_cmd->prot_data_type) {
3694 case LPFC_INJERR_REFTAG:
3696 lpfc_cmd->prot_data;
3698 case LPFC_INJERR_APPTAG:
3700 (uint16_t)lpfc_cmd->prot_data;
3702 case LPFC_INJERR_GUARD:
3704 (uint16_t)lpfc_cmd->prot_data;
3710 lpfc_cmd->prot_data = 0;
3711 lpfc_cmd->prot_data_type = 0;
3712 lpfc_cmd->prot_data_segment = NULL;
3716 if (lpfc_cmd->status) {
3717 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
3718 (lpfc_cmd->result & IOERR_DRVR_MASK))
3719 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
3720 else if (lpfc_cmd->status >= IOSTAT_CNT)
3721 lpfc_cmd->status = IOSTAT_DEFAULT;
3722 if (lpfc_cmd->status == IOSTAT_FCP_RSP_ERROR &&
3723 !lpfc_cmd->fcp_rsp->rspStatus3 &&
3724 (lpfc_cmd->fcp_rsp->rspStatus2 & RESID_UNDER) &&
3725 !(vport->cfg_log_verbose & LOG_FCP_UNDER))
3728 logit = LOG_FCP | LOG_FCP_UNDER;
3729 lpfc_printf_vlog(vport, KERN_WARNING, logit,
3730 "9030 FCP cmd x%x failed <%d/%lld> "
3731 "status: x%x result: x%x "
3732 "sid: x%x did: x%x oxid: x%x "
3735 cmd->device ? cmd->device->id : 0xffff,
3736 cmd->device ? cmd->device->lun : 0xffff,
3737 lpfc_cmd->status, lpfc_cmd->result,
3739 (pnode) ? pnode->nlp_DID : 0,
3740 phba->sli_rev == LPFC_SLI_REV4 ?
3741 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
3742 pIocbOut->iocb.ulpContext,
3743 lpfc_cmd->cur_iocbq.iocb.ulpIoTag);
3745 switch (lpfc_cmd->status) {
3746 case IOSTAT_FCP_RSP_ERROR:
3747 /* Call FCP RSP handler to determine result */
3748 lpfc_handle_fcp_err(vport, lpfc_cmd, pIocbOut);
3750 case IOSTAT_NPORT_BSY:
3751 case IOSTAT_FABRIC_BSY:
3752 cmd->result = DID_TRANSPORT_DISRUPTED << 16;
3753 fast_path_evt = lpfc_alloc_fast_evt(phba);
3756 fast_path_evt->un.fabric_evt.event_type =
3757 FC_REG_FABRIC_EVENT;
3758 fast_path_evt->un.fabric_evt.subcategory =
3759 (lpfc_cmd->status == IOSTAT_NPORT_BSY) ?
3760 LPFC_EVENT_PORT_BUSY : LPFC_EVENT_FABRIC_BUSY;
3761 if (pnode && NLP_CHK_NODE_ACT(pnode)) {
3762 memcpy(&fast_path_evt->un.fabric_evt.wwpn,
3763 &pnode->nlp_portname,
3764 sizeof(struct lpfc_name));
3765 memcpy(&fast_path_evt->un.fabric_evt.wwnn,
3766 &pnode->nlp_nodename,
3767 sizeof(struct lpfc_name));
3769 fast_path_evt->vport = vport;
3770 fast_path_evt->work_evt.evt =
3771 LPFC_EVT_FASTPATH_MGMT_EVT;
3772 spin_lock_irqsave(&phba->hbalock, flags);
3773 list_add_tail(&fast_path_evt->work_evt.evt_listp,
3775 spin_unlock_irqrestore(&phba->hbalock, flags);
3776 lpfc_worker_wake_up(phba);
3778 case IOSTAT_LOCAL_REJECT:
3779 case IOSTAT_REMOTE_STOP:
3780 if (lpfc_cmd->result == IOERR_ELXSEC_KEY_UNWRAP_ERROR ||
3782 IOERR_ELXSEC_KEY_UNWRAP_COMPARE_ERROR ||
3783 lpfc_cmd->result == IOERR_ELXSEC_CRYPTO_ERROR ||
3785 IOERR_ELXSEC_CRYPTO_COMPARE_ERROR) {
3786 cmd->result = DID_NO_CONNECT << 16;
3789 if (lpfc_cmd->result == IOERR_INVALID_RPI ||
3790 lpfc_cmd->result == IOERR_NO_RESOURCES ||
3791 lpfc_cmd->result == IOERR_ABORT_REQUESTED ||
3792 lpfc_cmd->result == IOERR_SLER_CMD_RCV_FAILURE) {
3793 cmd->result = DID_REQUEUE << 16;
3796 if ((lpfc_cmd->result == IOERR_RX_DMA_FAILED ||
3797 lpfc_cmd->result == IOERR_TX_DMA_FAILED) &&
3798 pIocbOut->iocb.unsli3.sli3_bg.bgstat) {
3799 if (scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
3801 * This is a response for a BG enabled
3802 * cmd. Parse BG error
3804 lpfc_parse_bg_err(phba, lpfc_cmd,
3808 lpfc_printf_vlog(vport, KERN_WARNING,
3810 "9031 non-zero BGSTAT "
3811 "on unprotected cmd\n");
3814 if ((lpfc_cmd->status == IOSTAT_REMOTE_STOP)
3815 && (phba->sli_rev == LPFC_SLI_REV4)
3816 && (pnode && NLP_CHK_NODE_ACT(pnode))) {
3817 /* This IO was aborted by the target, we don't
3818 * know the rxid and because we did not send the
3819 * ABTS we cannot generate and RRQ.
3821 lpfc_set_rrq_active(phba, pnode,
3822 lpfc_cmd->cur_iocbq.sli4_lxritag,
3825 /* else: fall through */
3827 cmd->result = DID_ERROR << 16;
3831 if (!pnode || !NLP_CHK_NODE_ACT(pnode)
3832 || (pnode->nlp_state != NLP_STE_MAPPED_NODE))
3833 cmd->result = DID_TRANSPORT_DISRUPTED << 16 |
3836 cmd->result = DID_OK << 16;
3838 if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) {
3839 uint32_t *lp = (uint32_t *)cmd->sense_buffer;
3841 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
3842 "0710 Iodone <%d/%llu> cmd %p, error "
3843 "x%x SNS x%x x%x Data: x%x x%x\n",
3844 cmd->device->id, cmd->device->lun, cmd,
3845 cmd->result, *lp, *(lp + 3), cmd->retries,
3846 scsi_get_resid(cmd));
3849 lpfc_update_stats(phba, lpfc_cmd);
3850 if (vport->cfg_max_scsicmpl_time &&
3851 time_after(jiffies, lpfc_cmd->start_time +
3852 msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) {
3853 spin_lock_irqsave(shost->host_lock, flags);
3854 if (pnode && NLP_CHK_NODE_ACT(pnode)) {
3855 if (pnode->cmd_qdepth >
3856 atomic_read(&pnode->cmd_pending) &&
3857 (atomic_read(&pnode->cmd_pending) >
3858 LPFC_MIN_TGT_QDEPTH) &&
3859 ((cmd->cmnd[0] == READ_10) ||
3860 (cmd->cmnd[0] == WRITE_10)))
3862 atomic_read(&pnode->cmd_pending);
3864 pnode->last_change_time = jiffies;
3866 spin_unlock_irqrestore(shost->host_lock, flags);
3868 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
3870 lpfc_cmd->pCmd = NULL;
3871 spin_unlock(&lpfc_cmd->buf_lock);
3873 /* The sdev is not guaranteed to be valid post scsi_done upcall. */
3874 cmd->scsi_done(cmd);
3877 * If there is an abort thread waiting for command completion
3878 * wake up the thread.
3880 spin_lock(&lpfc_cmd->buf_lock);
3881 lpfc_cmd->cur_iocbq.iocb_flag &= ~LPFC_DRIVER_ABORTED;
3882 if (lpfc_cmd->waitq) {
3883 wake_up(lpfc_cmd->waitq);
3884 lpfc_cmd->waitq = NULL;
3886 spin_unlock(&lpfc_cmd->buf_lock);
3888 lpfc_release_scsi_buf(phba, lpfc_cmd);
3892 * lpfc_fcpcmd_to_iocb - copy the fcp_cmd data into the IOCB
3893 * @data: A pointer to the immediate command data portion of the IOCB.
3894 * @fcp_cmnd: The FCP Command that is provided by the SCSI layer.
3896 * The routine copies the entire FCP command from @fcp_cmnd to @data while
3897 * byte swapping the data to big endian format for transmission on the wire.
3900 lpfc_fcpcmd_to_iocb(uint8_t *data, struct fcp_cmnd *fcp_cmnd)
3903 for (i = 0, j = 0; i < sizeof(struct fcp_cmnd);
3904 i += sizeof(uint32_t), j++) {
3905 ((uint32_t *)data)[j] = cpu_to_be32(((uint32_t *)fcp_cmnd)[j]);
3910 * lpfc_scsi_prep_cmnd - Wrapper func for convert scsi cmnd to FCP info unit
3911 * @vport: The virtual port for which this call is being executed.
3912 * @lpfc_cmd: The scsi command which needs to send.
3913 * @pnode: Pointer to lpfc_nodelist.
3915 * This routine initializes fcp_cmnd and iocb data structure from scsi command
3916 * to transfer for device with SLI3 interface spec.
3919 lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_io_buf *lpfc_cmd,
3920 struct lpfc_nodelist *pnode)
3922 struct lpfc_hba *phba = vport->phba;
3923 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3924 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3925 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3926 struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
3927 struct lpfc_sli4_hdw_queue *hdwq = NULL;
3928 int datadir = scsi_cmnd->sc_data_direction;
3934 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
3937 lpfc_cmd->fcp_rsp->rspSnsLen = 0;
3938 /* clear task management bits */
3939 lpfc_cmd->fcp_cmnd->fcpCntl2 = 0;
3941 int_to_scsilun(lpfc_cmd->pCmd->device->lun,
3942 &lpfc_cmd->fcp_cmnd->fcp_lun);
3944 ptr = &fcp_cmnd->fcpCdb[0];
3945 memcpy(ptr, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
3946 if (scsi_cmnd->cmd_len < LPFC_FCP_CDB_LEN) {
3947 ptr += scsi_cmnd->cmd_len;
3948 memset(ptr, 0, (LPFC_FCP_CDB_LEN - scsi_cmnd->cmd_len));
3951 fcp_cmnd->fcpCntl1 = SIMPLE_Q;
3953 sli4 = (phba->sli_rev == LPFC_SLI_REV4);
3954 piocbq->iocb.un.fcpi.fcpi_XRdy = 0;
3955 idx = lpfc_cmd->hdwq_no;
3956 if (phba->sli4_hba.hdwq)
3957 hdwq = &phba->sli4_hba.hdwq[idx];
3960 * There are three possibilities here - use scatter-gather segment, use
3961 * the single mapping, or neither. Start the lpfc command prep by
3962 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
3965 if (scsi_sg_count(scsi_cmnd)) {
3966 if (datadir == DMA_TO_DEVICE) {
3967 iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
3968 iocb_cmd->ulpPU = PARM_READ_CHECK;
3969 if (vport->cfg_first_burst_size &&
3970 (pnode->nlp_flag & NLP_FIRSTBURST)) {
3971 fcpdl = scsi_bufflen(scsi_cmnd);
3972 if (fcpdl < vport->cfg_first_burst_size)
3973 piocbq->iocb.un.fcpi.fcpi_XRdy = fcpdl;
3975 piocbq->iocb.un.fcpi.fcpi_XRdy =
3976 vport->cfg_first_burst_size;
3978 fcp_cmnd->fcpCntl3 = WRITE_DATA;
3980 hdwq->scsi_cstat.output_requests++;
3982 iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR;
3983 iocb_cmd->ulpPU = PARM_READ_CHECK;
3984 fcp_cmnd->fcpCntl3 = READ_DATA;
3986 hdwq->scsi_cstat.input_requests++;
3989 iocb_cmd->ulpCommand = CMD_FCP_ICMND64_CR;
3990 iocb_cmd->un.fcpi.fcpi_parm = 0;
3991 iocb_cmd->ulpPU = 0;
3992 fcp_cmnd->fcpCntl3 = 0;
3994 hdwq->scsi_cstat.control_requests++;
3996 if (phba->sli_rev == 3 &&
3997 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED))
3998 lpfc_fcpcmd_to_iocb(iocb_cmd->unsli3.fcp_ext.icd, fcp_cmnd);
4000 * Finish initializing those IOCB fields that are independent
4001 * of the scsi_cmnd request_buffer
4003 piocbq->iocb.ulpContext = pnode->nlp_rpi;
4005 piocbq->iocb.ulpContext =
4006 phba->sli4_hba.rpi_ids[pnode->nlp_rpi];
4007 if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE)
4008 piocbq->iocb.ulpFCP2Rcvy = 1;
4010 piocbq->iocb.ulpFCP2Rcvy = 0;
4012 piocbq->iocb.ulpClass = (pnode->nlp_fcp_info & 0x0f);
4013 piocbq->context1 = lpfc_cmd;
4014 piocbq->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
4015 piocbq->iocb.ulpTimeout = lpfc_cmd->timeout;
4016 piocbq->vport = vport;
4020 * lpfc_scsi_prep_task_mgmt_cmd - Convert SLI3 scsi TM cmd to FCP info unit
4021 * @vport: The virtual port for which this call is being executed.
4022 * @lpfc_cmd: Pointer to lpfc_io_buf data structure.
4023 * @lun: Logical unit number.
4024 * @task_mgmt_cmd: SCSI task management command.
4026 * This routine creates FCP information unit corresponding to @task_mgmt_cmd
4027 * for device with SLI-3 interface spec.
4034 lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
4035 struct lpfc_io_buf *lpfc_cmd,
4037 uint8_t task_mgmt_cmd)
4039 struct lpfc_iocbq *piocbq;
4041 struct fcp_cmnd *fcp_cmnd;
4042 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
4043 struct lpfc_nodelist *ndlp = rdata->pnode;
4045 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) ||
4046 ndlp->nlp_state != NLP_STE_MAPPED_NODE)
4049 piocbq = &(lpfc_cmd->cur_iocbq);
4050 piocbq->vport = vport;
4052 piocb = &piocbq->iocb;
4054 fcp_cmnd = lpfc_cmd->fcp_cmnd;
4055 /* Clear out any old data in the FCP command area */
4056 memset(fcp_cmnd, 0, sizeof(struct fcp_cmnd));
4057 int_to_scsilun(lun, &fcp_cmnd->fcp_lun);
4058 fcp_cmnd->fcpCntl2 = task_mgmt_cmd;
4059 if (vport->phba->sli_rev == 3 &&
4060 !(vport->phba->sli3_options & LPFC_SLI3_BG_ENABLED))
4061 lpfc_fcpcmd_to_iocb(piocb->unsli3.fcp_ext.icd, fcp_cmnd);
4062 piocb->ulpCommand = CMD_FCP_ICMND64_CR;
4063 piocb->ulpContext = ndlp->nlp_rpi;
4064 if (vport->phba->sli_rev == LPFC_SLI_REV4) {
4066 vport->phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
4068 piocb->ulpFCP2Rcvy = (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) ? 1 : 0;
4069 piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f);
4071 piocb->un.fcpi.fcpi_parm = 0;
4073 /* ulpTimeout is only one byte */
4074 if (lpfc_cmd->timeout > 0xff) {
4076 * Do not timeout the command at the firmware level.
4077 * The driver will provide the timeout mechanism.
4079 piocb->ulpTimeout = 0;
4081 piocb->ulpTimeout = lpfc_cmd->timeout;
4083 if (vport->phba->sli_rev == LPFC_SLI_REV4)
4084 lpfc_sli4_set_rsp_sgl_last(vport->phba, lpfc_cmd);
4090 * lpfc_scsi_api_table_setup - Set up scsi api function jump table
4091 * @phba: The hba struct for which this call is being executed.
4092 * @dev_grp: The HBA PCI-Device group number.
4094 * This routine sets up the SCSI interface API function jump table in @phba
4096 * Returns: 0 - success, -ENODEV - failure.
4099 lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
4102 phba->lpfc_scsi_unprep_dma_buf = lpfc_scsi_unprep_dma_buf;
4103 phba->lpfc_scsi_prep_cmnd = lpfc_scsi_prep_cmnd;
4106 case LPFC_PCI_DEV_LP:
4107 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s3;
4108 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s3;
4109 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s3;
4110 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s3;
4112 case LPFC_PCI_DEV_OC:
4113 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s4;
4114 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s4;
4115 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s4;
4116 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s4;
4119 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4120 "1418 Invalid HBA PCI-device group: 0x%x\n",
4125 phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth;
4126 phba->lpfc_scsi_cmd_iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
4131 * lpfc_taskmgmt_def_cmpl - IOCB completion routine for task management command
4132 * @phba: The Hba for which this call is being executed.
4133 * @cmdiocbq: Pointer to lpfc_iocbq data structure.
4134 * @rspiocbq: Pointer to lpfc_iocbq data structure.
4136 * This routine is IOCB completion routine for device reset and target reset
4137 * routine. This routine release scsi buffer associated with lpfc_cmd.
4140 lpfc_tskmgmt_def_cmpl(struct lpfc_hba *phba,
4141 struct lpfc_iocbq *cmdiocbq,
4142 struct lpfc_iocbq *rspiocbq)
4144 struct lpfc_io_buf *lpfc_cmd =
4145 (struct lpfc_io_buf *) cmdiocbq->context1;
4147 lpfc_release_scsi_buf(phba, lpfc_cmd);
4152 * lpfc_check_pci_resettable - Walks list of devices on pci_dev's bus to check
4153 * if issuing a pci_bus_reset is possibly unsafe
4154 * @phba: lpfc_hba pointer.
4157 * Walks the bus_list to ensure only PCI devices with Emulex
4158 * vendor id, device ids that support hot reset, and only one occurrence
4162 * -EBADSLT, detected invalid device
4166 lpfc_check_pci_resettable(const struct lpfc_hba *phba)
4168 const struct pci_dev *pdev = phba->pcidev;
4169 struct pci_dev *ptr = NULL;
4172 /* Walk the list of devices on the pci_dev's bus */
4173 list_for_each_entry(ptr, &pdev->bus->devices, bus_list) {
4174 /* Check for Emulex Vendor ID */
4175 if (ptr->vendor != PCI_VENDOR_ID_EMULEX) {
4176 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4177 "8346 Non-Emulex vendor found: "
4178 "0x%04x\n", ptr->vendor);
4182 /* Check for valid Emulex Device ID */
4183 switch (ptr->device) {
4184 case PCI_DEVICE_ID_LANCER_FC:
4185 case PCI_DEVICE_ID_LANCER_G6_FC:
4186 case PCI_DEVICE_ID_LANCER_G7_FC:
4189 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4190 "8347 Invalid device found: "
4191 "0x%04x\n", ptr->device);
4195 /* Check for only one function 0 ID to ensure only one HBA on
4198 if (ptr->devfn == 0) {
4199 if (++counter > 1) {
4200 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4201 "8348 More than one device on "
4202 "secondary bus found\n");
4212 * lpfc_info - Info entry point of scsi_host_template data structure
4213 * @host: The scsi host for which this call is being executed.
4215 * This routine provides module information about hba.
4218 * Pointer to char - Success.
4221 lpfc_info(struct Scsi_Host *host)
4223 struct lpfc_vport *vport = (struct lpfc_vport *) host->hostdata;
4224 struct lpfc_hba *phba = vport->phba;
4226 static char lpfcinfobuf[384];
4227 char tmp[384] = {0};
4229 memset(lpfcinfobuf, 0, sizeof(lpfcinfobuf));
4230 if (phba && phba->pcidev){
4231 /* Model Description */
4232 scnprintf(tmp, sizeof(tmp), phba->ModelDesc);
4233 if (strlcat(lpfcinfobuf, tmp, sizeof(lpfcinfobuf)) >=
4234 sizeof(lpfcinfobuf))
4238 scnprintf(tmp, sizeof(tmp),
4239 " on PCI bus %02x device %02x irq %d",
4240 phba->pcidev->bus->number, phba->pcidev->devfn,
4242 if (strlcat(lpfcinfobuf, tmp, sizeof(lpfcinfobuf)) >=
4243 sizeof(lpfcinfobuf))
4247 if (phba->Port[0]) {
4248 scnprintf(tmp, sizeof(tmp), " port %s", phba->Port);
4249 if (strlcat(lpfcinfobuf, tmp, sizeof(lpfcinfobuf)) >=
4250 sizeof(lpfcinfobuf))
4255 link_speed = lpfc_sli_port_speed_get(phba);
4256 if (link_speed != 0) {
4257 scnprintf(tmp, sizeof(tmp),
4258 " Logical Link Speed: %d Mbps", link_speed);
4259 if (strlcat(lpfcinfobuf, tmp, sizeof(lpfcinfobuf)) >=
4260 sizeof(lpfcinfobuf))
4264 /* PCI resettable */
4265 if (!lpfc_check_pci_resettable(phba)) {
4266 scnprintf(tmp, sizeof(tmp), " PCI resettable");
4267 strlcat(lpfcinfobuf, tmp, sizeof(lpfcinfobuf));
4276 * lpfc_poll_rearm_time - Routine to modify fcp_poll timer of hba
4277 * @phba: The Hba for which this call is being executed.
4279 * This routine modifies fcp_poll_timer field of @phba by cfg_poll_tmo.
4280 * The default value of cfg_poll_tmo is 10 milliseconds.
4282 static __inline__ void lpfc_poll_rearm_timer(struct lpfc_hba * phba)
4284 unsigned long poll_tmo_expires =
4285 (jiffies + msecs_to_jiffies(phba->cfg_poll_tmo));
4287 if (!list_empty(&phba->sli.sli3_ring[LPFC_FCP_RING].txcmplq))
4288 mod_timer(&phba->fcp_poll_timer,
4293 * lpfc_poll_start_timer - Routine to start fcp_poll_timer of HBA
4294 * @phba: The Hba for which this call is being executed.
4296 * This routine starts the fcp_poll_timer of @phba.
4298 void lpfc_poll_start_timer(struct lpfc_hba * phba)
4300 lpfc_poll_rearm_timer(phba);
4304 * lpfc_poll_timeout - Restart polling timer
4305 * @ptr: Map to lpfc_hba data structure pointer.
4307 * This routine restarts fcp_poll timer, when FCP ring polling is enable
4308 * and FCP Ring interrupt is disable.
4311 void lpfc_poll_timeout(struct timer_list *t)
4313 struct lpfc_hba *phba = from_timer(phba, t, fcp_poll_timer);
4315 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
4316 lpfc_sli_handle_fast_ring_event(phba,
4317 &phba->sli.sli3_ring[LPFC_FCP_RING], HA_R0RE_REQ);
4319 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4320 lpfc_poll_rearm_timer(phba);
4325 * lpfc_queuecommand - scsi_host_template queuecommand entry point
4326 * @cmnd: Pointer to scsi_cmnd data structure.
4327 * @done: Pointer to done routine.
4329 * Driver registers this routine to scsi midlayer to submit a @cmd to process.
4330 * This routine prepares an IOCB from scsi command and provides to firmware.
4331 * The @done callback is invoked after driver finished processing the command.
4335 * SCSI_MLQUEUE_HOST_BUSY - Block all devices served by this host temporarily.
4338 lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
4340 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4341 struct lpfc_hba *phba = vport->phba;
4342 struct lpfc_rport_data *rdata;
4343 struct lpfc_nodelist *ndlp;
4344 struct lpfc_io_buf *lpfc_cmd;
4345 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
4347 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
4351 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
4353 /* sanity check on references */
4354 if (unlikely(!rdata) || unlikely(!rport))
4355 goto out_fail_command;
4357 err = fc_remote_port_chkready(rport);
4360 goto out_fail_command;
4362 ndlp = rdata->pnode;
4364 if ((scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) &&
4365 (!(phba->sli3_options & LPFC_SLI3_BG_ENABLED))) {
4367 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4368 "9058 BLKGRD: ERROR: rcvd protected cmd:%02x"
4369 " op:%02x str=%s without registering for"
4370 " BlockGuard - Rejecting command\n",
4371 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
4372 dif_op_str[scsi_get_prot_op(cmnd)]);
4373 goto out_fail_command;
4377 * Catch race where our node has transitioned, but the
4378 * transport is still transitioning.
4380 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
4382 if (lpfc_ndlp_check_qdepth(phba, ndlp)) {
4383 if (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth) {
4384 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP_ERROR,
4385 "3377 Target Queue Full, scsi Id:%d "
4386 "Qdepth:%d Pending command:%d"
4387 " WWNN:%02x:%02x:%02x:%02x:"
4388 "%02x:%02x:%02x:%02x, "
4389 " WWPN:%02x:%02x:%02x:%02x:"
4390 "%02x:%02x:%02x:%02x",
4391 ndlp->nlp_sid, ndlp->cmd_qdepth,
4392 atomic_read(&ndlp->cmd_pending),
4393 ndlp->nlp_nodename.u.wwn[0],
4394 ndlp->nlp_nodename.u.wwn[1],
4395 ndlp->nlp_nodename.u.wwn[2],
4396 ndlp->nlp_nodename.u.wwn[3],
4397 ndlp->nlp_nodename.u.wwn[4],
4398 ndlp->nlp_nodename.u.wwn[5],
4399 ndlp->nlp_nodename.u.wwn[6],
4400 ndlp->nlp_nodename.u.wwn[7],
4401 ndlp->nlp_portname.u.wwn[0],
4402 ndlp->nlp_portname.u.wwn[1],
4403 ndlp->nlp_portname.u.wwn[2],
4404 ndlp->nlp_portname.u.wwn[3],
4405 ndlp->nlp_portname.u.wwn[4],
4406 ndlp->nlp_portname.u.wwn[5],
4407 ndlp->nlp_portname.u.wwn[6],
4408 ndlp->nlp_portname.u.wwn[7]);
4413 lpfc_cmd = lpfc_get_scsi_buf(phba, ndlp, cmnd);
4414 if (lpfc_cmd == NULL) {
4415 lpfc_rampdown_queue_depth(phba);
4417 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP_ERROR,
4418 "0707 driver's buffer pool is empty, "
4424 * Store the midlayer's command structure for the completion phase
4425 * and complete the command initialization.
4427 lpfc_cmd->pCmd = cmnd;
4428 lpfc_cmd->rdata = rdata;
4429 lpfc_cmd->ndlp = ndlp;
4430 cmnd->host_scribble = (unsigned char *)lpfc_cmd;
4432 if (scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
4433 if (vport->phba->cfg_enable_bg) {
4434 lpfc_printf_vlog(vport,
4435 KERN_INFO, LOG_SCSI_CMD,
4436 "9033 BLKGRD: rcvd %s cmd:x%x "
4437 "sector x%llx cnt %u pt %x\n",
4438 dif_op_str[scsi_get_prot_op(cmnd)],
4440 (unsigned long long)scsi_get_lba(cmnd),
4441 blk_rq_sectors(cmnd->request),
4442 (cmnd->cmnd[1]>>5));
4444 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
4446 if (vport->phba->cfg_enable_bg) {
4447 lpfc_printf_vlog(vport,
4448 KERN_INFO, LOG_SCSI_CMD,
4449 "9038 BLKGRD: rcvd PROT_NORMAL cmd: "
4450 "x%x sector x%llx cnt %u pt %x\n",
4452 (unsigned long long)scsi_get_lba(cmnd),
4453 blk_rq_sectors(cmnd->request),
4454 (cmnd->cmnd[1]>>5));
4456 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
4460 goto out_host_busy_free_buf;
4462 lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp);
4464 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
4465 if (phba->cpucheck_on & LPFC_CHECK_SCSI_IO) {
4466 cpu = smp_processor_id();
4467 if (cpu < LPFC_CHECK_CPU_CNT) {
4468 struct lpfc_sli4_hdw_queue *hdwq =
4469 &phba->sli4_hba.hdwq[lpfc_cmd->hdwq_no];
4470 hdwq->cpucheck_xmt_io[cpu]++;
4474 err = lpfc_sli_issue_iocb(phba, LPFC_FCP_RING,
4475 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
4477 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4478 "3376 FCP could not issue IOCB err %x"
4479 "FCP cmd x%x <%d/%llu> "
4480 "sid: x%x did: x%x oxid: x%x "
4481 "Data: x%x x%x x%x x%x\n",
4483 cmnd->device ? cmnd->device->id : 0xffff,
4484 cmnd->device ? cmnd->device->lun : (u64) -1,
4485 vport->fc_myDID, ndlp->nlp_DID,
4486 phba->sli_rev == LPFC_SLI_REV4 ?
4487 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
4488 lpfc_cmd->cur_iocbq.iocb.ulpContext,
4489 lpfc_cmd->cur_iocbq.iocb.ulpIoTag,
4490 lpfc_cmd->cur_iocbq.iocb.ulpTimeout,
4492 (cmnd->request->timeout / 1000));
4494 goto out_host_busy_free_buf;
4496 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
4497 lpfc_sli_handle_fast_ring_event(phba,
4498 &phba->sli.sli3_ring[LPFC_FCP_RING], HA_R0RE_REQ);
4500 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4501 lpfc_poll_rearm_timer(phba);
4504 if (phba->cfg_xri_rebalancing)
4505 lpfc_keep_pvt_pool_above_lowwm(phba, lpfc_cmd->hdwq_no);
4509 out_host_busy_free_buf:
4510 idx = lpfc_cmd->hdwq_no;
4511 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
4512 if (phba->sli4_hba.hdwq) {
4513 switch (lpfc_cmd->fcp_cmnd->fcpCntl3) {
4515 phba->sli4_hba.hdwq[idx].scsi_cstat.output_requests--;
4518 phba->sli4_hba.hdwq[idx].scsi_cstat.input_requests--;
4521 phba->sli4_hba.hdwq[idx].scsi_cstat.control_requests--;
4524 lpfc_release_scsi_buf(phba, lpfc_cmd);
4526 return SCSI_MLQUEUE_HOST_BUSY;
4529 return SCSI_MLQUEUE_TARGET_BUSY;
4532 cmnd->scsi_done(cmnd);
4538 * lpfc_abort_handler - scsi_host_template eh_abort_handler entry point
4539 * @cmnd: Pointer to scsi_cmnd data structure.
4541 * This routine aborts @cmnd pending in base driver.
4548 lpfc_abort_handler(struct scsi_cmnd *cmnd)
4550 struct Scsi_Host *shost = cmnd->device->host;
4551 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4552 struct lpfc_hba *phba = vport->phba;
4553 struct lpfc_iocbq *iocb;
4554 struct lpfc_iocbq *abtsiocb;
4555 struct lpfc_io_buf *lpfc_cmd;
4557 int ret = SUCCESS, status = 0;
4558 struct lpfc_sli_ring *pring_s4 = NULL;
4560 unsigned long flags;
4561 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq);
4563 status = fc_block_scsi_eh(cmnd);
4564 if (status != 0 && status != SUCCESS)
4567 lpfc_cmd = (struct lpfc_io_buf *)cmnd->host_scribble;
4571 spin_lock_irqsave(&phba->hbalock, flags);
4572 /* driver queued commands are in process of being flushed */
4573 if (phba->hba_flag & HBA_FCP_IOQ_FLUSH) {
4574 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4575 "3168 SCSI Layer abort requested I/O has been "
4576 "flushed by LLD.\n");
4581 /* Guard against IO completion being called at same time */
4582 spin_lock(&lpfc_cmd->buf_lock);
4584 if (!lpfc_cmd->pCmd) {
4585 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4586 "2873 SCSI Layer I/O Abort Request IO CMPL Status "
4587 "x%x ID %d LUN %llu\n",
4588 SUCCESS, cmnd->device->id, cmnd->device->lun);
4589 goto out_unlock_buf;
4592 iocb = &lpfc_cmd->cur_iocbq;
4593 if (phba->sli_rev == LPFC_SLI_REV4) {
4594 pring_s4 = phba->sli4_hba.hdwq[iocb->hba_wqidx].fcp_wq->pring;
4597 goto out_unlock_buf;
4599 spin_lock(&pring_s4->ring_lock);
4601 /* the command is in process of being cancelled */
4602 if (!(iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ)) {
4603 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4604 "3169 SCSI Layer abort requested I/O has been "
4605 "cancelled by LLD.\n");
4607 goto out_unlock_ring;
4610 * If pCmd field of the corresponding lpfc_io_buf structure
4611 * points to a different SCSI command, then the driver has
4612 * already completed this command, but the midlayer did not
4613 * see the completion before the eh fired. Just return SUCCESS.
4615 if (lpfc_cmd->pCmd != cmnd) {
4616 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4617 "3170 SCSI Layer abort requested I/O has been "
4618 "completed by LLD.\n");
4619 goto out_unlock_ring;
4622 BUG_ON(iocb->context1 != lpfc_cmd);
4624 /* abort issued in recovery is still in progress */
4625 if (iocb->iocb_flag & LPFC_DRIVER_ABORTED) {
4626 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4627 "3389 SCSI Layer I/O Abort Request is pending\n");
4628 if (phba->sli_rev == LPFC_SLI_REV4)
4629 spin_unlock(&pring_s4->ring_lock);
4630 spin_unlock(&lpfc_cmd->buf_lock);
4631 spin_unlock_irqrestore(&phba->hbalock, flags);
4635 abtsiocb = __lpfc_sli_get_iocbq(phba);
4636 if (abtsiocb == NULL) {
4638 goto out_unlock_ring;
4641 /* Indicate the IO is being aborted by the driver. */
4642 iocb->iocb_flag |= LPFC_DRIVER_ABORTED;
4645 * The scsi command can not be in txq and it is in flight because the
4646 * pCmd is still pointig at the SCSI command we have to abort. There
4647 * is no need to search the txcmplq. Just send an abort to the FW.
4651 icmd = &abtsiocb->iocb;
4652 icmd->un.acxri.abortType = ABORT_TYPE_ABTS;
4653 icmd->un.acxri.abortContextTag = cmd->ulpContext;
4654 if (phba->sli_rev == LPFC_SLI_REV4)
4655 icmd->un.acxri.abortIoTag = iocb->sli4_xritag;
4657 icmd->un.acxri.abortIoTag = cmd->ulpIoTag;
4660 icmd->ulpClass = cmd->ulpClass;
4662 /* ABTS WQE must go to the same WQ as the WQE to be aborted */
4663 abtsiocb->hba_wqidx = iocb->hba_wqidx;
4664 abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
4665 if (iocb->iocb_flag & LPFC_IO_FOF)
4666 abtsiocb->iocb_flag |= LPFC_IO_FOF;
4668 if (lpfc_is_link_up(phba))
4669 icmd->ulpCommand = CMD_ABORT_XRI_CN;
4671 icmd->ulpCommand = CMD_CLOSE_XRI_CN;
4673 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
4674 abtsiocb->vport = vport;
4675 lpfc_cmd->waitq = &waitq;
4676 if (phba->sli_rev == LPFC_SLI_REV4) {
4677 /* Note: both hbalock and ring_lock must be set here */
4678 ret_val = __lpfc_sli_issue_iocb(phba, pring_s4->ringno,
4680 spin_unlock(&pring_s4->ring_lock);
4682 ret_val = __lpfc_sli_issue_iocb(phba, LPFC_FCP_RING,
4685 /* no longer need the lock after this point */
4686 spin_unlock_irqrestore(&phba->hbalock, flags);
4688 if (ret_val == IOCB_ERROR) {
4689 /* Indicate the IO is not being aborted by the driver. */
4690 iocb->iocb_flag &= ~LPFC_DRIVER_ABORTED;
4691 lpfc_cmd->waitq = NULL;
4692 spin_unlock(&lpfc_cmd->buf_lock);
4693 lpfc_sli_release_iocbq(phba, abtsiocb);
4698 spin_unlock(&lpfc_cmd->buf_lock);
4700 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4701 lpfc_sli_handle_fast_ring_event(phba,
4702 &phba->sli.sli3_ring[LPFC_FCP_RING], HA_R0RE_REQ);
4705 /* Wait for abort to complete */
4706 wait_event_timeout(waitq,
4707 (lpfc_cmd->pCmd != cmnd),
4708 msecs_to_jiffies(2*vport->cfg_devloss_tmo*1000));
4710 spin_lock(&lpfc_cmd->buf_lock);
4712 if (lpfc_cmd->pCmd == cmnd) {
4714 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4715 "0748 abort handler timed out waiting "
4716 "for aborting I/O (xri:x%x) to complete: "
4717 "ret %#x, ID %d, LUN %llu\n",
4718 iocb->sli4_xritag, ret,
4719 cmnd->device->id, cmnd->device->lun);
4721 spin_unlock(&lpfc_cmd->buf_lock);
4725 if (phba->sli_rev == LPFC_SLI_REV4)
4726 spin_unlock(&pring_s4->ring_lock);
4728 spin_unlock(&lpfc_cmd->buf_lock);
4730 spin_unlock_irqrestore(&phba->hbalock, flags);
4732 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4733 "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
4734 "LUN %llu\n", ret, cmnd->device->id,
4740 lpfc_taskmgmt_name(uint8_t task_mgmt_cmd)
4742 switch (task_mgmt_cmd) {
4743 case FCP_ABORT_TASK_SET:
4744 return "ABORT_TASK_SET";
4745 case FCP_CLEAR_TASK_SET:
4746 return "FCP_CLEAR_TASK_SET";
4748 return "FCP_BUS_RESET";
4750 return "FCP_LUN_RESET";
4751 case FCP_TARGET_RESET:
4752 return "FCP_TARGET_RESET";
4754 return "FCP_CLEAR_ACA";
4755 case FCP_TERMINATE_TASK:
4756 return "FCP_TERMINATE_TASK";
4764 * lpfc_check_fcp_rsp - check the returned fcp_rsp to see if task failed
4765 * @vport: The virtual port for which this call is being executed.
4766 * @lpfc_cmd: Pointer to lpfc_io_buf data structure.
4768 * This routine checks the FCP RSP INFO to see if the tsk mgmt command succeded
4775 lpfc_check_fcp_rsp(struct lpfc_vport *vport, struct lpfc_io_buf *lpfc_cmd)
4777 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
4780 uint8_t rsp_info_code;
4785 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4786 "0703 fcp_rsp is missing\n");
4788 rsp_info = fcprsp->rspStatus2;
4789 rsp_len = be32_to_cpu(fcprsp->rspRspLen);
4790 rsp_info_code = fcprsp->rspInfo3;
4793 lpfc_printf_vlog(vport, KERN_INFO,
4795 "0706 fcp_rsp valid 0x%x,"
4796 " rsp len=%d code 0x%x\n",
4798 rsp_len, rsp_info_code);
4800 if ((fcprsp->rspStatus2&RSP_LEN_VALID) && (rsp_len == 8)) {
4801 switch (rsp_info_code) {
4802 case RSP_NO_FAILURE:
4803 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4804 "0715 Task Mgmt No Failure\n");
4807 case RSP_TM_NOT_SUPPORTED: /* TM rejected */
4808 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4809 "0716 Task Mgmt Target "
4812 case RSP_TM_NOT_COMPLETED: /* TM failed */
4813 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4814 "0717 Task Mgmt Target "
4817 case RSP_TM_INVALID_LU: /* TM to invalid LU! */
4818 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4819 "0718 Task Mgmt to invalid "
4830 * lpfc_send_taskmgmt - Generic SCSI Task Mgmt Handler
4831 * @vport: The virtual port for which this call is being executed.
4832 * @rdata: Pointer to remote port local data
4833 * @tgt_id: Target ID of remote device.
4834 * @lun_id: Lun number for the TMF
4835 * @task_mgmt_cmd: type of TMF to send
4837 * This routine builds and sends a TMF (SCSI Task Mgmt Function) to
4845 lpfc_send_taskmgmt(struct lpfc_vport *vport, struct scsi_cmnd *cmnd,
4846 unsigned int tgt_id, uint64_t lun_id,
4847 uint8_t task_mgmt_cmd)
4849 struct lpfc_hba *phba = vport->phba;
4850 struct lpfc_io_buf *lpfc_cmd;
4851 struct lpfc_iocbq *iocbq;
4852 struct lpfc_iocbq *iocbqrsp;
4853 struct lpfc_rport_data *rdata;
4854 struct lpfc_nodelist *pnode;
4858 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
4859 if (!rdata || !rdata->pnode || !NLP_CHK_NODE_ACT(rdata->pnode))
4861 pnode = rdata->pnode;
4863 lpfc_cmd = lpfc_get_scsi_buf(phba, pnode, NULL);
4864 if (lpfc_cmd == NULL)
4866 lpfc_cmd->timeout = phba->cfg_task_mgmt_tmo;
4867 lpfc_cmd->rdata = rdata;
4868 lpfc_cmd->pCmd = cmnd;
4869 lpfc_cmd->ndlp = pnode;
4871 status = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun_id,
4874 lpfc_release_scsi_buf(phba, lpfc_cmd);
4878 iocbq = &lpfc_cmd->cur_iocbq;
4879 iocbqrsp = lpfc_sli_get_iocbq(phba);
4880 if (iocbqrsp == NULL) {
4881 lpfc_release_scsi_buf(phba, lpfc_cmd);
4884 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
4886 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4887 "0702 Issue %s to TGT %d LUN %llu "
4888 "rpi x%x nlp_flag x%x Data: x%x x%x\n",
4889 lpfc_taskmgmt_name(task_mgmt_cmd), tgt_id, lun_id,
4890 pnode->nlp_rpi, pnode->nlp_flag, iocbq->sli4_xritag,
4893 status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING,
4894 iocbq, iocbqrsp, lpfc_cmd->timeout);
4895 if ((status != IOCB_SUCCESS) ||
4896 (iocbqrsp->iocb.ulpStatus != IOSTAT_SUCCESS)) {
4897 if (status != IOCB_SUCCESS ||
4898 iocbqrsp->iocb.ulpStatus != IOSTAT_FCP_RSP_ERROR)
4899 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4900 "0727 TMF %s to TGT %d LUN %llu "
4901 "failed (%d, %d) iocb_flag x%x\n",
4902 lpfc_taskmgmt_name(task_mgmt_cmd),
4904 iocbqrsp->iocb.ulpStatus,
4905 iocbqrsp->iocb.un.ulpWord[4],
4907 /* if ulpStatus != IOCB_SUCCESS, then status == IOCB_SUCCESS */
4908 if (status == IOCB_SUCCESS) {
4909 if (iocbqrsp->iocb.ulpStatus == IOSTAT_FCP_RSP_ERROR)
4910 /* Something in the FCP_RSP was invalid.
4911 * Check conditions */
4912 ret = lpfc_check_fcp_rsp(vport, lpfc_cmd);
4915 } else if (status == IOCB_TIMEDOUT) {
4916 ret = TIMEOUT_ERROR;
4923 lpfc_sli_release_iocbq(phba, iocbqrsp);
4925 if (ret != TIMEOUT_ERROR)
4926 lpfc_release_scsi_buf(phba, lpfc_cmd);
4932 * lpfc_chk_tgt_mapped -
4933 * @vport: The virtual port to check on
4934 * @cmnd: Pointer to scsi_cmnd data structure.
4936 * This routine delays until the scsi target (aka rport) for the
4937 * command exists (is present and logged in) or we declare it non-existent.
4944 lpfc_chk_tgt_mapped(struct lpfc_vport *vport, struct scsi_cmnd *cmnd)
4946 struct lpfc_rport_data *rdata;
4947 struct lpfc_nodelist *pnode;
4948 unsigned long later;
4950 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
4952 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4953 "0797 Tgt Map rport failure: rdata x%p\n", rdata);
4956 pnode = rdata->pnode;
4958 * If target is not in a MAPPED state, delay until
4959 * target is rediscovered or devloss timeout expires.
4961 later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
4962 while (time_after(later, jiffies)) {
4963 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
4965 if (pnode->nlp_state == NLP_STE_MAPPED_NODE)
4967 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
4968 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
4971 pnode = rdata->pnode;
4973 if (!pnode || !NLP_CHK_NODE_ACT(pnode) ||
4974 (pnode->nlp_state != NLP_STE_MAPPED_NODE))
4980 * lpfc_reset_flush_io_context -
4981 * @vport: The virtual port (scsi_host) for the flush context
4982 * @tgt_id: If aborting by Target contect - specifies the target id
4983 * @lun_id: If aborting by Lun context - specifies the lun id
4984 * @context: specifies the context level to flush at.
4986 * After a reset condition via TMF, we need to flush orphaned i/o
4987 * contexts from the adapter. This routine aborts any contexts
4988 * outstanding, then waits for their completions. The wait is
4989 * bounded by devloss_tmo though.
4996 lpfc_reset_flush_io_context(struct lpfc_vport *vport, uint16_t tgt_id,
4997 uint64_t lun_id, lpfc_ctx_cmd context)
4999 struct lpfc_hba *phba = vport->phba;
5000 unsigned long later;
5003 cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context);
5005 lpfc_sli_abort_taskmgmt(vport,
5006 &phba->sli.sli3_ring[LPFC_FCP_RING],
5007 tgt_id, lun_id, context);
5008 later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
5009 while (time_after(later, jiffies) && cnt) {
5010 schedule_timeout_uninterruptible(msecs_to_jiffies(20));
5011 cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context);
5014 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5015 "0724 I/O flush failure for context %s : cnt x%x\n",
5016 ((context == LPFC_CTX_LUN) ? "LUN" :
5017 ((context == LPFC_CTX_TGT) ? "TGT" :
5018 ((context == LPFC_CTX_HOST) ? "HOST" : "Unknown"))),
5026 * lpfc_device_reset_handler - scsi_host_template eh_device_reset entry point
5027 * @cmnd: Pointer to scsi_cmnd data structure.
5029 * This routine does a device reset by sending a LUN_RESET task management
5037 lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
5039 struct Scsi_Host *shost = cmnd->device->host;
5040 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5041 struct lpfc_rport_data *rdata;
5042 struct lpfc_nodelist *pnode;
5043 unsigned tgt_id = cmnd->device->id;
5044 uint64_t lun_id = cmnd->device->lun;
5045 struct lpfc_scsi_event_header scsi_event;
5048 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
5049 if (!rdata || !rdata->pnode) {
5050 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5051 "0798 Device Reset rport failure: rdata x%p\n",
5055 pnode = rdata->pnode;
5056 status = fc_block_scsi_eh(cmnd);
5057 if (status != 0 && status != SUCCESS)
5060 status = lpfc_chk_tgt_mapped(vport, cmnd);
5061 if (status == FAILED) {
5062 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5063 "0721 Device Reset rport failure: rdata x%p\n", rdata);
5067 scsi_event.event_type = FC_REG_SCSI_EVENT;
5068 scsi_event.subcategory = LPFC_EVENT_LUNRESET;
5069 scsi_event.lun = lun_id;
5070 memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name));
5071 memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name));
5073 fc_host_post_vendor_event(shost, fc_get_event_number(),
5074 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
5076 status = lpfc_send_taskmgmt(vport, cmnd, tgt_id, lun_id,
5079 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5080 "0713 SCSI layer issued Device Reset (%d, %llu) "
5081 "return x%x\n", tgt_id, lun_id, status);
5084 * We have to clean up i/o as : they may be orphaned by the TMF;
5085 * or if the TMF failed, they may be in an indeterminate state.
5087 * We will report success if all the i/o aborts successfully.
5089 if (status == SUCCESS)
5090 status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
5097 * lpfc_target_reset_handler - scsi_host_template eh_target_reset entry point
5098 * @cmnd: Pointer to scsi_cmnd data structure.
5100 * This routine does a target reset by sending a TARGET_RESET task management
5108 lpfc_target_reset_handler(struct scsi_cmnd *cmnd)
5110 struct Scsi_Host *shost = cmnd->device->host;
5111 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5112 struct lpfc_rport_data *rdata;
5113 struct lpfc_nodelist *pnode;
5114 unsigned tgt_id = cmnd->device->id;
5115 uint64_t lun_id = cmnd->device->lun;
5116 struct lpfc_scsi_event_header scsi_event;
5119 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
5121 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5122 "0799 Target Reset rport failure: rdata x%p\n", rdata);
5125 pnode = rdata->pnode;
5126 status = fc_block_scsi_eh(cmnd);
5127 if (status != 0 && status != SUCCESS)
5130 status = lpfc_chk_tgt_mapped(vport, cmnd);
5131 if (status == FAILED) {
5132 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5133 "0722 Target Reset rport failure: rdata x%p\n", rdata);
5135 spin_lock_irq(shost->host_lock);
5136 pnode->nlp_flag &= ~NLP_NPR_ADISC;
5137 pnode->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
5138 spin_unlock_irq(shost->host_lock);
5140 lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
5142 return FAST_IO_FAIL;
5145 scsi_event.event_type = FC_REG_SCSI_EVENT;
5146 scsi_event.subcategory = LPFC_EVENT_TGTRESET;
5148 memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name));
5149 memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name));
5151 fc_host_post_vendor_event(shost, fc_get_event_number(),
5152 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
5154 status = lpfc_send_taskmgmt(vport, cmnd, tgt_id, lun_id,
5157 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5158 "0723 SCSI layer issued Target Reset (%d, %llu) "
5159 "return x%x\n", tgt_id, lun_id, status);
5162 * We have to clean up i/o as : they may be orphaned by the TMF;
5163 * or if the TMF failed, they may be in an indeterminate state.
5165 * We will report success if all the i/o aborts successfully.
5167 if (status == SUCCESS)
5168 status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
5174 * lpfc_bus_reset_handler - scsi_host_template eh_bus_reset_handler entry point
5175 * @cmnd: Pointer to scsi_cmnd data structure.
5177 * This routine does target reset to all targets on @cmnd->device->host.
5178 * This emulates Parallel SCSI Bus Reset Semantics.
5185 lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
5187 struct Scsi_Host *shost = cmnd->device->host;
5188 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5189 struct lpfc_nodelist *ndlp = NULL;
5190 struct lpfc_scsi_event_header scsi_event;
5192 int ret = SUCCESS, status, i;
5194 scsi_event.event_type = FC_REG_SCSI_EVENT;
5195 scsi_event.subcategory = LPFC_EVENT_BUSRESET;
5197 memcpy(scsi_event.wwpn, &vport->fc_portname, sizeof(struct lpfc_name));
5198 memcpy(scsi_event.wwnn, &vport->fc_nodename, sizeof(struct lpfc_name));
5200 fc_host_post_vendor_event(shost, fc_get_event_number(),
5201 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
5203 status = fc_block_scsi_eh(cmnd);
5204 if (status != 0 && status != SUCCESS)
5208 * Since the driver manages a single bus device, reset all
5209 * targets known to the driver. Should any target reset
5210 * fail, this routine returns failure to the midlayer.
5212 for (i = 0; i < LPFC_MAX_TARGET; i++) {
5213 /* Search for mapped node by target ID */
5215 spin_lock_irq(shost->host_lock);
5216 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
5217 if (!NLP_CHK_NODE_ACT(ndlp))
5219 if (vport->phba->cfg_fcp2_no_tgt_reset &&
5220 (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE))
5222 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
5223 ndlp->nlp_sid == i &&
5225 ndlp->nlp_type & NLP_FCP_TARGET) {
5230 spin_unlock_irq(shost->host_lock);
5234 status = lpfc_send_taskmgmt(vport, cmnd,
5235 i, 0, FCP_TARGET_RESET);
5237 if (status != SUCCESS) {
5238 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5239 "0700 Bus Reset on target %d failed\n",
5245 * We have to clean up i/o as : they may be orphaned by the TMFs
5246 * above; or if any of the TMFs failed, they may be in an
5247 * indeterminate state.
5248 * We will report success if all the i/o aborts successfully.
5251 status = lpfc_reset_flush_io_context(vport, 0, 0, LPFC_CTX_HOST);
5252 if (status != SUCCESS)
5255 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5256 "0714 SCSI layer issued Bus Reset Data: x%x\n", ret);
5261 * lpfc_host_reset_handler - scsi_host_template eh_host_reset_handler entry pt
5262 * @cmnd: Pointer to scsi_cmnd data structure.
5264 * This routine does host reset to the adaptor port. It brings the HBA
5265 * offline, performs a board restart, and then brings the board back online.
5266 * The lpfc_offline calls lpfc_sli_hba_down which will abort and local
5267 * reject all outstanding SCSI commands to the host and error returned
5268 * back to SCSI mid-level. As this will be SCSI mid-level's last resort
5269 * of error handling, it will only return error if resetting of the adapter
5270 * is not successful; in all other cases, will return success.
5277 lpfc_host_reset_handler(struct scsi_cmnd *cmnd)
5279 struct Scsi_Host *shost = cmnd->device->host;
5280 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5281 struct lpfc_hba *phba = vport->phba;
5282 int rc, ret = SUCCESS;
5284 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5285 "3172 SCSI layer issued Host Reset Data:\n");
5287 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
5289 rc = lpfc_sli_brdrestart(phba);
5292 rc = lpfc_online(phba);
5295 lpfc_unblock_mgmt_io(phba);
5297 if (ret == FAILED) {
5298 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5299 "3323 Failed host reset, bring it offline\n");
5300 lpfc_sli4_offline_eratt(phba);
5306 * lpfc_slave_alloc - scsi_host_template slave_alloc entry point
5307 * @sdev: Pointer to scsi_device.
5309 * This routine populates the cmds_per_lun count + 2 scsi_bufs into this host's
5310 * globally available list of scsi buffers. This routine also makes sure scsi
5311 * buffer is not allocated more than HBA limit conveyed to midlayer. This list
5312 * of scsi buffer exists for the lifetime of the driver.
5319 lpfc_slave_alloc(struct scsi_device *sdev)
5321 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5322 struct lpfc_hba *phba = vport->phba;
5323 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
5325 uint32_t num_to_alloc = 0;
5326 int num_allocated = 0;
5328 struct lpfc_device_data *device_data;
5329 unsigned long flags;
5330 struct lpfc_name target_wwpn;
5332 if (!rport || fc_remote_port_chkready(rport))
5335 if (phba->cfg_fof) {
5338 * Check to see if the device data structure for the lun
5339 * exists. If not, create one.
5342 u64_to_wwn(rport->port_name, target_wwpn.u.wwn);
5343 spin_lock_irqsave(&phba->devicelock, flags);
5344 device_data = __lpfc_get_device_data(phba,
5346 &vport->fc_portname,
5350 spin_unlock_irqrestore(&phba->devicelock, flags);
5351 device_data = lpfc_create_device_data(phba,
5352 &vport->fc_portname,
5355 phba->cfg_XLanePriority,
5359 spin_lock_irqsave(&phba->devicelock, flags);
5360 list_add_tail(&device_data->listentry, &phba->luns);
5362 device_data->rport_data = rport->dd_data;
5363 device_data->available = true;
5364 spin_unlock_irqrestore(&phba->devicelock, flags);
5365 sdev->hostdata = device_data;
5367 sdev->hostdata = rport->dd_data;
5369 sdev_cnt = atomic_inc_return(&phba->sdev_cnt);
5371 /* For SLI4, all IO buffers are pre-allocated */
5372 if (phba->sli_rev == LPFC_SLI_REV4)
5375 /* This code path is now ONLY for SLI3 adapters */
5378 * Populate the cmds_per_lun count scsi_bufs into this host's globally
5379 * available list of scsi buffers. Don't allocate more than the
5380 * HBA limit conveyed to the midlayer via the host structure. The
5381 * formula accounts for the lun_queue_depth + error handlers + 1
5382 * extra. This list of scsi bufs exists for the lifetime of the driver.
5384 total = phba->total_scsi_bufs;
5385 num_to_alloc = vport->cfg_lun_queue_depth + 2;
5387 /* If allocated buffers are enough do nothing */
5388 if ((sdev_cnt * (vport->cfg_lun_queue_depth + 2)) < total)
5391 /* Allow some exchanges to be available always to complete discovery */
5392 if (total >= phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
5393 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
5394 "0704 At limitation of %d preallocated "
5395 "command buffers\n", total);
5397 /* Allow some exchanges to be available always to complete discovery */
5398 } else if (total + num_to_alloc >
5399 phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
5400 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
5401 "0705 Allocation request of %d "
5402 "command buffers will exceed max of %d. "
5403 "Reducing allocation request to %d.\n",
5404 num_to_alloc, phba->cfg_hba_queue_depth,
5405 (phba->cfg_hba_queue_depth - total));
5406 num_to_alloc = phba->cfg_hba_queue_depth - total;
5408 num_allocated = lpfc_new_scsi_buf_s3(vport, num_to_alloc);
5409 if (num_to_alloc != num_allocated) {
5410 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5411 "0708 Allocation request of %d "
5412 "command buffers did not succeed. "
5413 "Allocated %d buffers.\n",
5414 num_to_alloc, num_allocated);
5416 if (num_allocated > 0)
5417 phba->total_scsi_bufs += num_allocated;
5422 * lpfc_slave_configure - scsi_host_template slave_configure entry point
5423 * @sdev: Pointer to scsi_device.
5425 * This routine configures following items
5426 * - Tag command queuing support for @sdev if supported.
5427 * - Enable SLI polling for fcp ring if ENABLE_FCP_RING_POLLING flag is set.
5433 lpfc_slave_configure(struct scsi_device *sdev)
5435 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5436 struct lpfc_hba *phba = vport->phba;
5438 scsi_change_queue_depth(sdev, vport->cfg_lun_queue_depth);
5440 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
5441 lpfc_sli_handle_fast_ring_event(phba,
5442 &phba->sli.sli3_ring[LPFC_FCP_RING], HA_R0RE_REQ);
5443 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
5444 lpfc_poll_rearm_timer(phba);
5451 * lpfc_slave_destroy - slave_destroy entry point of SHT data structure
5452 * @sdev: Pointer to scsi_device.
5454 * This routine sets @sdev hostatdata filed to null.
5457 lpfc_slave_destroy(struct scsi_device *sdev)
5459 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5460 struct lpfc_hba *phba = vport->phba;
5461 unsigned long flags;
5462 struct lpfc_device_data *device_data = sdev->hostdata;
5464 atomic_dec(&phba->sdev_cnt);
5465 if ((phba->cfg_fof) && (device_data)) {
5466 spin_lock_irqsave(&phba->devicelock, flags);
5467 device_data->available = false;
5468 if (!device_data->oas_enabled)
5469 lpfc_delete_device_data(phba, device_data);
5470 spin_unlock_irqrestore(&phba->devicelock, flags);
5472 sdev->hostdata = NULL;
5477 * lpfc_create_device_data - creates and initializes device data structure for OAS
5478 * @pha: Pointer to host bus adapter structure.
5479 * @vport_wwpn: Pointer to vport's wwpn information
5480 * @target_wwpn: Pointer to target's wwpn information
5481 * @lun: Lun on target
5482 * @atomic_create: Flag to indicate if memory should be allocated using the
5483 * GFP_ATOMIC flag or not.
5485 * This routine creates a device data structure which will contain identifying
5486 * information for the device (host wwpn, target wwpn, lun), state of OAS,
5487 * whether or not the corresponding lun is available by the system,
5488 * and pointer to the rport data.
5492 * Pointer to lpfc_device_data - Success
5494 struct lpfc_device_data*
5495 lpfc_create_device_data(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5496 struct lpfc_name *target_wwpn, uint64_t lun,
5497 uint32_t pri, bool atomic_create)
5500 struct lpfc_device_data *lun_info;
5503 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5507 /* Attempt to create the device data to contain lun info */
5510 memory_flags = GFP_ATOMIC;
5512 memory_flags = GFP_KERNEL;
5513 lun_info = mempool_alloc(phba->device_data_mem_pool, memory_flags);
5516 INIT_LIST_HEAD(&lun_info->listentry);
5517 lun_info->rport_data = NULL;
5518 memcpy(&lun_info->device_id.vport_wwpn, vport_wwpn,
5519 sizeof(struct lpfc_name));
5520 memcpy(&lun_info->device_id.target_wwpn, target_wwpn,
5521 sizeof(struct lpfc_name));
5522 lun_info->device_id.lun = lun;
5523 lun_info->oas_enabled = false;
5524 lun_info->priority = pri;
5525 lun_info->available = false;
5530 * lpfc_delete_device_data - frees a device data structure for OAS
5531 * @pha: Pointer to host bus adapter structure.
5532 * @lun_info: Pointer to device data structure to free.
5534 * This routine frees the previously allocated device data structure passed.
5538 lpfc_delete_device_data(struct lpfc_hba *phba,
5539 struct lpfc_device_data *lun_info)
5542 if (unlikely(!phba) || !lun_info ||
5546 if (!list_empty(&lun_info->listentry))
5547 list_del(&lun_info->listentry);
5548 mempool_free(lun_info, phba->device_data_mem_pool);
5553 * __lpfc_get_device_data - returns the device data for the specified lun
5554 * @pha: Pointer to host bus adapter structure.
5555 * @list: Point to list to search.
5556 * @vport_wwpn: Pointer to vport's wwpn information
5557 * @target_wwpn: Pointer to target's wwpn information
5558 * @lun: Lun on target
5560 * This routine searches the list passed for the specified lun's device data.
5561 * This function does not hold locks, it is the responsibility of the caller
5562 * to ensure the proper lock is held before calling the function.
5566 * Pointer to lpfc_device_data - Success
5568 struct lpfc_device_data*
5569 __lpfc_get_device_data(struct lpfc_hba *phba, struct list_head *list,
5570 struct lpfc_name *vport_wwpn,
5571 struct lpfc_name *target_wwpn, uint64_t lun)
5574 struct lpfc_device_data *lun_info;
5576 if (unlikely(!phba) || !list || !vport_wwpn || !target_wwpn ||
5580 /* Check to see if the lun is already enabled for OAS. */
5582 list_for_each_entry(lun_info, list, listentry) {
5583 if ((memcmp(&lun_info->device_id.vport_wwpn, vport_wwpn,
5584 sizeof(struct lpfc_name)) == 0) &&
5585 (memcmp(&lun_info->device_id.target_wwpn, target_wwpn,
5586 sizeof(struct lpfc_name)) == 0) &&
5587 (lun_info->device_id.lun == lun))
5595 * lpfc_find_next_oas_lun - searches for the next oas lun
5596 * @pha: Pointer to host bus adapter structure.
5597 * @vport_wwpn: Pointer to vport's wwpn information
5598 * @target_wwpn: Pointer to target's wwpn information
5599 * @starting_lun: Pointer to the lun to start searching for
5600 * @found_vport_wwpn: Pointer to the found lun's vport wwpn information
5601 * @found_target_wwpn: Pointer to the found lun's target wwpn information
5602 * @found_lun: Pointer to the found lun.
5603 * @found_lun_status: Pointer to status of the found lun.
5605 * This routine searches the luns list for the specified lun
5606 * or the first lun for the vport/target. If the vport wwpn contains
5607 * a zero value then a specific vport is not specified. In this case
5608 * any vport which contains the lun will be considered a match. If the
5609 * target wwpn contains a zero value then a specific target is not specified.
5610 * In this case any target which contains the lun will be considered a
5611 * match. If the lun is found, the lun, vport wwpn, target wwpn and lun status
5612 * are returned. The function will also return the next lun if available.
5613 * If the next lun is not found, starting_lun parameter will be set to
5621 lpfc_find_next_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5622 struct lpfc_name *target_wwpn, uint64_t *starting_lun,
5623 struct lpfc_name *found_vport_wwpn,
5624 struct lpfc_name *found_target_wwpn,
5625 uint64_t *found_lun,
5626 uint32_t *found_lun_status,
5627 uint32_t *found_lun_pri)
5630 unsigned long flags;
5631 struct lpfc_device_data *lun_info;
5632 struct lpfc_device_id *device_id;
5636 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5637 !starting_lun || !found_vport_wwpn ||
5638 !found_target_wwpn || !found_lun || !found_lun_status ||
5639 (*starting_lun == NO_MORE_OAS_LUN) ||
5643 lun = *starting_lun;
5644 *found_lun = NO_MORE_OAS_LUN;
5645 *starting_lun = NO_MORE_OAS_LUN;
5647 /* Search for lun or the lun closet in value */
5649 spin_lock_irqsave(&phba->devicelock, flags);
5650 list_for_each_entry(lun_info, &phba->luns, listentry) {
5651 if (((wwn_to_u64(vport_wwpn->u.wwn) == 0) ||
5652 (memcmp(&lun_info->device_id.vport_wwpn, vport_wwpn,
5653 sizeof(struct lpfc_name)) == 0)) &&
5654 ((wwn_to_u64(target_wwpn->u.wwn) == 0) ||
5655 (memcmp(&lun_info->device_id.target_wwpn, target_wwpn,
5656 sizeof(struct lpfc_name)) == 0)) &&
5657 (lun_info->oas_enabled)) {
5658 device_id = &lun_info->device_id;
5660 ((lun == FIND_FIRST_OAS_LUN) ||
5661 (device_id->lun == lun))) {
5662 *found_lun = device_id->lun;
5663 memcpy(found_vport_wwpn,
5664 &device_id->vport_wwpn,
5665 sizeof(struct lpfc_name));
5666 memcpy(found_target_wwpn,
5667 &device_id->target_wwpn,
5668 sizeof(struct lpfc_name));
5669 if (lun_info->available)
5671 OAS_LUN_STATUS_EXISTS;
5673 *found_lun_status = 0;
5674 *found_lun_pri = lun_info->priority;
5675 if (phba->cfg_oas_flags & OAS_FIND_ANY_VPORT)
5676 memset(vport_wwpn, 0x0,
5677 sizeof(struct lpfc_name));
5678 if (phba->cfg_oas_flags & OAS_FIND_ANY_TARGET)
5679 memset(target_wwpn, 0x0,
5680 sizeof(struct lpfc_name));
5683 *starting_lun = device_id->lun;
5684 memcpy(vport_wwpn, &device_id->vport_wwpn,
5685 sizeof(struct lpfc_name));
5686 memcpy(target_wwpn, &device_id->target_wwpn,
5687 sizeof(struct lpfc_name));
5692 spin_unlock_irqrestore(&phba->devicelock, flags);
5697 * lpfc_enable_oas_lun - enables a lun for OAS operations
5698 * @pha: Pointer to host bus adapter structure.
5699 * @vport_wwpn: Pointer to vport's wwpn information
5700 * @target_wwpn: Pointer to target's wwpn information
5703 * This routine enables a lun for oas operations. The routines does so by
5704 * doing the following :
5706 * 1) Checks to see if the device data for the lun has been created.
5707 * 2) If found, sets the OAS enabled flag if not set and returns.
5708 * 3) Otherwise, creates a device data structure.
5709 * 4) If successfully created, indicates the device data is for an OAS lun,
5710 * indicates the lun is not available and add to the list of luns.
5717 lpfc_enable_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5718 struct lpfc_name *target_wwpn, uint64_t lun, uint8_t pri)
5721 struct lpfc_device_data *lun_info;
5722 unsigned long flags;
5724 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5728 spin_lock_irqsave(&phba->devicelock, flags);
5730 /* Check to see if the device data for the lun has been created */
5731 lun_info = __lpfc_get_device_data(phba, &phba->luns, vport_wwpn,
5734 if (!lun_info->oas_enabled)
5735 lun_info->oas_enabled = true;
5736 lun_info->priority = pri;
5737 spin_unlock_irqrestore(&phba->devicelock, flags);
5741 /* Create an lun info structure and add to list of luns */
5742 lun_info = lpfc_create_device_data(phba, vport_wwpn, target_wwpn, lun,
5745 lun_info->oas_enabled = true;
5746 lun_info->priority = pri;
5747 lun_info->available = false;
5748 list_add_tail(&lun_info->listentry, &phba->luns);
5749 spin_unlock_irqrestore(&phba->devicelock, flags);
5752 spin_unlock_irqrestore(&phba->devicelock, flags);
5757 * lpfc_disable_oas_lun - disables a lun for OAS operations
5758 * @pha: Pointer to host bus adapter structure.
5759 * @vport_wwpn: Pointer to vport's wwpn information
5760 * @target_wwpn: Pointer to target's wwpn information
5763 * This routine disables a lun for oas operations. The routines does so by
5764 * doing the following :
5766 * 1) Checks to see if the device data for the lun is created.
5767 * 2) If present, clears the flag indicating this lun is for OAS.
5768 * 3) If the lun is not available by the system, the device data is
5776 lpfc_disable_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5777 struct lpfc_name *target_wwpn, uint64_t lun, uint8_t pri)
5780 struct lpfc_device_data *lun_info;
5781 unsigned long flags;
5783 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5787 spin_lock_irqsave(&phba->devicelock, flags);
5789 /* Check to see if the lun is available. */
5790 lun_info = __lpfc_get_device_data(phba,
5791 &phba->luns, vport_wwpn,
5794 lun_info->oas_enabled = false;
5795 lun_info->priority = pri;
5796 if (!lun_info->available)
5797 lpfc_delete_device_data(phba, lun_info);
5798 spin_unlock_irqrestore(&phba->devicelock, flags);
5802 spin_unlock_irqrestore(&phba->devicelock, flags);
5807 lpfc_no_command(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
5809 return SCSI_MLQUEUE_HOST_BUSY;
5813 lpfc_no_handler(struct scsi_cmnd *cmnd)
5819 lpfc_no_slave(struct scsi_device *sdev)
5824 struct scsi_host_template lpfc_template_nvme = {
5825 .module = THIS_MODULE,
5826 .name = LPFC_DRIVER_NAME,
5827 .proc_name = LPFC_DRIVER_NAME,
5829 .queuecommand = lpfc_no_command,
5830 .eh_abort_handler = lpfc_no_handler,
5831 .eh_device_reset_handler = lpfc_no_handler,
5832 .eh_target_reset_handler = lpfc_no_handler,
5833 .eh_bus_reset_handler = lpfc_no_handler,
5834 .eh_host_reset_handler = lpfc_no_handler,
5835 .slave_alloc = lpfc_no_slave,
5836 .slave_configure = lpfc_no_slave,
5837 .scan_finished = lpfc_scan_finished,
5841 .shost_attrs = lpfc_hba_attrs,
5842 .max_sectors = 0xFFFF,
5843 .vendor_id = LPFC_NL_VENDOR_ID,
5844 .track_queue_depth = 0,
5847 struct scsi_host_template lpfc_template_no_hr = {
5848 .module = THIS_MODULE,
5849 .name = LPFC_DRIVER_NAME,
5850 .proc_name = LPFC_DRIVER_NAME,
5852 .queuecommand = lpfc_queuecommand,
5853 .eh_timed_out = fc_eh_timed_out,
5854 .eh_abort_handler = lpfc_abort_handler,
5855 .eh_device_reset_handler = lpfc_device_reset_handler,
5856 .eh_target_reset_handler = lpfc_target_reset_handler,
5857 .eh_bus_reset_handler = lpfc_bus_reset_handler,
5858 .slave_alloc = lpfc_slave_alloc,
5859 .slave_configure = lpfc_slave_configure,
5860 .slave_destroy = lpfc_slave_destroy,
5861 .scan_finished = lpfc_scan_finished,
5863 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT,
5864 .cmd_per_lun = LPFC_CMD_PER_LUN,
5865 .shost_attrs = lpfc_hba_attrs,
5866 .max_sectors = 0xFFFF,
5867 .vendor_id = LPFC_NL_VENDOR_ID,
5868 .change_queue_depth = scsi_change_queue_depth,
5869 .track_queue_depth = 1,
5872 struct scsi_host_template lpfc_template = {
5873 .module = THIS_MODULE,
5874 .name = LPFC_DRIVER_NAME,
5875 .proc_name = LPFC_DRIVER_NAME,
5877 .queuecommand = lpfc_queuecommand,
5878 .eh_timed_out = fc_eh_timed_out,
5879 .eh_abort_handler = lpfc_abort_handler,
5880 .eh_device_reset_handler = lpfc_device_reset_handler,
5881 .eh_target_reset_handler = lpfc_target_reset_handler,
5882 .eh_bus_reset_handler = lpfc_bus_reset_handler,
5883 .eh_host_reset_handler = lpfc_host_reset_handler,
5884 .slave_alloc = lpfc_slave_alloc,
5885 .slave_configure = lpfc_slave_configure,
5886 .slave_destroy = lpfc_slave_destroy,
5887 .scan_finished = lpfc_scan_finished,
5889 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT,
5890 .cmd_per_lun = LPFC_CMD_PER_LUN,
5891 .shost_attrs = lpfc_hba_attrs,
5892 .max_sectors = 0xFFFF,
5893 .vendor_id = LPFC_NL_VENDOR_ID,
5894 .change_queue_depth = scsi_change_queue_depth,
5895 .track_queue_depth = 1,
5898 struct scsi_host_template lpfc_vport_template = {
5899 .module = THIS_MODULE,
5900 .name = LPFC_DRIVER_NAME,
5901 .proc_name = LPFC_DRIVER_NAME,
5903 .queuecommand = lpfc_queuecommand,
5904 .eh_timed_out = fc_eh_timed_out,
5905 .eh_abort_handler = lpfc_abort_handler,
5906 .eh_device_reset_handler = lpfc_device_reset_handler,
5907 .eh_target_reset_handler = lpfc_target_reset_handler,
5908 .slave_alloc = lpfc_slave_alloc,
5909 .slave_configure = lpfc_slave_configure,
5910 .slave_destroy = lpfc_slave_destroy,
5911 .scan_finished = lpfc_scan_finished,
5913 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT,
5914 .cmd_per_lun = LPFC_CMD_PER_LUN,
5915 .shost_attrs = lpfc_vport_attrs,
5916 .max_sectors = 0xFFFF,
5917 .change_queue_depth = scsi_change_queue_depth,
5918 .track_queue_depth = 1,