git.oblomov.eu Git - linux-2.6/blob - 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-2008 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/interrupt.h>
  23 #include <linux/delay.h>
  24 #include <asm/unaligned.h>
  25
  26 #include <scsi/scsi.h>
  27 #include <scsi/scsi_device.h>
  28 #include <scsi/scsi_eh.h>
  29 #include <scsi/scsi_host.h>
  30 #include <scsi/scsi_tcq.h>
  31 #include <scsi/scsi_transport_fc.h>
  32
  33 #include "lpfc_version.h"
  34 #include "lpfc_hw.h"
  35 #include "lpfc_sli.h"
  36 #include "lpfc_nl.h"
  37 #include "lpfc_disc.h"
  38 #include "lpfc_scsi.h"
  39 #include "lpfc.h"
  40 #include "lpfc_logmsg.h"
  41 #include "lpfc_crtn.h"
  42 #include "lpfc_vport.h"
  43
  44 #define LPFC_RESET_WAIT  2
  45 #define LPFC_ABORT_WAIT  2
  46
  47 int _dump_buf_done;
  48
  49 static char *dif_op_str[] = {
  50         "SCSI_PROT_NORMAL",
  51         "SCSI_PROT_READ_INSERT",
  52         "SCSI_PROT_WRITE_STRIP",
  53         "SCSI_PROT_READ_STRIP",
  54         "SCSI_PROT_WRITE_INSERT",
  55         "SCSI_PROT_READ_PASS",
  56         "SCSI_PROT_WRITE_PASS",
  57         "SCSI_PROT_READ_CONVERT",
  58         "SCSI_PROT_WRITE_CONVERT"
  59 };
  60
  61 static void
  62 lpfc_debug_save_data(struct scsi_cmnd *cmnd)
  63 {
  64         void *src, *dst;
  65         struct scatterlist *sgde = scsi_sglist(cmnd);
  66
  67         if (!_dump_buf_data) {
  68                 printk(KERN_ERR "BLKGRD ERROR %s _dump_buf_data is NULL\n",
  69                                 __func__);
  70                 return;
  71         }
  72
  73
  74         if (!sgde) {
  75                 printk(KERN_ERR "BLKGRD ERROR: data scatterlist is null\n");
  76                 return;
  77         }
  78
  79         dst = (void *) _dump_buf_data;
  80         while (sgde) {
  81                 src = sg_virt(sgde);
  82                 memcpy(dst, src, sgde->length);
  83                 dst += sgde->length;
  84                 sgde = sg_next(sgde);
  85         }
  86 }
  87
  88 static void
  89 lpfc_debug_save_dif(struct scsi_cmnd *cmnd)
  90 {
  91         void *src, *dst;
  92         struct scatterlist *sgde = scsi_prot_sglist(cmnd);
  93
  94         if (!_dump_buf_dif) {
  95                 printk(KERN_ERR "BLKGRD ERROR %s _dump_buf_data is NULL\n",
  96                                 __func__);
  97                 return;
  98         }
  99
 100         if (!sgde) {
 101                 printk(KERN_ERR "BLKGRD ERROR: prot scatterlist is null\n");
 102                 return;
 103         }
 104
 105         dst = _dump_buf_dif;
 106         while (sgde) {
 107                 src = sg_virt(sgde);
 108                 memcpy(dst, src, sgde->length);
 109                 dst += sgde->length;
 110                 sgde = sg_next(sgde);
 111         }
 112 }
 113
 114 /**
 115  * lpfc_update_stats - Update statistical data for the command completion
 116  * @phba: Pointer to HBA object.
 117  * @lpfc_cmd: lpfc scsi command object pointer.
 118  *
 119  * This function is called when there is a command completion and this
 120  * function updates the statistical data for the command completion.
 121  **/
 122 static void
 123 lpfc_update_stats(struct lpfc_hba *phba, struct  lpfc_scsi_buf *lpfc_cmd)
 124 {
 125         struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
 126         struct lpfc_nodelist *pnode = rdata->pnode;
 127         struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
 128         unsigned long flags;
 129         struct Scsi_Host  *shost = cmd->device->host;
 130         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 131         unsigned long latency;
 132         int i;
 133
 134         if (cmd->result)
 135                 return;
 136
 137         latency = jiffies_to_msecs((long)jiffies - (long)lpfc_cmd->start_time);
 138
 139         spin_lock_irqsave(shost->host_lock, flags);
 140         if (!vport->stat_data_enabled ||
 141                 vport->stat_data_blocked ||
 142                 !pnode->lat_data ||
 143                 (phba->bucket_type == LPFC_NO_BUCKET)) {
 144                 spin_unlock_irqrestore(shost->host_lock, flags);
 145                 return;
 146         }
 147
 148         if (phba->bucket_type == LPFC_LINEAR_BUCKET) {
 149                 i = (latency + phba->bucket_step - 1 - phba->bucket_base)/
 150                         phba->bucket_step;
 151                 /* check array subscript bounds */
 152                 if (i < 0)
 153                         i = 0;
 154                 else if (i >= LPFC_MAX_BUCKET_COUNT)
 155                         i = LPFC_MAX_BUCKET_COUNT - 1;
 156         } else {
 157                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT-1; i++)
 158                         if (latency <= (phba->bucket_base +
 159                                 ((1<<i)*phba->bucket_step)))
 160                                 break;
 161         }
 162
 163         pnode->lat_data[i].cmd_count++;
 164         spin_unlock_irqrestore(shost->host_lock, flags);
 165 }
 166
 167 /**
 168  * lpfc_send_sdev_queuedepth_change_event - Posts a queuedepth change event
 169  * @phba: Pointer to HBA context object.
 170  * @vport: Pointer to vport object.
 171  * @ndlp: Pointer to FC node associated with the target.
 172  * @lun: Lun number of the scsi device.
 173  * @old_val: Old value of the queue depth.
 174  * @new_val: New value of the queue depth.
 175  *
 176  * This function sends an event to the mgmt application indicating
 177  * there is a change in the scsi device queue depth.
 178  **/
 179 static void
 180 lpfc_send_sdev_queuedepth_change_event(struct lpfc_hba *phba,
 181                 struct lpfc_vport  *vport,
 182                 struct lpfc_nodelist *ndlp,
 183                 uint32_t lun,
 184                 uint32_t old_val,
 185                 uint32_t new_val)
 186 {
 187         struct lpfc_fast_path_event *fast_path_evt;
 188         unsigned long flags;
 189
 190         fast_path_evt = lpfc_alloc_fast_evt(phba);
 191         if (!fast_path_evt)
 192                 return;
 193
 194         fast_path_evt->un.queue_depth_evt.scsi_event.event_type =
 195                 FC_REG_SCSI_EVENT;
 196         fast_path_evt->un.queue_depth_evt.scsi_event.subcategory =
 197                 LPFC_EVENT_VARQUEDEPTH;
 198
 199         /* Report all luns with change in queue depth */
 200         fast_path_evt->un.queue_depth_evt.scsi_event.lun = lun;
 201         if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
 202                 memcpy(&fast_path_evt->un.queue_depth_evt.scsi_event.wwpn,
 203                         &ndlp->nlp_portname, sizeof(struct lpfc_name));
 204                 memcpy(&fast_path_evt->un.queue_depth_evt.scsi_event.wwnn,
 205                         &ndlp->nlp_nodename, sizeof(struct lpfc_name));
 206         }
 207
 208         fast_path_evt->un.queue_depth_evt.oldval = old_val;
 209         fast_path_evt->un.queue_depth_evt.newval = new_val;
 210         fast_path_evt->vport = vport;
 211
 212         fast_path_evt->work_evt.evt = LPFC_EVT_FASTPATH_MGMT_EVT;
 213         spin_lock_irqsave(&phba->hbalock, flags);
 214         list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list);
 215         spin_unlock_irqrestore(&phba->hbalock, flags);
 216         lpfc_worker_wake_up(phba);
 217
 218         return;
 219 }
 220
 221 /**
 222  * lpfc_rampdown_queue_depth - Post RAMP_DOWN_QUEUE event to worker thread
 223  * @phba: The Hba for which this call is being executed.
 224  *
 225  * This routine is called when there is resource error in driver or firmware.
 226  * This routine posts WORKER_RAMP_DOWN_QUEUE event for @phba. This routine
 227  * posts at most 1 event each second. This routine wakes up worker thread of
 228  * @phba to process WORKER_RAM_DOWN_EVENT event.
 229  *
 230  * This routine should be called with no lock held.
 231  **/
 232 void
 233 lpfc_rampdown_queue_depth(struct lpfc_hba *phba)
 234 {
 235         unsigned long flags;
 236         uint32_t evt_posted;
 237
 238         spin_lock_irqsave(&phba->hbalock, flags);
 239         atomic_inc(&phba->num_rsrc_err);
 240         phba->last_rsrc_error_time = jiffies;
 241
 242         if ((phba->last_ramp_down_time + QUEUE_RAMP_DOWN_INTERVAL) > jiffies) {
 243                 spin_unlock_irqrestore(&phba->hbalock, flags);
 244                 return;
 245         }
 246
 247         phba->last_ramp_down_time = jiffies;
 248
 249         spin_unlock_irqrestore(&phba->hbalock, flags);
 250
 251         spin_lock_irqsave(&phba->pport->work_port_lock, flags);
 252         evt_posted = phba->pport->work_port_events & WORKER_RAMP_DOWN_QUEUE;
 253         if (!evt_posted)
 254                 phba->pport->work_port_events |= WORKER_RAMP_DOWN_QUEUE;
 255         spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);
 256
 257         if (!evt_posted)
 258                 lpfc_worker_wake_up(phba);
 259         return;
 260 }
 261
 262 /**
 263  * lpfc_rampup_queue_depth - Post RAMP_UP_QUEUE event for worker thread
 264  * @phba: The Hba for which this call is being executed.
 265  *
 266  * This routine post WORKER_RAMP_UP_QUEUE event for @phba vport. This routine
 267  * post at most 1 event every 5 minute after last_ramp_up_time or
 268  * last_rsrc_error_time.  This routine wakes up worker thread of @phba
 269  * to process WORKER_RAM_DOWN_EVENT event.
 270  *
 271  * This routine should be called with no lock held.
 272  **/
 273 static inline void
 274 lpfc_rampup_queue_depth(struct lpfc_vport  *vport,
 275                         uint32_t queue_depth)
 276 {
 277         unsigned long flags;
 278         struct lpfc_hba *phba = vport->phba;
 279         uint32_t evt_posted;
 280         atomic_inc(&phba->num_cmd_success);
 281
 282         if (vport->cfg_lun_queue_depth <= queue_depth)
 283                 return;
 284         spin_lock_irqsave(&phba->hbalock, flags);
 285         if (((phba->last_ramp_up_time + QUEUE_RAMP_UP_INTERVAL) > jiffies) ||
 286          ((phba->last_rsrc_error_time + QUEUE_RAMP_UP_INTERVAL ) > jiffies)) {
 287                 spin_unlock_irqrestore(&phba->hbalock, flags);
 288                 return;
 289         }
 290         phba->last_ramp_up_time = jiffies;
 291         spin_unlock_irqrestore(&phba->hbalock, flags);
 292
 293         spin_lock_irqsave(&phba->pport->work_port_lock, flags);
 294         evt_posted = phba->pport->work_port_events & WORKER_RAMP_UP_QUEUE;
 295         if (!evt_posted)
 296                 phba->pport->work_port_events |= WORKER_RAMP_UP_QUEUE;
 297         spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);
 298
 299         if (!evt_posted)
 300                 lpfc_worker_wake_up(phba);
 301         return;
 302 }
 303
 304 /**
 305  * lpfc_ramp_down_queue_handler - WORKER_RAMP_DOWN_QUEUE event handler
 306  * @phba: The Hba for which this call is being executed.
 307  *
 308  * This routine is called to  process WORKER_RAMP_DOWN_QUEUE event for worker
 309  * thread.This routine reduces queue depth for all scsi device on each vport
 310  * associated with @phba.
 311  **/
 312 void
 313 lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
 314 {
 315         struct lpfc_vport **vports;
 316         struct Scsi_Host  *shost;
 317         struct scsi_device *sdev;
 318         unsigned long new_queue_depth, old_queue_depth;
 319         unsigned long num_rsrc_err, num_cmd_success;
 320         int i;
 321         struct lpfc_rport_data *rdata;
 322
 323         num_rsrc_err = atomic_read(&phba->num_rsrc_err);
 324         num_cmd_success = atomic_read(&phba->num_cmd_success);
 325
 326         vports = lpfc_create_vport_work_array(phba);
 327         if (vports != NULL)
 328                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
 329                         shost = lpfc_shost_from_vport(vports[i]);
 330                         shost_for_each_device(sdev, shost) {
 331                                 new_queue_depth =
 332                                         sdev->queue_depth * num_rsrc_err /
 333                                         (num_rsrc_err + num_cmd_success);
 334                                 if (!new_queue_depth)
 335                                         new_queue_depth = sdev->queue_depth - 1;
 336                                 else
 337                                         new_queue_depth = sdev->queue_depth -
 338                                                                 new_queue_depth;
 339                                 old_queue_depth = sdev->queue_depth;
 340                                 if (sdev->ordered_tags)
 341                                         scsi_adjust_queue_depth(sdev,
 342                                                         MSG_ORDERED_TAG,
 343                                                         new_queue_depth);
 344                                 else
 345                                         scsi_adjust_queue_depth(sdev,
 346                                                         MSG_SIMPLE_TAG,
 347                                                         new_queue_depth);
 348                                 rdata = sdev->hostdata;
 349                                 if (rdata)
 350                                         lpfc_send_sdev_queuedepth_change_event(
 351                                                 phba, vports[i],
 352                                                 rdata->pnode,
 353                                                 sdev->lun, old_queue_depth,
 354                                                 new_queue_depth);
 355                         }
 356                 }
 357         lpfc_destroy_vport_work_array(phba, vports);
 358         atomic_set(&phba->num_rsrc_err, 0);
 359         atomic_set(&phba->num_cmd_success, 0);
 360 }
 361
 362 /**
 363  * lpfc_ramp_up_queue_handler - WORKER_RAMP_UP_QUEUE event handler
 364  * @phba: The Hba for which this call is being executed.
 365  *
 366  * This routine is called to  process WORKER_RAMP_UP_QUEUE event for worker
 367  * thread.This routine increases queue depth for all scsi device on each vport
 368  * associated with @phba by 1. This routine also sets @phba num_rsrc_err and
 369  * num_cmd_success to zero.
 370  **/
 371 void
 372 lpfc_ramp_up_queue_handler(struct lpfc_hba *phba)
 373 {
 374         struct lpfc_vport **vports;
 375         struct Scsi_Host  *shost;
 376         struct scsi_device *sdev;
 377         int i;
 378         struct lpfc_rport_data *rdata;
 379
 380         vports = lpfc_create_vport_work_array(phba);
 381         if (vports != NULL)
 382                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
 383                         shost = lpfc_shost_from_vport(vports[i]);
 384                         shost_for_each_device(sdev, shost) {
 385                                 if (vports[i]->cfg_lun_queue_depth <=
 386                                     sdev->queue_depth)
 387                                         continue;
 388                                 if (sdev->ordered_tags)
 389                                         scsi_adjust_queue_depth(sdev,
 390                                                         MSG_ORDERED_TAG,
 391                                                         sdev->queue_depth+1);
 392                                 else
 393                                         scsi_adjust_queue_depth(sdev,
 394                                                         MSG_SIMPLE_TAG,
 395                                                         sdev->queue_depth+1);
 396                                 rdata = sdev->hostdata;
 397                                 if (rdata)
 398                                         lpfc_send_sdev_queuedepth_change_event(
 399                                                 phba, vports[i],
 400                                                 rdata->pnode,
 401                                                 sdev->lun,
 402                                                 sdev->queue_depth - 1,
 403                                                 sdev->queue_depth);
 404                         }
 405                 }
 406         lpfc_destroy_vport_work_array(phba, vports);
 407         atomic_set(&phba->num_rsrc_err, 0);
 408         atomic_set(&phba->num_cmd_success, 0);
 409 }
 410
 411 /**
 412  * lpfc_scsi_dev_block - set all scsi hosts to block state
 413  * @phba: Pointer to HBA context object.
 414  *
 415  * This function walks vport list and set each SCSI host to block state
 416  * by invoking fc_remote_port_delete() routine. This function is invoked
 417  * with EEH when device's PCI slot has been permanently disabled.
 418  **/
 419 void
 420 lpfc_scsi_dev_block(struct lpfc_hba *phba)
 421 {
 422         struct lpfc_vport **vports;
 423         struct Scsi_Host  *shost;
 424         struct scsi_device *sdev;
 425         struct fc_rport *rport;
 426         int i;
 427
 428         vports = lpfc_create_vport_work_array(phba);
 429         if (vports != NULL)
 430                 for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
 431                         shost = lpfc_shost_from_vport(vports[i]);
 432                         shost_for_each_device(sdev, shost) {
 433                                 rport = starget_to_rport(scsi_target(sdev));
 434                                 fc_remote_port_delete(rport);
 435                         }
 436                 }
 437         lpfc_destroy_vport_work_array(phba, vports);
 438 }
 439
 440 /**
 441  * lpfc_new_scsi_buf - Scsi buffer allocator
 442  * @vport: The virtual port for which this call being executed.
 443  *
 444  * This routine allocates a scsi buffer, which contains all the necessary
 445  * information needed to initiate a SCSI I/O.  The non-DMAable buffer region
 446  * contains information to build the IOCB.  The DMAable region contains
 447  * memory for the FCP CMND, FCP RSP, and the initial BPL.  In addition to
 448  * allocating memory, the FCP CMND and FCP RSP BDEs are setup in the BPL
 449  * and the BPL BDE is setup in the IOCB.
 450  *
 451  * Return codes:
 452  *   NULL - Error
 453  *   Pointer to lpfc_scsi_buf data structure - Success
 454  **/
 455 static struct lpfc_scsi_buf *
 456 lpfc_new_scsi_buf(struct lpfc_vport *vport)
 457 {
 458         struct lpfc_hba *phba = vport->phba;
 459         struct lpfc_scsi_buf *psb;
 460         struct ulp_bde64 *bpl;
 461         IOCB_t *iocb;
 462         dma_addr_t pdma_phys_fcp_cmd;
 463         dma_addr_t pdma_phys_fcp_rsp;
 464         dma_addr_t pdma_phys_bpl;
 465         uint16_t iotag;
 466
 467         psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
 468         if (!psb)
 469                 return NULL;
 470
 471         /*
 472          * Get memory from the pci pool to map the virt space to pci bus space
 473          * for an I/O.  The DMA buffer includes space for the struct fcp_cmnd,
 474          * struct fcp_rsp and the number of bde's necessary to support the
 475          * sg_tablesize.
 476          */
 477         psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool, GFP_KERNEL,
 478                                                         &psb->dma_handle);
 479         if (!psb->data) {
 480                 kfree(psb);
 481                 return NULL;
 482         }
 483
 484         /* Initialize virtual ptrs to dma_buf region. */
 485         memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
 486
 487         /* Allocate iotag for psb->cur_iocbq. */
 488         iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
 489         if (iotag == 0) {
 490                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
 491                               psb->data, psb->dma_handle);
 492                 kfree (psb);
 493                 return NULL;
 494         }
 495         psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
 496
 497         psb->fcp_cmnd = psb->data;
 498         psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd);
 499         psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) +
 500                                                         sizeof(struct fcp_rsp);
 501
 502         /* Initialize local short-hand pointers. */
 503         bpl = psb->fcp_bpl;
 504         pdma_phys_fcp_cmd = psb->dma_handle;
 505         pdma_phys_fcp_rsp = psb->dma_handle + sizeof(struct fcp_cmnd);
 506         pdma_phys_bpl = psb->dma_handle + sizeof(struct fcp_cmnd) +
 507                         sizeof(struct fcp_rsp);
 508
 509         /*
 510          * The first two bdes are the FCP_CMD and FCP_RSP.  The balance are sg
 511          * list bdes.  Initialize the first two and leave the rest for
 512          * queuecommand.
 513          */
 514         bpl[0].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd));
 515         bpl[0].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd));
 516         bpl[0].tus.f.bdeSize = sizeof(struct fcp_cmnd);
 517         bpl[0].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 518         bpl[0].tus.w = le32_to_cpu(bpl[0].tus.w);
 519
 520         /* Setup the physical region for the FCP RSP */
 521         bpl[1].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp));
 522         bpl[1].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp));
 523         bpl[1].tus.f.bdeSize = sizeof(struct fcp_rsp);
 524         bpl[1].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 525         bpl[1].tus.w = le32_to_cpu(bpl[1].tus.w);
 526
 527         /*
 528          * Since the IOCB for the FCP I/O is built into this lpfc_scsi_buf,
 529          * initialize it with all known data now.
 530          */
 531         iocb = &psb->cur_iocbq.iocb;
 532         iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
 533         if ((phba->sli_rev == 3) &&
 534             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
 535                 /* fill in immediate fcp command BDE */
 536                 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_IMMED;
 537                 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
 538                 iocb->un.fcpi64.bdl.addrLow = offsetof(IOCB_t,
 539                                                        unsli3.fcp_ext.icd);
 540                 iocb->un.fcpi64.bdl.addrHigh = 0;
 541                 iocb->ulpBdeCount = 0;
 542                 iocb->ulpLe = 0;
 543                 /* fill in responce BDE */
 544                 iocb->unsli3.fcp_ext.rbde.tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 545                 iocb->unsli3.fcp_ext.rbde.tus.f.bdeSize =
 546                                                 sizeof(struct fcp_rsp);
 547                 iocb->unsli3.fcp_ext.rbde.addrLow =
 548                                                 putPaddrLow(pdma_phys_fcp_rsp);
 549                 iocb->unsli3.fcp_ext.rbde.addrHigh =
 550                                                 putPaddrHigh(pdma_phys_fcp_rsp);
 551         } else {
 552                 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
 553                 iocb->un.fcpi64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
 554                 iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys_bpl);
 555                 iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys_bpl);
 556                 iocb->ulpBdeCount = 1;
 557                 iocb->ulpLe = 1;
 558         }
 559         iocb->ulpClass = CLASS3;
 560
 561         return psb;
 562 }
 563
 564 /**
 565  * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list list of Hba
 566  * @phba: The Hba for which this call is being executed.
 567  *
 568  * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
 569  * and returns to caller.
 570  *
 571  * Return codes:
 572  *   NULL - Error
 573  *   Pointer to lpfc_scsi_buf - Success
 574  **/
 575 static struct lpfc_scsi_buf*
 576 lpfc_get_scsi_buf(struct lpfc_hba * phba)
 577 {
 578         struct  lpfc_scsi_buf * lpfc_cmd = NULL;
 579         struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
 580         unsigned long iflag = 0;
 581
 582         spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
 583         list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
 584         if (lpfc_cmd) {
 585                 lpfc_cmd->seg_cnt = 0;
 586                 lpfc_cmd->nonsg_phys = 0;
 587                 lpfc_cmd->prot_seg_cnt = 0;
 588         }
 589         spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
 590         return  lpfc_cmd;
 591 }
 592
 593 /**
 594  * lpfc_release_scsi_buf - Return a scsi buffer back to hba's lpfc_scsi_buf_list
 595  * @phba: The Hba for which this call is being executed.
 596  * @psb: The scsi buffer which is being released.
 597  *
 598  * This routine releases @psb scsi buffer by adding it to tail of @phba
 599  * lpfc_scsi_buf_list list.
 600  **/
 601 static void
 602 lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
 603 {
 604         unsigned long iflag = 0;
 605
 606         spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
 607         psb->pCmd = NULL;
 608         list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list);
 609         spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
 610 }
 611
 612 /**
 613  * lpfc_scsi_prep_dma_buf - Routine to do DMA mapping for scsi buffer
 614  * @phba: The Hba for which this call is being executed.
 615  * @lpfc_cmd: The scsi buffer which is going to be mapped.
 616  *
 617  * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
 618  * field of @lpfc_cmd. This routine scans through sg elements and format the
 619  * bdea. This routine also initializes all IOCB fields which are dependent on
 620  * scsi command request buffer.
 621  *
 622  * Return codes:
 623  *   1 - Error
 624  *   0 - Success
 625  **/
 626 static int
 627 lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
 628 {
 629         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
 630         struct scatterlist *sgel = NULL;
 631         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
 632         struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
 633         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
 634         struct ulp_bde64 *data_bde = iocb_cmd->unsli3.fcp_ext.dbde;
 635         dma_addr_t physaddr;
 636         uint32_t num_bde = 0;
 637         int nseg, datadir = scsi_cmnd->sc_data_direction;
 638
 639         /*
 640          * There are three possibilities here - use scatter-gather segment, use
 641          * the single mapping, or neither.  Start the lpfc command prep by
 642          * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
 643          * data bde entry.
 644          */
 645         bpl += 2;
 646         if (scsi_sg_count(scsi_cmnd)) {
 647                 /*
 648                  * The driver stores the segment count returned from pci_map_sg
 649                  * because this a count of dma-mappings used to map the use_sg
 650                  * pages.  They are not guaranteed to be the same for those
 651                  * architectures that implement an IOMMU.
 652                  */
 653
 654                 nseg = dma_map_sg(&phba->pcidev->dev, scsi_sglist(scsi_cmnd),
 655                                   scsi_sg_count(scsi_cmnd), datadir);
 656                 if (unlikely(!nseg))
 657                         return 1;
 658
 659                 lpfc_cmd->seg_cnt = nseg;
 660                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
 661                         printk(KERN_ERR "%s: Too many sg segments from "
 662                                "dma_map_sg.  Config %d, seg_cnt %d\n",
 663                                __func__, phba->cfg_sg_seg_cnt,
 664                                lpfc_cmd->seg_cnt);
 665                         scsi_dma_unmap(scsi_cmnd);
 666                         return 1;
 667                 }
 668
 669                 /*
 670                  * The driver established a maximum scatter-gather segment count
 671                  * during probe that limits the number of sg elements in any
 672                  * single scsi command.  Just run through the seg_cnt and format
 673                  * the bde's.
 674                  * When using SLI-3 the driver will try to fit all the BDEs into
 675                  * the IOCB. If it can't then the BDEs get added to a BPL as it
 676                  * does for SLI-2 mode.
 677                  */
 678                 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
 679                         physaddr = sg_dma_address(sgel);
 680                         if (phba->sli_rev == 3 &&
 681                             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
 682                             nseg <= LPFC_EXT_DATA_BDE_COUNT) {
 683                                 data_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 684                                 data_bde->tus.f.bdeSize = sg_dma_len(sgel);
 685                                 data_bde->addrLow = putPaddrLow(physaddr);
 686                                 data_bde->addrHigh = putPaddrHigh(physaddr);
 687                                 data_bde++;
 688                         } else {
 689                                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 690                                 bpl->tus.f.bdeSize = sg_dma_len(sgel);
 691                                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
 692                                 bpl->addrLow =
 693                                         le32_to_cpu(putPaddrLow(physaddr));
 694                                 bpl->addrHigh =
 695                                         le32_to_cpu(putPaddrHigh(physaddr));
 696                                 bpl++;
 697                         }
 698                 }
 699         }
 700
 701         /*
 702          * Finish initializing those IOCB fields that are dependent on the
 703          * scsi_cmnd request_buffer.  Note that for SLI-2 the bdeSize is
 704          * explicitly reinitialized and for SLI-3 the extended bde count is
 705          * explicitly reinitialized since all iocb memory resources are reused.
 706          */
 707         if (phba->sli_rev == 3 &&
 708             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
 709                 if (num_bde > LPFC_EXT_DATA_BDE_COUNT) {
 710                         /*
 711                          * The extended IOCB format can only fit 3 BDE or a BPL.
 712                          * This I/O has more than 3 BDE so the 1st data bde will
 713                          * be a BPL that is filled in here.
 714                          */
 715                         physaddr = lpfc_cmd->dma_handle;
 716                         data_bde->tus.f.bdeFlags = BUFF_TYPE_BLP_64;
 717                         data_bde->tus.f.bdeSize = (num_bde *
 718                                                    sizeof(struct ulp_bde64));
 719                         physaddr += (sizeof(struct fcp_cmnd) +
 720                                      sizeof(struct fcp_rsp) +
 721                                      (2 * sizeof(struct ulp_bde64)));
 722                         data_bde->addrHigh = putPaddrHigh(physaddr);
 723                         data_bde->addrLow = putPaddrLow(physaddr);
 724                         /* ebde count includes the responce bde and data bpl */
 725                         iocb_cmd->unsli3.fcp_ext.ebde_count = 2;
 726                 } else {
 727                         /* ebde count includes the responce bde and data bdes */
 728                         iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
 729                 }
 730         } else {
 731                 iocb_cmd->un.fcpi64.bdl.bdeSize =
 732                         ((num_bde + 2) * sizeof(struct ulp_bde64));
 733         }
 734         fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
 735
 736         /*
 737          * Due to difference in data length between DIF/non-DIF paths,
 738          * we need to set word 4 of IOCB here
 739          */
 740         iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
 741         return 0;
 742 }
 743
 744 /*
 745  * Given a scsi cmnd, determine the BlockGuard profile to be used
 746  * with the cmd
 747  */
 748 static int
 749 lpfc_sc_to_sli_prof(struct scsi_cmnd *sc)
 750 {
 751         uint8_t guard_type = scsi_host_get_guard(sc->device->host);
 752         uint8_t ret_prof = LPFC_PROF_INVALID;
 753
 754         if (guard_type == SHOST_DIX_GUARD_IP) {
 755                 switch (scsi_get_prot_op(sc)) {
 756                 case SCSI_PROT_READ_INSERT:
 757                 case SCSI_PROT_WRITE_STRIP:
 758                         ret_prof = LPFC_PROF_AST2;
 759                         break;
 760
 761                 case SCSI_PROT_READ_STRIP:
 762                 case SCSI_PROT_WRITE_INSERT:
 763                         ret_prof = LPFC_PROF_A1;
 764                         break;
 765
 766                 case SCSI_PROT_READ_CONVERT:
 767                 case SCSI_PROT_WRITE_CONVERT:
 768                         ret_prof = LPFC_PROF_AST1;
 769                         break;
 770
 771                 case SCSI_PROT_READ_PASS:
 772                 case SCSI_PROT_WRITE_PASS:
 773                 case SCSI_PROT_NORMAL:
 774                 default:
 775                         printk(KERN_ERR "Bad op/guard:%d/%d combination\n",
 776                                         scsi_get_prot_op(sc), guard_type);
 777                         break;
 778
 779                 }
 780         } else if (guard_type == SHOST_DIX_GUARD_CRC) {
 781                 switch (scsi_get_prot_op(sc)) {
 782                 case SCSI_PROT_READ_STRIP:
 783                 case SCSI_PROT_WRITE_INSERT:
 784                         ret_prof = LPFC_PROF_A1;
 785                         break;
 786
 787                 case SCSI_PROT_READ_PASS:
 788                 case SCSI_PROT_WRITE_PASS:
 789                         ret_prof = LPFC_PROF_C1;
 790                         break;
 791
 792                 case SCSI_PROT_READ_CONVERT:
 793                 case SCSI_PROT_WRITE_CONVERT:
 794                 case SCSI_PROT_READ_INSERT:
 795                 case SCSI_PROT_WRITE_STRIP:
 796                 case SCSI_PROT_NORMAL:
 797                 default:
 798                         printk(KERN_ERR "Bad op/guard:%d/%d combination\n",
 799                                         scsi_get_prot_op(sc), guard_type);
 800                         break;
 801                 }
 802         } else {
 803                 /* unsupported format */
 804                 BUG();
 805         }
 806
 807         return ret_prof;
 808 }
 809
 810 struct scsi_dif_tuple {
 811         __be16 guard_tag;       /* Checksum */
 812         __be16 app_tag;         /* Opaque storage */
 813         __be32 ref_tag;         /* Target LBA or indirect LBA */
 814 };
 815
 816 static inline unsigned
 817 lpfc_cmd_blksize(struct scsi_cmnd *sc)
 818 {
 819         return sc->device->sector_size;
 820 }
 821
 822 /**
 823  * lpfc_get_cmd_dif_parms - Extract DIF parameters from SCSI command
 824  * @sc:             in: SCSI command
 825  * @apptagmask:     out: app tag mask
 826  * @apptagval:      out: app tag value
 827  * @reftag:         out: ref tag (reference tag)
 828  *
 829  * Description:
 830  *   Extract DIF paramters from the command if possible.  Otherwise,
 831  *   use default paratmers.
 832  *
 833  **/
 834 static inline void
 835 lpfc_get_cmd_dif_parms(struct scsi_cmnd *sc, uint16_t *apptagmask,
 836                 uint16_t *apptagval, uint32_t *reftag)
 837 {
 838         struct  scsi_dif_tuple *spt;
 839         unsigned char op = scsi_get_prot_op(sc);
 840         unsigned int protcnt = scsi_prot_sg_count(sc);
 841         static int cnt;
 842
 843         if (protcnt && (op == SCSI_PROT_WRITE_STRIP ||
 844                                 op == SCSI_PROT_WRITE_PASS ||
 845                                 op == SCSI_PROT_WRITE_CONVERT)) {
 846
 847                 cnt++;
 848                 spt = page_address(sg_page(scsi_prot_sglist(sc))) +
 849                         scsi_prot_sglist(sc)[0].offset;
 850                 *apptagmask = 0;
 851                 *apptagval = 0;
 852                 *reftag = cpu_to_be32(spt->ref_tag);
 853
 854         } else {
 855                 /* SBC defines ref tag to be lower 32bits of LBA */
 856                 *reftag = (uint32_t) (0xffffffff & scsi_get_lba(sc));
 857                 *apptagmask = 0;
 858                 *apptagval = 0;
 859         }
 860 }
 861
 862 /*
 863  * This function sets up buffer list for protection groups of
 864  * type LPFC_PG_TYPE_NO_DIF
 865  *
 866  * This is usually used when the HBA is instructed to generate
 867  * DIFs and insert them into data stream (or strip DIF from
 868  * incoming data stream)
 869  *
 870  * The buffer list consists of just one protection group described
 871  * below:
 872  *                                +-------------------------+
 873  *   start of prot group  -->     |          PDE_1          |
 874  *                                +-------------------------+
 875  *                                |         Data BDE        |
 876  *                                +-------------------------+
 877  *                                |more Data BDE's ... (opt)|
 878  *                                +-------------------------+
 879  *
 880  * @sc: pointer to scsi command we're working on
 881  * @bpl: pointer to buffer list for protection groups
 882  * @datacnt: number of segments of data that have been dma mapped
 883  *
 884  * Note: Data s/g buffers have been dma mapped
 885  */
 886 static int
 887 lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
 888                 struct ulp_bde64 *bpl, int datasegcnt)
 889 {
 890         struct scatterlist *sgde = NULL; /* s/g data entry */
 891         struct lpfc_pde *pde1 = NULL;
 892         dma_addr_t physaddr;
 893         int i = 0, num_bde = 0;
 894         int datadir = sc->sc_data_direction;
 895         int prof = LPFC_PROF_INVALID;
 896         unsigned blksize;
 897         uint32_t reftag;
 898         uint16_t apptagmask, apptagval;
 899
 900         pde1 = (struct lpfc_pde *) bpl;
 901         prof = lpfc_sc_to_sli_prof(sc);
 902
 903         if (prof == LPFC_PROF_INVALID)
 904                 goto out;
 905
 906         /* extract some info from the scsi command for PDE1*/
 907         blksize = lpfc_cmd_blksize(sc);
 908         lpfc_get_cmd_dif_parms(sc, &apptagmask, &apptagval, &reftag);
 909
 910         /* setup PDE1 with what we have */
 911         lpfc_pde_set_bg_parms(pde1, LPFC_PDE1_DESCRIPTOR, prof, blksize,
 912                         BG_EC_STOP_ERR);
 913         lpfc_pde_set_dif_parms(pde1, apptagmask, apptagval, reftag);
 914
 915         num_bde++;
 916         bpl++;
 917
 918         /* assumption: caller has already run dma_map_sg on command data */
 919         scsi_for_each_sg(sc, sgde, datasegcnt, i) {
 920                 physaddr = sg_dma_address(sgde);
 921                 bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr));
 922                 bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
 923                 bpl->tus.f.bdeSize = sg_dma_len(sgde);
 924                 if (datadir == DMA_TO_DEVICE)
 925                         bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 926                 else
 927                         bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
 928                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
 929                 bpl++;
 930                 num_bde++;
 931         }
 932
 933 out:
 934         return num_bde;
 935 }
 936
 937 /*
 938  * This function sets up buffer list for protection groups of
 939  * type LPFC_PG_TYPE_DIF_BUF
 940  *
 941  * This is usually used when DIFs are in their own buffers,
 942  * separate from the data. The HBA can then by instructed
 943  * to place the DIFs in the outgoing stream.  For read operations,
 944  * The HBA could extract the DIFs and place it in DIF buffers.
 945  *
 946  * The buffer list for this type consists of one or more of the
 947  * protection groups described below:
 948  *                                    +-------------------------+
 949  *   start of first prot group  -->   |          PDE_1          |
 950  *                                    +-------------------------+
 951  *                                    |      PDE_3 (Prot BDE)   |
 952  *                                    +-------------------------+
 953  *                                    |        Data BDE         |
 954  *                                    +-------------------------+
 955  *                                    |more Data BDE's ... (opt)|
 956  *                                    +-------------------------+
 957  *   start of new  prot group  -->    |          PDE_1          |
 958  *                                    +-------------------------+
 959  *                                    |          ...            |
 960  *                                    +-------------------------+
 961  *
 962  * @sc: pointer to scsi command we're working on
 963  * @bpl: pointer to buffer list for protection groups
 964  * @datacnt: number of segments of data that have been dma mapped
 965  * @protcnt: number of segment of protection data that have been dma mapped
 966  *
 967  * Note: It is assumed that both data and protection s/g buffers have been
 968  *       mapped for DMA
 969  */
 970 static int
 971 lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
 972                 struct ulp_bde64 *bpl, int datacnt, int protcnt)
 973 {
 974         struct scatterlist *sgde = NULL; /* s/g data entry */
 975         struct scatterlist *sgpe = NULL; /* s/g prot entry */
 976         struct lpfc_pde *pde1 = NULL;
 977         struct ulp_bde64 *prot_bde = NULL;
 978         dma_addr_t dataphysaddr, protphysaddr;
 979         unsigned short curr_data = 0, curr_prot = 0;
 980         unsigned int split_offset, protgroup_len;
 981         unsigned int protgrp_blks, protgrp_bytes;
 982         unsigned int remainder, subtotal;
 983         int prof = LPFC_PROF_INVALID;
 984         int datadir = sc->sc_data_direction;
 985         unsigned char pgdone = 0, alldone = 0;
 986         unsigned blksize;
 987         uint32_t reftag;
 988         uint16_t apptagmask, apptagval;
 989         int num_bde = 0;
 990
 991         sgpe = scsi_prot_sglist(sc);
 992         sgde = scsi_sglist(sc);
 993
 994         if (!sgpe || !sgde) {
 995                 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
 996                                 "9020 Invalid s/g entry: data=0x%p prot=0x%p\n",
 997                                 sgpe, sgde);
 998                 return 0;
 999         }
1000
1001         prof = lpfc_sc_to_sli_prof(sc);
1002         if (prof == LPFC_PROF_INVALID)
1003                 goto out;
1004
1005         /* extract some info from the scsi command for PDE1*/
1006         blksize = lpfc_cmd_blksize(sc);
1007         lpfc_get_cmd_dif_parms(sc, &apptagmask, &apptagval, &reftag);
1008
1009         split_offset = 0;
1010         do {
1011                 /* setup the first PDE_1 */
1012                 pde1 = (struct lpfc_pde *) bpl;
1013
1014                 lpfc_pde_set_bg_parms(pde1, LPFC_PDE1_DESCRIPTOR, prof, blksize,
1015                                 BG_EC_STOP_ERR);
1016                 lpfc_pde_set_dif_parms(pde1, apptagmask, apptagval, reftag);
1017
1018                 num_bde++;
1019                 bpl++;
1020
1021                 /* setup the first BDE that points to protection buffer */
1022                 prot_bde = (struct ulp_bde64 *) bpl;
1023                 protphysaddr = sg_dma_address(sgpe);
1024                 prot_bde->addrLow = le32_to_cpu(putPaddrLow(protphysaddr));
1025                 prot_bde->addrHigh = le32_to_cpu(putPaddrHigh(protphysaddr));
1026                 protgroup_len = sg_dma_len(sgpe);
1027
1028
1029                 /* must be integer multiple of the DIF block length */
1030                 BUG_ON(protgroup_len % 8);
1031
1032                 protgrp_blks = protgroup_len / 8;
1033                 protgrp_bytes = protgrp_blks * blksize;
1034
1035                 prot_bde->tus.f.bdeSize = protgroup_len;
1036                 if (datadir == DMA_TO_DEVICE)
1037                         prot_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1038                 else
1039                         prot_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
1040                 prot_bde->tus.w = le32_to_cpu(bpl->tus.w);
1041
1042                 curr_prot++;
1043                 num_bde++;
1044
1045                 /* setup BDE's for data blocks associated with DIF data */
1046                 pgdone = 0;
1047                 subtotal = 0; /* total bytes processed for current prot grp */
1048                 while (!pgdone) {
1049                         if (!sgde) {
1050                                 printk(KERN_ERR "%s Invalid data segment\n",
1051                                                 __func__);
1052                                 return 0;
1053                         }
1054                         bpl++;
1055                         dataphysaddr = sg_dma_address(sgde) + split_offset;
1056                         bpl->addrLow = le32_to_cpu(putPaddrLow(dataphysaddr));
1057                         bpl->addrHigh = le32_to_cpu(putPaddrHigh(dataphysaddr));
1058
1059                         remainder = sg_dma_len(sgde) - split_offset;
1060
1061                         if ((subtotal + remainder) <= protgrp_bytes) {
1062                                 /* we can use this whole buffer */
1063                                 bpl->tus.f.bdeSize = remainder;
1064                                 split_offset = 0;
1065
1066                                 if ((subtotal + remainder) == protgrp_bytes)
1067                                         pgdone = 1;
1068                         } else {
1069                                 /* must split this buffer with next prot grp */
1070                                 bpl->tus.f.bdeSize = protgrp_bytes - subtotal;
1071                                 split_offset += bpl->tus.f.bdeSize;
1072                         }
1073
1074                         subtotal += bpl->tus.f.bdeSize;
1075
1076                         if (datadir == DMA_TO_DEVICE)
1077                                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1078                         else
1079                                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
1080                         bpl->tus.w = le32_to_cpu(bpl->tus.w);
1081
1082                         num_bde++;
1083                         curr_data++;
1084
1085                         if (split_offset)
1086                                 break;
1087
1088                         /* Move to the next s/g segment if possible */
1089                         sgde = sg_next(sgde);
1090                 }
1091
1092                 /* are we done ? */
1093                 if (curr_prot == protcnt) {
1094                         alldone = 1;
1095                 } else if (curr_prot < protcnt) {
1096                         /* advance to next prot buffer */
1097                         sgpe = sg_next(sgpe);
1098                         bpl++;
1099
1100                         /* update the reference tag */
1101                         reftag += protgrp_blks;
1102                 } else {
1103                         /* if we're here, we have a bug */
1104                         printk(KERN_ERR "BLKGRD: bug in %s\n", __func__);
1105                 }
1106
1107         } while (!alldone);
1108
1109 out:
1110
1111
1112         return num_bde;
1113 }
1114 /*
1115  * Given a SCSI command that supports DIF, determine composition of protection
1116  * groups involved in setting up buffer lists
1117  *
1118  * Returns:
1119  *                            for DIF (for both read and write)
1120  * */
1121 static int
1122 lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc)
1123 {
1124         int ret = LPFC_PG_TYPE_INVALID;
1125         unsigned char op = scsi_get_prot_op(sc);
1126
1127         switch (op) {
1128         case SCSI_PROT_READ_STRIP:
1129         case SCSI_PROT_WRITE_INSERT:
1130                 ret = LPFC_PG_TYPE_NO_DIF;
1131                 break;
1132         case SCSI_PROT_READ_INSERT:
1133         case SCSI_PROT_WRITE_STRIP:
1134         case SCSI_PROT_READ_PASS:
1135         case SCSI_PROT_WRITE_PASS:
1136         case SCSI_PROT_WRITE_CONVERT:
1137         case SCSI_PROT_READ_CONVERT:
1138                 ret = LPFC_PG_TYPE_DIF_BUF;
1139                 break;
1140         default:
1141                 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1142                                 "9021 Unsupported protection op:%d\n", op);
1143                 break;
1144         }
1145
1146         return ret;
1147 }
1148
1149 /*
1150  * This is the protection/DIF aware version of
1151  * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the
1152  * two functions eventually, but for now, it's here
1153  */
1154 static int
1155 lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba,
1156                 struct lpfc_scsi_buf *lpfc_cmd)
1157 {
1158         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
1159         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
1160         struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
1161         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
1162         uint32_t num_bde = 0;
1163         int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
1164         int prot_group_type = 0;
1165         int diflen, fcpdl;
1166         unsigned blksize;
1167
1168         /*
1169          * Start the lpfc command prep by bumping the bpl beyond fcp_cmnd
1170          *  fcp_rsp regions to the first data bde entry
1171          */
1172         bpl += 2;
1173         if (scsi_sg_count(scsi_cmnd)) {
1174                 /*
1175                  * The driver stores the segment count returned from pci_map_sg
1176                  * because this a count of dma-mappings used to map the use_sg
1177                  * pages.  They are not guaranteed to be the same for those
1178                  * architectures that implement an IOMMU.
1179                  */
1180                 datasegcnt = dma_map_sg(&phba->pcidev->dev,
1181                                         scsi_sglist(scsi_cmnd),
1182                                         scsi_sg_count(scsi_cmnd), datadir);
1183                 if (unlikely(!datasegcnt))
1184                         return 1;
1185
1186                 lpfc_cmd->seg_cnt = datasegcnt;
1187                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
1188                         printk(KERN_ERR "%s: Too many sg segments from "
1189                                         "dma_map_sg.  Config %d, seg_cnt %d\n",
1190                                         __func__, phba->cfg_sg_seg_cnt,
1191                                         lpfc_cmd->seg_cnt);
1192                         scsi_dma_unmap(scsi_cmnd);
1193                         return 1;
1194                 }
1195
1196                 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
1197
1198                 switch (prot_group_type) {
1199                 case LPFC_PG_TYPE_NO_DIF:
1200                         num_bde = lpfc_bg_setup_bpl(phba, scsi_cmnd, bpl,
1201                                         datasegcnt);
1202                         /* we shoud have 2 or more entries in buffer list */
1203                         if (num_bde < 2)
1204                                 goto err;
1205                         break;
1206                 case LPFC_PG_TYPE_DIF_BUF:{
1207                         /*
1208                          * This type indicates that protection buffers are
1209                          * passed to the driver, so that needs to be prepared
1210                          * for DMA
1211                          */
1212                         protsegcnt = dma_map_sg(&phba->pcidev->dev,
1213                                         scsi_prot_sglist(scsi_cmnd),
1214                                         scsi_prot_sg_count(scsi_cmnd), datadir);
1215                         if (unlikely(!protsegcnt)) {
1216                                 scsi_dma_unmap(scsi_cmnd);
1217                                 return 1;
1218                         }
1219
1220                         lpfc_cmd->prot_seg_cnt = protsegcnt;
1221                         if (lpfc_cmd->prot_seg_cnt
1222                             > phba->cfg_prot_sg_seg_cnt) {
1223                                 printk(KERN_ERR "%s: Too many prot sg segments "
1224                                                 "from dma_map_sg.  Config %d,"
1225                                                 "prot_seg_cnt %d\n", __func__,
1226                                                 phba->cfg_prot_sg_seg_cnt,
1227                                                 lpfc_cmd->prot_seg_cnt);
1228                                 dma_unmap_sg(&phba->pcidev->dev,
1229                                              scsi_prot_sglist(scsi_cmnd),
1230                                              scsi_prot_sg_count(scsi_cmnd),
1231                                              datadir);
1232                                 scsi_dma_unmap(scsi_cmnd);
1233                                 return 1;
1234                         }
1235
1236                         num_bde = lpfc_bg_setup_bpl_prot(phba, scsi_cmnd, bpl,
1237                                         datasegcnt, protsegcnt);
1238                         /* we shoud have 3 or more entries in buffer list */
1239                         if (num_bde < 3)
1240                                 goto err;
1241                         break;
1242                 }
1243                 case LPFC_PG_TYPE_INVALID:
1244                 default:
1245                         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1246                                         "9022 Unexpected protection group %i\n",
1247                                         prot_group_type);
1248                         return 1;
1249                 }
1250         }
1251
1252         /*
1253          * Finish initializing those IOCB fields that are dependent on the
1254          * scsi_cmnd request_buffer.  Note that the bdeSize is explicitly
1255          * reinitialized since all iocb memory resources are used many times
1256          * for transmit, receive, and continuation bpl's.
1257          */
1258         iocb_cmd->un.fcpi64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
1259         iocb_cmd->un.fcpi64.bdl.bdeSize += (num_bde * sizeof(struct ulp_bde64));
1260         iocb_cmd->ulpBdeCount = 1;
1261         iocb_cmd->ulpLe = 1;
1262
1263         fcpdl = scsi_bufflen(scsi_cmnd);
1264
1265         if (scsi_get_prot_type(scsi_cmnd) == SCSI_PROT_DIF_TYPE1) {
1266                 /*
1267                  * We are in DIF Type 1 mode
1268                  * Every data block has a 8 byte DIF (trailer)
1269                  * attached to it.  Must ajust FCP data length
1270                  */
1271                 blksize = lpfc_cmd_blksize(scsi_cmnd);
1272                 diflen = (fcpdl / blksize) * 8;
1273                 fcpdl += diflen;
1274         }
1275         fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
1276
1277         /*
1278          * Due to difference in data length between DIF/non-DIF paths,
1279          * we need to set word 4 of IOCB here
1280          */
1281         iocb_cmd->un.fcpi.fcpi_parm = fcpdl;
1282
1283         return 0;
1284 err:
1285         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1286                         "9023 Could not setup all needed BDE's"
1287                         "prot_group_type=%d, num_bde=%d\n",
1288                         prot_group_type, num_bde);
1289         return 1;
1290 }
1291
1292 /*
1293  * This function checks for BlockGuard errors detected by
1294  * the HBA.  In case of errors, the ASC/ASCQ fields in the
1295  * sense buffer will be set accordingly, paired with
1296  * ILLEGAL_REQUEST to signal to the kernel that the HBA
1297  * detected corruption.
1298  *
1299  * Returns:
1300  *  0 - No error found
1301  *  1 - BlockGuard error found
1302  * -1 - Internal error (bad profile, ...etc)
1303  */
1304 static int
1305 lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
1306                         struct lpfc_iocbq *pIocbOut)
1307 {
1308         struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
1309         struct sli3_bg_fields *bgf = &pIocbOut->iocb.unsli3.sli3_bg;
1310         int ret = 0;
1311         uint32_t bghm = bgf->bghm;
1312         uint32_t bgstat = bgf->bgstat;
1313         uint64_t failing_sector = 0;
1314
1315         printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%lx "
1316                         "bgstat=0x%x bghm=0x%x\n",
1317                         cmd->cmnd[0], (unsigned long long)scsi_get_lba(cmd),
1318                         cmd->request->nr_sectors, bgstat, bghm);
1319
1320         spin_lock(&_dump_buf_lock);
1321         if (!_dump_buf_done) {
1322                 printk(KERN_ERR "Saving Data for %u blocks to debugfs\n",
1323                                 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
1324                 lpfc_debug_save_data(cmd);
1325
1326                 /* If we have a prot sgl, save the DIF buffer */
1327                 if (lpfc_prot_group_type(phba, cmd) ==
1328                                 LPFC_PG_TYPE_DIF_BUF) {
1329                         printk(KERN_ERR "Saving DIF for %u blocks to debugfs\n",
1330                                         (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
1331                         lpfc_debug_save_dif(cmd);
1332                 }
1333
1334                 _dump_buf_done = 1;
1335         }
1336         spin_unlock(&_dump_buf_lock);
1337
1338         if (lpfc_bgs_get_invalid_prof(bgstat)) {
1339                 cmd->result = ScsiResult(DID_ERROR, 0);
1340                 printk(KERN_ERR "Invalid BlockGuard profile. bgstat:0x%x\n",
1341                                 bgstat);
1342                 ret = (-1);
1343                 goto out;
1344         }
1345
1346         if (lpfc_bgs_get_uninit_dif_block(bgstat)) {
1347                 cmd->result = ScsiResult(DID_ERROR, 0);
1348                 printk(KERN_ERR "Invalid BlockGuard DIF Block. bgstat:0x%x\n",
1349                                 bgstat);
1350                 ret = (-1);
1351                 goto out;
1352         }
1353
1354         if (lpfc_bgs_get_guard_err(bgstat)) {
1355                 ret = 1;
1356
1357                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1358                                 0x10, 0x1);
1359                 cmd->result = DRIVER_SENSE << 24
1360                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
1361                 phba->bg_guard_err_cnt++;
1362                 printk(KERN_ERR "BLKGRD: guard_tag error\n");
1363         }
1364
1365         if (lpfc_bgs_get_reftag_err(bgstat)) {
1366                 ret = 1;
1367
1368                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1369                                 0x10, 0x3);
1370                 cmd->result = DRIVER_SENSE << 24
1371                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
1372
1373                 phba->bg_reftag_err_cnt++;
1374                 printk(KERN_ERR "BLKGRD: ref_tag error\n");
1375         }
1376
1377         if (lpfc_bgs_get_apptag_err(bgstat)) {
1378                 ret = 1;
1379
1380                 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1381                                 0x10, 0x2);
1382                 cmd->result = DRIVER_SENSE << 24
1383                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
1384
1385                 phba->bg_apptag_err_cnt++;
1386                 printk(KERN_ERR "BLKGRD: app_tag error\n");
1387         }
1388
1389         if (lpfc_bgs_get_hi_water_mark_present(bgstat)) {
1390                 /*
1391                  * setup sense data descriptor 0 per SPC-4 as an information
1392                  * field, and put the failing LBA in it
1393                  */
1394                 cmd->sense_buffer[8] = 0;     /* Information */
1395                 cmd->sense_buffer[9] = 0xa;   /* Add. length */
1396                 bghm /= cmd->device->sector_size;
1397
1398                 failing_sector = scsi_get_lba(cmd);
1399                 failing_sector += bghm;
1400
1401                 put_unaligned_be64(failing_sector, &cmd->sense_buffer[10]);
1402         }
1403
1404         if (!ret) {
1405                 /* No error was reported - problem in FW? */
1406                 cmd->result = ScsiResult(DID_ERROR, 0);
1407                 printk(KERN_ERR "BLKGRD: no errors reported!\n");
1408         }
1409
1410 out:
1411         return ret;
1412 }
1413
1414 /**
1415  * lpfc_send_scsi_error_event - Posts an event when there is SCSI error
1416  * @phba: Pointer to hba context object.
1417  * @vport: Pointer to vport object.
1418  * @lpfc_cmd: Pointer to lpfc scsi command which reported the error.
1419  * @rsp_iocb: Pointer to response iocb object which reported error.
1420  *
1421  * This function posts an event when there is a SCSI command reporting
1422  * error from the scsi device.
1423  **/
1424 static void
1425 lpfc_send_scsi_error_event(struct lpfc_hba *phba, struct lpfc_vport *vport,
1426                 struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_iocbq *rsp_iocb) {
1427         struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
1428         struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
1429         uint32_t resp_info = fcprsp->rspStatus2;
1430         uint32_t scsi_status = fcprsp->rspStatus3;
1431         uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
1432         struct lpfc_fast_path_event *fast_path_evt = NULL;
1433         struct lpfc_nodelist *pnode = lpfc_cmd->rdata->pnode;
1434         unsigned long flags;
1435
1436         /* If there is queuefull or busy condition send a scsi event */
1437         if ((cmnd->result == SAM_STAT_TASK_SET_FULL) ||
1438                 (cmnd->result == SAM_STAT_BUSY)) {
1439                 fast_path_evt = lpfc_alloc_fast_evt(phba);
1440                 if (!fast_path_evt)
1441                         return;
1442                 fast_path_evt->un.scsi_evt.event_type =
1443                         FC_REG_SCSI_EVENT;
1444                 fast_path_evt->un.scsi_evt.subcategory =
1445                 (cmnd->result == SAM_STAT_TASK_SET_FULL) ?
1446                 LPFC_EVENT_QFULL : LPFC_EVENT_DEVBSY;
1447                 fast_path_evt->un.scsi_evt.lun = cmnd->device->lun;
1448                 memcpy(&fast_path_evt->un.scsi_evt.wwpn,
1449                         &pnode->nlp_portname, sizeof(struct lpfc_name));
1450                 memcpy(&fast_path_evt->un.scsi_evt.wwnn,
1451                         &pnode->nlp_nodename, sizeof(struct lpfc_name));
1452         } else if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen &&
1453                 ((cmnd->cmnd[0] == READ_10) || (cmnd->cmnd[0] == WRITE_10))) {
1454                 fast_path_evt = lpfc_alloc_fast_evt(phba);
1455                 if (!fast_path_evt)
1456                         return;
1457                 fast_path_evt->un.check_cond_evt.scsi_event.event_type =
1458                         FC_REG_SCSI_EVENT;
1459                 fast_path_evt->un.check_cond_evt.scsi_event.subcategory =
1460                         LPFC_EVENT_CHECK_COND;
1461                 fast_path_evt->un.check_cond_evt.scsi_event.lun =
1462                         cmnd->device->lun;
1463                 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwpn,
1464                         &pnode->nlp_portname, sizeof(struct lpfc_name));
1465                 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwnn,
1466                         &pnode->nlp_nodename, sizeof(struct lpfc_name));
1467                 fast_path_evt->un.check_cond_evt.sense_key =
1468                         cmnd->sense_buffer[2] & 0xf;
1469                 fast_path_evt->un.check_cond_evt.asc = cmnd->sense_buffer[12];
1470                 fast_path_evt->un.check_cond_evt.ascq = cmnd->sense_buffer[13];
1471         } else if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
1472                      fcpi_parm &&
1473                      ((be32_to_cpu(fcprsp->rspResId) != fcpi_parm) ||
1474                         ((scsi_status == SAM_STAT_GOOD) &&
1475                         !(resp_info & (RESID_UNDER | RESID_OVER))))) {
1476                 /*
1477                  * If status is good or resid does not match with fcp_param and
1478                  * there is valid fcpi_parm, then there is a read_check error
1479                  */
1480                 fast_path_evt = lpfc_alloc_fast_evt(phba);
1481                 if (!fast_path_evt)
1482                         return;
1483                 fast_path_evt->un.read_check_error.header.event_type =
1484                         FC_REG_FABRIC_EVENT;
1485                 fast_path_evt->un.read_check_error.header.subcategory =
1486                         LPFC_EVENT_FCPRDCHKERR;
1487                 memcpy(&fast_path_evt->un.read_check_error.header.wwpn,
1488                         &pnode->nlp_portname, sizeof(struct lpfc_name));
1489                 memcpy(&fast_path_evt->un.read_check_error.header.wwnn,
1490                         &pnode->nlp_nodename, sizeof(struct lpfc_name));
1491                 fast_path_evt->un.read_check_error.lun = cmnd->device->lun;
1492                 fast_path_evt->un.read_check_error.opcode = cmnd->cmnd[0];
1493                 fast_path_evt->un.read_check_error.fcpiparam =
1494                         fcpi_parm;
1495         } else
1496                 return;
1497
1498         fast_path_evt->vport = vport;
1499         spin_lock_irqsave(&phba->hbalock, flags);
1500         list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list);
1501         spin_unlock_irqrestore(&phba->hbalock, flags);
1502         lpfc_worker_wake_up(phba);
1503         return;
1504 }
1505
1506 /**
1507  * lpfc_scsi_unprep_dma_buf - Routine to un-map DMA mapping of scatter gather
1508  * @phba: The Hba for which this call is being executed.
1509  * @psb: The scsi buffer which is going to be un-mapped.
1510  *
1511  * This routine does DMA un-mapping of scatter gather list of scsi command
1512  * field of @lpfc_cmd.
1513  **/
1514 static void
1515 lpfc_scsi_unprep_dma_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * psb)
1516 {
1517         /*
1518          * There are only two special cases to consider.  (1) the scsi command
1519          * requested scatter-gather usage or (2) the scsi command allocated
1520          * a request buffer, but did not request use_sg.  There is a third
1521          * case, but it does not require resource deallocation.
1522          */
1523         if (psb->seg_cnt > 0)
1524                 scsi_dma_unmap(psb->pCmd);
1525         if (psb->prot_seg_cnt > 0)
1526                 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(psb->pCmd),
1527                                 scsi_prot_sg_count(psb->pCmd),
1528                                 psb->pCmd->sc_data_direction);
1529 }
1530
1531 /**
1532  * lpfc_handler_fcp_err - FCP response handler
1533  * @vport: The virtual port for which this call is being executed.
1534  * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
1535  * @rsp_iocb: The response IOCB which contains FCP error.
1536  *
1537  * This routine is called to process response IOCB with status field
1538  * IOSTAT_FCP_RSP_ERROR. This routine sets result field of scsi command
1539  * based upon SCSI and FCP error.
1540  **/
1541 static void
1542 lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
1543                     struct lpfc_iocbq *rsp_iocb)
1544 {
1545         struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
1546         struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
1547         struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
1548         uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
1549         uint32_t resp_info = fcprsp->rspStatus2;
1550         uint32_t scsi_status = fcprsp->rspStatus3;
1551         uint32_t *lp;
1552         uint32_t host_status = DID_OK;
1553         uint32_t rsplen = 0;
1554         uint32_t logit = LOG_FCP | LOG_FCP_ERROR;
1555
1556
1557         /*
1558          *  If this is a task management command, there is no
1559          *  scsi packet associated with this lpfc_cmd.  The driver
1560          *  consumes it.
1561          */
1562         if (fcpcmd->fcpCntl2) {
1563                 scsi_status = 0;
1564                 goto out;
1565         }
1566
1567         if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) {
1568                 uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen);
1569                 if (snslen > SCSI_SENSE_BUFFERSIZE)
1570                         snslen = SCSI_SENSE_BUFFERSIZE;
1571
1572                 if (resp_info & RSP_LEN_VALID)
1573                   rsplen = be32_to_cpu(fcprsp->rspRspLen);
1574                 memcpy(cmnd->sense_buffer, &fcprsp->rspInfo0 + rsplen, snslen);
1575         }
1576         lp = (uint32_t *)cmnd->sense_buffer;
1577
1578         if (!scsi_status && (resp_info & RESID_UNDER))
1579                 logit = LOG_FCP;
1580
1581         lpfc_printf_vlog(vport, KERN_WARNING, logit,
1582                          "9024 FCP command x%x failed: x%x SNS x%x x%x "
1583                          "Data: x%x x%x x%x x%x x%x\n",
1584                          cmnd->cmnd[0], scsi_status,
1585                          be32_to_cpu(*lp), be32_to_cpu(*(lp + 3)), resp_info,
1586                          be32_to_cpu(fcprsp->rspResId),
1587                          be32_to_cpu(fcprsp->rspSnsLen),
1588                          be32_to_cpu(fcprsp->rspRspLen),
1589                          fcprsp->rspInfo3);
1590
1591         if (resp_info & RSP_LEN_VALID) {
1592                 rsplen = be32_to_cpu(fcprsp->rspRspLen);
1593                 if ((rsplen != 0 && rsplen != 4 && rsplen != 8) ||
1594                     (fcprsp->rspInfo3 != RSP_NO_FAILURE)) {
1595                         host_status = DID_ERROR;
1596                         goto out;
1597                 }
1598         }
1599
1600         scsi_set_resid(cmnd, 0);
1601         if (resp_info & RESID_UNDER) {
1602                 scsi_set_resid(cmnd, be32_to_cpu(fcprsp->rspResId));
1603
1604                 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
1605                                  "9025 FCP Read Underrun, expected %d, "
1606                                  "residual %d Data: x%x x%x x%x\n",
1607                                  be32_to_cpu(fcpcmd->fcpDl),
1608                                  scsi_get_resid(cmnd), fcpi_parm, cmnd->cmnd[0],
1609                                  cmnd->underflow);
1610
1611                 /*
1612                  * If there is an under run check if under run reported by
1613                  * storage array is same as the under run reported by HBA.
1614                  * If this is not same, there is a dropped frame.
1615                  */
1616                 if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
1617                         fcpi_parm &&
1618                         (scsi_get_resid(cmnd) != fcpi_parm)) {
1619                         lpfc_printf_vlog(vport, KERN_WARNING,
1620                                          LOG_FCP | LOG_FCP_ERROR,
1621                                          "9026 FCP Read Check Error "
1622                                          "and Underrun Data: x%x x%x x%x x%x\n",
1623                                          be32_to_cpu(fcpcmd->fcpDl),
1624                                          scsi_get_resid(cmnd), fcpi_parm,
1625                                          cmnd->cmnd[0]);
1626                         scsi_set_resid(cmnd, scsi_bufflen(cmnd));
1627                         host_status = DID_ERROR;
1628                 }
1629                 /*
1630                  * The cmnd->underflow is the minimum number of bytes that must
1631                  * be transfered for this command.  Provided a sense condition
1632                  * is not present, make sure the actual amount transferred is at
1633                  * least the underflow value or fail.
1634                  */
1635                 if (!(resp_info & SNS_LEN_VALID) &&
1636                     (scsi_status == SAM_STAT_GOOD) &&
1637                     (scsi_bufflen(cmnd) - scsi_get_resid(cmnd)
1638                      < cmnd->underflow)) {
1639                         lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
1640                                          "9027 FCP command x%x residual "
1641                                          "underrun converted to error "
1642                                          "Data: x%x x%x x%x\n",
1643                                          cmnd->cmnd[0], scsi_bufflen(cmnd),
1644                                          scsi_get_resid(cmnd), cmnd->underflow);
1645                         host_status = DID_ERROR;
1646                 }
1647         } else if (resp_info & RESID_OVER) {
1648                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
1649                                  "9028 FCP command x%x residual overrun error. "
1650                                  "Data: x%x x%x \n", cmnd->cmnd[0],
1651                                  scsi_bufflen(cmnd), scsi_get_resid(cmnd));
1652                 host_status = DID_ERROR;
1653
1654         /*
1655          * Check SLI validation that all the transfer was actually done
1656          * (fcpi_parm should be zero). Apply check only to reads.
1657          */
1658         } else if ((scsi_status == SAM_STAT_GOOD) && fcpi_parm &&
1659                         (cmnd->sc_data_direction == DMA_FROM_DEVICE)) {
1660                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP | LOG_FCP_ERROR,
1661                                  "9029 FCP Read Check Error Data: "
1662                                  "x%x x%x x%x x%x\n",
1663                                  be32_to_cpu(fcpcmd->fcpDl),
1664                                  be32_to_cpu(fcprsp->rspResId),
1665                                  fcpi_parm, cmnd->cmnd[0]);
1666                 host_status = DID_ERROR;
1667                 scsi_set_resid(cmnd, scsi_bufflen(cmnd));
1668         }
1669
1670  out:
1671         cmnd->result = ScsiResult(host_status, scsi_status);
1672         lpfc_send_scsi_error_event(vport->phba, vport, lpfc_cmd, rsp_iocb);
1673 }
1674
1675 /**
1676  * lpfc_scsi_cmd_iocb_cmpl - Scsi cmnd IOCB completion routine
1677  * @phba: The Hba for which this call is being executed.
1678  * @pIocbIn: The command IOCBQ for the scsi cmnd.
1679  * @pIocbOut: The response IOCBQ for the scsi cmnd .
1680  *
1681  * This routine assigns scsi command result by looking into response IOCB
1682  * status field appropriately. This routine handles QUEUE FULL condition as
1683  * well by ramping down device queue depth.
1684  **/
1685 static void
1686 lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
1687                         struct lpfc_iocbq *pIocbOut)
1688 {
1689         struct lpfc_scsi_buf *lpfc_cmd =
1690                 (struct lpfc_scsi_buf *) pIocbIn->context1;
1691         struct lpfc_vport      *vport = pIocbIn->vport;
1692         struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
1693         struct lpfc_nodelist *pnode = rdata->pnode;
1694         struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
1695         int result;
1696         struct scsi_device *tmp_sdev;
1697         int depth = 0;
1698         unsigned long flags;
1699         struct lpfc_fast_path_event *fast_path_evt;
1700         struct Scsi_Host *shost = cmd->device->host;
1701         uint32_t queue_depth, scsi_id;
1702
1703         lpfc_cmd->result = pIocbOut->iocb.un.ulpWord[4];
1704         lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
1705         if (pnode && NLP_CHK_NODE_ACT(pnode))
1706                 atomic_dec(&pnode->cmd_pending);
1707
1708         if (lpfc_cmd->status) {
1709                 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
1710                     (lpfc_cmd->result & IOERR_DRVR_MASK))
1711                         lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
1712                 else if (lpfc_cmd->status >= IOSTAT_CNT)
1713                         lpfc_cmd->status = IOSTAT_DEFAULT;
1714
1715                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
1716                                  "9030 FCP cmd x%x failed <%d/%d> "
1717                                  "status: x%x result: x%x Data: x%x x%x\n",
1718                                  cmd->cmnd[0],
1719                                  cmd->device ? cmd->device->id : 0xffff,
1720                                  cmd->device ? cmd->device->lun : 0xffff,
1721                                  lpfc_cmd->status, lpfc_cmd->result,
1722                                  pIocbOut->iocb.ulpContext,
1723                                  lpfc_cmd->cur_iocbq.iocb.ulpIoTag);
1724
1725                 switch (lpfc_cmd->status) {
1726                 case IOSTAT_FCP_RSP_ERROR:
1727                         /* Call FCP RSP handler to determine result */
1728                         lpfc_handle_fcp_err(vport, lpfc_cmd, pIocbOut);
1729                         break;
1730                 case IOSTAT_NPORT_BSY:
1731                 case IOSTAT_FABRIC_BSY:
1732                         cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED, 0);
1733                         fast_path_evt = lpfc_alloc_fast_evt(phba);
1734                         if (!fast_path_evt)
1735                                 break;
1736                         fast_path_evt->un.fabric_evt.event_type =
1737                                 FC_REG_FABRIC_EVENT;
1738                         fast_path_evt->un.fabric_evt.subcategory =
1739                                 (lpfc_cmd->status == IOSTAT_NPORT_BSY) ?
1740                                 LPFC_EVENT_PORT_BUSY : LPFC_EVENT_FABRIC_BUSY;
1741                         if (pnode && NLP_CHK_NODE_ACT(pnode)) {
1742                                 memcpy(&fast_path_evt->un.fabric_evt.wwpn,
1743                                         &pnode->nlp_portname,
1744                                         sizeof(struct lpfc_name));
1745                                 memcpy(&fast_path_evt->un.fabric_evt.wwnn,
1746                                         &pnode->nlp_nodename,
1747                                         sizeof(struct lpfc_name));
1748                         }
1749                         fast_path_evt->vport = vport;
1750                         fast_path_evt->work_evt.evt =
1751                                 LPFC_EVT_FASTPATH_MGMT_EVT;
1752                         spin_lock_irqsave(&phba->hbalock, flags);
1753                         list_add_tail(&fast_path_evt->work_evt.evt_listp,
1754                                 &phba->work_list);
1755                         spin_unlock_irqrestore(&phba->hbalock, flags);
1756                         lpfc_worker_wake_up(phba);
1757                         break;
1758                 case IOSTAT_LOCAL_REJECT:
1759                         if (lpfc_cmd->result == IOERR_INVALID_RPI ||
1760                             lpfc_cmd->result == IOERR_NO_RESOURCES ||
1761                             lpfc_cmd->result == IOERR_ABORT_REQUESTED) {
1762                                 cmd->result = ScsiResult(DID_REQUEUE, 0);
1763                                 break;
1764                         }
1765
1766                         if ((lpfc_cmd->result == IOERR_RX_DMA_FAILED ||
1767                              lpfc_cmd->result == IOERR_TX_DMA_FAILED) &&
1768                              pIocbOut->iocb.unsli3.sli3_bg.bgstat) {
1769                                 if (scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
1770                                         /*
1771                                          * This is a response for a BG enabled
1772                                          * cmd. Parse BG error
1773                                          */
1774                                         lpfc_parse_bg_err(phba, lpfc_cmd,
1775                                                         pIocbOut);
1776                                         break;
1777                                 } else {
1778                                         lpfc_printf_vlog(vport, KERN_WARNING,
1779                                                         LOG_BG,
1780                                                         "9031 non-zero BGSTAT "
1781                                                         "on unprotected cmd");
1782                                 }
1783                         }
1784
1785                 /* else: fall through */
1786                 default:
1787                         cmd->result = ScsiResult(DID_ERROR, 0);
1788                         break;
1789                 }
1790
1791                 if (!pnode || !NLP_CHK_NODE_ACT(pnode)
1792                     || (pnode->nlp_state != NLP_STE_MAPPED_NODE))
1793                         cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED,
1794                                                  SAM_STAT_BUSY);
1795         } else {
1796                 cmd->result = ScsiResult(DID_OK, 0);
1797         }
1798
1799         if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) {
1800                 uint32_t *lp = (uint32_t *)cmd->sense_buffer;
1801
1802                 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
1803                                  "0710 Iodone <%d/%d> cmd %p, error "
1804                                  "x%x SNS x%x x%x Data: x%x x%x\n",
1805                                  cmd->device->id, cmd->device->lun, cmd,
1806                                  cmd->result, *lp, *(lp + 3), cmd->retries,
1807                                  scsi_get_resid(cmd));
1808         }
1809
1810         lpfc_update_stats(phba, lpfc_cmd);
1811         result = cmd->result;
1812         if (vport->cfg_max_scsicmpl_time &&
1813            time_after(jiffies, lpfc_cmd->start_time +
1814                 msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) {
1815                 spin_lock_irqsave(shost->host_lock, flags);
1816                 if (pnode && NLP_CHK_NODE_ACT(pnode)) {
1817                         if (pnode->cmd_qdepth >
1818                                 atomic_read(&pnode->cmd_pending) &&
1819                                 (atomic_read(&pnode->cmd_pending) >
1820                                 LPFC_MIN_TGT_QDEPTH) &&
1821                                 ((cmd->cmnd[0] == READ_10) ||
1822                                 (cmd->cmnd[0] == WRITE_10)))
1823                                 pnode->cmd_qdepth =
1824                                         atomic_read(&pnode->cmd_pending);
1825
1826                         pnode->last_change_time = jiffies;
1827                 }
1828                 spin_unlock_irqrestore(shost->host_lock, flags);
1829         } else if (pnode && NLP_CHK_NODE_ACT(pnode)) {
1830                 if ((pnode->cmd_qdepth < LPFC_MAX_TGT_QDEPTH) &&
1831                    time_after(jiffies, pnode->last_change_time +
1832                               msecs_to_jiffies(LPFC_TGTQ_INTERVAL))) {
1833                         spin_lock_irqsave(shost->host_lock, flags);
1834                         pnode->cmd_qdepth += pnode->cmd_qdepth *
1835                                 LPFC_TGTQ_RAMPUP_PCENT / 100;
1836                         if (pnode->cmd_qdepth > LPFC_MAX_TGT_QDEPTH)
1837                                 pnode->cmd_qdepth = LPFC_MAX_TGT_QDEPTH;
1838                         pnode->last_change_time = jiffies;
1839                         spin_unlock_irqrestore(shost->host_lock, flags);
1840                 }
1841         }
1842
1843         lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
1844
1845         /* The sdev is not guaranteed to be valid post scsi_done upcall. */
1846         queue_depth = cmd->device->queue_depth;
1847         scsi_id = cmd->device->id;
1848         cmd->scsi_done(cmd);
1849
1850         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1851                 /*
1852                  * If there is a thread waiting for command completion
1853                  * wake up the thread.
1854                  */
1855                 spin_lock_irqsave(shost->host_lock, flags);
1856                 lpfc_cmd->pCmd = NULL;
1857                 if (lpfc_cmd->waitq)
1858                         wake_up(lpfc_cmd->waitq);
1859                 spin_unlock_irqrestore(shost->host_lock, flags);
1860                 lpfc_release_scsi_buf(phba, lpfc_cmd);
1861                 return;
1862         }
1863
1864
1865         if (!result)
1866                 lpfc_rampup_queue_depth(vport, queue_depth);
1867
1868         if (!result && pnode && NLP_CHK_NODE_ACT(pnode) &&
1869            ((jiffies - pnode->last_ramp_up_time) >
1870                 LPFC_Q_RAMP_UP_INTERVAL * HZ) &&
1871            ((jiffies - pnode->last_q_full_time) >
1872                 LPFC_Q_RAMP_UP_INTERVAL * HZ) &&
1873            (vport->cfg_lun_queue_depth > queue_depth)) {
1874                 shost_for_each_device(tmp_sdev, shost) {
1875                         if (vport->cfg_lun_queue_depth > tmp_sdev->queue_depth){
1876                                 if (tmp_sdev->id != scsi_id)
1877                                         continue;
1878                                 if (tmp_sdev->ordered_tags)
1879                                         scsi_adjust_queue_depth(tmp_sdev,
1880                                                 MSG_ORDERED_TAG,
1881                                                 tmp_sdev->queue_depth+1);
1882                                 else
1883                                         scsi_adjust_queue_depth(tmp_sdev,
1884                                                 MSG_SIMPLE_TAG,
1885                                                 tmp_sdev->queue_depth+1);
1886
1887                                 pnode->last_ramp_up_time = jiffies;
1888                         }
1889                 }
1890                 lpfc_send_sdev_queuedepth_change_event(phba, vport, pnode,
1891                         0xFFFFFFFF,
1892                         queue_depth , queue_depth + 1);
1893         }
1894
1895         /*
1896          * Check for queue full.  If the lun is reporting queue full, then
1897          * back off the lun queue depth to prevent target overloads.
1898          */
1899         if (result == SAM_STAT_TASK_SET_FULL && pnode &&
1900             NLP_CHK_NODE_ACT(pnode)) {
1901                 pnode->last_q_full_time = jiffies;
1902
1903                 shost_for_each_device(tmp_sdev, shost) {
1904                         if (tmp_sdev->id != scsi_id)
1905                                 continue;
1906                         depth = scsi_track_queue_full(tmp_sdev,
1907                                         tmp_sdev->queue_depth - 1);
1908                 }
1909                 /*
1910                  * The queue depth cannot be lowered any more.
1911                  * Modify the returned error code to store
1912                  * the final depth value set by
1913                  * scsi_track_queue_full.
1914                  */
1915                 if (depth == -1)
1916                         depth = shost->cmd_per_lun;
1917
1918                 if (depth) {
1919                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
1920                                          "0711 detected queue full - lun queue "
1921                                          "depth adjusted to %d.\n", depth);
1922                         lpfc_send_sdev_queuedepth_change_event(phba, vport,
1923                                 pnode, 0xFFFFFFFF,
1924                                 depth+1, depth);
1925                 }
1926         }
1927
1928         /*
1929          * If there is a thread waiting for command completion
1930          * wake up the thread.
1931          */
1932         spin_lock_irqsave(shost->host_lock, flags);
1933         lpfc_cmd->pCmd = NULL;
1934         if (lpfc_cmd->waitq)
1935                 wake_up(lpfc_cmd->waitq);
1936         spin_unlock_irqrestore(shost->host_lock, flags);
1937
1938         lpfc_release_scsi_buf(phba, lpfc_cmd);
1939 }
1940
1941 /**
1942  * lpfc_fcpcmd_to_iocb - copy the fcp_cmd data into the IOCB
1943  * @data: A pointer to the immediate command data portion of the IOCB.
1944  * @fcp_cmnd: The FCP Command that is provided by the SCSI layer.
1945  *
1946  * The routine copies the entire FCP command from @fcp_cmnd to @data while
1947  * byte swapping the data to big endian format for transmission on the wire.
1948  **/
1949 static void
1950 lpfc_fcpcmd_to_iocb(uint8_t *data, struct fcp_cmnd *fcp_cmnd)
1951 {
1952         int i, j;
1953         for (i = 0, j = 0; i < sizeof(struct fcp_cmnd);
1954              i += sizeof(uint32_t), j++) {
1955                 ((uint32_t *)data)[j] = cpu_to_be32(((uint32_t *)fcp_cmnd)[j]);
1956         }
1957 }
1958
1959 /**
1960  * lpfc_scsi_prep_cmnd -  Routine to convert scsi cmnd to FCP information unit
1961  * @vport: The virtual port for which this call is being executed.
1962  * @lpfc_cmd: The scsi command which needs to send.
1963  * @pnode: Pointer to lpfc_nodelist.
1964  *
1965  * This routine initializes fcp_cmnd and iocb data structure from scsi command
1966  * to transfer.
1967  **/
1968 static void
1969 lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
1970                     struct lpfc_nodelist *pnode)
1971 {
1972         struct lpfc_hba *phba = vport->phba;
1973         struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
1974         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
1975         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
1976         struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
1977         int datadir = scsi_cmnd->sc_data_direction;
1978         char tag[2];
1979
1980         if (!pnode || !NLP_CHK_NODE_ACT(pnode))
1981                 return;
1982
1983         lpfc_cmd->fcp_rsp->rspSnsLen = 0;
1984         /* clear task management bits */
1985         lpfc_cmd->fcp_cmnd->fcpCntl2 = 0;
1986
1987         int_to_scsilun(lpfc_cmd->pCmd->device->lun,
1988                         &lpfc_cmd->fcp_cmnd->fcp_lun);
1989
1990         memcpy(&fcp_cmnd->fcpCdb[0], scsi_cmnd->cmnd, 16);
1991
1992         if (scsi_populate_tag_msg(scsi_cmnd, tag)) {
1993                 switch (tag[0]) {
1994                 case HEAD_OF_QUEUE_TAG:
1995                         fcp_cmnd->fcpCntl1 = HEAD_OF_Q;
1996                         break;
1997                 case ORDERED_QUEUE_TAG:
1998                         fcp_cmnd->fcpCntl1 = ORDERED_Q;
1999                         break;
2000                 default:
2001                         fcp_cmnd->fcpCntl1 = SIMPLE_Q;
2002                         break;
2003                 }
2004         } else
2005                 fcp_cmnd->fcpCntl1 = 0;
2006
2007         /*
2008          * There are three possibilities here - use scatter-gather segment, use
2009          * the single mapping, or neither.  Start the lpfc command prep by
2010          * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
2011          * data bde entry.
2012          */
2013         if (scsi_sg_count(scsi_cmnd)) {
2014                 if (datadir == DMA_TO_DEVICE) {
2015                         iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
2016                         iocb_cmd->un.fcpi.fcpi_parm = 0;
2017                         iocb_cmd->ulpPU = 0;
2018                         fcp_cmnd->fcpCntl3 = WRITE_DATA;
2019                         phba->fc4OutputRequests++;
2020                 } else {
2021                         iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR;
2022                         iocb_cmd->ulpPU = PARM_READ_CHECK;
2023                         fcp_cmnd->fcpCntl3 = READ_DATA;
2024                         phba->fc4InputRequests++;
2025                 }
2026         } else {
2027                 iocb_cmd->ulpCommand = CMD_FCP_ICMND64_CR;
2028                 iocb_cmd->un.fcpi.fcpi_parm = 0;
2029                 iocb_cmd->ulpPU = 0;
2030                 fcp_cmnd->fcpCntl3 = 0;
2031                 phba->fc4ControlRequests++;
2032         }
2033         if (phba->sli_rev == 3 &&
2034             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED))
2035                 lpfc_fcpcmd_to_iocb(iocb_cmd->unsli3.fcp_ext.icd, fcp_cmnd);
2036         /*
2037          * Finish initializing those IOCB fields that are independent
2038          * of the scsi_cmnd request_buffer
2039          */
2040         piocbq->iocb.ulpContext = pnode->nlp_rpi;
2041         if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE)
2042                 piocbq->iocb.ulpFCP2Rcvy = 1;
2043         else
2044                 piocbq->iocb.ulpFCP2Rcvy = 0;
2045
2046         piocbq->iocb.ulpClass = (pnode->nlp_fcp_info & 0x0f);
2047         piocbq->context1  = lpfc_cmd;
2048         piocbq->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
2049         piocbq->iocb.ulpTimeout = lpfc_cmd->timeout;
2050         piocbq->vport = vport;
2051 }
2052
2053 /**
2054  * lpfc_scsi_prep_task_mgmt_cmnd - Convert scsi TM cmnd to FCP information unit
2055  * @vport: The virtual port for which this call is being executed.
2056  * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
2057  * @lun: Logical unit number.
2058  * @task_mgmt_cmd: SCSI task management command.
2059  *
2060  * This routine creates FCP information unit corresponding to @task_mgmt_cmd.
2061  *
2062  * Return codes:
2063  *   0 - Error
2064  *   1 - Success
2065  **/
2066 static int
2067 lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
2068                              struct lpfc_scsi_buf *lpfc_cmd,
2069                              unsigned int lun,
2070                              uint8_t task_mgmt_cmd)
2071 {
2072         struct lpfc_iocbq *piocbq;
2073         IOCB_t *piocb;
2074         struct fcp_cmnd *fcp_cmnd;
2075         struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
2076         struct lpfc_nodelist *ndlp = rdata->pnode;
2077
2078         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) ||
2079             ndlp->nlp_state != NLP_STE_MAPPED_NODE)
2080                 return 0;
2081
2082         piocbq = &(lpfc_cmd->cur_iocbq);
2083         piocbq->vport = vport;
2084
2085         piocb = &piocbq->iocb;
2086
2087         fcp_cmnd = lpfc_cmd->fcp_cmnd;
2088         /* Clear out any old data in the FCP command area */
2089         memset(fcp_cmnd, 0, sizeof(struct fcp_cmnd));
2090         int_to_scsilun(lun, &fcp_cmnd->fcp_lun);
2091         fcp_cmnd->fcpCntl2 = task_mgmt_cmd;
2092         if (vport->phba->sli_rev == 3 &&
2093             !(vport->phba->sli3_options & LPFC_SLI3_BG_ENABLED))
2094                 lpfc_fcpcmd_to_iocb(piocb->unsli3.fcp_ext.icd, fcp_cmnd);
2095         piocb->ulpCommand = CMD_FCP_ICMND64_CR;
2096         piocb->ulpContext = ndlp->nlp_rpi;
2097         if (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) {
2098                 piocb->ulpFCP2Rcvy = 1;
2099         }
2100         piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f);
2101
2102         /* ulpTimeout is only one byte */
2103         if (lpfc_cmd->timeout > 0xff) {
2104                 /*
2105                  * Do not timeout the command at the firmware level.
2106                  * The driver will provide the timeout mechanism.
2107                  */
2108                 piocb->ulpTimeout = 0;
2109         } else {
2110                 piocb->ulpTimeout = lpfc_cmd->timeout;
2111         }
2112
2113         return 1;
2114 }
2115
2116 /**
2117  * lpfc_taskmgmt_def_cmpl - IOCB completion routine for task management command
2118  * @phba: The Hba for which this call is being executed.
2119  * @cmdiocbq: Pointer to lpfc_iocbq data structure.
2120  * @rspiocbq: Pointer to lpfc_iocbq data structure.
2121  *
2122  * This routine is IOCB completion routine for device reset and target reset
2123  * routine. This routine release scsi buffer associated with lpfc_cmd.
2124  **/
2125 static void
2126 lpfc_tskmgmt_def_cmpl(struct lpfc_hba *phba,
2127                         struct lpfc_iocbq *cmdiocbq,
2128                         struct lpfc_iocbq *rspiocbq)
2129 {
2130         struct lpfc_scsi_buf *lpfc_cmd =
2131                 (struct lpfc_scsi_buf *) cmdiocbq->context1;
2132         if (lpfc_cmd)
2133                 lpfc_release_scsi_buf(phba, lpfc_cmd);
2134         return;
2135 }
2136
2137 /**
2138  * lpfc_scsi_tgt_reset - Target reset handler
2139  * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure
2140  * @vport: The virtual port for which this call is being executed.
2141  * @tgt_id: Target ID.
2142  * @lun: Lun number.
2143  * @rdata: Pointer to lpfc_rport_data.
2144  *
2145  * This routine issues a TARGET RESET iocb to reset a target with @tgt_id ID.
2146  *
2147  * Return Code:
2148  *   0x2003 - Error
2149  *   0x2002 - Success.
2150  **/
2151 static int
2152 lpfc_scsi_tgt_reset(struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_vport *vport,
2153                     unsigned  tgt_id, unsigned int lun,
2154                     struct lpfc_rport_data *rdata)
2155 {
2156         struct lpfc_hba   *phba = vport->phba;
2157         struct lpfc_iocbq *iocbq;
2158         struct lpfc_iocbq *iocbqrsp;
2159         int ret;
2160         int status;
2161
2162         if (!rdata->pnode || !NLP_CHK_NODE_ACT(rdata->pnode))
2163                 return FAILED;
2164
2165         lpfc_cmd->rdata = rdata;
2166         status = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun,
2167                                            FCP_TARGET_RESET);
2168         if (!status)
2169                 return FAILED;
2170
2171         iocbq = &lpfc_cmd->cur_iocbq;
2172         iocbqrsp = lpfc_sli_get_iocbq(phba);
2173
2174         if (!iocbqrsp)
2175                 return FAILED;
2176
2177         /* Issue Target Reset to TGT <num> */
2178         lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
2179                          "0702 Issue Target Reset to TGT %d Data: x%x x%x\n",
2180                          tgt_id, rdata->pnode->nlp_rpi, rdata->pnode->nlp_flag);
2181         status = lpfc_sli_issue_iocb_wait(phba,
2182                                        &phba->sli.ring[phba->sli.fcp_ring],
2183                                        iocbq, iocbqrsp, lpfc_cmd->timeout);
2184         if (status != IOCB_SUCCESS) {
2185                 if (status == IOCB_TIMEDOUT) {
2186                         iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
2187                         ret = TIMEOUT_ERROR;
2188                 } else
2189                         ret = FAILED;
2190                 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
2191         } else {
2192                 ret = SUCCESS;
2193                 lpfc_cmd->result = iocbqrsp->iocb.un.ulpWord[4];
2194                 lpfc_cmd->status = iocbqrsp->iocb.ulpStatus;
2195                 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
2196                         (lpfc_cmd->result & IOERR_DRVR_MASK))
2197                                 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
2198         }
2199
2200         lpfc_sli_release_iocbq(phba, iocbqrsp);
2201         return ret;
2202 }
2203
2204 /**
2205  * lpfc_info - Info entry point of scsi_host_template data structure
2206  * @host: The scsi host for which this call is being executed.
2207  *
2208  * This routine provides module information about hba.
2209  *
2210  * Reutrn code:
2211  *   Pointer to char - Success.
2212  **/
2213 const char *
2214 lpfc_info(struct Scsi_Host *host)
2215 {
2216         struct lpfc_vport *vport = (struct lpfc_vport *) host->hostdata;
2217         struct lpfc_hba   *phba = vport->phba;
2218         int len;
2219         static char  lpfcinfobuf[384];
2220
2221         memset(lpfcinfobuf,0,384);
2222         if (phba && phba->pcidev){
2223                 strncpy(lpfcinfobuf, phba->ModelDesc, 256);
2224                 len = strlen(lpfcinfobuf);
2225                 snprintf(lpfcinfobuf + len,
2226                         384-len,
2227                         " on PCI bus %02x device %02x irq %d",
2228                         phba->pcidev->bus->number,
2229                         phba->pcidev->devfn,
2230                         phba->pcidev->irq);
2231                 len = strlen(lpfcinfobuf);
2232                 if (phba->Port[0]) {
2233                         snprintf(lpfcinfobuf + len,
2234                                  384-len,
2235                                  " port %s",
2236                                  phba->Port);
2237                 }
2238         }
2239         return lpfcinfobuf;
2240 }
2241
2242 /**
2243  * lpfc_poll_rearm_time - Routine to modify fcp_poll timer of hba
2244  * @phba: The Hba for which this call is being executed.
2245  *
2246  * This routine modifies fcp_poll_timer  field of @phba by cfg_poll_tmo.
2247  * The default value of cfg_poll_tmo is 10 milliseconds.
2248  **/
2249 static __inline__ void lpfc_poll_rearm_timer(struct lpfc_hba * phba)
2250 {
2251         unsigned long  poll_tmo_expires =
2252                 (jiffies + msecs_to_jiffies(phba->cfg_poll_tmo));
2253
2254         if (phba->sli.ring[LPFC_FCP_RING].txcmplq_cnt)
2255                 mod_timer(&phba->fcp_poll_timer,
2256                           poll_tmo_expires);
2257 }
2258
2259 /**
2260  * lpfc_poll_start_timer - Routine to start fcp_poll_timer of HBA
2261  * @phba: The Hba for which this call is being executed.
2262  *
2263  * This routine starts the fcp_poll_timer of @phba.
2264  **/
2265 void lpfc_poll_start_timer(struct lpfc_hba * phba)
2266 {
2267         lpfc_poll_rearm_timer(phba);
2268 }
2269
2270 /**
2271  * lpfc_poll_timeout - Restart polling timer
2272  * @ptr: Map to lpfc_hba data structure pointer.
2273  *
2274  * This routine restarts fcp_poll timer, when FCP ring  polling is enable
2275  * and FCP Ring interrupt is disable.
2276  **/
2277
2278 void lpfc_poll_timeout(unsigned long ptr)
2279 {
2280         struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
2281
2282         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
2283                 lpfc_sli_poll_fcp_ring (phba);
2284                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
2285                         lpfc_poll_rearm_timer(phba);
2286         }
2287 }
2288
2289 /**
2290  * lpfc_queuecommand - scsi_host_template queuecommand entry point
2291  * @cmnd: Pointer to scsi_cmnd data structure.
2292  * @done: Pointer to done routine.
2293  *
2294  * Driver registers this routine to scsi midlayer to submit a @cmd to process.
2295  * This routine prepares an IOCB from scsi command and provides to firmware.
2296  * The @done callback is invoked after driver finished processing the command.
2297  *
2298  * Return value :
2299  *   0 - Success
2300  *   SCSI_MLQUEUE_HOST_BUSY - Block all devices served by this host temporarily.
2301  **/
2302 static int
2303 lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
2304 {
2305         struct Scsi_Host  *shost = cmnd->device->host;
2306         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2307         struct lpfc_hba   *phba = vport->phba;
2308         struct lpfc_sli   *psli = &phba->sli;
2309         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
2310         struct lpfc_nodelist *ndlp = rdata->pnode;
2311         struct lpfc_scsi_buf *lpfc_cmd;
2312         struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
2313         int err;
2314
2315         err = fc_remote_port_chkready(rport);
2316         if (err) {
2317                 cmnd->result = err;
2318                 goto out_fail_command;
2319         }
2320
2321         if (!(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
2322                 scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
2323
2324                 printk(KERN_ERR "BLKGRD ERROR: rcvd protected cmd:%02x op:%02x "
2325                                 "str=%s without registering for BlockGuard - "
2326                                 "Rejecting command\n",
2327                                 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
2328                                 dif_op_str[scsi_get_prot_op(cmnd)]);
2329                 goto out_fail_command;
2330         }
2331
2332         /*
2333          * Catch race where our node has transitioned, but the
2334          * transport is still transitioning.
2335          */
2336         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
2337                 cmnd->result = ScsiResult(DID_TRANSPORT_DISRUPTED, 0);
2338                 goto out_fail_command;
2339         }
2340         if (vport->cfg_max_scsicmpl_time &&
2341                 (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth))
2342                 goto out_host_busy;
2343
2344         lpfc_cmd = lpfc_get_scsi_buf(phba);
2345         if (lpfc_cmd == NULL) {
2346                 lpfc_rampdown_queue_depth(phba);
2347
2348                 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
2349                                  "0707 driver's buffer pool is empty, "
2350                                  "IO busied\n");
2351                 goto out_host_busy;
2352         }
2353
2354         /*
2355          * Store the midlayer's command structure for the completion phase
2356          * and complete the command initialization.
2357          */
2358         lpfc_cmd->pCmd  = cmnd;
2359         lpfc_cmd->rdata = rdata;
2360         lpfc_cmd->timeout = 0;
2361         lpfc_cmd->start_time = jiffies;
2362         cmnd->host_scribble = (unsigned char *)lpfc_cmd;
2363         cmnd->scsi_done = done;
2364
2365         if (scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
2366                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2367                                 "9033 BLKGRD: rcvd protected cmd:%02x op:%02x "
2368                                 "str=%s\n",
2369                                 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
2370                                 dif_op_str[scsi_get_prot_op(cmnd)]);
2371                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2372                                 "9034 BLKGRD: CDB: %02x %02x %02x %02x %02x "
2373                                 "%02x %02x %02x %02x %02x \n",
2374                                 cmnd->cmnd[0], cmnd->cmnd[1], cmnd->cmnd[2],
2375                                 cmnd->cmnd[3], cmnd->cmnd[4], cmnd->cmnd[5],
2376                                 cmnd->cmnd[6], cmnd->cmnd[7], cmnd->cmnd[8],
2377                                 cmnd->cmnd[9]);
2378                 if (cmnd->cmnd[0] == READ_10)
2379                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2380                                         "9035 BLKGRD: READ @ sector %llu, "
2381                                          "count %lu\n",
2382                                          (unsigned long long)scsi_get_lba(cmnd),
2383                                         cmnd->request->nr_sectors);
2384                 else if (cmnd->cmnd[0] == WRITE_10)
2385                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2386                                         "9036 BLKGRD: WRITE @ sector %llu, "
2387                                         "count %lu cmd=%p\n",
2388                                         (unsigned long long)scsi_get_lba(cmnd),
2389                                         cmnd->request->nr_sectors,
2390                                         cmnd);
2391
2392                 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
2393         } else {
2394                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2395                                 "9038 BLKGRD: rcvd unprotected cmd:%02x op:%02x"
2396                                 " str=%s\n",
2397                                 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
2398                                 dif_op_str[scsi_get_prot_op(cmnd)]);
2399                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2400                                  "9039 BLKGRD: CDB: %02x %02x %02x %02x %02x "
2401                                  "%02x %02x %02x %02x %02x \n",
2402                                  cmnd->cmnd[0], cmnd->cmnd[1], cmnd->cmnd[2],
2403                                  cmnd->cmnd[3], cmnd->cmnd[4], cmnd->cmnd[5],
2404                                  cmnd->cmnd[6], cmnd->cmnd[7], cmnd->cmnd[8],
2405                                  cmnd->cmnd[9]);
2406                 if (cmnd->cmnd[0] == READ_10)
2407                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2408                                          "9040 dbg: READ @ sector %llu, "
2409                                          "count %lu\n",
2410                                          (unsigned long long)scsi_get_lba(cmnd),
2411                                          cmnd->request->nr_sectors);
2412                 else if (cmnd->cmnd[0] == WRITE_10)
2413                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2414                                          "9041 dbg: WRITE @ sector %llu, "
2415                                          "count %lu cmd=%p\n",
2416                                          (unsigned long long)scsi_get_lba(cmnd),
2417                                          cmnd->request->nr_sectors, cmnd);
2418                 else
2419                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
2420                                          "9042 dbg: parser not implemented\n");
2421                 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
2422         }
2423
2424         if (err)
2425                 goto out_host_busy_free_buf;
2426
2427         lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp);
2428
2429         atomic_inc(&ndlp->cmd_pending);
2430         err = lpfc_sli_issue_iocb(phba, &phba->sli.ring[psli->fcp_ring],
2431                                   &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
2432         if (err) {
2433                 atomic_dec(&ndlp->cmd_pending);
2434                 goto out_host_busy_free_buf;
2435         }
2436         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
2437                 lpfc_sli_poll_fcp_ring(phba);
2438                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
2439                         lpfc_poll_rearm_timer(phba);
2440         }
2441
2442         return 0;
2443
2444  out_host_busy_free_buf:
2445         lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
2446         lpfc_release_scsi_buf(phba, lpfc_cmd);
2447  out_host_busy:
2448         return SCSI_MLQUEUE_HOST_BUSY;
2449
2450  out_fail_command:
2451         done(cmnd);
2452         return 0;
2453 }
2454
2455 /**
2456  * lpfc_block_error_handler - Routine to block error  handler
2457  * @cmnd: Pointer to scsi_cmnd data structure.
2458  *
2459  *  This routine blocks execution till fc_rport state is not FC_PORSTAT_BLCOEKD.
2460  **/
2461 static void
2462 lpfc_block_error_handler(struct scsi_cmnd *cmnd)
2463 {
2464         struct Scsi_Host *shost = cmnd->device->host;
2465         struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
2466
2467         spin_lock_irq(shost->host_lock);
2468         while (rport->port_state == FC_PORTSTATE_BLOCKED) {
2469                 spin_unlock_irq(shost->host_lock);
2470                 msleep(1000);
2471                 spin_lock_irq(shost->host_lock);
2472         }
2473         spin_unlock_irq(shost->host_lock);
2474         return;
2475 }
2476
2477 /**
2478  * lpfc_abort_handler - scsi_host_template eh_abort_handler entry point
2479  * @cmnd: Pointer to scsi_cmnd data structure.
2480  *
2481  * This routine aborts @cmnd pending in base driver.
2482  *
2483  * Return code :
2484  *   0x2003 - Error
2485  *   0x2002 - Success
2486  **/
2487 static int
2488 lpfc_abort_handler(struct scsi_cmnd *cmnd)
2489 {
2490         struct Scsi_Host  *shost = cmnd->device->host;
2491         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2492         struct lpfc_hba   *phba = vport->phba;
2493         struct lpfc_sli_ring *pring = &phba->sli.ring[phba->sli.fcp_ring];
2494         struct lpfc_iocbq *iocb;
2495         struct lpfc_iocbq *abtsiocb;
2496         struct lpfc_scsi_buf *lpfc_cmd;
2497         IOCB_t *cmd, *icmd;
2498         int ret = SUCCESS;
2499         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq);
2500
2501         lpfc_block_error_handler(cmnd);
2502         lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble;
2503         BUG_ON(!lpfc_cmd);
2504
2505         /*
2506          * If pCmd field of the corresponding lpfc_scsi_buf structure
2507          * points to a different SCSI command, then the driver has
2508          * already completed this command, but the midlayer did not
2509          * see the completion before the eh fired.  Just return
2510          * SUCCESS.
2511          */
2512         iocb = &lpfc_cmd->cur_iocbq;
2513         if (lpfc_cmd->pCmd != cmnd)
2514                 goto out;
2515
2516         BUG_ON(iocb->context1 != lpfc_cmd);
2517
2518         abtsiocb = lpfc_sli_get_iocbq(phba);
2519         if (abtsiocb == NULL) {
2520                 ret = FAILED;
2521                 goto out;
2522         }
2523
2524         /*
2525          * The scsi command can not be in txq and it is in flight because the
2526          * pCmd is still pointig at the SCSI command we have to abort. There
2527          * is no need to search the txcmplq. Just send an abort to the FW.
2528          */
2529
2530         cmd = &iocb->iocb;
2531         icmd = &abtsiocb->iocb;
2532         icmd->un.acxri.abortType = ABORT_TYPE_ABTS;
2533         icmd->un.acxri.abortContextTag = cmd->ulpContext;
2534         icmd->un.acxri.abortIoTag = cmd->ulpIoTag;
2535
2536         icmd->ulpLe = 1;
2537         icmd->ulpClass = cmd->ulpClass;
2538         if (lpfc_is_link_up(phba))
2539                 icmd->ulpCommand = CMD_ABORT_XRI_CN;
2540         else
2541                 icmd->ulpCommand = CMD_CLOSE_XRI_CN;
2542
2543         abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
2544         abtsiocb->vport = vport;
2545         if (lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0) == IOCB_ERROR) {
2546                 lpfc_sli_release_iocbq(phba, abtsiocb);
2547                 ret = FAILED;
2548                 goto out;
2549         }
2550
2551         if (phba->cfg_poll & DISABLE_FCP_RING_INT)
2552                 lpfc_sli_poll_fcp_ring (phba);
2553
2554         lpfc_cmd->waitq = &waitq;
2555         /* Wait for abort to complete */
2556         wait_event_timeout(waitq,
2557                           (lpfc_cmd->pCmd != cmnd),
2558                            (2*vport->cfg_devloss_tmo*HZ));
2559
2560         spin_lock_irq(shost->host_lock);
2561         lpfc_cmd->waitq = NULL;
2562         spin_unlock_irq(shost->host_lock);
2563
2564         if (lpfc_cmd->pCmd == cmnd) {
2565                 ret = FAILED;
2566                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2567                                  "0748 abort handler timed out waiting "
2568                                  "for abort to complete: ret %#x, ID %d, "
2569                                  "LUN %d, snum %#lx\n",
2570                                  ret, cmnd->device->id, cmnd->device->lun,
2571                                  cmnd->serial_number);
2572         }
2573
2574  out:
2575         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
2576                          "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
2577                          "LUN %d snum %#lx\n", ret, cmnd->device->id,
2578                          cmnd->device->lun, cmnd->serial_number);
2579         return ret;
2580 }
2581
2582 /**
2583  * lpfc_device_reset_handler - scsi_host_template eh_device_reset entry point
2584  * @cmnd: Pointer to scsi_cmnd data structure.
2585  *
2586  * This routine does a device reset by sending a TARGET_RESET task management
2587  * command.
2588  *
2589  * Return code :
2590  *  0x2003 - Error
2591  *  0x2002 - Success
2592  **/
2593 static int
2594 lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
2595 {
2596         struct Scsi_Host  *shost = cmnd->device->host;
2597         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2598         struct lpfc_hba   *phba = vport->phba;
2599         struct lpfc_scsi_buf *lpfc_cmd;
2600         struct lpfc_iocbq *iocbq, *iocbqrsp;
2601         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
2602         struct lpfc_nodelist *pnode = rdata->pnode;
2603         unsigned long later;
2604         int ret = SUCCESS;
2605         int status;
2606         int cnt;
2607         struct lpfc_scsi_event_header scsi_event;
2608
2609         lpfc_block_error_handler(cmnd);
2610         /*
2611          * If target is not in a MAPPED state, delay the reset until
2612          * target is rediscovered or devloss timeout expires.
2613          */
2614         later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
2615         while (time_after(later, jiffies)) {
2616                 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
2617                         return FAILED;
2618                 if (pnode->nlp_state == NLP_STE_MAPPED_NODE)
2619                         break;
2620                 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
2621                 rdata = cmnd->device->hostdata;
2622                 if (!rdata)
2623                         break;
2624                 pnode = rdata->pnode;
2625         }
2626
2627         scsi_event.event_type = FC_REG_SCSI_EVENT;
2628         scsi_event.subcategory = LPFC_EVENT_TGTRESET;
2629         scsi_event.lun = 0;
2630         memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name));
2631         memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name));
2632
2633         fc_host_post_vendor_event(shost,
2634                 fc_get_event_number(),
2635                 sizeof(scsi_event),
2636                 (char *)&scsi_event,
2637                 LPFC_NL_VENDOR_ID);
2638
2639         if (!rdata || pnode->nlp_state != NLP_STE_MAPPED_NODE) {
2640                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2641                                  "0721 LUN Reset rport "
2642                                  "failure: msec x%x rdata x%p\n",
2643                                  jiffies_to_msecs(jiffies - later), rdata);
2644                 return FAILED;
2645         }
2646         lpfc_cmd = lpfc_get_scsi_buf(phba);
2647         if (lpfc_cmd == NULL)
2648                 return FAILED;
2649         lpfc_cmd->timeout = 60;
2650         lpfc_cmd->rdata = rdata;
2651
2652         status = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd,
2653                                               cmnd->device->lun,
2654                                               FCP_TARGET_RESET);
2655         if (!status) {
2656                 lpfc_release_scsi_buf(phba, lpfc_cmd);
2657                 return FAILED;
2658         }
2659         iocbq = &lpfc_cmd->cur_iocbq;
2660
2661         /* get a buffer for this IOCB command response */
2662         iocbqrsp = lpfc_sli_get_iocbq(phba);
2663         if (iocbqrsp == NULL) {
2664                 lpfc_release_scsi_buf(phba, lpfc_cmd);
2665                 return FAILED;
2666         }
2667         lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
2668                          "0703 Issue target reset to TGT %d LUN %d "
2669                          "rpi x%x nlp_flag x%x\n", cmnd->device->id,
2670                          cmnd->device->lun, pnode->nlp_rpi, pnode->nlp_flag);
2671         status = lpfc_sli_issue_iocb_wait(phba,
2672                                           &phba->sli.ring[phba->sli.fcp_ring],
2673                                           iocbq, iocbqrsp, lpfc_cmd->timeout);
2674         if (status == IOCB_TIMEDOUT) {
2675                 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
2676                 ret = TIMEOUT_ERROR;
2677         } else {
2678                 if (status != IOCB_SUCCESS)
2679                         ret = FAILED;
2680                 lpfc_release_scsi_buf(phba, lpfc_cmd);
2681         }
2682         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2683                          "0713 SCSI layer issued device reset (%d, %d) "
2684                          "return x%x status x%x result x%x\n",
2685                          cmnd->device->id, cmnd->device->lun, ret,
2686                          iocbqrsp->iocb.ulpStatus,
2687                          iocbqrsp->iocb.un.ulpWord[4]);
2688         lpfc_sli_release_iocbq(phba, iocbqrsp);
2689         cnt = lpfc_sli_sum_iocb(vport, cmnd->device->id, cmnd->device->lun,
2690                                 LPFC_CTX_TGT);
2691         if (cnt)
2692                 lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring],
2693                                     cmnd->device->id, cmnd->device->lun,
2694                                     LPFC_CTX_TGT);
2695         later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
2696         while (time_after(later, jiffies) && cnt) {
2697                 schedule_timeout_uninterruptible(msecs_to_jiffies(20));
2698                 cnt = lpfc_sli_sum_iocb(vport, cmnd->device->id,
2699                                         cmnd->device->lun, LPFC_CTX_TGT);
2700         }
2701         if (cnt) {
2702                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2703                                  "0719 device reset I/O flush failure: "
2704                                  "cnt x%x\n", cnt);
2705                 ret = FAILED;
2706         }
2707         return ret;
2708 }
2709
2710 /**
2711  * lpfc_bus_reset_handler - scsi_host_template eh_bus_reset_handler entry point
2712  * @cmnd: Pointer to scsi_cmnd data structure.
2713  *
2714  * This routine does target reset to all target on @cmnd->device->host.
2715  *
2716  * Return Code:
2717  *   0x2003 - Error
2718  *   0x2002 - Success
2719  **/
2720 static int
2721 lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
2722 {
2723         struct Scsi_Host  *shost = cmnd->device->host;
2724         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2725         struct lpfc_hba   *phba = vport->phba;
2726         struct lpfc_nodelist *ndlp = NULL;
2727         int match;
2728         int ret = SUCCESS, status = SUCCESS, i;
2729         int cnt;
2730         struct lpfc_scsi_buf * lpfc_cmd;
2731         unsigned long later;
2732         struct lpfc_scsi_event_header scsi_event;
2733
2734         scsi_event.event_type = FC_REG_SCSI_EVENT;
2735         scsi_event.subcategory = LPFC_EVENT_BUSRESET;
2736         scsi_event.lun = 0;
2737         memcpy(scsi_event.wwpn, &vport->fc_portname, sizeof(struct lpfc_name));
2738         memcpy(scsi_event.wwnn, &vport->fc_nodename, sizeof(struct lpfc_name));
2739
2740         fc_host_post_vendor_event(shost,
2741                 fc_get_event_number(),
2742                 sizeof(scsi_event),
2743                 (char *)&scsi_event,
2744                 LPFC_NL_VENDOR_ID);
2745
2746         lpfc_block_error_handler(cmnd);
2747         /*
2748          * Since the driver manages a single bus device, reset all
2749          * targets known to the driver.  Should any target reset
2750          * fail, this routine returns failure to the midlayer.
2751          */
2752         for (i = 0; i < LPFC_MAX_TARGET; i++) {
2753                 /* Search for mapped node by target ID */
2754                 match = 0;
2755                 spin_lock_irq(shost->host_lock);
2756                 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2757                         if (!NLP_CHK_NODE_ACT(ndlp))
2758                                 continue;
2759                         if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
2760                             ndlp->nlp_sid == i &&
2761                             ndlp->rport) {
2762                                 match = 1;
2763                                 break;
2764                         }
2765                 }
2766                 spin_unlock_irq(shost->host_lock);
2767                 if (!match)
2768                         continue;
2769                 lpfc_cmd = lpfc_get_scsi_buf(phba);
2770                 if (lpfc_cmd) {
2771                         lpfc_cmd->timeout = 60;
2772                         status = lpfc_scsi_tgt_reset(lpfc_cmd, vport, i,
2773                                                      cmnd->device->lun,
2774                                                      ndlp->rport->dd_data);
2775                         if (status != TIMEOUT_ERROR)
2776                                 lpfc_release_scsi_buf(phba, lpfc_cmd);
2777                 }
2778                 if (!lpfc_cmd || status != SUCCESS) {
2779                         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2780                                          "0700 Bus Reset on target %d failed\n",
2781                                          i);
2782                         ret = FAILED;
2783                 }
2784         }
2785         /*
2786          * All outstanding txcmplq I/Os should have been aborted by
2787          * the targets.  Unfortunately, some targets do not abide by
2788          * this forcing the driver to double check.
2789          */
2790         cnt = lpfc_sli_sum_iocb(vport, 0, 0, LPFC_CTX_HOST);
2791         if (cnt)
2792                 lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring],
2793                                     0, 0, LPFC_CTX_HOST);
2794         later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
2795         while (time_after(later, jiffies) && cnt) {
2796                 schedule_timeout_uninterruptible(msecs_to_jiffies(20));
2797                 cnt = lpfc_sli_sum_iocb(vport, 0, 0, LPFC_CTX_HOST);
2798         }
2799         if (cnt) {
2800                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2801                                  "0715 Bus Reset I/O flush failure: "
2802                                  "cnt x%x left x%x\n", cnt, i);
2803                 ret = FAILED;
2804         }
2805         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2806                          "0714 SCSI layer issued Bus Reset Data: x%x\n", ret);
2807         return ret;
2808 }
2809
2810 /**
2811  * lpfc_slave_alloc - scsi_host_template slave_alloc entry point
2812  * @sdev: Pointer to scsi_device.
2813  *
2814  * This routine populates the cmds_per_lun count + 2 scsi_bufs into  this host's
2815  * globally available list of scsi buffers. This routine also makes sure scsi
2816  * buffer is not allocated more than HBA limit conveyed to midlayer. This list
2817  * of scsi buffer exists for the lifetime of the driver.
2818  *
2819  * Return codes:
2820  *   non-0 - Error
2821  *   0 - Success
2822  **/
2823 static int
2824 lpfc_slave_alloc(struct scsi_device *sdev)
2825 {
2826         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
2827         struct lpfc_hba   *phba = vport->phba;
2828         struct lpfc_scsi_buf *scsi_buf = NULL;
2829         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2830         uint32_t total = 0, i;
2831         uint32_t num_to_alloc = 0;
2832         unsigned long flags;
2833
2834         if (!rport || fc_remote_port_chkready(rport))
2835                 return -ENXIO;
2836
2837         sdev->hostdata = rport->dd_data;
2838
2839         /*
2840          * Populate the cmds_per_lun count scsi_bufs into this host's globally
2841          * available list of scsi buffers.  Don't allocate more than the
2842          * HBA limit conveyed to the midlayer via the host structure.  The
2843          * formula accounts for the lun_queue_depth + error handlers + 1
2844          * extra.  This list of scsi bufs exists for the lifetime of the driver.
2845          */
2846         total = phba->total_scsi_bufs;
2847         num_to_alloc = vport->cfg_lun_queue_depth + 2;
2848
2849         /* Allow some exchanges to be available always to complete discovery */
2850         if (total >= phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
2851                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
2852                                  "0704 At limitation of %d preallocated "
2853                                  "command buffers\n", total);
2854                 return 0;
2855         /* Allow some exchanges to be available always to complete discovery */
2856         } else if (total + num_to_alloc >
2857                 phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
2858                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
2859                                  "0705 Allocation request of %d "
2860                                  "command buffers will exceed max of %d.  "
2861                                  "Reducing allocation request to %d.\n",
2862                                  num_to_alloc, phba->cfg_hba_queue_depth,
2863                                  (phba->cfg_hba_queue_depth - total));
2864                 num_to_alloc = phba->cfg_hba_queue_depth - total;
2865         }
2866
2867         for (i = 0; i < num_to_alloc; i++) {
2868                 scsi_buf = lpfc_new_scsi_buf(vport);
2869                 if (!scsi_buf) {
2870                         lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
2871                                          "0706 Failed to allocate "
2872                                          "command buffer\n");
2873                         break;
2874                 }
2875
2876                 spin_lock_irqsave(&phba->scsi_buf_list_lock, flags);
2877                 phba->total_scsi_bufs++;
2878                 list_add_tail(&scsi_buf->list, &phba->lpfc_scsi_buf_list);
2879                 spin_unlock_irqrestore(&phba->scsi_buf_list_lock, flags);
2880         }
2881         return 0;
2882 }
2883
2884 /**
2885  * lpfc_slave_configure - scsi_host_template slave_configure entry point
2886  * @sdev: Pointer to scsi_device.
2887  *
2888  * This routine configures following items
2889  *   - Tag command queuing support for @sdev if supported.
2890  *   - Dev loss time out value of fc_rport.
2891  *   - Enable SLI polling for fcp ring if ENABLE_FCP_RING_POLLING flag is set.
2892  *
2893  * Return codes:
2894  *   0 - Success
2895  **/
2896 static int
2897 lpfc_slave_configure(struct scsi_device *sdev)
2898 {
2899         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
2900         struct lpfc_hba   *phba = vport->phba;
2901         struct fc_rport   *rport = starget_to_rport(sdev->sdev_target);
2902
2903         if (sdev->tagged_supported)
2904                 scsi_activate_tcq(sdev, vport->cfg_lun_queue_depth);
2905         else
2906                 scsi_deactivate_tcq(sdev, vport->cfg_lun_queue_depth);
2907
2908         /*
2909          * Initialize the fc transport attributes for the target
2910          * containing this scsi device.  Also note that the driver's
2911          * target pointer is stored in the starget_data for the
2912          * driver's sysfs entry point functions.
2913          */
2914         rport->dev_loss_tmo = vport->cfg_devloss_tmo;
2915
2916         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
2917                 lpfc_sli_poll_fcp_ring(phba);
2918                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
2919                         lpfc_poll_rearm_timer(phba);
2920         }
2921
2922         return 0;
2923 }
2924
2925 /**
2926  * lpfc_slave_destroy - slave_destroy entry point of SHT data structure
2927  * @sdev: Pointer to scsi_device.
2928  *
2929  * This routine sets @sdev hostatdata filed to null.
2930  **/
2931 static void
2932 lpfc_slave_destroy(struct scsi_device *sdev)
2933 {
2934         sdev->hostdata = NULL;
2935         return;
2936 }
2937
2938
2939 struct scsi_host_template lpfc_template = {
2940         .module                 = THIS_MODULE,
2941         .name                   = LPFC_DRIVER_NAME,
2942         .info                   = lpfc_info,
2943         .queuecommand           = lpfc_queuecommand,
2944         .eh_abort_handler       = lpfc_abort_handler,
2945         .eh_device_reset_handler= lpfc_device_reset_handler,
2946         .eh_bus_reset_handler   = lpfc_bus_reset_handler,
2947         .slave_alloc            = lpfc_slave_alloc,
2948         .slave_configure        = lpfc_slave_configure,
2949         .slave_destroy          = lpfc_slave_destroy,
2950         .scan_finished          = lpfc_scan_finished,
2951         .this_id                = -1,
2952         .sg_tablesize           = LPFC_DEFAULT_SG_SEG_CNT,
2953         .cmd_per_lun            = LPFC_CMD_PER_LUN,
2954         .use_clustering         = ENABLE_CLUSTERING,
2955         .shost_attrs            = lpfc_hba_attrs,
2956         .max_sectors            = 0xFFFF,
2957 };
2958
2959 struct scsi_host_template lpfc_vport_template = {
2960         .module                 = THIS_MODULE,
2961         .name                   = LPFC_DRIVER_NAME,
2962         .info                   = lpfc_info,
2963         .queuecommand           = lpfc_queuecommand,
2964         .eh_abort_handler       = lpfc_abort_handler,
2965         .eh_device_reset_handler= lpfc_device_reset_handler,
2966         .eh_bus_reset_handler   = lpfc_bus_reset_handler,
2967         .slave_alloc            = lpfc_slave_alloc,
2968         .slave_configure        = lpfc_slave_configure,
2969         .slave_destroy          = lpfc_slave_destroy,
2970         .scan_finished          = lpfc_scan_finished,
2971         .this_id                = -1,
2972         .sg_tablesize           = LPFC_DEFAULT_SG_SEG_CNT,
2973         .cmd_per_lun            = LPFC_CMD_PER_LUN,
2974         .use_clustering         = ENABLE_CLUSTERING,
2975         .shost_attrs            = lpfc_vport_attrs,
2976         .max_sectors            = 0xFFFF,
2977 };