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