drivers/scsi/lpfc/lpfc_bsg.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2009-2014 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  *                                                                 *
   8  * This program is free software; you can redistribute it and/or   *
   9  * modify it under the terms of version 2 of the GNU General       *
  10  * Public License as published by the Free Software Foundation.    *
  11  * This program is distributed in the hope that it will be useful. *
  12  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  13  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  14  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  15  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  16  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  17  * more details, a copy of which can be found in the file COPYING  *
  18  * included with this package.                                     *
  19  *******************************************************************/
  20
  21 #include <linux/interrupt.h>
  22 #include <linux/mempool.h>
  23 #include <linux/pci.h>
  24 #include <linux/slab.h>
  25 #include <linux/delay.h>
  26 #include <linux/list.h>
  27
  28 #include <scsi/scsi.h>
  29 #include <scsi/scsi_host.h>
  30 #include <scsi/scsi_transport_fc.h>
  31 #include <scsi/scsi_bsg_fc.h>
  32 #include <scsi/fc/fc_fs.h>
  33
  34 #include "lpfc_hw4.h"
  35 #include "lpfc_hw.h"
  36 #include "lpfc_sli.h"
  37 #include "lpfc_sli4.h"
  38 #include "lpfc_nl.h"
  39 #include "lpfc_bsg.h"
  40 #include "lpfc_disc.h"
  41 #include "lpfc_scsi.h"
  42 #include "lpfc.h"
  43 #include "lpfc_logmsg.h"
  44 #include "lpfc_crtn.h"
  45 #include "lpfc_debugfs.h"
  46 #include "lpfc_vport.h"
  47 #include "lpfc_version.h"
  48
  49 struct lpfc_bsg_event {
  50         struct list_head node;
  51         struct kref kref;
  52         wait_queue_head_t wq;
  53
  54         /* Event type and waiter identifiers */
  55         uint32_t type_mask;
  56         uint32_t req_id;
  57         uint32_t reg_id;
  58
  59         /* next two flags are here for the auto-delete logic */
  60         unsigned long wait_time_stamp;
  61         int waiting;
  62
  63         /* seen and not seen events */
  64         struct list_head events_to_get;
  65         struct list_head events_to_see;
  66
  67         /* driver data associated with the job */
  68         void *dd_data;
  69 };
  70
  71 struct lpfc_bsg_iocb {
  72         struct lpfc_iocbq *cmdiocbq;
  73         struct lpfc_dmabuf *rmp;
  74         struct lpfc_nodelist *ndlp;
  75 };
  76
  77 struct lpfc_bsg_mbox {
  78         LPFC_MBOXQ_t *pmboxq;
  79         MAILBOX_t *mb;
  80         struct lpfc_dmabuf *dmabuffers; /* for BIU diags */
  81         uint8_t *ext; /* extended mailbox data */
  82         uint32_t mbOffset; /* from app */
  83         uint32_t inExtWLen; /* from app */
  84         uint32_t outExtWLen; /* from app */
  85 };
  86
  87 #define MENLO_DID 0x0000FC0E
  88
  89 struct lpfc_bsg_menlo {
  90         struct lpfc_iocbq *cmdiocbq;
  91         struct lpfc_dmabuf *rmp;
  92 };
  93
  94 #define TYPE_EVT        1
  95 #define TYPE_IOCB       2
  96 #define TYPE_MBOX       3
  97 #define TYPE_MENLO      4
  98 struct bsg_job_data {
  99         uint32_t type;
 100         struct fc_bsg_job *set_job; /* job waiting for this iocb to finish */
 101         union {
 102                 struct lpfc_bsg_event *evt;
 103                 struct lpfc_bsg_iocb iocb;
 104                 struct lpfc_bsg_mbox mbox;
 105                 struct lpfc_bsg_menlo menlo;
 106         } context_un;
 107 };
 108
 109 struct event_data {
 110         struct list_head node;
 111         uint32_t type;
 112         uint32_t immed_dat;
 113         void *data;
 114         uint32_t len;
 115 };
 116
 117 #define BUF_SZ_4K 4096
 118 #define SLI_CT_ELX_LOOPBACK 0x10
 119
 120 enum ELX_LOOPBACK_CMD {
 121         ELX_LOOPBACK_XRI_SETUP,
 122         ELX_LOOPBACK_DATA,
 123 };
 124
 125 #define ELX_LOOPBACK_HEADER_SZ \
 126         (size_t)(&((struct lpfc_sli_ct_request *)NULL)->un)
 127
 128 struct lpfc_dmabufext {
 129         struct lpfc_dmabuf dma;
 130         uint32_t size;
 131         uint32_t flag;
 132 };
 133
 134 static void
 135 lpfc_free_bsg_buffers(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist)
 136 {
 137         struct lpfc_dmabuf *mlast, *next_mlast;
 138
 139         if (mlist) {
 140                 list_for_each_entry_safe(mlast, next_mlast, &mlist->list,
 141                                          list) {
 142                         lpfc_mbuf_free(phba, mlast->virt, mlast->phys);
 143                         list_del(&mlast->list);
 144                         kfree(mlast);
 145                 }
 146                 lpfc_mbuf_free(phba, mlist->virt, mlist->phys);
 147                 kfree(mlist);
 148         }
 149         return;
 150 }
 151
 152 static struct lpfc_dmabuf *
 153 lpfc_alloc_bsg_buffers(struct lpfc_hba *phba, unsigned int size,
 154                        int outbound_buffers, struct ulp_bde64 *bpl,
 155                        int *bpl_entries)
 156 {
 157         struct lpfc_dmabuf *mlist = NULL;
 158         struct lpfc_dmabuf *mp;
 159         unsigned int bytes_left = size;
 160
 161         /* Verify we can support the size specified */
 162         if (!size || (size > (*bpl_entries * LPFC_BPL_SIZE)))
 163                 return NULL;
 164
 165         /* Determine the number of dma buffers to allocate */
 166         *bpl_entries = (size % LPFC_BPL_SIZE ? size/LPFC_BPL_SIZE + 1 :
 167                         size/LPFC_BPL_SIZE);
 168
 169         /* Allocate dma buffer and place in BPL passed */
 170         while (bytes_left) {
 171                 /* Allocate dma buffer  */
 172                 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
 173                 if (!mp) {
 174                         if (mlist)
 175                                 lpfc_free_bsg_buffers(phba, mlist);
 176                         return NULL;
 177                 }
 178
 179                 INIT_LIST_HEAD(&mp->list);
 180                 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
 181
 182                 if (!mp->virt) {
 183                         kfree(mp);
 184                         if (mlist)
 185                                 lpfc_free_bsg_buffers(phba, mlist);
 186                         return NULL;
 187                 }
 188
 189                 /* Queue it to a linked list */
 190                 if (!mlist)
 191                         mlist = mp;
 192                 else
 193                         list_add_tail(&mp->list, &mlist->list);
 194
 195                 /* Add buffer to buffer pointer list */
 196                 if (outbound_buffers)
 197                         bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
 198                 else
 199                         bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
 200                 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys));
 201                 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys));
 202                 bpl->tus.f.bdeSize = (uint16_t)
 203                         (bytes_left >= LPFC_BPL_SIZE ? LPFC_BPL_SIZE :
 204                          bytes_left);
 205                 bytes_left -= bpl->tus.f.bdeSize;
 206                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
 207                 bpl++;
 208         }
 209         return mlist;
 210 }
 211
 212 static unsigned int
 213 lpfc_bsg_copy_data(struct lpfc_dmabuf *dma_buffers,
 214                    struct fc_bsg_buffer *bsg_buffers,
 215                    unsigned int bytes_to_transfer, int to_buffers)
 216 {
 217
 218         struct lpfc_dmabuf *mp;
 219         unsigned int transfer_bytes, bytes_copied = 0;
 220         unsigned int sg_offset, dma_offset;
 221         unsigned char *dma_address, *sg_address;
 222         LIST_HEAD(temp_list);
 223         struct sg_mapping_iter miter;
 224         unsigned long flags;
 225         unsigned int sg_flags = SG_MITER_ATOMIC;
 226         bool sg_valid;
 227
 228         list_splice_init(&dma_buffers->list, &temp_list);
 229         list_add(&dma_buffers->list, &temp_list);
 230         sg_offset = 0;
 231         if (to_buffers)
 232                 sg_flags |= SG_MITER_FROM_SG;
 233         else
 234                 sg_flags |= SG_MITER_TO_SG;
 235         sg_miter_start(&miter, bsg_buffers->sg_list, bsg_buffers->sg_cnt,
 236                        sg_flags);
 237         local_irq_save(flags);
 238         sg_valid = sg_miter_next(&miter);
 239         list_for_each_entry(mp, &temp_list, list) {
 240                 dma_offset = 0;
 241                 while (bytes_to_transfer && sg_valid &&
 242                        (dma_offset < LPFC_BPL_SIZE)) {
 243                         dma_address = mp->virt + dma_offset;
 244                         if (sg_offset) {
 245                                 /* Continue previous partial transfer of sg */
 246                                 sg_address = miter.addr + sg_offset;
 247                                 transfer_bytes = miter.length - sg_offset;
 248                         } else {
 249                                 sg_address = miter.addr;
 250                                 transfer_bytes = miter.length;
 251                         }
 252                         if (bytes_to_transfer < transfer_bytes)
 253                                 transfer_bytes = bytes_to_transfer;
 254                         if (transfer_bytes > (LPFC_BPL_SIZE - dma_offset))
 255                                 transfer_bytes = LPFC_BPL_SIZE - dma_offset;
 256                         if (to_buffers)
 257                                 memcpy(dma_address, sg_address, transfer_bytes);
 258                         else
 259                                 memcpy(sg_address, dma_address, transfer_bytes);
 260                         dma_offset += transfer_bytes;
 261                         sg_offset += transfer_bytes;
 262                         bytes_to_transfer -= transfer_bytes;
 263                         bytes_copied += transfer_bytes;
 264                         if (sg_offset >= miter.length) {
 265                                 sg_offset = 0;
 266                                 sg_valid = sg_miter_next(&miter);
 267                         }
 268                 }
 269         }
 270         sg_miter_stop(&miter);
 271         local_irq_restore(flags);
 272         list_del_init(&dma_buffers->list);
 273         list_splice(&temp_list, &dma_buffers->list);
 274         return bytes_copied;
 275 }
 276
 277 /**
 278  * lpfc_bsg_send_mgmt_cmd_cmp - lpfc_bsg_send_mgmt_cmd's completion handler
 279  * @phba: Pointer to HBA context object.
 280  * @cmdiocbq: Pointer to command iocb.
 281  * @rspiocbq: Pointer to response iocb.
 282  *
 283  * This function is the completion handler for iocbs issued using
 284  * lpfc_bsg_send_mgmt_cmd function. This function is called by the
 285  * ring event handler function without any lock held. This function
 286  * can be called from both worker thread context and interrupt
 287  * context. This function also can be called from another thread which
 288  * cleans up the SLI layer objects.
 289  * This function copies the contents of the response iocb to the
 290  * response iocb memory object provided by the caller of
 291  * lpfc_sli_issue_iocb_wait and then wakes up the thread which
 292  * sleeps for the iocb completion.
 293  **/
 294 static void
 295 lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
 296                         struct lpfc_iocbq *cmdiocbq,
 297                         struct lpfc_iocbq *rspiocbq)
 298 {
 299         struct bsg_job_data *dd_data;
 300         struct fc_bsg_job *job;
 301         IOCB_t *rsp;
 302         struct lpfc_dmabuf *bmp, *cmp, *rmp;
 303         struct lpfc_nodelist *ndlp;
 304         struct lpfc_bsg_iocb *iocb;
 305         unsigned long flags;
 306         unsigned int rsp_size;
 307         int rc = 0;
 308
 309         dd_data = cmdiocbq->context1;
 310
 311         /* Determine if job has been aborted */
 312         spin_lock_irqsave(&phba->ct_ev_lock, flags);
 313         job = dd_data->set_job;
 314         if (job) {
 315                 /* Prevent timeout handling from trying to abort job */
 316                 job->dd_data = NULL;
 317         }
 318         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 319
 320         /* Close the timeout handler abort window */
 321         spin_lock_irqsave(&phba->hbalock, flags);
 322         cmdiocbq->iocb_flag &= ~LPFC_IO_CMD_OUTSTANDING;
 323         spin_unlock_irqrestore(&phba->hbalock, flags);
 324
 325         iocb = &dd_data->context_un.iocb;
 326         ndlp = iocb->ndlp;
 327         rmp = iocb->rmp;
 328         cmp = cmdiocbq->context2;
 329         bmp = cmdiocbq->context3;
 330         rsp = &rspiocbq->iocb;
 331
 332         /* Copy the completed data or set the error status */
 333
 334         if (job) {
 335                 if (rsp->ulpStatus) {
 336                         if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
 337                                 switch (rsp->un.ulpWord[4] & IOERR_PARAM_MASK) {
 338                                 case IOERR_SEQUENCE_TIMEOUT:
 339                                         rc = -ETIMEDOUT;
 340                                         break;
 341                                 case IOERR_INVALID_RPI:
 342                                         rc = -EFAULT;
 343                                         break;
 344                                 default:
 345                                         rc = -EACCES;
 346                                         break;
 347                                 }
 348                         } else {
 349                                 rc = -EACCES;
 350                         }
 351                 } else {
 352                         rsp_size = rsp->un.genreq64.bdl.bdeSize;
 353                         job->reply->reply_payload_rcv_len =
 354                                 lpfc_bsg_copy_data(rmp, &job->reply_payload,
 355                                                    rsp_size, 0);
 356                 }
 357         }
 358
 359         lpfc_free_bsg_buffers(phba, cmp);
 360         lpfc_free_bsg_buffers(phba, rmp);
 361         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
 362         kfree(bmp);
 363         lpfc_sli_release_iocbq(phba, cmdiocbq);
 364         lpfc_nlp_put(ndlp);
 365         kfree(dd_data);
 366
 367         /* Complete the job if the job is still active */
 368
 369         if (job) {
 370                 job->reply->result = rc;
 371                 job->job_done(job);
 372         }
 373         return;
 374 }
 375
 376 /**
 377  * lpfc_bsg_send_mgmt_cmd - send a CT command from a bsg request
 378  * @job: fc_bsg_job to handle
 379  **/
 380 static int
 381 lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
 382 {
 383         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
 384         struct lpfc_hba *phba = vport->phba;
 385         struct lpfc_rport_data *rdata = job->rport->dd_data;
 386         struct lpfc_nodelist *ndlp = rdata->pnode;
 387         struct ulp_bde64 *bpl = NULL;
 388         uint32_t timeout;
 389         struct lpfc_iocbq *cmdiocbq = NULL;
 390         IOCB_t *cmd;
 391         struct lpfc_dmabuf *bmp = NULL, *cmp = NULL, *rmp = NULL;
 392         int request_nseg;
 393         int reply_nseg;
 394         struct bsg_job_data *dd_data;
 395         unsigned long flags;
 396         uint32_t creg_val;
 397         int rc = 0;
 398         int iocb_stat;
 399
 400         /* in case no data is transferred */
 401         job->reply->reply_payload_rcv_len = 0;
 402
 403         /* allocate our bsg tracking structure */
 404         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
 405         if (!dd_data) {
 406                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
 407                                 "2733 Failed allocation of dd_data\n");
 408                 rc = -ENOMEM;
 409                 goto no_dd_data;
 410         }
 411
 412         if (!lpfc_nlp_get(ndlp)) {
 413                 rc = -ENODEV;
 414                 goto no_ndlp;
 415         }
 416
 417         if (ndlp->nlp_flag & NLP_ELS_SND_MASK) {
 418                 rc = -ENODEV;
 419                 goto free_ndlp;
 420         }
 421
 422         cmdiocbq = lpfc_sli_get_iocbq(phba);
 423         if (!cmdiocbq) {
 424                 rc = -ENOMEM;
 425                 goto free_ndlp;
 426         }
 427
 428         cmd = &cmdiocbq->iocb;
 429
 430         bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
 431         if (!bmp) {
 432                 rc = -ENOMEM;
 433                 goto free_cmdiocbq;
 434         }
 435         bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
 436         if (!bmp->virt) {
 437                 rc = -ENOMEM;
 438                 goto free_bmp;
 439         }
 440
 441         INIT_LIST_HEAD(&bmp->list);
 442
 443         bpl = (struct ulp_bde64 *) bmp->virt;
 444         request_nseg = LPFC_BPL_SIZE/sizeof(struct ulp_bde64);
 445         cmp = lpfc_alloc_bsg_buffers(phba, job->request_payload.payload_len,
 446                                      1, bpl, &request_nseg);
 447         if (!cmp) {
 448                 rc = -ENOMEM;
 449                 goto free_bmp;
 450         }
 451         lpfc_bsg_copy_data(cmp, &job->request_payload,
 452                            job->request_payload.payload_len, 1);
 453
 454         bpl += request_nseg;
 455         reply_nseg = LPFC_BPL_SIZE/sizeof(struct ulp_bde64) - request_nseg;
 456         rmp = lpfc_alloc_bsg_buffers(phba, job->reply_payload.payload_len, 0,
 457                                      bpl, &reply_nseg);
 458         if (!rmp) {
 459                 rc = -ENOMEM;
 460                 goto free_cmp;
 461         }
 462
 463         cmd->un.genreq64.bdl.ulpIoTag32 = 0;
 464         cmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
 465         cmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
 466         cmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
 467         cmd->un.genreq64.bdl.bdeSize =
 468                 (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
 469         cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
 470         cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
 471         cmd->un.genreq64.w5.hcsw.Dfctl = 0;
 472         cmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
 473         cmd->un.genreq64.w5.hcsw.Type = FC_TYPE_CT;
 474         cmd->ulpBdeCount = 1;
 475         cmd->ulpLe = 1;
 476         cmd->ulpClass = CLASS3;
 477         cmd->ulpContext = ndlp->nlp_rpi;
 478         if (phba->sli_rev == LPFC_SLI_REV4)
 479                 cmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
 480         cmd->ulpOwner = OWN_CHIP;
 481         cmdiocbq->vport = phba->pport;
 482         cmdiocbq->context3 = bmp;
 483         cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
 484         timeout = phba->fc_ratov * 2;
 485         cmd->ulpTimeout = timeout;
 486
 487         cmdiocbq->iocb_cmpl = lpfc_bsg_send_mgmt_cmd_cmp;
 488         cmdiocbq->context1 = dd_data;
 489         cmdiocbq->context2 = cmp;
 490         cmdiocbq->context3 = bmp;
 491         cmdiocbq->context_un.ndlp = ndlp;
 492         dd_data->type = TYPE_IOCB;
 493         dd_data->set_job = job;
 494         dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
 495         dd_data->context_un.iocb.ndlp = ndlp;
 496         dd_data->context_un.iocb.rmp = rmp;
 497         job->dd_data = dd_data;
 498
 499         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
 500                 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
 501                         rc = -EIO ;
 502                         goto free_rmp;
 503                 }
 504                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
 505                 writel(creg_val, phba->HCregaddr);
 506                 readl(phba->HCregaddr); /* flush */
 507         }
 508
 509         iocb_stat = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
 510
 511         if (iocb_stat == IOCB_SUCCESS) {
 512                 spin_lock_irqsave(&phba->hbalock, flags);
 513                 /* make sure the I/O had not been completed yet */
 514                 if (cmdiocbq->iocb_flag & LPFC_IO_LIBDFC) {
 515                         /* open up abort window to timeout handler */
 516                         cmdiocbq->iocb_flag |= LPFC_IO_CMD_OUTSTANDING;
 517                 }
 518                 spin_unlock_irqrestore(&phba->hbalock, flags);
 519                 return 0; /* done for now */
 520         } else if (iocb_stat == IOCB_BUSY) {
 521                 rc = -EAGAIN;
 522         } else {
 523                 rc = -EIO;
 524         }
 525
 526         /* iocb failed so cleanup */
 527         job->dd_data = NULL;
 528
 529 free_rmp:
 530         lpfc_free_bsg_buffers(phba, rmp);
 531 free_cmp:
 532         lpfc_free_bsg_buffers(phba, cmp);
 533 free_bmp:
 534         if (bmp->virt)
 535                 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
 536         kfree(bmp);
 537 free_cmdiocbq:
 538         lpfc_sli_release_iocbq(phba, cmdiocbq);
 539 free_ndlp:
 540         lpfc_nlp_put(ndlp);
 541 no_ndlp:
 542         kfree(dd_data);
 543 no_dd_data:
 544         /* make error code available to userspace */
 545         job->reply->result = rc;
 546         job->dd_data = NULL;
 547         return rc;
 548 }
 549
 550 /**
 551  * lpfc_bsg_rport_els_cmp - lpfc_bsg_rport_els's completion handler
 552  * @phba: Pointer to HBA context object.
 553  * @cmdiocbq: Pointer to command iocb.
 554  * @rspiocbq: Pointer to response iocb.
 555  *
 556  * This function is the completion handler for iocbs issued using
 557  * lpfc_bsg_rport_els_cmp function. This function is called by the
 558  * ring event handler function without any lock held. This function
 559  * can be called from both worker thread context and interrupt
 560  * context. This function also can be called from other thread which
 561  * cleans up the SLI layer objects.
 562  * This function copies the contents of the response iocb to the
 563  * response iocb memory object provided by the caller of
 564  * lpfc_sli_issue_iocb_wait and then wakes up the thread which
 565  * sleeps for the iocb completion.
 566  **/
 567 static void
 568 lpfc_bsg_rport_els_cmp(struct lpfc_hba *phba,
 569                         struct lpfc_iocbq *cmdiocbq,
 570                         struct lpfc_iocbq *rspiocbq)
 571 {
 572         struct bsg_job_data *dd_data;
 573         struct fc_bsg_job *job;
 574         IOCB_t *rsp;
 575         struct lpfc_nodelist *ndlp;
 576         struct lpfc_dmabuf *pcmd = NULL, *prsp = NULL;
 577         struct fc_bsg_ctels_reply *els_reply;
 578         uint8_t *rjt_data;
 579         unsigned long flags;
 580         unsigned int rsp_size;
 581         int rc = 0;
 582
 583         dd_data = cmdiocbq->context1;
 584         ndlp = dd_data->context_un.iocb.ndlp;
 585         cmdiocbq->context1 = ndlp;
 586
 587         /* Determine if job has been aborted */
 588         spin_lock_irqsave(&phba->ct_ev_lock, flags);
 589         job = dd_data->set_job;
 590         if (job) {
 591                 /* Prevent timeout handling from trying to abort job  */
 592                 job->dd_data = NULL;
 593         }
 594         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 595
 596         /* Close the timeout handler abort window */
 597         spin_lock_irqsave(&phba->hbalock, flags);
 598         cmdiocbq->iocb_flag &= ~LPFC_IO_CMD_OUTSTANDING;
 599         spin_unlock_irqrestore(&phba->hbalock, flags);
 600
 601         rsp = &rspiocbq->iocb;
 602         pcmd = (struct lpfc_dmabuf *)cmdiocbq->context2;
 603         prsp = (struct lpfc_dmabuf *)pcmd->list.next;
 604
 605         /* Copy the completed job data or determine the job status if job is
 606          * still active
 607          */
 608
 609         if (job) {
 610                 if (rsp->ulpStatus == IOSTAT_SUCCESS) {
 611                         rsp_size = rsp->un.elsreq64.bdl.bdeSize;
 612                         job->reply->reply_payload_rcv_len =
 613                                 sg_copy_from_buffer(job->reply_payload.sg_list,
 614                                                     job->reply_payload.sg_cnt,
 615                                                     prsp->virt,
 616                                                     rsp_size);
 617                 } else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
 618                         job->reply->reply_payload_rcv_len =
 619                                 sizeof(struct fc_bsg_ctels_reply);
 620                         /* LS_RJT data returned in word 4 */
 621                         rjt_data = (uint8_t *)&rsp->un.ulpWord[4];
 622                         els_reply = &job->reply->reply_data.ctels_reply;
 623                         els_reply->status = FC_CTELS_STATUS_REJECT;
 624                         els_reply->rjt_data.action = rjt_data[3];
 625                         els_reply->rjt_data.reason_code = rjt_data[2];
 626                         els_reply->rjt_data.reason_explanation = rjt_data[1];
 627                         els_reply->rjt_data.vendor_unique = rjt_data[0];
 628                 } else {
 629                         rc = -EIO;
 630                 }
 631         }
 632
 633         lpfc_nlp_put(ndlp);
 634         lpfc_els_free_iocb(phba, cmdiocbq);
 635         kfree(dd_data);
 636
 637         /* Complete the job if the job is still active */
 638
 639         if (job) {
 640                 job->reply->result = rc;
 641                 job->job_done(job);
 642         }
 643         return;
 644 }
 645
 646 /**
 647  * lpfc_bsg_rport_els - send an ELS command from a bsg request
 648  * @job: fc_bsg_job to handle
 649  **/
 650 static int
 651 lpfc_bsg_rport_els(struct fc_bsg_job *job)
 652 {
 653         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
 654         struct lpfc_hba *phba = vport->phba;
 655         struct lpfc_rport_data *rdata = job->rport->dd_data;
 656         struct lpfc_nodelist *ndlp = rdata->pnode;
 657         uint32_t elscmd;
 658         uint32_t cmdsize;
 659         uint32_t rspsize;
 660         struct lpfc_iocbq *cmdiocbq;
 661         uint16_t rpi = 0;
 662         struct bsg_job_data *dd_data;
 663         unsigned long flags;
 664         uint32_t creg_val;
 665         int rc = 0;
 666
 667         /* in case no data is transferred */
 668         job->reply->reply_payload_rcv_len = 0;
 669
 670         /* verify the els command is not greater than the
 671          * maximum ELS transfer size.
 672          */
 673
 674         if (job->request_payload.payload_len > FCELSSIZE) {
 675                 rc = -EINVAL;
 676                 goto no_dd_data;
 677         }
 678
 679         /* allocate our bsg tracking structure */
 680         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
 681         if (!dd_data) {
 682                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
 683                                 "2735 Failed allocation of dd_data\n");
 684                 rc = -ENOMEM;
 685                 goto no_dd_data;
 686         }
 687
 688         elscmd = job->request->rqst_data.r_els.els_code;
 689         cmdsize = job->request_payload.payload_len;
 690         rspsize = job->reply_payload.payload_len;
 691
 692         if (!lpfc_nlp_get(ndlp)) {
 693                 rc = -ENODEV;
 694                 goto free_dd_data;
 695         }
 696
 697         /* We will use the allocated dma buffers by prep els iocb for command
 698          * and response to ensure if the job times out and the request is freed,
 699          * we won't be dma into memory that is no longer allocated to for the
 700          * request.
 701          */
 702
 703         cmdiocbq = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp,
 704                                       ndlp->nlp_DID, elscmd);
 705         if (!cmdiocbq) {
 706                 rc = -EIO;
 707                 goto release_ndlp;
 708         }
 709
 710         rpi = ndlp->nlp_rpi;
 711
 712         /* Transfer the request payload to allocated command dma buffer */
 713
 714         sg_copy_to_buffer(job->request_payload.sg_list,
 715                           job->request_payload.sg_cnt,
 716                           ((struct lpfc_dmabuf *)cmdiocbq->context2)->virt,
 717                           cmdsize);
 718
 719         if (phba->sli_rev == LPFC_SLI_REV4)
 720                 cmdiocbq->iocb.ulpContext = phba->sli4_hba.rpi_ids[rpi];
 721         else
 722                 cmdiocbq->iocb.ulpContext = rpi;
 723         cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
 724         cmdiocbq->context1 = dd_data;
 725         cmdiocbq->context_un.ndlp = ndlp;
 726         cmdiocbq->iocb_cmpl = lpfc_bsg_rport_els_cmp;
 727         dd_data->type = TYPE_IOCB;
 728         dd_data->set_job = job;
 729         dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
 730         dd_data->context_un.iocb.ndlp = ndlp;
 731         dd_data->context_un.iocb.rmp = NULL;
 732         job->dd_data = dd_data;
 733
 734         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
 735                 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
 736                         rc = -EIO;
 737                         goto linkdown_err;
 738                 }
 739                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
 740                 writel(creg_val, phba->HCregaddr);
 741                 readl(phba->HCregaddr); /* flush */
 742         }
 743
 744         rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
 745
 746         if (rc == IOCB_SUCCESS) {
 747                 spin_lock_irqsave(&phba->hbalock, flags);
 748                 /* make sure the I/O had not been completed/released */
 749                 if (cmdiocbq->iocb_flag & LPFC_IO_LIBDFC) {
 750                         /* open up abort window to timeout handler */
 751                         cmdiocbq->iocb_flag |= LPFC_IO_CMD_OUTSTANDING;
 752                 }
 753                 spin_unlock_irqrestore(&phba->hbalock, flags);
 754                 return 0; /* done for now */
 755         } else if (rc == IOCB_BUSY) {
 756                 rc = -EAGAIN;
 757         } else {
 758                 rc = -EIO;
 759         }
 760
 761         /* iocb failed so cleanup */
 762         job->dd_data = NULL;
 763
 764 linkdown_err:
 765         cmdiocbq->context1 = ndlp;
 766         lpfc_els_free_iocb(phba, cmdiocbq);
 767
 768 release_ndlp:
 769         lpfc_nlp_put(ndlp);
 770
 771 free_dd_data:
 772         kfree(dd_data);
 773
 774 no_dd_data:
 775         /* make error code available to userspace */
 776         job->reply->result = rc;
 777         job->dd_data = NULL;
 778         return rc;
 779 }
 780
 781 /**
 782  * lpfc_bsg_event_free - frees an allocated event structure
 783  * @kref: Pointer to a kref.
 784  *
 785  * Called from kref_put. Back cast the kref into an event structure address.
 786  * Free any events to get, delete associated nodes, free any events to see,
 787  * free any data then free the event itself.
 788  **/
 789 static void
 790 lpfc_bsg_event_free(struct kref *kref)
 791 {
 792         struct lpfc_bsg_event *evt = container_of(kref, struct lpfc_bsg_event,
 793                                                   kref);
 794         struct event_data *ed;
 795
 796         list_del(&evt->node);
 797
 798         while (!list_empty(&evt->events_to_get)) {
 799                 ed = list_entry(evt->events_to_get.next, typeof(*ed), node);
 800                 list_del(&ed->node);
 801                 kfree(ed->data);
 802                 kfree(ed);
 803         }
 804
 805         while (!list_empty(&evt->events_to_see)) {
 806                 ed = list_entry(evt->events_to_see.next, typeof(*ed), node);
 807                 list_del(&ed->node);
 808                 kfree(ed->data);
 809                 kfree(ed);
 810         }
 811
 812         kfree(evt->dd_data);
 813         kfree(evt);
 814 }
 815
 816 /**
 817  * lpfc_bsg_event_ref - increments the kref for an event
 818  * @evt: Pointer to an event structure.
 819  **/
 820 static inline void
 821 lpfc_bsg_event_ref(struct lpfc_bsg_event *evt)
 822 {
 823         kref_get(&evt->kref);
 824 }
 825
 826 /**
 827  * lpfc_bsg_event_unref - Uses kref_put to free an event structure
 828  * @evt: Pointer to an event structure.
 829  **/
 830 static inline void
 831 lpfc_bsg_event_unref(struct lpfc_bsg_event *evt)
 832 {
 833         kref_put(&evt->kref, lpfc_bsg_event_free);
 834 }
 835
 836 /**
 837  * lpfc_bsg_event_new - allocate and initialize a event structure
 838  * @ev_mask: Mask of events.
 839  * @ev_reg_id: Event reg id.
 840  * @ev_req_id: Event request id.
 841  **/
 842 static struct lpfc_bsg_event *
 843 lpfc_bsg_event_new(uint32_t ev_mask, int ev_reg_id, uint32_t ev_req_id)
 844 {
 845         struct lpfc_bsg_event *evt = kzalloc(sizeof(*evt), GFP_KERNEL);
 846
 847         if (!evt)
 848                 return NULL;
 849
 850         INIT_LIST_HEAD(&evt->events_to_get);
 851         INIT_LIST_HEAD(&evt->events_to_see);
 852         evt->type_mask = ev_mask;
 853         evt->req_id = ev_req_id;
 854         evt->reg_id = ev_reg_id;
 855         evt->wait_time_stamp = jiffies;
 856         evt->dd_data = NULL;
 857         init_waitqueue_head(&evt->wq);
 858         kref_init(&evt->kref);
 859         return evt;
 860 }
 861
 862 /**
 863  * diag_cmd_data_free - Frees an lpfc dma buffer extension
 864  * @phba: Pointer to HBA context object.
 865  * @mlist: Pointer to an lpfc dma buffer extension.
 866  **/
 867 static int
 868 diag_cmd_data_free(struct lpfc_hba *phba, struct lpfc_dmabufext *mlist)
 869 {
 870         struct lpfc_dmabufext *mlast;
 871         struct pci_dev *pcidev;
 872         struct list_head head, *curr, *next;
 873
 874         if ((!mlist) || (!lpfc_is_link_up(phba) &&
 875                 (phba->link_flag & LS_LOOPBACK_MODE))) {
 876                 return 0;
 877         }
 878
 879         pcidev = phba->pcidev;
 880         list_add_tail(&head, &mlist->dma.list);
 881
 882         list_for_each_safe(curr, next, &head) {
 883                 mlast = list_entry(curr, struct lpfc_dmabufext , dma.list);
 884                 if (mlast->dma.virt)
 885                         dma_free_coherent(&pcidev->dev,
 886                                           mlast->size,
 887                                           mlast->dma.virt,
 888                                           mlast->dma.phys);
 889                 kfree(mlast);
 890         }
 891         return 0;
 892 }
 893
 894 /**
 895  * lpfc_bsg_ct_unsol_event - process an unsolicited CT command
 896  * @phba:
 897  * @pring:
 898  * @piocbq:
 899  *
 900  * This function is called when an unsolicited CT command is received.  It
 901  * forwards the event to any processes registered to receive CT events.
 902  **/
 903 int
 904 lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 905                         struct lpfc_iocbq *piocbq)
 906 {
 907         uint32_t evt_req_id = 0;
 908         uint32_t cmd;
 909         uint32_t len;
 910         struct lpfc_dmabuf *dmabuf = NULL;
 911         struct lpfc_bsg_event *evt;
 912         struct event_data *evt_dat = NULL;
 913         struct lpfc_iocbq *iocbq;
 914         size_t offset = 0;
 915         struct list_head head;
 916         struct ulp_bde64 *bde;
 917         dma_addr_t dma_addr;
 918         int i;
 919         struct lpfc_dmabuf *bdeBuf1 = piocbq->context2;
 920         struct lpfc_dmabuf *bdeBuf2 = piocbq->context3;
 921         struct lpfc_hbq_entry *hbqe;
 922         struct lpfc_sli_ct_request *ct_req;
 923         struct fc_bsg_job *job = NULL;
 924         struct bsg_job_data *dd_data = NULL;
 925         unsigned long flags;
 926         int size = 0;
 927
 928         INIT_LIST_HEAD(&head);
 929         list_add_tail(&head, &piocbq->list);
 930
 931         if (piocbq->iocb.ulpBdeCount == 0 ||
 932             piocbq->iocb.un.cont64[0].tus.f.bdeSize == 0)
 933                 goto error_ct_unsol_exit;
 934
 935         if (phba->link_state == LPFC_HBA_ERROR ||
 936                 (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)))
 937                 goto error_ct_unsol_exit;
 938
 939         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
 940                 dmabuf = bdeBuf1;
 941         else {
 942                 dma_addr = getPaddr(piocbq->iocb.un.cont64[0].addrHigh,
 943                                     piocbq->iocb.un.cont64[0].addrLow);
 944                 dmabuf = lpfc_sli_ringpostbuf_get(phba, pring, dma_addr);
 945         }
 946         if (dmabuf == NULL)
 947                 goto error_ct_unsol_exit;
 948         ct_req = (struct lpfc_sli_ct_request *)dmabuf->virt;
 949         evt_req_id = ct_req->FsType;
 950         cmd = ct_req->CommandResponse.bits.CmdRsp;
 951         len = ct_req->CommandResponse.bits.Size;
 952         if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
 953                 lpfc_sli_ringpostbuf_put(phba, pring, dmabuf);
 954
 955         spin_lock_irqsave(&phba->ct_ev_lock, flags);
 956         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
 957                 if (!(evt->type_mask & FC_REG_CT_EVENT) ||
 958                         evt->req_id != evt_req_id)
 959                         continue;
 960
 961                 lpfc_bsg_event_ref(evt);
 962                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 963                 evt_dat = kzalloc(sizeof(*evt_dat), GFP_KERNEL);
 964                 if (evt_dat == NULL) {
 965                         spin_lock_irqsave(&phba->ct_ev_lock, flags);
 966                         lpfc_bsg_event_unref(evt);
 967                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
 968                                         "2614 Memory allocation failed for "
 969                                         "CT event\n");
 970                         break;
 971                 }
 972
 973                 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
 974                         /* take accumulated byte count from the last iocbq */
 975                         iocbq = list_entry(head.prev, typeof(*iocbq), list);
 976                         evt_dat->len = iocbq->iocb.unsli3.rcvsli3.acc_len;
 977                 } else {
 978                         list_for_each_entry(iocbq, &head, list) {
 979                                 for (i = 0; i < iocbq->iocb.ulpBdeCount; i++)
 980                                         evt_dat->len +=
 981                                         iocbq->iocb.un.cont64[i].tus.f.bdeSize;
 982                         }
 983                 }
 984
 985                 evt_dat->data = kzalloc(evt_dat->len, GFP_KERNEL);
 986                 if (evt_dat->data == NULL) {
 987                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
 988                                         "2615 Memory allocation failed for "
 989                                         "CT event data, size %d\n",
 990                                         evt_dat->len);
 991                         kfree(evt_dat);
 992                         spin_lock_irqsave(&phba->ct_ev_lock, flags);
 993                         lpfc_bsg_event_unref(evt);
 994                         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 995                         goto error_ct_unsol_exit;
 996                 }
 997
 998                 list_for_each_entry(iocbq, &head, list) {
 999                         size = 0;
1000                         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
1001                                 bdeBuf1 = iocbq->context2;
1002                                 bdeBuf2 = iocbq->context3;
1003                         }
1004                         for (i = 0; i < iocbq->iocb.ulpBdeCount; i++) {
1005                                 if (phba->sli3_options &
1006                                     LPFC_SLI3_HBQ_ENABLED) {
1007                                         if (i == 0) {
1008                                                 hbqe = (struct lpfc_hbq_entry *)
1009                                                   &iocbq->iocb.un.ulpWord[0];
1010                                                 size = hbqe->bde.tus.f.bdeSize;
1011                                                 dmabuf = bdeBuf1;
1012                                         } else if (i == 1) {
1013                                                 hbqe = (struct lpfc_hbq_entry *)
1014                                                         &iocbq->iocb.unsli3.
1015                                                         sli3Words[4];
1016                                                 size = hbqe->bde.tus.f.bdeSize;
1017                                                 dmabuf = bdeBuf2;
1018                                         }
1019                                         if ((offset + size) > evt_dat->len)
1020                                                 size = evt_dat->len - offset;
1021                                 } else {
1022                                         size = iocbq->iocb.un.cont64[i].
1023                                                 tus.f.bdeSize;
1024                                         bde = &iocbq->iocb.un.cont64[i];
1025                                         dma_addr = getPaddr(bde->addrHigh,
1026                                                             bde->addrLow);
1027                                         dmabuf = lpfc_sli_ringpostbuf_get(phba,
1028                                                         pring, dma_addr);
1029                                 }
1030                                 if (!dmabuf) {
1031                                         lpfc_printf_log(phba, KERN_ERR,
1032                                                 LOG_LIBDFC, "2616 No dmabuf "
1033                                                 "found for iocbq 0x%p\n",
1034                                                 iocbq);
1035                                         kfree(evt_dat->data);
1036                                         kfree(evt_dat);
1037                                         spin_lock_irqsave(&phba->ct_ev_lock,
1038                                                 flags);
1039                                         lpfc_bsg_event_unref(evt);
1040                                         spin_unlock_irqrestore(
1041                                                 &phba->ct_ev_lock, flags);
1042                                         goto error_ct_unsol_exit;
1043                                 }
1044                                 memcpy((char *)(evt_dat->data) + offset,
1045                                        dmabuf->virt, size);
1046                                 offset += size;
1047                                 if (evt_req_id != SLI_CT_ELX_LOOPBACK &&
1048                                     !(phba->sli3_options &
1049                                       LPFC_SLI3_HBQ_ENABLED)) {
1050                                         lpfc_sli_ringpostbuf_put(phba, pring,
1051                                                                  dmabuf);
1052                                 } else {
1053                                         switch (cmd) {
1054                                         case ELX_LOOPBACK_DATA:
1055                                                 if (phba->sli_rev <
1056                                                     LPFC_SLI_REV4)
1057                                                         diag_cmd_data_free(phba,
1058                                                         (struct lpfc_dmabufext
1059                                                          *)dmabuf);
1060                                                 break;
1061                                         case ELX_LOOPBACK_XRI_SETUP:
1062                                                 if ((phba->sli_rev ==
1063                                                         LPFC_SLI_REV2) ||
1064                                                         (phba->sli3_options &
1065                                                         LPFC_SLI3_HBQ_ENABLED
1066                                                         )) {
1067                                                         lpfc_in_buf_free(phba,
1068                                                                         dmabuf);
1069                                                 } else {
1070                                                         lpfc_post_buffer(phba,
1071                                                                          pring,
1072                                                                          1);
1073                                                 }
1074                                                 break;
1075                                         default:
1076                                                 if (!(phba->sli3_options &
1077                                                       LPFC_SLI3_HBQ_ENABLED))
1078                                                         lpfc_post_buffer(phba,
1079                                                                          pring,
1080                                                                          1);
1081                                                 break;
1082                                         }
1083                                 }
1084                         }
1085                 }
1086
1087                 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1088                 if (phba->sli_rev == LPFC_SLI_REV4) {
1089                         evt_dat->immed_dat = phba->ctx_idx;
1090                         phba->ctx_idx = (phba->ctx_idx + 1) % LPFC_CT_CTX_MAX;
1091                         /* Provide warning for over-run of the ct_ctx array */
1092                         if (phba->ct_ctx[evt_dat->immed_dat].valid ==
1093                             UNSOL_VALID)
1094                                 lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
1095                                                 "2717 CT context array entry "
1096                                                 "[%d] over-run: oxid:x%x, "
1097                                                 "sid:x%x\n", phba->ctx_idx,
1098                                                 phba->ct_ctx[
1099                                                     evt_dat->immed_dat].oxid,
1100                                                 phba->ct_ctx[
1101                                                     evt_dat->immed_dat].SID);
1102                         phba->ct_ctx[evt_dat->immed_dat].rxid =
1103                                 piocbq->iocb.ulpContext;
1104                         phba->ct_ctx[evt_dat->immed_dat].oxid =
1105                                 piocbq->iocb.unsli3.rcvsli3.ox_id;
1106                         phba->ct_ctx[evt_dat->immed_dat].SID =
1107                                 piocbq->iocb.un.rcvels.remoteID;
1108                         phba->ct_ctx[evt_dat->immed_dat].valid = UNSOL_VALID;
1109                 } else
1110                         evt_dat->immed_dat = piocbq->iocb.ulpContext;
1111
1112                 evt_dat->type = FC_REG_CT_EVENT;
1113                 list_add(&evt_dat->node, &evt->events_to_see);
1114                 if (evt_req_id == SLI_CT_ELX_LOOPBACK) {
1115                         wake_up_interruptible(&evt->wq);
1116                         lpfc_bsg_event_unref(evt);
1117                         break;
1118                 }
1119
1120                 list_move(evt->events_to_see.prev, &evt->events_to_get);
1121
1122                 dd_data = (struct bsg_job_data *)evt->dd_data;
1123                 job = dd_data->set_job;
1124                 dd_data->set_job = NULL;
1125                 lpfc_bsg_event_unref(evt);
1126                 if (job) {
1127                         job->reply->reply_payload_rcv_len = size;
1128                         /* make error code available to userspace */
1129                         job->reply->result = 0;
1130                         job->dd_data = NULL;
1131                         /* complete the job back to userspace */
1132                         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1133                         job->job_done(job);
1134                         spin_lock_irqsave(&phba->ct_ev_lock, flags);
1135                 }
1136         }
1137         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1138
1139 error_ct_unsol_exit:
1140         if (!list_empty(&head))
1141                 list_del(&head);
1142         if ((phba->sli_rev < LPFC_SLI_REV4) &&
1143             (evt_req_id == SLI_CT_ELX_LOOPBACK))
1144                 return 0;
1145         return 1;
1146 }
1147
1148 /**
1149  * lpfc_bsg_ct_unsol_abort - handler ct abort to management plane
1150  * @phba: Pointer to HBA context object.
1151  * @dmabuf: pointer to a dmabuf that describes the FC sequence
1152  *
1153  * This function handles abort to the CT command toward management plane
1154  * for SLI4 port.
1155  *
1156  * If the pending context of a CT command to management plane present, clears
1157  * such context and returns 1 for handled; otherwise, it returns 0 indicating
1158  * no context exists.
1159  **/
1160 int
1161 lpfc_bsg_ct_unsol_abort(struct lpfc_hba *phba, struct hbq_dmabuf *dmabuf)
1162 {
1163         struct fc_frame_header fc_hdr;
1164         struct fc_frame_header *fc_hdr_ptr = &fc_hdr;
1165         int ctx_idx, handled = 0;
1166         uint16_t oxid, rxid;
1167         uint32_t sid;
1168
1169         memcpy(fc_hdr_ptr, dmabuf->hbuf.virt, sizeof(struct fc_frame_header));
1170         sid = sli4_sid_from_fc_hdr(fc_hdr_ptr);
1171         oxid = be16_to_cpu(fc_hdr_ptr->fh_ox_id);
1172         rxid = be16_to_cpu(fc_hdr_ptr->fh_rx_id);
1173
1174         for (ctx_idx = 0; ctx_idx < LPFC_CT_CTX_MAX; ctx_idx++) {
1175                 if (phba->ct_ctx[ctx_idx].valid != UNSOL_VALID)
1176                         continue;
1177                 if (phba->ct_ctx[ctx_idx].rxid != rxid)
1178                         continue;
1179                 if (phba->ct_ctx[ctx_idx].oxid != oxid)
1180                         continue;
1181                 if (phba->ct_ctx[ctx_idx].SID != sid)
1182                         continue;
1183                 phba->ct_ctx[ctx_idx].valid = UNSOL_INVALID;
1184                 handled = 1;
1185         }
1186         return handled;
1187 }
1188
1189 /**
1190  * lpfc_bsg_hba_set_event - process a SET_EVENT bsg vendor command
1191  * @job: SET_EVENT fc_bsg_job
1192  **/
1193 static int
1194 lpfc_bsg_hba_set_event(struct fc_bsg_job *job)
1195 {
1196         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
1197         struct lpfc_hba *phba = vport->phba;
1198         struct set_ct_event *event_req;
1199         struct lpfc_bsg_event *evt;
1200         int rc = 0;
1201         struct bsg_job_data *dd_data = NULL;
1202         uint32_t ev_mask;
1203         unsigned long flags;
1204
1205         if (job->request_len <
1206             sizeof(struct fc_bsg_request) + sizeof(struct set_ct_event)) {
1207                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1208                                 "2612 Received SET_CT_EVENT below minimum "
1209                                 "size\n");
1210                 rc = -EINVAL;
1211                 goto job_error;
1212         }
1213
1214         event_req = (struct set_ct_event *)
1215                 job->request->rqst_data.h_vendor.vendor_cmd;
1216         ev_mask = ((uint32_t)(unsigned long)event_req->type_mask &
1217                                 FC_REG_EVENT_MASK);
1218         spin_lock_irqsave(&phba->ct_ev_lock, flags);
1219         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
1220                 if (evt->reg_id == event_req->ev_reg_id) {
1221                         lpfc_bsg_event_ref(evt);
1222                         evt->wait_time_stamp = jiffies;
1223                         dd_data = (struct bsg_job_data *)evt->dd_data;
1224                         break;
1225                 }
1226         }
1227         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1228
1229         if (&evt->node == &phba->ct_ev_waiters) {
1230                 /* no event waiting struct yet - first call */
1231                 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
1232                 if (dd_data == NULL) {
1233                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1234                                         "2734 Failed allocation of dd_data\n");
1235                         rc = -ENOMEM;
1236                         goto job_error;
1237                 }
1238                 evt = lpfc_bsg_event_new(ev_mask, event_req->ev_reg_id,
1239                                         event_req->ev_req_id);
1240                 if (!evt) {
1241                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1242                                         "2617 Failed allocation of event "
1243                                         "waiter\n");
1244                         rc = -ENOMEM;
1245                         goto job_error;
1246                 }
1247                 dd_data->type = TYPE_EVT;
1248                 dd_data->set_job = NULL;
1249                 dd_data->context_un.evt = evt;
1250                 evt->dd_data = (void *)dd_data;
1251                 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1252                 list_add(&evt->node, &phba->ct_ev_waiters);
1253                 lpfc_bsg_event_ref(evt);
1254                 evt->wait_time_stamp = jiffies;
1255                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1256         }
1257
1258         spin_lock_irqsave(&phba->ct_ev_lock, flags);
1259         evt->waiting = 1;
1260         dd_data->set_job = job; /* for unsolicited command */
1261         job->dd_data = dd_data; /* for fc transport timeout callback*/
1262         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1263         return 0; /* call job done later */
1264
1265 job_error:
1266         if (dd_data != NULL)
1267                 kfree(dd_data);
1268
1269         job->dd_data = NULL;
1270         return rc;
1271 }
1272
1273 /**
1274  * lpfc_bsg_hba_get_event - process a GET_EVENT bsg vendor command
1275  * @job: GET_EVENT fc_bsg_job
1276  **/
1277 static int
1278 lpfc_bsg_hba_get_event(struct fc_bsg_job *job)
1279 {
1280         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
1281         struct lpfc_hba *phba = vport->phba;
1282         struct get_ct_event *event_req;
1283         struct get_ct_event_reply *event_reply;
1284         struct lpfc_bsg_event *evt, *evt_next;
1285         struct event_data *evt_dat = NULL;
1286         unsigned long flags;
1287         uint32_t rc = 0;
1288
1289         if (job->request_len <
1290             sizeof(struct fc_bsg_request) + sizeof(struct get_ct_event)) {
1291                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1292                                 "2613 Received GET_CT_EVENT request below "
1293                                 "minimum size\n");
1294                 rc = -EINVAL;
1295                 goto job_error;
1296         }
1297
1298         event_req = (struct get_ct_event *)
1299                 job->request->rqst_data.h_vendor.vendor_cmd;
1300
1301         event_reply = (struct get_ct_event_reply *)
1302                 job->reply->reply_data.vendor_reply.vendor_rsp;
1303         spin_lock_irqsave(&phba->ct_ev_lock, flags);
1304         list_for_each_entry_safe(evt, evt_next, &phba->ct_ev_waiters, node) {
1305                 if (evt->reg_id == event_req->ev_reg_id) {
1306                         if (list_empty(&evt->events_to_get))
1307                                 break;
1308                         lpfc_bsg_event_ref(evt);
1309                         evt->wait_time_stamp = jiffies;
1310                         evt_dat = list_entry(evt->events_to_get.prev,
1311                                              struct event_data, node);
1312                         list_del(&evt_dat->node);
1313                         break;
1314                 }
1315         }
1316         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1317
1318         /* The app may continue to ask for event data until it gets
1319          * an error indicating that there isn't anymore
1320          */
1321         if (evt_dat == NULL) {
1322                 job->reply->reply_payload_rcv_len = 0;
1323                 rc = -ENOENT;
1324                 goto job_error;
1325         }
1326
1327         if (evt_dat->len > job->request_payload.payload_len) {
1328                 evt_dat->len = job->request_payload.payload_len;
1329                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1330                                 "2618 Truncated event data at %d "
1331                                 "bytes\n",
1332                                 job->request_payload.payload_len);
1333         }
1334
1335         event_reply->type = evt_dat->type;
1336         event_reply->immed_data = evt_dat->immed_dat;
1337         if (evt_dat->len > 0)
1338                 job->reply->reply_payload_rcv_len =
1339                         sg_copy_from_buffer(job->request_payload.sg_list,
1340                                             job->request_payload.sg_cnt,
1341                                             evt_dat->data, evt_dat->len);
1342         else
1343                 job->reply->reply_payload_rcv_len = 0;
1344
1345         if (evt_dat) {
1346                 kfree(evt_dat->data);
1347                 kfree(evt_dat);
1348         }
1349
1350         spin_lock_irqsave(&phba->ct_ev_lock, flags);
1351         lpfc_bsg_event_unref(evt);
1352         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1353         job->dd_data = NULL;
1354         job->reply->result = 0;
1355         job->job_done(job);
1356         return 0;
1357
1358 job_error:
1359         job->dd_data = NULL;
1360         job->reply->result = rc;
1361         return rc;
1362 }
1363
1364 /**
1365  * lpfc_issue_ct_rsp_cmp - lpfc_issue_ct_rsp's completion handler
1366  * @phba: Pointer to HBA context object.
1367  * @cmdiocbq: Pointer to command iocb.
1368  * @rspiocbq: Pointer to response iocb.
1369  *
1370  * This function is the completion handler for iocbs issued using
1371  * lpfc_issue_ct_rsp_cmp function. This function is called by the
1372  * ring event handler function without any lock held. This function
1373  * can be called from both worker thread context and interrupt
1374  * context. This function also can be called from other thread which
1375  * cleans up the SLI layer objects.
1376  * This function copy the contents of the response iocb to the
1377  * response iocb memory object provided by the caller of
1378  * lpfc_sli_issue_iocb_wait and then wakes up the thread which
1379  * sleeps for the iocb completion.
1380  **/
1381 static void
1382 lpfc_issue_ct_rsp_cmp(struct lpfc_hba *phba,
1383                         struct lpfc_iocbq *cmdiocbq,
1384                         struct lpfc_iocbq *rspiocbq)
1385 {
1386         struct bsg_job_data *dd_data;
1387         struct fc_bsg_job *job;
1388         IOCB_t *rsp;
1389         struct lpfc_dmabuf *bmp, *cmp;
1390         struct lpfc_nodelist *ndlp;
1391         unsigned long flags;
1392         int rc = 0;
1393
1394         dd_data = cmdiocbq->context1;
1395
1396         /* Determine if job has been aborted */
1397         spin_lock_irqsave(&phba->ct_ev_lock, flags);
1398         job = dd_data->set_job;
1399         if (job) {
1400                 /* Prevent timeout handling from trying to abort job  */
1401                 job->dd_data = NULL;
1402         }
1403         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1404
1405         /* Close the timeout handler abort window */
1406         spin_lock_irqsave(&phba->hbalock, flags);
1407         cmdiocbq->iocb_flag &= ~LPFC_IO_CMD_OUTSTANDING;
1408         spin_unlock_irqrestore(&phba->hbalock, flags);
1409
1410         ndlp = dd_data->context_un.iocb.ndlp;
1411         cmp = cmdiocbq->context2;
1412         bmp = cmdiocbq->context3;
1413         rsp = &rspiocbq->iocb;
1414
1415         /* Copy the completed job data or set the error status */
1416
1417         if (job) {
1418                 if (rsp->ulpStatus) {
1419                         if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
1420                                 switch (rsp->un.ulpWord[4] & IOERR_PARAM_MASK) {
1421                                 case IOERR_SEQUENCE_TIMEOUT:
1422                                         rc = -ETIMEDOUT;
1423                                         break;
1424                                 case IOERR_INVALID_RPI:
1425                                         rc = -EFAULT;
1426                                         break;
1427                                 default:
1428                                         rc = -EACCES;
1429                                         break;
1430                                 }
1431                         } else {
1432                                 rc = -EACCES;
1433                         }
1434                 } else {
1435                         job->reply->reply_payload_rcv_len = 0;
1436                 }
1437         }
1438
1439         lpfc_free_bsg_buffers(phba, cmp);
1440         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1441         kfree(bmp);
1442         lpfc_sli_release_iocbq(phba, cmdiocbq);
1443         lpfc_nlp_put(ndlp);
1444         kfree(dd_data);
1445
1446         /* Complete the job if the job is still active */
1447
1448         if (job) {
1449                 job->reply->result = rc;
1450                 job->job_done(job);
1451         }
1452         return;
1453 }
1454
1455 /**
1456  * lpfc_issue_ct_rsp - issue a ct response
1457  * @phba: Pointer to HBA context object.
1458  * @job: Pointer to the job object.
1459  * @tag: tag index value into the ports context exchange array.
1460  * @bmp: Pointer to a dma buffer descriptor.
1461  * @num_entry: Number of enties in the bde.
1462  **/
1463 static int
1464 lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
1465                   struct lpfc_dmabuf *cmp, struct lpfc_dmabuf *bmp,
1466                   int num_entry)
1467 {
1468         IOCB_t *icmd;
1469         struct lpfc_iocbq *ctiocb = NULL;
1470         int rc = 0;
1471         struct lpfc_nodelist *ndlp = NULL;
1472         struct bsg_job_data *dd_data;
1473         unsigned long flags;
1474         uint32_t creg_val;
1475
1476         /* allocate our bsg tracking structure */
1477         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
1478         if (!dd_data) {
1479                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1480                                 "2736 Failed allocation of dd_data\n");
1481                 rc = -ENOMEM;
1482                 goto no_dd_data;
1483         }
1484
1485         /* Allocate buffer for  command iocb */
1486         ctiocb = lpfc_sli_get_iocbq(phba);
1487         if (!ctiocb) {
1488                 rc = -ENOMEM;
1489                 goto no_ctiocb;
1490         }
1491
1492         icmd = &ctiocb->iocb;
1493         icmd->un.xseq64.bdl.ulpIoTag32 = 0;
1494         icmd->un.xseq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
1495         icmd->un.xseq64.bdl.addrLow = putPaddrLow(bmp->phys);
1496         icmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
1497         icmd->un.xseq64.bdl.bdeSize = (num_entry * sizeof(struct ulp_bde64));
1498         icmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
1499         icmd->un.xseq64.w5.hcsw.Dfctl = 0;
1500         icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_SOL_CTL;
1501         icmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
1502
1503         /* Fill in rest of iocb */
1504         icmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
1505         icmd->ulpBdeCount = 1;
1506         icmd->ulpLe = 1;
1507         icmd->ulpClass = CLASS3;
1508         if (phba->sli_rev == LPFC_SLI_REV4) {
1509                 /* Do not issue unsol response if oxid not marked as valid */
1510                 if (phba->ct_ctx[tag].valid != UNSOL_VALID) {
1511                         rc = IOCB_ERROR;
1512                         goto issue_ct_rsp_exit;
1513                 }
1514                 icmd->ulpContext = phba->ct_ctx[tag].rxid;
1515                 icmd->unsli3.rcvsli3.ox_id = phba->ct_ctx[tag].oxid;
1516                 ndlp = lpfc_findnode_did(phba->pport, phba->ct_ctx[tag].SID);
1517                 if (!ndlp) {
1518                         lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
1519                                  "2721 ndlp null for oxid %x SID %x\n",
1520                                         icmd->ulpContext,
1521                                         phba->ct_ctx[tag].SID);
1522                         rc = IOCB_ERROR;
1523                         goto issue_ct_rsp_exit;
1524                 }
1525
1526                 /* Check if the ndlp is active */
1527                 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
1528                         rc = IOCB_ERROR;
1529                         goto issue_ct_rsp_exit;
1530                 }
1531
1532                 /* get a refernece count so the ndlp doesn't go away while
1533                  * we respond
1534                  */
1535                 if (!lpfc_nlp_get(ndlp)) {
1536                         rc = IOCB_ERROR;
1537                         goto issue_ct_rsp_exit;
1538                 }
1539
1540                 icmd->un.ulpWord[3] =
1541                                 phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
1542
1543                 /* The exchange is done, mark the entry as invalid */
1544                 phba->ct_ctx[tag].valid = UNSOL_INVALID;
1545         } else
1546                 icmd->ulpContext = (ushort) tag;
1547
1548         icmd->ulpTimeout = phba->fc_ratov * 2;
1549
1550         /* Xmit CT response on exchange <xid> */
1551         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1552                 "2722 Xmit CT response on exchange x%x Data: x%x x%x x%x\n",
1553                 icmd->ulpContext, icmd->ulpIoTag, tag, phba->link_state);
1554
1555         ctiocb->iocb_cmpl = NULL;
1556         ctiocb->iocb_flag |= LPFC_IO_LIBDFC;
1557         ctiocb->vport = phba->pport;
1558         ctiocb->context1 = dd_data;
1559         ctiocb->context2 = cmp;
1560         ctiocb->context3 = bmp;
1561         ctiocb->context_un.ndlp = ndlp;
1562         ctiocb->iocb_cmpl = lpfc_issue_ct_rsp_cmp;
1563
1564         dd_data->type = TYPE_IOCB;
1565         dd_data->set_job = job;
1566         dd_data->context_un.iocb.cmdiocbq = ctiocb;
1567         dd_data->context_un.iocb.ndlp = ndlp;
1568         dd_data->context_un.iocb.rmp = NULL;
1569         job->dd_data = dd_data;
1570
1571         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
1572                 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1573                         rc = -IOCB_ERROR;
1574                         goto issue_ct_rsp_exit;
1575                 }
1576                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
1577                 writel(creg_val, phba->HCregaddr);
1578                 readl(phba->HCregaddr); /* flush */
1579         }
1580
1581         rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, ctiocb, 0);
1582
1583         if (rc == IOCB_SUCCESS) {
1584                 spin_lock_irqsave(&phba->hbalock, flags);
1585                 /* make sure the I/O had not been completed/released */
1586                 if (ctiocb->iocb_flag & LPFC_IO_LIBDFC) {
1587                         /* open up abort window to timeout handler */
1588                         ctiocb->iocb_flag |= LPFC_IO_CMD_OUTSTANDING;
1589                 }
1590                 spin_unlock_irqrestore(&phba->hbalock, flags);
1591                 return 0; /* done for now */
1592         }
1593
1594         /* iocb failed so cleanup */
1595         job->dd_data = NULL;
1596
1597 issue_ct_rsp_exit:
1598         lpfc_sli_release_iocbq(phba, ctiocb);
1599 no_ctiocb:
1600         kfree(dd_data);
1601 no_dd_data:
1602         return rc;
1603 }
1604
1605 /**
1606  * lpfc_bsg_send_mgmt_rsp - process a SEND_MGMT_RESP bsg vendor command
1607  * @job: SEND_MGMT_RESP fc_bsg_job
1608  **/
1609 static int
1610 lpfc_bsg_send_mgmt_rsp(struct fc_bsg_job *job)
1611 {
1612         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
1613         struct lpfc_hba *phba = vport->phba;
1614         struct send_mgmt_resp *mgmt_resp = (struct send_mgmt_resp *)
1615                 job->request->rqst_data.h_vendor.vendor_cmd;
1616         struct ulp_bde64 *bpl;
1617         struct lpfc_dmabuf *bmp = NULL, *cmp = NULL;
1618         int bpl_entries;
1619         uint32_t tag = mgmt_resp->tag;
1620         unsigned long reqbfrcnt =
1621                         (unsigned long)job->request_payload.payload_len;
1622         int rc = 0;
1623
1624         /* in case no data is transferred */
1625         job->reply->reply_payload_rcv_len = 0;
1626
1627         if (!reqbfrcnt || (reqbfrcnt > (80 * BUF_SZ_4K))) {
1628                 rc = -ERANGE;
1629                 goto send_mgmt_rsp_exit;
1630         }
1631
1632         bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1633         if (!bmp) {
1634                 rc = -ENOMEM;
1635                 goto send_mgmt_rsp_exit;
1636         }
1637
1638         bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
1639         if (!bmp->virt) {
1640                 rc = -ENOMEM;
1641                 goto send_mgmt_rsp_free_bmp;
1642         }
1643
1644         INIT_LIST_HEAD(&bmp->list);
1645         bpl = (struct ulp_bde64 *) bmp->virt;
1646         bpl_entries = (LPFC_BPL_SIZE/sizeof(struct ulp_bde64));
1647         cmp = lpfc_alloc_bsg_buffers(phba, job->request_payload.payload_len,
1648                                      1, bpl, &bpl_entries);
1649         if (!cmp) {
1650                 rc = -ENOMEM;
1651                 goto send_mgmt_rsp_free_bmp;
1652         }
1653         lpfc_bsg_copy_data(cmp, &job->request_payload,
1654                            job->request_payload.payload_len, 1);
1655
1656         rc = lpfc_issue_ct_rsp(phba, job, tag, cmp, bmp, bpl_entries);
1657
1658         if (rc == IOCB_SUCCESS)
1659                 return 0; /* done for now */
1660
1661         rc = -EACCES;
1662
1663         lpfc_free_bsg_buffers(phba, cmp);
1664
1665 send_mgmt_rsp_free_bmp:
1666         if (bmp->virt)
1667                 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1668         kfree(bmp);
1669 send_mgmt_rsp_exit:
1670         /* make error code available to userspace */
1671         job->reply->result = rc;
1672         job->dd_data = NULL;
1673         return rc;
1674 }
1675
1676 /**
1677  * lpfc_bsg_diag_mode_enter - process preparing into device diag loopback mode
1678  * @phba: Pointer to HBA context object.
1679  *
1680  * This function is responsible for preparing driver for diag loopback
1681  * on device.
1682  */
1683 static int
1684 lpfc_bsg_diag_mode_enter(struct lpfc_hba *phba)
1685 {
1686         struct lpfc_vport **vports;
1687         struct Scsi_Host *shost;
1688         struct lpfc_sli *psli;
1689         struct lpfc_sli_ring *pring;
1690         int i = 0;
1691
1692         psli = &phba->sli;
1693         if (!psli)
1694                 return -ENODEV;
1695
1696         pring = &psli->ring[LPFC_FCP_RING];
1697         if (!pring)
1698                 return -ENODEV;
1699
1700         if ((phba->link_state == LPFC_HBA_ERROR) ||
1701             (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
1702             (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
1703                 return -EACCES;
1704
1705         vports = lpfc_create_vport_work_array(phba);
1706         if (vports) {
1707                 for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1708                         shost = lpfc_shost_from_vport(vports[i]);
1709                         scsi_block_requests(shost);
1710                 }
1711                 lpfc_destroy_vport_work_array(phba, vports);
1712         } else {
1713                 shost = lpfc_shost_from_vport(phba->pport);
1714                 scsi_block_requests(shost);
1715         }
1716
1717         while (!list_empty(&pring->txcmplq)) {
1718                 if (i++ > 500)  /* wait up to 5 seconds */
1719                         break;
1720                 msleep(10);
1721         }
1722         return 0;
1723 }
1724
1725 /**
1726  * lpfc_bsg_diag_mode_exit - exit process from device diag loopback mode
1727  * @phba: Pointer to HBA context object.
1728  *
1729  * This function is responsible for driver exit processing of setting up
1730  * diag loopback mode on device.
1731  */
1732 static void
1733 lpfc_bsg_diag_mode_exit(struct lpfc_hba *phba)
1734 {
1735         struct Scsi_Host *shost;
1736         struct lpfc_vport **vports;
1737         int i;
1738
1739         vports = lpfc_create_vport_work_array(phba);
1740         if (vports) {
1741                 for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1742                         shost = lpfc_shost_from_vport(vports[i]);
1743                         scsi_unblock_requests(shost);
1744                 }
1745                 lpfc_destroy_vport_work_array(phba, vports);
1746         } else {
1747                 shost = lpfc_shost_from_vport(phba->pport);
1748                 scsi_unblock_requests(shost);
1749         }
1750         return;
1751 }
1752
1753 /**
1754  * lpfc_sli3_bsg_diag_loopback_mode - process an sli3 bsg vendor command
1755  * @phba: Pointer to HBA context object.
1756  * @job: LPFC_BSG_VENDOR_DIAG_MODE
1757  *
1758  * This function is responsible for placing an sli3  port into diagnostic
1759  * loopback mode in order to perform a diagnostic loopback test.
1760  * All new scsi requests are blocked, a small delay is used to allow the
1761  * scsi requests to complete then the link is brought down. If the link is
1762  * is placed in loopback mode then scsi requests are again allowed
1763  * so the scsi mid-layer doesn't give up on the port.
1764  * All of this is done in-line.
1765  */
1766 static int
1767 lpfc_sli3_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
1768 {
1769         struct diag_mode_set *loopback_mode;
1770         uint32_t link_flags;
1771         uint32_t timeout;
1772         LPFC_MBOXQ_t *pmboxq  = NULL;
1773         int mbxstatus = MBX_SUCCESS;
1774         int i = 0;
1775         int rc = 0;
1776
1777         /* no data to return just the return code */
1778         job->reply->reply_payload_rcv_len = 0;
1779
1780         if (job->request_len < sizeof(struct fc_bsg_request) +
1781             sizeof(struct diag_mode_set)) {
1782                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1783                                 "2738 Received DIAG MODE request size:%d "
1784                                 "below the minimum size:%d\n",
1785                                 job->request_len,
1786                                 (int)(sizeof(struct fc_bsg_request) +
1787                                 sizeof(struct diag_mode_set)));
1788                 rc = -EINVAL;
1789                 goto job_error;
1790         }
1791
1792         rc = lpfc_bsg_diag_mode_enter(phba);
1793         if (rc)
1794                 goto job_error;
1795
1796         /* bring the link to diagnostic mode */
1797         loopback_mode = (struct diag_mode_set *)
1798                 job->request->rqst_data.h_vendor.vendor_cmd;
1799         link_flags = loopback_mode->type;
1800         timeout = loopback_mode->timeout * 100;
1801
1802         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1803         if (!pmboxq) {
1804                 rc = -ENOMEM;
1805                 goto loopback_mode_exit;
1806         }
1807         memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
1808         pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
1809         pmboxq->u.mb.mbxOwner = OWN_HOST;
1810
1811         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
1812
1813         if ((mbxstatus == MBX_SUCCESS) && (pmboxq->u.mb.mbxStatus == 0)) {
1814                 /* wait for link down before proceeding */
1815                 i = 0;
1816                 while (phba->link_state != LPFC_LINK_DOWN) {
1817                         if (i++ > timeout) {
1818                                 rc = -ETIMEDOUT;
1819                                 goto loopback_mode_exit;
1820                         }
1821                         msleep(10);
1822                 }
1823
1824                 memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
1825                 if (link_flags == INTERNAL_LOOP_BACK)
1826                         pmboxq->u.mb.un.varInitLnk.link_flags = FLAGS_LOCAL_LB;
1827                 else
1828                         pmboxq->u.mb.un.varInitLnk.link_flags =
1829                                 FLAGS_TOPOLOGY_MODE_LOOP;
1830
1831                 pmboxq->u.mb.mbxCommand = MBX_INIT_LINK;
1832                 pmboxq->u.mb.mbxOwner = OWN_HOST;
1833
1834                 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
1835                                                      LPFC_MBOX_TMO);
1836
1837                 if ((mbxstatus != MBX_SUCCESS) || (pmboxq->u.mb.mbxStatus))
1838                         rc = -ENODEV;
1839                 else {
1840                         spin_lock_irq(&phba->hbalock);
1841                         phba->link_flag |= LS_LOOPBACK_MODE;
1842                         spin_unlock_irq(&phba->hbalock);
1843                         /* wait for the link attention interrupt */
1844                         msleep(100);
1845
1846                         i = 0;
1847                         while (phba->link_state != LPFC_HBA_READY) {
1848                                 if (i++ > timeout) {
1849                                         rc = -ETIMEDOUT;
1850                                         break;
1851                                 }
1852
1853                                 msleep(10);
1854                         }
1855                 }
1856
1857         } else
1858                 rc = -ENODEV;
1859
1860 loopback_mode_exit:
1861         lpfc_bsg_diag_mode_exit(phba);
1862
1863         /*
1864          * Let SLI layer release mboxq if mbox command completed after timeout.
1865          */
1866         if (pmboxq && mbxstatus != MBX_TIMEOUT)
1867                 mempool_free(pmboxq, phba->mbox_mem_pool);
1868
1869 job_error:
1870         /* make error code available to userspace */
1871         job->reply->result = rc;
1872         /* complete the job back to userspace if no error */
1873         if (rc == 0)
1874                 job->job_done(job);
1875         return rc;
1876 }
1877
1878 /**
1879  * lpfc_sli4_bsg_set_link_diag_state - set sli4 link diag state
1880  * @phba: Pointer to HBA context object.
1881  * @diag: Flag for set link to diag or nomral operation state.
1882  *
1883  * This function is responsible for issuing a sli4 mailbox command for setting
1884  * link to either diag state or normal operation state.
1885  */
1886 static int
1887 lpfc_sli4_bsg_set_link_diag_state(struct lpfc_hba *phba, uint32_t diag)
1888 {
1889         LPFC_MBOXQ_t *pmboxq;
1890         struct lpfc_mbx_set_link_diag_state *link_diag_state;
1891         uint32_t req_len, alloc_len;
1892         int mbxstatus = MBX_SUCCESS, rc;
1893
1894         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1895         if (!pmboxq)
1896                 return -ENOMEM;
1897
1898         req_len = (sizeof(struct lpfc_mbx_set_link_diag_state) -
1899                    sizeof(struct lpfc_sli4_cfg_mhdr));
1900         alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
1901                                 LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,
1902                                 req_len, LPFC_SLI4_MBX_EMBED);
1903         if (alloc_len != req_len) {
1904                 rc = -ENOMEM;
1905                 goto link_diag_state_set_out;
1906         }
1907         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
1908                         "3128 Set link to diagnostic state:x%x (x%x/x%x)\n",
1909                         diag, phba->sli4_hba.lnk_info.lnk_tp,
1910                         phba->sli4_hba.lnk_info.lnk_no);
1911
1912         link_diag_state = &pmboxq->u.mqe.un.link_diag_state;
1913         bf_set(lpfc_mbx_set_diag_state_diag_bit_valid, &link_diag_state->u.req,
1914                LPFC_DIAG_STATE_DIAG_BIT_VALID_CHANGE);
1915         bf_set(lpfc_mbx_set_diag_state_link_num, &link_diag_state->u.req,
1916                phba->sli4_hba.lnk_info.lnk_no);
1917         bf_set(lpfc_mbx_set_diag_state_link_type, &link_diag_state->u.req,
1918                phba->sli4_hba.lnk_info.lnk_tp);
1919         if (diag)
1920                 bf_set(lpfc_mbx_set_diag_state_diag,
1921                        &link_diag_state->u.req, 1);
1922         else
1923                 bf_set(lpfc_mbx_set_diag_state_diag,
1924                        &link_diag_state->u.req, 0);
1925
1926         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
1927
1928         if ((mbxstatus == MBX_SUCCESS) && (pmboxq->u.mb.mbxStatus == 0))
1929                 rc = 0;
1930         else
1931                 rc = -ENODEV;
1932
1933 link_diag_state_set_out:
1934         if (pmboxq && (mbxstatus != MBX_TIMEOUT))
1935                 mempool_free(pmboxq, phba->mbox_mem_pool);
1936
1937         return rc;
1938 }
1939
1940 /**
1941  * lpfc_sli4_bsg_set_internal_loopback - set sli4 internal loopback diagnostic
1942  * @phba: Pointer to HBA context object.
1943  *
1944  * This function is responsible for issuing a sli4 mailbox command for setting
1945  * up internal loopback diagnostic.
1946  */
1947 static int
1948 lpfc_sli4_bsg_set_internal_loopback(struct lpfc_hba *phba)
1949 {
1950         LPFC_MBOXQ_t *pmboxq;
1951         uint32_t req_len, alloc_len;
1952         struct lpfc_mbx_set_link_diag_loopback *link_diag_loopback;
1953         int mbxstatus = MBX_SUCCESS, rc = 0;
1954
1955         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1956         if (!pmboxq)
1957                 return -ENOMEM;
1958         req_len = (sizeof(struct lpfc_mbx_set_link_diag_loopback) -
1959                    sizeof(struct lpfc_sli4_cfg_mhdr));
1960         alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
1961                                 LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_LOOPBACK,
1962                                 req_len, LPFC_SLI4_MBX_EMBED);
1963         if (alloc_len != req_len) {
1964                 mempool_free(pmboxq, phba->mbox_mem_pool);
1965                 return -ENOMEM;
1966         }
1967         link_diag_loopback = &pmboxq->u.mqe.un.link_diag_loopback;
1968         bf_set(lpfc_mbx_set_diag_state_link_num,
1969                &link_diag_loopback->u.req, phba->sli4_hba.lnk_info.lnk_no);
1970         bf_set(lpfc_mbx_set_diag_state_link_type,
1971                &link_diag_loopback->u.req, phba->sli4_hba.lnk_info.lnk_tp);
1972         bf_set(lpfc_mbx_set_diag_lpbk_type, &link_diag_loopback->u.req,
1973                LPFC_DIAG_LOOPBACK_TYPE_INTERNAL);
1974
1975         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
1976         if ((mbxstatus != MBX_SUCCESS) || (pmboxq->u.mb.mbxStatus)) {
1977                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1978                                 "3127 Failed setup loopback mode mailbox "
1979                                 "command, rc:x%x, status:x%x\n", mbxstatus,
1980                                 pmboxq->u.mb.mbxStatus);
1981                 rc = -ENODEV;
1982         }
1983         if (pmboxq && (mbxstatus != MBX_TIMEOUT))
1984                 mempool_free(pmboxq, phba->mbox_mem_pool);
1985         return rc;
1986 }
1987
1988 /**
1989  * lpfc_sli4_diag_fcport_reg_setup - setup port registrations for diagnostic
1990  * @phba: Pointer to HBA context object.
1991  *
1992  * This function set up SLI4 FC port registrations for diagnostic run, which
1993  * includes all the rpis, vfi, and also vpi.
1994  */
1995 static int
1996 lpfc_sli4_diag_fcport_reg_setup(struct lpfc_hba *phba)
1997 {
1998         int rc;
1999
2000         if (phba->pport->fc_flag & FC_VFI_REGISTERED) {
2001                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2002                                 "3136 Port still had vfi registered: "
2003                                 "mydid:x%x, fcfi:%d, vfi:%d, vpi:%d\n",
2004                                 phba->pport->fc_myDID, phba->fcf.fcfi,
2005                                 phba->sli4_hba.vfi_ids[phba->pport->vfi],
2006                                 phba->vpi_ids[phba->pport->vpi]);
2007                 return -EINVAL;
2008         }
2009         rc = lpfc_issue_reg_vfi(phba->pport);
2010         return rc;
2011 }
2012
2013 /**
2014  * lpfc_sli4_bsg_diag_loopback_mode - process an sli4 bsg vendor command
2015  * @phba: Pointer to HBA context object.
2016  * @job: LPFC_BSG_VENDOR_DIAG_MODE
2017  *
2018  * This function is responsible for placing an sli4 port into diagnostic
2019  * loopback mode in order to perform a diagnostic loopback test.
2020  */
2021 static int
2022 lpfc_sli4_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
2023 {
2024         struct diag_mode_set *loopback_mode;
2025         uint32_t link_flags, timeout;
2026         int i, rc = 0;
2027
2028         /* no data to return just the return code */
2029         job->reply->reply_payload_rcv_len = 0;
2030
2031         if (job->request_len < sizeof(struct fc_bsg_request) +
2032             sizeof(struct diag_mode_set)) {
2033                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2034                                 "3011 Received DIAG MODE request size:%d "
2035                                 "below the minimum size:%d\n",
2036                                 job->request_len,
2037                                 (int)(sizeof(struct fc_bsg_request) +
2038                                 sizeof(struct diag_mode_set)));
2039                 rc = -EINVAL;
2040                 goto job_error;
2041         }
2042
2043         rc = lpfc_bsg_diag_mode_enter(phba);
2044         if (rc)
2045                 goto job_error;
2046
2047         /* indicate we are in loobpack diagnostic mode */
2048         spin_lock_irq(&phba->hbalock);
2049         phba->link_flag |= LS_LOOPBACK_MODE;
2050         spin_unlock_irq(&phba->hbalock);
2051
2052         /* reset port to start frome scratch */
2053         rc = lpfc_selective_reset(phba);
2054         if (rc)
2055                 goto job_error;
2056
2057         /* bring the link to diagnostic mode */
2058         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
2059                         "3129 Bring link to diagnostic state.\n");
2060         loopback_mode = (struct diag_mode_set *)
2061                 job->request->rqst_data.h_vendor.vendor_cmd;
2062         link_flags = loopback_mode->type;
2063         timeout = loopback_mode->timeout * 100;
2064
2065         rc = lpfc_sli4_bsg_set_link_diag_state(phba, 1);
2066         if (rc) {
2067                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2068                                 "3130 Failed to bring link to diagnostic "
2069                                 "state, rc:x%x\n", rc);
2070                 goto loopback_mode_exit;
2071         }
2072
2073         /* wait for link down before proceeding */
2074         i = 0;
2075         while (phba->link_state != LPFC_LINK_DOWN) {
2076                 if (i++ > timeout) {
2077                         rc = -ETIMEDOUT;
2078                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
2079                                         "3131 Timeout waiting for link to "
2080                                         "diagnostic mode, timeout:%d ms\n",
2081                                         timeout * 10);
2082                         goto loopback_mode_exit;
2083                 }
2084                 msleep(10);
2085         }
2086
2087         /* set up loopback mode */
2088         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
2089                         "3132 Set up loopback mode:x%x\n", link_flags);
2090
2091         if (link_flags == INTERNAL_LOOP_BACK)
2092                 rc = lpfc_sli4_bsg_set_internal_loopback(phba);
2093         else if (link_flags == EXTERNAL_LOOP_BACK)
2094                 rc = lpfc_hba_init_link_fc_topology(phba,
2095                                                     FLAGS_TOPOLOGY_MODE_PT_PT,
2096                                                     MBX_NOWAIT);
2097         else {
2098                 rc = -EINVAL;
2099                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
2100                                 "3141 Loopback mode:x%x not supported\n",
2101                                 link_flags);
2102                 goto loopback_mode_exit;
2103         }
2104
2105         if (!rc) {
2106                 /* wait for the link attention interrupt */
2107                 msleep(100);
2108                 i = 0;
2109                 while (phba->link_state < LPFC_LINK_UP) {
2110                         if (i++ > timeout) {
2111                                 rc = -ETIMEDOUT;
2112                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
2113                                         "3137 Timeout waiting for link up "
2114                                         "in loopback mode, timeout:%d ms\n",
2115                                         timeout * 10);
2116                                 break;
2117                         }
2118                         msleep(10);
2119                 }
2120         }
2121
2122         /* port resource registration setup for loopback diagnostic */
2123         if (!rc) {
2124                 /* set up a none zero myDID for loopback test */
2125                 phba->pport->fc_myDID = 1;
2126                 rc = lpfc_sli4_diag_fcport_reg_setup(phba);
2127         } else
2128                 goto loopback_mode_exit;
2129
2130         if (!rc) {
2131                 /* wait for the port ready */
2132                 msleep(100);
2133                 i = 0;
2134                 while (phba->link_state != LPFC_HBA_READY) {
2135                         if (i++ > timeout) {
2136                                 rc = -ETIMEDOUT;
2137                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
2138                                         "3133 Timeout waiting for port "
2139                                         "loopback mode ready, timeout:%d ms\n",
2140                                         timeout * 10);
2141                                 break;
2142                         }
2143                         msleep(10);
2144                 }
2145         }
2146
2147 loopback_mode_exit:
2148         /* clear loopback diagnostic mode */
2149         if (rc) {
2150                 spin_lock_irq(&phba->hbalock);
2151                 phba->link_flag &= ~LS_LOOPBACK_MODE;
2152                 spin_unlock_irq(&phba->hbalock);
2153         }
2154         lpfc_bsg_diag_mode_exit(phba);
2155
2156 job_error:
2157         /* make error code available to userspace */
2158         job->reply->result = rc;
2159         /* complete the job back to userspace if no error */
2160         if (rc == 0)
2161                 job->job_done(job);
2162         return rc;
2163 }
2164
2165 /**
2166  * lpfc_bsg_diag_loopback_mode - bsg vendor command for diag loopback mode
2167  * @job: LPFC_BSG_VENDOR_DIAG_MODE
2168  *
2169  * This function is responsible for responding to check and dispatch bsg diag
2170  * command from the user to proper driver action routines.
2171  */
2172 static int
2173 lpfc_bsg_diag_loopback_mode(struct fc_bsg_job *job)
2174 {
2175         struct Scsi_Host *shost;
2176         struct lpfc_vport *vport;
2177         struct lpfc_hba *phba;
2178         int rc;
2179
2180         shost = job->shost;
2181         if (!shost)
2182                 return -ENODEV;
2183         vport = (struct lpfc_vport *)job->shost->hostdata;
2184         if (!vport)
2185                 return -ENODEV;
2186         phba = vport->phba;
2187         if (!phba)
2188                 return -ENODEV;
2189
2190         if (phba->sli_rev < LPFC_SLI_REV4)
2191                 rc = lpfc_sli3_bsg_diag_loopback_mode(phba, job);
2192         else if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
2193                  LPFC_SLI_INTF_IF_TYPE_2)
2194                 rc = lpfc_sli4_bsg_diag_loopback_mode(phba, job);
2195         else
2196                 rc = -ENODEV;
2197
2198         return rc;
2199 }
2200
2201 /**
2202  * lpfc_sli4_bsg_diag_mode_end - sli4 bsg vendor command for ending diag mode
2203  * @job: LPFC_BSG_VENDOR_DIAG_MODE_END
2204  *
2205  * This function is responsible for responding to check and dispatch bsg diag
2206  * command from the user to proper driver action routines.
2207  */
2208 static int
2209 lpfc_sli4_bsg_diag_mode_end(struct fc_bsg_job *job)
2210 {
2211         struct Scsi_Host *shost;
2212         struct lpfc_vport *vport;
2213         struct lpfc_hba *phba;
2214         struct diag_mode_set *loopback_mode_end_cmd;
2215         uint32_t timeout;
2216         int rc, i;
2217
2218         shost = job->shost;
2219         if (!shost)
2220                 return -ENODEV;
2221         vport = (struct lpfc_vport *)job->shost->hostdata;
2222         if (!vport)
2223                 return -ENODEV;
2224         phba = vport->phba;
2225         if (!phba)
2226                 return -ENODEV;
2227
2228         if (phba->sli_rev < LPFC_SLI_REV4)
2229                 return -ENODEV;
2230         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
2231             LPFC_SLI_INTF_IF_TYPE_2)
2232                 return -ENODEV;
2233
2234         /* clear loopback diagnostic mode */
2235         spin_lock_irq(&phba->hbalock);
2236         phba->link_flag &= ~LS_LOOPBACK_MODE;
2237         spin_unlock_irq(&phba->hbalock);
2238         loopback_mode_end_cmd = (struct diag_mode_set *)
2239                         job->request->rqst_data.h_vendor.vendor_cmd;
2240         timeout = loopback_mode_end_cmd->timeout * 100;
2241
2242         rc = lpfc_sli4_bsg_set_link_diag_state(phba, 0);
2243         if (rc) {
2244                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2245                                 "3139 Failed to bring link to diagnostic "
2246                                 "state, rc:x%x\n", rc);
2247                 goto loopback_mode_end_exit;
2248         }
2249
2250         /* wait for link down before proceeding */
2251         i = 0;
2252         while (phba->link_state != LPFC_LINK_DOWN) {
2253                 if (i++ > timeout) {
2254                         rc = -ETIMEDOUT;
2255                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
2256                                         "3140 Timeout waiting for link to "
2257                                         "diagnostic mode_end, timeout:%d ms\n",
2258                                         timeout * 10);
2259                         /* there is nothing much we can do here */
2260                         break;
2261                 }
2262                 msleep(10);
2263         }
2264
2265         /* reset port resource registrations */
2266         rc = lpfc_selective_reset(phba);
2267         phba->pport->fc_myDID = 0;
2268
2269 loopback_mode_end_exit:
2270         /* make return code available to userspace */
2271         job->reply->result = rc;
2272         /* complete the job back to userspace if no error */
2273         if (rc == 0)
2274                 job->job_done(job);
2275         return rc;
2276 }
2277
2278 /**
2279  * lpfc_sli4_bsg_link_diag_test - sli4 bsg vendor command for diag link test
2280  * @job: LPFC_BSG_VENDOR_DIAG_LINK_TEST
2281  *
2282  * This function is to perform SLI4 diag link test request from the user
2283  * applicaiton.
2284  */
2285 static int
2286 lpfc_sli4_bsg_link_diag_test(struct fc_bsg_job *job)
2287 {
2288         struct Scsi_Host *shost;
2289         struct lpfc_vport *vport;
2290         struct lpfc_hba *phba;
2291         LPFC_MBOXQ_t *pmboxq;
2292         struct sli4_link_diag *link_diag_test_cmd;
2293         uint32_t req_len, alloc_len;
2294         uint32_t timeout;
2295         struct lpfc_mbx_run_link_diag_test *run_link_diag_test;
2296         union lpfc_sli4_cfg_shdr *shdr;
2297         uint32_t shdr_status, shdr_add_status;
2298         struct diag_status *diag_status_reply;
2299         int mbxstatus, rc = 0;
2300
2301         shost = job->shost;
2302         if (!shost) {
2303                 rc = -ENODEV;
2304                 goto job_error;
2305         }
2306         vport = (struct lpfc_vport *)job->shost->hostdata;
2307         if (!vport) {
2308                 rc = -ENODEV;
2309                 goto job_error;
2310         }
2311         phba = vport->phba;
2312         if (!phba) {
2313                 rc = -ENODEV;
2314                 goto job_error;
2315         }
2316
2317         if (phba->sli_rev < LPFC_SLI_REV4) {
2318                 rc = -ENODEV;
2319                 goto job_error;
2320         }
2321         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
2322             LPFC_SLI_INTF_IF_TYPE_2) {
2323                 rc = -ENODEV;
2324                 goto job_error;
2325         }
2326
2327         if (job->request_len < sizeof(struct fc_bsg_request) +
2328             sizeof(struct sli4_link_diag)) {
2329                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2330                                 "3013 Received LINK DIAG TEST request "
2331                                 " size:%d below the minimum size:%d\n",
2332                                 job->request_len,
2333                                 (int)(sizeof(struct fc_bsg_request) +
2334                                 sizeof(struct sli4_link_diag)));
2335                 rc = -EINVAL;
2336                 goto job_error;
2337         }
2338
2339         rc = lpfc_bsg_diag_mode_enter(phba);
2340         if (rc)
2341                 goto job_error;
2342
2343         link_diag_test_cmd = (struct sli4_link_diag *)
2344                          job->request->rqst_data.h_vendor.vendor_cmd;
2345         timeout = link_diag_test_cmd->timeout * 100;
2346
2347         rc = lpfc_sli4_bsg_set_link_diag_state(phba, 1);
2348
2349         if (rc)
2350                 goto job_error;
2351
2352         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2353         if (!pmboxq) {
2354                 rc = -ENOMEM;
2355                 goto link_diag_test_exit;
2356         }
2357
2358         req_len = (sizeof(struct lpfc_mbx_set_link_diag_state) -
2359                    sizeof(struct lpfc_sli4_cfg_mhdr));
2360         alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
2361                                      LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,
2362                                      req_len, LPFC_SLI4_MBX_EMBED);
2363         if (alloc_len != req_len) {
2364                 rc = -ENOMEM;
2365                 goto link_diag_test_exit;
2366         }
2367         run_link_diag_test = &pmboxq->u.mqe.un.link_diag_test;
2368         bf_set(lpfc_mbx_run_diag_test_link_num, &run_link_diag_test->u.req,
2369                phba->sli4_hba.lnk_info.lnk_no);
2370         bf_set(lpfc_mbx_run_diag_test_link_type, &run_link_diag_test->u.req,
2371                phba->sli4_hba.lnk_info.lnk_tp);
2372         bf_set(lpfc_mbx_run_diag_test_test_id, &run_link_diag_test->u.req,
2373                link_diag_test_cmd->test_id);
2374         bf_set(lpfc_mbx_run_diag_test_loops, &run_link_diag_test->u.req,
2375                link_diag_test_cmd->loops);
2376         bf_set(lpfc_mbx_run_diag_test_test_ver, &run_link_diag_test->u.req,
2377                link_diag_test_cmd->test_version);
2378         bf_set(lpfc_mbx_run_diag_test_err_act, &run_link_diag_test->u.req,
2379                link_diag_test_cmd->error_action);
2380
2381         mbxstatus = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2382
2383         shdr = (union lpfc_sli4_cfg_shdr *)
2384                 &pmboxq->u.mqe.un.sli4_config.header.cfg_shdr;
2385         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
2386         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
2387         if (shdr_status || shdr_add_status || mbxstatus) {
2388                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
2389                                 "3010 Run link diag test mailbox failed with "
2390                                 "mbx_status x%x status x%x, add_status x%x\n",
2391                                 mbxstatus, shdr_status, shdr_add_status);
2392         }
2393
2394         diag_status_reply = (struct diag_status *)
2395                             job->reply->reply_data.vendor_reply.vendor_rsp;
2396
2397         if (job->reply_len <
2398             sizeof(struct fc_bsg_request) + sizeof(struct diag_status)) {
2399                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2400                                 "3012 Received Run link diag test reply "
2401                                 "below minimum size (%d): reply_len:%d\n",
2402                                 (int)(sizeof(struct fc_bsg_request) +
2403                                 sizeof(struct diag_status)),
2404                                 job->reply_len);
2405                 rc = -EINVAL;
2406                 goto job_error;
2407         }
2408
2409         diag_status_reply->mbox_status = mbxstatus;
2410         diag_status_reply->shdr_status = shdr_status;
2411         diag_status_reply->shdr_add_status = shdr_add_status;
2412
2413 link_diag_test_exit:
2414         rc = lpfc_sli4_bsg_set_link_diag_state(phba, 0);
2415
2416         if (pmboxq)
2417                 mempool_free(pmboxq, phba->mbox_mem_pool);
2418
2419         lpfc_bsg_diag_mode_exit(phba);
2420
2421 job_error:
2422         /* make error code available to userspace */
2423         job->reply->result = rc;
2424         /* complete the job back to userspace if no error */
2425         if (rc == 0)
2426                 job->job_done(job);
2427         return rc;
2428 }
2429
2430 /**
2431  * lpfcdiag_loop_self_reg - obtains a remote port login id
2432  * @phba: Pointer to HBA context object
2433  * @rpi: Pointer to a remote port login id
2434  *
2435  * This function obtains a remote port login id so the diag loopback test
2436  * can send and receive its own unsolicited CT command.
2437  **/
2438 static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t *rpi)
2439 {
2440         LPFC_MBOXQ_t *mbox;
2441         struct lpfc_dmabuf *dmabuff;
2442         int status;
2443
2444         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2445         if (!mbox)
2446                 return -ENOMEM;
2447
2448         if (phba->sli_rev < LPFC_SLI_REV4)
2449                 status = lpfc_reg_rpi(phba, 0, phba->pport->fc_myDID,
2450                                 (uint8_t *)&phba->pport->fc_sparam,
2451                                 mbox, *rpi);
2452         else {
2453                 *rpi = lpfc_sli4_alloc_rpi(phba);
2454                 status = lpfc_reg_rpi(phba, phba->pport->vpi,
2455                                 phba->pport->fc_myDID,
2456                                 (uint8_t *)&phba->pport->fc_sparam,
2457                                 mbox, *rpi);
2458         }
2459
2460         if (status) {
2461                 mempool_free(mbox, phba->mbox_mem_pool);
2462                 if (phba->sli_rev == LPFC_SLI_REV4)
2463                         lpfc_sli4_free_rpi(phba, *rpi);
2464                 return -ENOMEM;
2465         }
2466
2467         dmabuff = (struct lpfc_dmabuf *) mbox->context1;
2468         mbox->context1 = NULL;
2469         mbox->context2 = NULL;
2470         status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
2471
2472         if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
2473                 lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
2474                 kfree(dmabuff);
2475                 if (status != MBX_TIMEOUT)
2476                         mempool_free(mbox, phba->mbox_mem_pool);
2477                 if (phba->sli_rev == LPFC_SLI_REV4)
2478                         lpfc_sli4_free_rpi(phba, *rpi);
2479                 return -ENODEV;
2480         }
2481
2482         if (phba->sli_rev < LPFC_SLI_REV4)
2483                 *rpi = mbox->u.mb.un.varWords[0];
2484
2485         lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
2486         kfree(dmabuff);
2487         mempool_free(mbox, phba->mbox_mem_pool);
2488         return 0;
2489 }
2490
2491 /**
2492  * lpfcdiag_loop_self_unreg - unregs from the rpi
2493  * @phba: Pointer to HBA context object
2494  * @rpi: Remote port login id
2495  *
2496  * This function unregisters the rpi obtained in lpfcdiag_loop_self_reg
2497  **/
2498 static int lpfcdiag_loop_self_unreg(struct lpfc_hba *phba, uint16_t rpi)
2499 {
2500         LPFC_MBOXQ_t *mbox;
2501         int status;
2502
2503         /* Allocate mboxq structure */
2504         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2505         if (mbox == NULL)
2506                 return -ENOMEM;
2507
2508         if (phba->sli_rev < LPFC_SLI_REV4)
2509                 lpfc_unreg_login(phba, 0, rpi, mbox);
2510         else
2511                 lpfc_unreg_login(phba, phba->pport->vpi,
2512                                  phba->sli4_hba.rpi_ids[rpi], mbox);
2513
2514         status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
2515
2516         if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
2517                 if (status != MBX_TIMEOUT)
2518                         mempool_free(mbox, phba->mbox_mem_pool);
2519                 return -EIO;
2520         }
2521         mempool_free(mbox, phba->mbox_mem_pool);
2522         if (phba->sli_rev == LPFC_SLI_REV4)
2523                 lpfc_sli4_free_rpi(phba, rpi);
2524         return 0;
2525 }
2526
2527 /**
2528  * lpfcdiag_loop_get_xri - obtains the transmit and receive ids
2529  * @phba: Pointer to HBA context object
2530  * @rpi: Remote port login id
2531  * @txxri: Pointer to transmit exchange id
2532  * @rxxri: Pointer to response exchabge id
2533  *
2534  * This function obtains the transmit and receive ids required to send
2535  * an unsolicited ct command with a payload. A special lpfc FsType and CmdRsp
2536  * flags are used to the unsolicted response handler is able to process
2537  * the ct command sent on the same port.
2538  **/
2539 static int lpfcdiag_loop_get_xri(struct lpfc_hba *phba, uint16_t rpi,
2540                          uint16_t *txxri, uint16_t * rxxri)
2541 {
2542         struct lpfc_bsg_event *evt;
2543         struct lpfc_iocbq *cmdiocbq, *rspiocbq;
2544         IOCB_t *cmd, *rsp;
2545         struct lpfc_dmabuf *dmabuf;
2546         struct ulp_bde64 *bpl = NULL;
2547         struct lpfc_sli_ct_request *ctreq = NULL;
2548         int ret_val = 0;
2549         int time_left;
2550         int iocb_stat = IOCB_SUCCESS;
2551         unsigned long flags;
2552
2553         *txxri = 0;
2554         *rxxri = 0;
2555         evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
2556                                 SLI_CT_ELX_LOOPBACK);
2557         if (!evt)
2558                 return -ENOMEM;
2559
2560         spin_lock_irqsave(&phba->ct_ev_lock, flags);
2561         list_add(&evt->node, &phba->ct_ev_waiters);
2562         lpfc_bsg_event_ref(evt);
2563         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
2564
2565         cmdiocbq = lpfc_sli_get_iocbq(phba);
2566         rspiocbq = lpfc_sli_get_iocbq(phba);
2567
2568         dmabuf = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2569         if (dmabuf) {
2570                 dmabuf->virt = lpfc_mbuf_alloc(phba, 0, &dmabuf->phys);
2571                 if (dmabuf->virt) {
2572                         INIT_LIST_HEAD(&dmabuf->list);
2573                         bpl = (struct ulp_bde64 *) dmabuf->virt;
2574                         memset(bpl, 0, sizeof(*bpl));
2575                         ctreq = (struct lpfc_sli_ct_request *)(bpl + 1);
2576                         bpl->addrHigh =
2577                                 le32_to_cpu(putPaddrHigh(dmabuf->phys +
2578                                         sizeof(*bpl)));
2579                         bpl->addrLow =
2580                                 le32_to_cpu(putPaddrLow(dmabuf->phys +
2581                                         sizeof(*bpl)));
2582                         bpl->tus.f.bdeFlags = 0;
2583                         bpl->tus.f.bdeSize = ELX_LOOPBACK_HEADER_SZ;
2584                         bpl->tus.w = le32_to_cpu(bpl->tus.w);
2585                 }
2586         }
2587
2588         if (cmdiocbq == NULL || rspiocbq == NULL ||
2589             dmabuf == NULL || bpl == NULL || ctreq == NULL ||
2590                 dmabuf->virt == NULL) {
2591                 ret_val = -ENOMEM;
2592                 goto err_get_xri_exit;
2593         }
2594
2595         cmd = &cmdiocbq->iocb;
2596         rsp = &rspiocbq->iocb;
2597
2598         memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
2599
2600         ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
2601         ctreq->RevisionId.bits.InId = 0;
2602         ctreq->FsType = SLI_CT_ELX_LOOPBACK;
2603         ctreq->FsSubType = 0;
2604         ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_XRI_SETUP;
2605         ctreq->CommandResponse.bits.Size = 0;
2606
2607
2608         cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(dmabuf->phys);
2609         cmd->un.xseq64.bdl.addrLow = putPaddrLow(dmabuf->phys);
2610         cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
2611         cmd->un.xseq64.bdl.bdeSize = sizeof(*bpl);
2612
2613         cmd->un.xseq64.w5.hcsw.Fctl = LA;
2614         cmd->un.xseq64.w5.hcsw.Dfctl = 0;
2615         cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
2616         cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
2617
2618         cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CR;
2619         cmd->ulpBdeCount = 1;
2620         cmd->ulpLe = 1;
2621         cmd->ulpClass = CLASS3;
2622         cmd->ulpContext = rpi;
2623
2624         cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
2625         cmdiocbq->vport = phba->pport;
2626         cmdiocbq->iocb_cmpl = NULL;
2627
2628         iocb_stat = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
2629                                 rspiocbq,
2630                                 (phba->fc_ratov * 2)
2631                                 + LPFC_DRVR_TIMEOUT);
2632         if ((iocb_stat != IOCB_SUCCESS) || (rsp->ulpStatus != IOSTAT_SUCCESS)) {
2633                 ret_val = -EIO;
2634                 goto err_get_xri_exit;
2635         }
2636         *txxri =  rsp->ulpContext;
2637
2638         evt->waiting = 1;
2639         evt->wait_time_stamp = jiffies;
2640         time_left = wait_event_interruptible_timeout(
2641                 evt->wq, !list_empty(&evt->events_to_see),
2642                 msecs_to_jiffies(1000 *
2643                         ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT)));
2644         if (list_empty(&evt->events_to_see))
2645                 ret_val = (time_left) ? -EINTR : -ETIMEDOUT;
2646         else {
2647                 spin_lock_irqsave(&phba->ct_ev_lock, flags);
2648                 list_move(evt->events_to_see.prev, &evt->events_to_get);
2649                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
2650                 *rxxri = (list_entry(evt->events_to_get.prev,
2651                                      typeof(struct event_data),
2652                                      node))->immed_dat;
2653         }
2654         evt->waiting = 0;
2655
2656 err_get_xri_exit:
2657         spin_lock_irqsave(&phba->ct_ev_lock, flags);
2658         lpfc_bsg_event_unref(evt); /* release ref */
2659         lpfc_bsg_event_unref(evt); /* delete */
2660         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
2661
2662         if (dmabuf) {
2663                 if (dmabuf->virt)
2664                         lpfc_mbuf_free(phba, dmabuf->virt, dmabuf->phys);
2665                 kfree(dmabuf);
2666         }
2667
2668         if (cmdiocbq && (iocb_stat != IOCB_TIMEDOUT))
2669                 lpfc_sli_release_iocbq(phba, cmdiocbq);
2670         if (rspiocbq)
2671                 lpfc_sli_release_iocbq(phba, rspiocbq);
2672         return ret_val;
2673 }
2674
2675 /**
2676  * lpfc_bsg_dma_page_alloc - allocate a bsg mbox page sized dma buffers
2677  * @phba: Pointer to HBA context object
2678  *
2679  * This function allocates BSG_MBOX_SIZE (4KB) page size dma buffer and.
2680  * returns the pointer to the buffer.
2681  **/
2682 static struct lpfc_dmabuf *
2683 lpfc_bsg_dma_page_alloc(struct lpfc_hba *phba)
2684 {
2685         struct lpfc_dmabuf *dmabuf;
2686         struct pci_dev *pcidev = phba->pcidev;
2687
2688         /* allocate dma buffer struct */
2689         dmabuf = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2690         if (!dmabuf)
2691                 return NULL;
2692
2693         INIT_LIST_HEAD(&dmabuf->list);
2694
2695         /* now, allocate dma buffer */
2696         dmabuf->virt = dma_alloc_coherent(&pcidev->dev, BSG_MBOX_SIZE,
2697                                           &(dmabuf->phys), GFP_KERNEL);
2698
2699         if (!dmabuf->virt) {
2700                 kfree(dmabuf);
2701                 return NULL;
2702         }
2703         memset((uint8_t *)dmabuf->virt, 0, BSG_MBOX_SIZE);
2704
2705         return dmabuf;
2706 }
2707
2708 /**
2709  * lpfc_bsg_dma_page_free - free a bsg mbox page sized dma buffer
2710  * @phba: Pointer to HBA context object.
2711  * @dmabuf: Pointer to the bsg mbox page sized dma buffer descriptor.
2712  *
2713  * This routine just simply frees a dma buffer and its associated buffer
2714  * descriptor referred by @dmabuf.
2715  **/
2716 static void
2717 lpfc_bsg_dma_page_free(struct lpfc_hba *phba, struct lpfc_dmabuf *dmabuf)
2718 {
2719         struct pci_dev *pcidev = phba->pcidev;
2720
2721         if (!dmabuf)
2722                 return;
2723
2724         if (dmabuf->virt)
2725                 dma_free_coherent(&pcidev->dev, BSG_MBOX_SIZE,
2726                                   dmabuf->virt, dmabuf->phys);
2727         kfree(dmabuf);
2728         return;
2729 }
2730
2731 /**
2732  * lpfc_bsg_dma_page_list_free - free a list of bsg mbox page sized dma buffers
2733  * @phba: Pointer to HBA context object.
2734  * @dmabuf_list: Pointer to a list of bsg mbox page sized dma buffer descs.
2735  *
2736  * This routine just simply frees all dma buffers and their associated buffer
2737  * descriptors referred by @dmabuf_list.
2738  **/
2739 static void
2740 lpfc_bsg_dma_page_list_free(struct lpfc_hba *phba,
2741                             struct list_head *dmabuf_list)
2742 {
2743         struct lpfc_dmabuf *dmabuf, *next_dmabuf;
2744
2745         if (list_empty(dmabuf_list))
2746                 return;
2747
2748         list_for_each_entry_safe(dmabuf, next_dmabuf, dmabuf_list, list) {
2749                 list_del_init(&dmabuf->list);
2750                 lpfc_bsg_dma_page_free(phba, dmabuf);
2751         }
2752         return;
2753 }
2754
2755 /**
2756  * diag_cmd_data_alloc - fills in a bde struct with dma buffers
2757  * @phba: Pointer to HBA context object
2758  * @bpl: Pointer to 64 bit bde structure
2759  * @size: Number of bytes to process
2760  * @nocopydata: Flag to copy user data into the allocated buffer
2761  *
2762  * This function allocates page size buffers and populates an lpfc_dmabufext.
2763  * If allowed the user data pointed to with indataptr is copied into the kernel
2764  * memory. The chained list of page size buffers is returned.
2765  **/
2766 static struct lpfc_dmabufext *
2767 diag_cmd_data_alloc(struct lpfc_hba *phba,
2768                    struct ulp_bde64 *bpl, uint32_t size,
2769                    int nocopydata)
2770 {
2771         struct lpfc_dmabufext *mlist = NULL;
2772         struct lpfc_dmabufext *dmp;
2773         int cnt, offset = 0, i = 0;
2774         struct pci_dev *pcidev;
2775
2776         pcidev = phba->pcidev;
2777
2778         while (size) {
2779                 /* We get chunks of 4K */
2780                 if (size > BUF_SZ_4K)
2781                         cnt = BUF_SZ_4K;
2782                 else
2783                         cnt = size;
2784
2785                 /* allocate struct lpfc_dmabufext buffer header */
2786                 dmp = kmalloc(sizeof(struct lpfc_dmabufext), GFP_KERNEL);
2787                 if (!dmp)
2788                         goto out;
2789
2790                 INIT_LIST_HEAD(&dmp->dma.list);
2791
2792                 /* Queue it to a linked list */
2793                 if (mlist)
2794                         list_add_tail(&dmp->dma.list, &mlist->dma.list);
2795                 else
2796                         mlist = dmp;
2797
2798                 /* allocate buffer */
2799                 dmp->dma.virt = dma_alloc_coherent(&pcidev->dev,
2800                                                    cnt,
2801                                                    &(dmp->dma.phys),
2802                                                    GFP_KERNEL);
2803
2804                 if (!dmp->dma.virt)
2805                         goto out;
2806
2807                 dmp->size = cnt;
2808
2809                 if (nocopydata) {
2810                         bpl->tus.f.bdeFlags = 0;
2811                         pci_dma_sync_single_for_device(phba->pcidev,
2812                                 dmp->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
2813
2814                 } else {
2815                         memset((uint8_t *)dmp->dma.virt, 0, cnt);
2816                         bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
2817                 }
2818
2819                 /* build buffer ptr list for IOCB */
2820                 bpl->addrLow = le32_to_cpu(putPaddrLow(dmp->dma.phys));
2821                 bpl->addrHigh = le32_to_cpu(putPaddrHigh(dmp->dma.phys));
2822                 bpl->tus.f.bdeSize = (ushort) cnt;
2823                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
2824                 bpl++;
2825
2826                 i++;
2827                 offset += cnt;
2828                 size -= cnt;
2829         }
2830
2831         mlist->flag = i;
2832         return mlist;
2833 out:
2834         diag_cmd_data_free(phba, mlist);
2835         return NULL;
2836 }
2837
2838 /**
2839  * lpfcdiag_loop_post_rxbufs - post the receive buffers for an unsol CT cmd
2840  * @phba: Pointer to HBA context object
2841  * @rxxri: Receive exchange id
2842  * @len: Number of data bytes
2843  *
2844  * This function allocates and posts a data buffer of sufficient size to receive
2845  * an unsolicted CT command.
2846  **/
2847 static int lpfcdiag_loop_post_rxbufs(struct lpfc_hba *phba, uint16_t rxxri,
2848                              size_t len)
2849 {
2850         struct lpfc_sli *psli = &phba->sli;
2851         struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
2852         struct lpfc_iocbq *cmdiocbq;
2853         IOCB_t *cmd = NULL;
2854         struct list_head head, *curr, *next;
2855         struct lpfc_dmabuf *rxbmp;
2856         struct lpfc_dmabuf *dmp;
2857         struct lpfc_dmabuf *mp[2] = {NULL, NULL};
2858         struct ulp_bde64 *rxbpl = NULL;
2859         uint32_t num_bde;
2860         struct lpfc_dmabufext *rxbuffer = NULL;
2861         int ret_val = 0;
2862         int iocb_stat;
2863         int i = 0;
2864
2865         cmdiocbq = lpfc_sli_get_iocbq(phba);
2866         rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2867         if (rxbmp != NULL) {
2868                 rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
2869                 if (rxbmp->virt) {
2870                         INIT_LIST_HEAD(&rxbmp->list);
2871                         rxbpl = (struct ulp_bde64 *) rxbmp->virt;
2872                         rxbuffer = diag_cmd_data_alloc(phba, rxbpl, len, 0);
2873                 }
2874         }
2875
2876         if (!cmdiocbq || !rxbmp || !rxbpl || !rxbuffer) {
2877                 ret_val = -ENOMEM;
2878                 goto err_post_rxbufs_exit;
2879         }
2880
2881         /* Queue buffers for the receive exchange */
2882         num_bde = (uint32_t)rxbuffer->flag;
2883         dmp = &rxbuffer->dma;
2884
2885         cmd = &cmdiocbq->iocb;
2886         i = 0;
2887
2888         INIT_LIST_HEAD(&head);
2889         list_add_tail(&head, &dmp->list);
2890         list_for_each_safe(curr, next, &head) {
2891                 mp[i] = list_entry(curr, struct lpfc_dmabuf, list);
2892                 list_del(curr);
2893
2894                 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
2895                         mp[i]->buffer_tag = lpfc_sli_get_buffer_tag(phba);
2896                         cmd->un.quexri64cx.buff.bde.addrHigh =
2897                                 putPaddrHigh(mp[i]->phys);
2898                         cmd->un.quexri64cx.buff.bde.addrLow =
2899                                 putPaddrLow(mp[i]->phys);
2900                         cmd->un.quexri64cx.buff.bde.tus.f.bdeSize =
2901                                 ((struct lpfc_dmabufext *)mp[i])->size;
2902                         cmd->un.quexri64cx.buff.buffer_tag = mp[i]->buffer_tag;
2903                         cmd->ulpCommand = CMD_QUE_XRI64_CX;
2904                         cmd->ulpPU = 0;
2905                         cmd->ulpLe = 1;
2906                         cmd->ulpBdeCount = 1;
2907                         cmd->unsli3.que_xri64cx_ext_words.ebde_count = 0;
2908
2909                 } else {
2910                         cmd->un.cont64[i].addrHigh = putPaddrHigh(mp[i]->phys);
2911                         cmd->un.cont64[i].addrLow = putPaddrLow(mp[i]->phys);
2912                         cmd->un.cont64[i].tus.f.bdeSize =
2913                                 ((struct lpfc_dmabufext *)mp[i])->size;
2914                                         cmd->ulpBdeCount = ++i;
2915
2916                         if ((--num_bde > 0) && (i < 2))
2917                                 continue;
2918
2919                         cmd->ulpCommand = CMD_QUE_XRI_BUF64_CX;
2920                         cmd->ulpLe = 1;
2921                 }
2922
2923                 cmd->ulpClass = CLASS3;
2924                 cmd->ulpContext = rxxri;
2925
2926                 iocb_stat = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq,
2927                                                 0);
2928                 if (iocb_stat == IOCB_ERROR) {
2929                         diag_cmd_data_free(phba,
2930                                 (struct lpfc_dmabufext *)mp[0]);
2931                         if (mp[1])
2932                                 diag_cmd_data_free(phba,
2933                                           (struct lpfc_dmabufext *)mp[1]);
2934                         dmp = list_entry(next, struct lpfc_dmabuf, list);
2935                         ret_val = -EIO;
2936                         goto err_post_rxbufs_exit;
2937                 }
2938
2939                 lpfc_sli_ringpostbuf_put(phba, pring, mp[0]);
2940                 if (mp[1]) {
2941                         lpfc_sli_ringpostbuf_put(phba, pring, mp[1]);
2942                         mp[1] = NULL;
2943                 }
2944
2945                 /* The iocb was freed by lpfc_sli_issue_iocb */
2946                 cmdiocbq = lpfc_sli_get_iocbq(phba);
2947                 if (!cmdiocbq) {
2948                         dmp = list_entry(next, struct lpfc_dmabuf, list);
2949                         ret_val = -EIO;
2950                         goto err_post_rxbufs_exit;
2951                 }
2952
2953                 cmd = &cmdiocbq->iocb;
2954                 i = 0;
2955         }
2956         list_del(&head);
2957
2958 err_post_rxbufs_exit:
2959
2960         if (rxbmp) {
2961                 if (rxbmp->virt)
2962                         lpfc_mbuf_free(phba, rxbmp->virt, rxbmp->phys);
2963                 kfree(rxbmp);
2964         }
2965
2966         if (cmdiocbq)
2967                 lpfc_sli_release_iocbq(phba, cmdiocbq);
2968         return ret_val;
2969 }
2970
2971 /**
2972  * lpfc_bsg_diag_loopback_run - run loopback on a port by issue ct cmd to itself
2973  * @job: LPFC_BSG_VENDOR_DIAG_TEST fc_bsg_job
2974  *
2975  * This function receives a user data buffer to be transmitted and received on
2976  * the same port, the link must be up and in loopback mode prior
2977  * to being called.
2978  * 1. A kernel buffer is allocated to copy the user data into.
2979  * 2. The port registers with "itself".
2980  * 3. The transmit and receive exchange ids are obtained.
2981  * 4. The receive exchange id is posted.
2982  * 5. A new els loopback event is created.
2983  * 6. The command and response iocbs are allocated.
2984  * 7. The cmd iocb FsType is set to elx loopback and the CmdRsp to looppback.
2985  *
2986  * This function is meant to be called n times while the port is in loopback
2987  * so it is the apps responsibility to issue a reset to take the port out
2988  * of loopback mode.
2989  **/
2990 static int
2991 lpfc_bsg_diag_loopback_run(struct fc_bsg_job *job)
2992 {
2993         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
2994         struct lpfc_hba *phba = vport->phba;
2995         struct diag_mode_test *diag_mode;
2996         struct lpfc_bsg_event *evt;
2997         struct event_data *evdat;
2998         struct lpfc_sli *psli = &phba->sli;
2999         uint32_t size;
3000         uint32_t full_size;
3001         size_t segment_len = 0, segment_offset = 0, current_offset = 0;
3002         uint16_t rpi = 0;
3003         struct lpfc_iocbq *cmdiocbq, *rspiocbq = NULL;
3004         IOCB_t *cmd, *rsp = NULL;
3005         struct lpfc_sli_ct_request *ctreq;
3006         struct lpfc_dmabuf *txbmp;
3007         struct ulp_bde64 *txbpl = NULL;
3008         struct lpfc_dmabufext *txbuffer = NULL;
3009         struct list_head head;
3010         struct lpfc_dmabuf  *curr;
3011         uint16_t txxri = 0, rxxri;
3012         uint32_t num_bde;
3013         uint8_t *ptr = NULL, *rx_databuf = NULL;
3014         int rc = 0;
3015         int time_left;
3016         int iocb_stat = IOCB_SUCCESS;
3017         unsigned long flags;
3018         void *dataout = NULL;
3019         uint32_t total_mem;
3020
3021         /* in case no data is returned return just the return code */
3022         job->reply->reply_payload_rcv_len = 0;
3023
3024         if (job->request_len <
3025             sizeof(struct fc_bsg_request) + sizeof(struct diag_mode_test)) {
3026                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3027                                 "2739 Received DIAG TEST request below minimum "
3028                                 "size\n");
3029                 rc = -EINVAL;
3030                 goto loopback_test_exit;
3031         }
3032
3033         if (job->request_payload.payload_len !=
3034                 job->reply_payload.payload_len) {
3035                 rc = -EINVAL;
3036                 goto loopback_test_exit;
3037         }
3038         diag_mode = (struct diag_mode_test *)
3039                 job->request->rqst_data.h_vendor.vendor_cmd;
3040
3041         if ((phba->link_state == LPFC_HBA_ERROR) ||
3042             (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
3043             (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
3044                 rc = -EACCES;
3045                 goto loopback_test_exit;
3046         }
3047
3048         if (!lpfc_is_link_up(phba) || !(phba->link_flag & LS_LOOPBACK_MODE)) {
3049                 rc = -EACCES;
3050                 goto loopback_test_exit;
3051         }
3052
3053         size = job->request_payload.payload_len;
3054         full_size = size + ELX_LOOPBACK_HEADER_SZ; /* plus the header */
3055
3056         if ((size == 0) || (size > 80 * BUF_SZ_4K)) {
3057                 rc = -ERANGE;
3058                 goto loopback_test_exit;
3059         }
3060
3061         if (full_size >= BUF_SZ_4K) {
3062                 /*
3063                  * Allocate memory for ioctl data. If buffer is bigger than 64k,
3064                  * then we allocate 64k and re-use that buffer over and over to
3065                  * xfer the whole block. This is because Linux kernel has a
3066                  * problem allocating more than 120k of kernel space memory. Saw
3067                  * problem with GET_FCPTARGETMAPPING...
3068                  */
3069                 if (size <= (64 * 1024))
3070                         total_mem = full_size;
3071                 else
3072                         total_mem = 64 * 1024;
3073         } else
3074                 /* Allocate memory for ioctl data */
3075                 total_mem = BUF_SZ_4K;
3076
3077         dataout = kmalloc(total_mem, GFP_KERNEL);
3078         if (dataout == NULL) {
3079                 rc = -ENOMEM;
3080                 goto loopback_test_exit;
3081         }
3082
3083         ptr = dataout;
3084         ptr += ELX_LOOPBACK_HEADER_SZ;
3085         sg_copy_to_buffer(job->request_payload.sg_list,
3086                                 job->request_payload.sg_cnt,
3087                                 ptr, size);
3088         rc = lpfcdiag_loop_self_reg(phba, &rpi);
3089         if (rc)
3090                 goto loopback_test_exit;
3091
3092         if (phba->sli_rev < LPFC_SLI_REV4) {
3093                 rc = lpfcdiag_loop_get_xri(phba, rpi, &txxri, &rxxri);
3094                 if (rc) {
3095                         lpfcdiag_loop_self_unreg(phba, rpi);
3096                         goto loopback_test_exit;
3097                 }
3098
3099                 rc = lpfcdiag_loop_post_rxbufs(phba, rxxri, full_size);
3100                 if (rc) {
3101                         lpfcdiag_loop_self_unreg(phba, rpi);
3102                         goto loopback_test_exit;
3103                 }
3104         }
3105         evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
3106                                 SLI_CT_ELX_LOOPBACK);
3107         if (!evt) {
3108                 lpfcdiag_loop_self_unreg(phba, rpi);
3109                 rc = -ENOMEM;
3110                 goto loopback_test_exit;
3111         }
3112
3113         spin_lock_irqsave(&phba->ct_ev_lock, flags);
3114         list_add(&evt->node, &phba->ct_ev_waiters);
3115         lpfc_bsg_event_ref(evt);
3116         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3117
3118         cmdiocbq = lpfc_sli_get_iocbq(phba);
3119         if (phba->sli_rev < LPFC_SLI_REV4)
3120                 rspiocbq = lpfc_sli_get_iocbq(phba);
3121         txbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
3122
3123         if (txbmp) {
3124                 txbmp->virt = lpfc_mbuf_alloc(phba, 0, &txbmp->phys);
3125                 if (txbmp->virt) {
3126                         INIT_LIST_HEAD(&txbmp->list);
3127                         txbpl = (struct ulp_bde64 *) txbmp->virt;
3128                         txbuffer = diag_cmd_data_alloc(phba,
3129                                                         txbpl, full_size, 0);
3130                 }
3131         }
3132
3133         if (!cmdiocbq || !txbmp || !txbpl || !txbuffer || !txbmp->virt) {
3134                 rc = -ENOMEM;
3135                 goto err_loopback_test_exit;
3136         }
3137         if ((phba->sli_rev < LPFC_SLI_REV4) && !rspiocbq) {
3138                 rc = -ENOMEM;
3139                 goto err_loopback_test_exit;
3140         }
3141
3142         cmd = &cmdiocbq->iocb;
3143         if (phba->sli_rev < LPFC_SLI_REV4)
3144                 rsp = &rspiocbq->iocb;
3145
3146         INIT_LIST_HEAD(&head);
3147         list_add_tail(&head, &txbuffer->dma.list);
3148         list_for_each_entry(curr, &head, list) {
3149                 segment_len = ((struct lpfc_dmabufext *)curr)->size;
3150                 if (current_offset == 0) {
3151                         ctreq = curr->virt;
3152                         memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
3153                         ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
3154                         ctreq->RevisionId.bits.InId = 0;
3155                         ctreq->FsType = SLI_CT_ELX_LOOPBACK;
3156                         ctreq->FsSubType = 0;
3157                         ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_DATA;
3158                         ctreq->CommandResponse.bits.Size   = size;
3159                         segment_offset = ELX_LOOPBACK_HEADER_SZ;
3160                 } else
3161                         segment_offset = 0;
3162
3163                 BUG_ON(segment_offset >= segment_len);
3164                 memcpy(curr->virt + segment_offset,
3165                         ptr + current_offset,
3166                         segment_len - segment_offset);
3167
3168                 current_offset += segment_len - segment_offset;
3169                 BUG_ON(current_offset > size);
3170         }
3171         list_del(&head);
3172
3173         /* Build the XMIT_SEQUENCE iocb */
3174         num_bde = (uint32_t)txbuffer->flag;
3175
3176         cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(txbmp->phys);
3177         cmd->un.xseq64.bdl.addrLow = putPaddrLow(txbmp->phys);
3178         cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
3179         cmd->un.xseq64.bdl.bdeSize = (num_bde * sizeof(struct ulp_bde64));
3180
3181         cmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
3182         cmd->un.xseq64.w5.hcsw.Dfctl = 0;
3183         cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
3184         cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
3185
3186         cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
3187         cmd->ulpBdeCount = 1;
3188         cmd->ulpLe = 1;
3189         cmd->ulpClass = CLASS3;
3190
3191         if (phba->sli_rev < LPFC_SLI_REV4) {
3192                 cmd->ulpContext = txxri;
3193         } else {
3194                 cmd->un.xseq64.bdl.ulpIoTag32 = 0;
3195                 cmd->un.ulpWord[3] = phba->sli4_hba.rpi_ids[rpi];
3196                 cmdiocbq->context3 = txbmp;
3197                 cmdiocbq->sli4_xritag = NO_XRI;
3198                 cmd->unsli3.rcvsli3.ox_id = 0xffff;
3199         }
3200         cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
3201         cmdiocbq->vport = phba->pport;
3202         cmdiocbq->iocb_cmpl = NULL;
3203         iocb_stat = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
3204                                              rspiocbq, (phba->fc_ratov * 2) +
3205                                              LPFC_DRVR_TIMEOUT);
3206
3207         if ((iocb_stat != IOCB_SUCCESS) ||
3208             ((phba->sli_rev < LPFC_SLI_REV4) &&
3209              (rsp->ulpStatus != IOSTAT_SUCCESS))) {
3210                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3211                                 "3126 Failed loopback test issue iocb: "
3212                                 "iocb_stat:x%x\n", iocb_stat);
3213                 rc = -EIO;
3214                 goto err_loopback_test_exit;
3215         }
3216
3217         evt->waiting = 1;
3218         time_left = wait_event_interruptible_timeout(
3219                 evt->wq, !list_empty(&evt->events_to_see),
3220                 msecs_to_jiffies(1000 *
3221                         ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT)));
3222         evt->waiting = 0;
3223         if (list_empty(&evt->events_to_see)) {
3224                 rc = (time_left) ? -EINTR : -ETIMEDOUT;
3225                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3226                                 "3125 Not receiving unsolicited event, "
3227                                 "rc:x%x\n", rc);
3228         } else {
3229                 spin_lock_irqsave(&phba->ct_ev_lock, flags);
3230                 list_move(evt->events_to_see.prev, &evt->events_to_get);
3231                 evdat = list_entry(evt->events_to_get.prev,
3232                                    typeof(*evdat), node);
3233                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3234                 rx_databuf = evdat->data;
3235                 if (evdat->len != full_size) {
3236                         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3237                                 "1603 Loopback test did not receive expected "
3238                                 "data length. actual length 0x%x expected "
3239                                 "length 0x%x\n",
3240                                 evdat->len, full_size);
3241                         rc = -EIO;
3242                 } else if (rx_databuf == NULL)
3243                         rc = -EIO;
3244                 else {
3245                         rc = IOCB_SUCCESS;
3246                         /* skip over elx loopback header */
3247                         rx_databuf += ELX_LOOPBACK_HEADER_SZ;
3248                         job->reply->reply_payload_rcv_len =
3249                                 sg_copy_from_buffer(job->reply_payload.sg_list,
3250                                                     job->reply_payload.sg_cnt,
3251                                                     rx_databuf, size);
3252                         job->reply->reply_payload_rcv_len = size;
3253                 }
3254         }
3255
3256 err_loopback_test_exit:
3257         lpfcdiag_loop_self_unreg(phba, rpi);
3258
3259         spin_lock_irqsave(&phba->ct_ev_lock, flags);
3260         lpfc_bsg_event_unref(evt); /* release ref */
3261         lpfc_bsg_event_unref(evt); /* delete */
3262         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3263
3264         if ((cmdiocbq != NULL) && (iocb_stat != IOCB_TIMEDOUT))
3265                 lpfc_sli_release_iocbq(phba, cmdiocbq);
3266
3267         if (rspiocbq != NULL)
3268                 lpfc_sli_release_iocbq(phba, rspiocbq);
3269
3270         if (txbmp != NULL) {
3271                 if (txbpl != NULL) {
3272                         if (txbuffer != NULL)
3273                                 diag_cmd_data_free(phba, txbuffer);
3274                         lpfc_mbuf_free(phba, txbmp->virt, txbmp->phys);
3275                 }
3276                 kfree(txbmp);
3277         }
3278
3279 loopback_test_exit:
3280         kfree(dataout);
3281         /* make error code available to userspace */
3282         job->reply->result = rc;
3283         job->dd_data = NULL;
3284         /* complete the job back to userspace if no error */
3285         if (rc == IOCB_SUCCESS)
3286                 job->job_done(job);
3287         return rc;
3288 }
3289
3290 /**
3291  * lpfc_bsg_get_dfc_rev - process a GET_DFC_REV bsg vendor command
3292  * @job: GET_DFC_REV fc_bsg_job
3293  **/
3294 static int
3295 lpfc_bsg_get_dfc_rev(struct fc_bsg_job *job)
3296 {
3297         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
3298         struct lpfc_hba *phba = vport->phba;
3299         struct get_mgmt_rev *event_req;
3300         struct get_mgmt_rev_reply *event_reply;
3301         int rc = 0;
3302
3303         if (job->request_len <
3304             sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev)) {
3305                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3306                                 "2740 Received GET_DFC_REV request below "
3307                                 "minimum size\n");
3308                 rc = -EINVAL;
3309                 goto job_error;
3310         }
3311
3312         event_req = (struct get_mgmt_rev *)
3313                 job->request->rqst_data.h_vendor.vendor_cmd;
3314
3315         event_reply = (struct get_mgmt_rev_reply *)
3316                 job->reply->reply_data.vendor_reply.vendor_rsp;
3317
3318         if (job->reply_len <
3319             sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev_reply)) {
3320                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3321                                 "2741 Received GET_DFC_REV reply below "
3322                                 "minimum size\n");
3323                 rc = -EINVAL;
3324                 goto job_error;
3325         }
3326
3327         event_reply->info.a_Major = MANAGEMENT_MAJOR_REV;
3328         event_reply->info.a_Minor = MANAGEMENT_MINOR_REV;
3329 job_error:
3330         job->reply->result = rc;
3331         if (rc == 0)
3332                 job->job_done(job);
3333         return rc;
3334 }
3335
3336 /**
3337  * lpfc_bsg_issue_mbox_cmpl - lpfc_bsg_issue_mbox mbox completion handler
3338  * @phba: Pointer to HBA context object.
3339  * @pmboxq: Pointer to mailbox command.
3340  *
3341  * This is completion handler function for mailbox commands issued from
3342  * lpfc_bsg_issue_mbox function. This function is called by the
3343  * mailbox event handler function with no lock held. This function
3344  * will wake up thread waiting on the wait queue pointed by context1
3345  * of the mailbox.
3346  **/
3347 void
3348 lpfc_bsg_issue_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3349 {
3350         struct bsg_job_data *dd_data;
3351         struct fc_bsg_job *job;
3352         uint32_t size;
3353         unsigned long flags;
3354         uint8_t *pmb, *pmb_buf;
3355
3356         dd_data = pmboxq->context1;
3357
3358         /*
3359          * The outgoing buffer is readily referred from the dma buffer,
3360          * just need to get header part from mailboxq structure.
3361          */
3362         pmb = (uint8_t *)&pmboxq->u.mb;
3363         pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb;
3364         memcpy(pmb_buf, pmb, sizeof(MAILBOX_t));
3365
3366         /* Determine if job has been aborted */
3367
3368         spin_lock_irqsave(&phba->ct_ev_lock, flags);
3369         job = dd_data->set_job;
3370         if (job) {
3371                 /* Prevent timeout handling from trying to abort job  */
3372                 job->dd_data = NULL;
3373         }
3374         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3375
3376         /* Copy the mailbox data to the job if it is still active */
3377
3378         if (job) {
3379                 size = job->reply_payload.payload_len;
3380                 job->reply->reply_payload_rcv_len =
3381                         sg_copy_from_buffer(job->reply_payload.sg_list,
3382                                             job->reply_payload.sg_cnt,
3383                                             pmb_buf, size);
3384         }
3385
3386         dd_data->set_job = NULL;
3387         mempool_free(dd_data->context_un.mbox.pmboxq, phba->mbox_mem_pool);
3388         lpfc_bsg_dma_page_free(phba, dd_data->context_un.mbox.dmabuffers);
3389         kfree(dd_data);
3390
3391         /* Complete the job if the job is still active */
3392
3393         if (job) {
3394                 job->reply->result = 0;
3395                 job->job_done(job);
3396         }
3397         return;
3398 }
3399
3400 /**
3401  * lpfc_bsg_check_cmd_access - test for a supported mailbox command
3402  * @phba: Pointer to HBA context object.
3403  * @mb: Pointer to a mailbox object.
3404  * @vport: Pointer to a vport object.
3405  *
3406  * Some commands require the port to be offline, some may not be called from
3407  * the application.
3408  **/
3409 static int lpfc_bsg_check_cmd_access(struct lpfc_hba *phba,
3410         MAILBOX_t *mb, struct lpfc_vport *vport)
3411 {
3412         /* return negative error values for bsg job */
3413         switch (mb->mbxCommand) {
3414         /* Offline only */
3415         case MBX_INIT_LINK:
3416         case MBX_DOWN_LINK:
3417         case MBX_CONFIG_LINK:
3418         case MBX_CONFIG_RING:
3419         case MBX_RESET_RING:
3420         case MBX_UNREG_LOGIN:
3421         case MBX_CLEAR_LA:
3422         case MBX_DUMP_CONTEXT:
3423         case MBX_RUN_DIAGS:
3424         case MBX_RESTART:
3425         case MBX_SET_MASK:
3426                 if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
3427                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3428                                 "2743 Command 0x%x is illegal in on-line "
3429                                 "state\n",
3430                                 mb->mbxCommand);
3431                         return -EPERM;
3432                 }
3433         case MBX_WRITE_NV:
3434         case MBX_WRITE_VPARMS:
3435         case MBX_LOAD_SM:
3436         case MBX_READ_NV:
3437         case MBX_READ_CONFIG:
3438         case MBX_READ_RCONFIG:
3439         case MBX_READ_STATUS:
3440         case MBX_READ_XRI:
3441         case MBX_READ_REV:
3442         case MBX_READ_LNK_STAT:
3443         case MBX_DUMP_MEMORY:
3444         case MBX_DOWN_LOAD:
3445         case MBX_UPDATE_CFG:
3446         case MBX_KILL_BOARD:
3447         case MBX_READ_TOPOLOGY:
3448         case MBX_LOAD_AREA:
3449         case MBX_LOAD_EXP_ROM:
3450         case MBX_BEACON:
3451         case MBX_DEL_LD_ENTRY:
3452         case MBX_SET_DEBUG:
3453         case MBX_WRITE_WWN:
3454         case MBX_SLI4_CONFIG:
3455         case MBX_READ_EVENT_LOG:
3456         case MBX_READ_EVENT_LOG_STATUS:
3457         case MBX_WRITE_EVENT_LOG:
3458         case MBX_PORT_CAPABILITIES:
3459         case MBX_PORT_IOV_CONTROL:
3460         case MBX_RUN_BIU_DIAG64:
3461                 break;
3462         case MBX_SET_VARIABLE:
3463                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3464                         "1226 mbox: set_variable 0x%x, 0x%x\n",
3465                         mb->un.varWords[0],
3466                         mb->un.varWords[1]);
3467                 if ((mb->un.varWords[0] == SETVAR_MLOMNT)
3468                         && (mb->un.varWords[1] == 1)) {
3469                         phba->wait_4_mlo_maint_flg = 1;
3470                 } else if (mb->un.varWords[0] == SETVAR_MLORST) {
3471                         spin_lock_irq(&phba->hbalock);
3472                         phba->link_flag &= ~LS_LOOPBACK_MODE;
3473                         spin_unlock_irq(&phba->hbalock);
3474                         phba->fc_topology = LPFC_TOPOLOGY_PT_PT;
3475                 }
3476                 break;
3477         case MBX_READ_SPARM64:
3478         case MBX_REG_LOGIN:
3479         case MBX_REG_LOGIN64:
3480         case MBX_CONFIG_PORT:
3481         case MBX_RUN_BIU_DIAG:
3482         default:
3483                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3484                         "2742 Unknown Command 0x%x\n",
3485                         mb->mbxCommand);
3486                 return -EPERM;
3487         }
3488
3489         return 0; /* ok */
3490 }
3491
3492 /**
3493  * lpfc_bsg_mbox_ext_cleanup - clean up context of multi-buffer mbox session
3494  * @phba: Pointer to HBA context object.
3495  *
3496  * This is routine clean up and reset BSG handling of multi-buffer mbox
3497  * command session.
3498  **/
3499 static void
3500 lpfc_bsg_mbox_ext_session_reset(struct lpfc_hba *phba)
3501 {
3502         if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_IDLE)
3503                 return;
3504
3505         /* free all memory, including dma buffers */
3506         lpfc_bsg_dma_page_list_free(phba,
3507                                     &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3508         lpfc_bsg_dma_page_free(phba, phba->mbox_ext_buf_ctx.mbx_dmabuf);
3509         /* multi-buffer write mailbox command pass-through complete */
3510         memset((char *)&phba->mbox_ext_buf_ctx, 0,
3511                sizeof(struct lpfc_mbox_ext_buf_ctx));
3512         INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3513
3514         return;
3515 }
3516
3517 /**
3518  * lpfc_bsg_issue_mbox_ext_handle_job - job handler for multi-buffer mbox cmpl
3519  * @phba: Pointer to HBA context object.
3520  * @pmboxq: Pointer to mailbox command.
3521  *
3522  * This is routine handles BSG job for mailbox commands completions with
3523  * multiple external buffers.
3524  **/
3525 static struct fc_bsg_job *
3526 lpfc_bsg_issue_mbox_ext_handle_job(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3527 {
3528         struct bsg_job_data *dd_data;
3529         struct fc_bsg_job *job;
3530         uint8_t *pmb, *pmb_buf;
3531         unsigned long flags;
3532         uint32_t size;
3533         int rc = 0;
3534         struct lpfc_dmabuf *dmabuf;
3535         struct lpfc_sli_config_mbox *sli_cfg_mbx;
3536         uint8_t *pmbx;
3537
3538         dd_data = pmboxq->context1;
3539
3540         /* Determine if job has been aborted */
3541         spin_lock_irqsave(&phba->ct_ev_lock, flags);
3542         job = dd_data->set_job;
3543         if (job) {
3544                 /* Prevent timeout handling from trying to abort job  */
3545                 job->dd_data = NULL;
3546         }
3547         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3548
3549         /*
3550          * The outgoing buffer is readily referred from the dma buffer,
3551          * just need to get header part from mailboxq structure.
3552          */
3553
3554         pmb = (uint8_t *)&pmboxq->u.mb;
3555         pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb;
3556         /* Copy the byte swapped response mailbox back to the user */
3557         memcpy(pmb_buf, pmb, sizeof(MAILBOX_t));
3558         /* if there is any non-embedded extended data copy that too */
3559         dmabuf = phba->mbox_ext_buf_ctx.mbx_dmabuf;
3560         sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
3561         if (!bsg_bf_get(lpfc_mbox_hdr_emb,
3562             &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) {
3563                 pmbx = (uint8_t *)dmabuf->virt;
3564                 /* byte swap the extended data following the mailbox command */
3565                 lpfc_sli_pcimem_bcopy(&pmbx[sizeof(MAILBOX_t)],
3566                         &pmbx[sizeof(MAILBOX_t)],
3567                         sli_cfg_mbx->un.sli_config_emb0_subsys.mse[0].buf_len);
3568         }
3569
3570         /* Complete the job if the job is still active */
3571
3572         if (job) {
3573                 size = job->reply_payload.payload_len;
3574                 job->reply->reply_payload_rcv_len =
3575                         sg_copy_from_buffer(job->reply_payload.sg_list,
3576                                             job->reply_payload.sg_cnt,
3577                                             pmb_buf, size);
3578
3579                 /* result for successful */
3580                 job->reply->result = 0;
3581
3582                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3583                                 "2937 SLI_CONFIG ext-buffer maibox command "
3584                                 "(x%x/x%x) complete bsg job done, bsize:%d\n",
3585                                 phba->mbox_ext_buf_ctx.nembType,
3586                                 phba->mbox_ext_buf_ctx.mboxType, size);
3587                 lpfc_idiag_mbxacc_dump_bsg_mbox(phba,
3588                                         phba->mbox_ext_buf_ctx.nembType,
3589                                         phba->mbox_ext_buf_ctx.mboxType,
3590                                         dma_ebuf, sta_pos_addr,
3591                                         phba->mbox_ext_buf_ctx.mbx_dmabuf, 0);
3592         } else {
3593                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3594                                 "2938 SLI_CONFIG ext-buffer maibox "
3595                                 "command (x%x/x%x) failure, rc:x%x\n",
3596                                 phba->mbox_ext_buf_ctx.nembType,
3597                                 phba->mbox_ext_buf_ctx.mboxType, rc);
3598         }
3599
3600
3601         /* state change */
3602         phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_DONE;
3603         kfree(dd_data);
3604         return job;
3605 }
3606
3607 /**
3608  * lpfc_bsg_issue_read_mbox_ext_cmpl - compl handler for multi-buffer read mbox
3609  * @phba: Pointer to HBA context object.
3610  * @pmboxq: Pointer to mailbox command.
3611  *
3612  * This is completion handler function for mailbox read commands with multiple
3613  * external buffers.
3614  **/
3615 static void
3616 lpfc_bsg_issue_read_mbox_ext_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3617 {
3618         struct fc_bsg_job *job;
3619
3620         job = lpfc_bsg_issue_mbox_ext_handle_job(phba, pmboxq);
3621
3622         /* handle the BSG job with mailbox command */
3623         if (!job)
3624                 pmboxq->u.mb.mbxStatus = MBXERR_ERROR;
3625
3626         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3627                         "2939 SLI_CONFIG ext-buffer rd maibox command "
3628                         "complete, ctxState:x%x, mbxStatus:x%x\n",
3629                         phba->mbox_ext_buf_ctx.state, pmboxq->u.mb.mbxStatus);
3630
3631         if (pmboxq->u.mb.mbxStatus || phba->mbox_ext_buf_ctx.numBuf == 1)
3632                 lpfc_bsg_mbox_ext_session_reset(phba);
3633
3634         /* free base driver mailbox structure memory */
3635         mempool_free(pmboxq, phba->mbox_mem_pool);
3636
3637         /* if the job is still active, call job done */
3638         if (job)
3639                 job->job_done(job);
3640
3641         return;
3642 }
3643
3644 /**
3645  * lpfc_bsg_issue_write_mbox_ext_cmpl - cmpl handler for multi-buffer write mbox
3646  * @phba: Pointer to HBA context object.
3647  * @pmboxq: Pointer to mailbox command.
3648  *
3649  * This is completion handler function for mailbox write commands with multiple
3650  * external buffers.
3651  **/
3652 static void
3653 lpfc_bsg_issue_write_mbox_ext_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3654 {
3655         struct fc_bsg_job *job;
3656
3657         job = lpfc_bsg_issue_mbox_ext_handle_job(phba, pmboxq);
3658
3659         /* handle the BSG job with the mailbox command */
3660         if (!job)
3661                 pmboxq->u.mb.mbxStatus = MBXERR_ERROR;
3662
3663         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3664                         "2940 SLI_CONFIG ext-buffer wr maibox command "
3665                         "complete, ctxState:x%x, mbxStatus:x%x\n",
3666                         phba->mbox_ext_buf_ctx.state, pmboxq->u.mb.mbxStatus);
3667
3668         /* free all memory, including dma buffers */
3669         mempool_free(pmboxq, phba->mbox_mem_pool);
3670         lpfc_bsg_mbox_ext_session_reset(phba);
3671
3672         /* if the job is still active, call job done */
3673         if (job)
3674                 job->job_done(job);
3675
3676         return;
3677 }
3678
3679 static void
3680 lpfc_bsg_sli_cfg_dma_desc_setup(struct lpfc_hba *phba, enum nemb_type nemb_tp,
3681                                 uint32_t index, struct lpfc_dmabuf *mbx_dmabuf,
3682                                 struct lpfc_dmabuf *ext_dmabuf)
3683 {
3684         struct lpfc_sli_config_mbox *sli_cfg_mbx;
3685
3686         /* pointer to the start of mailbox command */
3687         sli_cfg_mbx = (struct lpfc_sli_config_mbox *)mbx_dmabuf->virt;
3688
3689         if (nemb_tp == nemb_mse) {
3690                 if (index == 0) {
3691                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3692                                 mse[index].pa_hi =
3693                                 putPaddrHigh(mbx_dmabuf->phys +
3694                                              sizeof(MAILBOX_t));
3695                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3696                                 mse[index].pa_lo =
3697                                 putPaddrLow(mbx_dmabuf->phys +
3698                                             sizeof(MAILBOX_t));
3699                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3700                                         "2943 SLI_CONFIG(mse)[%d], "
3701                                         "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3702                                         index,
3703                                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3704                                         mse[index].buf_len,
3705                                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3706                                         mse[index].pa_hi,
3707                                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3708                                         mse[index].pa_lo);
3709                 } else {
3710                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3711                                 mse[index].pa_hi =
3712                                 putPaddrHigh(ext_dmabuf->phys);
3713                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3714                                 mse[index].pa_lo =
3715                                 putPaddrLow(ext_dmabuf->phys);
3716                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3717                                         "2944 SLI_CONFIG(mse)[%d], "
3718                                         "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3719                                         index,
3720                                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3721                                         mse[index].buf_len,
3722                                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3723                                         mse[index].pa_hi,
3724                                         sli_cfg_mbx->un.sli_config_emb0_subsys.
3725                                         mse[index].pa_lo);
3726                 }
3727         } else {
3728                 if (index == 0) {
3729                         sli_cfg_mbx->un.sli_config_emb1_subsys.
3730                                 hbd[index].pa_hi =
3731                                 putPaddrHigh(mbx_dmabuf->phys +
3732                                              sizeof(MAILBOX_t));
3733                         sli_cfg_mbx->un.sli_config_emb1_subsys.
3734                                 hbd[index].pa_lo =
3735                                 putPaddrLow(mbx_dmabuf->phys +
3736                                             sizeof(MAILBOX_t));
3737                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3738                                         "3007 SLI_CONFIG(hbd)[%d], "
3739                                         "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3740                                 index,
3741                                 bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
3742                                 &sli_cfg_mbx->un.
3743                                 sli_config_emb1_subsys.hbd[index]),
3744                                 sli_cfg_mbx->un.sli_config_emb1_subsys.
3745                                 hbd[index].pa_hi,
3746                                 sli_cfg_mbx->un.sli_config_emb1_subsys.
3747                                 hbd[index].pa_lo);
3748
3749                 } else {
3750                         sli_cfg_mbx->un.sli_config_emb1_subsys.
3751                                 hbd[index].pa_hi =
3752                                 putPaddrHigh(ext_dmabuf->phys);
3753                         sli_cfg_mbx->un.sli_config_emb1_subsys.
3754                                 hbd[index].pa_lo =
3755                                 putPaddrLow(ext_dmabuf->phys);
3756                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3757                                         "3008 SLI_CONFIG(hbd)[%d], "
3758                                         "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3759                                 index,
3760                                 bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
3761                                 &sli_cfg_mbx->un.
3762                                 sli_config_emb1_subsys.hbd[index]),
3763                                 sli_cfg_mbx->un.sli_config_emb1_subsys.
3764                                 hbd[index].pa_hi,
3765                                 sli_cfg_mbx->un.sli_config_emb1_subsys.
3766                                 hbd[index].pa_lo);
3767                 }
3768         }
3769         return;
3770 }
3771
3772 /**
3773  * lpfc_bsg_sli_cfg_mse_read_cmd_ext - sli_config non-embedded mailbox cmd read
3774  * @phba: Pointer to HBA context object.
3775  * @mb: Pointer to a BSG mailbox object.
3776  * @nemb_tp: Enumerate of non-embedded mailbox command type.
3777  * @dmabuff: Pointer to a DMA buffer descriptor.
3778  *
3779  * This routine performs SLI_CONFIG (0x9B) read mailbox command operation with
3780  * non-embedded external bufffers.
3781  **/
3782 static int
3783 lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
3784                               enum nemb_type nemb_tp,
3785                               struct lpfc_dmabuf *dmabuf)
3786 {
3787         struct lpfc_sli_config_mbox *sli_cfg_mbx;
3788         struct dfc_mbox_req *mbox_req;
3789         struct lpfc_dmabuf *curr_dmabuf, *next_dmabuf;
3790         uint32_t ext_buf_cnt, ext_buf_index;
3791         struct lpfc_dmabuf *ext_dmabuf = NULL;
3792         struct bsg_job_data *dd_data = NULL;
3793         LPFC_MBOXQ_t *pmboxq = NULL;
3794         MAILBOX_t *pmb;
3795         uint8_t *pmbx;
3796         int rc, i;
3797
3798         mbox_req =
3799            (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
3800
3801         /* pointer to the start of mailbox command */
3802         sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
3803
3804         if (nemb_tp == nemb_mse) {
3805                 ext_buf_cnt = bsg_bf_get(lpfc_mbox_hdr_mse_cnt,
3806                         &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr);
3807                 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) {
3808                         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3809                                         "2945 Handled SLI_CONFIG(mse) rd, "
3810                                         "ext_buf_cnt(%d) out of range(%d)\n",
3811                                         ext_buf_cnt,
3812                                         LPFC_MBX_SLI_CONFIG_MAX_MSE);
3813                         rc = -ERANGE;
3814                         goto job_error;
3815                 }
3816                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3817                                 "2941 Handled SLI_CONFIG(mse) rd, "
3818                                 "ext_buf_cnt:%d\n", ext_buf_cnt);
3819         } else {
3820                 /* sanity check on interface type for support */
3821                 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
3822                     LPFC_SLI_INTF_IF_TYPE_2) {
3823                         rc = -ENODEV;
3824                         goto job_error;
3825                 }
3826                 /* nemb_tp == nemb_hbd */
3827                 ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count;
3828                 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) {
3829                         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3830                                         "2946 Handled SLI_CONFIG(hbd) rd, "
3831                                         "ext_buf_cnt(%d) out of range(%d)\n",
3832                                         ext_buf_cnt,
3833                                         LPFC_MBX_SLI_CONFIG_MAX_HBD);
3834                         rc = -ERANGE;
3835                         goto job_error;
3836                 }
3837                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3838                                 "2942 Handled SLI_CONFIG(hbd) rd, "
3839                                 "ext_buf_cnt:%d\n", ext_buf_cnt);
3840         }
3841
3842         /* before dma descriptor setup */
3843         lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_rd, dma_mbox,
3844                                         sta_pre_addr, dmabuf, ext_buf_cnt);
3845
3846         /* reject non-embedded mailbox command with none external buffer */
3847         if (ext_buf_cnt == 0) {
3848                 rc = -EPERM;
3849                 goto job_error;
3850         } else if (ext_buf_cnt > 1) {
3851                 /* additional external read buffers */
3852                 for (i = 1; i < ext_buf_cnt; i++) {
3853                         ext_dmabuf = lpfc_bsg_dma_page_alloc(phba);
3854                         if (!ext_dmabuf) {
3855                                 rc = -ENOMEM;
3856                                 goto job_error;
3857                         }
3858                         list_add_tail(&ext_dmabuf->list,
3859                                       &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3860                 }
3861         }
3862
3863         /* bsg tracking structure */
3864         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
3865         if (!dd_data) {
3866                 rc = -ENOMEM;
3867                 goto job_error;
3868         }
3869
3870         /* mailbox command structure for base driver */
3871         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3872         if (!pmboxq) {
3873                 rc = -ENOMEM;
3874                 goto job_error;
3875         }
3876         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
3877
3878         /* for the first external buffer */
3879         lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, 0, dmabuf, dmabuf);
3880
3881         /* for the rest of external buffer descriptors if any */
3882         if (ext_buf_cnt > 1) {
3883                 ext_buf_index = 1;
3884                 list_for_each_entry_safe(curr_dmabuf, next_dmabuf,
3885                                 &phba->mbox_ext_buf_ctx.ext_dmabuf_list, list) {
3886                         lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp,
3887                                                 ext_buf_index, dmabuf,
3888                                                 curr_dmabuf);
3889                         ext_buf_index++;
3890                 }
3891         }
3892
3893         /* after dma descriptor setup */
3894         lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_rd, dma_mbox,
3895                                         sta_pos_addr, dmabuf, ext_buf_cnt);
3896
3897         /* construct base driver mbox command */
3898         pmb = &pmboxq->u.mb;
3899         pmbx = (uint8_t *)dmabuf->virt;
3900         memcpy(pmb, pmbx, sizeof(*pmb));
3901         pmb->mbxOwner = OWN_HOST;
3902         pmboxq->vport = phba->pport;
3903
3904         /* multi-buffer handling context */
3905         phba->mbox_ext_buf_ctx.nembType = nemb_tp;
3906         phba->mbox_ext_buf_ctx.mboxType = mbox_rd;
3907         phba->mbox_ext_buf_ctx.numBuf = ext_buf_cnt;
3908         phba->mbox_ext_buf_ctx.mbxTag = mbox_req->extMboxTag;
3909         phba->mbox_ext_buf_ctx.seqNum = mbox_req->extSeqNum;
3910         phba->mbox_ext_buf_ctx.mbx_dmabuf = dmabuf;
3911
3912         /* callback for multi-buffer read mailbox command */
3913         pmboxq->mbox_cmpl = lpfc_bsg_issue_read_mbox_ext_cmpl;
3914
3915         /* context fields to callback function */
3916         pmboxq->context1 = dd_data;
3917         dd_data->type = TYPE_MBOX;
3918         dd_data->set_job = job;
3919         dd_data->context_un.mbox.pmboxq = pmboxq;
3920         dd_data->context_un.mbox.mb = (MAILBOX_t *)pmbx;
3921         job->dd_data = dd_data;
3922
3923         /* state change */
3924         phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
3925
3926         /*
3927          * Non-embedded mailbox subcommand data gets byte swapped here because
3928          * the lower level driver code only does the first 64 mailbox words.
3929          */
3930         if ((!bsg_bf_get(lpfc_mbox_hdr_emb,
3931             &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) &&
3932                 (nemb_tp == nemb_mse))
3933                 lpfc_sli_pcimem_bcopy(&pmbx[sizeof(MAILBOX_t)],
3934                         &pmbx[sizeof(MAILBOX_t)],
3935                                 sli_cfg_mbx->un.sli_config_emb0_subsys.
3936                                         mse[0].buf_len);
3937
3938         rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
3939         if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
3940                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3941                                 "2947 Issued SLI_CONFIG ext-buffer "
3942                                 "maibox command, rc:x%x\n", rc);
3943                 return SLI_CONFIG_HANDLED;
3944         }
3945         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3946                         "2948 Failed to issue SLI_CONFIG ext-buffer "
3947                         "maibox command, rc:x%x\n", rc);
3948         rc = -EPIPE;
3949
3950 job_error:
3951         if (pmboxq)
3952                 mempool_free(pmboxq, phba->mbox_mem_pool);
3953         lpfc_bsg_dma_page_list_free(phba,
3954                                     &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3955         kfree(dd_data);
3956         phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_IDLE;
3957         return rc;
3958 }
3959
3960 /**
3961  * lpfc_bsg_sli_cfg_write_cmd_ext - sli_config non-embedded mailbox cmd write
3962  * @phba: Pointer to HBA context object.
3963  * @mb: Pointer to a BSG mailbox object.
3964  * @dmabuff: Pointer to a DMA buffer descriptor.
3965  *
3966  * This routine performs SLI_CONFIG (0x9B) write mailbox command operation with
3967  * non-embedded external bufffers.
3968  **/
3969 static int
3970 lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
3971                                enum nemb_type nemb_tp,
3972                                struct lpfc_dmabuf *dmabuf)
3973 {
3974         struct dfc_mbox_req *mbox_req;
3975         struct lpfc_sli_config_mbox *sli_cfg_mbx;
3976         uint32_t ext_buf_cnt;
3977         struct bsg_job_data *dd_data = NULL;
3978         LPFC_MBOXQ_t *pmboxq = NULL;
3979         MAILBOX_t *pmb;
3980         uint8_t *mbx;
3981         int rc = SLI_CONFIG_NOT_HANDLED, i;
3982
3983         mbox_req =
3984            (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
3985
3986         /* pointer to the start of mailbox command */
3987         sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
3988
3989         if (nemb_tp == nemb_mse) {
3990                 ext_buf_cnt = bsg_bf_get(lpfc_mbox_hdr_mse_cnt,
3991                         &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr);
3992                 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) {
3993                         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3994                                         "2953 Failed SLI_CONFIG(mse) wr, "
3995                                         "ext_buf_cnt(%d) out of range(%d)\n",
3996                                         ext_buf_cnt,
3997                                         LPFC_MBX_SLI_CONFIG_MAX_MSE);
3998                         return -ERANGE;
3999                 }
4000                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4001                                 "2949 Handled SLI_CONFIG(mse) wr, "
4002                                 "ext_buf_cnt:%d\n", ext_buf_cnt);
4003         } else {
4004                 /* sanity check on interface type for support */
4005                 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
4006                     LPFC_SLI_INTF_IF_TYPE_2)
4007                         return -ENODEV;
4008                 /* nemb_tp == nemb_hbd */
4009                 ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count;
4010                 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) {
4011                         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4012                                         "2954 Failed SLI_CONFIG(hbd) wr, "
4013                                         "ext_buf_cnt(%d) out of range(%d)\n",
4014                                         ext_buf_cnt,
4015                                         LPFC_MBX_SLI_CONFIG_MAX_HBD);
4016                         return -ERANGE;
4017                 }
4018                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4019                                 "2950 Handled SLI_CONFIG(hbd) wr, "
4020                                 "ext_buf_cnt:%d\n", ext_buf_cnt);
4021         }
4022
4023         /* before dma buffer descriptor setup */
4024         lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_wr, dma_mbox,
4025                                         sta_pre_addr, dmabuf, ext_buf_cnt);
4026
4027         if (ext_buf_cnt == 0)
4028                 return -EPERM;
4029
4030         /* for the first external buffer */
4031         lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, 0, dmabuf, dmabuf);
4032
4033         /* after dma descriptor setup */
4034         lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_wr, dma_mbox,
4035                                         sta_pos_addr, dmabuf, ext_buf_cnt);
4036
4037         /* log for looking forward */
4038         for (i = 1; i < ext_buf_cnt; i++) {
4039                 if (nemb_tp == nemb_mse)
4040                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4041                                 "2951 SLI_CONFIG(mse), buf[%d]-length:%d\n",
4042                                 i, sli_cfg_mbx->un.sli_config_emb0_subsys.
4043                                 mse[i].buf_len);
4044                 else
4045                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4046                                 "2952 SLI_CONFIG(hbd), buf[%d]-length:%d\n",
4047                                 i, bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
4048                                 &sli_cfg_mbx->un.sli_config_emb1_subsys.
4049                                 hbd[i]));
4050         }
4051
4052         /* multi-buffer handling context */
4053         phba->mbox_ext_buf_ctx.nembType = nemb_tp;
4054         phba->mbox_ext_buf_ctx.mboxType = mbox_wr;
4055         phba->mbox_ext_buf_ctx.numBuf = ext_buf_cnt;
4056         phba->mbox_ext_buf_ctx.mbxTag = mbox_req->extMboxTag;
4057         phba->mbox_ext_buf_ctx.seqNum = mbox_req->extSeqNum;
4058         phba->mbox_ext_buf_ctx.mbx_dmabuf = dmabuf;
4059
4060         if (ext_buf_cnt == 1) {
4061                 /* bsg tracking structure */
4062                 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
4063                 if (!dd_data) {
4064                         rc = -ENOMEM;
4065                         goto job_error;
4066                 }
4067
4068                 /* mailbox command structure for base driver */
4069                 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4070                 if (!pmboxq) {
4071                         rc = -ENOMEM;
4072                         goto job_error;
4073                 }
4074                 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4075                 pmb = &pmboxq->u.mb;
4076                 mbx = (uint8_t *)dmabuf->virt;
4077                 memcpy(pmb, mbx, sizeof(*pmb));
4078                 pmb->mbxOwner = OWN_HOST;
4079                 pmboxq->vport = phba->pport;
4080
4081                 /* callback for multi-buffer read mailbox command */
4082                 pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
4083
4084                 /* context fields to callback function */
4085                 pmboxq->context1 = dd_data;
4086                 dd_data->type = TYPE_MBOX;
4087                 dd_data->set_job = job;
4088                 dd_data->context_un.mbox.pmboxq = pmboxq;
4089                 dd_data->context_un.mbox.mb = (MAILBOX_t *)mbx;
4090                 job->dd_data = dd_data;
4091
4092                 /* state change */
4093
4094                 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
4095                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
4096                 if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
4097                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4098                                         "2955 Issued SLI_CONFIG ext-buffer "
4099                                         "maibox command, rc:x%x\n", rc);
4100                         return SLI_CONFIG_HANDLED;
4101                 }
4102                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4103                                 "2956 Failed to issue SLI_CONFIG ext-buffer "
4104                                 "maibox command, rc:x%x\n", rc);
4105                 rc = -EPIPE;
4106                 goto job_error;
4107         }
4108
4109         /* wait for additoinal external buffers */
4110
4111         job->reply->result = 0;
4112         job->job_done(job);
4113         return SLI_CONFIG_HANDLED;
4114
4115 job_error:
4116         if (pmboxq)
4117                 mempool_free(pmboxq, phba->mbox_mem_pool);
4118         kfree(dd_data);
4119
4120         return rc;
4121 }
4122
4123 /**
4124  * lpfc_bsg_handle_sli_cfg_mbox - handle sli-cfg mailbox cmd with ext buffer
4125  * @phba: Pointer to HBA context object.
4126  * @mb: Pointer to a BSG mailbox object.
4127  * @dmabuff: Pointer to a DMA buffer descriptor.
4128  *
4129  * This routine handles SLI_CONFIG (0x9B) mailbox command with non-embedded
4130  * external bufffers, including both 0x9B with non-embedded MSEs and 0x9B
4131  * with embedded sussystem 0x1 and opcodes with external HBDs.
4132  **/
4133 static int
4134 lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
4135                              struct lpfc_dmabuf *dmabuf)
4136 {
4137         struct lpfc_sli_config_mbox *sli_cfg_mbx;
4138         uint32_t subsys;
4139         uint32_t opcode;
4140         int rc = SLI_CONFIG_NOT_HANDLED;
4141
4142         /* state change on new multi-buffer pass-through mailbox command */
4143         phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_HOST;
4144
4145         sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
4146
4147         if (!bsg_bf_get(lpfc_mbox_hdr_emb,
4148             &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) {
4149                 subsys = bsg_bf_get(lpfc_emb0_subcmnd_subsys,
4150                                     &sli_cfg_mbx->un.sli_config_emb0_subsys);
4151                 opcode = bsg_bf_get(lpfc_emb0_subcmnd_opcode,
4152                                     &sli_cfg_mbx->un.sli_config_emb0_subsys);
4153                 if (subsys == SLI_CONFIG_SUBSYS_FCOE) {
4154                         switch (opcode) {
4155                         case FCOE_OPCODE_READ_FCF:
4156                         case FCOE_OPCODE_GET_DPORT_RESULTS:
4157                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4158                                                 "2957 Handled SLI_CONFIG "
4159                                                 "subsys_fcoe, opcode:x%x\n",
4160                                                 opcode);
4161                                 rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
4162                                                         nemb_mse, dmabuf);
4163                                 break;
4164                         case FCOE_OPCODE_ADD_FCF:
4165                         case FCOE_OPCODE_SET_DPORT_MODE:
4166                         case LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE:
4167                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4168                                                 "2958 Handled SLI_CONFIG "
4169                                                 "subsys_fcoe, opcode:x%x\n",
4170                                                 opcode);
4171                                 rc = lpfc_bsg_sli_cfg_write_cmd_ext(phba, job,
4172                                                         nemb_mse, dmabuf);
4173                                 break;
4174                         default:
4175                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4176                                                 "2959 Reject SLI_CONFIG "
4177                                                 "subsys_fcoe, opcode:x%x\n",
4178                                                 opcode);
4179                                 rc = -EPERM;
4180                                 break;
4181                         }
4182                 } else if (subsys == SLI_CONFIG_SUBSYS_COMN) {
4183                         switch (opcode) {
4184                         case COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES:
4185                         case COMN_OPCODE_GET_CNTL_ATTRIBUTES:
4186                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4187                                                 "3106 Handled SLI_CONFIG "
4188                                                 "subsys_comn, opcode:x%x\n",
4189                                                 opcode);
4190                                 rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
4191                                                         nemb_mse, dmabuf);
4192                                 break;
4193                         default:
4194                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4195                                                 "3107 Reject SLI_CONFIG "
4196                                                 "subsys_comn, opcode:x%x\n",
4197                                                 opcode);
4198                                 rc = -EPERM;
4199                                 break;
4200                         }
4201                 } else {
4202                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4203                                         "2977 Reject SLI_CONFIG "
4204                                         "subsys:x%d, opcode:x%x\n",
4205                                         subsys, opcode);
4206                         rc = -EPERM;
4207                 }
4208         } else {
4209                 subsys = bsg_bf_get(lpfc_emb1_subcmnd_subsys,
4210                                     &sli_cfg_mbx->un.sli_config_emb1_subsys);
4211                 opcode = bsg_bf_get(lpfc_emb1_subcmnd_opcode,
4212                                     &sli_cfg_mbx->un.sli_config_emb1_subsys);
4213                 if (subsys == SLI_CONFIG_SUBSYS_COMN) {
4214                         switch (opcode) {
4215                         case COMN_OPCODE_READ_OBJECT:
4216                         case COMN_OPCODE_READ_OBJECT_LIST:
4217                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4218                                                 "2960 Handled SLI_CONFIG "
4219                                                 "subsys_comn, opcode:x%x\n",
4220                                                 opcode);
4221                                 rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
4222                                                         nemb_hbd, dmabuf);
4223                                 break;
4224                         case COMN_OPCODE_WRITE_OBJECT:
4225                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4226                                                 "2961 Handled SLI_CONFIG "
4227                                                 "subsys_comn, opcode:x%x\n",
4228                                                 opcode);
4229                                 rc = lpfc_bsg_sli_cfg_write_cmd_ext(phba, job,
4230                                                         nemb_hbd, dmabuf);
4231                                 break;
4232                         default:
4233                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4234                                                 "2962 Not handled SLI_CONFIG "
4235                                                 "subsys_comn, opcode:x%x\n",
4236                                                 opcode);
4237                                 rc = SLI_CONFIG_NOT_HANDLED;
4238                                 break;
4239                         }
4240                 } else {
4241                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4242                                         "2978 Not handled SLI_CONFIG "
4243                                         "subsys:x%d, opcode:x%x\n",
4244                                         subsys, opcode);
4245                         rc = SLI_CONFIG_NOT_HANDLED;
4246                 }
4247         }
4248
4249         /* state reset on not handled new multi-buffer mailbox command */
4250         if (rc != SLI_CONFIG_HANDLED)
4251                 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_IDLE;
4252
4253         return rc;
4254 }
4255
4256 /**
4257  * lpfc_bsg_mbox_ext_abort_req - request to abort mbox command with ext buffers
4258  * @phba: Pointer to HBA context object.
4259  *
4260  * This routine is for requesting to abort a pass-through mailbox command with
4261  * multiple external buffers due to error condition.
4262  **/
4263 static void
4264 lpfc_bsg_mbox_ext_abort(struct lpfc_hba *phba)
4265 {
4266         if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_PORT)
4267                 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_ABTS;
4268         else
4269                 lpfc_bsg_mbox_ext_session_reset(phba);
4270         return;
4271 }
4272
4273 /**
4274  * lpfc_bsg_read_ebuf_get - get the next mailbox read external buffer
4275  * @phba: Pointer to HBA context object.
4276  * @dmabuf: Pointer to a DMA buffer descriptor.
4277  *
4278  * This routine extracts the next mailbox read external buffer back to
4279  * user space through BSG.
4280  **/
4281 static int
4282 lpfc_bsg_read_ebuf_get(struct lpfc_hba *phba, struct fc_bsg_job *job)
4283 {
4284         struct lpfc_sli_config_mbox *sli_cfg_mbx;
4285         struct lpfc_dmabuf *dmabuf;
4286         uint8_t *pbuf;
4287         uint32_t size;
4288         uint32_t index;
4289
4290         index = phba->mbox_ext_buf_ctx.seqNum;
4291         phba->mbox_ext_buf_ctx.seqNum++;
4292
4293         sli_cfg_mbx = (struct lpfc_sli_config_mbox *)
4294                         phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
4295
4296         if (phba->mbox_ext_buf_ctx.nembType == nemb_mse) {
4297                 size = bsg_bf_get(lpfc_mbox_sli_config_mse_len,
4298                         &sli_cfg_mbx->un.sli_config_emb0_subsys.mse[index]);
4299                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4300                                 "2963 SLI_CONFIG (mse) ext-buffer rd get "
4301                                 "buffer[%d], size:%d\n", index, size);
4302         } else {
4303                 size = bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
4304                         &sli_cfg_mbx->un.sli_config_emb1_subsys.hbd[index]);
4305                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4306                                 "2964 SLI_CONFIG (hbd) ext-buffer rd get "
4307                                 "buffer[%d], size:%d\n", index, size);
4308         }
4309         if (list_empty(&phba->mbox_ext_buf_ctx.ext_dmabuf_list))
4310                 return -EPIPE;
4311         dmabuf = list_first_entry(&phba->mbox_ext_buf_ctx.ext_dmabuf_list,
4312                                   struct lpfc_dmabuf, list);
4313         list_del_init(&dmabuf->list);
4314
4315         /* after dma buffer descriptor setup */
4316         lpfc_idiag_mbxacc_dump_bsg_mbox(phba, phba->mbox_ext_buf_ctx.nembType,
4317                                         mbox_rd, dma_ebuf, sta_pos_addr,
4318                                         dmabuf, index);
4319
4320         pbuf = (uint8_t *)dmabuf->virt;
4321         job->reply->reply_payload_rcv_len =
4322                 sg_copy_from_buffer(job->reply_payload.sg_list,
4323                                     job->reply_payload.sg_cnt,
4324                                     pbuf, size);
4325
4326         lpfc_bsg_dma_page_free(phba, dmabuf);
4327
4328         if (phba->mbox_ext_buf_ctx.seqNum == phba->mbox_ext_buf_ctx.numBuf) {
4329                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4330                                 "2965 SLI_CONFIG (hbd) ext-buffer rd mbox "
4331                                 "command session done\n");
4332                 lpfc_bsg_mbox_ext_session_reset(phba);
4333         }
4334
4335         job->reply->result = 0;
4336         job->job_done(job);
4337
4338         return SLI_CONFIG_HANDLED;
4339 }
4340
4341 /**
4342  * lpfc_bsg_write_ebuf_set - set the next mailbox write external buffer
4343  * @phba: Pointer to HBA context object.
4344  * @dmabuf: Pointer to a DMA buffer descriptor.
4345  *
4346  * This routine sets up the next mailbox read external buffer obtained
4347  * from user space through BSG.
4348  **/
4349 static int
4350 lpfc_bsg_write_ebuf_set(struct lpfc_hba *phba, struct fc_bsg_job *job,
4351                         struct lpfc_dmabuf *dmabuf)
4352 {
4353         struct lpfc_sli_config_mbox *sli_cfg_mbx;
4354         struct bsg_job_data *dd_data = NULL;
4355         LPFC_MBOXQ_t *pmboxq = NULL;
4356         MAILBOX_t *pmb;
4357         enum nemb_type nemb_tp;
4358         uint8_t *pbuf;
4359         uint32_t size;
4360         uint32_t index;
4361         int rc;
4362
4363         index = phba->mbox_ext_buf_ctx.seqNum;
4364         phba->mbox_ext_buf_ctx.seqNum++;
4365         nemb_tp = phba->mbox_ext_buf_ctx.nembType;
4366
4367         sli_cfg_mbx = (struct lpfc_sli_config_mbox *)
4368                         phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
4369
4370         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
4371         if (!dd_data) {
4372                 rc = -ENOMEM;
4373                 goto job_error;
4374         }
4375
4376         pbuf = (uint8_t *)dmabuf->virt;
4377         size = job->request_payload.payload_len;
4378         sg_copy_to_buffer(job->request_payload.sg_list,
4379                           job->request_payload.sg_cnt,
4380                           pbuf, size);
4381
4382         if (phba->mbox_ext_buf_ctx.nembType == nemb_mse) {
4383                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4384                                 "2966 SLI_CONFIG (mse) ext-buffer wr set "
4385                                 "buffer[%d], size:%d\n",
4386                                 phba->mbox_ext_buf_ctx.seqNum, size);
4387
4388         } else {
4389                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4390                                 "2967 SLI_CONFIG (hbd) ext-buffer wr set "
4391                                 "buffer[%d], size:%d\n",
4392                                 phba->mbox_ext_buf_ctx.seqNum, size);
4393
4394         }
4395
4396         /* set up external buffer descriptor and add to external buffer list */
4397         lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, index,
4398                                         phba->mbox_ext_buf_ctx.mbx_dmabuf,
4399                                         dmabuf);
4400         list_add_tail(&dmabuf->list, &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
4401
4402         /* after write dma buffer */
4403         lpfc_idiag_mbxacc_dump_bsg_mbox(phba, phba->mbox_ext_buf_ctx.nembType,
4404                                         mbox_wr, dma_ebuf, sta_pos_addr,
4405                                         dmabuf, index);
4406
4407         if (phba->mbox_ext_buf_ctx.seqNum == phba->mbox_ext_buf_ctx.numBuf) {
4408                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4409                                 "2968 SLI_CONFIG ext-buffer wr all %d "
4410                                 "ebuffers received\n",
4411                                 phba->mbox_ext_buf_ctx.numBuf);
4412                 /* mailbox command structure for base driver */
4413                 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4414                 if (!pmboxq) {
4415                         rc = -ENOMEM;
4416                         goto job_error;
4417                 }
4418                 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4419                 pbuf = (uint8_t *)phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
4420                 pmb = &pmboxq->u.mb;
4421                 memcpy(pmb, pbuf, sizeof(*pmb));
4422                 pmb->mbxOwner = OWN_HOST;
4423                 pmboxq->vport = phba->pport;
4424
4425                 /* callback for multi-buffer write mailbox command */
4426                 pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
4427
4428                 /* context fields to callback function */
4429                 pmboxq->context1 = dd_data;
4430                 dd_data->type = TYPE_MBOX;
4431                 dd_data->set_job = job;
4432                 dd_data->context_un.mbox.pmboxq = pmboxq;
4433                 dd_data->context_un.mbox.mb = (MAILBOX_t *)pbuf;
4434                 job->dd_data = dd_data;
4435
4436                 /* state change */
4437                 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
4438
4439                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
4440                 if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
4441                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4442                                         "2969 Issued SLI_CONFIG ext-buffer "
4443                                         "maibox command, rc:x%x\n", rc);
4444                         return SLI_CONFIG_HANDLED;
4445                 }
4446                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4447                                 "2970 Failed to issue SLI_CONFIG ext-buffer "
4448                                 "maibox command, rc:x%x\n", rc);
4449                 rc = -EPIPE;
4450                 goto job_error;
4451         }
4452
4453         /* wait for additoinal external buffers */
4454         job->reply->result = 0;
4455         job->job_done(job);
4456         return SLI_CONFIG_HANDLED;
4457
4458 job_error:
4459         lpfc_bsg_dma_page_free(phba, dmabuf);
4460         kfree(dd_data);
4461
4462         return rc;
4463 }
4464
4465 /**
4466  * lpfc_bsg_handle_sli_cfg_ebuf - handle ext buffer with sli-cfg mailbox cmd
4467  * @phba: Pointer to HBA context object.
4468  * @mb: Pointer to a BSG mailbox object.
4469  * @dmabuff: Pointer to a DMA buffer descriptor.
4470  *
4471  * This routine handles the external buffer with SLI_CONFIG (0x9B) mailbox
4472  * command with multiple non-embedded external buffers.
4473  **/
4474 static int
4475 lpfc_bsg_handle_sli_cfg_ebuf(struct lpfc_hba *phba, struct fc_bsg_job *job,
4476                              struct lpfc_dmabuf *dmabuf)
4477 {
4478         int rc;
4479
4480         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4481                         "2971 SLI_CONFIG buffer (type:x%x)\n",
4482                         phba->mbox_ext_buf_ctx.mboxType);
4483
4484         if (phba->mbox_ext_buf_ctx.mboxType == mbox_rd) {
4485                 if (phba->mbox_ext_buf_ctx.state != LPFC_BSG_MBOX_DONE) {
4486                         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4487                                         "2972 SLI_CONFIG rd buffer state "
4488                                         "mismatch:x%x\n",
4489                                         phba->mbox_ext_buf_ctx.state);
4490                         lpfc_bsg_mbox_ext_abort(phba);
4491                         return -EPIPE;
4492                 }
4493                 rc = lpfc_bsg_read_ebuf_get(phba, job);
4494                 if (rc == SLI_CONFIG_HANDLED)
4495                         lpfc_bsg_dma_page_free(phba, dmabuf);
4496         } else { /* phba->mbox_ext_buf_ctx.mboxType == mbox_wr */
4497                 if (phba->mbox_ext_buf_ctx.state != LPFC_BSG_MBOX_HOST) {
4498                         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4499                                         "2973 SLI_CONFIG wr buffer state "
4500                                         "mismatch:x%x\n",
4501                                         phba->mbox_ext_buf_ctx.state);
4502                         lpfc_bsg_mbox_ext_abort(phba);
4503                         return -EPIPE;
4504                 }
4505                 rc = lpfc_bsg_write_ebuf_set(phba, job, dmabuf);
4506         }
4507         return rc;
4508 }
4509
4510 /**
4511  * lpfc_bsg_handle_sli_cfg_ext - handle sli-cfg mailbox with external buffer
4512  * @phba: Pointer to HBA context object.
4513  * @mb: Pointer to a BSG mailbox object.
4514  * @dmabuff: Pointer to a DMA buffer descriptor.
4515  *
4516  * This routine checkes and handles non-embedded multi-buffer SLI_CONFIG
4517  * (0x9B) mailbox commands and external buffers.
4518  **/
4519 static int
4520 lpfc_bsg_handle_sli_cfg_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
4521                             struct lpfc_dmabuf *dmabuf)
4522 {
4523         struct dfc_mbox_req *mbox_req;
4524         int rc = SLI_CONFIG_NOT_HANDLED;
4525
4526         mbox_req =
4527            (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
4528
4529         /* mbox command with/without single external buffer */
4530         if (mbox_req->extMboxTag == 0 && mbox_req->extSeqNum == 0)
4531                 return rc;
4532
4533         /* mbox command and first external buffer */
4534         if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_IDLE) {
4535                 if (mbox_req->extSeqNum == 1) {
4536                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4537                                         "2974 SLI_CONFIG mailbox: tag:%d, "
4538                                         "seq:%d\n", mbox_req->extMboxTag,
4539                                         mbox_req->extSeqNum);
4540                         rc = lpfc_bsg_handle_sli_cfg_mbox(phba, job, dmabuf);
4541                         return rc;
4542                 } else
4543                         goto sli_cfg_ext_error;
4544         }
4545
4546         /*
4547          * handle additional external buffers
4548          */
4549
4550         /* check broken pipe conditions */
4551         if (mbox_req->extMboxTag != phba->mbox_ext_buf_ctx.mbxTag)
4552                 goto sli_cfg_ext_error;
4553         if (mbox_req->extSeqNum > phba->mbox_ext_buf_ctx.numBuf)
4554                 goto sli_cfg_ext_error;
4555         if (mbox_req->extSeqNum != phba->mbox_ext_buf_ctx.seqNum + 1)
4556                 goto sli_cfg_ext_error;
4557
4558         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4559                         "2975 SLI_CONFIG mailbox external buffer: "
4560                         "extSta:x%x, tag:%d, seq:%d\n",
4561                         phba->mbox_ext_buf_ctx.state, mbox_req->extMboxTag,
4562                         mbox_req->extSeqNum);
4563         rc = lpfc_bsg_handle_sli_cfg_ebuf(phba, job, dmabuf);
4564         return rc;
4565
4566 sli_cfg_ext_error:
4567         /* all other cases, broken pipe */
4568         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4569                         "2976 SLI_CONFIG mailbox broken pipe: "
4570                         "ctxSta:x%x, ctxNumBuf:%d "
4571                         "ctxTag:%d, ctxSeq:%d, tag:%d, seq:%d\n",
4572                         phba->mbox_ext_buf_ctx.state,
4573                         phba->mbox_ext_buf_ctx.numBuf,
4574                         phba->mbox_ext_buf_ctx.mbxTag,
4575                         phba->mbox_ext_buf_ctx.seqNum,
4576                         mbox_req->extMboxTag, mbox_req->extSeqNum);
4577
4578         lpfc_bsg_mbox_ext_session_reset(phba);
4579
4580         return -EPIPE;
4581 }
4582
4583 /**
4584  * lpfc_bsg_issue_mbox - issues a mailbox command on behalf of an app
4585  * @phba: Pointer to HBA context object.
4586  * @mb: Pointer to a mailbox object.
4587  * @vport: Pointer to a vport object.
4588  *
4589  * Allocate a tracking object, mailbox command memory, get a mailbox
4590  * from the mailbox pool, copy the caller mailbox command.
4591  *
4592  * If offline and the sli is active we need to poll for the command (port is
4593  * being reset) and com-plete the job, otherwise issue the mailbox command and
4594  * let our completion handler finish the command.
4595  **/
4596 static uint32_t
4597 lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
4598         struct lpfc_vport *vport)
4599 {
4600         LPFC_MBOXQ_t *pmboxq = NULL; /* internal mailbox queue */
4601         MAILBOX_t *pmb; /* shortcut to the pmboxq mailbox */
4602         /* a 4k buffer to hold the mb and extended data from/to the bsg */
4603         uint8_t *pmbx = NULL;
4604         struct bsg_job_data *dd_data = NULL; /* bsg data tracking structure */
4605         struct lpfc_dmabuf *dmabuf = NULL;
4606         struct dfc_mbox_req *mbox_req;
4607         struct READ_EVENT_LOG_VAR *rdEventLog;
4608         uint32_t transmit_length, receive_length, mode;
4609         struct lpfc_mbx_sli4_config *sli4_config;
4610         struct lpfc_mbx_nembed_cmd *nembed_sge;
4611         struct mbox_header *header;
4612         struct ulp_bde64 *bde;
4613         uint8_t *ext = NULL;
4614         int rc = 0;
4615         uint8_t *from;
4616         uint32_t size;
4617
4618         /* in case no data is transferred */
4619         job->reply->reply_payload_rcv_len = 0;
4620
4621         /* sanity check to protect driver */
4622         if (job->reply_payload.payload_len > BSG_MBOX_SIZE ||
4623             job->request_payload.payload_len > BSG_MBOX_SIZE) {
4624                 rc = -ERANGE;
4625                 goto job_done;
4626         }
4627
4628         /*
4629          * Don't allow mailbox commands to be sent when blocked or when in
4630          * the middle of discovery
4631          */
4632          if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
4633                 rc = -EAGAIN;
4634                 goto job_done;
4635         }
4636
4637         mbox_req =
4638             (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
4639
4640         /* check if requested extended data lengths are valid */
4641         if ((mbox_req->inExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t)) ||
4642             (mbox_req->outExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t))) {
4643                 rc = -ERANGE;
4644                 goto job_done;
4645         }
4646
4647         dmabuf = lpfc_bsg_dma_page_alloc(phba);
4648         if (!dmabuf || !dmabuf->virt) {
4649                 rc = -ENOMEM;
4650                 goto job_done;
4651         }
4652
4653         /* Get the mailbox command or external buffer from BSG */
4654         pmbx = (uint8_t *)dmabuf->virt;
4655         size = job->request_payload.payload_len;
4656         sg_copy_to_buffer(job->request_payload.sg_list,
4657                           job->request_payload.sg_cnt, pmbx, size);
4658
4659         /* Handle possible SLI_CONFIG with non-embedded payloads */
4660         if (phba->sli_rev == LPFC_SLI_REV4) {
4661                 rc = lpfc_bsg_handle_sli_cfg_ext(phba, job, dmabuf);
4662                 if (rc == SLI_CONFIG_HANDLED)
4663                         goto job_cont;
4664                 if (rc)
4665                         goto job_done;
4666                 /* SLI_CONFIG_NOT_HANDLED for other mailbox commands */
4667         }
4668
4669         rc = lpfc_bsg_check_cmd_access(phba, (MAILBOX_t *)pmbx, vport);
4670         if (rc != 0)
4671                 goto job_done; /* must be negative */
4672
4673         /* allocate our bsg tracking structure */
4674         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
4675         if (!dd_data) {
4676                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
4677                                 "2727 Failed allocation of dd_data\n");
4678                 rc = -ENOMEM;
4679                 goto job_done;
4680         }
4681
4682         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4683         if (!pmboxq) {
4684                 rc = -ENOMEM;
4685                 goto job_done;
4686         }
4687         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4688
4689         pmb = &pmboxq->u.mb;
4690         memcpy(pmb, pmbx, sizeof(*pmb));
4691         pmb->mbxOwner = OWN_HOST;
4692         pmboxq->vport = vport;
4693
4694         /* If HBA encountered an error attention, allow only DUMP
4695          * or RESTART mailbox commands until the HBA is restarted.
4696          */
4697         if (phba->pport->stopped &&
4698             pmb->mbxCommand != MBX_DUMP_MEMORY &&
4699             pmb->mbxCommand != MBX_RESTART &&
4700             pmb->mbxCommand != MBX_WRITE_VPARMS &&
4701             pmb->mbxCommand != MBX_WRITE_WWN)
4702                 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
4703                                 "2797 mbox: Issued mailbox cmd "
4704                                 "0x%x while in stopped state.\n",
4705                                 pmb->mbxCommand);
4706
4707         /* extended mailbox commands will need an extended buffer */
4708         if (mbox_req->inExtWLen || mbox_req->outExtWLen) {
4709                 from = pmbx;
4710                 ext = from + sizeof(MAILBOX_t);
4711                 pmboxq->context2 = ext;
4712                 pmboxq->in_ext_byte_len =
4713                         mbox_req->inExtWLen * sizeof(uint32_t);
4714                 pmboxq->out_ext_byte_len =
4715                         mbox_req->outExtWLen * sizeof(uint32_t);
4716                 pmboxq->mbox_offset_word = mbox_req->mbOffset;
4717         }
4718
4719         /* biu diag will need a kernel buffer to transfer the data
4720          * allocate our own buffer and setup the mailbox command to
4721          * use ours
4722          */
4723         if (pmb->mbxCommand == MBX_RUN_BIU_DIAG64) {
4724                 transmit_length = pmb->un.varWords[1];
4725                 receive_length = pmb->un.varWords[4];
4726                 /* transmit length cannot be greater than receive length or
4727                  * mailbox extension size
4728                  */
4729                 if ((transmit_length > receive_length) ||
4730                         (transmit_length > BSG_MBOX_SIZE - sizeof(MAILBOX_t))) {
4731                         rc = -ERANGE;
4732                         goto job_done;
4733                 }
4734                 pmb->un.varBIUdiag.un.s2.xmit_bde64.addrHigh =
4735                         putPaddrHigh(dmabuf->phys + sizeof(MAILBOX_t));
4736                 pmb->un.varBIUdiag.un.s2.xmit_bde64.addrLow =
4737                         putPaddrLow(dmabuf->phys + sizeof(MAILBOX_t));
4738
4739                 pmb->un.varBIUdiag.un.s2.rcv_bde64.addrHigh =
4740                         putPaddrHigh(dmabuf->phys + sizeof(MAILBOX_t)
4741                           + pmb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize);
4742                 pmb->un.varBIUdiag.un.s2.rcv_bde64.addrLow =
4743                         putPaddrLow(dmabuf->phys + sizeof(MAILBOX_t)
4744                           + pmb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize);
4745         } else if (pmb->mbxCommand == MBX_READ_EVENT_LOG) {
4746                 rdEventLog = &pmb->un.varRdEventLog;
4747                 receive_length = rdEventLog->rcv_bde64.tus.f.bdeSize;
4748                 mode = bf_get(lpfc_event_log, rdEventLog);
4749
4750                 /* receive length cannot be greater than mailbox
4751                  * extension size
4752                  */
4753                 if (receive_length > BSG_MBOX_SIZE - sizeof(MAILBOX_t)) {
4754                         rc = -ERANGE;
4755                         goto job_done;
4756                 }
4757
4758                 /* mode zero uses a bde like biu diags command */
4759                 if (mode == 0) {
4760                         pmb->un.varWords[3] = putPaddrLow(dmabuf->phys
4761                                                         + sizeof(MAILBOX_t));
4762                         pmb->un.varWords[4] = putPaddrHigh(dmabuf->phys
4763                                                         + sizeof(MAILBOX_t));
4764                 }
4765         } else if (phba->sli_rev == LPFC_SLI_REV4) {
4766                 /* Let type 4 (well known data) through because the data is
4767                  * returned in varwords[4-8]
4768                  * otherwise check the recieve length and fetch the buffer addr
4769                  */
4770                 if ((pmb->mbxCommand == MBX_DUMP_MEMORY) &&
4771                         (pmb->un.varDmp.type != DMP_WELL_KNOWN)) {
4772                         /* rebuild the command for sli4 using our own buffers
4773                         * like we do for biu diags
4774                         */
4775                         receive_length = pmb->un.varWords[2];
4776                         /* receive length cannot be greater than mailbox
4777                          * extension size
4778                          */
4779                         if (receive_length == 0) {
4780                                 rc = -ERANGE;
4781                                 goto job_done;
4782                         }
4783                         pmb->un.varWords[3] = putPaddrLow(dmabuf->phys
4784                                                 + sizeof(MAILBOX_t));
4785                         pmb->un.varWords[4] = putPaddrHigh(dmabuf->phys
4786                                                 + sizeof(MAILBOX_t));
4787                 } else if ((pmb->mbxCommand == MBX_UPDATE_CFG) &&
4788                         pmb->un.varUpdateCfg.co) {
4789                         bde = (struct ulp_bde64 *)&pmb->un.varWords[4];
4790
4791                         /* bde size cannot be greater than mailbox ext size */
4792                         if (bde->tus.f.bdeSize >
4793                             BSG_MBOX_SIZE - sizeof(MAILBOX_t)) {
4794                                 rc = -ERANGE;
4795                                 goto job_done;
4796                         }
4797                         bde->addrHigh = putPaddrHigh(dmabuf->phys
4798                                                 + sizeof(MAILBOX_t));
4799                         bde->addrLow = putPaddrLow(dmabuf->phys
4800                                                 + sizeof(MAILBOX_t));
4801                 } else if (pmb->mbxCommand == MBX_SLI4_CONFIG) {
4802                         /* Handling non-embedded SLI_CONFIG mailbox command */
4803                         sli4_config = &pmboxq->u.mqe.un.sli4_config;
4804                         if (!bf_get(lpfc_mbox_hdr_emb,
4805                             &sli4_config->header.cfg_mhdr)) {
4806                                 /* rebuild the command for sli4 using our
4807                                  * own buffers like we do for biu diags
4808                                  */
4809                                 header = (struct mbox_header *)
4810                                                 &pmb->un.varWords[0];
4811                                 nembed_sge = (struct lpfc_mbx_nembed_cmd *)
4812                                                 &pmb->un.varWords[0];
4813                                 receive_length = nembed_sge->sge[0].length;
4814
4815                                 /* receive length cannot be greater than
4816                                  * mailbox extension size
4817                                  */
4818                                 if ((receive_length == 0) ||
4819                                     (receive_length >
4820                                      BSG_MBOX_SIZE - sizeof(MAILBOX_t))) {
4821                                         rc = -ERANGE;
4822                                         goto job_done;
4823                                 }
4824
4825                                 nembed_sge->sge[0].pa_hi =
4826                                                 putPaddrHigh(dmabuf->phys
4827                                                    + sizeof(MAILBOX_t));
4828                                 nembed_sge->sge[0].pa_lo =
4829                                                 putPaddrLow(dmabuf->phys
4830                                                    + sizeof(MAILBOX_t));
4831                         }
4832                 }
4833         }
4834
4835         dd_data->context_un.mbox.dmabuffers = dmabuf;
4836
4837         /* setup wake call as IOCB callback */
4838         pmboxq->mbox_cmpl = lpfc_bsg_issue_mbox_cmpl;
4839
4840         /* setup context field to pass wait_queue pointer to wake function */
4841         pmboxq->context1 = dd_data;
4842         dd_data->type = TYPE_MBOX;
4843         dd_data->set_job = job;
4844         dd_data->context_un.mbox.pmboxq = pmboxq;
4845         dd_data->context_un.mbox.mb = (MAILBOX_t *)pmbx;
4846         dd_data->context_un.mbox.ext = ext;
4847         dd_data->context_un.mbox.mbOffset = mbox_req->mbOffset;
4848         dd_data->context_un.mbox.inExtWLen = mbox_req->inExtWLen;
4849         dd_data->context_un.mbox.outExtWLen = mbox_req->outExtWLen;
4850         job->dd_data = dd_data;
4851
4852         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4853             (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE))) {
4854                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4855                 if (rc != MBX_SUCCESS) {
4856                         rc = (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
4857                         goto job_done;
4858                 }
4859
4860                 /* job finished, copy the data */
4861                 memcpy(pmbx, pmb, sizeof(*pmb));
4862                 job->reply->reply_payload_rcv_len =
4863                         sg_copy_from_buffer(job->reply_payload.sg_list,
4864                                             job->reply_payload.sg_cnt,
4865                                             pmbx, size);
4866                 /* not waiting mbox already done */
4867                 rc = 0;
4868                 goto job_done;
4869         }
4870
4871         rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
4872         if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY))
4873                 return 1; /* job started */
4874
4875 job_done:
4876         /* common exit for error or job completed inline */
4877         if (pmboxq)
4878                 mempool_free(pmboxq, phba->mbox_mem_pool);
4879         lpfc_bsg_dma_page_free(phba, dmabuf);
4880         kfree(dd_data);
4881
4882 job_cont:
4883         return rc;
4884 }
4885
4886 /**
4887  * lpfc_bsg_mbox_cmd - process an fc bsg LPFC_BSG_VENDOR_MBOX command
4888  * @job: MBOX fc_bsg_job for LPFC_BSG_VENDOR_MBOX.
4889  **/
4890 static int
4891 lpfc_bsg_mbox_cmd(struct fc_bsg_job *job)
4892 {
4893         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
4894         struct lpfc_hba *phba = vport->phba;
4895         struct dfc_mbox_req *mbox_req;
4896         int rc = 0;
4897
4898         /* mix-and-match backward compatibility */
4899         job->reply->reply_payload_rcv_len = 0;
4900         if (job->request_len <
4901             sizeof(struct fc_bsg_request) + sizeof(struct dfc_mbox_req)) {
4902                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4903                                 "2737 Mix-and-match backward compatibility "
4904                                 "between MBOX_REQ old size:%d and "
4905                                 "new request size:%d\n",
4906                                 (int)(job->request_len -
4907                                       sizeof(struct fc_bsg_request)),
4908                                 (int)sizeof(struct dfc_mbox_req));
4909                 mbox_req = (struct dfc_mbox_req *)
4910                                 job->request->rqst_data.h_vendor.vendor_cmd;
4911                 mbox_req->extMboxTag = 0;
4912                 mbox_req->extSeqNum = 0;
4913         }
4914
4915         rc = lpfc_bsg_issue_mbox(phba, job, vport);
4916
4917         if (rc == 0) {
4918                 /* job done */
4919                 job->reply->result = 0;
4920                 job->dd_data = NULL;
4921                 job->job_done(job);
4922         } else if (rc == 1)
4923                 /* job submitted, will complete later*/
4924                 rc = 0; /* return zero, no error */
4925         else {
4926                 /* some error occurred */
4927                 job->reply->result = rc;
4928                 job->dd_data = NULL;
4929         }
4930
4931         return rc;
4932 }
4933
4934 /**
4935  * lpfc_bsg_menlo_cmd_cmp - lpfc_menlo_cmd completion handler
4936  * @phba: Pointer to HBA context object.
4937  * @cmdiocbq: Pointer to command iocb.
4938  * @rspiocbq: Pointer to response iocb.
4939  *
4940  * This function is the completion handler for iocbs issued using
4941  * lpfc_menlo_cmd function. This function is called by the
4942  * ring event handler function without any lock held. This function
4943  * can be called from both worker thread context and interrupt
4944  * context. This function also can be called from another thread which
4945  * cleans up the SLI layer objects.
4946  * This function copies the contents of the response iocb to the
4947  * response iocb memory object provided by the caller of
4948  * lpfc_sli_issue_iocb_wait and then wakes up the thread which
4949  * sleeps for the iocb completion.
4950  **/
4951 static void
4952 lpfc_bsg_menlo_cmd_cmp(struct lpfc_hba *phba,
4953                         struct lpfc_iocbq *cmdiocbq,
4954                         struct lpfc_iocbq *rspiocbq)
4955 {
4956         struct bsg_job_data *dd_data;
4957         struct fc_bsg_job *job;
4958         IOCB_t *rsp;
4959         struct lpfc_dmabuf *bmp, *cmp, *rmp;
4960         struct lpfc_bsg_menlo *menlo;
4961         unsigned long flags;
4962         struct menlo_response *menlo_resp;
4963         unsigned int rsp_size;
4964         int rc = 0;
4965
4966         dd_data = cmdiocbq->context1;
4967         cmp = cmdiocbq->context2;
4968         bmp = cmdiocbq->context3;
4969         menlo = &dd_data->context_un.menlo;
4970         rmp = menlo->rmp;
4971         rsp = &rspiocbq->iocb;
4972
4973         /* Determine if job has been aborted */
4974         spin_lock_irqsave(&phba->ct_ev_lock, flags);
4975         job = dd_data->set_job;
4976         if (job) {
4977                 /* Prevent timeout handling from trying to abort job  */
4978                 job->dd_data = NULL;
4979         }
4980         spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
4981
4982         /* Copy the job data or set the failing status for the job */
4983
4984         if (job) {
4985                 /* always return the xri, this would be used in the case
4986                  * of a menlo download to allow the data to be sent as a
4987                  * continuation of the exchange.
4988                  */
4989
4990                 menlo_resp = (struct menlo_response *)
4991                         job->reply->reply_data.vendor_reply.vendor_rsp;
4992                 menlo_resp->xri = rsp->ulpContext;
4993                 if (rsp->ulpStatus) {
4994                         if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
4995                                 switch (rsp->un.ulpWord[4] & IOERR_PARAM_MASK) {
4996                                 case IOERR_SEQUENCE_TIMEOUT:
4997                                         rc = -ETIMEDOUT;
4998                                         break;
4999                                 case IOERR_INVALID_RPI:
5000                                         rc = -EFAULT;
5001                                         break;
5002                                 default:
5003                                         rc = -EACCES;
5004                                         break;
5005                                 }
5006                         } else {
5007                                 rc = -EACCES;
5008                         }
5009                 } else {
5010                         rsp_size = rsp->un.genreq64.bdl.bdeSize;
5011                         job->reply->reply_payload_rcv_len =
5012                                 lpfc_bsg_copy_data(rmp, &job->reply_payload,
5013                                                    rsp_size, 0);
5014                 }
5015
5016         }
5017
5018         lpfc_sli_release_iocbq(phba, cmdiocbq);
5019         lpfc_free_bsg_buffers(phba, cmp);
5020         lpfc_free_bsg_buffers(phba, rmp);
5021         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
5022         kfree(bmp);
5023         kfree(dd_data);
5024
5025         /* Complete the job if active */
5026
5027         if (job) {
5028                 job->reply->result = rc;
5029                 job->job_done(job);
5030         }
5031
5032         return;
5033 }
5034
5035 /**
5036  * lpfc_menlo_cmd - send an ioctl for menlo hardware
5037  * @job: fc_bsg_job to handle
5038  *
5039  * This function issues a gen request 64 CR ioctl for all menlo cmd requests,
5040  * all the command completions will return the xri for the command.
5041  * For menlo data requests a gen request 64 CX is used to continue the exchange
5042  * supplied in the menlo request header xri field.
5043  **/
5044 static int
5045 lpfc_menlo_cmd(struct fc_bsg_job *job)
5046 {
5047         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
5048         struct lpfc_hba *phba = vport->phba;
5049         struct lpfc_iocbq *cmdiocbq;
5050         IOCB_t *cmd;
5051         int rc = 0;
5052         struct menlo_command *menlo_cmd;
5053         struct menlo_response *menlo_resp;
5054         struct lpfc_dmabuf *bmp = NULL, *cmp = NULL, *rmp = NULL;
5055         int request_nseg;
5056         int reply_nseg;
5057         struct bsg_job_data *dd_data;
5058         struct ulp_bde64 *bpl = NULL;
5059
5060         /* in case no data is returned return just the return code */
5061         job->reply->reply_payload_rcv_len = 0;
5062
5063         if (job->request_len <
5064             sizeof(struct fc_bsg_request) +
5065                 sizeof(struct menlo_command)) {
5066                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
5067                                 "2784 Received MENLO_CMD request below "
5068                                 "minimum size\n");
5069                 rc = -ERANGE;
5070                 goto no_dd_data;
5071         }
5072
5073         if (job->reply_len <
5074             sizeof(struct fc_bsg_request) + sizeof(struct menlo_response)) {
5075                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
5076                                 "2785 Received MENLO_CMD reply below "
5077                                 "minimum size\n");
5078                 rc = -ERANGE;
5079                 goto no_dd_data;
5080         }
5081
5082         if (!(phba->menlo_flag & HBA_MENLO_SUPPORT)) {
5083                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
5084                                 "2786 Adapter does not support menlo "
5085                                 "commands\n");
5086                 rc = -EPERM;
5087                 goto no_dd_data;
5088         }
5089
5090         menlo_cmd = (struct menlo_command *)
5091                 job->request->rqst_data.h_vendor.vendor_cmd;
5092
5093         menlo_resp = (struct menlo_response *)
5094                 job->reply->reply_data.vendor_reply.vendor_rsp;
5095
5096         /* allocate our bsg tracking structure */
5097         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
5098         if (!dd_data) {
5099                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
5100                                 "2787 Failed allocation of dd_data\n");
5101                 rc = -ENOMEM;
5102                 goto no_dd_data;
5103         }
5104
5105         bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
5106         if (!bmp) {
5107                 rc = -ENOMEM;
5108                 goto free_dd;
5109         }
5110
5111         bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
5112         if (!bmp->virt) {
5113                 rc = -ENOMEM;
5114                 goto free_bmp;
5115         }
5116
5117         INIT_LIST_HEAD(&bmp->list);
5118
5119         bpl = (struct ulp_bde64 *)bmp->virt;
5120         request_nseg = LPFC_BPL_SIZE/sizeof(struct ulp_bde64);
5121         cmp = lpfc_alloc_bsg_buffers(phba, job->request_payload.payload_len,
5122                                      1, bpl, &request_nseg);
5123         if (!cmp) {
5124                 rc = -ENOMEM;
5125                 goto free_bmp;
5126         }
5127         lpfc_bsg_copy_data(cmp, &job->request_payload,
5128                            job->request_payload.payload_len, 1);
5129
5130         bpl += request_nseg;
5131         reply_nseg = LPFC_BPL_SIZE/sizeof(struct ulp_bde64) - request_nseg;
5132         rmp = lpfc_alloc_bsg_buffers(phba, job->reply_payload.payload_len, 0,
5133                                      bpl, &reply_nseg);
5134         if (!rmp) {
5135                 rc = -ENOMEM;
5136                 goto free_cmp;
5137         }
5138
5139         cmdiocbq = lpfc_sli_get_iocbq(phba);
5140         if (!cmdiocbq) {
5141                 rc = -ENOMEM;
5142                 goto free_rmp;
5143         }
5144
5145         cmd = &cmdiocbq->iocb;
5146         cmd->un.genreq64.bdl.ulpIoTag32 = 0;
5147         cmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
5148         cmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
5149         cmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
5150         cmd->un.genreq64.bdl.bdeSize =
5151             (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
5152         cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
5153         cmd->un.genreq64.w5.hcsw.Dfctl = 0;
5154         cmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CMD;
5155         cmd->un.genreq64.w5.hcsw.Type = MENLO_TRANSPORT_TYPE; /* 0xfe */
5156         cmd->ulpBdeCount = 1;
5157         cmd->ulpClass = CLASS3;
5158         cmd->ulpOwner = OWN_CHIP;
5159         cmd->ulpLe = 1; /* Limited Edition */
5160         cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
5161         cmdiocbq->vport = phba->pport;
5162         /* We want the firmware to timeout before we do */
5163         cmd->ulpTimeout = MENLO_TIMEOUT - 5;
5164         cmdiocbq->iocb_cmpl = lpfc_bsg_menlo_cmd_cmp;
5165         cmdiocbq->context1 = dd_data;
5166         cmdiocbq->context2 = cmp;
5167         cmdiocbq->context3 = bmp;
5168         if (menlo_cmd->cmd == LPFC_BSG_VENDOR_MENLO_CMD) {
5169                 cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
5170                 cmd->ulpPU = MENLO_PU; /* 3 */
5171                 cmd->un.ulpWord[4] = MENLO_DID; /* 0x0000FC0E */
5172                 cmd->ulpContext = MENLO_CONTEXT; /* 0 */
5173         } else {
5174                 cmd->ulpCommand = CMD_GEN_REQUEST64_CX;
5175                 cmd->ulpPU = 1;
5176                 cmd->un.ulpWord[4] = 0;
5177                 cmd->ulpContext = menlo_cmd->xri;
5178         }
5179
5180         dd_data->type = TYPE_MENLO;
5181         dd_data->set_job = job;
5182         dd_data->context_un.menlo.cmdiocbq = cmdiocbq;
5183         dd_data->context_un.menlo.rmp = rmp;
5184         job->dd_data = dd_data;
5185
5186         rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq,
5187                 MENLO_TIMEOUT - 5);
5188         if (rc == IOCB_SUCCESS)
5189                 return 0; /* done for now */
5190
5191         lpfc_sli_release_iocbq(phba, cmdiocbq);
5192
5193 free_rmp:
5194         lpfc_free_bsg_buffers(phba, rmp);
5195 free_cmp:
5196         lpfc_free_bsg_buffers(phba, cmp);
5197 free_bmp:
5198         if (bmp->virt)
5199                 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
5200         kfree(bmp);
5201 free_dd:
5202         kfree(dd_data);
5203 no_dd_data:
5204         /* make error code available to userspace */
5205         job->reply->result = rc;
5206         job->dd_data = NULL;
5207         return rc;
5208 }
5209
5210 /**
5211  * lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
5212  * @job: fc_bsg_job to handle
5213  **/
5214 static int
5215 lpfc_bsg_hst_vendor(struct fc_bsg_job *job)
5216 {
5217         int command = job->request->rqst_data.h_vendor.vendor_cmd[0];
5218         int rc;
5219
5220         switch (command) {
5221         case LPFC_BSG_VENDOR_SET_CT_EVENT:
5222                 rc = lpfc_bsg_hba_set_event(job);
5223                 break;
5224         case LPFC_BSG_VENDOR_GET_CT_EVENT:
5225                 rc = lpfc_bsg_hba_get_event(job);
5226                 break;
5227         case LPFC_BSG_VENDOR_SEND_MGMT_RESP:
5228                 rc = lpfc_bsg_send_mgmt_rsp(job);
5229                 break;
5230         case LPFC_BSG_VENDOR_DIAG_MODE:
5231                 rc = lpfc_bsg_diag_loopback_mode(job);
5232                 break;
5233         case LPFC_BSG_VENDOR_DIAG_MODE_END:
5234                 rc = lpfc_sli4_bsg_diag_mode_end(job);
5235                 break;
5236         case LPFC_BSG_VENDOR_DIAG_RUN_LOOPBACK:
5237                 rc = lpfc_bsg_diag_loopback_run(job);
5238                 break;
5239         case LPFC_BSG_VENDOR_LINK_DIAG_TEST:
5240                 rc = lpfc_sli4_bsg_link_diag_test(job);
5241                 break;
5242         case LPFC_BSG_VENDOR_GET_MGMT_REV:
5243                 rc = lpfc_bsg_get_dfc_rev(job);
5244                 break;
5245         case LPFC_BSG_VENDOR_MBOX:
5246                 rc = lpfc_bsg_mbox_cmd(job);
5247                 break;
5248         case LPFC_BSG_VENDOR_MENLO_CMD:
5249         case LPFC_BSG_VENDOR_MENLO_DATA:
5250                 rc = lpfc_menlo_cmd(job);
5251                 break;
5252         default:
5253                 rc = -EINVAL;
5254                 job->reply->reply_payload_rcv_len = 0;
5255                 /* make error code available to userspace */
5256                 job->reply->result = rc;
5257                 break;
5258         }
5259
5260         return rc;
5261 }
5262
5263 /**
5264  * lpfc_bsg_request - handle a bsg request from the FC transport
5265  * @job: fc_bsg_job to handle
5266  **/
5267 int
5268 lpfc_bsg_request(struct fc_bsg_job *job)
5269 {
5270         uint32_t msgcode;
5271         int rc;
5272
5273         msgcode = job->request->msgcode;
5274         switch (msgcode) {
5275         case FC_BSG_HST_VENDOR:
5276                 rc = lpfc_bsg_hst_vendor(job);
5277                 break;
5278         case FC_BSG_RPT_ELS:
5279                 rc = lpfc_bsg_rport_els(job);
5280                 break;
5281         case FC_BSG_RPT_CT:
5282                 rc = lpfc_bsg_send_mgmt_cmd(job);
5283                 break;
5284         default:
5285                 rc = -EINVAL;
5286                 job->reply->reply_payload_rcv_len = 0;
5287                 /* make error code available to userspace */
5288                 job->reply->result = rc;
5289                 break;
5290         }
5291
5292         return rc;
5293 }
5294
5295 /**
5296  * lpfc_bsg_timeout - handle timeout of a bsg request from the FC transport
5297  * @job: fc_bsg_job that has timed out
5298  *
5299  * This function just aborts the job's IOCB.  The aborted IOCB will return to
5300  * the waiting function which will handle passing the error back to userspace
5301  **/
5302 int
5303 lpfc_bsg_timeout(struct fc_bsg_job *job)
5304 {
5305         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
5306         struct lpfc_hba *phba = vport->phba;
5307         struct lpfc_iocbq *cmdiocb;
5308         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
5309         struct bsg_job_data *dd_data;
5310         unsigned long flags;
5311         int rc = 0;
5312         LIST_HEAD(completions);
5313         struct lpfc_iocbq *check_iocb, *next_iocb;
5314
5315         /* if job's driver data is NULL, the command completed or is in the
5316          * the process of completing.  In this case, return status to request
5317          * so the timeout is retried.  This avoids double completion issues
5318          * and the request will be pulled off the timer queue when the
5319          * command's completion handler executes.  Otherwise, prevent the
5320          * command's completion handler from executing the job done callback
5321          * and continue processing to abort the outstanding the command.
5322          */
5323
5324         spin_lock_irqsave(&phba->ct_ev_lock, flags);
5325         dd_data = (struct bsg_job_data *)job->dd_data;
5326         if (dd_data) {
5327                 dd_data->set_job = NULL;
5328                 job->dd_data = NULL;
5329         } else {
5330                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5331                 return -EAGAIN;
5332         }
5333
5334         switch (dd_data->type) {
5335         case TYPE_IOCB:
5336                 /* Check to see if IOCB was issued to the port or not. If not,
5337                  * remove it from the txq queue and call cancel iocbs.
5338                  * Otherwise, call abort iotag
5339                  */
5340                 cmdiocb = dd_data->context_un.iocb.cmdiocbq;
5341                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5342
5343                 spin_lock_irqsave(&phba->hbalock, flags);
5344                 /* make sure the I/O abort window is still open */
5345                 if (!(cmdiocb->iocb_flag & LPFC_IO_CMD_OUTSTANDING)) {
5346                         spin_unlock_irqrestore(&phba->hbalock, flags);
5347                         return -EAGAIN;
5348                 }
5349                 list_for_each_entry_safe(check_iocb, next_iocb, &pring->txq,
5350                                          list) {
5351                         if (check_iocb == cmdiocb) {
5352                                 list_move_tail(&check_iocb->list, &completions);
5353                                 break;
5354                         }
5355                 }
5356                 if (list_empty(&completions))
5357                         lpfc_sli_issue_abort_iotag(phba, pring, cmdiocb);
5358                 spin_unlock_irqrestore(&phba->hbalock, flags);
5359                 if (!list_empty(&completions)) {
5360                         lpfc_sli_cancel_iocbs(phba, &completions,
5361                                               IOSTAT_LOCAL_REJECT,
5362                                               IOERR_SLI_ABORTED);
5363                 }
5364                 break;
5365
5366         case TYPE_EVT:
5367                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5368                 break;
5369
5370         case TYPE_MBOX:
5371                 /* Update the ext buf ctx state if needed */
5372
5373                 if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_PORT)
5374                         phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_ABTS;
5375                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5376                 break;
5377         case TYPE_MENLO:
5378                 /* Check to see if IOCB was issued to the port or not. If not,
5379                  * remove it from the txq queue and call cancel iocbs.
5380                  * Otherwise, call abort iotag.
5381                  */
5382                 cmdiocb = dd_data->context_un.menlo.cmdiocbq;
5383                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5384
5385                 spin_lock_irqsave(&phba->hbalock, flags);
5386                 list_for_each_entry_safe(check_iocb, next_iocb, &pring->txq,
5387                                          list) {
5388                         if (check_iocb == cmdiocb) {
5389                                 list_move_tail(&check_iocb->list, &completions);
5390                                 break;
5391                         }
5392                 }
5393                 if (list_empty(&completions))
5394                         lpfc_sli_issue_abort_iotag(phba, pring, cmdiocb);
5395                 spin_unlock_irqrestore(&phba->hbalock, flags);
5396                 if (!list_empty(&completions)) {
5397                         lpfc_sli_cancel_iocbs(phba, &completions,
5398                                               IOSTAT_LOCAL_REJECT,
5399                                               IOERR_SLI_ABORTED);
5400                 }
5401                 break;
5402         default:
5403                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5404                 break;
5405         }
5406
5407         /* scsi transport fc fc_bsg_job_timeout expects a zero return code,
5408          * otherwise an error message will be displayed on the console
5409          * so always return success (zero)
5410          */
5411         return rc;
5412 }