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