drivers/scsi/lpfc/lpfc_scsi.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2004-2012 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21 #include <linux/pci.h>
  22 #include <linux/slab.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/export.h>
  25 #include <linux/delay.h>
  26 #include <asm/unaligned.h>
  27
  28 #include <scsi/scsi.h>
  29 #include <scsi/scsi_device.h>
  30 #include <scsi/scsi_eh.h>
  31 #include <scsi/scsi_host.h>
  32 #include <scsi/scsi_tcq.h>
  33 #include <scsi/scsi_transport_fc.h>
  34
  35 #include "lpfc_version.h"
  36 #include "lpfc_hw4.h"
  37 #include "lpfc_hw.h"
  38 #include "lpfc_sli.h"
  39 #include "lpfc_sli4.h"
  40 #include "lpfc_nl.h"
  41 #include "lpfc_disc.h"
  42 #include "lpfc.h"
  43 #include "lpfc_scsi.h"
  44 #include "lpfc_logmsg.h"
  45 #include "lpfc_crtn.h"
  46 #include "lpfc_vport.h"
  47
  48 #define LPFC_RESET_WAIT  2
  49 #define LPFC_ABORT_WAIT  2
  50
  51 int _dump_buf_done;
  52
  53 static char *dif_op_str[] = {
  54         "PROT_NORMAL",
  55         "PROT_READ_INSERT",
  56         "PROT_WRITE_STRIP",
  57         "PROT_READ_STRIP",
  58         "PROT_WRITE_INSERT",
  59         "PROT_READ_PASS",
  60         "PROT_WRITE_PASS",
  61 };
  62
  63 struct scsi_dif_tuple {
  64         __be16 guard_tag;       /* Checksum */
  65         __be16 app_tag;         /* Opaque storage */
  66         __be32 ref_tag;         /* Target LBA or indirect LBA */
  67 };
  68
  69 static void
  70 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb);
  71 static void
  72 lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb);
  73
  74 static void
  75 lpfc_debug_save_data(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
  76 {
  77         void *src, *dst;
  78         struct scatterlist *sgde = scsi_sglist(cmnd);
  79
  80         if (!_dump_buf_data) {
  81                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
  82                         "9050 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
  83                                 __func__);
  84                 return;
  85         }
  86
  87
  88         if (!sgde) {
  89                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
  90                         "9051 BLKGRD: ERROR: data scatterlist is null\n");
  91                 return;
  92         }
  93
  94         dst = (void *) _dump_buf_data;
  95         while (sgde) {
  96                 src = sg_virt(sgde);
  97                 memcpy(dst, src, sgde->length);
  98                 dst += sgde->length;
  99                 sgde = sg_next(sgde);
 100         }
 101 }
 102
 103 static void
 104 lpfc_debug_save_dif(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
 105 {
 106         void *src, *dst;
 107         struct scatterlist *sgde = scsi_prot_sglist(cmnd);
 108
 109         if (!_dump_buf_dif) {
 110                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
 111                         "9052 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
 112                                 __func__);
 113                 return;
 114         }
 115
 116         if (!sgde) {
 117                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
 118                         "9053 BLKGRD: ERROR: prot scatterlist is null\n");
 119                 return;
 120         }
 121
 122         dst = _dump_buf_dif;
 123         while (sgde) {
 124                 src = sg_virt(sgde);
 125                 memcpy(dst, src, sgde->length);
 126                 dst += sgde->length;
 127                 sgde = sg_next(sgde);
 128         }
 129 }
 130
 131 /**
 132  * lpfc_sli4_set_rsp_sgl_last - Set the last bit in the response sge.
 133  * @phba: Pointer to HBA object.
 134  * @lpfc_cmd: lpfc scsi command object pointer.
 135  *
 136  * This function is called from the lpfc_prep_task_mgmt_cmd function to
 137  * set the last bit in the response sge entry.
 138  **/
 139 static void
 140 lpfc_sli4_set_rsp_sgl_last(struct lpfc_hba *phba,
 141                                 struct lpfc_scsi_buf *lpfc_cmd)
 142 {
 143         struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->fcp_bpl;
 144         if (sgl) {
 145                 sgl += 1;
 146                 sgl->word2 = le32_to_cpu(sgl->word2);
 147                 bf_set(lpfc_sli4_sge_last, sgl, 1);
 148                 sgl->word2 = cpu_to_le32(sgl->word2);
 149         }
 150 }
 151
 152 /**
 153  * lpfc_update_stats - Update statistical data for the command completion
 154  * @phba: Pointer to HBA object.
 155  * @lpfc_cmd: lpfc scsi command object pointer.
 156  *
 157  * This function is called when there is a command completion and this
 158  * function updates the statistical data for the command completion.
 159  **/
 160 static void
 161 lpfc_update_stats(struct lpfc_hba *phba, struct  lpfc_scsi_buf *lpfc_cmd)
 162 {
 163         struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
 164         struct lpfc_nodelist *pnode = rdata->pnode;
 165         struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
 166         unsigned long flags;
 167         struct Scsi_Host  *shost = cmd->device->host;
 168         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 169         unsigned long latency;
 170         int i;
 171
 172         if (cmd->result)
 173                 return;
 174
 175         latency = jiffies_to_msecs((long)jiffies - (long)lpfc_cmd->start_time);
 176
 177         spin_lock_irqsave(shost->host_lock, flags);
 178         if (!vport->stat_data_enabled ||
 179                 vport->stat_data_blocked ||
 180                 !pnode ||
 181                 !pnode->lat_data ||
 182                 (phba->bucket_type == LPFC_NO_BUCKET)) {
 183                 spin_unlock_irqrestore(shost->host_lock, flags);
 184                 return;
 185         }
 186
 187         if (phba->bucket_type == LPFC_LINEAR_BUCKET) {
 188                 i = (latency + phba->bucket_step - 1 - phba->bucket_base)/
 189                         phba->bucket_step;
 190                 /* check array subscript bounds */
 191                 if (i < 0)
 192                         i = 0;
 193                 else if (i >= LPFC_MAX_BUCKET_COUNT)
 194                         i = LPFC_MAX_BUCKET_COUNT - 1;
 195         } else {
 196                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT-1; i++)
 197                         if (latency <= (phba->bucket_base +
 198                                 ((1<<i)*phba->bucket_step)))
 199                                 break;
 200         }
 201
 202         pnode->lat_data[i].cmd_count++;
 203         spin_unlock_irqrestore(shost->host_lock, flags);
 204 }
 205
 206 /**
 207  * lpfc_send_sdev_queuedepth_change_event - Posts a queuedepth change event
 208  * @phba: Pointer to HBA context object.
 209  * @vport: Pointer to vport object.
 210  * @ndlp: Pointer to FC node associated with the target.
 211  * @lun: Lun number of the scsi device.
 212  * @old_val: Old value of the queue depth.
 213  * @new_val: New value of the queue depth.
 214  *
 215  * This function sends an event to the mgmt application indicating
 216  * there is a change in the scsi device queue depth.
 217  **/
 218 static void
 219 lpfc_send_sdev_queuedepth_change_event(struct lpfc_hba *phba,
 220                 struct lpfc_vport  *vport,
 221                 struct lpfc_nodelist *ndlp,
 222                 uint32_t lun,
 223                 uint32_t old_val,
 224                 uint32_t new_val)
 225 {
 226         struct lpfc_fast_path_event *fast_path_evt;
 227         unsigned long flags;
 228
 229         fast_path_evt = lpfc_alloc_fast_evt(phba);
 230         if (!fast_path_evt)
 231                 return;
 232
 233         fast_path_evt->un.queue_depth_evt.scsi_event.event_type =
 234                 FC_REG_SCSI_EVENT;
 235         fast_path_evt->un.queue_depth_evt.scsi_event.subcategory =
 236                 LPFC_EVENT_VARQUEDEPTH;
 237
 238         /* Report all luns with change in queue depth */
 239         fast_path_evt->un.queue_depth_evt.scsi_event.lun = lun;
 240         if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
 241                 memcpy(&fast_path_evt->un.queue_depth_evt.scsi_event.wwpn,
 242                         &ndlp->nlp_portname, sizeof(struct lpfc_name));
 243                 memcpy(&fast_path_evt->un.queue_depth_evt.scsi_event.wwnn,
 244                         &ndlp->nlp_nodename, sizeof(struct lpfc_name));
 245         }
 246
 247         fast_path_evt->un.queue_depth_evt.oldval = old_val;
 248         fast_path_evt->un.queue_depth_evt.newval = new_val;
 249         fast_path_evt->vport = vport;
 250
 251         fast_path_evt->work_evt.evt = LPFC_EVT_FASTPATH_MGMT_EVT;
 252         spin_lock_irqsave(&phba->hbalock, flags);
 253         list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list);
 254         spin_unlock_irqrestore(&phba->hbalock, flags);
 255         lpfc_worker_wake_up(phba);
 256
 257         return;
 258 }
 259
 260 /**
 261  * lpfc_change_queue_depth - Alter scsi device queue depth
 262  * @sdev: Pointer the scsi device on which to change the queue depth.
 263  * @qdepth: New queue depth to set the sdev to.
 264  * @reason: The reason for the queue depth change.
 265  *
 266  * This function is called by the midlayer and the LLD to alter the queue
 267  * depth for a scsi device. This function sets the queue depth to the new
 268  * value and sends an event out to log the queue depth change.
 269  **/
 270 int
 271 lpfc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 272 {
 273         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
 274         struct lpfc_hba   *phba = vport->phba;
 275         struct lpfc_rport_data *rdata;
 276         unsigned long new_queue_depth, old_queue_depth;
 277
 278         old_queue_depth = sdev->queue_depth;
 279         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
 280         new_queue_depth = sdev->queue_depth;
 281         rdata = sdev->hostdata;
 282         if (rdata)
 283                 lpfc_send_sdev_queuedepth_change_event(phba, vport,
 284                                                        rdata->pnode, sdev->lun,
 285                                                        old_queue_depth,
 286                                                        new_queue_depth);
 287         return sdev->queue_depth;
 288 }
 289
 290 /**
 291  * lpfc_change_queue_type() - Change a device's scsi tag queuing type
 292  * @sdev: Pointer the scsi device whose queue depth is to change
 293  * @tag_type: Identifier for queue tag type
 294  */
 295 static int
 296 lpfc_change_queue_type(struct scsi_device *sdev, int tag_type)
 297 {
 298         if (sdev->tagged_supported) {
 299                 scsi_set_tag_type(sdev, tag_type);
 300                 if (tag_type)
 301                         scsi_activate_tcq(sdev, sdev->queue_depth);
 302                 else
 303                         scsi_deactivate_tcq(sdev, sdev->queue_depth);
 304         } else
 305                 tag_type = 0;
 306
 307         return tag_type;
 308 }
 309
 310 /**
 311  * lpfc_rampdown_queue_depth - Post RAMP_DOWN_QUEUE event to worker thread
 312  * @phba: The Hba for which this call is being executed.
 313  *
 314  * This routine is called when there is resource error in driver or firmware.
 315  * This routine posts WORKER_RAMP_DOWN_QUEUE event for @phba. This routine
 316  * posts at most 1 event each second. This routine wakes up worker thread of
 317  * @phba to process WORKER_RAM_DOWN_EVENT event.
 318  *
 319  * This routine should be called with no lock held.
 320  **/
 321 void
 322 lpfc_rampdown_queue_depth(struct lpfc_hba *phba)
 323 {
 324         unsigned long flags;
 325         uint32_t evt_posted;
 326
 327         spin_lock_irqsave(&phba->hbalock, flags);
 328         atomic_inc(&phba->num_rsrc_err);
 329         phba->last_rsrc_error_time = jiffies;
 330
 331         if ((phba->last_ramp_down_time + QUEUE_RAMP_DOWN_INTERVAL) > jiffies) {
 332                 spin_unlock_irqrestore(&phba->hbalock, flags);
 333                 return;
 334         }
 335
 336         phba->last_ramp_down_time = jiffies;
 337
 338         spin_unlock_irqrestore(&phba->hbalock, flags);
 339
 340         spin_lock_irqsave(&phba->pport->work_port_lock, flags);
 341         evt_posted = phba->pport->work_port_events & WORKER_RAMP_DOWN_QUEUE;
 342         if (!evt_posted)
 343                 phba->pport->work_port_events |= WORKER_RAMP_DOWN_QUEUE;
 344         spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);
 345
 346         if (!evt_posted)
 347                 lpfc_worker_wake_up(phba);
 348         return;
 349 }
 350
 351 /**
 352  * lpfc_rampup_queue_depth - Post RAMP_UP_QUEUE event for worker thread
 353  * @phba: The Hba for which this call is being executed.
 354  *
 355  * This routine post WORKER_RAMP_UP_QUEUE event for @phba vport. This routine
 356  * post at most 1 event every 5 minute after last_ramp_up_time or
 357  * last_rsrc_error_time.  This routine wakes up worker thread of @phba
 358  * to process WORKER_RAM_DOWN_EVENT event.
 359  *
 360  * This routine should be called with no lock held.
 361  **/
 362 static inline void
 363 lpfc_rampup_queue_depth(struct lpfc_vport  *vport,
 364                         uint32_t queue_depth)
 365 {
 366         unsigned long flags;
 367         struct lpfc_hba *phba = vport->phba;
 368         uint32_t evt_posted;
 369         atomic_inc(&phba->num_cmd_success);
 370
 371         if (vport->cfg_lun_queue_depth <= queue_depth)
 372                 return;
 373         spin_lock_irqsave(&phba->hbalock, flags);
 374         if (time_before(jiffies,
 375                         phba->last_ramp_up_time + QUEUE_RAMP_UP_INTERVAL) ||
 376             time_before(jiffies,
 377                         phba->last_rsrc_error_time + QUEUE_RAMP_UP_INTERVAL)) {
 378                 spin_unlock_irqrestore(&phba->hbalock, flags);
 379                 return;
 380         }
 381         phba->last_ramp_up_time = jiffies;
 382         spin_unlock_irqrestore(&phba->hbalock, flags);
 383
 384         spin_lock_irqsave(&phba->pport->work_port_lock, flags);
 385         evt_posted = phba->pport->work_port_events & WORKER_RAMP_UP_QUEUE;
 386         if (!evt_posted)
 387                 phba->pport->work_port_events |= WORKER_RAMP_UP_QUEUE;
 388         spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);
 389
 390         if (!evt_posted)
 391                 lpfc_worker_wake_up(phba);
 392         return;
 393 }
 394
 395 /**
 396  * lpfc_ramp_down_queue_handler - WORKER_RAMP_DOWN_QUEUE event handler
 397  * @phba: The Hba for which this call is being executed.
 398  *
 399  * This routine is called to  process WORKER_RAMP_DOWN_QUEUE event for worker
 400  * thread.This routine reduces queue depth for all scsi device on each vport
 401  * associated with @phba.
 402  **/
 403 void
 404 lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
 405 {
 406         struct lpfc_vport **vports;
 407         struct Scsi_Host  *shost;
 408         struct scsi_device *sdev;
 409         unsigned long new_queue_depth;
 410         unsigned long num_rsrc_err, num_cmd_success;
 411         int i;
 412
 413         num_rsrc_err = atomic_read(&phba->num_rsrc_err);
 414         num_cmd_success = atomic_read(&phba->num_cmd_success);
 415
 416         /*
 417          * The error and success command counters are global per
 418          * driver instance.  If another handler has already
 419          * operated on this error event, just exit.
 420          */
 421         if (num_rsrc_err == 0)
 422                 return;
 423
 424         vports = lpfc_create_vport_work_array(phba);
 425         if (vports != NULL)
 426                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
 427                         shost = lpfc_shost_from_vport(vports[i]);
 428                         shost_for_each_device(sdev, shost) {
 429                                 new_queue_depth =
 430                                         sdev->queue_depth * num_rsrc_err /
 431                                         (num_rsrc_err + num_cmd_success);
 432                                 if (!new_queue_depth)
 433                                         new_queue_depth = sdev->queue_depth - 1;
 434                                 else
 435                                         new_queue_depth = sdev->queue_depth -
 436                                                                 new_queue_depth;
 437                                 lpfc_change_queue_depth(sdev, new_queue_depth,
 438                                                         SCSI_QDEPTH_DEFAULT);
 439                         }
 440                 }
 441         lpfc_destroy_vport_work_array(phba, vports);
 442         atomic_set(&phba->num_rsrc_err, 0);
 443         atomic_set(&phba->num_cmd_success, 0);
 444 }
 445
 446 /**
 447  * lpfc_ramp_up_queue_handler - WORKER_RAMP_UP_QUEUE event handler
 448  * @phba: The Hba for which this call is being executed.
 449  *
 450  * This routine is called to  process WORKER_RAMP_UP_QUEUE event for worker
 451  * thread.This routine increases queue depth for all scsi device on each vport
 452  * associated with @phba by 1. This routine also sets @phba num_rsrc_err and
 453  * num_cmd_success to zero.
 454  **/
 455 void
 456 lpfc_ramp_up_queue_handler(struct lpfc_hba *phba)
 457 {
 458         struct lpfc_vport **vports;
 459         struct Scsi_Host  *shost;
 460         struct scsi_device *sdev;
 461         int i;
 462
 463         vports = lpfc_create_vport_work_array(phba);
 464         if (vports != NULL)
 465                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
 466                         shost = lpfc_shost_from_vport(vports[i]);
 467                         shost_for_each_device(sdev, shost) {
 468                                 if (vports[i]->cfg_lun_queue_depth <=
 469                                     sdev->queue_depth)
 470                                         continue;
 471                                 lpfc_change_queue_depth(sdev,
 472                                                         sdev->queue_depth+1,
 473                                                         SCSI_QDEPTH_RAMP_UP);
 474                         }
 475                 }
 476         lpfc_destroy_vport_work_array(phba, vports);
 477         atomic_set(&phba->num_rsrc_err, 0);
 478         atomic_set(&phba->num_cmd_success, 0);
 479 }
 480
 481 /**
 482  * lpfc_scsi_dev_block - set all scsi hosts to block state
 483  * @phba: Pointer to HBA context object.
 484  *
 485  * This function walks vport list and set each SCSI host to block state
 486  * by invoking fc_remote_port_delete() routine. This function is invoked
 487  * with EEH when device's PCI slot has been permanently disabled.
 488  **/
 489 void
 490 lpfc_scsi_dev_block(struct lpfc_hba *phba)
 491 {
 492         struct lpfc_vport **vports;
 493         struct Scsi_Host  *shost;
 494         struct scsi_device *sdev;
 495         struct fc_rport *rport;
 496         int i;
 497
 498         vports = lpfc_create_vport_work_array(phba);
 499         if (vports != NULL)
 500                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
 501                         shost = lpfc_shost_from_vport(vports[i]);
 502                         shost_for_each_device(sdev, shost) {
 503                                 rport = starget_to_rport(scsi_target(sdev));
 504                                 fc_remote_port_delete(rport);
 505                         }
 506                 }
 507         lpfc_destroy_vport_work_array(phba, vports);
 508 }
 509
 510 /**
 511  * lpfc_new_scsi_buf_s3 - Scsi buffer allocator for HBA with SLI3 IF spec
 512  * @vport: The virtual port for which this call being executed.
 513  * @num_to_allocate: The requested number of buffers to allocate.
 514  *
 515  * This routine allocates a scsi buffer for device with SLI-3 interface spec,
 516  * the scsi buffer contains all the necessary information needed to initiate
 517  * a SCSI I/O. The non-DMAable buffer region contains information to build
 518  * the IOCB. The DMAable region contains memory for the FCP CMND, FCP RSP,
 519  * and the initial BPL. In addition to allocating memory, the FCP CMND and
 520  * FCP RSP BDEs are setup in the BPL and the BPL BDE is setup in the IOCB.
 521  *
 522  * Return codes:
 523  *   int - number of scsi buffers that were allocated.
 524  *   0 = failure, less than num_to_alloc is a partial failure.
 525  **/
 526 static int
 527 lpfc_new_scsi_buf_s3(struct lpfc_vport *vport, int num_to_alloc)
 528 {
 529         struct lpfc_hba *phba = vport->phba;
 530         struct lpfc_scsi_buf *psb;
 531         struct ulp_bde64 *bpl;
 532         IOCB_t *iocb;
 533         dma_addr_t pdma_phys_fcp_cmd;
 534         dma_addr_t pdma_phys_fcp_rsp;
 535         dma_addr_t pdma_phys_bpl;
 536         uint16_t iotag;
 537         int bcnt;
 538
 539         for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
 540                 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
 541                 if (!psb)
 542                         break;
 543
 544                 /*
 545                  * Get memory from the pci pool to map the virt space to pci
 546                  * bus space for an I/O.  The DMA buffer includes space for the
 547                  * struct fcp_cmnd, struct fcp_rsp and the number of bde's
 548                  * necessary to support the sg_tablesize.
 549                  */
 550                 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool,
 551                                         GFP_KERNEL, &psb->dma_handle);
 552                 if (!psb->data) {
 553                         kfree(psb);
 554                         break;
 555                 }
 556
 557                 /* Initialize virtual ptrs to dma_buf region. */
 558                 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
 559
 560                 /* Allocate iotag for psb->cur_iocbq. */
 561                 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
 562                 if (iotag == 0) {
 563                         pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
 564                                         psb->data, psb->dma_handle);
 565                         kfree(psb);
 566                         break;
 567                 }
 568                 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
 569
 570                 psb->fcp_cmnd = psb->data;
 571                 psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd);
 572                 psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) +
 573                         sizeof(struct fcp_rsp);
 574
 575                 /* Initialize local short-hand pointers. */
 576                 bpl = psb->fcp_bpl;
 577                 pdma_phys_fcp_cmd = psb->dma_handle;
 578                 pdma_phys_fcp_rsp = psb->dma_handle + sizeof(struct fcp_cmnd);
 579                 pdma_phys_bpl = psb->dma_handle + sizeof(struct fcp_cmnd) +
 580                         sizeof(struct fcp_rsp);
 581
 582                 /*
 583                  * The first two bdes are the FCP_CMD and FCP_RSP. The balance
 584                  * are sg list bdes.  Initialize the first two and leave the
 585                  * rest for queuecommand.
 586                  */
 587                 bpl[0].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd));
 588                 bpl[0].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd));
 589                 bpl[0].tus.f.bdeSize = sizeof(struct fcp_cmnd);
 590                 bpl[0].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 591                 bpl[0].tus.w = le32_to_cpu(bpl[0].tus.w);
 592
 593                 /* Setup the physical region for the FCP RSP */
 594                 bpl[1].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp));
 595                 bpl[1].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp));
 596                 bpl[1].tus.f.bdeSize = sizeof(struct fcp_rsp);
 597                 bpl[1].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 598                 bpl[1].tus.w = le32_to_cpu(bpl[1].tus.w);
 599
 600                 /*
 601                  * Since the IOCB for the FCP I/O is built into this
 602                  * lpfc_scsi_buf, initialize it with all known data now.
 603                  */
 604                 iocb = &psb->cur_iocbq.iocb;
 605                 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
 606                 if ((phba->sli_rev == 3) &&
 607                                 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
 608                         /* fill in immediate fcp command BDE */
 609                         iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_IMMED;
 610                         iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
 611                         iocb->un.fcpi64.bdl.addrLow = offsetof(IOCB_t,
 612                                         unsli3.fcp_ext.icd);
 613                         iocb->un.fcpi64.bdl.addrHigh = 0;
 614                         iocb->ulpBdeCount = 0;
 615                         iocb->ulpLe = 0;
 616                         /* fill in response BDE */
 617                         iocb->unsli3.fcp_ext.rbde.tus.f.bdeFlags =
 618                                                         BUFF_TYPE_BDE_64;
 619                         iocb->unsli3.fcp_ext.rbde.tus.f.bdeSize =
 620                                 sizeof(struct fcp_rsp);
 621                         iocb->unsli3.fcp_ext.rbde.addrLow =
 622                                 putPaddrLow(pdma_phys_fcp_rsp);
 623                         iocb->unsli3.fcp_ext.rbde.addrHigh =
 624                                 putPaddrHigh(pdma_phys_fcp_rsp);
 625                 } else {
 626                         iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
 627                         iocb->un.fcpi64.bdl.bdeSize =
 628                                         (2 * sizeof(struct ulp_bde64));
 629                         iocb->un.fcpi64.bdl.addrLow =
 630                                         putPaddrLow(pdma_phys_bpl);
 631                         iocb->un.fcpi64.bdl.addrHigh =
 632                                         putPaddrHigh(pdma_phys_bpl);
 633                         iocb->ulpBdeCount = 1;
 634                         iocb->ulpLe = 1;
 635                 }
 636                 iocb->ulpClass = CLASS3;
 637                 psb->status = IOSTAT_SUCCESS;
 638                 /* Put it back into the SCSI buffer list */
 639                 psb->cur_iocbq.context1  = psb;
 640                 lpfc_release_scsi_buf_s3(phba, psb);
 641
 642         }
 643
 644         return bcnt;
 645 }
 646
 647 /**
 648  * lpfc_sli4_vport_delete_fcp_xri_aborted -Remove all ndlp references for vport
 649  * @vport: pointer to lpfc vport data structure.
 650  *
 651  * This routine is invoked by the vport cleanup for deletions and the cleanup
 652  * for an ndlp on removal.
 653  **/
 654 void
 655 lpfc_sli4_vport_delete_fcp_xri_aborted(struct lpfc_vport *vport)
 656 {
 657         struct lpfc_hba *phba = vport->phba;
 658         struct lpfc_scsi_buf *psb, *next_psb;
 659         unsigned long iflag = 0;
 660
 661         spin_lock_irqsave(&phba->hbalock, iflag);
 662         spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
 663         list_for_each_entry_safe(psb, next_psb,
 664                                 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) {
 665                 if (psb->rdata && psb->rdata->pnode
 666                         && psb->rdata->pnode->vport == vport)
 667                         psb->rdata = NULL;
 668         }
 669         spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
 670         spin_unlock_irqrestore(&phba->hbalock, iflag);
 671 }
 672
 673 /**
 674  * lpfc_sli4_fcp_xri_aborted - Fast-path process of fcp xri abort
 675  * @phba: pointer to lpfc hba data structure.
 676  * @axri: pointer to the fcp xri abort wcqe structure.
 677  *
 678  * This routine is invoked by the worker thread to process a SLI4 fast-path
 679  * FCP aborted xri.
 680  **/
 681 void
 682 lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
 683                           struct sli4_wcqe_xri_aborted *axri)
 684 {
 685         uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
 686         uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);
 687         struct lpfc_scsi_buf *psb, *next_psb;
 688         unsigned long iflag = 0;
 689         struct lpfc_iocbq *iocbq;
 690         int i;
 691         struct lpfc_nodelist *ndlp;
 692         int rrq_empty = 0;
 693         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
 694
 695         spin_lock_irqsave(&phba->hbalock, iflag);
 696         spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
 697         list_for_each_entry_safe(psb, next_psb,
 698                 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) {
 699                 if (psb->cur_iocbq.sli4_xritag == xri) {
 700                         list_del(&psb->list);
 701                         psb->exch_busy = 0;
 702                         psb->status = IOSTAT_SUCCESS;
 703                         spin_unlock(
 704                                 &phba->sli4_hba.abts_scsi_buf_list_lock);
 705                         if (psb->rdata && psb->rdata->pnode)
 706                                 ndlp = psb->rdata->pnode;
 707                         else
 708                                 ndlp = NULL;
 709
 710                         rrq_empty = list_empty(&phba->active_rrq_list);
 711                         spin_unlock_irqrestore(&phba->hbalock, iflag);
 712                         if (ndlp) {
 713                                 lpfc_set_rrq_active(phba, ndlp,
 714                                         psb->cur_iocbq.sli4_lxritag, rxid, 1);
 715                                 lpfc_sli4_abts_err_handler(phba, ndlp, axri);
 716                         }
 717                         lpfc_release_scsi_buf_s4(phba, psb);
 718                         if (rrq_empty)
 719                                 lpfc_worker_wake_up(phba);
 720                         return;
 721                 }
 722         }
 723         spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
 724         for (i = 1; i <= phba->sli.last_iotag; i++) {
 725                 iocbq = phba->sli.iocbq_lookup[i];
 726
 727                 if (!(iocbq->iocb_flag &  LPFC_IO_FCP) ||
 728                         (iocbq->iocb_flag & LPFC_IO_LIBDFC))
 729                         continue;
 730                 if (iocbq->sli4_xritag != xri)
 731                         continue;
 732                 psb = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
 733                 psb->exch_busy = 0;
 734                 spin_unlock_irqrestore(&phba->hbalock, iflag);
 735                 if (!list_empty(&pring->txq))
 736                         lpfc_worker_wake_up(phba);
 737                 return;
 738
 739         }
 740         spin_unlock_irqrestore(&phba->hbalock, iflag);
 741 }
 742
 743 /**
 744  * lpfc_sli4_post_scsi_sgl_list - Psot blocks of scsi buffer sgls from a list
 745  * @phba: pointer to lpfc hba data structure.
 746  * @post_sblist: pointer to the scsi buffer list.
 747  *
 748  * This routine walks a list of scsi buffers that was passed in. It attempts
 749  * to construct blocks of scsi buffer sgls which contains contiguous xris and
 750  * uses the non-embedded SGL block post mailbox commands to post to the port.
 751  * For single SCSI buffer sgl with non-contiguous xri, if any, it shall use
 752  * embedded SGL post mailbox command for posting. The @post_sblist passed in
 753  * must be local list, thus no lock is needed when manipulate the list.
 754  *
 755  * Returns: 0 = failure, non-zero number of successfully posted buffers.
 756  **/
 757 int
 758 lpfc_sli4_post_scsi_sgl_list(struct lpfc_hba *phba,
 759                              struct list_head *post_sblist, int sb_count)
 760 {
 761         struct lpfc_scsi_buf *psb, *psb_next;
 762         int status;
 763         int post_cnt = 0, block_cnt = 0, num_posting = 0, num_posted = 0;
 764         dma_addr_t pdma_phys_bpl1;
 765         int last_xritag = NO_XRI;
 766         LIST_HEAD(prep_sblist);
 767         LIST_HEAD(blck_sblist);
 768         LIST_HEAD(scsi_sblist);
 769
 770         /* sanity check */
 771         if (sb_count <= 0)
 772                 return -EINVAL;
 773
 774         list_for_each_entry_safe(psb, psb_next, post_sblist, list) {
 775                 list_del_init(&psb->list);
 776                 block_cnt++;
 777                 if ((last_xritag != NO_XRI) &&
 778                     (psb->cur_iocbq.sli4_xritag != last_xritag + 1)) {
 779                         /* a hole in xri block, form a sgl posting block */
 780                         list_splice_init(&prep_sblist, &blck_sblist);
 781                         post_cnt = block_cnt - 1;
 782                         /* prepare list for next posting block */
 783                         list_add_tail(&psb->list, &prep_sblist);
 784                         block_cnt = 1;
 785                 } else {
 786                         /* prepare list for next posting block */
 787                         list_add_tail(&psb->list, &prep_sblist);
 788                         /* enough sgls for non-embed sgl mbox command */
 789                         if (block_cnt == LPFC_NEMBED_MBOX_SGL_CNT) {
 790                                 list_splice_init(&prep_sblist, &blck_sblist);
 791                                 post_cnt = block_cnt;
 792                                 block_cnt = 0;
 793                         }
 794                 }
 795                 num_posting++;
 796                 last_xritag = psb->cur_iocbq.sli4_xritag;
 797
 798                 /* end of repost sgl list condition for SCSI buffers */
 799                 if (num_posting == sb_count) {
 800                         if (post_cnt == 0) {
 801                                 /* last sgl posting block */
 802                                 list_splice_init(&prep_sblist, &blck_sblist);
 803                                 post_cnt = block_cnt;
 804                         } else if (block_cnt == 1) {
 805                                 /* last single sgl with non-contiguous xri */
 806                                 if (phba->cfg_sg_dma_buf_size > SGL_PAGE_SIZE)
 807                                         pdma_phys_bpl1 = psb->dma_phys_bpl +
 808                                                                 SGL_PAGE_SIZE;
 809                                 else
 810                                         pdma_phys_bpl1 = 0;
 811                                 status = lpfc_sli4_post_sgl(phba,
 812                                                 psb->dma_phys_bpl,
 813                                                 pdma_phys_bpl1,
 814                                                 psb->cur_iocbq.sli4_xritag);
 815                                 if (status) {
 816                                         /* failure, put on abort scsi list */
 817                                         psb->exch_busy = 1;
 818                                 } else {
 819                                         /* success, put on SCSI buffer list */
 820                                         psb->exch_busy = 0;
 821                                         psb->status = IOSTAT_SUCCESS;
 822                                         num_posted++;
 823                                 }
 824                                 /* success, put on SCSI buffer sgl list */
 825                                 list_add_tail(&psb->list, &scsi_sblist);
 826                         }
 827                 }
 828
 829                 /* continue until a nembed page worth of sgls */
 830                 if (post_cnt == 0)
 831                         continue;
 832
 833                 /* post block of SCSI buffer list sgls */
 834                 status = lpfc_sli4_post_scsi_sgl_block(phba, &blck_sblist,
 835                                                        post_cnt);
 836
 837                 /* don't reset xirtag due to hole in xri block */
 838                 if (block_cnt == 0)
 839                         last_xritag = NO_XRI;
 840
 841                 /* reset SCSI buffer post count for next round of posting */
 842                 post_cnt = 0;
 843
 844                 /* put posted SCSI buffer-sgl posted on SCSI buffer sgl list */
 845                 while (!list_empty(&blck_sblist)) {
 846                         list_remove_head(&blck_sblist, psb,
 847                                          struct lpfc_scsi_buf, list);
 848                         if (status) {
 849                                 /* failure, put on abort scsi list */
 850                                 psb->exch_busy = 1;
 851                         } else {
 852                                 /* success, put on SCSI buffer list */
 853                                 psb->exch_busy = 0;
 854                                 psb->status = IOSTAT_SUCCESS;
 855                                 num_posted++;
 856                         }
 857                         list_add_tail(&psb->list, &scsi_sblist);
 858                 }
 859         }
 860         /* Push SCSI buffers with sgl posted to the availble list */
 861         while (!list_empty(&scsi_sblist)) {
 862                 list_remove_head(&scsi_sblist, psb,
 863                                  struct lpfc_scsi_buf, list);
 864                 lpfc_release_scsi_buf_s4(phba, psb);
 865         }
 866         return num_posted;
 867 }
 868
 869 /**
 870  * lpfc_sli4_repost_scsi_sgl_list - Repsot all the allocated scsi buffer sgls
 871  * @phba: pointer to lpfc hba data structure.
 872  *
 873  * This routine walks the list of scsi buffers that have been allocated and
 874  * repost them to the port by using SGL block post. This is needed after a
 875  * pci_function_reset/warm_start or start. The lpfc_hba_down_post_s4 routine
 876  * is responsible for moving all scsi buffers on the lpfc_abts_scsi_sgl_list
 877  * to the lpfc_scsi_buf_list. If the repost fails, reject all scsi buffers.
 878  *
 879  * Returns: 0 = success, non-zero failure.
 880  **/
 881 int
 882 lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
 883 {
 884         LIST_HEAD(post_sblist);
 885         int num_posted, rc = 0;
 886
 887         /* get all SCSI buffers need to repost to a local list */
 888         spin_lock_irq(&phba->scsi_buf_list_lock);
 889         list_splice_init(&phba->lpfc_scsi_buf_list, &post_sblist);
 890         spin_unlock_irq(&phba->scsi_buf_list_lock);
 891
 892         /* post the list of scsi buffer sgls to port if available */
 893         if (!list_empty(&post_sblist)) {
 894                 num_posted = lpfc_sli4_post_scsi_sgl_list(phba, &post_sblist,
 895                                                 phba->sli4_hba.scsi_xri_cnt);
 896                 /* failed to post any scsi buffer, return error */
 897                 if (num_posted == 0)
 898                         rc = -EIO;
 899         }
 900         return rc;
 901 }
 902
 903 /**
 904  * lpfc_new_scsi_buf_s4 - Scsi buffer allocator for HBA with SLI4 IF spec
 905  * @vport: The virtual port for which this call being executed.
 906  * @num_to_allocate: The requested number of buffers to allocate.
 907  *
 908  * This routine allocates scsi buffers for device with SLI-4 interface spec,
 909  * the scsi buffer contains all the necessary information needed to initiate
 910  * a SCSI I/O. After allocating up to @num_to_allocate SCSI buffers and put
 911  * them on a list, it post them to the port by using SGL block post.
 912  *
 913  * Return codes:
 914  *   int - number of scsi buffers that were allocated and posted.
 915  *   0 = failure, less than num_to_alloc is a partial failure.
 916  **/
 917 static int
 918 lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
 919 {
 920         struct lpfc_hba *phba = vport->phba;
 921         struct lpfc_scsi_buf *psb;
 922         struct sli4_sge *sgl;
 923         IOCB_t *iocb;
 924         dma_addr_t pdma_phys_fcp_cmd;
 925         dma_addr_t pdma_phys_fcp_rsp;
 926         dma_addr_t pdma_phys_bpl, pdma_phys_bpl1;
 927         uint16_t iotag, lxri = 0;
 928         int bcnt, num_posted;
 929         LIST_HEAD(prep_sblist);
 930         LIST_HEAD(post_sblist);
 931         LIST_HEAD(scsi_sblist);
 932
 933         for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
 934                 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
 935                 if (!psb)
 936                         break;
 937                 /*
 938                  * Get memory from the pci pool to map the virt space to
 939                  * pci bus space for an I/O. The DMA buffer includes space
 940                  * for the struct fcp_cmnd, struct fcp_rsp and the number
 941                  * of bde's necessary to support the sg_tablesize.
 942                  */
 943                 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool,
 944                                                 GFP_KERNEL, &psb->dma_handle);
 945                 if (!psb->data) {
 946                         kfree(psb);
 947                         break;
 948                 }
 949                 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
 950
 951                 /* Allocate iotag for psb->cur_iocbq. */
 952                 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
 953                 if (iotag == 0) {
 954                         pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
 955                                 psb->data, psb->dma_handle);
 956                         kfree(psb);
 957                         break;
 958                 }
 959
 960                 lxri = lpfc_sli4_next_xritag(phba);
 961                 if (lxri == NO_XRI) {
 962                         pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
 963                               psb->data, psb->dma_handle);
 964                         kfree(psb);
 965                         break;
 966                 }
 967                 psb->cur_iocbq.sli4_lxritag = lxri;
 968                 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
 969                 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
 970                 psb->fcp_bpl = psb->data;
 971                 psb->fcp_cmnd = (psb->data + phba->cfg_sg_dma_buf_size)
 972                         - (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
 973                 psb->fcp_rsp = (struct fcp_rsp *)((uint8_t *)psb->fcp_cmnd +
 974                                         sizeof(struct fcp_cmnd));
 975
 976                 /* Initialize local short-hand pointers. */
 977                 sgl = (struct sli4_sge *)psb->fcp_bpl;
 978                 pdma_phys_bpl = psb->dma_handle;
 979                 pdma_phys_fcp_cmd =
 980                         (psb->dma_handle + phba->cfg_sg_dma_buf_size)
 981                          - (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
 982                 pdma_phys_fcp_rsp = pdma_phys_fcp_cmd + sizeof(struct fcp_cmnd);
 983
 984                 /*
 985                  * The first two bdes are the FCP_CMD and FCP_RSP.
 986                  * The balance are sg list bdes. Initialize the
 987                  * first two and leave the rest for queuecommand.
 988                  */
 989                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd));
 990                 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd));
 991                 sgl->word2 = le32_to_cpu(sgl->word2);
 992                 bf_set(lpfc_sli4_sge_last, sgl, 0);
 993                 sgl->word2 = cpu_to_le32(sgl->word2);
 994                 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_cmnd));
 995                 sgl++;
 996
 997                 /* Setup the physical region for the FCP RSP */
 998                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_rsp));
 999                 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_rsp));
1000                 sgl->word2 = le32_to_cpu(sgl->word2);
1001                 bf_set(lpfc_sli4_sge_last, sgl, 1);
1002                 sgl->word2 = cpu_to_le32(sgl->word2);
1003                 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_rsp));
1004
1005                 /*
1006                  * Since the IOCB for the FCP I/O is built into this
1007                  * lpfc_scsi_buf, initialize it with all known data now.
1008                  */
1009                 iocb = &psb->cur_iocbq.iocb;
1010                 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
1011                 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_64;
1012                 /* setting the BLP size to 2 * sizeof BDE may not be correct.
1013                  * We are setting the bpl to point to out sgl. An sgl's
1014                  * entries are 16 bytes, a bpl entries are 12 bytes.
1015                  */
1016                 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
1017                 iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys_fcp_cmd);
1018                 iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys_fcp_cmd);
1019                 iocb->ulpBdeCount = 1;
1020                 iocb->ulpLe = 1;
1021                 iocb->ulpClass = CLASS3;
1022                 psb->cur_iocbq.context1 = psb;
1023                 if (phba->cfg_sg_dma_buf_size > SGL_PAGE_SIZE)
1024                         pdma_phys_bpl1 = pdma_phys_bpl + SGL_PAGE_SIZE;
1025                 else
1026                         pdma_phys_bpl1 = 0;
1027                 psb->dma_phys_bpl = pdma_phys_bpl;
1028
1029                 /* add the scsi buffer to a post list */
1030                 list_add_tail(&psb->list, &post_sblist);
1031                 spin_lock_irq(&phba->scsi_buf_list_lock);
1032                 phba->sli4_hba.scsi_xri_cnt++;
1033                 spin_unlock_irq(&phba->scsi_buf_list_lock);
1034         }
1035         lpfc_printf_log(phba, KERN_INFO, LOG_BG,
1036                         "3021 Allocate %d out of %d requested new SCSI "
1037                         "buffers\n", bcnt, num_to_alloc);
1038
1039         /* post the list of scsi buffer sgls to port if available */
1040         if (!list_empty(&post_sblist))
1041                 num_posted = lpfc_sli4_post_scsi_sgl_list(phba,
1042                                                           &post_sblist, bcnt);
1043         else
1044                 num_posted = 0;
1045
1046         return num_posted;
1047 }
1048
1049 /**
1050  * lpfc_new_scsi_buf - Wrapper funciton for scsi buffer allocator
1051  * @vport: The virtual port for which this call being executed.
1052  * @num_to_allocate: The requested number of buffers to allocate.
1053  *
1054  * This routine wraps the actual SCSI buffer allocator function pointer from
1055  * the lpfc_hba struct.
1056  *
1057  * Return codes:
1058  *   int - number of scsi buffers that were allocated.
1059  *   0 = failure, less than num_to_alloc is a partial failure.
1060  **/
1061 static inline int
1062 lpfc_new_scsi_buf(struct lpfc_vport *vport, int num_to_alloc)
1063 {
1064         return vport->phba->lpfc_new_scsi_buf(vport, num_to_alloc);
1065 }
1066
1067 /**
1068  * lpfc_get_scsi_buf_s3 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
1069  * @phba: The HBA for which this call is being executed.
1070  *
1071  * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
1072  * and returns to caller.
1073  *
1074  * Return codes:
1075  *   NULL - Error
1076  *   Pointer to lpfc_scsi_buf - Success
1077  **/
1078 static struct lpfc_scsi_buf*
1079 lpfc_get_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
1080 {
1081         struct  lpfc_scsi_buf * lpfc_cmd = NULL;
1082         struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
1083         unsigned long iflag = 0;
1084
1085         spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
1086         list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
1087         if (lpfc_cmd) {
1088                 lpfc_cmd->seg_cnt = 0;
1089                 lpfc_cmd->nonsg_phys = 0;
1090                 lpfc_cmd->prot_seg_cnt = 0;
1091         }
1092         spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
1093         return  lpfc_cmd;
1094 }
1095 /**
1096  * lpfc_get_scsi_buf_s4 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
1097  * @phba: The HBA for which this call is being executed.
1098  *
1099  * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
1100  * and returns to caller.
1101  *
1102  * Return codes:
1103  *   NULL - Error
1104  *   Pointer to lpfc_scsi_buf - Success
1105  **/
1106 static struct lpfc_scsi_buf*
1107 lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
1108 {
1109         struct lpfc_scsi_buf *lpfc_cmd ;
1110         unsigned long iflag = 0;
1111         int found = 0;
1112
1113         spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
1114         list_for_each_entry(lpfc_cmd, &phba->lpfc_scsi_buf_list,
1115                                                         list) {
1116                 if (lpfc_test_rrq_active(phba, ndlp,
1117                                          lpfc_cmd->cur_iocbq.sli4_lxritag))
1118                         continue;
1119                 list_del(&lpfc_cmd->list);
1120                 found = 1;
1121                 lpfc_cmd->seg_cnt = 0;
1122                 lpfc_cmd->nonsg_phys = 0;
1123                 lpfc_cmd->prot_seg_cnt = 0;
1124                 break;
1125         }
1126         spin_unlock_irqrestore(&phba->scsi_buf_list_lock,
1127                                                  iflag);
1128         if (!found)
1129                 return NULL;
1130         else
1131                 return  lpfc_cmd;
1132 }
1133 /**
1134  * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
1135  * @phba: The HBA for which this call is being executed.
1136  *
1137  * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
1138  * and returns to caller.
1139  *
1140  * Return codes:
1141  *   NULL - Error
1142  *   Pointer to lpfc_scsi_buf - Success
1143  **/
1144 static struct lpfc_scsi_buf*
1145 lpfc_get_scsi_buf(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
1146 {
1147         return  phba->lpfc_get_scsi_buf(phba, ndlp);
1148 }
1149
1150 /**
1151  * lpfc_release_scsi_buf - Return a scsi buffer back to hba scsi buf list
1152  * @phba: The Hba for which this call is being executed.
1153  * @psb: The scsi buffer which is being released.
1154  *
1155  * This routine releases @psb scsi buffer by adding it to tail of @phba
1156  * lpfc_scsi_buf_list list.
1157  **/
1158 static void
1159 lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1160 {
1161         unsigned long iflag = 0;
1162
1163         spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
1164         psb->pCmd = NULL;
1165         list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list);
1166         spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
1167 }
1168
1169 /**
1170  * lpfc_release_scsi_buf_s4: Return a scsi buffer back to hba scsi buf list.
1171  * @phba: The Hba for which this call is being executed.
1172  * @psb: The scsi buffer which is being released.
1173  *
1174  * This routine releases @psb scsi buffer by adding it to tail of @phba
1175  * lpfc_scsi_buf_list list. For SLI4 XRI's are tied to the scsi buffer
1176  * and cannot be reused for at least RA_TOV amount of time if it was
1177  * aborted.
1178  **/
1179 static void
1180 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1181 {
1182         unsigned long iflag = 0;
1183
1184         if (psb->exch_busy) {
1185                 spin_lock_irqsave(&phba->sli4_hba.abts_scsi_buf_list_lock,
1186                                         iflag);
1187                 psb->pCmd = NULL;
1188                 list_add_tail(&psb->list,
1189                         &phba->sli4_hba.lpfc_abts_scsi_buf_list);
1190                 spin_unlock_irqrestore(&phba->sli4_hba.abts_scsi_buf_list_lock,
1191                                         iflag);
1192         } else {
1193
1194                 spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
1195                 psb->pCmd = NULL;
1196                 list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list);
1197                 spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
1198         }
1199 }
1200
1201 /**
1202  * lpfc_release_scsi_buf: Return a scsi buffer back to hba scsi buf list.
1203  * @phba: The Hba for which this call is being executed.
1204  * @psb: The scsi buffer which is being released.
1205  *
1206  * This routine releases @psb scsi buffer by adding it to tail of @phba
1207  * lpfc_scsi_buf_list list.
1208  **/
1209 static void
1210 lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1211 {
1212
1213         phba->lpfc_release_scsi_buf(phba, psb);
1214 }
1215
1216 /**
1217  * lpfc_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec
1218  * @phba: The Hba for which this call is being executed.
1219  * @lpfc_cmd: The scsi buffer which is going to be mapped.
1220  *
1221  * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
1222  * field of @lpfc_cmd for device with SLI-3 interface spec. This routine scans
1223  * through sg elements and format the bdea. This routine also initializes all
1224  * IOCB fields which are dependent on scsi command request buffer.
1225  *
1226  * Return codes:
1227  *   1 - Error
1228  *   0 - Success
1229  **/
1230 static int
1231 lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
1232 {
1233         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
1234         struct scatterlist *sgel = NULL;
1235         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
1236         struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
1237         struct lpfc_iocbq *iocbq = &lpfc_cmd->cur_iocbq;
1238         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
1239         struct ulp_bde64 *data_bde = iocb_cmd->unsli3.fcp_ext.dbde;
1240         dma_addr_t physaddr;
1241         uint32_t num_bde = 0;
1242         int nseg, datadir = scsi_cmnd->sc_data_direction;
1243
1244         /*
1245          * There are three possibilities here - use scatter-gather segment, use
1246          * the single mapping, or neither.  Start the lpfc command prep by
1247          * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
1248          * data bde entry.
1249          */
1250         bpl += 2;
1251         if (scsi_sg_count(scsi_cmnd)) {
1252                 /*
1253                  * The driver stores the segment count returned from pci_map_sg
1254                  * because this a count of dma-mappings used to map the use_sg
1255                  * pages.  They are not guaranteed to be the same for those
1256                  * architectures that implement an IOMMU.
1257                  */
1258
1259                 nseg = dma_map_sg(&phba->pcidev->dev, scsi_sglist(scsi_cmnd),
1260                                   scsi_sg_count(scsi_cmnd), datadir);
1261                 if (unlikely(!nseg))
1262                         return 1;
1263
1264                 lpfc_cmd->seg_cnt = nseg;
1265                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
1266                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1267                                 "9064 BLKGRD: %s: Too many sg segments from "
1268                                "dma_map_sg.  Config %d, seg_cnt %d\n",
1269                                __func__, phba->cfg_sg_seg_cnt,
1270                                lpfc_cmd->seg_cnt);
1271                         scsi_dma_unmap(scsi_cmnd);
1272                         return 1;
1273                 }
1274
1275                 /*
1276                  * The driver established a maximum scatter-gather segment count
1277                  * during probe that limits the number of sg elements in any
1278                  * single scsi command.  Just run through the seg_cnt and format
1279                  * the bde's.
1280                  * When using SLI-3 the driver will try to fit all the BDEs into
1281                  * the IOCB. If it can't then the BDEs get added to a BPL as it
1282                  * does for SLI-2 mode.
1283                  */
1284                 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
1285                         physaddr = sg_dma_address(sgel);
1286                         if (phba->sli_rev == 3 &&
1287                             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
1288                             !(iocbq->iocb_flag & DSS_SECURITY_OP) &&
1289                             nseg <= LPFC_EXT_DATA_BDE_COUNT) {
1290                                 data_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1291                                 data_bde->tus.f.bdeSize = sg_dma_len(sgel);
1292                                 data_bde->addrLow = putPaddrLow(physaddr);
1293                                 data_bde->addrHigh = putPaddrHigh(physaddr);
1294                                 data_bde++;
1295                         } else {
1296                                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1297                                 bpl->tus.f.bdeSize = sg_dma_len(sgel);
1298                                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1299                                 bpl->addrLow =
1300                                         le32_to_cpu(putPaddrLow(physaddr));
1301                                 bpl->addrHigh =
1302                                         le32_to_cpu(putPaddrHigh(physaddr));
1303                                 bpl++;
1304                         }
1305                 }
1306         }
1307
1308         /*
1309          * Finish initializing those IOCB fields that are dependent on the
1310          * scsi_cmnd request_buffer.  Note that for SLI-2 the bdeSize is
1311          * explicitly reinitialized and for SLI-3 the extended bde count is
1312          * explicitly reinitialized since all iocb memory resources are reused.
1313          */
1314         if (phba->sli_rev == 3 &&
1315             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
1316             !(iocbq->iocb_flag & DSS_SECURITY_OP)) {
1317                 if (num_bde > LPFC_EXT_DATA_BDE_COUNT) {
1318                         /*
1319                          * The extended IOCB format can only fit 3 BDE or a BPL.
1320                          * This I/O has more than 3 BDE so the 1st data bde will
1321                          * be a BPL that is filled in here.
1322                          */
1323                         physaddr = lpfc_cmd->dma_handle;
1324                         data_bde->tus.f.bdeFlags = BUFF_TYPE_BLP_64;
1325                         data_bde->tus.f.bdeSize = (num_bde *
1326                                                    sizeof(struct ulp_bde64));
1327                         physaddr += (sizeof(struct fcp_cmnd) +
1328                                      sizeof(struct fcp_rsp) +
1329                                      (2 * sizeof(struct ulp_bde64)));
1330                         data_bde->addrHigh = putPaddrHigh(physaddr);
1331                         data_bde->addrLow = putPaddrLow(physaddr);
1332                         /* ebde count includes the response bde and data bpl */
1333                         iocb_cmd->unsli3.fcp_ext.ebde_count = 2;
1334                 } else {
1335                         /* ebde count includes the response bde and data bdes */
1336                         iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
1337                 }
1338         } else {
1339                 iocb_cmd->un.fcpi64.bdl.bdeSize =
1340                         ((num_bde + 2) * sizeof(struct ulp_bde64));
1341                 iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
1342         }
1343         fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
1344
1345         /*
1346          * Due to difference in data length between DIF/non-DIF paths,
1347          * we need to set word 4 of IOCB here
1348          */
1349         iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
1350         return 0;
1351 }
1352
1353 static inline unsigned
1354 lpfc_cmd_blksize(struct scsi_cmnd *sc)
1355 {
1356         return sc->device->sector_size;
1357 }
1358
1359 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1360
1361 /* Return if if error injection is detected by Initiator */
1362 #define BG_ERR_INIT     0x1
1363 /* Return if if error injection is detected by Target */
1364 #define BG_ERR_TGT      0x2
1365 /* Return if if swapping CSUM<-->CRC is required for error injection */
1366 #define BG_ERR_SWAP     0x10
1367 /* Return if disabling Guard/Ref/App checking is required for error injection */
1368 #define BG_ERR_CHECK    0x20
1369
1370 /**
1371  * lpfc_bg_err_inject - Determine if we should inject an error
1372  * @phba: The Hba for which this call is being executed.
1373  * @sc: The SCSI command to examine
1374  * @reftag: (out) BlockGuard reference tag for transmitted data
1375  * @apptag: (out) BlockGuard application tag for transmitted data
1376  * @new_guard (in) Value to replace CRC with if needed
1377  *
1378  * Returns BG_ERR_* bit mask or 0 if request ignored
1379  **/
1380 static int
1381 lpfc_bg_err_inject(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1382                 uint32_t *reftag, uint16_t *apptag, uint32_t new_guard)
1383 {
1384         struct scatterlist *sgpe; /* s/g prot entry */
1385         struct scatterlist *sgde; /* s/g data entry */
1386         struct lpfc_scsi_buf *lpfc_cmd = NULL;
1387         struct scsi_dif_tuple *src = NULL;
1388         struct lpfc_nodelist *ndlp;
1389         struct lpfc_rport_data *rdata;
1390         uint32_t op = scsi_get_prot_op(sc);
1391         uint32_t blksize;
1392         uint32_t numblks;
1393         sector_t lba;
1394         int rc = 0;
1395         int blockoff = 0;
1396
1397         if (op == SCSI_PROT_NORMAL)
1398                 return 0;
1399
1400         sgpe = scsi_prot_sglist(sc);
1401         sgde = scsi_sglist(sc);
1402         lba = scsi_get_lba(sc);
1403
1404         /* First check if we need to match the LBA */
1405         if (phba->lpfc_injerr_lba != LPFC_INJERR_LBA_OFF) {
1406                 blksize = lpfc_cmd_blksize(sc);
1407                 numblks = (scsi_bufflen(sc) + blksize - 1) / blksize;
1408
1409                 /* Make sure we have the right LBA if one is specified */
1410                 if ((phba->lpfc_injerr_lba < lba) ||
1411                         (phba->lpfc_injerr_lba >= (lba + numblks)))
1412                         return 0;
1413                 if (sgpe) {
1414                         blockoff = phba->lpfc_injerr_lba - lba;
1415                         numblks = sg_dma_len(sgpe) /
1416                                 sizeof(struct scsi_dif_tuple);
1417                         if (numblks < blockoff)
1418                                 blockoff = numblks;
1419                 }
1420         }
1421
1422         /* Next check if we need to match the remote NPortID or WWPN */
1423         rdata = sc->device->hostdata;
1424         if (rdata && rdata->pnode) {
1425                 ndlp = rdata->pnode;
1426
1427                 /* Make sure we have the right NPortID if one is specified */
1428                 if (phba->lpfc_injerr_nportid  &&
1429                         (phba->lpfc_injerr_nportid != ndlp->nlp_DID))
1430                         return 0;
1431
1432                 /*
1433                  * Make sure we have the right WWPN if one is specified.
1434                  * wwn[0] should be a non-zero NAA in a good WWPN.
1435                  */
1436                 if (phba->lpfc_injerr_wwpn.u.wwn[0]  &&
1437                         (memcmp(&ndlp->nlp_portname, &phba->lpfc_injerr_wwpn,
1438                                 sizeof(struct lpfc_name)) != 0))
1439                         return 0;
1440         }
1441
1442         /* Setup a ptr to the protection data if the SCSI host provides it */
1443         if (sgpe) {
1444                 src = (struct scsi_dif_tuple *)sg_virt(sgpe);
1445                 src += blockoff;
1446                 lpfc_cmd = (struct lpfc_scsi_buf *)sc->host_scribble;
1447         }
1448
1449         /* Should we change the Reference Tag */
1450         if (reftag) {
1451                 if (phba->lpfc_injerr_wref_cnt) {
1452                         switch (op) {
1453                         case SCSI_PROT_WRITE_PASS:
1454                                 if (src) {
1455                                         /*
1456                                          * For WRITE_PASS, force the error
1457                                          * to be sent on the wire. It should
1458                                          * be detected by the Target.
1459                                          * If blockoff != 0 error will be
1460                                          * inserted in middle of the IO.
1461                                          */
1462
1463                                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1464                                         "9076 BLKGRD: Injecting reftag error: "
1465                                         "write lba x%lx + x%x oldrefTag x%x\n",
1466                                         (unsigned long)lba, blockoff,
1467                                         be32_to_cpu(src->ref_tag));
1468
1469                                         /*
1470                                          * Save the old ref_tag so we can
1471                                          * restore it on completion.
1472                                          */
1473                                         if (lpfc_cmd) {
1474                                                 lpfc_cmd->prot_data_type =
1475                                                         LPFC_INJERR_REFTAG;
1476                                                 lpfc_cmd->prot_data_segment =
1477                                                         src;
1478                                                 lpfc_cmd->prot_data =
1479                                                         src->ref_tag;
1480                                         }
1481                                         src->ref_tag = cpu_to_be32(0xDEADBEEF);
1482                                         phba->lpfc_injerr_wref_cnt--;
1483                                         if (phba->lpfc_injerr_wref_cnt == 0) {
1484                                                 phba->lpfc_injerr_nportid = 0;
1485                                                 phba->lpfc_injerr_lba =
1486                                                         LPFC_INJERR_LBA_OFF;
1487                                                 memset(&phba->lpfc_injerr_wwpn,
1488                                                   0, sizeof(struct lpfc_name));
1489                                         }
1490                                         rc = BG_ERR_TGT | BG_ERR_CHECK;
1491
1492                                         break;
1493                                 }
1494                                 /* Drop thru */
1495                         case SCSI_PROT_WRITE_INSERT:
1496                                 /*
1497                                  * For WRITE_INSERT, force the error
1498                                  * to be sent on the wire. It should be
1499                                  * detected by the Target.
1500                                  */
1501                                 /* DEADBEEF will be the reftag on the wire */
1502                                 *reftag = 0xDEADBEEF;
1503                                 phba->lpfc_injerr_wref_cnt--;
1504                                 if (phba->lpfc_injerr_wref_cnt == 0) {
1505                                         phba->lpfc_injerr_nportid = 0;
1506                                         phba->lpfc_injerr_lba =
1507                                         LPFC_INJERR_LBA_OFF;
1508                                         memset(&phba->lpfc_injerr_wwpn,
1509                                                 0, sizeof(struct lpfc_name));
1510                                 }
1511                                 rc = BG_ERR_TGT | BG_ERR_CHECK;
1512
1513                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1514                                         "9078 BLKGRD: Injecting reftag error: "
1515                                         "write lba x%lx\n", (unsigned long)lba);
1516                                 break;
1517                         case SCSI_PROT_WRITE_STRIP:
1518                                 /*
1519                                  * For WRITE_STRIP and WRITE_PASS,
1520                                  * force the error on data
1521                                  * being copied from SLI-Host to SLI-Port.
1522                                  */
1523                                 *reftag = 0xDEADBEEF;
1524                                 phba->lpfc_injerr_wref_cnt--;
1525                                 if (phba->lpfc_injerr_wref_cnt == 0) {
1526                                         phba->lpfc_injerr_nportid = 0;
1527                                         phba->lpfc_injerr_lba =
1528                                                 LPFC_INJERR_LBA_OFF;
1529                                         memset(&phba->lpfc_injerr_wwpn,
1530                                                 0, sizeof(struct lpfc_name));
1531                                 }
1532                                 rc = BG_ERR_INIT;
1533
1534                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1535                                         "9077 BLKGRD: Injecting reftag error: "
1536                                         "write lba x%lx\n", (unsigned long)lba);
1537                                 break;
1538                         }
1539                 }
1540                 if (phba->lpfc_injerr_rref_cnt) {
1541                         switch (op) {
1542                         case SCSI_PROT_READ_INSERT:
1543                         case SCSI_PROT_READ_STRIP:
1544                         case SCSI_PROT_READ_PASS:
1545                                 /*
1546                                  * For READ_STRIP and READ_PASS, force the
1547                                  * error on data being read off the wire. It
1548                                  * should force an IO error to the driver.
1549                                  */
1550                                 *reftag = 0xDEADBEEF;
1551                                 phba->lpfc_injerr_rref_cnt--;
1552                                 if (phba->lpfc_injerr_rref_cnt == 0) {
1553                                         phba->lpfc_injerr_nportid = 0;
1554                                         phba->lpfc_injerr_lba =
1555                                                 LPFC_INJERR_LBA_OFF;
1556                                         memset(&phba->lpfc_injerr_wwpn,
1557                                                 0, sizeof(struct lpfc_name));
1558                                 }
1559                                 rc = BG_ERR_INIT;
1560
1561                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1562                                         "9079 BLKGRD: Injecting reftag error: "
1563                                         "read lba x%lx\n", (unsigned long)lba);
1564                                 break;
1565                         }
1566                 }
1567         }
1568
1569         /* Should we change the Application Tag */
1570         if (apptag) {
1571                 if (phba->lpfc_injerr_wapp_cnt) {
1572                         switch (op) {
1573                         case SCSI_PROT_WRITE_PASS:
1574                                 if (src) {
1575                                         /*
1576                                          * For WRITE_PASS, force the error
1577                                          * to be sent on the wire. It should
1578                                          * be detected by the Target.
1579                                          * If blockoff != 0 error will be
1580                                          * inserted in middle of the IO.
1581                                          */
1582
1583                                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1584                                         "9080 BLKGRD: Injecting apptag error: "
1585                                         "write lba x%lx + x%x oldappTag x%x\n",
1586                                         (unsigned long)lba, blockoff,
1587                                         be16_to_cpu(src->app_tag));
1588
1589                                         /*
1590                                          * Save the old app_tag so we can
1591                                          * restore it on completion.
1592                                          */
1593                                         if (lpfc_cmd) {
1594                                                 lpfc_cmd->prot_data_type =
1595                                                         LPFC_INJERR_APPTAG;
1596                                                 lpfc_cmd->prot_data_segment =
1597                                                         src;
1598                                                 lpfc_cmd->prot_data =
1599                                                         src->app_tag;
1600                                         }
1601                                         src->app_tag = cpu_to_be16(0xDEAD);
1602                                         phba->lpfc_injerr_wapp_cnt--;
1603                                         if (phba->lpfc_injerr_wapp_cnt == 0) {
1604                                                 phba->lpfc_injerr_nportid = 0;
1605                                                 phba->lpfc_injerr_lba =
1606                                                         LPFC_INJERR_LBA_OFF;
1607                                                 memset(&phba->lpfc_injerr_wwpn,
1608                                                   0, sizeof(struct lpfc_name));
1609                                         }
1610                                         rc = BG_ERR_TGT | BG_ERR_CHECK;
1611                                         break;
1612                                 }
1613                                 /* Drop thru */
1614                         case SCSI_PROT_WRITE_INSERT:
1615                                 /*
1616                                  * For WRITE_INSERT, force the
1617                                  * error to be sent on the wire. It should be
1618                                  * detected by the Target.
1619                                  */
1620                                 /* DEAD will be the apptag on the wire */
1621                                 *apptag = 0xDEAD;
1622                                 phba->lpfc_injerr_wapp_cnt--;
1623                                 if (phba->lpfc_injerr_wapp_cnt == 0) {
1624                                         phba->lpfc_injerr_nportid = 0;
1625                                         phba->lpfc_injerr_lba =
1626                                                 LPFC_INJERR_LBA_OFF;
1627                                         memset(&phba->lpfc_injerr_wwpn,
1628                                                 0, sizeof(struct lpfc_name));
1629                                 }
1630                                 rc = BG_ERR_TGT | BG_ERR_CHECK;
1631
1632                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1633                                         "0813 BLKGRD: Injecting apptag error: "
1634                                         "write lba x%lx\n", (unsigned long)lba);
1635                                 break;
1636                         case SCSI_PROT_WRITE_STRIP:
1637                                 /*
1638                                  * For WRITE_STRIP and WRITE_PASS,
1639                                  * force the error on data
1640                                  * being copied from SLI-Host to SLI-Port.
1641                                  */
1642                                 *apptag = 0xDEAD;
1643                                 phba->lpfc_injerr_wapp_cnt--;
1644                                 if (phba->lpfc_injerr_wapp_cnt == 0) {
1645                                         phba->lpfc_injerr_nportid = 0;
1646                                         phba->lpfc_injerr_lba =
1647                                                 LPFC_INJERR_LBA_OFF;
1648                                         memset(&phba->lpfc_injerr_wwpn,
1649                                                 0, sizeof(struct lpfc_name));
1650                                 }
1651                                 rc = BG_ERR_INIT;
1652
1653                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1654                                         "0812 BLKGRD: Injecting apptag error: "
1655                                         "write lba x%lx\n", (unsigned long)lba);
1656                                 break;
1657                         }
1658                 }
1659                 if (phba->lpfc_injerr_rapp_cnt) {
1660                         switch (op) {
1661                         case SCSI_PROT_READ_INSERT:
1662                         case SCSI_PROT_READ_STRIP:
1663                         case SCSI_PROT_READ_PASS:
1664                                 /*
1665                                  * For READ_STRIP and READ_PASS, force the
1666                                  * error on data being read off the wire. It
1667                                  * should force an IO error to the driver.
1668                                  */
1669                                 *apptag = 0xDEAD;
1670                                 phba->lpfc_injerr_rapp_cnt--;
1671                                 if (phba->lpfc_injerr_rapp_cnt == 0) {
1672                                         phba->lpfc_injerr_nportid = 0;
1673                                         phba->lpfc_injerr_lba =
1674                                                 LPFC_INJERR_LBA_OFF;
1675                                         memset(&phba->lpfc_injerr_wwpn,
1676                                                 0, sizeof(struct lpfc_name));
1677                                 }
1678                                 rc = BG_ERR_INIT;
1679
1680                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1681                                         "0814 BLKGRD: Injecting apptag error: "
1682                                         "read lba x%lx\n", (unsigned long)lba);
1683                                 break;
1684                         }
1685                 }
1686         }
1687
1688
1689         /* Should we change the Guard Tag */
1690         if (new_guard) {
1691                 if (phba->lpfc_injerr_wgrd_cnt) {
1692                         switch (op) {
1693                         case SCSI_PROT_WRITE_PASS:
1694                                 rc = BG_ERR_CHECK;
1695                                 /* Drop thru */
1696
1697                         case SCSI_PROT_WRITE_INSERT:
1698                                 /*
1699                                  * For WRITE_INSERT, force the
1700                                  * error to be sent on the wire. It should be
1701                                  * detected by the Target.
1702                                  */
1703                                 phba->lpfc_injerr_wgrd_cnt--;
1704                                 if (phba->lpfc_injerr_wgrd_cnt == 0) {
1705                                         phba->lpfc_injerr_nportid = 0;
1706                                         phba->lpfc_injerr_lba =
1707                                                 LPFC_INJERR_LBA_OFF;
1708                                         memset(&phba->lpfc_injerr_wwpn,
1709                                                 0, sizeof(struct lpfc_name));
1710                                 }
1711
1712                                 rc |= BG_ERR_TGT | BG_ERR_SWAP;
1713                                 /* Signals the caller to swap CRC->CSUM */
1714
1715                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1716                                         "0817 BLKGRD: Injecting guard error: "
1717                                         "write lba x%lx\n", (unsigned long)lba);
1718                                 break;
1719                         case SCSI_PROT_WRITE_STRIP:
1720                                 /*
1721                                  * For WRITE_STRIP and WRITE_PASS,
1722                                  * force the error on data
1723                                  * being copied from SLI-Host to SLI-Port.
1724                                  */
1725                                 phba->lpfc_injerr_wgrd_cnt--;
1726                                 if (phba->lpfc_injerr_wgrd_cnt == 0) {
1727                                         phba->lpfc_injerr_nportid = 0;
1728                                         phba->lpfc_injerr_lba =
1729                                                 LPFC_INJERR_LBA_OFF;
1730                                         memset(&phba->lpfc_injerr_wwpn,
1731                                                 0, sizeof(struct lpfc_name));
1732                                 }
1733
1734                                 rc = BG_ERR_INIT | BG_ERR_SWAP;
1735                                 /* Signals the caller to swap CRC->CSUM */
1736
1737                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1738                                         "0816 BLKGRD: Injecting guard error: "
1739                                         "write lba x%lx\n", (unsigned long)lba);
1740                                 break;
1741                         }
1742                 }
1743                 if (phba->lpfc_injerr_rgrd_cnt) {
1744                         switch (op) {
1745                         case SCSI_PROT_READ_INSERT:
1746                         case SCSI_PROT_READ_STRIP:
1747                         case SCSI_PROT_READ_PASS:
1748                                 /*
1749                                  * For READ_STRIP and READ_PASS, force the
1750                                  * error on data being read off the wire. It
1751                                  * should force an IO error to the driver.
1752                                  */
1753                                 phba->lpfc_injerr_rgrd_cnt--;
1754                                 if (phba->lpfc_injerr_rgrd_cnt == 0) {
1755                                         phba->lpfc_injerr_nportid = 0;
1756                                         phba->lpfc_injerr_lba =
1757                                                 LPFC_INJERR_LBA_OFF;
1758                                         memset(&phba->lpfc_injerr_wwpn,
1759                                                 0, sizeof(struct lpfc_name));
1760                                 }
1761
1762                                 rc = BG_ERR_INIT | BG_ERR_SWAP;
1763                                 /* Signals the caller to swap CRC->CSUM */
1764
1765                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1766                                         "0818 BLKGRD: Injecting guard error: "
1767                                         "read lba x%lx\n", (unsigned long)lba);
1768                         }
1769                 }
1770         }
1771
1772         return rc;
1773 }
1774 #endif
1775
1776 /**
1777  * lpfc_sc_to_bg_opcodes - Determine the BlockGuard opcodes to be used with
1778  * the specified SCSI command.
1779  * @phba: The Hba for which this call is being executed.
1780  * @sc: The SCSI command to examine
1781  * @txopt: (out) BlockGuard operation for transmitted data
1782  * @rxopt: (out) BlockGuard operation for received data
1783  *
1784  * Returns: zero on success; non-zero if tx and/or rx op cannot be determined
1785  *
1786  **/
1787 static int
1788 lpfc_sc_to_bg_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1789                 uint8_t *txop, uint8_t *rxop)
1790 {
1791         uint8_t guard_type = scsi_host_get_guard(sc->device->host);
1792         uint8_t ret = 0;
1793
1794         if (guard_type == SHOST_DIX_GUARD_IP) {
1795                 switch (scsi_get_prot_op(sc)) {
1796                 case SCSI_PROT_READ_INSERT:
1797                 case SCSI_PROT_WRITE_STRIP:
1798                         *rxop = BG_OP_IN_NODIF_OUT_CSUM;
1799                         *txop = BG_OP_IN_CSUM_OUT_NODIF;
1800                         break;
1801
1802                 case SCSI_PROT_READ_STRIP:
1803                 case SCSI_PROT_WRITE_INSERT:
1804                         *rxop = BG_OP_IN_CRC_OUT_NODIF;
1805                         *txop = BG_OP_IN_NODIF_OUT_CRC;
1806                         break;
1807
1808                 case SCSI_PROT_READ_PASS:
1809                 case SCSI_PROT_WRITE_PASS:
1810                         *rxop = BG_OP_IN_CRC_OUT_CSUM;
1811                         *txop = BG_OP_IN_CSUM_OUT_CRC;
1812                         break;
1813
1814                 case SCSI_PROT_NORMAL:
1815                 default:
1816                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1817                                 "9063 BLKGRD: Bad op/guard:%d/IP combination\n",
1818                                         scsi_get_prot_op(sc));
1819                         ret = 1;
1820                         break;
1821
1822                 }
1823         } else {
1824                 switch (scsi_get_prot_op(sc)) {
1825                 case SCSI_PROT_READ_STRIP:
1826                 case SCSI_PROT_WRITE_INSERT:
1827                         *rxop = BG_OP_IN_CRC_OUT_NODIF;
1828                         *txop = BG_OP_IN_NODIF_OUT_CRC;
1829                         break;
1830
1831                 case SCSI_PROT_READ_PASS:
1832                 case SCSI_PROT_WRITE_PASS:
1833                         *rxop = BG_OP_IN_CRC_OUT_CRC;
1834                         *txop = BG_OP_IN_CRC_OUT_CRC;
1835                         break;
1836
1837                 case SCSI_PROT_READ_INSERT:
1838                 case SCSI_PROT_WRITE_STRIP:
1839                         *rxop = BG_OP_IN_NODIF_OUT_CRC;
1840                         *txop = BG_OP_IN_CRC_OUT_NODIF;
1841                         break;
1842
1843                 case SCSI_PROT_NORMAL:
1844                 default:
1845                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1846                                 "9075 BLKGRD: Bad op/guard:%d/CRC combination\n",
1847                                         scsi_get_prot_op(sc));
1848                         ret = 1;
1849                         break;
1850                 }
1851         }
1852
1853         return ret;
1854 }
1855
1856 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1857 /**
1858  * lpfc_bg_err_opcodes - reDetermine the BlockGuard opcodes to be used with
1859  * the specified SCSI command in order to force a guard tag error.
1860  * @phba: The Hba for which this call is being executed.
1861  * @sc: The SCSI command to examine
1862  * @txopt: (out) BlockGuard operation for transmitted data
1863  * @rxopt: (out) BlockGuard operation for received data
1864  *
1865  * Returns: zero on success; non-zero if tx and/or rx op cannot be determined
1866  *
1867  **/
1868 static int
1869 lpfc_bg_err_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1870                 uint8_t *txop, uint8_t *rxop)
1871 {
1872         uint8_t guard_type = scsi_host_get_guard(sc->device->host);
1873         uint8_t ret = 0;
1874
1875         if (guard_type == SHOST_DIX_GUARD_IP) {
1876                 switch (scsi_get_prot_op(sc)) {
1877                 case SCSI_PROT_READ_INSERT:
1878                 case SCSI_PROT_WRITE_STRIP:
1879                         *rxop = BG_OP_IN_NODIF_OUT_CRC;
1880                         *txop = BG_OP_IN_CRC_OUT_NODIF;
1881                         break;
1882
1883                 case SCSI_PROT_READ_STRIP:
1884                 case SCSI_PROT_WRITE_INSERT:
1885                         *rxop = BG_OP_IN_CSUM_OUT_NODIF;
1886                         *txop = BG_OP_IN_NODIF_OUT_CSUM;
1887                         break;
1888
1889                 case SCSI_PROT_READ_PASS:
1890                 case SCSI_PROT_WRITE_PASS:
1891                         *rxop = BG_OP_IN_CSUM_OUT_CRC;
1892                         *txop = BG_OP_IN_CRC_OUT_CSUM;
1893                         break;
1894
1895                 case SCSI_PROT_NORMAL:
1896                 default:
1897                         break;
1898
1899                 }
1900         } else {
1901                 switch (scsi_get_prot_op(sc)) {
1902                 case SCSI_PROT_READ_STRIP:
1903                 case SCSI_PROT_WRITE_INSERT:
1904                         *rxop = BG_OP_IN_CSUM_OUT_NODIF;
1905                         *txop = BG_OP_IN_NODIF_OUT_CSUM;
1906                         break;
1907
1908                 case SCSI_PROT_READ_PASS:
1909                 case SCSI_PROT_WRITE_PASS:
1910                         *rxop = BG_OP_IN_CSUM_OUT_CSUM;
1911                         *txop = BG_OP_IN_CSUM_OUT_CSUM;
1912                         break;
1913
1914                 case SCSI_PROT_READ_INSERT:
1915                 case SCSI_PROT_WRITE_STRIP:
1916                         *rxop = BG_OP_IN_NODIF_OUT_CSUM;
1917                         *txop = BG_OP_IN_CSUM_OUT_NODIF;
1918                         break;
1919
1920                 case SCSI_PROT_NORMAL:
1921                 default:
1922                         break;
1923                 }
1924         }
1925
1926         return ret;
1927 }
1928 #endif
1929
1930 /**
1931  * lpfc_bg_setup_bpl - Setup BlockGuard BPL with no protection data
1932  * @phba: The Hba for which this call is being executed.
1933  * @sc: pointer to scsi command we're working on
1934  * @bpl: pointer to buffer list for protection groups
1935  * @datacnt: number of segments of data that have been dma mapped
1936  *
1937  * This function sets up BPL buffer list for protection groups of
1938  * type LPFC_PG_TYPE_NO_DIF
1939  *
1940  * This is usually used when the HBA is instructed to generate
1941  * DIFs and insert them into data stream (or strip DIF from
1942  * incoming data stream)
1943  *
1944  * The buffer list consists of just one protection group described
1945  * below:
1946  *                                +-------------------------+
1947  *   start of prot group  -->     |          PDE_5          |
1948  *                                +-------------------------+
1949  *                                |          PDE_6          |
1950  *                                +-------------------------+
1951  *                                |         Data BDE        |
1952  *                                +-------------------------+
1953  *                                |more Data BDE's ... (opt)|
1954  *                                +-------------------------+
1955  *
1956  *
1957  * Note: Data s/g buffers have been dma mapped
1958  *
1959  * Returns the number of BDEs added to the BPL.
1960  **/
1961 static int
1962 lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1963                 struct ulp_bde64 *bpl, int datasegcnt)
1964 {
1965         struct scatterlist *sgde = NULL; /* s/g data entry */
1966         struct lpfc_pde5 *pde5 = NULL;
1967         struct lpfc_pde6 *pde6 = NULL;
1968         dma_addr_t physaddr;
1969         int i = 0, num_bde = 0, status;
1970         int datadir = sc->sc_data_direction;
1971 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1972         uint32_t rc;
1973 #endif
1974         uint32_t checking = 1;
1975         uint32_t reftag;
1976         unsigned blksize;
1977         uint8_t txop, rxop;
1978
1979         status  = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
1980         if (status)
1981                 goto out;
1982
1983         /* extract some info from the scsi command for pde*/
1984         blksize = lpfc_cmd_blksize(sc);
1985         reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
1986
1987 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1988         rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
1989         if (rc) {
1990                 if (rc & BG_ERR_SWAP)
1991                         lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
1992                 if (rc & BG_ERR_CHECK)
1993                         checking = 0;
1994         }
1995 #endif
1996
1997         /* setup PDE5 with what we have */
1998         pde5 = (struct lpfc_pde5 *) bpl;
1999         memset(pde5, 0, sizeof(struct lpfc_pde5));
2000         bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
2001
2002         /* Endianness conversion if necessary for PDE5 */
2003         pde5->word0 = cpu_to_le32(pde5->word0);
2004         pde5->reftag = cpu_to_le32(reftag);
2005
2006         /* advance bpl and increment bde count */
2007         num_bde++;
2008         bpl++;
2009         pde6 = (struct lpfc_pde6 *) bpl;
2010
2011         /* setup PDE6 with the rest of the info */
2012         memset(pde6, 0, sizeof(struct lpfc_pde6));
2013         bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
2014         bf_set(pde6_optx, pde6, txop);
2015         bf_set(pde6_oprx, pde6, rxop);
2016         if (datadir == DMA_FROM_DEVICE) {
2017                 bf_set(pde6_ce, pde6, checking);
2018                 bf_set(pde6_re, pde6, checking);
2019         }
2020         bf_set(pde6_ai, pde6, 1);
2021         bf_set(pde6_ae, pde6, 0);
2022         bf_set(pde6_apptagval, pde6, 0);
2023
2024         /* Endianness conversion if necessary for PDE6 */
2025         pde6->word0 = cpu_to_le32(pde6->word0);
2026         pde6->word1 = cpu_to_le32(pde6->word1);
2027         pde6->word2 = cpu_to_le32(pde6->word2);
2028
2029         /* advance bpl and increment bde count */
2030         num_bde++;
2031         bpl++;
2032
2033         /* assumption: caller has already run dma_map_sg on command data */
2034         scsi_for_each_sg(sc, sgde, datasegcnt, i) {
2035                 physaddr = sg_dma_address(sgde);
2036                 bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr));
2037                 bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
2038                 bpl->tus.f.bdeSize = sg_dma_len(sgde);
2039                 if (datadir == DMA_TO_DEVICE)
2040                         bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
2041                 else
2042                         bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
2043                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
2044                 bpl++;
2045                 num_bde++;
2046         }
2047
2048 out:
2049         return num_bde;
2050 }
2051
2052 /**
2053  * lpfc_bg_setup_bpl_prot - Setup BlockGuard BPL with protection data
2054  * @phba: The Hba for which this call is being executed.
2055  * @sc: pointer to scsi command we're working on
2056  * @bpl: pointer to buffer list for protection groups
2057  * @datacnt: number of segments of data that have been dma mapped
2058  * @protcnt: number of segment of protection data that have been dma mapped
2059  *
2060  * This function sets up BPL buffer list for protection groups of
2061  * type LPFC_PG_TYPE_DIF
2062  *
2063  * This is usually used when DIFs are in their own buffers,
2064  * separate from the data. The HBA can then by instructed
2065  * to place the DIFs in the outgoing stream.  For read operations,
2066  * The HBA could extract the DIFs and place it in DIF buffers.
2067  *
2068  * The buffer list for this type consists of one or more of the
2069  * protection groups described below:
2070  *                                    +-------------------------+
2071  *   start of first prot group  -->   |          PDE_5          |
2072  *                                    +-------------------------+
2073  *                                    |          PDE_6          |
2074  *                                    +-------------------------+
2075  *                                    |      PDE_7 (Prot BDE)   |
2076  *                                    +-------------------------+
2077  *                                    |        Data BDE         |
2078  *                                    +-------------------------+
2079  *                                    |more Data BDE's ... (opt)|
2080  *                                    +-------------------------+
2081  *   start of new  prot group  -->    |          PDE_5          |
2082  *                                    +-------------------------+
2083  *                                    |          ...            |
2084  *                                    +-------------------------+
2085  *
2086  * Note: It is assumed that both data and protection s/g buffers have been
2087  *       mapped for DMA
2088  *
2089  * Returns the number of BDEs added to the BPL.
2090  **/
2091 static int
2092 lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
2093                 struct ulp_bde64 *bpl, int datacnt, int protcnt)
2094 {
2095         struct scatterlist *sgde = NULL; /* s/g data entry */
2096         struct scatterlist *sgpe = NULL; /* s/g prot entry */
2097         struct lpfc_pde5 *pde5 = NULL;
2098         struct lpfc_pde6 *pde6 = NULL;
2099         struct lpfc_pde7 *pde7 = NULL;
2100         dma_addr_t dataphysaddr, protphysaddr;
2101         unsigned short curr_data = 0, curr_prot = 0;
2102         unsigned int split_offset;
2103         unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder;
2104         unsigned int protgrp_blks, protgrp_bytes;
2105         unsigned int remainder, subtotal;
2106         int status;
2107         int datadir = sc->sc_data_direction;
2108         unsigned char pgdone = 0, alldone = 0;
2109         unsigned blksize;
2110 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2111         uint32_t rc;
2112 #endif
2113         uint32_t checking = 1;
2114         uint32_t reftag;
2115         uint8_t txop, rxop;
2116         int num_bde = 0;
2117
2118         sgpe = scsi_prot_sglist(sc);
2119         sgde = scsi_sglist(sc);
2120
2121         if (!sgpe || !sgde) {
2122                 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2123                                 "9020 Invalid s/g entry: data=0x%p prot=0x%p\n",
2124                                 sgpe, sgde);
2125                 return 0;
2126         }
2127
2128         status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2129         if (status)
2130                 goto out;
2131
2132         /* extract some info from the scsi command */
2133         blksize = lpfc_cmd_blksize(sc);
2134         reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
2135
2136 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2137         rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2138         if (rc) {
2139                 if (rc & BG_ERR_SWAP)
2140                         lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2141                 if (rc & BG_ERR_CHECK)
2142                         checking = 0;
2143         }
2144 #endif
2145
2146         split_offset = 0;
2147         do {
2148                 /* setup PDE5 with what we have */
2149                 pde5 = (struct lpfc_pde5 *) bpl;
2150                 memset(pde5, 0, sizeof(struct lpfc_pde5));
2151                 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
2152
2153                 /* Endianness conversion if necessary for PDE5 */
2154                 pde5->word0 = cpu_to_le32(pde5->word0);
2155                 pde5->reftag = cpu_to_le32(reftag);
2156
2157                 /* advance bpl and increment bde count */
2158                 num_bde++;
2159                 bpl++;
2160                 pde6 = (struct lpfc_pde6 *) bpl;
2161
2162                 /* setup PDE6 with the rest of the info */
2163                 memset(pde6, 0, sizeof(struct lpfc_pde6));
2164                 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
2165                 bf_set(pde6_optx, pde6, txop);
2166                 bf_set(pde6_oprx, pde6, rxop);
2167                 bf_set(pde6_ce, pde6, checking);
2168                 bf_set(pde6_re, pde6, checking);
2169                 bf_set(pde6_ai, pde6, 1);
2170                 bf_set(pde6_ae, pde6, 0);
2171                 bf_set(pde6_apptagval, pde6, 0);
2172
2173                 /* Endianness conversion if necessary for PDE6 */
2174                 pde6->word0 = cpu_to_le32(pde6->word0);
2175                 pde6->word1 = cpu_to_le32(pde6->word1);
2176                 pde6->word2 = cpu_to_le32(pde6->word2);
2177
2178                 /* advance bpl and increment bde count */
2179                 num_bde++;
2180                 bpl++;
2181
2182                 /* setup the first BDE that points to protection buffer */
2183                 protphysaddr = sg_dma_address(sgpe) + protgroup_offset;
2184                 protgroup_len = sg_dma_len(sgpe) - protgroup_offset;
2185
2186                 /* must be integer multiple of the DIF block length */
2187                 BUG_ON(protgroup_len % 8);
2188
2189                 pde7 = (struct lpfc_pde7 *) bpl;
2190                 memset(pde7, 0, sizeof(struct lpfc_pde7));
2191                 bf_set(pde7_type, pde7, LPFC_PDE7_DESCRIPTOR);
2192
2193                 pde7->addrHigh = le32_to_cpu(putPaddrHigh(protphysaddr));
2194                 pde7->addrLow = le32_to_cpu(putPaddrLow(protphysaddr));
2195
2196                 protgrp_blks = protgroup_len / 8;
2197                 protgrp_bytes = protgrp_blks * blksize;
2198
2199                 /* check if this pde is crossing the 4K boundary; if so split */
2200                 if ((pde7->addrLow & 0xfff) + protgroup_len > 0x1000) {
2201                         protgroup_remainder = 0x1000 - (pde7->addrLow & 0xfff);
2202                         protgroup_offset += protgroup_remainder;
2203                         protgrp_blks = protgroup_remainder / 8;
2204                         protgrp_bytes = protgrp_blks * blksize;
2205                 } else {
2206                         protgroup_offset = 0;
2207                         curr_prot++;
2208                 }
2209
2210                 num_bde++;
2211
2212                 /* setup BDE's for data blocks associated with DIF data */
2213                 pgdone = 0;
2214                 subtotal = 0; /* total bytes processed for current prot grp */
2215                 while (!pgdone) {
2216                         if (!sgde) {
2217                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2218                                         "9065 BLKGRD:%s Invalid data segment\n",
2219                                                 __func__);
2220                                 return 0;
2221                         }
2222                         bpl++;
2223                         dataphysaddr = sg_dma_address(sgde) + split_offset;
2224                         bpl->addrLow = le32_to_cpu(putPaddrLow(dataphysaddr));
2225                         bpl->addrHigh = le32_to_cpu(putPaddrHigh(dataphysaddr));
2226
2227                         remainder = sg_dma_len(sgde) - split_offset;
2228
2229                         if ((subtotal + remainder) <= protgrp_bytes) {
2230                                 /* we can use this whole buffer */
2231                                 bpl->tus.f.bdeSize = remainder;
2232                                 split_offset = 0;
2233
2234                                 if ((subtotal + remainder) == protgrp_bytes)
2235                                         pgdone = 1;
2236                         } else {
2237                                 /* must split this buffer with next prot grp */
2238                                 bpl->tus.f.bdeSize = protgrp_bytes - subtotal;
2239                                 split_offset += bpl->tus.f.bdeSize;
2240                         }
2241
2242                         subtotal += bpl->tus.f.bdeSize;
2243
2244                         if (datadir == DMA_TO_DEVICE)
2245                                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
2246                         else
2247                                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
2248                         bpl->tus.w = le32_to_cpu(bpl->tus.w);
2249
2250                         num_bde++;
2251                         curr_data++;
2252
2253                         if (split_offset)
2254                                 break;
2255
2256                         /* Move to the next s/g segment if possible */
2257                         sgde = sg_next(sgde);
2258
2259                 }
2260
2261                 if (protgroup_offset) {
2262                         /* update the reference tag */
2263                         reftag += protgrp_blks;
2264                         bpl++;
2265                         continue;
2266                 }
2267
2268                 /* are we done ? */
2269                 if (curr_prot == protcnt) {
2270                         alldone = 1;
2271                 } else if (curr_prot < protcnt) {
2272                         /* advance to next prot buffer */
2273                         sgpe = sg_next(sgpe);
2274                         bpl++;
2275
2276                         /* update the reference tag */
2277                         reftag += protgrp_blks;
2278                 } else {
2279                         /* if we're here, we have a bug */
2280                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2281                                 "9054 BLKGRD: bug in %s\n", __func__);
2282                 }
2283
2284         } while (!alldone);
2285 out:
2286
2287         return num_bde;
2288 }
2289
2290 /**
2291  * lpfc_bg_setup_sgl - Setup BlockGuard SGL with no protection data
2292  * @phba: The Hba for which this call is being executed.
2293  * @sc: pointer to scsi command we're working on
2294  * @sgl: pointer to buffer list for protection groups
2295  * @datacnt: number of segments of data that have been dma mapped
2296  *
2297  * This function sets up SGL buffer list for protection groups of
2298  * type LPFC_PG_TYPE_NO_DIF
2299  *
2300  * This is usually used when the HBA is instructed to generate
2301  * DIFs and insert them into data stream (or strip DIF from
2302  * incoming data stream)
2303  *
2304  * The buffer list consists of just one protection group described
2305  * below:
2306  *                                +-------------------------+
2307  *   start of prot group  -->     |         DI_SEED         |
2308  *                                +-------------------------+
2309  *                                |         Data SGE        |
2310  *                                +-------------------------+
2311  *                                |more Data SGE's ... (opt)|
2312  *                                +-------------------------+
2313  *
2314  *
2315  * Note: Data s/g buffers have been dma mapped
2316  *
2317  * Returns the number of SGEs added to the SGL.
2318  **/
2319 static int
2320 lpfc_bg_setup_sgl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
2321                 struct sli4_sge *sgl, int datasegcnt)
2322 {
2323         struct scatterlist *sgde = NULL; /* s/g data entry */
2324         struct sli4_sge_diseed *diseed = NULL;
2325         dma_addr_t physaddr;
2326         int i = 0, num_sge = 0, status;
2327         int datadir = sc->sc_data_direction;
2328         uint32_t reftag;
2329         unsigned blksize;
2330         uint8_t txop, rxop;
2331 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2332         uint32_t rc;
2333 #endif
2334         uint32_t checking = 1;
2335         uint32_t dma_len;
2336         uint32_t dma_offset = 0;
2337
2338         status  = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2339         if (status)
2340                 goto out;
2341
2342         /* extract some info from the scsi command for pde*/
2343         blksize = lpfc_cmd_blksize(sc);
2344         reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
2345
2346 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2347         rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2348         if (rc) {
2349                 if (rc & BG_ERR_SWAP)
2350                         lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2351                 if (rc & BG_ERR_CHECK)
2352                         checking = 0;
2353         }
2354 #endif
2355
2356         /* setup DISEED with what we have */
2357         diseed = (struct sli4_sge_diseed *) sgl;
2358         memset(diseed, 0, sizeof(struct sli4_sge_diseed));
2359         bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED);
2360
2361         /* Endianness conversion if necessary */
2362         diseed->ref_tag = cpu_to_le32(reftag);
2363         diseed->ref_tag_tran = diseed->ref_tag;
2364
2365         /* setup DISEED with the rest of the info */
2366         bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
2367         bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
2368         if (datadir == DMA_FROM_DEVICE) {
2369                 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
2370                 bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
2371         }
2372         bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
2373         bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
2374
2375         /* Endianness conversion if necessary for DISEED */
2376         diseed->word2 = cpu_to_le32(diseed->word2);
2377         diseed->word3 = cpu_to_le32(diseed->word3);
2378
2379         /* advance bpl and increment sge count */
2380         num_sge++;
2381         sgl++;
2382
2383         /* assumption: caller has already run dma_map_sg on command data */
2384         scsi_for_each_sg(sc, sgde, datasegcnt, i) {
2385                 physaddr = sg_dma_address(sgde);
2386                 dma_len = sg_dma_len(sgde);
2387                 sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
2388                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
2389                 if ((i + 1) == datasegcnt)
2390                         bf_set(lpfc_sli4_sge_last, sgl, 1);
2391                 else
2392                         bf_set(lpfc_sli4_sge_last, sgl, 0);
2393                 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
2394                 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
2395
2396                 sgl->sge_len = cpu_to_le32(dma_len);
2397                 dma_offset += dma_len;
2398
2399                 sgl++;
2400                 num_sge++;
2401         }
2402
2403 out:
2404         return num_sge;
2405 }
2406
2407 /**
2408  * lpfc_bg_setup_sgl_prot - Setup BlockGuard SGL with protection data
2409  * @phba: The Hba for which this call is being executed.
2410  * @sc: pointer to scsi command we're working on
2411  * @sgl: pointer to buffer list for protection groups
2412  * @datacnt: number of segments of data that have been dma mapped
2413  * @protcnt: number of segment of protection data that have been dma mapped
2414  *
2415  * This function sets up SGL buffer list for protection groups of
2416  * type LPFC_PG_TYPE_DIF
2417  *
2418  * This is usually used when DIFs are in their own buffers,
2419  * separate from the data. The HBA can then by instructed
2420  * to place the DIFs in the outgoing stream.  For read operations,
2421  * The HBA could extract the DIFs and place it in DIF buffers.
2422  *
2423  * The buffer list for this type consists of one or more of the
2424  * protection groups described below:
2425  *                                    +-------------------------+
2426  *   start of first prot group  -->   |         DISEED          |
2427  *                                    +-------------------------+
2428  *                                    |      DIF (Prot SGE)     |
2429  *                                    +-------------------------+
2430  *                                    |        Data SGE         |
2431  *                                    +-------------------------+
2432  *                                    |more Data SGE's ... (opt)|
2433  *                                    +-------------------------+
2434  *   start of new  prot group  -->    |         DISEED          |
2435  *                                    +-------------------------+
2436  *                                    |          ...            |
2437  *                                    +-------------------------+
2438  *
2439  * Note: It is assumed that both data and protection s/g buffers have been
2440  *       mapped for DMA
2441  *
2442  * Returns the number of SGEs added to the SGL.
2443  **/
2444 static int
2445 lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
2446                 struct sli4_sge *sgl, int datacnt, int protcnt)
2447 {
2448         struct scatterlist *sgde = NULL; /* s/g data entry */
2449         struct scatterlist *sgpe = NULL; /* s/g prot entry */
2450         struct sli4_sge_diseed *diseed = NULL;
2451         dma_addr_t dataphysaddr, protphysaddr;
2452         unsigned short curr_data = 0, curr_prot = 0;
2453         unsigned int split_offset;
2454         unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder;
2455         unsigned int protgrp_blks, protgrp_bytes;
2456         unsigned int remainder, subtotal;
2457         int status;
2458         unsigned char pgdone = 0, alldone = 0;
2459         unsigned blksize;
2460         uint32_t reftag;
2461         uint8_t txop, rxop;
2462         uint32_t dma_len;
2463 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2464         uint32_t rc;
2465 #endif
2466         uint32_t checking = 1;
2467         uint32_t dma_offset = 0;
2468         int num_sge = 0;
2469
2470         sgpe = scsi_prot_sglist(sc);
2471         sgde = scsi_sglist(sc);
2472
2473         if (!sgpe || !sgde) {
2474                 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2475                                 "9082 Invalid s/g entry: data=0x%p prot=0x%p\n",
2476                                 sgpe, sgde);
2477                 return 0;
2478         }
2479
2480         status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2481         if (status)
2482                 goto out;
2483
2484         /* extract some info from the scsi command */
2485         blksize = lpfc_cmd_blksize(sc);
2486         reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */
2487
2488 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2489         rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2490         if (rc) {
2491                 if (rc & BG_ERR_SWAP)
2492                         lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2493                 if (rc & BG_ERR_CHECK)
2494                         checking = 0;
2495         }
2496 #endif
2497
2498         split_offset = 0;
2499         do {
2500                 /* setup DISEED with what we have */
2501                 diseed = (struct sli4_sge_diseed *) sgl;
2502                 memset(diseed, 0, sizeof(struct sli4_sge_diseed));
2503                 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED);
2504
2505                 /* Endianness conversion if necessary */
2506                 diseed->ref_tag = cpu_to_le32(reftag);
2507                 diseed->ref_tag_tran = diseed->ref_tag;
2508
2509                 /* setup DISEED with the rest of the info */
2510                 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
2511                 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
2512                 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
2513                 bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
2514                 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
2515                 bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
2516
2517                 /* Endianness conversion if necessary for DISEED */
2518                 diseed->word2 = cpu_to_le32(diseed->word2);
2519                 diseed->word3 = cpu_to_le32(diseed->word3);
2520
2521                 /* advance sgl and increment bde count */
2522                 num_sge++;
2523                 sgl++;
2524
2525                 /* setup the first BDE that points to protection buffer */
2526                 protphysaddr = sg_dma_address(sgpe) + protgroup_offset;
2527                 protgroup_len = sg_dma_len(sgpe) - protgroup_offset;
2528
2529                 /* must be integer multiple of the DIF block length */
2530                 BUG_ON(protgroup_len % 8);
2531
2532                 /* Now setup DIF SGE */
2533                 sgl->word2 = 0;
2534                 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DIF);
2535                 sgl->addr_hi = le32_to_cpu(putPaddrHigh(protphysaddr));
2536                 sgl->addr_lo = le32_to_cpu(putPaddrLow(protphysaddr));
2537                 sgl->word2 = cpu_to_le32(sgl->word2);
2538
2539                 protgrp_blks = protgroup_len / 8;
2540                 protgrp_bytes = protgrp_blks * blksize;
2541
2542                 /* check if DIF SGE is crossing the 4K boundary; if so split */
2543                 if ((sgl->addr_lo & 0xfff) + protgroup_len > 0x1000) {
2544                         protgroup_remainder = 0x1000 - (sgl->addr_lo & 0xfff);
2545                         protgroup_offset += protgroup_remainder;
2546                         protgrp_blks = protgroup_remainder / 8;
2547                         protgrp_bytes = protgrp_blks * blksize;
2548                 } else {
2549                         protgroup_offset = 0;
2550                         curr_prot++;
2551                 }
2552
2553                 num_sge++;
2554
2555                 /* setup SGE's for data blocks associated with DIF data */
2556                 pgdone = 0;
2557                 subtotal = 0; /* total bytes processed for current prot grp */
2558                 while (!pgdone) {
2559                         if (!sgde) {
2560                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2561                                         "9086 BLKGRD:%s Invalid data segment\n",
2562                                                 __func__);
2563                                 return 0;
2564                         }
2565                         sgl++;
2566                         dataphysaddr = sg_dma_address(sgde) + split_offset;
2567
2568                         remainder = sg_dma_len(sgde) - split_offset;
2569
2570                         if ((subtotal + remainder) <= protgrp_bytes) {
2571                                 /* we can use this whole buffer */
2572                                 dma_len = remainder;
2573                                 split_offset = 0;
2574
2575                                 if ((subtotal + remainder) == protgrp_bytes)
2576                                         pgdone = 1;
2577                         } else {
2578                                 /* must split this buffer with next prot grp */
2579                                 dma_len = protgrp_bytes - subtotal;
2580                                 split_offset += dma_len;
2581                         }
2582
2583                         subtotal += dma_len;
2584
2585                         sgl->addr_lo = cpu_to_le32(putPaddrLow(dataphysaddr));
2586                         sgl->addr_hi = cpu_to_le32(putPaddrHigh(dataphysaddr));
2587                         bf_set(lpfc_sli4_sge_last, sgl, 0);
2588                         bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
2589                         bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
2590
2591                         sgl->sge_len = cpu_to_le32(dma_len);
2592                         dma_offset += dma_len;
2593
2594                         num_sge++;
2595                         curr_data++;
2596
2597                         if (split_offset)
2598                                 break;
2599
2600                         /* Move to the next s/g segment if possible */
2601                         sgde = sg_next(sgde);
2602                 }
2603
2604                 if (protgroup_offset) {
2605                         /* update the reference tag */
2606                         reftag += protgrp_blks;
2607                         sgl++;
2608                         continue;
2609                 }
2610
2611                 /* are we done ? */
2612                 if (curr_prot == protcnt) {
2613                         bf_set(lpfc_sli4_sge_last, sgl, 1);
2614                         alldone = 1;
2615                 } else if (curr_prot < protcnt) {
2616                         /* advance to next prot buffer */
2617                         sgpe = sg_next(sgpe);
2618                         sgl++;
2619
2620                         /* update the reference tag */
2621                         reftag += protgrp_blks;
2622                 } else {
2623                         /* if we're here, we have a bug */
2624                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2625                                 "9085 BLKGRD: bug in %s\n", __func__);
2626                 }
2627
2628         } while (!alldone);
2629
2630 out:
2631
2632         return num_sge;
2633 }
2634
2635 /**
2636  * lpfc_prot_group_type - Get prtotection group type of SCSI command
2637  * @phba: The Hba for which this call is being executed.
2638  * @sc: pointer to scsi command we're working on
2639  *
2640  * Given a SCSI command that supports DIF, determine composition of protection
2641  * groups involved in setting up buffer lists
2642  *
2643  * Returns: Protection group type (with or without DIF)
2644  *
2645  **/
2646 static int
2647 lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc)
2648 {
2649         int ret = LPFC_PG_TYPE_INVALID;
2650         unsigned char op = scsi_get_prot_op(sc);
2651
2652         switch (op) {
2653         case SCSI_PROT_READ_STRIP:
2654         case SCSI_PROT_WRITE_INSERT:
2655                 ret = LPFC_PG_TYPE_NO_DIF;
2656                 break;
2657         case SCSI_PROT_READ_INSERT:
2658         case SCSI_PROT_WRITE_STRIP:
2659         case SCSI_PROT_READ_PASS:
2660         case SCSI_PROT_WRITE_PASS:
2661                 ret = LPFC_PG_TYPE_DIF_BUF;
2662                 break;
2663         default:
2664                 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2665                                 "9021 Unsupported protection op:%d\n", op);
2666                 break;
2667         }
2668
2669         return ret;
2670 }
2671
2672 /**
2673  * lpfc_bg_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec
2674  * @phba: The Hba for which this call is being executed.
2675  * @lpfc_cmd: The scsi buffer which is going to be prep'ed.
2676  *
2677  * This is the protection/DIF aware version of
2678  * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the
2679  * two functions eventually, but for now, it's here
2680  **/
2681 static int
2682 lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
2683                 struct lpfc_scsi_buf *lpfc_cmd)
2684 {
2685         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
2686         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
2687         struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
2688         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
2689         uint32_t num_bde = 0;
2690         int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
2691         int prot_group_type = 0;
2692         int diflen, fcpdl;
2693         unsigned blksize;
2694
2695         /*
2696          * Start the lpfc command prep by bumping the bpl beyond fcp_cmnd
2697          *  fcp_rsp regions to the first data bde entry
2698          */
2699         bpl += 2;
2700         if (scsi_sg_count(scsi_cmnd)) {
2701                 /*
2702                  * The driver stores the segment count returned from pci_map_sg
2703                  * because this a count of dma-mappings used to map the use_sg
2704                  * pages.  They are not guaranteed to be the same for those
2705                  * architectures that implement an IOMMU.
2706                  */
2707                 datasegcnt = dma_map_sg(&phba->pcidev->dev,
2708                                         scsi_sglist(scsi_cmnd),
2709                                         scsi_sg_count(scsi_cmnd), datadir);
2710                 if (unlikely(!datasegcnt))
2711                         return 1;
2712
2713                 lpfc_cmd->seg_cnt = datasegcnt;
2714                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
2715                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2716                                         "9067 BLKGRD: %s: Too many sg segments"
2717                                         " from dma_map_sg.  Config %d, seg_cnt"
2718                                         " %d\n",
2719                                         __func__, phba->cfg_sg_seg_cnt,
2720                                         lpfc_cmd->seg_cnt);
2721                         scsi_dma_unmap(scsi_cmnd);
2722                         return 1;
2723                 }
2724
2725                 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
2726
2727                 switch (prot_group_type) {
2728                 case LPFC_PG_TYPE_NO_DIF:
2729                         num_bde = lpfc_bg_setup_bpl(phba, scsi_cmnd, bpl,
2730                                         datasegcnt);
2731                         /* we should have 2 or more entries in buffer list */
2732                         if (num_bde < 2)
2733                                 goto err;
2734                         break;
2735                 case LPFC_PG_TYPE_DIF_BUF:{
2736                         /*
2737                          * This type indicates that protection buffers are
2738                          * passed to the driver, so that needs to be prepared
2739                          * for DMA
2740                          */
2741                         protsegcnt = dma_map_sg(&phba->pcidev->dev,
2742                                         scsi_prot_sglist(scsi_cmnd),
2743                                         scsi_prot_sg_count(scsi_cmnd), datadir);
2744                         if (unlikely(!protsegcnt)) {
2745                                 scsi_dma_unmap(scsi_cmnd);
2746                                 return 1;
2747                         }
2748
2749                         lpfc_cmd->prot_seg_cnt = protsegcnt;
2750                         if (lpfc_cmd->prot_seg_cnt
2751                             > phba->cfg_prot_sg_seg_cnt) {
2752                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2753                                         "9068 BLKGRD: %s: Too many prot sg "
2754                                         "segments from dma_map_sg.  Config %d,"
2755                                                 "prot_seg_cnt %d\n", __func__,
2756                                                 phba->cfg_prot_sg_seg_cnt,
2757                                                 lpfc_cmd->prot_seg_cnt);
2758                                 dma_unmap_sg(&phba->pcidev->dev,
2759                                              scsi_prot_sglist(scsi_cmnd),
2760                                              scsi_prot_sg_count(scsi_cmnd),
2761                                              datadir);
2762                                 scsi_dma_unmap(scsi_cmnd);
2763                                 return 1;
2764                         }
2765
2766                         num_bde = lpfc_bg_setup_bpl_prot(phba, scsi_cmnd, bpl,
2767                                         datasegcnt, protsegcnt);
2768                         /* we should have 3 or more entries in buffer list */
2769                         if (num_bde < 3)
2770                                 goto err;
2771                         break;
2772                 }
2773                 case LPFC_PG_TYPE_INVALID:
2774                 default:
2775                         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2776                                         "9022 Unexpected protection group %i\n",
2777                                         prot_group_type);
2778                         return 1;
2779                 }
2780         }
2781
2782         /*
2783          * Finish initializing those IOCB fields that are dependent on the
2784          * scsi_cmnd request_buffer.  Note that the bdeSize is explicitly
2785          * reinitialized since all iocb memory resources are used many times
2786          * for transmit, receive, and continuation bpl's.
2787          */
2788         iocb_cmd->un.fcpi64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
2789         iocb_cmd->un.fcpi64.bdl.bdeSize += (num_bde * sizeof(struct ulp_bde64));
2790         iocb_cmd->ulpBdeCount = 1;
2791         iocb_cmd->ulpLe = 1;
2792
2793         fcpdl = scsi_bufflen(scsi_cmnd);
2794
2795         if (scsi_get_prot_type(scsi_cmnd) == SCSI_PROT_DIF_TYPE1) {
2796                 /*
2797                  * We are in DIF Type 1 mode
2798                  * Every data block has a 8 byte DIF (trailer)
2799                  * attached to it.  Must ajust FCP data length
2800                  */
2801                 blksize = lpfc_cmd_blksize(scsi_cmnd);
2802                 diflen = (fcpdl / blksize) * 8;
2803                 fcpdl += diflen;
2804         }
2805         fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
2806
2807         /*
2808          * Due to difference in data length between DIF/non-DIF paths,
2809          * we need to set word 4 of IOCB here
2810          */
2811         iocb_cmd->un.fcpi.fcpi_parm = fcpdl;
2812
2813         return 0;
2814 err:
2815         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2816                         "9023 Could not setup all needed BDE's"
2817                         "prot_group_type=%d, num_bde=%d\n",
2818                         prot_group_type, num_bde);
2819         return 1;
2820 }
2821
2822 /*
2823  * This function checks for BlockGuard errors detected by
2824  * the HBA.  In case of errors, the ASC/ASCQ fields in the
2825  * sense buffer will be set accordingly, paired with
2826  * ILLEGAL_REQUEST to signal to the kernel that the HBA
2827  * detected corruption.
2828  *
2829  * Returns:
2830  *  0 - No error found
2831  *  1 - BlockGuard error found
2832  * -1 - Internal error (bad profile, ...etc)
2833  */
2834 static int
2835 lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
2836                         struct lpfc_iocbq *pIocbOut)
2837 {
2838         struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
2839         struct sli3_bg_fields *bgf = &pIocbOut->iocb.unsli3.sli3_bg;
2840         int ret = 0;
2841         uint32_t bghm = bgf->bghm;
2842         uint32_t bgstat = bgf->bgstat;
2843         uint64_t failing_sector = 0;
2844
2845         lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9069 BLKGRD: BG ERROR in cmd"
2846                         " 0x%x lba 0x%llx blk cnt 0x%x "
2847                         "bgstat=0x%x bghm=0x%x\n",
2848                         cmd->cmnd[0], (unsigned long long)scsi_get_lba(cmd),
2849                         blk_rq_sectors(cmd->request), bgstat, bghm);
2850
2851         spin_lock(&_dump_buf_lock);
2852         if (!_dump_buf_done) {
2853                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,  "9070 BLKGRD: Saving"
2854                         " Data for %u blocks to debugfs\n",
2855                                 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
2856                 lpfc_debug_save_data(phba, cmd);
2857
2858                 /* If we have a prot sgl, save the DIF buffer */
2859                 if (lpfc_prot_group_type(phba, cmd) ==
2860                                 LPFC_PG_TYPE_DIF_BUF) {
2861                         lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9071 BLKGRD: "
2862                                 "Saving DIF for %u blocks to debugfs\n",
2863                                 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
2864                         lpfc_debug_save_dif(phba, cmd);
2865                 }
2866
2867                 _dump_buf_done = 1;
2868         }
2869         spin_unlock(&_dump_buf_lock);
2870
2871         if (lpfc_bgs_get_invalid_prof(bgstat)) {
2872                 cmd->result = ScsiResult(DID_ERROR, 0);
2873                 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9072 BLKGRD: Invalid"
2874                         " BlockGuard profile. bgstat:0x%x\n",
2875                         bgstat);
2876                 ret = (-1);
2877                 goto out;
2878         }
2879
2880         if (lpfc_bgs_get_uninit_dif_block(bgstat)) {
2881                 cmd->result = ScsiResult(DID_ERROR, 0);
2882                 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9073 BLKGRD: "
2883                                 "Invalid BlockGuard DIF Block. bgstat:0x%x\n",
2884                                 bgstat);
2885                 ret = (-1);
2886                 goto out;
2887         }
2888
2889         if (lpfc_bgs_get_guard_err(bgstat)) {
2890                 ret = 1;
2891
2892                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2893                                 0x10, 0x1);
2894                 cmd->result = DRIVER_SENSE << 24
2895                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
2896                 phba->bg_guard_err_cnt++;
2897                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2898                         "9055 BLKGRD: guard_tag error\n");
2899         }
2900
2901         if (lpfc_bgs_get_reftag_err(bgstat)) {
2902                 ret = 1;
2903
2904                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2905                                 0x10, 0x3);
2906                 cmd->result = DRIVER_SENSE << 24
2907                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
2908
2909                 phba->bg_reftag_err_cnt++;
2910                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2911                         "9056 BLKGRD: ref_tag error\n");
2912         }
2913
2914         if (lpfc_bgs_get_apptag_err(bgstat)) {
2915                 ret = 1;
2916
2917                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
2918                                 0x10, 0x2);
2919                 cmd->result = DRIVER_SENSE << 24
2920                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
2921
2922                 phba->bg_apptag_err_cnt++;
2923                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2924                         "9061 BLKGRD: app_tag error\n");
2925         }
2926
2927         if (lpfc_bgs_get_hi_water_mark_present(bgstat)) {
2928                 /*
2929                  * setup sense data descriptor 0 per SPC-4 as an information
2930                  * field, and put the failing LBA in it.
2931                  * This code assumes there was also a guard/app/ref tag error
2932                  * indication.
2933                  */
2934                 cmd->sense_buffer[7] = 0xc;   /* Additional sense length */
2935                 cmd->sense_buffer[8] = 0;     /* Information descriptor type */
2936                 cmd->sense_buffer[9] = 0xa;   /* Additional descriptor length */
2937                 cmd->sense_buffer[10] = 0x80; /* Validity bit */
2938
2939                 /* bghm is a "on the wire" FC frame based count */
2940                 switch (scsi_get_prot_op(cmd)) {
2941                 case SCSI_PROT_READ_INSERT:
2942                 case SCSI_PROT_WRITE_STRIP:
2943                         bghm /= cmd->device->sector_size;
2944                         break;
2945                 case SCSI_PROT_READ_STRIP:
2946                 case SCSI_PROT_WRITE_INSERT:
2947                 case SCSI_PROT_READ_PASS:
2948                 case SCSI_PROT_WRITE_PASS:
2949                         bghm /= (cmd->device->sector_size +
2950                                 sizeof(struct scsi_dif_tuple));
2951                         break;
2952                 }
2953
2954                 failing_sector = scsi_get_lba(cmd);
2955                 failing_sector += bghm;
2956
2957                 /* Descriptor Information */
2958                 put_unaligned_be64(failing_sector, &cmd->sense_buffer[12]);
2959         }
2960
2961         if (!ret) {
2962                 /* No error was reported - problem in FW? */
2963                 cmd->result = ScsiResult(DID_ERROR, 0);
2964                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2965                         "9057 BLKGRD: Unknown error reported!\n");
2966         }
2967
2968 out:
2969         return ret;
2970 }
2971
2972 /**
2973  * lpfc_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec
2974  * @phba: The Hba for which this call is being executed.
2975  * @lpfc_cmd: The scsi buffer which is going to be mapped.
2976  *
2977  * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
2978  * field of @lpfc_cmd for device with SLI-4 interface spec.
2979  *
2980  * Return codes:
2981  *      1 - Error
2982  *      0 - Success
2983  **/
2984 static int
2985 lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
2986 {
2987         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
2988         struct scatterlist *sgel = NULL;
2989         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
2990         struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->fcp_bpl;
2991         struct sli4_sge *first_data_sgl;
2992         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
2993         dma_addr_t physaddr;
2994         uint32_t num_bde = 0;
2995         uint32_t dma_len;
2996         uint32_t dma_offset = 0;
2997         int nseg;
2998         struct ulp_bde64 *bde;
2999
3000         /*
3001          * There are three possibilities here - use scatter-gather segment, use
3002          * the single mapping, or neither.  Start the lpfc command prep by
3003          * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
3004          * data bde entry.
3005          */
3006         if (scsi_sg_count(scsi_cmnd)) {
3007                 /*
3008                  * The driver stores the segment count returned from pci_map_sg
3009                  * because this a count of dma-mappings used to map the use_sg
3010                  * pages.  They are not guaranteed to be the same for those
3011                  * architectures that implement an IOMMU.
3012                  */
3013
3014                 nseg = scsi_dma_map(scsi_cmnd);
3015                 if (unlikely(!nseg))
3016                         return 1;
3017                 sgl += 1;
3018                 /* clear the last flag in the fcp_rsp map entry */
3019                 sgl->word2 = le32_to_cpu(sgl->word2);
3020                 bf_set(lpfc_sli4_sge_last, sgl, 0);
3021                 sgl->word2 = cpu_to_le32(sgl->word2);
3022                 sgl += 1;
3023                 first_data_sgl = sgl;
3024                 lpfc_cmd->seg_cnt = nseg;
3025                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
3026                         lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9074 BLKGRD:"
3027                                 " %s: Too many sg segments from "
3028                                 "dma_map_sg.  Config %d, seg_cnt %d\n",
3029                                 __func__, phba->cfg_sg_seg_cnt,
3030                                lpfc_cmd->seg_cnt);
3031                         scsi_dma_unmap(scsi_cmnd);
3032                         return 1;
3033                 }
3034
3035                 /*
3036                  * The driver established a maximum scatter-gather segment count
3037                  * during probe that limits the number of sg elements in any
3038                  * single scsi command.  Just run through the seg_cnt and format
3039                  * the sge's.
3040                  * When using SLI-3 the driver will try to fit all the BDEs into
3041                  * the IOCB. If it can't then the BDEs get added to a BPL as it
3042                  * does for SLI-2 mode.
3043                  */
3044                 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
3045                         physaddr = sg_dma_address(sgel);
3046                         dma_len = sg_dma_len(sgel);
3047                         sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
3048                         sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
3049                         sgl->word2 = le32_to_cpu(sgl->word2);
3050                         if ((num_bde + 1) == nseg)
3051                                 bf_set(lpfc_sli4_sge_last, sgl, 1);
3052                         else
3053                                 bf_set(lpfc_sli4_sge_last, sgl, 0);
3054                         bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
3055                         bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
3056                         sgl->word2 = cpu_to_le32(sgl->word2);
3057                         sgl->sge_len = cpu_to_le32(dma_len);
3058                         dma_offset += dma_len;
3059                         sgl++;
3060                 }
3061                 /* setup the performance hint (first data BDE) if enabled */
3062                 if (phba->sli3_options & LPFC_SLI4_PERFH_ENABLED) {
3063                         bde = (struct ulp_bde64 *)
3064                                         &(iocb_cmd->unsli3.sli3Words[5]);
3065                         bde->addrLow = first_data_sgl->addr_lo;
3066                         bde->addrHigh = first_data_sgl->addr_hi;
3067                         bde->tus.f.bdeSize =
3068                                         le32_to_cpu(first_data_sgl->sge_len);
3069                         bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
3070                         bde->tus.w = cpu_to_le32(bde->tus.w);
3071                 }
3072         } else {
3073                 sgl += 1;
3074                 /* clear the last flag in the fcp_rsp map entry */
3075                 sgl->word2 = le32_to_cpu(sgl->word2);
3076                 bf_set(lpfc_sli4_sge_last, sgl, 1);
3077                 sgl->word2 = cpu_to_le32(sgl->word2);
3078         }
3079
3080         /*
3081          * Finish initializing those IOCB fields that are dependent on the
3082          * scsi_cmnd request_buffer.  Note that for SLI-2 the bdeSize is
3083          * explicitly reinitialized.
3084          * all iocb memory resources are reused.
3085          */
3086         fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
3087
3088         /*
3089          * Due to difference in data length between DIF/non-DIF paths,
3090          * we need to set word 4 of IOCB here
3091          */
3092         iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
3093         return 0;
3094 }
3095
3096 /**
3097  * lpfc_bg_scsi_adjust_dl - Adjust SCSI data length for BlockGuard
3098  * @phba: The Hba for which this call is being executed.
3099  * @lpfc_cmd: The scsi buffer which is going to be adjusted.
3100  *
3101  * Adjust the data length to account for how much data
3102  * is actually on the wire.
3103  *
3104  * returns the adjusted data length
3105  **/
3106 static int
3107 lpfc_bg_scsi_adjust_dl(struct lpfc_hba *phba,
3108                 struct lpfc_scsi_buf *lpfc_cmd)
3109 {
3110         struct scsi_cmnd *sc = lpfc_cmd->pCmd;
3111         int diflen, fcpdl;
3112         unsigned blksize;
3113
3114         fcpdl = scsi_bufflen(sc);
3115
3116         /* Check if there is protection data on the wire */
3117         if (sc->sc_data_direction == DMA_FROM_DEVICE) {
3118                 /* Read */
3119                 if (scsi_get_prot_op(sc) ==  SCSI_PROT_READ_INSERT)
3120                         return fcpdl;
3121
3122         } else {
3123                 /* Write */
3124                 if (scsi_get_prot_op(sc) ==  SCSI_PROT_WRITE_STRIP)
3125                         return fcpdl;
3126         }
3127
3128         /* If protection data on the wire, adjust the count accordingly */
3129         blksize = lpfc_cmd_blksize(sc);
3130         diflen = (fcpdl / blksize) * 8;
3131         fcpdl += diflen;
3132         return fcpdl;
3133 }
3134
3135 /**
3136  * lpfc_bg_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec
3137  * @phba: The Hba for which this call is being executed.
3138  * @lpfc_cmd: The scsi buffer which is going to be mapped.
3139  *
3140  * This is the protection/DIF aware version of
3141  * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the
3142  * two functions eventually, but for now, it's here
3143  **/
3144 static int
3145 lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
3146                 struct lpfc_scsi_buf *lpfc_cmd)
3147 {
3148         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3149         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3150         struct sli4_sge *sgl = (struct sli4_sge *)(lpfc_cmd->fcp_bpl);
3151         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3152         uint32_t num_bde = 0;
3153         int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
3154         int prot_group_type = 0;
3155         int fcpdl;
3156
3157         /*
3158          * Start the lpfc command prep by bumping the sgl beyond fcp_cmnd
3159          *  fcp_rsp regions to the first data bde entry
3160          */
3161         if (scsi_sg_count(scsi_cmnd)) {
3162                 /*
3163                  * The driver stores the segment count returned from pci_map_sg
3164                  * because this a count of dma-mappings used to map the use_sg
3165                  * pages.  They are not guaranteed to be the same for those
3166                  * architectures that implement an IOMMU.
3167                  */
3168                 datasegcnt = dma_map_sg(&phba->pcidev->dev,
3169                                         scsi_sglist(scsi_cmnd),
3170                                         scsi_sg_count(scsi_cmnd), datadir);
3171                 if (unlikely(!datasegcnt))
3172                         return 1;
3173
3174                 sgl += 1;
3175                 /* clear the last flag in the fcp_rsp map entry */
3176                 sgl->word2 = le32_to_cpu(sgl->word2);
3177                 bf_set(lpfc_sli4_sge_last, sgl, 0);
3178                 sgl->word2 = cpu_to_le32(sgl->word2);
3179
3180                 sgl += 1;
3181                 lpfc_cmd->seg_cnt = datasegcnt;
3182                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
3183                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
3184                                         "9087 BLKGRD: %s: Too many sg segments"
3185                                         " from dma_map_sg.  Config %d, seg_cnt"
3186                                         " %d\n",
3187                                         __func__, phba->cfg_sg_seg_cnt,
3188                                         lpfc_cmd->seg_cnt);
3189                         scsi_dma_unmap(scsi_cmnd);
3190                         return 1;
3191                 }
3192
3193                 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
3194
3195                 switch (prot_group_type) {
3196                 case LPFC_PG_TYPE_NO_DIF:
3197                         num_bde = lpfc_bg_setup_sgl(phba, scsi_cmnd, sgl,
3198                                         datasegcnt);
3199                         /* we should have 2 or more entries in buffer list */
3200                         if (num_bde < 2)
3201                                 goto err;
3202                         break;
3203                 case LPFC_PG_TYPE_DIF_BUF:{
3204                         /*
3205                          * This type indicates that protection buffers are
3206                          * passed to the driver, so that needs to be prepared
3207                          * for DMA
3208                          */
3209                         protsegcnt = dma_map_sg(&phba->pcidev->dev,
3210                                         scsi_prot_sglist(scsi_cmnd),
3211                                         scsi_prot_sg_count(scsi_cmnd), datadir);
3212                         if (unlikely(!protsegcnt)) {
3213                                 scsi_dma_unmap(scsi_cmnd);
3214                                 return 1;
3215                         }
3216
3217                         lpfc_cmd->prot_seg_cnt = protsegcnt;
3218                         if (lpfc_cmd->prot_seg_cnt
3219                             > phba->cfg_prot_sg_seg_cnt) {
3220                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
3221                                         "9088 BLKGRD: %s: Too many prot sg "
3222                                         "segments from dma_map_sg.  Config %d,"
3223                                                 "prot_seg_cnt %d\n", __func__,
3224                                                 phba->cfg_prot_sg_seg_cnt,
3225                                                 lpfc_cmd->prot_seg_cnt);
3226                                 dma_unmap_sg(&phba->pcidev->dev,
3227                                              scsi_prot_sglist(scsi_cmnd),
3228                                              scsi_prot_sg_count(scsi_cmnd),
3229                                              datadir);
3230                                 scsi_dma_unmap(scsi_cmnd);
3231                                 return 1;
3232                         }
3233
3234                         num_bde = lpfc_bg_setup_sgl_prot(phba, scsi_cmnd, sgl,
3235                                         datasegcnt, protsegcnt);
3236                         /* we should have 3 or more entries in buffer list */
3237                         if (num_bde < 3)
3238                                 goto err;
3239                         break;
3240                 }
3241                 case LPFC_PG_TYPE_INVALID:
3242                 default:
3243                         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
3244                                         "9083 Unexpected protection group %i\n",
3245                                         prot_group_type);
3246                         return 1;
3247                 }
3248         }
3249
3250         switch (scsi_get_prot_op(scsi_cmnd)) {
3251         case SCSI_PROT_WRITE_STRIP:
3252         case SCSI_PROT_READ_STRIP:
3253                 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_STRIP;
3254                 break;
3255         case SCSI_PROT_WRITE_INSERT:
3256         case SCSI_PROT_READ_INSERT:
3257                 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_INSERT;
3258                 break;
3259         case SCSI_PROT_WRITE_PASS:
3260         case SCSI_PROT_READ_PASS:
3261                 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_PASS;
3262                 break;
3263         }
3264
3265         fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
3266
3267         fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
3268
3269         /*
3270          * Due to difference in data length between DIF/non-DIF paths,
3271          * we need to set word 4 of IOCB here
3272          */
3273         iocb_cmd->un.fcpi.fcpi_parm = fcpdl;
3274
3275         return 0;
3276 err:
3277         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
3278                         "9084 Could not setup all needed BDE's"
3279                         "prot_group_type=%d, num_bde=%d\n",
3280                         prot_group_type, num_bde);
3281         return 1;
3282 }
3283
3284 /**
3285  * lpfc_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer
3286  * @phba: The Hba for which this call is being executed.
3287  * @lpfc_cmd: The scsi buffer which is going to be mapped.
3288  *
3289  * This routine wraps the actual DMA mapping function pointer from the
3290  * lpfc_hba struct.
3291  *
3292  * Return codes:
3293  *      1 - Error
3294  *      0 - Success
3295  **/
3296 static inline int
3297 lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
3298 {
3299         return phba->lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
3300 }
3301
3302 /**
3303  * lpfc_bg_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer
3304  * using BlockGuard.
3305  * @phba: The Hba for which this call is being executed.
3306  * @lpfc_cmd: The scsi buffer which is going to be mapped.
3307  *
3308  * This routine wraps the actual DMA mapping function pointer from the
3309  * lpfc_hba struct.
3310  *
3311  * Return codes:
3312  *      1 - Error
3313  *      0 - Success
3314  **/
3315 static inline int
3316 lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
3317 {
3318         return phba->lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
3319 }
3320
3321 /**
3322  * lpfc_send_scsi_error_event - Posts an event when there is SCSI error
3323  * @phba: Pointer to hba context object.
3324  * @vport: Pointer to vport object.
3325  * @lpfc_cmd: Pointer to lpfc scsi command which reported the error.
3326  * @rsp_iocb: Pointer to response iocb object which reported error.
3327  *
3328  * This function posts an event when there is a SCSI command reporting
3329  * error from the scsi device.
3330  **/
3331 static void
3332 lpfc_send_scsi_error_event(struct lpfc_hba *phba, struct lpfc_vport *vport,
3333                 struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_iocbq *rsp_iocb) {
3334         struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3335         struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3336         uint32_t resp_info = fcprsp->rspStatus2;
3337         uint32_t scsi_status = fcprsp->rspStatus3;
3338         uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
3339         struct lpfc_fast_path_event *fast_path_evt = NULL;
3340         struct lpfc_nodelist *pnode = lpfc_cmd->rdata->pnode;
3341         unsigned long flags;
3342
3343         if (!pnode || !NLP_CHK_NODE_ACT(pnode))
3344                 return;
3345
3346         /* If there is queuefull or busy condition send a scsi event */
3347         if ((cmnd->result == SAM_STAT_TASK_SET_FULL) ||
3348                 (cmnd->result == SAM_STAT_BUSY)) {
3349                 fast_path_evt = lpfc_alloc_fast_evt(phba);
3350                 if (!fast_path_evt)
3351                         return;
3352                 fast_path_evt->un.scsi_evt.event_type =
3353                         FC_REG_SCSI_EVENT;
3354                 fast_path_evt->un.scsi_evt.subcategory =
3355                 (cmnd->result == SAM_STAT_TASK_SET_FULL) ?
3356                 LPFC_EVENT_QFULL : LPFC_EVENT_DEVBSY;
3357                 fast_path_evt->un.scsi_evt.lun = cmnd->device->lun;
3358                 memcpy(&fast_path_evt->un.scsi_evt.wwpn,
3359                         &pnode->nlp_portname, sizeof(struct lpfc_name));
3360                 memcpy(&fast_path_evt->un.scsi_evt.wwnn,
3361                         &pnode->nlp_nodename, sizeof(struct lpfc_name));
3362         } else if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen &&
3363                 ((cmnd->cmnd[0] == READ_10) || (cmnd->cmnd[0] == WRITE_10))) {
3364                 fast_path_evt = lpfc_alloc_fast_evt(phba);
3365                 if (!fast_path_evt)
3366                         return;
3367                 fast_path_evt->un.check_cond_evt.scsi_event.event_type =
3368                         FC_REG_SCSI_EVENT;
3369                 fast_path_evt->un.check_cond_evt.scsi_event.subcategory =
3370                         LPFC_EVENT_CHECK_COND;
3371                 fast_path_evt->un.check_cond_evt.scsi_event.lun =
3372                         cmnd->device->lun;
3373                 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwpn,
3374                         &pnode->nlp_portname, sizeof(struct lpfc_name));
3375                 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwnn,
3376                         &pnode->nlp_nodename, sizeof(struct lpfc_name));
3377                 fast_path_evt->un.check_cond_evt.sense_key =
3378                         cmnd->sense_buffer[2] & 0xf;
3379                 fast_path_evt->un.check_cond_evt.asc = cmnd->sense_buffer[12];
3380                 fast_path_evt->un.check_cond_evt.ascq = cmnd->sense_buffer[13];
3381         } else if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
3382                      fcpi_parm &&
3383                      ((be32_to_cpu(fcprsp->rspResId) != fcpi_parm) ||
3384                         ((scsi_status == SAM_STAT_GOOD) &&
3385                         !(resp_info & (RESID_UNDER | RESID_OVER))))) {
3386                 /*
3387                  * If status is good or resid does not match with fcp_param and
3388                  * there is valid fcpi_parm, then there is a read_check error
3389                  */
3390                 fast_path_evt = lpfc_alloc_fast_evt(phba);
3391                 if (!fast_path_evt)
3392                         return;
3393                 fast_path_evt->un.read_check_error.header.event_type =
3394                         FC_REG_FABRIC_EVENT;
3395                 fast_path_evt->un.read_check_error.header.subcategory =
3396                         LPFC_EVENT_FCPRDCHKERR;
3397                 memcpy(&fast_path_evt->un.read_check_error.header.wwpn,
3398                         &pnode->nlp_portname, sizeof(struct lpfc_name));
3399                 memcpy(&fast_path_evt->un.read_check_error.header.wwnn,
3400                         &pnode->nlp_nodename, sizeof(struct lpfc_name));
3401                 fast_path_evt->un.read_check_error.lun = cmnd->device->lun;
3402                 fast_path_evt->un.read_check_error.opcode = cmnd->cmnd[0];
3403                 fast_path_evt->un.read_check_error.fcpiparam =
3404                         fcpi_parm;
3405         } else
3406                 return;
3407
3408         fast_path_evt->vport = vport;
3409         spin_lock_irqsave(&phba->hbalock, flags);
3410         list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list);
3411         spin_unlock_irqrestore(&phba->hbalock, flags);
3412         lpfc_worker_wake_up(phba);
3413         return;
3414 }
3415
3416 /**
3417  * lpfc_scsi_unprep_dma_buf - Un-map DMA mapping of SG-list for dev
3418  * @phba: The HBA for which this call is being executed.
3419  * @psb: The scsi buffer which is going to be un-mapped.
3420  *
3421  * This routine does DMA un-mapping of scatter gather list of scsi command
3422  * field of @lpfc_cmd for device with SLI-3 interface spec.
3423  **/
3424 static void
3425 lpfc_scsi_unprep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
3426 {
3427         /*
3428          * There are only two special cases to consider.  (1) the scsi command
3429          * requested scatter-gather usage or (2) the scsi command allocated
3430          * a request buffer, but did not request use_sg.  There is a third
3431          * case, but it does not require resource deallocation.
3432          */
3433         if (psb->seg_cnt > 0)
3434                 scsi_dma_unmap(psb->pCmd);
3435         if (psb->prot_seg_cnt > 0)
3436                 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(psb->pCmd),
3437                                 scsi_prot_sg_count(psb->pCmd),
3438                                 psb->pCmd->sc_data_direction);
3439 }
3440
3441 /**
3442  * lpfc_handler_fcp_err - FCP response handler
3443  * @vport: The virtual port for which this call is being executed.
3444  * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
3445  * @rsp_iocb: The response IOCB which contains FCP error.
3446  *
3447  * This routine is called to process response IOCB with status field
3448  * IOSTAT_FCP_RSP_ERROR. This routine sets result field of scsi command
3449  * based upon SCSI and FCP error.
3450  **/
3451 static void
3452 lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
3453                     struct lpfc_iocbq *rsp_iocb)
3454 {
3455         struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3456         struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
3457         struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3458         uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
3459         uint32_t resp_info = fcprsp->rspStatus2;
3460         uint32_t scsi_status = fcprsp->rspStatus3;
3461         uint32_t *lp;
3462         uint32_t host_status = DID_OK;
3463         uint32_t rsplen = 0;
3464         uint32_t logit = LOG_FCP | LOG_FCP_ERROR;
3465
3466
3467         /*
3468          *  If this is a task management command, there is no
3469          *  scsi packet associated with this lpfc_cmd.  The driver
3470          *  consumes it.
3471          */
3472         if (fcpcmd->fcpCntl2) {
3473                 scsi_status = 0;
3474                 goto out;
3475         }
3476
3477         if (resp_info & RSP_LEN_VALID) {
3478                 rsplen = be32_to_cpu(fcprsp->rspRspLen);
3479                 if (rsplen != 0 && rsplen != 4 && rsplen != 8) {
3480                         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
3481                                  "2719 Invalid response length: "
3482                                  "tgt x%x lun x%x cmnd x%x rsplen x%x\n",
3483                                  cmnd->device->id,
3484                                  cmnd->device->lun, cmnd->cmnd[0],
3485                                  rsplen);
3486                         host_status = DID_ERROR;
3487                         goto out;
3488                 }
3489                 if (fcprsp->rspInfo3 != RSP_NO_FAILURE) {
3490                         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
3491                                  "2757 Protocol failure detected during "
3492                                  "processing of FCP I/O op: "
3493                                  "tgt x%x lun x%x cmnd x%x rspInfo3 x%x\n",
3494                                  cmnd->device->id,
3495                                  cmnd->device->lun, cmnd->cmnd[0],
3496                                  fcprsp->rspInfo3);
3497                         host_status = DID_ERROR;
3498                         goto out;
3499                 }
3500         }
3501
3502         if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) {
3503                 uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen);
3504                 if (snslen > SCSI_SENSE_BUFFERSIZE)
3505                         snslen = SCSI_SENSE_BUFFERSIZE;
3506
3507                 if (resp_info & RSP_LEN_VALID)
3508                   rsplen = be32_to_cpu(fcprsp->rspRspLen);
3509                 memcpy(cmnd->sense_buffer, &fcprsp->rspInfo0 + rsplen, snslen);
3510         }
3511         lp = (uint32_t *)cmnd->sense_buffer;
3512
3513         /* special handling for under run conditions */
3514         if (!scsi_status && (resp_info & RESID_UNDER)) {
3515                 /* don't log under runs if fcp set... */
3516                 if (vport->cfg_log_verbose & LOG_FCP)
3517                         logit = LOG_FCP_ERROR;
3518                 /* unless operator says so */
3519                 if (vport->cfg_log_verbose & LOG_FCP_UNDER)
3520                         logit = LOG_FCP_UNDER;
3521         }
3522
3523         lpfc_printf_vlog(vport, KERN_WARNING, logit,
3524                          "9024 FCP command x%x failed: x%x SNS x%x x%x "
3525                          "Data: x%x x%x x%x x%x x%x\n",
3526                          cmnd->cmnd[0], scsi_status,
3527                          be32_to_cpu(*lp), be32_to_cpu(*(lp + 3)), resp_info,
3528                          be32_to_cpu(fcprsp->rspResId),
3529                          be32_to_cpu(fcprsp->rspSnsLen),
3530                          be32_to_cpu(fcprsp->rspRspLen),
3531                          fcprsp->rspInfo3);
3532
3533         scsi_set_resid(cmnd, 0);
3534         if (resp_info & RESID_UNDER) {
3535                 scsi_set_resid(cmnd, be32_to_cpu(fcprsp->rspResId));
3536
3537                 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP_UNDER,
3538                                  "9025 FCP Read Underrun, expected %d, "
3539                                  "residual %d Data: x%x x%x x%x\n",
3540                                  be32_to_cpu(fcpcmd->fcpDl),
3541                                  scsi_get_resid(cmnd), fcpi_parm, cmnd->cmnd[0],
3542                                  cmnd->underflow);
3543
3544                 /*
3545                  * If there is an under run check if under run reported by
3546                  * storage array is same as the under run reported by HBA.
3547                  * If this is not same, there is a dropped frame.
3548                  */
3549                 if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
3550                         fcpi_parm &&
3551                         (scsi_get_resid(cmnd) != fcpi_parm)) {
3552                         lpfc_printf_vlog(vport, KERN_WARNING,
3553                                          LOG_FCP | LOG_FCP_ERROR,
3554                                          "9026 FCP Read Check Error "
3555                                          "and Underrun Data: x%x x%x x%x x%x\n",
3556                                          be32_to_cpu(fcpcmd->fcpDl),
3557                                          scsi_get_resid(cmnd), fcpi_parm,
3558                                          cmnd->cmnd[0]);
3559                         scsi_set_resid(cmnd, scsi_bufflen(cmnd));
3560                         host_status = DID_ERROR;
3561                 }
3562                 /*
3563                  * The cmnd->underflow is the minimum number of bytes that must
3564                  * be transferred for this command.  Provided a sense condition
3565                  * is not present, make sure the actual amount transferred is at
3566                  * least the underflow value or fail.
3567                  */
3568                 if (!(resp_info & SNS_LEN_VALID) &&
3569                     (scsi_status == SAM_STAT_GOOD) &&
3570                     (scsi_bufflen(cmnd) - scsi_get_resid(cmnd)
3571                      < cmnd->underflow)) {
3572                         lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
3573                                          "9027 FCP command x%x residual "
3574                                          "underrun converted to error "
3575                                          "Data: x%x x%x x%x\n",
3576                                          cmnd->cmnd[0], scsi_bufflen(cmnd),
3577                                          scsi_get_resid(cmnd), cmnd->underflow);
3578                         host_status = DID_ERROR;
3579                 }
3580         } else if (resp_info & RESID_OVER) {
3581                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
3582                                  "9028 FCP command x%x residual overrun error. "
3583                                  "Data: x%x x%x\n", cmnd->cmnd[0],
3584                                  scsi_bufflen(cmnd), scsi_get_resid(cmnd));
3585                 host_status = DID_ERROR;
3586
3587         /*
3588          * Check SLI validation that all the transfer was actually done
3589          * (fcpi_parm should be zero).
3590          */
3591         } else if (fcpi_parm) {
3592                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP | LOG_FCP_ERROR,
3593                                  "9029 FCP Data Transfer Check Error: "
3594                                  "x%x x%x x%x x%x x%x\n",
3595                                  be32_to_cpu(fcpcmd->fcpDl),
3596                                  be32_to_cpu(fcprsp->rspResId),
3597                                  fcpi_parm, cmnd->cmnd[0], scsi_status);
3598                 switch (scsi_status) {
3599                 case SAM_STAT_GOOD:
3600                 case SAM_STAT_CHECK_CONDITION:
3601                         /* Fabric dropped a data frame. Fail any successful
3602                          * command in which we detected dropped frames.
3603                          * A status of good or some check conditions could
3604                          * be considered a successful command.
3605                          */
3606                         host_status = DID_ERROR;
3607                         break;
3608                 }
3609                 scsi_set_resid(cmnd, scsi_bufflen(cmnd));
3610         }
3611
3612  out:
3613         cmnd->result = ScsiResult(host_status, scsi_status);
3614         lpfc_send_scsi_error_event(vport->phba, vport, lpfc_cmd, rsp_iocb);
3615 }
3616
3617 /**
3618  * lpfc_scsi_cmd_iocb_cmpl - Scsi cmnd IOCB completion routine
3619  * @phba: The Hba for which this call is being executed.
3620  * @pIocbIn: The command IOCBQ for the scsi cmnd.
3621  * @pIocbOut: The response IOCBQ for the scsi cmnd.
3622  *
3623  * This routine assigns scsi command result by looking into response IOCB
3624  * status field appropriately. This routine handles QUEUE FULL condition as
3625  * well by ramping down device queue depth.
3626  **/
3627 static void
3628 lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
3629                         struct lpfc_iocbq *pIocbOut)
3630 {
3631         struct lpfc_scsi_buf *lpfc_cmd =
3632                 (struct lpfc_scsi_buf *) pIocbIn->context1;
3633         struct lpfc_vport      *vport = pIocbIn->vport;
3634         struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
3635         struct lpfc_nodelist *pnode = rdata->pnode;
3636         struct scsi_cmnd *cmd;
3637         int result;
3638         struct scsi_device *tmp_sdev;
3639         int depth;
3640         unsigned long flags;
3641         struct lpfc_fast_path_event *fast_path_evt;
3642         struct Scsi_Host *shost;
3643         uint32_t queue_depth, scsi_id;
3644         uint32_t logit = LOG_FCP;
3645
3646         /* Sanity check on return of outstanding command */
3647         if (!(lpfc_cmd->pCmd))
3648                 return;
3649         cmd = lpfc_cmd->pCmd;
3650         shost = cmd->device->host;
3651
3652         lpfc_cmd->result = (pIocbOut->iocb.un.ulpWord[4] & IOERR_PARAM_MASK);
3653         lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
3654         /* pick up SLI4 exhange busy status from HBA */
3655         lpfc_cmd->exch_busy = pIocbOut->iocb_flag & LPFC_EXCHANGE_BUSY;
3656
3657 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
3658         if (lpfc_cmd->prot_data_type) {
3659                 struct scsi_dif_tuple *src = NULL;
3660
3661                 src =  (struct scsi_dif_tuple *)lpfc_cmd->prot_data_segment;
3662                 /*
3663                  * Used to restore any changes to protection
3664                  * data for error injection.
3665                  */
3666                 switch (lpfc_cmd->prot_data_type) {
3667                 case LPFC_INJERR_REFTAG:
3668                         src->ref_tag =
3669                                 lpfc_cmd->prot_data;
3670                         break;
3671                 case LPFC_INJERR_APPTAG:
3672                         src->app_tag =
3673                                 (uint16_t)lpfc_cmd->prot_data;
3674                         break;
3675                 case LPFC_INJERR_GUARD:
3676                         src->guard_tag =
3677                                 (uint16_t)lpfc_cmd->prot_data;
3678                         break;
3679                 default:
3680                         break;
3681                 }
3682
3683                 lpfc_cmd->prot_data = 0;
3684                 lpfc_cmd->prot_data_type = 0;
3685                 lpfc_cmd->prot_data_segment = NULL;
3686         }
3687 #endif
3688         if (pnode && NLP_CHK_NODE_ACT(pnode))
3689                 atomic_dec(&pnode->cmd_pending);
3690
3691         if (lpfc_cmd->status) {
3692                 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
3693                     (lpfc_cmd->result & IOERR_DRVR_MASK))
3694                         lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
3695                 else if (lpfc_cmd->status >= IOSTAT_CNT)
3696                         lpfc_cmd->status = IOSTAT_DEFAULT;
3697                 if (lpfc_cmd->status == IOSTAT_FCP_RSP_ERROR &&
3698                     !lpfc_cmd->fcp_rsp->rspStatus3 &&
3699                     (lpfc_cmd->fcp_rsp->rspStatus2 & RESID_UNDER) &&
3700                     !(vport->cfg_log_verbose & LOG_FCP_UNDER))
3701                         logit = 0;
3702                 else
3703                         logit = LOG_FCP | LOG_FCP_UNDER;
3704                 lpfc_printf_vlog(vport, KERN_WARNING, logit,
3705                          "9030 FCP cmd x%x failed <%d/%d> "
3706                          "status: x%x result: x%x "
3707                          "sid: x%x did: x%x oxid: x%x "
3708                          "Data: x%x x%x\n",
3709                          cmd->cmnd[0],
3710                          cmd->device ? cmd->device->id : 0xffff,
3711                          cmd->device ? cmd->device->lun : 0xffff,
3712                          lpfc_cmd->status, lpfc_cmd->result,
3713                          vport->fc_myDID, pnode->nlp_DID,
3714                          phba->sli_rev == LPFC_SLI_REV4 ?
3715                              lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
3716                          pIocbOut->iocb.ulpContext,
3717                          lpfc_cmd->cur_iocbq.iocb.ulpIoTag);
3718
3719                 switch (lpfc_cmd->status) {
3720                 case IOSTAT_FCP_RSP_ERROR:
3721                         /* Call FCP RSP handler to determine result */
3722                         lpfc_handle_fcp_err(vport, lpfc_cmd, pIocbOut);
3723                         break;
3724                 case IOSTAT_NPORT_BSY:
3725                 case IOSTAT_FABRIC_BSY:
3726                         cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED, 0);
3727                         fast_path_evt = lpfc_alloc_fast_evt(phba);
3728                         if (!fast_path_evt)
3729                                 break;
3730                         fast_path_evt->un.fabric_evt.event_type =
3731                                 FC_REG_FABRIC_EVENT;
3732                         fast_path_evt->un.fabric_evt.subcategory =
3733                                 (lpfc_cmd->status == IOSTAT_NPORT_BSY) ?
3734                                 LPFC_EVENT_PORT_BUSY : LPFC_EVENT_FABRIC_BUSY;
3735                         if (pnode && NLP_CHK_NODE_ACT(pnode)) {
3736                                 memcpy(&fast_path_evt->un.fabric_evt.wwpn,
3737                                         &pnode->nlp_portname,
3738                                         sizeof(struct lpfc_name));
3739                                 memcpy(&fast_path_evt->un.fabric_evt.wwnn,
3740                                         &pnode->nlp_nodename,
3741                                         sizeof(struct lpfc_name));
3742                         }
3743                         fast_path_evt->vport = vport;
3744                         fast_path_evt->work_evt.evt =
3745                                 LPFC_EVT_FASTPATH_MGMT_EVT;
3746                         spin_lock_irqsave(&phba->hbalock, flags);
3747                         list_add_tail(&fast_path_evt->work_evt.evt_listp,
3748                                 &phba->work_list);
3749                         spin_unlock_irqrestore(&phba->hbalock, flags);
3750                         lpfc_worker_wake_up(phba);
3751                         break;
3752                 case IOSTAT_LOCAL_REJECT:
3753                 case IOSTAT_REMOTE_STOP:
3754                         if (lpfc_cmd->result == IOERR_ELXSEC_KEY_UNWRAP_ERROR ||
3755                             lpfc_cmd->result ==
3756                                         IOERR_ELXSEC_KEY_UNWRAP_COMPARE_ERROR ||
3757                             lpfc_cmd->result == IOERR_ELXSEC_CRYPTO_ERROR ||
3758                             lpfc_cmd->result ==
3759                                         IOERR_ELXSEC_CRYPTO_COMPARE_ERROR) {
3760                                 cmd->result = ScsiResult(DID_NO_CONNECT, 0);
3761                                 break;
3762                         }
3763                         if (lpfc_cmd->result == IOERR_INVALID_RPI ||
3764                             lpfc_cmd->result == IOERR_NO_RESOURCES ||
3765                             lpfc_cmd->result == IOERR_ABORT_REQUESTED ||
3766                             lpfc_cmd->result == IOERR_SLER_CMD_RCV_FAILURE) {
3767                                 cmd->result = ScsiResult(DID_REQUEUE, 0);
3768                                 break;
3769                         }
3770                         if ((lpfc_cmd->result == IOERR_RX_DMA_FAILED ||
3771                              lpfc_cmd->result == IOERR_TX_DMA_FAILED) &&
3772                              pIocbOut->iocb.unsli3.sli3_bg.bgstat) {
3773                                 if (scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
3774                                         /*
3775                                          * This is a response for a BG enabled
3776                                          * cmd. Parse BG error
3777                                          */
3778                                         lpfc_parse_bg_err(phba, lpfc_cmd,
3779                                                         pIocbOut);
3780                                         break;
3781                                 } else {
3782                                         lpfc_printf_vlog(vport, KERN_WARNING,
3783                                                         LOG_BG,
3784                                                         "9031 non-zero BGSTAT "
3785                                                         "on unprotected cmd\n");
3786                                 }
3787                         }
3788                         if ((lpfc_cmd->status == IOSTAT_REMOTE_STOP)
3789                                 && (phba->sli_rev == LPFC_SLI_REV4)
3790                                 && (pnode && NLP_CHK_NODE_ACT(pnode))) {
3791                                 /* This IO was aborted by the target, we don't
3792                                  * know the rxid and because we did not send the
3793                                  * ABTS we cannot generate and RRQ.
3794                                  */
3795                                 lpfc_set_rrq_active(phba, pnode,
3796                                         lpfc_cmd->cur_iocbq.sli4_lxritag,
3797                                         0, 0);
3798                         }
3799                 /* else: fall through */
3800                 default:
3801                         cmd->result = ScsiResult(DID_ERROR, 0);
3802                         break;
3803                 }
3804
3805                 if (!pnode || !NLP_CHK_NODE_ACT(pnode)
3806                     || (pnode->nlp_state != NLP_STE_MAPPED_NODE))
3807                         cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED,
3808                                                  SAM_STAT_BUSY);
3809         } else
3810                 cmd->result = ScsiResult(DID_OK, 0);
3811
3812         if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) {
3813                 uint32_t *lp = (uint32_t *)cmd->sense_buffer;
3814
3815                 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
3816                                  "0710 Iodone <%d/%d> cmd %p, error "
3817                                  "x%x SNS x%x x%x Data: x%x x%x\n",
3818                                  cmd->device->id, cmd->device->lun, cmd,
3819                                  cmd->result, *lp, *(lp + 3), cmd->retries,
3820                                  scsi_get_resid(cmd));
3821         }
3822
3823         lpfc_update_stats(phba, lpfc_cmd);
3824         result = cmd->result;
3825         if (vport->cfg_max_scsicmpl_time &&
3826            time_after(jiffies, lpfc_cmd->start_time +
3827                 msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) {
3828                 spin_lock_irqsave(shost->host_lock, flags);
3829                 if (pnode && NLP_CHK_NODE_ACT(pnode)) {
3830                         if (pnode->cmd_qdepth >
3831                                 atomic_read(&pnode->cmd_pending) &&
3832                                 (atomic_read(&pnode->cmd_pending) >
3833                                 LPFC_MIN_TGT_QDEPTH) &&
3834                                 ((cmd->cmnd[0] == READ_10) ||
3835                                 (cmd->cmnd[0] == WRITE_10)))
3836                                 pnode->cmd_qdepth =
3837                                         atomic_read(&pnode->cmd_pending);
3838
3839                         pnode->last_change_time = jiffies;
3840                 }
3841                 spin_unlock_irqrestore(shost->host_lock, flags);
3842         } else if (pnode && NLP_CHK_NODE_ACT(pnode)) {
3843                 if ((pnode->cmd_qdepth < vport->cfg_tgt_queue_depth) &&
3844                    time_after(jiffies, pnode->last_change_time +
3845                               msecs_to_jiffies(LPFC_TGTQ_INTERVAL))) {
3846                         spin_lock_irqsave(shost->host_lock, flags);
3847                         depth = pnode->cmd_qdepth * LPFC_TGTQ_RAMPUP_PCENT
3848                                 / 100;
3849                         depth = depth ? depth : 1;
3850                         pnode->cmd_qdepth += depth;
3851                         if (pnode->cmd_qdepth > vport->cfg_tgt_queue_depth)
3852                                 pnode->cmd_qdepth = vport->cfg_tgt_queue_depth;
3853                         pnode->last_change_time = jiffies;
3854                         spin_unlock_irqrestore(shost->host_lock, flags);
3855                 }
3856         }
3857
3858         lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
3859
3860         /* The sdev is not guaranteed to be valid post scsi_done upcall. */
3861         queue_depth = cmd->device->queue_depth;
3862         scsi_id = cmd->device->id;
3863         cmd->scsi_done(cmd);
3864
3865         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
3866                 spin_lock_irqsave(&phba->hbalock, flags);
3867                 lpfc_cmd->pCmd = NULL;
3868                 spin_unlock_irqrestore(&phba->hbalock, flags);
3869
3870                 /*
3871                  * If there is a thread waiting for command completion
3872                  * wake up the thread.
3873                  */
3874                 spin_lock_irqsave(shost->host_lock, flags);
3875                 if (lpfc_cmd->waitq)
3876                         wake_up(lpfc_cmd->waitq);
3877                 spin_unlock_irqrestore(shost->host_lock, flags);
3878                 lpfc_release_scsi_buf(phba, lpfc_cmd);
3879                 return;
3880         }
3881
3882         if (!result)
3883                 lpfc_rampup_queue_depth(vport, queue_depth);
3884
3885         /*
3886          * Check for queue full.  If the lun is reporting queue full, then
3887          * back off the lun queue depth to prevent target overloads.
3888          */
3889         if (result == SAM_STAT_TASK_SET_FULL && pnode &&
3890             NLP_CHK_NODE_ACT(pnode)) {
3891                 shost_for_each_device(tmp_sdev, shost) {
3892                         if (tmp_sdev->id != scsi_id)
3893                                 continue;
3894                         depth = scsi_track_queue_full(tmp_sdev,
3895                                                       tmp_sdev->queue_depth-1);
3896                         if (depth <= 0)
3897                                 continue;
3898                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
3899                                          "0711 detected queue full - lun queue "
3900                                          "depth adjusted to %d.\n", depth);
3901                         lpfc_send_sdev_queuedepth_change_event(phba, vport,
3902                                                                pnode,
3903                                                                tmp_sdev->lun,
3904                                                                depth+1, depth);
3905                 }
3906         }
3907
3908         spin_lock_irqsave(&phba->hbalock, flags);
3909         lpfc_cmd->pCmd = NULL;
3910         spin_unlock_irqrestore(&phba->hbalock, flags);
3911
3912         /*
3913          * If there is a thread waiting for command completion
3914          * wake up the thread.
3915          */
3916         spin_lock_irqsave(shost->host_lock, flags);
3917         if (lpfc_cmd->waitq)
3918                 wake_up(lpfc_cmd->waitq);
3919         spin_unlock_irqrestore(shost->host_lock, flags);
3920
3921         lpfc_release_scsi_buf(phba, lpfc_cmd);
3922 }
3923
3924 /**
3925  * lpfc_fcpcmd_to_iocb - copy the fcp_cmd data into the IOCB
3926  * @data: A pointer to the immediate command data portion of the IOCB.
3927  * @fcp_cmnd: The FCP Command that is provided by the SCSI layer.
3928  *
3929  * The routine copies the entire FCP command from @fcp_cmnd to @data while
3930  * byte swapping the data to big endian format for transmission on the wire.
3931  **/
3932 static void
3933 lpfc_fcpcmd_to_iocb(uint8_t *data, struct fcp_cmnd *fcp_cmnd)
3934 {
3935         int i, j;
3936         for (i = 0, j = 0; i < sizeof(struct fcp_cmnd);
3937              i += sizeof(uint32_t), j++) {
3938                 ((uint32_t *)data)[j] = cpu_to_be32(((uint32_t *)fcp_cmnd)[j]);
3939         }
3940 }
3941
3942 /**
3943  * lpfc_scsi_prep_cmnd - Wrapper func for convert scsi cmnd to FCP info unit
3944  * @vport: The virtual port for which this call is being executed.
3945  * @lpfc_cmd: The scsi command which needs to send.
3946  * @pnode: Pointer to lpfc_nodelist.
3947  *
3948  * This routine initializes fcp_cmnd and iocb data structure from scsi command
3949  * to transfer for device with SLI3 interface spec.
3950  **/
3951 static void
3952 lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
3953                     struct lpfc_nodelist *pnode)
3954 {
3955         struct lpfc_hba *phba = vport->phba;
3956         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3957         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3958         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3959         struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
3960         int datadir = scsi_cmnd->sc_data_direction;
3961         char tag[2];
3962         uint8_t *ptr;
3963         bool sli4;
3964
3965         if (!pnode || !NLP_CHK_NODE_ACT(pnode))
3966                 return;
3967
3968         lpfc_cmd->fcp_rsp->rspSnsLen = 0;
3969         /* clear task management bits */
3970         lpfc_cmd->fcp_cmnd->fcpCntl2 = 0;
3971
3972         int_to_scsilun(lpfc_cmd->pCmd->device->lun,
3973                         &lpfc_cmd->fcp_cmnd->fcp_lun);
3974
3975         ptr = &fcp_cmnd->fcpCdb[0];
3976         memcpy(ptr, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
3977         if (scsi_cmnd->cmd_len < LPFC_FCP_CDB_LEN) {
3978                 ptr += scsi_cmnd->cmd_len;
3979                 memset(ptr, 0, (LPFC_FCP_CDB_LEN - scsi_cmnd->cmd_len));
3980         }
3981
3982         if (scsi_populate_tag_msg(scsi_cmnd, tag)) {
3983                 switch (tag[0]) {
3984                 case HEAD_OF_QUEUE_TAG:
3985                         fcp_cmnd->fcpCntl1 = HEAD_OF_Q;
3986                         break;
3987                 case ORDERED_QUEUE_TAG:
3988                         fcp_cmnd->fcpCntl1 = ORDERED_Q;
3989                         break;
3990                 default:
3991                         fcp_cmnd->fcpCntl1 = SIMPLE_Q;
3992                         break;
3993                 }
3994         } else
3995                 fcp_cmnd->fcpCntl1 = SIMPLE_Q;
3996
3997         sli4 = (phba->sli_rev == LPFC_SLI_REV4);
3998
3999         /*
4000          * There are three possibilities here - use scatter-gather segment, use
4001          * the single mapping, or neither.  Start the lpfc command prep by
4002          * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
4003          * data bde entry.
4004          */
4005         if (scsi_sg_count(scsi_cmnd)) {
4006                 if (datadir == DMA_TO_DEVICE) {
4007                         iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
4008                         if (sli4)
4009                                 iocb_cmd->ulpPU = PARM_READ_CHECK;
4010                         else {
4011                                 iocb_cmd->un.fcpi.fcpi_parm = 0;
4012                                 iocb_cmd->ulpPU = 0;
4013                         }
4014                         fcp_cmnd->fcpCntl3 = WRITE_DATA;
4015                         phba->fc4OutputRequests++;
4016                 } else {
4017                         iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR;
4018                         iocb_cmd->ulpPU = PARM_READ_CHECK;
4019                         fcp_cmnd->fcpCntl3 = READ_DATA;
4020                         phba->fc4InputRequests++;
4021                 }
4022         } else {
4023                 iocb_cmd->ulpCommand = CMD_FCP_ICMND64_CR;
4024                 iocb_cmd->un.fcpi.fcpi_parm = 0;
4025                 iocb_cmd->ulpPU = 0;
4026                 fcp_cmnd->fcpCntl3 = 0;
4027                 phba->fc4ControlRequests++;
4028         }
4029         if (phba->sli_rev == 3 &&
4030             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED))
4031                 lpfc_fcpcmd_to_iocb(iocb_cmd->unsli3.fcp_ext.icd, fcp_cmnd);
4032         /*
4033          * Finish initializing those IOCB fields that are independent
4034          * of the scsi_cmnd request_buffer
4035          */
4036         piocbq->iocb.ulpContext = pnode->nlp_rpi;
4037         if (sli4)
4038                 piocbq->iocb.ulpContext =
4039                   phba->sli4_hba.rpi_ids[pnode->nlp_rpi];
4040         if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE)
4041                 piocbq->iocb.ulpFCP2Rcvy = 1;
4042         else
4043                 piocbq->iocb.ulpFCP2Rcvy = 0;
4044
4045         piocbq->iocb.ulpClass = (pnode->nlp_fcp_info & 0x0f);
4046         piocbq->context1  = lpfc_cmd;
4047         piocbq->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
4048         piocbq->iocb.ulpTimeout = lpfc_cmd->timeout;
4049         piocbq->vport = vport;
4050 }
4051
4052 /**
4053  * lpfc_scsi_prep_task_mgmt_cmd - Convert SLI3 scsi TM cmd to FCP info unit
4054  * @vport: The virtual port for which this call is being executed.
4055  * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
4056  * @lun: Logical unit number.
4057  * @task_mgmt_cmd: SCSI task management command.
4058  *
4059  * This routine creates FCP information unit corresponding to @task_mgmt_cmd
4060  * for device with SLI-3 interface spec.
4061  *
4062  * Return codes:
4063  *   0 - Error
4064  *   1 - Success
4065  **/
4066 static int
4067 lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
4068                              struct lpfc_scsi_buf *lpfc_cmd,
4069                              unsigned int lun,
4070                              uint8_t task_mgmt_cmd)
4071 {
4072         struct lpfc_iocbq *piocbq;
4073         IOCB_t *piocb;
4074         struct fcp_cmnd *fcp_cmnd;
4075         struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
4076         struct lpfc_nodelist *ndlp = rdata->pnode;
4077
4078         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) ||
4079             ndlp->nlp_state != NLP_STE_MAPPED_NODE)
4080                 return 0;
4081
4082         piocbq = &(lpfc_cmd->cur_iocbq);
4083         piocbq->vport = vport;
4084
4085         piocb = &piocbq->iocb;
4086
4087         fcp_cmnd = lpfc_cmd->fcp_cmnd;
4088         /* Clear out any old data in the FCP command area */
4089         memset(fcp_cmnd, 0, sizeof(struct fcp_cmnd));
4090         int_to_scsilun(lun, &fcp_cmnd->fcp_lun);
4091         fcp_cmnd->fcpCntl2 = task_mgmt_cmd;
4092         if (vport->phba->sli_rev == 3 &&
4093             !(vport->phba->sli3_options & LPFC_SLI3_BG_ENABLED))
4094                 lpfc_fcpcmd_to_iocb(piocb->unsli3.fcp_ext.icd, fcp_cmnd);
4095         piocb->ulpCommand = CMD_FCP_ICMND64_CR;
4096         piocb->ulpContext = ndlp->nlp_rpi;
4097         if (vport->phba->sli_rev == LPFC_SLI_REV4) {
4098                 piocb->ulpContext =
4099                   vport->phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
4100         }
4101         if (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) {
4102                 piocb->ulpFCP2Rcvy = 1;
4103         }
4104         piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f);
4105
4106         /* ulpTimeout is only one byte */
4107         if (lpfc_cmd->timeout > 0xff) {
4108                 /*
4109                  * Do not timeout the command at the firmware level.
4110                  * The driver will provide the timeout mechanism.
4111                  */
4112                 piocb->ulpTimeout = 0;
4113         } else
4114                 piocb->ulpTimeout = lpfc_cmd->timeout;
4115
4116         if (vport->phba->sli_rev == LPFC_SLI_REV4)
4117                 lpfc_sli4_set_rsp_sgl_last(vport->phba, lpfc_cmd);
4118
4119         return 1;
4120 }
4121
4122 /**
4123  * lpfc_scsi_api_table_setup - Set up scsi api function jump table
4124  * @phba: The hba struct for which this call is being executed.
4125  * @dev_grp: The HBA PCI-Device group number.
4126  *
4127  * This routine sets up the SCSI interface API function jump table in @phba
4128  * struct.
4129  * Returns: 0 - success, -ENODEV - failure.
4130  **/
4131 int
4132 lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
4133 {
4134
4135         phba->lpfc_scsi_unprep_dma_buf = lpfc_scsi_unprep_dma_buf;
4136         phba->lpfc_scsi_prep_cmnd = lpfc_scsi_prep_cmnd;
4137
4138         switch (dev_grp) {
4139         case LPFC_PCI_DEV_LP:
4140                 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s3;
4141                 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s3;
4142                 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s3;
4143                 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s3;
4144                 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s3;
4145                 break;
4146         case LPFC_PCI_DEV_OC:
4147                 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s4;
4148                 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s4;
4149                 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s4;
4150                 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s4;
4151                 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s4;
4152                 break;
4153         default:
4154                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4155                                 "1418 Invalid HBA PCI-device group: 0x%x\n",
4156                                 dev_grp);
4157                 return -ENODEV;
4158                 break;
4159         }
4160         phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth;
4161         phba->lpfc_scsi_cmd_iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
4162         return 0;
4163 }
4164
4165 /**
4166  * lpfc_taskmgmt_def_cmpl - IOCB completion routine for task management command
4167  * @phba: The Hba for which this call is being executed.
4168  * @cmdiocbq: Pointer to lpfc_iocbq data structure.
4169  * @rspiocbq: Pointer to lpfc_iocbq data structure.
4170  *
4171  * This routine is IOCB completion routine for device reset and target reset
4172  * routine. This routine release scsi buffer associated with lpfc_cmd.
4173  **/
4174 static void
4175 lpfc_tskmgmt_def_cmpl(struct lpfc_hba *phba,
4176                         struct lpfc_iocbq *cmdiocbq,
4177                         struct lpfc_iocbq *rspiocbq)
4178 {
4179         struct lpfc_scsi_buf *lpfc_cmd =
4180                 (struct lpfc_scsi_buf *) cmdiocbq->context1;
4181         if (lpfc_cmd)
4182                 lpfc_release_scsi_buf(phba, lpfc_cmd);
4183         return;
4184 }
4185
4186 /**
4187  * lpfc_info - Info entry point of scsi_host_template data structure
4188  * @host: The scsi host for which this call is being executed.
4189  *
4190  * This routine provides module information about hba.
4191  *
4192  * Reutrn code:
4193  *   Pointer to char - Success.
4194  **/
4195 const char *
4196 lpfc_info(struct Scsi_Host *host)
4197 {
4198         struct lpfc_vport *vport = (struct lpfc_vport *) host->hostdata;
4199         struct lpfc_hba   *phba = vport->phba;
4200         int len, link_speed = 0;
4201         static char  lpfcinfobuf[384];
4202
4203         memset(lpfcinfobuf,0,384);
4204         if (phba && phba->pcidev){
4205                 strncpy(lpfcinfobuf, phba->ModelDesc, 256);
4206                 len = strlen(lpfcinfobuf);
4207                 snprintf(lpfcinfobuf + len,
4208                         384-len,
4209                         " on PCI bus %02x device %02x irq %d",
4210                         phba->pcidev->bus->number,
4211                         phba->pcidev->devfn,
4212                         phba->pcidev->irq);
4213                 len = strlen(lpfcinfobuf);
4214                 if (phba->Port[0]) {
4215                         snprintf(lpfcinfobuf + len,
4216                                  384-len,
4217                                  " port %s",
4218                                  phba->Port);
4219                 }
4220                 len = strlen(lpfcinfobuf);
4221                 if (phba->sli_rev <= LPFC_SLI_REV3) {
4222                         link_speed = lpfc_sli_port_speed_get(phba);
4223                 } else {
4224                         if (phba->sli4_hba.link_state.logical_speed)
4225                                 link_speed =
4226                                       phba->sli4_hba.link_state.logical_speed;
4227                         else
4228                                 link_speed = phba->sli4_hba.link_state.speed;
4229                 }
4230                 if (link_speed != 0)
4231                         snprintf(lpfcinfobuf + len, 384-len,
4232                                  " Logical Link Speed: %d Mbps", link_speed);
4233         }
4234         return lpfcinfobuf;
4235 }
4236
4237 /**
4238  * lpfc_poll_rearm_time - Routine to modify fcp_poll timer of hba
4239  * @phba: The Hba for which this call is being executed.
4240  *
4241  * This routine modifies fcp_poll_timer  field of @phba by cfg_poll_tmo.
4242  * The default value of cfg_poll_tmo is 10 milliseconds.
4243  **/
4244 static __inline__ void lpfc_poll_rearm_timer(struct lpfc_hba * phba)
4245 {
4246         unsigned long  poll_tmo_expires =
4247                 (jiffies + msecs_to_jiffies(phba->cfg_poll_tmo));
4248
4249         if (!list_empty(&phba->sli.ring[LPFC_FCP_RING].txcmplq))
4250                 mod_timer(&phba->fcp_poll_timer,
4251                           poll_tmo_expires);
4252 }
4253
4254 /**
4255  * lpfc_poll_start_timer - Routine to start fcp_poll_timer of HBA
4256  * @phba: The Hba for which this call is being executed.
4257  *
4258  * This routine starts the fcp_poll_timer of @phba.
4259  **/
4260 void lpfc_poll_start_timer(struct lpfc_hba * phba)
4261 {
4262         lpfc_poll_rearm_timer(phba);
4263 }
4264
4265 /**
4266  * lpfc_poll_timeout - Restart polling timer
4267  * @ptr: Map to lpfc_hba data structure pointer.
4268  *
4269  * This routine restarts fcp_poll timer, when FCP ring  polling is enable
4270  * and FCP Ring interrupt is disable.
4271  **/
4272
4273 void lpfc_poll_timeout(unsigned long ptr)
4274 {
4275         struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
4276
4277         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
4278                 lpfc_sli_handle_fast_ring_event(phba,
4279                         &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
4280
4281                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4282                         lpfc_poll_rearm_timer(phba);
4283         }
4284 }
4285
4286 /**
4287  * lpfc_queuecommand - scsi_host_template queuecommand entry point
4288  * @cmnd: Pointer to scsi_cmnd data structure.
4289  * @done: Pointer to done routine.
4290  *
4291  * Driver registers this routine to scsi midlayer to submit a @cmd to process.
4292  * This routine prepares an IOCB from scsi command and provides to firmware.
4293  * The @done callback is invoked after driver finished processing the command.
4294  *
4295  * Return value :
4296  *   0 - Success
4297  *   SCSI_MLQUEUE_HOST_BUSY - Block all devices served by this host temporarily.
4298  **/
4299 static int
4300 lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
4301 {
4302         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4303         struct lpfc_hba   *phba = vport->phba;
4304         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
4305         struct lpfc_nodelist *ndlp;
4306         struct lpfc_scsi_buf *lpfc_cmd;
4307         struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
4308         int err;
4309
4310         err = fc_remote_port_chkready(rport);
4311         if (err) {
4312                 cmnd->result = err;
4313                 goto out_fail_command;
4314         }
4315         ndlp = rdata->pnode;
4316
4317         if ((scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) &&
4318                 (!(phba->sli3_options & LPFC_SLI3_BG_ENABLED))) {
4319
4320                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4321                                 "9058 BLKGRD: ERROR: rcvd protected cmd:%02x"
4322                                 " op:%02x str=%s without registering for"
4323                                 " BlockGuard - Rejecting command\n",
4324                                 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
4325                                 dif_op_str[scsi_get_prot_op(cmnd)]);
4326                 goto out_fail_command;
4327         }
4328
4329         /*
4330          * Catch race where our node has transitioned, but the
4331          * transport is still transitioning.
4332          */
4333         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
4334                 goto out_tgt_busy;
4335         if (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth)
4336                 goto out_tgt_busy;
4337
4338         lpfc_cmd = lpfc_get_scsi_buf(phba, ndlp);
4339         if (lpfc_cmd == NULL) {
4340                 lpfc_rampdown_queue_depth(phba);
4341
4342                 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4343                                  "0707 driver's buffer pool is empty, "
4344                                  "IO busied\n");
4345                 goto out_host_busy;
4346         }
4347
4348         /*
4349          * Store the midlayer's command structure for the completion phase
4350          * and complete the command initialization.
4351          */
4352         lpfc_cmd->pCmd  = cmnd;
4353         lpfc_cmd->rdata = rdata;
4354         lpfc_cmd->timeout = 0;
4355         lpfc_cmd->start_time = jiffies;
4356         cmnd->host_scribble = (unsigned char *)lpfc_cmd;
4357
4358         if (scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
4359                 if (vport->phba->cfg_enable_bg) {
4360                         lpfc_printf_vlog(vport, KERN_INFO, LOG_BG,
4361                                          "9033 BLKGRD: rcvd %s cmd:x%x "
4362                                          "sector x%llx cnt %u pt %x\n",
4363                                          dif_op_str[scsi_get_prot_op(cmnd)],
4364                                          cmnd->cmnd[0],
4365                                          (unsigned long long)scsi_get_lba(cmnd),
4366                                          blk_rq_sectors(cmnd->request),
4367                                          (cmnd->cmnd[1]>>5));
4368                 }
4369                 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
4370         } else {
4371                 if (vport->phba->cfg_enable_bg) {
4372                         lpfc_printf_vlog(vport, KERN_INFO, LOG_BG,
4373                                          "9038 BLKGRD: rcvd PROT_NORMAL cmd: "
4374                                          "x%x sector x%llx cnt %u pt %x\n",
4375                                          cmnd->cmnd[0],
4376                                          (unsigned long long)scsi_get_lba(cmnd),
4377                                          blk_rq_sectors(cmnd->request),
4378                                          (cmnd->cmnd[1]>>5));
4379                 }
4380                 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
4381         }
4382
4383         if (err)
4384                 goto out_host_busy_free_buf;
4385
4386         lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp);
4387
4388         atomic_inc(&ndlp->cmd_pending);
4389         err = lpfc_sli_issue_iocb(phba, LPFC_FCP_RING,
4390                                   &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
4391         if (err) {
4392                 atomic_dec(&ndlp->cmd_pending);
4393                 goto out_host_busy_free_buf;
4394         }
4395         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
4396                 lpfc_sli_handle_fast_ring_event(phba,
4397                         &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
4398
4399                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4400                         lpfc_poll_rearm_timer(phba);
4401         }
4402
4403         return 0;
4404
4405  out_host_busy_free_buf:
4406         lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
4407         lpfc_release_scsi_buf(phba, lpfc_cmd);
4408  out_host_busy:
4409         return SCSI_MLQUEUE_HOST_BUSY;
4410
4411  out_tgt_busy:
4412         return SCSI_MLQUEUE_TARGET_BUSY;
4413
4414  out_fail_command:
4415         cmnd->scsi_done(cmnd);
4416         return 0;
4417 }
4418
4419
4420 /**
4421  * lpfc_abort_handler - scsi_host_template eh_abort_handler entry point
4422  * @cmnd: Pointer to scsi_cmnd data structure.
4423  *
4424  * This routine aborts @cmnd pending in base driver.
4425  *
4426  * Return code :
4427  *   0x2003 - Error
4428  *   0x2002 - Success
4429  **/
4430 static int
4431 lpfc_abort_handler(struct scsi_cmnd *cmnd)
4432 {
4433         struct Scsi_Host  *shost = cmnd->device->host;
4434         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4435         struct lpfc_hba   *phba = vport->phba;
4436         struct lpfc_iocbq *iocb;
4437         struct lpfc_iocbq *abtsiocb;
4438         struct lpfc_scsi_buf *lpfc_cmd;
4439         IOCB_t *cmd, *icmd;
4440         int ret = SUCCESS, status = 0;
4441         unsigned long flags;
4442         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq);
4443
4444         status = fc_block_scsi_eh(cmnd);
4445         if (status != 0 && status != SUCCESS)
4446                 return status;
4447
4448         spin_lock_irqsave(&phba->hbalock, flags);
4449         /* driver queued commands are in process of being flushed */
4450         if (phba->hba_flag & HBA_FCP_IOQ_FLUSH) {
4451                 spin_unlock_irqrestore(&phba->hbalock, flags);
4452                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4453                         "3168 SCSI Layer abort requested I/O has been "
4454                         "flushed by LLD.\n");
4455                 return FAILED;
4456         }
4457
4458         lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble;
4459         if (!lpfc_cmd || !lpfc_cmd->pCmd) {
4460                 spin_unlock_irqrestore(&phba->hbalock, flags);
4461                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4462                          "2873 SCSI Layer I/O Abort Request IO CMPL Status "
4463                          "x%x ID %d LUN %d\n",
4464                          SUCCESS, cmnd->device->id, cmnd->device->lun);
4465                 return SUCCESS;
4466         }
4467
4468         iocb = &lpfc_cmd->cur_iocbq;
4469         /* the command is in process of being cancelled */
4470         if (!(iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ)) {
4471                 spin_unlock_irqrestore(&phba->hbalock, flags);
4472                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4473                         "3169 SCSI Layer abort requested I/O has been "
4474                         "cancelled by LLD.\n");
4475                 return FAILED;
4476         }
4477         /*
4478          * If pCmd field of the corresponding lpfc_scsi_buf structure
4479          * points to a different SCSI command, then the driver has
4480          * already completed this command, but the midlayer did not
4481          * see the completion before the eh fired. Just return SUCCESS.
4482          */
4483         if (lpfc_cmd->pCmd != cmnd) {
4484                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4485                         "3170 SCSI Layer abort requested I/O has been "
4486                         "completed by LLD.\n");
4487                 goto out_unlock;
4488         }
4489
4490         BUG_ON(iocb->context1 != lpfc_cmd);
4491
4492         abtsiocb = __lpfc_sli_get_iocbq(phba);
4493         if (abtsiocb == NULL) {
4494                 ret = FAILED;
4495                 goto out_unlock;
4496         }
4497
4498         /*
4499          * The scsi command can not be in txq and it is in flight because the
4500          * pCmd is still pointig at the SCSI command we have to abort. There
4501          * is no need to search the txcmplq. Just send an abort to the FW.
4502          */
4503
4504         cmd = &iocb->iocb;
4505         icmd = &abtsiocb->iocb;
4506         icmd->un.acxri.abortType = ABORT_TYPE_ABTS;
4507         icmd->un.acxri.abortContextTag = cmd->ulpContext;
4508         if (phba->sli_rev == LPFC_SLI_REV4)
4509                 icmd->un.acxri.abortIoTag = iocb->sli4_xritag;
4510         else
4511                 icmd->un.acxri.abortIoTag = cmd->ulpIoTag;
4512
4513         icmd->ulpLe = 1;
4514         icmd->ulpClass = cmd->ulpClass;
4515
4516         /* ABTS WQE must go to the same WQ as the WQE to be aborted */
4517         abtsiocb->fcp_wqidx = iocb->fcp_wqidx;
4518         abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
4519
4520         if (lpfc_is_link_up(phba))
4521                 icmd->ulpCommand = CMD_ABORT_XRI_CN;
4522         else
4523                 icmd->ulpCommand = CMD_CLOSE_XRI_CN;
4524
4525         abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
4526         abtsiocb->vport = vport;
4527         /* no longer need the lock after this point */
4528         spin_unlock_irqrestore(&phba->hbalock, flags);
4529
4530         if (lpfc_sli_issue_iocb(phba, LPFC_FCP_RING, abtsiocb, 0) ==
4531             IOCB_ERROR) {
4532                 lpfc_sli_release_iocbq(phba, abtsiocb);
4533                 ret = FAILED;
4534                 goto out;
4535         }
4536
4537         if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4538                 lpfc_sli_handle_fast_ring_event(phba,
4539                         &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
4540
4541         lpfc_cmd->waitq = &waitq;
4542         /* Wait for abort to complete */
4543         wait_event_timeout(waitq,
4544                           (lpfc_cmd->pCmd != cmnd),
4545                            (2*vport->cfg_devloss_tmo*HZ));
4546         lpfc_cmd->waitq = NULL;
4547
4548         if (lpfc_cmd->pCmd == cmnd) {
4549                 ret = FAILED;
4550                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4551                                  "0748 abort handler timed out waiting "
4552                                  "for abortng I/O (xri:x%x) to complete: "
4553                                  "ret %#x, ID %d, LUN %d\n",
4554                                  iocb->sli4_xritag, ret,
4555                                  cmnd->device->id, cmnd->device->lun);
4556         }
4557         goto out;
4558
4559 out_unlock:
4560         spin_unlock_irqrestore(&phba->hbalock, flags);
4561 out:
4562         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4563                          "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
4564                          "LUN %d\n", ret, cmnd->device->id,
4565                          cmnd->device->lun);
4566         return ret;
4567 }
4568
4569 static char *
4570 lpfc_taskmgmt_name(uint8_t task_mgmt_cmd)
4571 {
4572         switch (task_mgmt_cmd) {
4573         case FCP_ABORT_TASK_SET:
4574                 return "ABORT_TASK_SET";
4575         case FCP_CLEAR_TASK_SET:
4576                 return "FCP_CLEAR_TASK_SET";
4577         case FCP_BUS_RESET:
4578                 return "FCP_BUS_RESET";
4579         case FCP_LUN_RESET:
4580                 return "FCP_LUN_RESET";
4581         case FCP_TARGET_RESET:
4582                 return "FCP_TARGET_RESET";
4583         case FCP_CLEAR_ACA:
4584                 return "FCP_CLEAR_ACA";
4585         case FCP_TERMINATE_TASK:
4586                 return "FCP_TERMINATE_TASK";
4587         default:
4588                 return "unknown";
4589         }
4590 }
4591
4592 /**
4593  * lpfc_send_taskmgmt - Generic SCSI Task Mgmt Handler
4594  * @vport: The virtual port for which this call is being executed.
4595  * @rdata: Pointer to remote port local data
4596  * @tgt_id: Target ID of remote device.
4597  * @lun_id: Lun number for the TMF
4598  * @task_mgmt_cmd: type of TMF to send
4599  *
4600  * This routine builds and sends a TMF (SCSI Task Mgmt Function) to
4601  * a remote port.
4602  *
4603  * Return Code:
4604  *   0x2003 - Error
4605  *   0x2002 - Success.
4606  **/
4607 static int
4608 lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata,
4609                     unsigned  tgt_id, unsigned int lun_id,
4610                     uint8_t task_mgmt_cmd)
4611 {
4612         struct lpfc_hba   *phba = vport->phba;
4613         struct lpfc_scsi_buf *lpfc_cmd;
4614         struct lpfc_iocbq *iocbq;
4615         struct lpfc_iocbq *iocbqrsp;
4616         struct lpfc_nodelist *pnode = rdata->pnode;
4617         int ret;
4618         int status;
4619
4620         if (!pnode || !NLP_CHK_NODE_ACT(pnode))
4621                 return FAILED;
4622
4623         lpfc_cmd = lpfc_get_scsi_buf(phba, rdata->pnode);
4624         if (lpfc_cmd == NULL)
4625                 return FAILED;
4626         lpfc_cmd->timeout = 60;
4627         lpfc_cmd->rdata = rdata;
4628
4629         status = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun_id,
4630                                            task_mgmt_cmd);
4631         if (!status) {
4632                 lpfc_release_scsi_buf(phba, lpfc_cmd);
4633                 return FAILED;
4634         }
4635
4636         iocbq = &lpfc_cmd->cur_iocbq;
4637         iocbqrsp = lpfc_sli_get_iocbq(phba);
4638         if (iocbqrsp == NULL) {
4639                 lpfc_release_scsi_buf(phba, lpfc_cmd);
4640                 return FAILED;
4641         }
4642
4643         lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4644                          "0702 Issue %s to TGT %d LUN %d "
4645                          "rpi x%x nlp_flag x%x Data: x%x x%x\n",
4646                          lpfc_taskmgmt_name(task_mgmt_cmd), tgt_id, lun_id,
4647                          pnode->nlp_rpi, pnode->nlp_flag, iocbq->sli4_xritag,
4648                          iocbq->iocb_flag);
4649
4650         status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING,
4651                                           iocbq, iocbqrsp, lpfc_cmd->timeout);
4652         if (status != IOCB_SUCCESS) {
4653                 if (status == IOCB_TIMEDOUT) {
4654                         iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
4655                         ret = TIMEOUT_ERROR;
4656                 } else
4657                         ret = FAILED;
4658                 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
4659                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4660                          "0727 TMF %s to TGT %d LUN %d failed (%d, %d) "
4661                          "iocb_flag x%x\n",
4662                          lpfc_taskmgmt_name(task_mgmt_cmd),
4663                          tgt_id, lun_id, iocbqrsp->iocb.ulpStatus,
4664                          iocbqrsp->iocb.un.ulpWord[4],
4665                          iocbq->iocb_flag);
4666         } else if (status == IOCB_BUSY)
4667                 ret = FAILED;
4668         else
4669                 ret = SUCCESS;
4670
4671         lpfc_sli_release_iocbq(phba, iocbqrsp);
4672
4673         if (ret != TIMEOUT_ERROR)
4674                 lpfc_release_scsi_buf(phba, lpfc_cmd);
4675
4676         return ret;
4677 }
4678
4679 /**
4680  * lpfc_chk_tgt_mapped -
4681  * @vport: The virtual port to check on
4682  * @cmnd: Pointer to scsi_cmnd data structure.
4683  *
4684  * This routine delays until the scsi target (aka rport) for the
4685  * command exists (is present and logged in) or we declare it non-existent.
4686  *
4687  * Return code :
4688  *  0x2003 - Error
4689  *  0x2002 - Success
4690  **/
4691 static int
4692 lpfc_chk_tgt_mapped(struct lpfc_vport *vport, struct scsi_cmnd *cmnd)
4693 {
4694         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
4695         struct lpfc_nodelist *pnode;
4696         unsigned long later;
4697
4698         if (!rdata) {
4699                 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4700                         "0797 Tgt Map rport failure: rdata x%p\n", rdata);
4701                 return FAILED;
4702         }
4703         pnode = rdata->pnode;
4704         /*
4705          * If target is not in a MAPPED state, delay until
4706          * target is rediscovered or devloss timeout expires.
4707          */
4708         later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
4709         while (time_after(later, jiffies)) {
4710                 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
4711                         return FAILED;
4712                 if (pnode->nlp_state == NLP_STE_MAPPED_NODE)
4713                         return SUCCESS;
4714                 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
4715                 rdata = cmnd->device->hostdata;
4716                 if (!rdata)
4717                         return FAILED;
4718                 pnode = rdata->pnode;
4719         }
4720         if (!pnode || !NLP_CHK_NODE_ACT(pnode) ||
4721             (pnode->nlp_state != NLP_STE_MAPPED_NODE))
4722                 return FAILED;
4723         return SUCCESS;
4724 }
4725
4726 /**
4727  * lpfc_reset_flush_io_context -
4728  * @vport: The virtual port (scsi_host) for the flush context
4729  * @tgt_id: If aborting by Target contect - specifies the target id
4730  * @lun_id: If aborting by Lun context - specifies the lun id
4731  * @context: specifies the context level to flush at.
4732  *
4733  * After a reset condition via TMF, we need to flush orphaned i/o
4734  * contexts from the adapter. This routine aborts any contexts
4735  * outstanding, then waits for their completions. The wait is
4736  * bounded by devloss_tmo though.
4737  *
4738  * Return code :
4739  *  0x2003 - Error
4740  *  0x2002 - Success
4741  **/
4742 static int
4743 lpfc_reset_flush_io_context(struct lpfc_vport *vport, uint16_t tgt_id,
4744                         uint64_t lun_id, lpfc_ctx_cmd context)
4745 {
4746         struct lpfc_hba   *phba = vport->phba;
4747         unsigned long later;
4748         int cnt;
4749
4750         cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context);
4751         if (cnt)
4752                 lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring],
4753                                     tgt_id, lun_id, context);
4754         later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
4755         while (time_after(later, jiffies) && cnt) {
4756                 schedule_timeout_uninterruptible(msecs_to_jiffies(20));
4757                 cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context);
4758         }
4759         if (cnt) {
4760                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4761                         "0724 I/O flush failure for context %s : cnt x%x\n",
4762                         ((context == LPFC_CTX_LUN) ? "LUN" :
4763                          ((context == LPFC_CTX_TGT) ? "TGT" :
4764                           ((context == LPFC_CTX_HOST) ? "HOST" : "Unknown"))),
4765                         cnt);
4766                 return FAILED;
4767         }
4768         return SUCCESS;
4769 }
4770
4771 /**
4772  * lpfc_device_reset_handler - scsi_host_template eh_device_reset entry point
4773  * @cmnd: Pointer to scsi_cmnd data structure.
4774  *
4775  * This routine does a device reset by sending a LUN_RESET task management
4776  * command.
4777  *
4778  * Return code :
4779  *  0x2003 - Error
4780  *  0x2002 - Success
4781  **/
4782 static int
4783 lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
4784 {
4785         struct Scsi_Host  *shost = cmnd->device->host;
4786         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4787         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
4788         struct lpfc_nodelist *pnode;
4789         unsigned tgt_id = cmnd->device->id;
4790         unsigned int lun_id = cmnd->device->lun;
4791         struct lpfc_scsi_event_header scsi_event;
4792         int status, ret = SUCCESS;
4793
4794         if (!rdata) {
4795                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4796                         "0798 Device Reset rport failure: rdata x%p\n", rdata);
4797                 return FAILED;
4798         }
4799         pnode = rdata->pnode;
4800         status = fc_block_scsi_eh(cmnd);
4801         if (status != 0 && status != SUCCESS)
4802                 return status;
4803
4804         status = lpfc_chk_tgt_mapped(vport, cmnd);
4805         if (status == FAILED) {
4806                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4807                         "0721 Device Reset rport failure: rdata x%p\n", rdata);
4808                 return FAILED;
4809         }
4810
4811         scsi_event.event_type = FC_REG_SCSI_EVENT;
4812         scsi_event.subcategory = LPFC_EVENT_LUNRESET;
4813         scsi_event.lun = lun_id;
4814         memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name));
4815         memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name));
4816
4817         fc_host_post_vendor_event(shost, fc_get_event_number(),
4818                 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
4819
4820         status = lpfc_send_taskmgmt(vport, rdata, tgt_id, lun_id,
4821                                                 FCP_LUN_RESET);
4822
4823         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4824                          "0713 SCSI layer issued Device Reset (%d, %d) "
4825                          "return x%x\n", tgt_id, lun_id, status);
4826
4827         /*
4828          * We have to clean up i/o as : they may be orphaned by the TMF;
4829          * or if the TMF failed, they may be in an indeterminate state.
4830          * So, continue on.
4831          * We will report success if all the i/o aborts successfully.
4832          */
4833         ret = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
4834                                                 LPFC_CTX_LUN);
4835         return ret;
4836 }
4837
4838 /**
4839  * lpfc_target_reset_handler - scsi_host_template eh_target_reset entry point
4840  * @cmnd: Pointer to scsi_cmnd data structure.
4841  *
4842  * This routine does a target reset by sending a TARGET_RESET task management
4843  * command.
4844  *
4845  * Return code :
4846  *  0x2003 - Error
4847  *  0x2002 - Success
4848  **/
4849 static int
4850 lpfc_target_reset_handler(struct scsi_cmnd *cmnd)
4851 {
4852         struct Scsi_Host  *shost = cmnd->device->host;
4853         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4854         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
4855         struct lpfc_nodelist *pnode;
4856         unsigned tgt_id = cmnd->device->id;
4857         unsigned int lun_id = cmnd->device->lun;
4858         struct lpfc_scsi_event_header scsi_event;
4859         int status, ret = SUCCESS;
4860
4861         if (!rdata) {
4862                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4863                         "0799 Target Reset rport failure: rdata x%p\n", rdata);
4864                 return FAILED;
4865         }
4866         pnode = rdata->pnode;
4867         status = fc_block_scsi_eh(cmnd);
4868         if (status != 0 && status != SUCCESS)
4869                 return status;
4870
4871         status = lpfc_chk_tgt_mapped(vport, cmnd);
4872         if (status == FAILED) {
4873                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4874                         "0722 Target Reset rport failure: rdata x%p\n", rdata);
4875                 return FAILED;
4876         }
4877
4878         scsi_event.event_type = FC_REG_SCSI_EVENT;
4879         scsi_event.subcategory = LPFC_EVENT_TGTRESET;
4880         scsi_event.lun = 0;
4881         memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name));
4882         memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name));
4883
4884         fc_host_post_vendor_event(shost, fc_get_event_number(),
4885                 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
4886
4887         status = lpfc_send_taskmgmt(vport, rdata, tgt_id, lun_id,
4888                                         FCP_TARGET_RESET);
4889
4890         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4891                          "0723 SCSI layer issued Target Reset (%d, %d) "
4892                          "return x%x\n", tgt_id, lun_id, status);
4893
4894         /*
4895          * We have to clean up i/o as : they may be orphaned by the TMF;
4896          * or if the TMF failed, they may be in an indeterminate state.
4897          * So, continue on.
4898          * We will report success if all the i/o aborts successfully.
4899          */
4900         ret = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
4901                                           LPFC_CTX_TGT);
4902         return ret;
4903 }
4904
4905 /**
4906  * lpfc_bus_reset_handler - scsi_host_template eh_bus_reset_handler entry point
4907  * @cmnd: Pointer to scsi_cmnd data structure.
4908  *
4909  * This routine does target reset to all targets on @cmnd->device->host.
4910  * This emulates Parallel SCSI Bus Reset Semantics.
4911  *
4912  * Return code :
4913  *  0x2003 - Error
4914  *  0x2002 - Success
4915  **/
4916 static int
4917 lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
4918 {
4919         struct Scsi_Host  *shost = cmnd->device->host;
4920         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4921         struct lpfc_nodelist *ndlp = NULL;
4922         struct lpfc_scsi_event_header scsi_event;
4923         int match;
4924         int ret = SUCCESS, status, i;
4925
4926         scsi_event.event_type = FC_REG_SCSI_EVENT;
4927         scsi_event.subcategory = LPFC_EVENT_BUSRESET;
4928         scsi_event.lun = 0;
4929         memcpy(scsi_event.wwpn, &vport->fc_portname, sizeof(struct lpfc_name));
4930         memcpy(scsi_event.wwnn, &vport->fc_nodename, sizeof(struct lpfc_name));
4931
4932         fc_host_post_vendor_event(shost, fc_get_event_number(),
4933                 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
4934
4935         status = fc_block_scsi_eh(cmnd);
4936         if (status != 0 && status != SUCCESS)
4937                 return status;
4938
4939         /*
4940          * Since the driver manages a single bus device, reset all
4941          * targets known to the driver.  Should any target reset
4942          * fail, this routine returns failure to the midlayer.
4943          */
4944         for (i = 0; i < LPFC_MAX_TARGET; i++) {
4945                 /* Search for mapped node by target ID */
4946                 match = 0;
4947                 spin_lock_irq(shost->host_lock);
4948                 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
4949                         if (!NLP_CHK_NODE_ACT(ndlp))
4950                                 continue;
4951                         if (vport->phba->cfg_fcp2_no_tgt_reset &&
4952                             (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE))
4953                                 continue;
4954                         if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
4955                             ndlp->nlp_sid == i &&
4956                             ndlp->rport) {
4957                                 match = 1;
4958                                 break;
4959                         }
4960                 }
4961                 spin_unlock_irq(shost->host_lock);
4962                 if (!match)
4963                         continue;
4964
4965                 status = lpfc_send_taskmgmt(vport, ndlp->rport->dd_data,
4966                                         i, 0, FCP_TARGET_RESET);
4967
4968                 if (status != SUCCESS) {
4969                         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4970                                          "0700 Bus Reset on target %d failed\n",
4971                                          i);
4972                         ret = FAILED;
4973                 }
4974         }
4975         /*
4976          * We have to clean up i/o as : they may be orphaned by the TMFs
4977          * above; or if any of the TMFs failed, they may be in an
4978          * indeterminate state.
4979          * We will report success if all the i/o aborts successfully.
4980          */
4981
4982         status = lpfc_reset_flush_io_context(vport, 0, 0, LPFC_CTX_HOST);
4983         if (status != SUCCESS)
4984                 ret = FAILED;
4985
4986         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4987                          "0714 SCSI layer issued Bus Reset Data: x%x\n", ret);
4988         return ret;
4989 }
4990
4991 /**
4992  * lpfc_host_reset_handler - scsi_host_template eh_host_reset_handler entry pt
4993  * @cmnd: Pointer to scsi_cmnd data structure.
4994  *
4995  * This routine does host reset to the adaptor port. It brings the HBA
4996  * offline, performs a board restart, and then brings the board back online.
4997  * The lpfc_offline calls lpfc_sli_hba_down which will abort and local
4998  * reject all outstanding SCSI commands to the host and error returned
4999  * back to SCSI mid-level. As this will be SCSI mid-level's last resort
5000  * of error handling, it will only return error if resetting of the adapter
5001  * is not successful; in all other cases, will return success.
5002  *
5003  * Return code :
5004  *  0x2003 - Error
5005  *  0x2002 - Success
5006  **/
5007 static int
5008 lpfc_host_reset_handler(struct scsi_cmnd *cmnd)
5009 {
5010         struct Scsi_Host *shost = cmnd->device->host;
5011         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5012         struct lpfc_hba *phba = vport->phba;
5013         int rc, ret = SUCCESS;
5014
5015         lpfc_offline_prep(phba, LPFC_MBX_WAIT);
5016         lpfc_offline(phba);
5017         rc = lpfc_sli_brdrestart(phba);
5018         if (rc)
5019                 ret = FAILED;
5020         lpfc_online(phba);
5021         lpfc_unblock_mgmt_io(phba);
5022
5023         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
5024                         "3172 SCSI layer issued Host Reset Data: x%x\n", ret);
5025         return ret;
5026 }
5027
5028 /**
5029  * lpfc_slave_alloc - scsi_host_template slave_alloc entry point
5030  * @sdev: Pointer to scsi_device.
5031  *
5032  * This routine populates the cmds_per_lun count + 2 scsi_bufs into  this host's
5033  * globally available list of scsi buffers. This routine also makes sure scsi
5034  * buffer is not allocated more than HBA limit conveyed to midlayer. This list
5035  * of scsi buffer exists for the lifetime of the driver.
5036  *
5037  * Return codes:
5038  *   non-0 - Error
5039  *   0 - Success
5040  **/
5041 static int
5042 lpfc_slave_alloc(struct scsi_device *sdev)
5043 {
5044         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5045         struct lpfc_hba   *phba = vport->phba;
5046         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
5047         uint32_t total = 0;
5048         uint32_t num_to_alloc = 0;
5049         int num_allocated = 0;
5050         uint32_t sdev_cnt;
5051
5052         if (!rport || fc_remote_port_chkready(rport))
5053                 return -ENXIO;
5054
5055         sdev->hostdata = rport->dd_data;
5056         sdev_cnt = atomic_inc_return(&phba->sdev_cnt);
5057
5058         /*
5059          * Populate the cmds_per_lun count scsi_bufs into this host's globally
5060          * available list of scsi buffers.  Don't allocate more than the
5061          * HBA limit conveyed to the midlayer via the host structure.  The
5062          * formula accounts for the lun_queue_depth + error handlers + 1
5063          * extra.  This list of scsi bufs exists for the lifetime of the driver.
5064          */
5065         total = phba->total_scsi_bufs;
5066         num_to_alloc = vport->cfg_lun_queue_depth + 2;
5067
5068         /* If allocated buffers are enough do nothing */
5069         if ((sdev_cnt * (vport->cfg_lun_queue_depth + 2)) < total)
5070                 return 0;
5071
5072         /* Allow some exchanges to be available always to complete discovery */
5073         if (total >= phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
5074                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
5075                                  "0704 At limitation of %d preallocated "
5076                                  "command buffers\n", total);
5077                 return 0;
5078         /* Allow some exchanges to be available always to complete discovery */
5079         } else if (total + num_to_alloc >
5080                 phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
5081                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
5082                                  "0705 Allocation request of %d "
5083                                  "command buffers will exceed max of %d.  "
5084                                  "Reducing allocation request to %d.\n",
5085                                  num_to_alloc, phba->cfg_hba_queue_depth,
5086                                  (phba->cfg_hba_queue_depth - total));
5087                 num_to_alloc = phba->cfg_hba_queue_depth - total;
5088         }
5089         num_allocated = lpfc_new_scsi_buf(vport, num_to_alloc);
5090         if (num_to_alloc != num_allocated) {
5091                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
5092                                  "0708 Allocation request of %d "
5093                                  "command buffers did not succeed.  "
5094                                  "Allocated %d buffers.\n",
5095                                  num_to_alloc, num_allocated);
5096         }
5097         if (num_allocated > 0)
5098                 phba->total_scsi_bufs += num_allocated;
5099         return 0;
5100 }
5101
5102 /**
5103  * lpfc_slave_configure - scsi_host_template slave_configure entry point
5104  * @sdev: Pointer to scsi_device.
5105  *
5106  * This routine configures following items
5107  *   - Tag command queuing support for @sdev if supported.
5108  *   - Enable SLI polling for fcp ring if ENABLE_FCP_RING_POLLING flag is set.
5109  *
5110  * Return codes:
5111  *   0 - Success
5112  **/
5113 static int
5114 lpfc_slave_configure(struct scsi_device *sdev)
5115 {
5116         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5117         struct lpfc_hba   *phba = vport->phba;
5118
5119         if (sdev->tagged_supported)
5120                 scsi_activate_tcq(sdev, vport->cfg_lun_queue_depth);
5121         else
5122                 scsi_deactivate_tcq(sdev, vport->cfg_lun_queue_depth);
5123
5124         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
5125                 lpfc_sli_handle_fast_ring_event(phba,
5126                         &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
5127                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
5128                         lpfc_poll_rearm_timer(phba);
5129         }
5130
5131         return 0;
5132 }
5133
5134 /**
5135  * lpfc_slave_destroy - slave_destroy entry point of SHT data structure
5136  * @sdev: Pointer to scsi_device.
5137  *
5138  * This routine sets @sdev hostatdata filed to null.
5139  **/
5140 static void
5141 lpfc_slave_destroy(struct scsi_device *sdev)
5142 {
5143         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5144         struct lpfc_hba   *phba = vport->phba;
5145         atomic_dec(&phba->sdev_cnt);
5146         sdev->hostdata = NULL;
5147         return;
5148 }
5149
5150
5151 struct scsi_host_template lpfc_template = {
5152         .module                 = THIS_MODULE,
5153         .name                   = LPFC_DRIVER_NAME,
5154         .info                   = lpfc_info,
5155         .queuecommand           = lpfc_queuecommand,
5156         .eh_abort_handler       = lpfc_abort_handler,
5157         .eh_device_reset_handler = lpfc_device_reset_handler,
5158         .eh_target_reset_handler = lpfc_target_reset_handler,
5159         .eh_bus_reset_handler   = lpfc_bus_reset_handler,
5160         .eh_host_reset_handler  = lpfc_host_reset_handler,
5161         .slave_alloc            = lpfc_slave_alloc,
5162         .slave_configure        = lpfc_slave_configure,
5163         .slave_destroy          = lpfc_slave_destroy,
5164         .scan_finished          = lpfc_scan_finished,
5165         .this_id                = -1,
5166         .sg_tablesize           = LPFC_DEFAULT_SG_SEG_CNT,
5167         .cmd_per_lun            = LPFC_CMD_PER_LUN,
5168         .use_clustering         = ENABLE_CLUSTERING,
5169         .shost_attrs            = lpfc_hba_attrs,
5170         .max_sectors            = 0xFFFF,
5171         .vendor_id              = LPFC_NL_VENDOR_ID,
5172         .change_queue_depth     = lpfc_change_queue_depth,
5173         .change_queue_type      = lpfc_change_queue_type,
5174 };
5175
5176 struct scsi_host_template lpfc_vport_template = {
5177         .module                 = THIS_MODULE,
5178         .name                   = LPFC_DRIVER_NAME,
5179         .info                   = lpfc_info,
5180         .queuecommand           = lpfc_queuecommand,
5181         .eh_abort_handler       = lpfc_abort_handler,
5182         .eh_device_reset_handler = lpfc_device_reset_handler,
5183         .eh_target_reset_handler = lpfc_target_reset_handler,
5184         .eh_bus_reset_handler   = lpfc_bus_reset_handler,
5185         .slave_alloc            = lpfc_slave_alloc,
5186         .slave_configure        = lpfc_slave_configure,
5187         .slave_destroy          = lpfc_slave_destroy,
5188         .scan_finished          = lpfc_scan_finished,
5189         .this_id                = -1,
5190         .sg_tablesize           = LPFC_DEFAULT_SG_SEG_CNT,
5191         .cmd_per_lun            = LPFC_CMD_PER_LUN,
5192         .use_clustering         = ENABLE_CLUSTERING,
5193         .shost_attrs            = lpfc_vport_attrs,
5194         .max_sectors            = 0xFFFF,
5195         .change_queue_depth     = lpfc_change_queue_depth,
5196         .change_queue_type      = lpfc_change_queue_type,
5197 };