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