drivers/scsi/lpfc/lpfc_attr.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2017-2018 Broadcom. All Rights Reserved. The term *
   5  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.  *
   6  * Copyright (C) 2004-2016 Emulex.  All rights reserved.           *
   7  * EMULEX and SLI are trademarks of Emulex.                        *
   8  * www.broadcom.com                                                *
   9  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
  10  *                                                                 *
  11  * This program is free software; you can redistribute it and/or   *
  12  * modify it under the terms of version 2 of the GNU General       *
  13  * Public License as published by the Free Software Foundation.    *
  14  * This program is distributed in the hope that it will be useful. *
  15  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  16  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  17  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  18  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  19  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  20  * more details, a copy of which can be found in the file COPYING  *
  21  * included with this package.                                     *
  22  *******************************************************************/
  23
  24 #include <linux/ctype.h>
  25 #include <linux/delay.h>
  26 #include <linux/pci.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/module.h>
  29 #include <linux/aer.h>
  30 #include <linux/gfp.h>
  31 #include <linux/kernel.h>
  32
  33 #include <scsi/scsi.h>
  34 #include <scsi/scsi_device.h>
  35 #include <scsi/scsi_host.h>
  36 #include <scsi/scsi_tcq.h>
  37 #include <scsi/scsi_transport_fc.h>
  38 #include <scsi/fc/fc_fs.h>
  39
  40 #include <linux/nvme-fc-driver.h>
  41
  42 #include "lpfc_hw4.h"
  43 #include "lpfc_hw.h"
  44 #include "lpfc_sli.h"
  45 #include "lpfc_sli4.h"
  46 #include "lpfc_nl.h"
  47 #include "lpfc_disc.h"
  48 #include "lpfc.h"
  49 #include "lpfc_scsi.h"
  50 #include "lpfc_nvme.h"
  51 #include "lpfc_nvmet.h"
  52 #include "lpfc_logmsg.h"
  53 #include "lpfc_version.h"
  54 #include "lpfc_compat.h"
  55 #include "lpfc_crtn.h"
  56 #include "lpfc_vport.h"
  57 #include "lpfc_attr.h"
  58
  59 #define LPFC_DEF_DEVLOSS_TMO    30
  60 #define LPFC_MIN_DEVLOSS_TMO    1
  61 #define LPFC_MAX_DEVLOSS_TMO    255
  62
  63 #define LPFC_DEF_MRQ_POST       512
  64 #define LPFC_MIN_MRQ_POST       512
  65 #define LPFC_MAX_MRQ_POST       2048
  66
  67 #define LPFC_MAX_NVME_INFO_TMP_LEN      100
  68 #define LPFC_NVME_INFO_MORE_STR         "\nCould be more info...\n"
  69
  70 /*
  71  * Write key size should be multiple of 4. If write key is changed
  72  * make sure that library write key is also changed.
  73  */
  74 #define LPFC_REG_WRITE_KEY_SIZE 4
  75 #define LPFC_REG_WRITE_KEY      "EMLX"
  76
  77 /**
  78  * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
  79  * @incr: integer to convert.
  80  * @hdw: ascii string holding converted integer plus a string terminator.
  81  *
  82  * Description:
  83  * JEDEC Joint Electron Device Engineering Council.
  84  * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
  85  * character string. The string is then terminated with a NULL in byte 9.
  86  * Hex 0-9 becomes ascii '0' to '9'.
  87  * Hex a-f becomes ascii '=' to 'B' capital B.
  88  *
  89  * Notes:
  90  * Coded for 32 bit integers only.
  91  **/
  92 static void
  93 lpfc_jedec_to_ascii(int incr, char hdw[])
  94 {
  95         int i, j;
  96         for (i = 0; i < 8; i++) {
  97                 j = (incr & 0xf);
  98                 if (j <= 9)
  99                         hdw[7 - i] = 0x30 +  j;
 100                  else
 101                         hdw[7 - i] = 0x61 + j - 10;
 102                 incr = (incr >> 4);
 103         }
 104         hdw[8] = 0;
 105         return;
 106 }
 107
 108 /**
 109  * lpfc_drvr_version_show - Return the Emulex driver string with version number
 110  * @dev: class unused variable.
 111  * @attr: device attribute, not used.
 112  * @buf: on return contains the module description text.
 113  *
 114  * Returns: size of formatted string.
 115  **/
 116 static ssize_t
 117 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
 118                        char *buf)
 119 {
 120         return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
 121 }
 122
 123 /**
 124  * lpfc_enable_fip_show - Return the fip mode of the HBA
 125  * @dev: class unused variable.
 126  * @attr: device attribute, not used.
 127  * @buf: on return contains the module description text.
 128  *
 129  * Returns: size of formatted string.
 130  **/
 131 static ssize_t
 132 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
 133                        char *buf)
 134 {
 135         struct Scsi_Host *shost = class_to_shost(dev);
 136         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 137         struct lpfc_hba   *phba = vport->phba;
 138
 139         if (phba->hba_flag & HBA_FIP_SUPPORT)
 140                 return snprintf(buf, PAGE_SIZE, "1\n");
 141         else
 142                 return snprintf(buf, PAGE_SIZE, "0\n");
 143 }
 144
 145 static ssize_t
 146 lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
 147                     char *buf)
 148 {
 149         struct Scsi_Host *shost = class_to_shost(dev);
 150         struct lpfc_vport *vport = shost_priv(shost);
 151         struct lpfc_hba   *phba = vport->phba;
 152         struct lpfc_nvmet_tgtport *tgtp;
 153         struct nvme_fc_local_port *localport;
 154         struct lpfc_nvme_lport *lport;
 155         struct lpfc_nvme_rport *rport;
 156         struct lpfc_nodelist *ndlp;
 157         struct nvme_fc_remote_port *nrport;
 158         struct lpfc_nvme_ctrl_stat *cstat;
 159         uint64_t data1, data2, data3;
 160         uint64_t totin, totout, tot;
 161         char *statep;
 162         int i;
 163         int len = 0;
 164         char tmp[LPFC_MAX_NVME_INFO_TMP_LEN] = {0};
 165
 166         if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {
 167                 len = scnprintf(buf, PAGE_SIZE, "NVME Disabled\n");
 168                 return len;
 169         }
 170         if (phba->nvmet_support) {
 171                 if (!phba->targetport) {
 172                         len = scnprintf(buf, PAGE_SIZE,
 173                                         "NVME Target: x%llx is not allocated\n",
 174                                         wwn_to_u64(vport->fc_portname.u.wwn));
 175                         return len;
 176                 }
 177                 /* Port state is only one of two values for now. */
 178                 if (phba->targetport->port_id)
 179                         statep = "REGISTERED";
 180                 else
 181                         statep = "INIT";
 182                 scnprintf(tmp, sizeof(tmp),
 183                           "NVME Target Enabled  State %s\n",
 184                           statep);
 185                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 186                         goto buffer_done;
 187
 188                 scnprintf(tmp, sizeof(tmp),
 189                           "%s%d WWPN x%llx WWNN x%llx DID x%06x\n",
 190                           "NVME Target: lpfc",
 191                           phba->brd_no,
 192                           wwn_to_u64(vport->fc_portname.u.wwn),
 193                           wwn_to_u64(vport->fc_nodename.u.wwn),
 194                           phba->targetport->port_id);
 195                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 196                         goto buffer_done;
 197
 198                 if (strlcat(buf, "\nNVME Target: Statistics\n", PAGE_SIZE)
 199                     >= PAGE_SIZE)
 200                         goto buffer_done;
 201
 202                 tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
 203                 scnprintf(tmp, sizeof(tmp),
 204                           "LS: Rcv %08x Drop %08x Abort %08x\n",
 205                           atomic_read(&tgtp->rcv_ls_req_in),
 206                           atomic_read(&tgtp->rcv_ls_req_drop),
 207                           atomic_read(&tgtp->xmt_ls_abort));
 208                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 209                         goto buffer_done;
 210
 211                 if (atomic_read(&tgtp->rcv_ls_req_in) !=
 212                     atomic_read(&tgtp->rcv_ls_req_out)) {
 213                         scnprintf(tmp, sizeof(tmp),
 214                                   "Rcv LS: in %08x != out %08x\n",
 215                                   atomic_read(&tgtp->rcv_ls_req_in),
 216                                   atomic_read(&tgtp->rcv_ls_req_out));
 217                         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 218                                 goto buffer_done;
 219                 }
 220
 221                 scnprintf(tmp, sizeof(tmp),
 222                           "LS: Xmt %08x Drop %08x Cmpl %08x\n",
 223                           atomic_read(&tgtp->xmt_ls_rsp),
 224                           atomic_read(&tgtp->xmt_ls_drop),
 225                           atomic_read(&tgtp->xmt_ls_rsp_cmpl));
 226                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 227                         goto buffer_done;
 228
 229                 scnprintf(tmp, sizeof(tmp),
 230                           "LS: RSP Abort %08x xb %08x Err %08x\n",
 231                           atomic_read(&tgtp->xmt_ls_rsp_aborted),
 232                           atomic_read(&tgtp->xmt_ls_rsp_xb_set),
 233                           atomic_read(&tgtp->xmt_ls_rsp_error));
 234                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 235                         goto buffer_done;
 236
 237                 scnprintf(tmp, sizeof(tmp),
 238                           "FCP: Rcv %08x Defer %08x Release %08x "
 239                           "Drop %08x\n",
 240                           atomic_read(&tgtp->rcv_fcp_cmd_in),
 241                           atomic_read(&tgtp->rcv_fcp_cmd_defer),
 242                           atomic_read(&tgtp->xmt_fcp_release),
 243                           atomic_read(&tgtp->rcv_fcp_cmd_drop));
 244                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 245                         goto buffer_done;
 246
 247                 if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
 248                     atomic_read(&tgtp->rcv_fcp_cmd_out)) {
 249                         scnprintf(tmp, sizeof(tmp),
 250                                   "Rcv FCP: in %08x != out %08x\n",
 251                                   atomic_read(&tgtp->rcv_fcp_cmd_in),
 252                                   atomic_read(&tgtp->rcv_fcp_cmd_out));
 253                         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 254                                 goto buffer_done;
 255                 }
 256
 257                 scnprintf(tmp, sizeof(tmp),
 258                           "FCP Rsp: RD %08x rsp %08x WR %08x rsp %08x "
 259                           "drop %08x\n",
 260                           atomic_read(&tgtp->xmt_fcp_read),
 261                           atomic_read(&tgtp->xmt_fcp_read_rsp),
 262                           atomic_read(&tgtp->xmt_fcp_write),
 263                           atomic_read(&tgtp->xmt_fcp_rsp),
 264                           atomic_read(&tgtp->xmt_fcp_drop));
 265                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 266                         goto buffer_done;
 267
 268                 scnprintf(tmp, sizeof(tmp),
 269                           "FCP Rsp Cmpl: %08x err %08x drop %08x\n",
 270                           atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
 271                           atomic_read(&tgtp->xmt_fcp_rsp_error),
 272                           atomic_read(&tgtp->xmt_fcp_rsp_drop));
 273                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 274                         goto buffer_done;
 275
 276                 scnprintf(tmp, sizeof(tmp),
 277                           "FCP Rsp Abort: %08x xb %08x xricqe  %08x\n",
 278                           atomic_read(&tgtp->xmt_fcp_rsp_aborted),
 279                           atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
 280                           atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
 281                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 282                         goto buffer_done;
 283
 284                 scnprintf(tmp, sizeof(tmp),
 285                           "ABORT: Xmt %08x Cmpl %08x\n",
 286                           atomic_read(&tgtp->xmt_fcp_abort),
 287                           atomic_read(&tgtp->xmt_fcp_abort_cmpl));
 288                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 289                         goto buffer_done;
 290
 291                 scnprintf(tmp, sizeof(tmp),
 292                           "ABORT: Sol %08x  Usol %08x Err %08x Cmpl %08x\n",
 293                           atomic_read(&tgtp->xmt_abort_sol),
 294                           atomic_read(&tgtp->xmt_abort_unsol),
 295                           atomic_read(&tgtp->xmt_abort_rsp),
 296                           atomic_read(&tgtp->xmt_abort_rsp_error));
 297                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 298                         goto buffer_done;
 299
 300                 scnprintf(tmp, sizeof(tmp),
 301                           "DELAY: ctx %08x  fod %08x wqfull %08x\n",
 302                           atomic_read(&tgtp->defer_ctx),
 303                           atomic_read(&tgtp->defer_fod),
 304                           atomic_read(&tgtp->defer_wqfull));
 305                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 306                         goto buffer_done;
 307
 308                 /* Calculate outstanding IOs */
 309                 tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
 310                 tot += atomic_read(&tgtp->xmt_fcp_release);
 311                 tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
 312
 313                 scnprintf(tmp, sizeof(tmp),
 314                           "IO_CTX: %08x  WAIT: cur %08x tot %08x\n"
 315                           "CTX Outstanding %08llx\n\n",
 316                           phba->sli4_hba.nvmet_xri_cnt,
 317                           phba->sli4_hba.nvmet_io_wait_cnt,
 318                           phba->sli4_hba.nvmet_io_wait_total,
 319                           tot);
 320                 strlcat(buf, tmp, PAGE_SIZE);
 321                 goto buffer_done;
 322         }
 323
 324         localport = vport->localport;
 325         if (!localport) {
 326                 len = scnprintf(buf, PAGE_SIZE,
 327                                 "NVME Initiator x%llx is not allocated\n",
 328                                 wwn_to_u64(vport->fc_portname.u.wwn));
 329                 return len;
 330         }
 331         lport = (struct lpfc_nvme_lport *)localport->private;
 332         if (strlcat(buf, "\nNVME Initiator Enabled\n", PAGE_SIZE) >= PAGE_SIZE)
 333                 goto buffer_done;
 334
 335         rcu_read_lock();
 336         scnprintf(tmp, sizeof(tmp),
 337                   "XRI Dist lpfc%d Total %d NVME %d SCSI %d ELS %d\n",
 338                   phba->brd_no,
 339                   phba->sli4_hba.max_cfg_param.max_xri,
 340                   phba->sli4_hba.nvme_xri_max,
 341                   phba->sli4_hba.scsi_xri_max,
 342                   lpfc_sli4_get_els_iocb_cnt(phba));
 343         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 344                 goto buffer_done;
 345
 346         /* Port state is only one of two values for now. */
 347         if (localport->port_id)
 348                 statep = "ONLINE";
 349         else
 350                 statep = "UNKNOWN ";
 351
 352         scnprintf(tmp, sizeof(tmp),
 353                   "%s%d WWPN x%llx WWNN x%llx DID x%06x %s\n",
 354                   "NVME LPORT lpfc",
 355                   phba->brd_no,
 356                   wwn_to_u64(vport->fc_portname.u.wwn),
 357                   wwn_to_u64(vport->fc_nodename.u.wwn),
 358                   localport->port_id, statep);
 359         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 360                 goto buffer_done;
 361
 362         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
 363                 rport = lpfc_ndlp_get_nrport(ndlp);
 364                 if (!rport)
 365                         continue;
 366
 367                 /* local short-hand pointer. */
 368                 nrport = rport->remoteport;
 369                 if (!nrport)
 370                         continue;
 371
 372                 /* Port state is only one of two values for now. */
 373                 switch (nrport->port_state) {
 374                 case FC_OBJSTATE_ONLINE:
 375                         statep = "ONLINE";
 376                         break;
 377                 case FC_OBJSTATE_UNKNOWN:
 378                         statep = "UNKNOWN ";
 379                         break;
 380                 default:
 381                         statep = "UNSUPPORTED";
 382                         break;
 383                 }
 384
 385                 /* Tab in to show lport ownership. */
 386                 if (strlcat(buf, "NVME RPORT       ", PAGE_SIZE) >= PAGE_SIZE)
 387                         goto buffer_done;
 388                 if (phba->brd_no >= 10) {
 389                         if (strlcat(buf, " ", PAGE_SIZE) >= PAGE_SIZE)
 390                                 goto buffer_done;
 391                 }
 392
 393                 scnprintf(tmp, sizeof(tmp), "WWPN x%llx ",
 394                           nrport->port_name);
 395                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 396                         goto buffer_done;
 397
 398                 scnprintf(tmp, sizeof(tmp), "WWNN x%llx ",
 399                           nrport->node_name);
 400                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 401                         goto buffer_done;
 402
 403                 scnprintf(tmp, sizeof(tmp), "DID x%06x ",
 404                           nrport->port_id);
 405                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 406                         goto buffer_done;
 407
 408                 /* An NVME rport can have multiple roles. */
 409                 if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR) {
 410                         if (strlcat(buf, "INITIATOR ", PAGE_SIZE) >= PAGE_SIZE)
 411                                 goto buffer_done;
 412                 }
 413                 if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET) {
 414                         if (strlcat(buf, "TARGET ", PAGE_SIZE) >= PAGE_SIZE)
 415                                 goto buffer_done;
 416                 }
 417                 if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY) {
 418                         if (strlcat(buf, "DISCSRVC ", PAGE_SIZE) >= PAGE_SIZE)
 419                                 goto buffer_done;
 420                 }
 421                 if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
 422                                           FC_PORT_ROLE_NVME_TARGET |
 423                                           FC_PORT_ROLE_NVME_DISCOVERY)) {
 424                         scnprintf(tmp, sizeof(tmp), "UNKNOWN ROLE x%x",
 425                                   nrport->port_role);
 426                         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 427                                 goto buffer_done;
 428                 }
 429
 430                 scnprintf(tmp, sizeof(tmp), "%s\n", statep);
 431                 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 432                         goto buffer_done;
 433         }
 434         rcu_read_unlock();
 435
 436         if (!lport)
 437                 goto buffer_done;
 438
 439         if (strlcat(buf, "\nNVME Statistics\n", PAGE_SIZE) >= PAGE_SIZE)
 440                 goto buffer_done;
 441
 442         scnprintf(tmp, sizeof(tmp),
 443                   "LS: Xmt %010x Cmpl %010x Abort %08x\n",
 444                   atomic_read(&lport->fc4NvmeLsRequests),
 445                   atomic_read(&lport->fc4NvmeLsCmpls),
 446                   atomic_read(&lport->xmt_ls_abort));
 447         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 448                 goto buffer_done;
 449
 450         scnprintf(tmp, sizeof(tmp),
 451                   "LS XMIT: Err %08x  CMPL: xb %08x Err %08x\n",
 452                   atomic_read(&lport->xmt_ls_err),
 453                   atomic_read(&lport->cmpl_ls_xb),
 454                   atomic_read(&lport->cmpl_ls_err));
 455         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 456                 goto buffer_done;
 457
 458         totin = 0;
 459         totout = 0;
 460         for (i = 0; i < phba->cfg_nvme_io_channel; i++) {
 461                 cstat = &lport->cstat[i];
 462                 tot = atomic_read(&cstat->fc4NvmeIoCmpls);
 463                 totin += tot;
 464                 data1 = atomic_read(&cstat->fc4NvmeInputRequests);
 465                 data2 = atomic_read(&cstat->fc4NvmeOutputRequests);
 466                 data3 = atomic_read(&cstat->fc4NvmeControlRequests);
 467                 totout += (data1 + data2 + data3);
 468         }
 469         scnprintf(tmp, sizeof(tmp),
 470                   "Total FCP Cmpl %016llx Issue %016llx "
 471                   "OutIO %016llx\n",
 472                   totin, totout, totout - totin);
 473         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 474                 goto buffer_done;
 475
 476         scnprintf(tmp, sizeof(tmp),
 477                   "\tabort %08x noxri %08x nondlp %08x qdepth %08x "
 478                   "wqerr %08x err %08x\n",
 479                   atomic_read(&lport->xmt_fcp_abort),
 480                   atomic_read(&lport->xmt_fcp_noxri),
 481                   atomic_read(&lport->xmt_fcp_bad_ndlp),
 482                   atomic_read(&lport->xmt_fcp_qdepth),
 483                   atomic_read(&lport->xmt_fcp_err),
 484                   atomic_read(&lport->xmt_fcp_wqerr));
 485         if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
 486                 goto buffer_done;
 487
 488         scnprintf(tmp, sizeof(tmp),
 489                   "FCP CMPL: xb %08x Err %08x\n",
 490                   atomic_read(&lport->cmpl_fcp_xb),
 491                   atomic_read(&lport->cmpl_fcp_err));
 492         strlcat(buf, tmp, PAGE_SIZE);
 493
 494 buffer_done:
 495         len = strnlen(buf, PAGE_SIZE);
 496
 497         if (unlikely(len >= (PAGE_SIZE - 1))) {
 498                 lpfc_printf_log(phba, KERN_INFO, LOG_NVME,
 499                                 "6314 Catching potential buffer "
 500                                 "overflow > PAGE_SIZE = %lu bytes\n",
 501                                 PAGE_SIZE);
 502                 strlcpy(buf + PAGE_SIZE - 1 -
 503                         strnlen(LPFC_NVME_INFO_MORE_STR, PAGE_SIZE - 1),
 504                         LPFC_NVME_INFO_MORE_STR,
 505                         strnlen(LPFC_NVME_INFO_MORE_STR, PAGE_SIZE - 1)
 506                         + 1);
 507         }
 508
 509         return len;
 510 }
 511
 512 static ssize_t
 513 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
 514                   char *buf)
 515 {
 516         struct Scsi_Host *shost = class_to_shost(dev);
 517         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 518         struct lpfc_hba   *phba = vport->phba;
 519
 520         if (phba->cfg_enable_bg)
 521                 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
 522                         return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n");
 523                 else
 524                         return snprintf(buf, PAGE_SIZE,
 525                                         "BlockGuard Not Supported\n");
 526         else
 527                         return snprintf(buf, PAGE_SIZE,
 528                                         "BlockGuard Disabled\n");
 529 }
 530
 531 static ssize_t
 532 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
 533                        char *buf)
 534 {
 535         struct Scsi_Host *shost = class_to_shost(dev);
 536         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 537         struct lpfc_hba   *phba = vport->phba;
 538
 539         return snprintf(buf, PAGE_SIZE, "%llu\n",
 540                         (unsigned long long)phba->bg_guard_err_cnt);
 541 }
 542
 543 static ssize_t
 544 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
 545                         char *buf)
 546 {
 547         struct Scsi_Host *shost = class_to_shost(dev);
 548         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 549         struct lpfc_hba   *phba = vport->phba;
 550
 551         return snprintf(buf, PAGE_SIZE, "%llu\n",
 552                         (unsigned long long)phba->bg_apptag_err_cnt);
 553 }
 554
 555 static ssize_t
 556 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
 557                         char *buf)
 558 {
 559         struct Scsi_Host *shost = class_to_shost(dev);
 560         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 561         struct lpfc_hba   *phba = vport->phba;
 562
 563         return snprintf(buf, PAGE_SIZE, "%llu\n",
 564                         (unsigned long long)phba->bg_reftag_err_cnt);
 565 }
 566
 567 /**
 568  * lpfc_info_show - Return some pci info about the host in ascii
 569  * @dev: class converted to a Scsi_host structure.
 570  * @attr: device attribute, not used.
 571  * @buf: on return contains the formatted text from lpfc_info().
 572  *
 573  * Returns: size of formatted string.
 574  **/
 575 static ssize_t
 576 lpfc_info_show(struct device *dev, struct device_attribute *attr,
 577                char *buf)
 578 {
 579         struct Scsi_Host *host = class_to_shost(dev);
 580
 581         return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
 582 }
 583
 584 /**
 585  * lpfc_serialnum_show - Return the hba serial number in ascii
 586  * @dev: class converted to a Scsi_host structure.
 587  * @attr: device attribute, not used.
 588  * @buf: on return contains the formatted text serial number.
 589  *
 590  * Returns: size of formatted string.
 591  **/
 592 static ssize_t
 593 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
 594                     char *buf)
 595 {
 596         struct Scsi_Host  *shost = class_to_shost(dev);
 597         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 598         struct lpfc_hba   *phba = vport->phba;
 599
 600         return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
 601 }
 602
 603 /**
 604  * lpfc_temp_sensor_show - Return the temperature sensor level
 605  * @dev: class converted to a Scsi_host structure.
 606  * @attr: device attribute, not used.
 607  * @buf: on return contains the formatted support level.
 608  *
 609  * Description:
 610  * Returns a number indicating the temperature sensor level currently
 611  * supported, zero or one in ascii.
 612  *
 613  * Returns: size of formatted string.
 614  **/
 615 static ssize_t
 616 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
 617                       char *buf)
 618 {
 619         struct Scsi_Host *shost = class_to_shost(dev);
 620         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 621         struct lpfc_hba   *phba = vport->phba;
 622         return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
 623 }
 624
 625 /**
 626  * lpfc_modeldesc_show - Return the model description of the hba
 627  * @dev: class converted to a Scsi_host structure.
 628  * @attr: device attribute, not used.
 629  * @buf: on return contains the scsi vpd model description.
 630  *
 631  * Returns: size of formatted string.
 632  **/
 633 static ssize_t
 634 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
 635                     char *buf)
 636 {
 637         struct Scsi_Host  *shost = class_to_shost(dev);
 638         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 639         struct lpfc_hba   *phba = vport->phba;
 640
 641         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
 642 }
 643
 644 /**
 645  * lpfc_modelname_show - Return the model name of the hba
 646  * @dev: class converted to a Scsi_host structure.
 647  * @attr: device attribute, not used.
 648  * @buf: on return contains the scsi vpd model name.
 649  *
 650  * Returns: size of formatted string.
 651  **/
 652 static ssize_t
 653 lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
 654                     char *buf)
 655 {
 656         struct Scsi_Host  *shost = class_to_shost(dev);
 657         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 658         struct lpfc_hba   *phba = vport->phba;
 659
 660         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
 661 }
 662
 663 /**
 664  * lpfc_programtype_show - Return the program type of the hba
 665  * @dev: class converted to a Scsi_host structure.
 666  * @attr: device attribute, not used.
 667  * @buf: on return contains the scsi vpd program type.
 668  *
 669  * Returns: size of formatted string.
 670  **/
 671 static ssize_t
 672 lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
 673                       char *buf)
 674 {
 675         struct Scsi_Host  *shost = class_to_shost(dev);
 676         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 677         struct lpfc_hba   *phba = vport->phba;
 678
 679         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
 680 }
 681
 682 /**
 683  * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
 684  * @dev: class converted to a Scsi_host structure.
 685  * @attr: device attribute, not used.
 686  * @buf: on return contains the Menlo Maintenance sli flag.
 687  *
 688  * Returns: size of formatted string.
 689  **/
 690 static ssize_t
 691 lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
 692 {
 693         struct Scsi_Host  *shost = class_to_shost(dev);
 694         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
 695         struct lpfc_hba   *phba = vport->phba;
 696
 697         return snprintf(buf, PAGE_SIZE, "%d\n",
 698                 (phba->sli.sli_flag & LPFC_MENLO_MAINT));
 699 }
 700
 701 /**
 702  * lpfc_vportnum_show - Return the port number in ascii of the hba
 703  * @dev: class converted to a Scsi_host structure.
 704  * @attr: device attribute, not used.
 705  * @buf: on return contains scsi vpd program type.
 706  *
 707  * Returns: size of formatted string.
 708  **/
 709 static ssize_t
 710 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
 711                    char *buf)
 712 {
 713         struct Scsi_Host  *shost = class_to_shost(dev);
 714         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 715         struct lpfc_hba   *phba = vport->phba;
 716
 717         return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
 718 }
 719
 720 /**
 721  * lpfc_fwrev_show - Return the firmware rev running in the hba
 722  * @dev: class converted to a Scsi_host structure.
 723  * @attr: device attribute, not used.
 724  * @buf: on return contains the scsi vpd program type.
 725  *
 726  * Returns: size of formatted string.
 727  **/
 728 static ssize_t
 729 lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
 730                 char *buf)
 731 {
 732         struct Scsi_Host  *shost = class_to_shost(dev);
 733         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 734         struct lpfc_hba   *phba = vport->phba;
 735         uint32_t if_type;
 736         uint8_t sli_family;
 737         char fwrev[FW_REV_STR_SIZE];
 738         int len;
 739
 740         lpfc_decode_firmware_rev(phba, fwrev, 1);
 741         if_type = phba->sli4_hba.pc_sli4_params.if_type;
 742         sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
 743
 744         if (phba->sli_rev < LPFC_SLI_REV4)
 745                 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
 746                                fwrev, phba->sli_rev);
 747         else
 748                 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
 749                                fwrev, phba->sli_rev, if_type, sli_family);
 750
 751         return len;
 752 }
 753
 754 /**
 755  * lpfc_hdw_show - Return the jedec information about the hba
 756  * @dev: class converted to a Scsi_host structure.
 757  * @attr: device attribute, not used.
 758  * @buf: on return contains the scsi vpd program type.
 759  *
 760  * Returns: size of formatted string.
 761  **/
 762 static ssize_t
 763 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
 764 {
 765         char hdw[9];
 766         struct Scsi_Host  *shost = class_to_shost(dev);
 767         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 768         struct lpfc_hba   *phba = vport->phba;
 769         lpfc_vpd_t *vp = &phba->vpd;
 770
 771         lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
 772         return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
 773 }
 774
 775 /**
 776  * lpfc_option_rom_version_show - Return the adapter ROM FCode version
 777  * @dev: class converted to a Scsi_host structure.
 778  * @attr: device attribute, not used.
 779  * @buf: on return contains the ROM and FCode ascii strings.
 780  *
 781  * Returns: size of formatted string.
 782  **/
 783 static ssize_t
 784 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
 785                              char *buf)
 786 {
 787         struct Scsi_Host  *shost = class_to_shost(dev);
 788         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 789         struct lpfc_hba   *phba = vport->phba;
 790         char fwrev[FW_REV_STR_SIZE];
 791
 792         if (phba->sli_rev < LPFC_SLI_REV4)
 793                 return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
 794
 795         lpfc_decode_firmware_rev(phba, fwrev, 1);
 796         return snprintf(buf, PAGE_SIZE, "%s\n", fwrev);
 797 }
 798
 799 /**
 800  * lpfc_state_show - Return the link state of the port
 801  * @dev: class converted to a Scsi_host structure.
 802  * @attr: device attribute, not used.
 803  * @buf: on return contains text describing the state of the link.
 804  *
 805  * Notes:
 806  * The switch statement has no default so zero will be returned.
 807  *
 808  * Returns: size of formatted string.
 809  **/
 810 static ssize_t
 811 lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
 812                      char *buf)
 813 {
 814         struct Scsi_Host  *shost = class_to_shost(dev);
 815         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 816         struct lpfc_hba   *phba = vport->phba;
 817         int  len = 0;
 818
 819         switch (phba->link_state) {
 820         case LPFC_LINK_UNKNOWN:
 821         case LPFC_WARM_START:
 822         case LPFC_INIT_START:
 823         case LPFC_INIT_MBX_CMDS:
 824         case LPFC_LINK_DOWN:
 825         case LPFC_HBA_ERROR:
 826                 if (phba->hba_flag & LINK_DISABLED)
 827                         len += snprintf(buf + len, PAGE_SIZE-len,
 828                                 "Link Down - User disabled\n");
 829                 else
 830                         len += snprintf(buf + len, PAGE_SIZE-len,
 831                                 "Link Down\n");
 832                 break;
 833         case LPFC_LINK_UP:
 834         case LPFC_CLEAR_LA:
 835         case LPFC_HBA_READY:
 836                 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
 837
 838                 switch (vport->port_state) {
 839                 case LPFC_LOCAL_CFG_LINK:
 840                         len += snprintf(buf + len, PAGE_SIZE-len,
 841                                         "Configuring Link\n");
 842                         break;
 843                 case LPFC_FDISC:
 844                 case LPFC_FLOGI:
 845                 case LPFC_FABRIC_CFG_LINK:
 846                 case LPFC_NS_REG:
 847                 case LPFC_NS_QRY:
 848                 case LPFC_BUILD_DISC_LIST:
 849                 case LPFC_DISC_AUTH:
 850                         len += snprintf(buf + len, PAGE_SIZE - len,
 851                                         "Discovery\n");
 852                         break;
 853                 case LPFC_VPORT_READY:
 854                         len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
 855                         break;
 856
 857                 case LPFC_VPORT_FAILED:
 858                         len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
 859                         break;
 860
 861                 case LPFC_VPORT_UNKNOWN:
 862                         len += snprintf(buf + len, PAGE_SIZE - len,
 863                                         "Unknown\n");
 864                         break;
 865                 }
 866                 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
 867                         len += snprintf(buf + len, PAGE_SIZE-len,
 868                                         "   Menlo Maint Mode\n");
 869                 else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
 870                         if (vport->fc_flag & FC_PUBLIC_LOOP)
 871                                 len += snprintf(buf + len, PAGE_SIZE-len,
 872                                                 "   Public Loop\n");
 873                         else
 874                                 len += snprintf(buf + len, PAGE_SIZE-len,
 875                                                 "   Private Loop\n");
 876                 } else {
 877                         if (vport->fc_flag & FC_FABRIC)
 878                                 len += snprintf(buf + len, PAGE_SIZE-len,
 879                                                 "   Fabric\n");
 880                         else
 881                                 len += snprintf(buf + len, PAGE_SIZE-len,
 882                                                 "   Point-2-Point\n");
 883                 }
 884         }
 885
 886         return len;
 887 }
 888
 889 /**
 890  * lpfc_sli4_protocol_show - Return the fip mode of the HBA
 891  * @dev: class unused variable.
 892  * @attr: device attribute, not used.
 893  * @buf: on return contains the module description text.
 894  *
 895  * Returns: size of formatted string.
 896  **/
 897 static ssize_t
 898 lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
 899                         char *buf)
 900 {
 901         struct Scsi_Host *shost = class_to_shost(dev);
 902         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 903         struct lpfc_hba *phba = vport->phba;
 904
 905         if (phba->sli_rev < LPFC_SLI_REV4)
 906                 return snprintf(buf, PAGE_SIZE, "fc\n");
 907
 908         if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
 909                 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
 910                         return snprintf(buf, PAGE_SIZE, "fcoe\n");
 911                 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
 912                         return snprintf(buf, PAGE_SIZE, "fc\n");
 913         }
 914         return snprintf(buf, PAGE_SIZE, "unknown\n");
 915 }
 916
 917 /**
 918  * lpfc_oas_supported_show - Return whether or not Optimized Access Storage
 919  *                          (OAS) is supported.
 920  * @dev: class unused variable.
 921  * @attr: device attribute, not used.
 922  * @buf: on return contains the module description text.
 923  *
 924  * Returns: size of formatted string.
 925  **/
 926 static ssize_t
 927 lpfc_oas_supported_show(struct device *dev, struct device_attribute *attr,
 928                         char *buf)
 929 {
 930         struct Scsi_Host *shost = class_to_shost(dev);
 931         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
 932         struct lpfc_hba *phba = vport->phba;
 933
 934         return snprintf(buf, PAGE_SIZE, "%d\n",
 935                         phba->sli4_hba.pc_sli4_params.oas_supported);
 936 }
 937
 938 /**
 939  * lpfc_link_state_store - Transition the link_state on an HBA port
 940  * @dev: class device that is converted into a Scsi_host.
 941  * @attr: device attribute, not used.
 942  * @buf: one or more lpfc_polling_flags values.
 943  * @count: not used.
 944  *
 945  * Returns:
 946  * -EINVAL if the buffer is not "up" or "down"
 947  * return from link state change function if non-zero
 948  * length of the buf on success
 949  **/
 950 static ssize_t
 951 lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
 952                 const char *buf, size_t count)
 953 {
 954         struct Scsi_Host  *shost = class_to_shost(dev);
 955         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 956         struct lpfc_hba   *phba = vport->phba;
 957
 958         int status = -EINVAL;
 959
 960         if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
 961                         (phba->link_state == LPFC_LINK_DOWN))
 962                 status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
 963         else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
 964                         (phba->link_state >= LPFC_LINK_UP))
 965                 status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
 966
 967         if (status == 0)
 968                 return strlen(buf);
 969         else
 970                 return status;
 971 }
 972
 973 /**
 974  * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
 975  * @dev: class device that is converted into a Scsi_host.
 976  * @attr: device attribute, not used.
 977  * @buf: on return contains the sum of fc mapped and unmapped.
 978  *
 979  * Description:
 980  * Returns the ascii text number of the sum of the fc mapped and unmapped
 981  * vport counts.
 982  *
 983  * Returns: size of formatted string.
 984  **/
 985 static ssize_t
 986 lpfc_num_discovered_ports_show(struct device *dev,
 987                                struct device_attribute *attr, char *buf)
 988 {
 989         struct Scsi_Host  *shost = class_to_shost(dev);
 990         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 991
 992         return snprintf(buf, PAGE_SIZE, "%d\n",
 993                         vport->fc_map_cnt + vport->fc_unmap_cnt);
 994 }
 995
 996 /**
 997  * lpfc_issue_lip - Misnomer, name carried over from long ago
 998  * @shost: Scsi_Host pointer.
 999  *
1000  * Description:
1001  * Bring the link down gracefully then re-init the link. The firmware will
1002  * re-init the fiber channel interface as required. Does not issue a LIP.
1003  *
1004  * Returns:
1005  * -EPERM port offline or management commands are being blocked
1006  * -ENOMEM cannot allocate memory for the mailbox command
1007  * -EIO error sending the mailbox command
1008  * zero for success
1009  **/
1010 static int
1011 lpfc_issue_lip(struct Scsi_Host *shost)
1012 {
1013         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1014         struct lpfc_hba   *phba = vport->phba;
1015         LPFC_MBOXQ_t *pmboxq;
1016         int mbxstatus = MBXERR_ERROR;
1017
1018         /*
1019          * If the link is offline, disabled or BLOCK_MGMT_IO
1020          * it doesn't make any sense to allow issue_lip
1021          */
1022         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
1023             (phba->hba_flag & LINK_DISABLED) ||
1024             (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
1025                 return -EPERM;
1026
1027         pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
1028
1029         if (!pmboxq)
1030                 return -ENOMEM;
1031
1032         memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1033         pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
1034         pmboxq->u.mb.mbxOwner = OWN_HOST;
1035
1036         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
1037
1038         if ((mbxstatus == MBX_SUCCESS) &&
1039             (pmboxq->u.mb.mbxStatus == 0 ||
1040              pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
1041                 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1042                 lpfc_init_link(phba, pmboxq, phba->cfg_topology,
1043                                phba->cfg_link_speed);
1044                 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
1045                                                      phba->fc_ratov * 2);
1046                 if ((mbxstatus == MBX_SUCCESS) &&
1047                     (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
1048                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
1049                                         "2859 SLI authentication is required "
1050                                         "for INIT_LINK but has not done yet\n");
1051         }
1052
1053         lpfc_set_loopback_flag(phba);
1054         if (mbxstatus != MBX_TIMEOUT)
1055                 mempool_free(pmboxq, phba->mbox_mem_pool);
1056
1057         if (mbxstatus == MBXERR_ERROR)
1058                 return -EIO;
1059
1060         return 0;
1061 }
1062
1063 int
1064 lpfc_emptyq_wait(struct lpfc_hba *phba, struct list_head *q, spinlock_t *lock)
1065 {
1066         int cnt = 0;
1067
1068         spin_lock_irq(lock);
1069         while (!list_empty(q)) {
1070                 spin_unlock_irq(lock);
1071                 msleep(20);
1072                 if (cnt++ > 250) {  /* 5 secs */
1073                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1074                                         "0466 %s %s\n",
1075                                         "Outstanding IO when ",
1076                                         "bringing Adapter offline\n");
1077                                 return 0;
1078                 }
1079                 spin_lock_irq(lock);
1080         }
1081         spin_unlock_irq(lock);
1082         return 1;
1083 }
1084
1085 /**
1086  * lpfc_do_offline - Issues a mailbox command to bring the link down
1087  * @phba: lpfc_hba pointer.
1088  * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
1089  *
1090  * Notes:
1091  * Assumes any error from lpfc_do_offline() will be negative.
1092  * Can wait up to 5 seconds for the port ring buffers count
1093  * to reach zero, prints a warning if it is not zero and continues.
1094  * lpfc_workq_post_event() returns a non-zero return code if call fails.
1095  *
1096  * Returns:
1097  * -EIO error posting the event
1098  * zero for success
1099  **/
1100 static int
1101 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
1102 {
1103         struct completion online_compl;
1104         struct lpfc_queue *qp = NULL;
1105         struct lpfc_sli_ring *pring;
1106         struct lpfc_sli *psli;
1107         int status = 0;
1108         int i;
1109         int rc;
1110
1111         init_completion(&online_compl);
1112         rc = lpfc_workq_post_event(phba, &status, &online_compl,
1113                               LPFC_EVT_OFFLINE_PREP);
1114         if (rc == 0)
1115                 return -ENOMEM;
1116
1117         wait_for_completion(&online_compl);
1118
1119         if (status != 0)
1120                 return -EIO;
1121
1122         psli = &phba->sli;
1123
1124         /* Wait a little for things to settle down, but not
1125          * long enough for dev loss timeout to expire.
1126          */
1127         if (phba->sli_rev != LPFC_SLI_REV4) {
1128                 for (i = 0; i < psli->num_rings; i++) {
1129                         pring = &psli->sli3_ring[i];
1130                         if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
1131                                               &phba->hbalock))
1132                                 goto out;
1133                 }
1134         } else {
1135                 list_for_each_entry(qp, &phba->sli4_hba.lpfc_wq_list, wq_list) {
1136                         pring = qp->pring;
1137                         if (!pring)
1138                                 continue;
1139                         if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
1140                                               &pring->ring_lock))
1141                                 goto out;
1142                 }
1143         }
1144 out:
1145         init_completion(&online_compl);
1146         rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
1147         if (rc == 0)
1148                 return -ENOMEM;
1149
1150         wait_for_completion(&online_compl);
1151
1152         if (status != 0)
1153                 return -EIO;
1154
1155         return 0;
1156 }
1157
1158 /**
1159  * lpfc_selective_reset - Offline then onlines the port
1160  * @phba: lpfc_hba pointer.
1161  *
1162  * Description:
1163  * If the port is configured to allow a reset then the hba is brought
1164  * offline then online.
1165  *
1166  * Notes:
1167  * Assumes any error from lpfc_do_offline() will be negative.
1168  * Do not make this function static.
1169  *
1170  * Returns:
1171  * lpfc_do_offline() return code if not zero
1172  * -EIO reset not configured or error posting the event
1173  * zero for success
1174  **/
1175 int
1176 lpfc_selective_reset(struct lpfc_hba *phba)
1177 {
1178         struct completion online_compl;
1179         int status = 0;
1180         int rc;
1181
1182         if (!phba->cfg_enable_hba_reset)
1183                 return -EACCES;
1184
1185         if (!(phba->pport->fc_flag & FC_OFFLINE_MODE)) {
1186                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1187
1188                 if (status != 0)
1189                         return status;
1190         }
1191
1192         init_completion(&online_compl);
1193         rc = lpfc_workq_post_event(phba, &status, &online_compl,
1194                               LPFC_EVT_ONLINE);
1195         if (rc == 0)
1196                 return -ENOMEM;
1197
1198         wait_for_completion(&online_compl);
1199
1200         if (status != 0)
1201                 return -EIO;
1202
1203         return 0;
1204 }
1205
1206 /**
1207  * lpfc_issue_reset - Selectively resets an adapter
1208  * @dev: class device that is converted into a Scsi_host.
1209  * @attr: device attribute, not used.
1210  * @buf: containing the string "selective".
1211  * @count: unused variable.
1212  *
1213  * Description:
1214  * If the buf contains the string "selective" then lpfc_selective_reset()
1215  * is called to perform the reset.
1216  *
1217  * Notes:
1218  * Assumes any error from lpfc_selective_reset() will be negative.
1219  * If lpfc_selective_reset() returns zero then the length of the buffer
1220  * is returned which indicates success
1221  *
1222  * Returns:
1223  * -EINVAL if the buffer does not contain the string "selective"
1224  * length of buf if lpfc-selective_reset() if the call succeeds
1225  * return value of lpfc_selective_reset() if the call fails
1226 **/
1227 static ssize_t
1228 lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
1229                  const char *buf, size_t count)
1230 {
1231         struct Scsi_Host  *shost = class_to_shost(dev);
1232         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1233         struct lpfc_hba   *phba = vport->phba;
1234         int status = -EINVAL;
1235
1236         if (!phba->cfg_enable_hba_reset)
1237                 return -EACCES;
1238
1239         if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
1240                 status = phba->lpfc_selective_reset(phba);
1241
1242         if (status == 0)
1243                 return strlen(buf);
1244         else
1245                 return status;
1246 }
1247
1248 /**
1249  * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
1250  * @phba: lpfc_hba pointer.
1251  *
1252  * Description:
1253  * SLI4 interface type-2 device to wait on the sliport status register for
1254  * the readyness after performing a firmware reset.
1255  *
1256  * Returns:
1257  * zero for success, -EPERM when port does not have privilege to perform the
1258  * reset, -EIO when port timeout from recovering from the reset.
1259  *
1260  * Note:
1261  * As the caller will interpret the return code by value, be careful in making
1262  * change or addition to return codes.
1263  **/
1264 int
1265 lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
1266 {
1267         struct lpfc_register portstat_reg = {0};
1268         int i;
1269
1270         msleep(100);
1271         lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1272                    &portstat_reg.word0);
1273
1274         /* verify if privileged for the request operation */
1275         if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
1276             !bf_get(lpfc_sliport_status_err, &portstat_reg))
1277                 return -EPERM;
1278
1279         /* wait for the SLI port firmware ready after firmware reset */
1280         for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
1281                 msleep(10);
1282                 lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1283                            &portstat_reg.word0);
1284                 if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
1285                         continue;
1286                 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
1287                         continue;
1288                 if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
1289                         continue;
1290                 break;
1291         }
1292
1293         if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
1294                 return 0;
1295         else
1296                 return -EIO;
1297 }
1298
1299 /**
1300  * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
1301  * @phba: lpfc_hba pointer.
1302  *
1303  * Description:
1304  * Request SLI4 interface type-2 device to perform a physical register set
1305  * access.
1306  *
1307  * Returns:
1308  * zero for success
1309  **/
1310 static ssize_t
1311 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
1312 {
1313         struct completion online_compl;
1314         struct pci_dev *pdev = phba->pcidev;
1315         uint32_t before_fc_flag;
1316         uint32_t sriov_nr_virtfn;
1317         uint32_t reg_val;
1318         int status = 0, rc = 0;
1319         int job_posted = 1, sriov_err;
1320
1321         if (!phba->cfg_enable_hba_reset)
1322                 return -EACCES;
1323
1324         if ((phba->sli_rev < LPFC_SLI_REV4) ||
1325             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
1326              LPFC_SLI_INTF_IF_TYPE_2))
1327                 return -EPERM;
1328
1329         /* Keep state if we need to restore back */
1330         before_fc_flag = phba->pport->fc_flag;
1331         sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
1332
1333         /* Disable SR-IOV virtual functions if enabled */
1334         if (phba->cfg_sriov_nr_virtfn) {
1335                 pci_disable_sriov(pdev);
1336                 phba->cfg_sriov_nr_virtfn = 0;
1337         }
1338
1339         if (opcode == LPFC_FW_DUMP)
1340                 phba->hba_flag |= HBA_FW_DUMP_OP;
1341
1342         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1343
1344         if (status != 0) {
1345                 phba->hba_flag &= ~HBA_FW_DUMP_OP;
1346                 return status;
1347         }
1348
1349         /* wait for the device to be quiesced before firmware reset */
1350         msleep(100);
1351
1352         reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
1353                         LPFC_CTL_PDEV_CTL_OFFSET);
1354
1355         if (opcode == LPFC_FW_DUMP)
1356                 reg_val |= LPFC_FW_DUMP_REQUEST;
1357         else if (opcode == LPFC_FW_RESET)
1358                 reg_val |= LPFC_CTL_PDEV_CTL_FRST;
1359         else if (opcode == LPFC_DV_RESET)
1360                 reg_val |= LPFC_CTL_PDEV_CTL_DRST;
1361
1362         writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
1363                LPFC_CTL_PDEV_CTL_OFFSET);
1364         /* flush */
1365         readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
1366
1367         /* delay driver action following IF_TYPE_2 reset */
1368         rc = lpfc_sli4_pdev_status_reg_wait(phba);
1369
1370         if (rc == -EPERM) {
1371                 /* no privilege for reset */
1372                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1373                                 "3150 No privilege to perform the requested "
1374                                 "access: x%x\n", reg_val);
1375         } else if (rc == -EIO) {
1376                 /* reset failed, there is nothing more we can do */
1377                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1378                                 "3153 Fail to perform the requested "
1379                                 "access: x%x\n", reg_val);
1380                 return rc;
1381         }
1382
1383         /* keep the original port state */
1384         if (before_fc_flag & FC_OFFLINE_MODE)
1385                 goto out;
1386
1387         init_completion(&online_compl);
1388         job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
1389                                            LPFC_EVT_ONLINE);
1390         if (!job_posted)
1391                 goto out;
1392
1393         wait_for_completion(&online_compl);
1394
1395 out:
1396         /* in any case, restore the virtual functions enabled as before */
1397         if (sriov_nr_virtfn) {
1398                 sriov_err =
1399                         lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
1400                 if (!sriov_err)
1401                         phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
1402         }
1403
1404         /* return proper error code */
1405         if (!rc) {
1406                 if (!job_posted)
1407                         rc = -ENOMEM;
1408                 else if (status)
1409                         rc = -EIO;
1410         }
1411         return rc;
1412 }
1413
1414 /**
1415  * lpfc_nport_evt_cnt_show - Return the number of nport events
1416  * @dev: class device that is converted into a Scsi_host.
1417  * @attr: device attribute, not used.
1418  * @buf: on return contains the ascii number of nport events.
1419  *
1420  * Returns: size of formatted string.
1421  **/
1422 static ssize_t
1423 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
1424                         char *buf)
1425 {
1426         struct Scsi_Host  *shost = class_to_shost(dev);
1427         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1428         struct lpfc_hba   *phba = vport->phba;
1429
1430         return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
1431 }
1432
1433 /**
1434  * lpfc_board_mode_show - Return the state of the board
1435  * @dev: class device that is converted into a Scsi_host.
1436  * @attr: device attribute, not used.
1437  * @buf: on return contains the state of the adapter.
1438  *
1439  * Returns: size of formatted string.
1440  **/
1441 static ssize_t
1442 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
1443                      char *buf)
1444 {
1445         struct Scsi_Host  *shost = class_to_shost(dev);
1446         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1447         struct lpfc_hba   *phba = vport->phba;
1448         char  * state;
1449
1450         if (phba->link_state == LPFC_HBA_ERROR)
1451                 state = "error";
1452         else if (phba->link_state == LPFC_WARM_START)
1453                 state = "warm start";
1454         else if (phba->link_state == LPFC_INIT_START)
1455                 state = "offline";
1456         else
1457                 state = "online";
1458
1459         return snprintf(buf, PAGE_SIZE, "%s\n", state);
1460 }
1461
1462 /**
1463  * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
1464  * @dev: class device that is converted into a Scsi_host.
1465  * @attr: device attribute, not used.
1466  * @buf: containing one of the strings "online", "offline", "warm" or "error".
1467  * @count: unused variable.
1468  *
1469  * Returns:
1470  * -EACCES if enable hba reset not enabled
1471  * -EINVAL if the buffer does not contain a valid string (see above)
1472  * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
1473  * buf length greater than zero indicates success
1474  **/
1475 static ssize_t
1476 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
1477                       const char *buf, size_t count)
1478 {
1479         struct Scsi_Host  *shost = class_to_shost(dev);
1480         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1481         struct lpfc_hba   *phba = vport->phba;
1482         struct completion online_compl;
1483         char *board_mode_str = NULL;
1484         int status = 0;
1485         int rc;
1486
1487         if (!phba->cfg_enable_hba_reset) {
1488                 status = -EACCES;
1489                 goto board_mode_out;
1490         }
1491
1492         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1493                          "3050 lpfc_board_mode set to %s\n", buf);
1494
1495         init_completion(&online_compl);
1496
1497         if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
1498                 rc = lpfc_workq_post_event(phba, &status, &online_compl,
1499                                       LPFC_EVT_ONLINE);
1500                 if (rc == 0) {
1501                         status = -ENOMEM;
1502                         goto board_mode_out;
1503                 }
1504                 wait_for_completion(&online_compl);
1505                 if (status)
1506                         status = -EIO;
1507         } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
1508                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1509         else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
1510                 if (phba->sli_rev == LPFC_SLI_REV4)
1511                         status = -EINVAL;
1512                 else
1513                         status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
1514         else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
1515                 if (phba->sli_rev == LPFC_SLI_REV4)
1516                         status = -EINVAL;
1517                 else
1518                         status = lpfc_do_offline(phba, LPFC_EVT_KILL);
1519         else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
1520                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
1521         else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
1522                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
1523         else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
1524                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
1525         else
1526                 status = -EINVAL;
1527
1528 board_mode_out:
1529         if (!status)
1530                 return strlen(buf);
1531         else {
1532                 board_mode_str = strchr(buf, '\n');
1533                 if (board_mode_str)
1534                         *board_mode_str = '\0';
1535                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1536                                  "3097 Failed \"%s\", status(%d), "
1537                                  "fc_flag(x%x)\n",
1538                                  buf, status, phba->pport->fc_flag);
1539                 return status;
1540         }
1541 }
1542
1543 /**
1544  * lpfc_get_hba_info - Return various bits of informaton about the adapter
1545  * @phba: pointer to the adapter structure.
1546  * @mxri: max xri count.
1547  * @axri: available xri count.
1548  * @mrpi: max rpi count.
1549  * @arpi: available rpi count.
1550  * @mvpi: max vpi count.
1551  * @avpi: available vpi count.
1552  *
1553  * Description:
1554  * If an integer pointer for an count is not null then the value for the
1555  * count is returned.
1556  *
1557  * Returns:
1558  * zero on error
1559  * one for success
1560  **/
1561 static int
1562 lpfc_get_hba_info(struct lpfc_hba *phba,
1563                   uint32_t *mxri, uint32_t *axri,
1564                   uint32_t *mrpi, uint32_t *arpi,
1565                   uint32_t *mvpi, uint32_t *avpi)
1566 {
1567         struct lpfc_mbx_read_config *rd_config;
1568         LPFC_MBOXQ_t *pmboxq;
1569         MAILBOX_t *pmb;
1570         int rc = 0;
1571         uint32_t max_vpi;
1572
1573         /*
1574          * prevent udev from issuing mailbox commands until the port is
1575          * configured.
1576          */
1577         if (phba->link_state < LPFC_LINK_DOWN ||
1578             !phba->mbox_mem_pool ||
1579             (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
1580                 return 0;
1581
1582         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
1583                 return 0;
1584
1585         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1586         if (!pmboxq)
1587                 return 0;
1588         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1589
1590         pmb = &pmboxq->u.mb;
1591         pmb->mbxCommand = MBX_READ_CONFIG;
1592         pmb->mbxOwner = OWN_HOST;
1593         pmboxq->context1 = NULL;
1594
1595         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1596                 rc = MBX_NOT_FINISHED;
1597         else
1598                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
1599
1600         if (rc != MBX_SUCCESS) {
1601                 if (rc != MBX_TIMEOUT)
1602                         mempool_free(pmboxq, phba->mbox_mem_pool);
1603                 return 0;
1604         }
1605
1606         if (phba->sli_rev == LPFC_SLI_REV4) {
1607                 rd_config = &pmboxq->u.mqe.un.rd_config;
1608                 if (mrpi)
1609                         *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
1610                 if (arpi)
1611                         *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
1612                                         phba->sli4_hba.max_cfg_param.rpi_used;
1613                 if (mxri)
1614                         *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
1615                 if (axri)
1616                         *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
1617                                         phba->sli4_hba.max_cfg_param.xri_used;
1618
1619                 /* Account for differences with SLI-3.  Get vpi count from
1620                  * mailbox data and subtract one for max vpi value.
1621                  */
1622                 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
1623                         (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
1624
1625                 if (mvpi)
1626                         *mvpi = max_vpi;
1627                 if (avpi)
1628                         *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
1629         } else {
1630                 if (mrpi)
1631                         *mrpi = pmb->un.varRdConfig.max_rpi;
1632                 if (arpi)
1633                         *arpi = pmb->un.varRdConfig.avail_rpi;
1634                 if (mxri)
1635                         *mxri = pmb->un.varRdConfig.max_xri;
1636                 if (axri)
1637                         *axri = pmb->un.varRdConfig.avail_xri;
1638                 if (mvpi)
1639                         *mvpi = pmb->un.varRdConfig.max_vpi;
1640                 if (avpi)
1641                         *avpi = pmb->un.varRdConfig.avail_vpi;
1642         }
1643
1644         mempool_free(pmboxq, phba->mbox_mem_pool);
1645         return 1;
1646 }
1647
1648 /**
1649  * lpfc_max_rpi_show - Return maximum rpi
1650  * @dev: class device that is converted into a Scsi_host.
1651  * @attr: device attribute, not used.
1652  * @buf: on return contains the maximum rpi count in decimal or "Unknown".
1653  *
1654  * Description:
1655  * Calls lpfc_get_hba_info() asking for just the mrpi count.
1656  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1657  * to "Unknown" and the buffer length is returned, therefore the caller
1658  * must check for "Unknown" in the buffer to detect a failure.
1659  *
1660  * Returns: size of formatted string.
1661  **/
1662 static ssize_t
1663 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
1664                   char *buf)
1665 {
1666         struct Scsi_Host  *shost = class_to_shost(dev);
1667         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1668         struct lpfc_hba   *phba = vport->phba;
1669         uint32_t cnt;
1670
1671         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
1672                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1673         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1674 }
1675
1676 /**
1677  * lpfc_used_rpi_show - Return maximum rpi minus available rpi
1678  * @dev: class device that is converted into a Scsi_host.
1679  * @attr: device attribute, not used.
1680  * @buf: containing the used rpi count in decimal or "Unknown".
1681  *
1682  * Description:
1683  * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
1684  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1685  * to "Unknown" and the buffer length is returned, therefore the caller
1686  * must check for "Unknown" in the buffer to detect a failure.
1687  *
1688  * Returns: size of formatted string.
1689  **/
1690 static ssize_t
1691 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
1692                    char *buf)
1693 {
1694         struct Scsi_Host  *shost = class_to_shost(dev);
1695         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1696         struct lpfc_hba   *phba = vport->phba;
1697         uint32_t cnt, acnt;
1698
1699         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
1700                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1701         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1702 }
1703
1704 /**
1705  * lpfc_max_xri_show - Return maximum xri
1706  * @dev: class device that is converted into a Scsi_host.
1707  * @attr: device attribute, not used.
1708  * @buf: on return contains the maximum xri count in decimal or "Unknown".
1709  *
1710  * Description:
1711  * Calls lpfc_get_hba_info() asking for just the mrpi count.
1712  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1713  * to "Unknown" and the buffer length is returned, therefore the caller
1714  * must check for "Unknown" in the buffer to detect a failure.
1715  *
1716  * Returns: size of formatted string.
1717  **/
1718 static ssize_t
1719 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
1720                   char *buf)
1721 {
1722         struct Scsi_Host  *shost = class_to_shost(dev);
1723         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1724         struct lpfc_hba   *phba = vport->phba;
1725         uint32_t cnt;
1726
1727         if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
1728                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1729         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1730 }
1731
1732 /**
1733  * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1734  * @dev: class device that is converted into a Scsi_host.
1735  * @attr: device attribute, not used.
1736  * @buf: on return contains the used xri count in decimal or "Unknown".
1737  *
1738  * Description:
1739  * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
1740  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1741  * to "Unknown" and the buffer length is returned, therefore the caller
1742  * must check for "Unknown" in the buffer to detect a failure.
1743  *
1744  * Returns: size of formatted string.
1745  **/
1746 static ssize_t
1747 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
1748                    char *buf)
1749 {
1750         struct Scsi_Host  *shost = class_to_shost(dev);
1751         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1752         struct lpfc_hba   *phba = vport->phba;
1753         uint32_t cnt, acnt;
1754
1755         if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
1756                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1757         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1758 }
1759
1760 /**
1761  * lpfc_max_vpi_show - Return maximum vpi
1762  * @dev: class device that is converted into a Scsi_host.
1763  * @attr: device attribute, not used.
1764  * @buf: on return contains the maximum vpi count in decimal or "Unknown".
1765  *
1766  * Description:
1767  * Calls lpfc_get_hba_info() asking for just the mvpi count.
1768  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1769  * to "Unknown" and the buffer length is returned, therefore the caller
1770  * must check for "Unknown" in the buffer to detect a failure.
1771  *
1772  * Returns: size of formatted string.
1773  **/
1774 static ssize_t
1775 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
1776                   char *buf)
1777 {
1778         struct Scsi_Host  *shost = class_to_shost(dev);
1779         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1780         struct lpfc_hba   *phba = vport->phba;
1781         uint32_t cnt;
1782
1783         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
1784                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1785         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1786 }
1787
1788 /**
1789  * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1790  * @dev: class device that is converted into a Scsi_host.
1791  * @attr: device attribute, not used.
1792  * @buf: on return contains the used vpi count in decimal or "Unknown".
1793  *
1794  * Description:
1795  * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
1796  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1797  * to "Unknown" and the buffer length is returned, therefore the caller
1798  * must check for "Unknown" in the buffer to detect a failure.
1799  *
1800  * Returns: size of formatted string.
1801  **/
1802 static ssize_t
1803 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
1804                    char *buf)
1805 {
1806         struct Scsi_Host  *shost = class_to_shost(dev);
1807         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1808         struct lpfc_hba   *phba = vport->phba;
1809         uint32_t cnt, acnt;
1810
1811         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
1812                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1813         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1814 }
1815
1816 /**
1817  * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1818  * @dev: class device that is converted into a Scsi_host.
1819  * @attr: device attribute, not used.
1820  * @buf: text that must be interpreted to determine if npiv is supported.
1821  *
1822  * Description:
1823  * Buffer will contain text indicating npiv is not suppoerted on the port,
1824  * the port is an NPIV physical port, or it is an npiv virtual port with
1825  * the id of the vport.
1826  *
1827  * Returns: size of formatted string.
1828  **/
1829 static ssize_t
1830 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
1831                     char *buf)
1832 {
1833         struct Scsi_Host  *shost = class_to_shost(dev);
1834         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1835         struct lpfc_hba   *phba = vport->phba;
1836
1837         if (!(phba->max_vpi))
1838                 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
1839         if (vport->port_type == LPFC_PHYSICAL_PORT)
1840                 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
1841         return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
1842 }
1843
1844 /**
1845  * lpfc_poll_show - Return text about poll support for the adapter
1846  * @dev: class device that is converted into a Scsi_host.
1847  * @attr: device attribute, not used.
1848  * @buf: on return contains the cfg_poll in hex.
1849  *
1850  * Notes:
1851  * cfg_poll should be a lpfc_polling_flags type.
1852  *
1853  * Returns: size of formatted string.
1854  **/
1855 static ssize_t
1856 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
1857                char *buf)
1858 {
1859         struct Scsi_Host  *shost = class_to_shost(dev);
1860         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1861         struct lpfc_hba   *phba = vport->phba;
1862
1863         return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
1864 }
1865
1866 /**
1867  * lpfc_poll_store - Set the value of cfg_poll for the adapter
1868  * @dev: class device that is converted into a Scsi_host.
1869  * @attr: device attribute, not used.
1870  * @buf: one or more lpfc_polling_flags values.
1871  * @count: not used.
1872  *
1873  * Notes:
1874  * buf contents converted to integer and checked for a valid value.
1875  *
1876  * Returns:
1877  * -EINVAL if the buffer connot be converted or is out of range
1878  * length of the buf on success
1879  **/
1880 static ssize_t
1881 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
1882                 const char *buf, size_t count)
1883 {
1884         struct Scsi_Host  *shost = class_to_shost(dev);
1885         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1886         struct lpfc_hba   *phba = vport->phba;
1887         uint32_t creg_val;
1888         uint32_t old_val;
1889         int val=0;
1890
1891         if (!isdigit(buf[0]))
1892                 return -EINVAL;
1893
1894         if (sscanf(buf, "%i", &val) != 1)
1895                 return -EINVAL;
1896
1897         if ((val & 0x3) != val)
1898                 return -EINVAL;
1899
1900         if (phba->sli_rev == LPFC_SLI_REV4)
1901                 val = 0;
1902
1903         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1904                 "3051 lpfc_poll changed from %d to %d\n",
1905                 phba->cfg_poll, val);
1906
1907         spin_lock_irq(&phba->hbalock);
1908
1909         old_val = phba->cfg_poll;
1910
1911         if (val & ENABLE_FCP_RING_POLLING) {
1912                 if ((val & DISABLE_FCP_RING_INT) &&
1913                     !(old_val & DISABLE_FCP_RING_INT)) {
1914                         if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1915                                 spin_unlock_irq(&phba->hbalock);
1916                                 return -EINVAL;
1917                         }
1918                         creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
1919                         writel(creg_val, phba->HCregaddr);
1920                         readl(phba->HCregaddr); /* flush */
1921
1922                         lpfc_poll_start_timer(phba);
1923                 }
1924         } else if (val != 0x0) {
1925                 spin_unlock_irq(&phba->hbalock);
1926                 return -EINVAL;
1927         }
1928
1929         if (!(val & DISABLE_FCP_RING_INT) &&
1930             (old_val & DISABLE_FCP_RING_INT))
1931         {
1932                 spin_unlock_irq(&phba->hbalock);
1933                 del_timer(&phba->fcp_poll_timer);
1934                 spin_lock_irq(&phba->hbalock);
1935                 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1936                         spin_unlock_irq(&phba->hbalock);
1937                         return -EINVAL;
1938                 }
1939                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
1940                 writel(creg_val, phba->HCregaddr);
1941                 readl(phba->HCregaddr); /* flush */
1942         }
1943
1944         phba->cfg_poll = val;
1945
1946         spin_unlock_irq(&phba->hbalock);
1947
1948         return strlen(buf);
1949 }
1950
1951 /**
1952  * lpfc_fips_level_show - Return the current FIPS level for the HBA
1953  * @dev: class unused variable.
1954  * @attr: device attribute, not used.
1955  * @buf: on return contains the module description text.
1956  *
1957  * Returns: size of formatted string.
1958  **/
1959 static ssize_t
1960 lpfc_fips_level_show(struct device *dev,  struct device_attribute *attr,
1961                      char *buf)
1962 {
1963         struct Scsi_Host  *shost = class_to_shost(dev);
1964         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1965         struct lpfc_hba   *phba = vport->phba;
1966
1967         return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
1968 }
1969
1970 /**
1971  * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
1972  * @dev: class unused variable.
1973  * @attr: device attribute, not used.
1974  * @buf: on return contains the module description text.
1975  *
1976  * Returns: size of formatted string.
1977  **/
1978 static ssize_t
1979 lpfc_fips_rev_show(struct device *dev,  struct device_attribute *attr,
1980                    char *buf)
1981 {
1982         struct Scsi_Host  *shost = class_to_shost(dev);
1983         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1984         struct lpfc_hba   *phba = vport->phba;
1985
1986         return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
1987 }
1988
1989 /**
1990  * lpfc_dss_show - Return the current state of dss and the configured state
1991  * @dev: class converted to a Scsi_host structure.
1992  * @attr: device attribute, not used.
1993  * @buf: on return contains the formatted text.
1994  *
1995  * Returns: size of formatted string.
1996  **/
1997 static ssize_t
1998 lpfc_dss_show(struct device *dev, struct device_attribute *attr,
1999               char *buf)
2000 {
2001         struct Scsi_Host *shost = class_to_shost(dev);
2002         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2003         struct lpfc_hba   *phba = vport->phba;
2004
2005         return snprintf(buf, PAGE_SIZE, "%s - %sOperational\n",
2006                         (phba->cfg_enable_dss) ? "Enabled" : "Disabled",
2007                         (phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ?
2008                                 "" : "Not ");
2009 }
2010
2011 /**
2012  * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
2013  * @dev: class converted to a Scsi_host structure.
2014  * @attr: device attribute, not used.
2015  * @buf: on return contains the formatted support level.
2016  *
2017  * Description:
2018  * Returns the maximum number of virtual functions a physical function can
2019  * support, 0 will be returned if called on virtual function.
2020  *
2021  * Returns: size of formatted string.
2022  **/
2023 static ssize_t
2024 lpfc_sriov_hw_max_virtfn_show(struct device *dev,
2025                               struct device_attribute *attr,
2026                               char *buf)
2027 {
2028         struct Scsi_Host *shost = class_to_shost(dev);
2029         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2030         struct lpfc_hba *phba = vport->phba;
2031         uint16_t max_nr_virtfn;
2032
2033         max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
2034         return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
2035 }
2036
2037 static inline bool lpfc_rangecheck(uint val, uint min, uint max)
2038 {
2039         return val >= min && val <= max;
2040 }
2041
2042 /**
2043  * lpfc_enable_bbcr_set: Sets an attribute value.
2044  * @phba: pointer the the adapter structure.
2045  * @val: integer attribute value.
2046  *
2047  * Description:
2048  * Validates the min and max values then sets the
2049  * adapter config field if in the valid range. prints error message
2050  * and does not set the parameter if invalid.
2051  *
2052  * Returns:
2053  * zero on success
2054  * -EINVAL if val is invalid
2055  */
2056 static ssize_t
2057 lpfc_enable_bbcr_set(struct lpfc_hba *phba, uint val)
2058 {
2059         if (lpfc_rangecheck(val, 0, 1) && phba->sli_rev == LPFC_SLI_REV4) {
2060                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2061                                 "3068 %s_enable_bbcr changed from %d to %d\n",
2062                                 LPFC_DRIVER_NAME, phba->cfg_enable_bbcr, val);
2063                 phba->cfg_enable_bbcr = val;
2064                 return 0;
2065         }
2066         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2067                         "0451 %s_enable_bbcr cannot set to %d, range is 0, 1\n",
2068                         LPFC_DRIVER_NAME, val);
2069         return -EINVAL;
2070 }
2071
2072 /**
2073  * lpfc_param_show - Return a cfg attribute value in decimal
2074  *
2075  * Description:
2076  * Macro that given an attr e.g. hba_queue_depth expands
2077  * into a function with the name lpfc_hba_queue_depth_show.
2078  *
2079  * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
2080  * @dev: class device that is converted into a Scsi_host.
2081  * @attr: device attribute, not used.
2082  * @buf: on return contains the attribute value in decimal.
2083  *
2084  * Returns: size of formatted string.
2085  **/
2086 #define lpfc_param_show(attr)   \
2087 static ssize_t \
2088 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2089                    char *buf) \
2090 { \
2091         struct Scsi_Host  *shost = class_to_shost(dev);\
2092         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2093         struct lpfc_hba   *phba = vport->phba;\
2094         return snprintf(buf, PAGE_SIZE, "%d\n",\
2095                         phba->cfg_##attr);\
2096 }
2097
2098 /**
2099  * lpfc_param_hex_show - Return a cfg attribute value in hex
2100  *
2101  * Description:
2102  * Macro that given an attr e.g. hba_queue_depth expands
2103  * into a function with the name lpfc_hba_queue_depth_show
2104  *
2105  * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
2106  * @dev: class device that is converted into a Scsi_host.
2107  * @attr: device attribute, not used.
2108  * @buf: on return contains the attribute value in hexadecimal.
2109  *
2110  * Returns: size of formatted string.
2111  **/
2112 #define lpfc_param_hex_show(attr)       \
2113 static ssize_t \
2114 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2115                    char *buf) \
2116 { \
2117         struct Scsi_Host  *shost = class_to_shost(dev);\
2118         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2119         struct lpfc_hba   *phba = vport->phba;\
2120         uint val = 0;\
2121         val = phba->cfg_##attr;\
2122         return snprintf(buf, PAGE_SIZE, "%#x\n",\
2123                         phba->cfg_##attr);\
2124 }
2125
2126 /**
2127  * lpfc_param_init - Initializes a cfg attribute
2128  *
2129  * Description:
2130  * Macro that given an attr e.g. hba_queue_depth expands
2131  * into a function with the name lpfc_hba_queue_depth_init. The macro also
2132  * takes a default argument, a minimum and maximum argument.
2133  *
2134  * lpfc_##attr##_init: Initializes an attribute.
2135  * @phba: pointer the the adapter structure.
2136  * @val: integer attribute value.
2137  *
2138  * Validates the min and max values then sets the adapter config field
2139  * accordingly, or uses the default if out of range and prints an error message.
2140  *
2141  * Returns:
2142  * zero on success
2143  * -EINVAL if default used
2144  **/
2145 #define lpfc_param_init(attr, default, minval, maxval)  \
2146 static int \
2147 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
2148 { \
2149         if (lpfc_rangecheck(val, minval, maxval)) {\
2150                 phba->cfg_##attr = val;\
2151                 return 0;\
2152         }\
2153         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2154                         "0449 lpfc_"#attr" attribute cannot be set to %d, "\
2155                         "allowed range is ["#minval", "#maxval"]\n", val); \
2156         phba->cfg_##attr = default;\
2157         return -EINVAL;\
2158 }
2159
2160 /**
2161  * lpfc_param_set - Set a cfg attribute value
2162  *
2163  * Description:
2164  * Macro that given an attr e.g. hba_queue_depth expands
2165  * into a function with the name lpfc_hba_queue_depth_set
2166  *
2167  * lpfc_##attr##_set: Sets an attribute value.
2168  * @phba: pointer the the adapter structure.
2169  * @val: integer attribute value.
2170  *
2171  * Description:
2172  * Validates the min and max values then sets the
2173  * adapter config field if in the valid range. prints error message
2174  * and does not set the parameter if invalid.
2175  *
2176  * Returns:
2177  * zero on success
2178  * -EINVAL if val is invalid
2179  **/
2180 #define lpfc_param_set(attr, default, minval, maxval)   \
2181 static int \
2182 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
2183 { \
2184         if (lpfc_rangecheck(val, minval, maxval)) {\
2185                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2186                         "3052 lpfc_" #attr " changed from %d to %d\n", \
2187                         phba->cfg_##attr, val); \
2188                 phba->cfg_##attr = val;\
2189                 return 0;\
2190         }\
2191         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2192                         "0450 lpfc_"#attr" attribute cannot be set to %d, "\
2193                         "allowed range is ["#minval", "#maxval"]\n", val); \
2194         return -EINVAL;\
2195 }
2196
2197 /**
2198  * lpfc_param_store - Set a vport attribute value
2199  *
2200  * Description:
2201  * Macro that given an attr e.g. hba_queue_depth expands
2202  * into a function with the name lpfc_hba_queue_depth_store.
2203  *
2204  * lpfc_##attr##_store: Set an sttribute value.
2205  * @dev: class device that is converted into a Scsi_host.
2206  * @attr: device attribute, not used.
2207  * @buf: contains the attribute value in ascii.
2208  * @count: not used.
2209  *
2210  * Description:
2211  * Convert the ascii text number to an integer, then
2212  * use the lpfc_##attr##_set function to set the value.
2213  *
2214  * Returns:
2215  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2216  * length of buffer upon success.
2217  **/
2218 #define lpfc_param_store(attr)  \
2219 static ssize_t \
2220 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2221                     const char *buf, size_t count) \
2222 { \
2223         struct Scsi_Host  *shost = class_to_shost(dev);\
2224         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2225         struct lpfc_hba   *phba = vport->phba;\
2226         uint val = 0;\
2227         if (!isdigit(buf[0]))\
2228                 return -EINVAL;\
2229         if (sscanf(buf, "%i", &val) != 1)\
2230                 return -EINVAL;\
2231         if (lpfc_##attr##_set(phba, val) == 0) \
2232                 return strlen(buf);\
2233         else \
2234                 return -EINVAL;\
2235 }
2236
2237 /**
2238  * lpfc_vport_param_show - Return decimal formatted cfg attribute value
2239  *
2240  * Description:
2241  * Macro that given an attr e.g. hba_queue_depth expands
2242  * into a function with the name lpfc_hba_queue_depth_show
2243  *
2244  * lpfc_##attr##_show: prints the attribute value in decimal.
2245  * @dev: class device that is converted into a Scsi_host.
2246  * @attr: device attribute, not used.
2247  * @buf: on return contains the attribute value in decimal.
2248  *
2249  * Returns: length of formatted string.
2250  **/
2251 #define lpfc_vport_param_show(attr)     \
2252 static ssize_t \
2253 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2254                    char *buf) \
2255 { \
2256         struct Scsi_Host  *shost = class_to_shost(dev);\
2257         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2258         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
2259 }
2260
2261 /**
2262  * lpfc_vport_param_hex_show - Return hex formatted attribute value
2263  *
2264  * Description:
2265  * Macro that given an attr e.g.
2266  * hba_queue_depth expands into a function with the name
2267  * lpfc_hba_queue_depth_show
2268  *
2269  * lpfc_##attr##_show: prints the attribute value in hexadecimal.
2270  * @dev: class device that is converted into a Scsi_host.
2271  * @attr: device attribute, not used.
2272  * @buf: on return contains the attribute value in hexadecimal.
2273  *
2274  * Returns: length of formatted string.
2275  **/
2276 #define lpfc_vport_param_hex_show(attr) \
2277 static ssize_t \
2278 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2279                    char *buf) \
2280 { \
2281         struct Scsi_Host  *shost = class_to_shost(dev);\
2282         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2283         return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
2284 }
2285
2286 /**
2287  * lpfc_vport_param_init - Initialize a vport cfg attribute
2288  *
2289  * Description:
2290  * Macro that given an attr e.g. hba_queue_depth expands
2291  * into a function with the name lpfc_hba_queue_depth_init. The macro also
2292  * takes a default argument, a minimum and maximum argument.
2293  *
2294  * lpfc_##attr##_init: validates the min and max values then sets the
2295  * adapter config field accordingly, or uses the default if out of range
2296  * and prints an error message.
2297  * @phba: pointer the the adapter structure.
2298  * @val: integer attribute value.
2299  *
2300  * Returns:
2301  * zero on success
2302  * -EINVAL if default used
2303  **/
2304 #define lpfc_vport_param_init(attr, default, minval, maxval)    \
2305 static int \
2306 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
2307 { \
2308         if (lpfc_rangecheck(val, minval, maxval)) {\
2309                 vport->cfg_##attr = val;\
2310                 return 0;\
2311         }\
2312         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2313                          "0423 lpfc_"#attr" attribute cannot be set to %d, "\
2314                          "allowed range is ["#minval", "#maxval"]\n", val); \
2315         vport->cfg_##attr = default;\
2316         return -EINVAL;\
2317 }
2318
2319 /**
2320  * lpfc_vport_param_set - Set a vport cfg attribute
2321  *
2322  * Description:
2323  * Macro that given an attr e.g. hba_queue_depth expands
2324  * into a function with the name lpfc_hba_queue_depth_set
2325  *
2326  * lpfc_##attr##_set: validates the min and max values then sets the
2327  * adapter config field if in the valid range. prints error message
2328  * and does not set the parameter if invalid.
2329  * @phba: pointer the the adapter structure.
2330  * @val:        integer attribute value.
2331  *
2332  * Returns:
2333  * zero on success
2334  * -EINVAL if val is invalid
2335  **/
2336 #define lpfc_vport_param_set(attr, default, minval, maxval)     \
2337 static int \
2338 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
2339 { \
2340         if (lpfc_rangecheck(val, minval, maxval)) {\
2341                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2342                         "3053 lpfc_" #attr \
2343                         " changed from %d (x%x) to %d (x%x)\n", \
2344                         vport->cfg_##attr, vport->cfg_##attr, \
2345                         val, val); \
2346                 vport->cfg_##attr = val;\
2347                 return 0;\
2348         }\
2349         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2350                          "0424 lpfc_"#attr" attribute cannot be set to %d, "\
2351                          "allowed range is ["#minval", "#maxval"]\n", val); \
2352         return -EINVAL;\
2353 }
2354
2355 /**
2356  * lpfc_vport_param_store - Set a vport attribute
2357  *
2358  * Description:
2359  * Macro that given an attr e.g. hba_queue_depth
2360  * expands into a function with the name lpfc_hba_queue_depth_store
2361  *
2362  * lpfc_##attr##_store: convert the ascii text number to an integer, then
2363  * use the lpfc_##attr##_set function to set the value.
2364  * @cdev: class device that is converted into a Scsi_host.
2365  * @buf:        contains the attribute value in decimal.
2366  * @count: not used.
2367  *
2368  * Returns:
2369  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2370  * length of buffer upon success.
2371  **/
2372 #define lpfc_vport_param_store(attr)    \
2373 static ssize_t \
2374 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2375                     const char *buf, size_t count) \
2376 { \
2377         struct Scsi_Host  *shost = class_to_shost(dev);\
2378         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2379         uint val = 0;\
2380         if (!isdigit(buf[0]))\
2381                 return -EINVAL;\
2382         if (sscanf(buf, "%i", &val) != 1)\
2383                 return -EINVAL;\
2384         if (lpfc_##attr##_set(vport, val) == 0) \
2385                 return strlen(buf);\
2386         else \
2387                 return -EINVAL;\
2388 }
2389
2390
2391 static DEVICE_ATTR(nvme_info, 0444, lpfc_nvme_info_show, NULL);
2392 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
2393 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
2394 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
2395 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
2396 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
2397 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
2398 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
2399 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
2400 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
2401 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
2402 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
2403 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
2404 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
2405                 lpfc_link_state_store);
2406 static DEVICE_ATTR(option_rom_version, S_IRUGO,
2407                    lpfc_option_rom_version_show, NULL);
2408 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
2409                    lpfc_num_discovered_ports_show, NULL);
2410 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
2411 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
2412 static DEVICE_ATTR_RO(lpfc_drvr_version);
2413 static DEVICE_ATTR_RO(lpfc_enable_fip);
2414 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
2415                    lpfc_board_mode_show, lpfc_board_mode_store);
2416 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
2417 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
2418 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
2419 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
2420 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
2421 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
2422 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
2423 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
2424 static DEVICE_ATTR_RO(lpfc_temp_sensor);
2425 static DEVICE_ATTR_RO(lpfc_fips_level);
2426 static DEVICE_ATTR_RO(lpfc_fips_rev);
2427 static DEVICE_ATTR_RO(lpfc_dss);
2428 static DEVICE_ATTR_RO(lpfc_sriov_hw_max_virtfn);
2429 static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
2430 static DEVICE_ATTR(lpfc_xlane_supported, S_IRUGO, lpfc_oas_supported_show,
2431                    NULL);
2432
2433 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
2434 #define WWN_SZ 8
2435 /**
2436  * lpfc_wwn_set - Convert string to the 8 byte WWN value.
2437  * @buf: WWN string.
2438  * @cnt: Length of string.
2439  * @wwn: Array to receive converted wwn value.
2440  *
2441  * Returns:
2442  * -EINVAL if the buffer does not contain a valid wwn
2443  * 0 success
2444  **/
2445 static size_t
2446 lpfc_wwn_set(const char *buf, size_t cnt, char wwn[])
2447 {
2448         unsigned int i, j;
2449
2450         /* Count may include a LF at end of string */
2451         if (buf[cnt-1] == '\n')
2452                 cnt--;
2453
2454         if ((cnt < 16) || (cnt > 18) || ((cnt == 17) && (*buf++ != 'x')) ||
2455             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2456                 return -EINVAL;
2457
2458         memset(wwn, 0, WWN_SZ);
2459
2460         /* Validate and store the new name */
2461         for (i = 0, j = 0; i < 16; i++) {
2462                 if ((*buf >= 'a') && (*buf <= 'f'))
2463                         j = ((j << 4) | ((*buf++ - 'a') + 10));
2464                 else if ((*buf >= 'A') && (*buf <= 'F'))
2465                         j = ((j << 4) | ((*buf++ - 'A') + 10));
2466                 else if ((*buf >= '0') && (*buf <= '9'))
2467                         j = ((j << 4) | (*buf++ - '0'));
2468                 else
2469                         return -EINVAL;
2470                 if (i % 2) {
2471                         wwn[i/2] = j & 0xff;
2472                         j = 0;
2473                 }
2474         }
2475         return 0;
2476 }
2477 /**
2478  * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
2479  * @dev: class device that is converted into a Scsi_host.
2480  * @attr: device attribute, not used.
2481  * @buf: containing the string lpfc_soft_wwn_key.
2482  * @count: must be size of lpfc_soft_wwn_key.
2483  *
2484  * Returns:
2485  * -EINVAL if the buffer does not contain lpfc_soft_wwn_key
2486  * length of buf indicates success
2487  **/
2488 static ssize_t
2489 lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
2490                            const char *buf, size_t count)
2491 {
2492         struct Scsi_Host  *shost = class_to_shost(dev);
2493         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2494         struct lpfc_hba   *phba = vport->phba;
2495         unsigned int cnt = count;
2496         uint8_t vvvl = vport->fc_sparam.cmn.valid_vendor_ver_level;
2497         u32 *fawwpn_key = (uint32_t *)&vport->fc_sparam.un.vendorVersion[0];
2498
2499         /*
2500          * We're doing a simple sanity check for soft_wwpn setting.
2501          * We require that the user write a specific key to enable
2502          * the soft_wwpn attribute to be settable. Once the attribute
2503          * is written, the enable key resets. If further updates are
2504          * desired, the key must be written again to re-enable the
2505          * attribute.
2506          *
2507          * The "key" is not secret - it is a hardcoded string shown
2508          * here. The intent is to protect against the random user or
2509          * application that is just writing attributes.
2510          */
2511         if (vvvl == 1 && cpu_to_be32(*fawwpn_key) == FAPWWN_KEY_VENDOR) {
2512                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2513                                  "0051 "LPFC_DRIVER_NAME" soft wwpn can not"
2514                                  " be enabled: fawwpn is enabled\n");
2515                 return -EINVAL;
2516         }
2517
2518         /* count may include a LF at end of string */
2519         if (buf[cnt-1] == '\n')
2520                 cnt--;
2521
2522         if ((cnt != strlen(lpfc_soft_wwn_key)) ||
2523             (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
2524                 return -EINVAL;
2525
2526         phba->soft_wwn_enable = 1;
2527
2528         dev_printk(KERN_WARNING, &phba->pcidev->dev,
2529                    "lpfc%d: soft_wwpn assignment has been enabled.\n",
2530                    phba->brd_no);
2531         dev_printk(KERN_WARNING, &phba->pcidev->dev,
2532                    "  The soft_wwpn feature is not supported by Broadcom.");
2533
2534         return count;
2535 }
2536 static DEVICE_ATTR_WO(lpfc_soft_wwn_enable);
2537
2538 /**
2539  * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
2540  * @dev: class device that is converted into a Scsi_host.
2541  * @attr: device attribute, not used.
2542  * @buf: on return contains the wwpn in hexadecimal.
2543  *
2544  * Returns: size of formatted string.
2545  **/
2546 static ssize_t
2547 lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
2548                     char *buf)
2549 {
2550         struct Scsi_Host  *shost = class_to_shost(dev);
2551         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2552         struct lpfc_hba   *phba = vport->phba;
2553
2554         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2555                         (unsigned long long)phba->cfg_soft_wwpn);
2556 }
2557
2558 /**
2559  * lpfc_soft_wwpn_store - Set the ww port name of the adapter
2560  * @dev class device that is converted into a Scsi_host.
2561  * @attr: device attribute, not used.
2562  * @buf: contains the wwpn in hexadecimal.
2563  * @count: number of wwpn bytes in buf
2564  *
2565  * Returns:
2566  * -EACCES hba reset not enabled, adapter over temp
2567  * -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
2568  * -EIO error taking adapter offline or online
2569  * value of count on success
2570  **/
2571 static ssize_t
2572 lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
2573                      const char *buf, size_t count)
2574 {
2575         struct Scsi_Host  *shost = class_to_shost(dev);
2576         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2577         struct lpfc_hba   *phba = vport->phba;
2578         struct completion online_compl;
2579         int stat1 = 0, stat2 = 0;
2580         unsigned int cnt = count;
2581         u8 wwpn[WWN_SZ];
2582         int rc;
2583
2584         if (!phba->cfg_enable_hba_reset)
2585                 return -EACCES;
2586         spin_lock_irq(&phba->hbalock);
2587         if (phba->over_temp_state == HBA_OVER_TEMP) {
2588                 spin_unlock_irq(&phba->hbalock);
2589                 return -EACCES;
2590         }
2591         spin_unlock_irq(&phba->hbalock);
2592         /* count may include a LF at end of string */
2593         if (buf[cnt-1] == '\n')
2594                 cnt--;
2595
2596         if (!phba->soft_wwn_enable)
2597                 return -EINVAL;
2598
2599         /* lock setting wwpn, wwnn down */
2600         phba->soft_wwn_enable = 0;
2601
2602         rc = lpfc_wwn_set(buf, cnt, wwpn);
2603         if (rc) {
2604                 /* not able to set wwpn, unlock it */
2605                 phba->soft_wwn_enable = 1;
2606                 return rc;
2607         }
2608
2609         phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
2610         fc_host_port_name(shost) = phba->cfg_soft_wwpn;
2611         if (phba->cfg_soft_wwnn)
2612                 fc_host_node_name(shost) = phba->cfg_soft_wwnn;
2613
2614         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2615                    "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
2616
2617         stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2618         if (stat1)
2619                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2620                                 "0463 lpfc_soft_wwpn attribute set failed to "
2621                                 "reinit adapter - %d\n", stat1);
2622         init_completion(&online_compl);
2623         rc = lpfc_workq_post_event(phba, &stat2, &online_compl,
2624                                    LPFC_EVT_ONLINE);
2625         if (rc == 0)
2626                 return -ENOMEM;
2627
2628         wait_for_completion(&online_compl);
2629         if (stat2)
2630                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2631                                 "0464 lpfc_soft_wwpn attribute set failed to "
2632                                 "reinit adapter - %d\n", stat2);
2633         return (stat1 || stat2) ? -EIO : count;
2634 }
2635 static DEVICE_ATTR_RW(lpfc_soft_wwpn);
2636
2637 /**
2638  * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
2639  * @dev: class device that is converted into a Scsi_host.
2640  * @attr: device attribute, not used.
2641  * @buf: on return contains the wwnn in hexadecimal.
2642  *
2643  * Returns: size of formatted string.
2644  **/
2645 static ssize_t
2646 lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
2647                     char *buf)
2648 {
2649         struct Scsi_Host *shost = class_to_shost(dev);
2650         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2651         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2652                         (unsigned long long)phba->cfg_soft_wwnn);
2653 }
2654
2655 /**
2656  * lpfc_soft_wwnn_store - sets the ww node name of the adapter
2657  * @cdev: class device that is converted into a Scsi_host.
2658  * @buf: contains the ww node name in hexadecimal.
2659  * @count: number of wwnn bytes in buf.
2660  *
2661  * Returns:
2662  * -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
2663  * value of count on success
2664  **/
2665 static ssize_t
2666 lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
2667                      const char *buf, size_t count)
2668 {
2669         struct Scsi_Host *shost = class_to_shost(dev);
2670         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2671         unsigned int cnt = count;
2672         u8 wwnn[WWN_SZ];
2673         int rc;
2674
2675         /* count may include a LF at end of string */
2676         if (buf[cnt-1] == '\n')
2677                 cnt--;
2678
2679         if (!phba->soft_wwn_enable)
2680                 return -EINVAL;
2681
2682         rc = lpfc_wwn_set(buf, cnt, wwnn);
2683         if (rc) {
2684                 /* Allow wwnn to be set many times, as long as the enable
2685                  * is set. However, once the wwpn is set, everything locks.
2686                  */
2687                 return rc;
2688         }
2689
2690         phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
2691
2692         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2693                    "lpfc%d: soft_wwnn set. Value will take effect upon "
2694                    "setting of the soft_wwpn\n", phba->brd_no);
2695
2696         return count;
2697 }
2698 static DEVICE_ATTR_RW(lpfc_soft_wwnn);
2699
2700 /**
2701  * lpfc_oas_tgt_show - Return wwpn of target whose luns maybe enabled for
2702  *                    Optimized Access Storage (OAS) operations.
2703  * @dev: class device that is converted into a Scsi_host.
2704  * @attr: device attribute, not used.
2705  * @buf: buffer for passing information.
2706  *
2707  * Returns:
2708  * value of count
2709  **/
2710 static ssize_t
2711 lpfc_oas_tgt_show(struct device *dev, struct device_attribute *attr,
2712                   char *buf)
2713 {
2714         struct Scsi_Host *shost = class_to_shost(dev);
2715         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2716
2717         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2718                         wwn_to_u64(phba->cfg_oas_tgt_wwpn));
2719 }
2720
2721 /**
2722  * lpfc_oas_tgt_store - Store wwpn of target whose luns maybe enabled for
2723  *                    Optimized Access Storage (OAS) operations.
2724  * @dev: class device that is converted into a Scsi_host.
2725  * @attr: device attribute, not used.
2726  * @buf: buffer for passing information.
2727  * @count: Size of the data buffer.
2728  *
2729  * Returns:
2730  * -EINVAL count is invalid, invalid wwpn byte invalid
2731  * -EPERM oas is not supported by hba
2732  * value of count on success
2733  **/
2734 static ssize_t
2735 lpfc_oas_tgt_store(struct device *dev, struct device_attribute *attr,
2736                    const char *buf, size_t count)
2737 {
2738         struct Scsi_Host *shost = class_to_shost(dev);
2739         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2740         unsigned int cnt = count;
2741         uint8_t wwpn[WWN_SZ];
2742         int rc;
2743
2744         if (!phba->cfg_fof)
2745                 return -EPERM;
2746
2747         /* count may include a LF at end of string */
2748         if (buf[cnt-1] == '\n')
2749                 cnt--;
2750
2751         rc = lpfc_wwn_set(buf, cnt, wwpn);
2752         if (rc)
2753                 return rc;
2754
2755         memcpy(phba->cfg_oas_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2756         memcpy(phba->sli4_hba.oas_next_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2757         if (wwn_to_u64(wwpn) == 0)
2758                 phba->cfg_oas_flags |= OAS_FIND_ANY_TARGET;
2759         else
2760                 phba->cfg_oas_flags &= ~OAS_FIND_ANY_TARGET;
2761         phba->cfg_oas_flags &= ~OAS_LUN_VALID;
2762         phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
2763         return count;
2764 }
2765 static DEVICE_ATTR(lpfc_xlane_tgt, S_IRUGO | S_IWUSR,
2766                    lpfc_oas_tgt_show, lpfc_oas_tgt_store);
2767
2768 /**
2769  * lpfc_oas_priority_show - Return wwpn of target whose luns maybe enabled for
2770  *                    Optimized Access Storage (OAS) operations.
2771  * @dev: class device that is converted into a Scsi_host.
2772  * @attr: device attribute, not used.
2773  * @buf: buffer for passing information.
2774  *
2775  * Returns:
2776  * value of count
2777  **/
2778 static ssize_t
2779 lpfc_oas_priority_show(struct device *dev, struct device_attribute *attr,
2780                        char *buf)
2781 {
2782         struct Scsi_Host *shost = class_to_shost(dev);
2783         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2784
2785         return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
2786 }
2787
2788 /**
2789  * lpfc_oas_priority_store - Store wwpn of target whose luns maybe enabled for
2790  *                    Optimized Access Storage (OAS) operations.
2791  * @dev: class device that is converted into a Scsi_host.
2792  * @attr: device attribute, not used.
2793  * @buf: buffer for passing information.
2794  * @count: Size of the data buffer.
2795  *
2796  * Returns:
2797  * -EINVAL count is invalid, invalid wwpn byte invalid
2798  * -EPERM oas is not supported by hba
2799  * value of count on success
2800  **/
2801 static ssize_t
2802 lpfc_oas_priority_store(struct device *dev, struct device_attribute *attr,
2803                         const char *buf, size_t count)
2804 {
2805         struct Scsi_Host *shost = class_to_shost(dev);
2806         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2807         unsigned int cnt = count;
2808         unsigned long val;
2809         int ret;
2810
2811         if (!phba->cfg_fof)
2812                 return -EPERM;
2813
2814         /* count may include a LF at end of string */
2815         if (buf[cnt-1] == '\n')
2816                 cnt--;
2817
2818         ret = kstrtoul(buf, 0, &val);
2819         if (ret || (val > 0x7f))
2820                 return -EINVAL;
2821
2822         if (val)
2823                 phba->cfg_oas_priority = (uint8_t)val;
2824         else
2825                 phba->cfg_oas_priority = phba->cfg_XLanePriority;
2826         return count;
2827 }
2828 static DEVICE_ATTR(lpfc_xlane_priority, S_IRUGO | S_IWUSR,
2829                    lpfc_oas_priority_show, lpfc_oas_priority_store);
2830
2831 /**
2832  * lpfc_oas_vpt_show - Return wwpn of vport whose targets maybe enabled
2833  *                    for Optimized Access Storage (OAS) operations.
2834  * @dev: class device that is converted into a Scsi_host.
2835  * @attr: device attribute, not used.
2836  * @buf: buffer for passing information.
2837  *
2838  * Returns:
2839  * value of count on success
2840  **/
2841 static ssize_t
2842 lpfc_oas_vpt_show(struct device *dev, struct device_attribute *attr,
2843                   char *buf)
2844 {
2845         struct Scsi_Host *shost = class_to_shost(dev);
2846         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2847
2848         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2849                         wwn_to_u64(phba->cfg_oas_vpt_wwpn));
2850 }
2851
2852 /**
2853  * lpfc_oas_vpt_store - Store wwpn of vport whose targets maybe enabled
2854  *                    for Optimized Access Storage (OAS) operations.
2855  * @dev: class device that is converted into a Scsi_host.
2856  * @attr: device attribute, not used.
2857  * @buf: buffer for passing information.
2858  * @count: Size of the data buffer.
2859  *
2860  * Returns:
2861  * -EINVAL count is invalid, invalid wwpn byte invalid
2862  * -EPERM oas is not supported by hba
2863  * value of count on success
2864  **/
2865 static ssize_t
2866 lpfc_oas_vpt_store(struct device *dev, struct device_attribute *attr,
2867                    const char *buf, size_t count)
2868 {
2869         struct Scsi_Host *shost = class_to_shost(dev);
2870         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2871         unsigned int cnt = count;
2872         uint8_t wwpn[WWN_SZ];
2873         int rc;
2874
2875         if (!phba->cfg_fof)
2876                 return -EPERM;
2877
2878         /* count may include a LF at end of string */
2879         if (buf[cnt-1] == '\n')
2880                 cnt--;
2881
2882         rc = lpfc_wwn_set(buf, cnt, wwpn);
2883         if (rc)
2884                 return rc;
2885
2886         memcpy(phba->cfg_oas_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2887         memcpy(phba->sli4_hba.oas_next_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2888         if (wwn_to_u64(wwpn) == 0)
2889                 phba->cfg_oas_flags |= OAS_FIND_ANY_VPORT;
2890         else
2891                 phba->cfg_oas_flags &= ~OAS_FIND_ANY_VPORT;
2892         phba->cfg_oas_flags &= ~OAS_LUN_VALID;
2893         if (phba->cfg_oas_priority == 0)
2894                 phba->cfg_oas_priority = phba->cfg_XLanePriority;
2895         phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
2896         return count;
2897 }
2898 static DEVICE_ATTR(lpfc_xlane_vpt, S_IRUGO | S_IWUSR,
2899                    lpfc_oas_vpt_show, lpfc_oas_vpt_store);
2900
2901 /**
2902  * lpfc_oas_lun_state_show - Return the current state (enabled or disabled)
2903  *                          of whether luns will be enabled or disabled
2904  *                          for Optimized Access Storage (OAS) operations.
2905  * @dev: class device that is converted into a Scsi_host.
2906  * @attr: device attribute, not used.
2907  * @buf: buffer for passing information.
2908  *
2909  * Returns:
2910  * size of formatted string.
2911  **/
2912 static ssize_t
2913 lpfc_oas_lun_state_show(struct device *dev, struct device_attribute *attr,
2914                         char *buf)
2915 {
2916         struct Scsi_Host *shost = class_to_shost(dev);
2917         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2918
2919         return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
2920 }
2921
2922 /**
2923  * lpfc_oas_lun_state_store - Store the state (enabled or disabled)
2924  *                          of whether luns will be enabled or disabled
2925  *                          for Optimized Access Storage (OAS) operations.
2926  * @dev: class device that is converted into a Scsi_host.
2927  * @attr: device attribute, not used.
2928  * @buf: buffer for passing information.
2929  * @count: Size of the data buffer.
2930  *
2931  * Returns:
2932  * -EINVAL count is invalid, invalid wwpn byte invalid
2933  * -EPERM oas is not supported by hba
2934  * value of count on success
2935  **/
2936 static ssize_t
2937 lpfc_oas_lun_state_store(struct device *dev, struct device_attribute *attr,
2938                          const char *buf, size_t count)
2939 {
2940         struct Scsi_Host *shost = class_to_shost(dev);
2941         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2942         int val = 0;
2943
2944         if (!phba->cfg_fof)
2945                 return -EPERM;
2946
2947         if (!isdigit(buf[0]))
2948                 return -EINVAL;
2949
2950         if (sscanf(buf, "%i", &val) != 1)
2951                 return -EINVAL;
2952
2953         if ((val != 0) && (val != 1))
2954                 return -EINVAL;
2955
2956         phba->cfg_oas_lun_state = val;
2957         return strlen(buf);
2958 }
2959 static DEVICE_ATTR(lpfc_xlane_lun_state, S_IRUGO | S_IWUSR,
2960                    lpfc_oas_lun_state_show, lpfc_oas_lun_state_store);
2961
2962 /**
2963  * lpfc_oas_lun_status_show - Return the status of the Optimized Access
2964  *                          Storage (OAS) lun returned by the
2965  *                          lpfc_oas_lun_show function.
2966  * @dev: class device that is converted into a Scsi_host.
2967  * @attr: device attribute, not used.
2968  * @buf: buffer for passing information.
2969  *
2970  * Returns:
2971  * size of formatted string.
2972  **/
2973 static ssize_t
2974 lpfc_oas_lun_status_show(struct device *dev, struct device_attribute *attr,
2975                          char *buf)
2976 {
2977         struct Scsi_Host *shost = class_to_shost(dev);
2978         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2979
2980         if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
2981                 return -EFAULT;
2982
2983         return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
2984 }
2985 static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
2986                    lpfc_oas_lun_status_show, NULL);
2987
2988
2989 /**
2990  * lpfc_oas_lun_state_set - enable or disable a lun for Optimized Access Storage
2991  *                         (OAS) operations.
2992  * @phba: lpfc_hba pointer.
2993  * @ndlp: pointer to fcp target node.
2994  * @lun: the fc lun for setting oas state.
2995  * @oas_state: the oas state to be set to the lun.
2996  *
2997  * Returns:
2998  * SUCCESS : 0
2999  * -EPERM OAS is not enabled or not supported by this port.
3000  *
3001  */
3002 static size_t
3003 lpfc_oas_lun_state_set(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3004                        uint8_t tgt_wwpn[], uint64_t lun,
3005                        uint32_t oas_state, uint8_t pri)
3006 {
3007
3008         int rc = 0;
3009
3010         if (!phba->cfg_fof)
3011                 return -EPERM;
3012
3013         if (oas_state) {
3014                 if (!lpfc_enable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3015                                          (struct lpfc_name *)tgt_wwpn,
3016                                          lun, pri))
3017                         rc = -ENOMEM;
3018         } else {
3019                 lpfc_disable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3020                                      (struct lpfc_name *)tgt_wwpn, lun, pri);
3021         }
3022         return rc;
3023
3024 }
3025
3026 /**
3027  * lpfc_oas_lun_get_next - get the next lun that has been enabled for Optimized
3028  *                        Access Storage (OAS) operations.
3029  * @phba: lpfc_hba pointer.
3030  * @vpt_wwpn: wwpn of the vport associated with the returned lun
3031  * @tgt_wwpn: wwpn of the target associated with the returned lun
3032  * @lun_status: status of the lun returned lun
3033  *
3034  * Returns the first or next lun enabled for OAS operations for the vport/target
3035  * specified.  If a lun is found, its vport wwpn, target wwpn and status is
3036  * returned.  If the lun is not found, NOT_OAS_ENABLED_LUN is returned.
3037  *
3038  * Return:
3039  * lun that is OAS enabled for the vport/target
3040  * NOT_OAS_ENABLED_LUN when no oas enabled lun found.
3041  */
3042 static uint64_t
3043 lpfc_oas_lun_get_next(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3044                       uint8_t tgt_wwpn[], uint32_t *lun_status,
3045                       uint32_t *lun_pri)
3046 {
3047         uint64_t found_lun;
3048
3049         if (unlikely(!phba) || !vpt_wwpn || !tgt_wwpn)
3050                 return NOT_OAS_ENABLED_LUN;
3051         if (lpfc_find_next_oas_lun(phba, (struct lpfc_name *)
3052                                    phba->sli4_hba.oas_next_vpt_wwpn,
3053                                    (struct lpfc_name *)
3054                                    phba->sli4_hba.oas_next_tgt_wwpn,
3055                                    &phba->sli4_hba.oas_next_lun,
3056                                    (struct lpfc_name *)vpt_wwpn,
3057                                    (struct lpfc_name *)tgt_wwpn,
3058                                    &found_lun, lun_status, lun_pri))
3059                 return found_lun;
3060         else
3061                 return NOT_OAS_ENABLED_LUN;
3062 }
3063
3064 /**
3065  * lpfc_oas_lun_state_change - enable/disable a lun for OAS operations
3066  * @phba: lpfc_hba pointer.
3067  * @vpt_wwpn: vport wwpn by reference.
3068  * @tgt_wwpn: target wwpn by reference.
3069  * @lun: the fc lun for setting oas state.
3070  * @oas_state: the oas state to be set to the oas_lun.
3071  *
3072  * This routine enables (OAS_LUN_ENABLE) or disables (OAS_LUN_DISABLE)
3073  * a lun for OAS operations.
3074  *
3075  * Return:
3076  * SUCCESS: 0
3077  * -ENOMEM: failed to enable an lun for OAS operations
3078  * -EPERM: OAS is not enabled
3079  */
3080 static ssize_t
3081 lpfc_oas_lun_state_change(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3082                           uint8_t tgt_wwpn[], uint64_t lun,
3083                           uint32_t oas_state, uint8_t pri)
3084 {
3085
3086         int rc;
3087
3088         rc = lpfc_oas_lun_state_set(phba, vpt_wwpn, tgt_wwpn, lun,
3089                                     oas_state, pri);
3090         return rc;
3091 }
3092
3093 /**
3094  * lpfc_oas_lun_show - Return oas enabled luns from a chosen target
3095  * @dev: class device that is converted into a Scsi_host.
3096  * @attr: device attribute, not used.
3097  * @buf: buffer for passing information.
3098  *
3099  * This routine returns a lun enabled for OAS each time the function
3100  * is called.
3101  *
3102  * Returns:
3103  * SUCCESS: size of formatted string.
3104  * -EFAULT: target or vport wwpn was not set properly.
3105  * -EPERM: oas is not enabled.
3106  **/
3107 static ssize_t
3108 lpfc_oas_lun_show(struct device *dev, struct device_attribute *attr,
3109                   char *buf)
3110 {
3111         struct Scsi_Host *shost = class_to_shost(dev);
3112         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3113
3114         uint64_t oas_lun;
3115         int len = 0;
3116
3117         if (!phba->cfg_fof)
3118                 return -EPERM;
3119
3120         if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3121                 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_VPORT))
3122                         return -EFAULT;
3123
3124         if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3125                 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_TARGET))
3126                         return -EFAULT;
3127
3128         oas_lun = lpfc_oas_lun_get_next(phba, phba->cfg_oas_vpt_wwpn,
3129                                         phba->cfg_oas_tgt_wwpn,
3130                                         &phba->cfg_oas_lun_status,
3131                                         &phba->cfg_oas_priority);
3132         if (oas_lun != NOT_OAS_ENABLED_LUN)
3133                 phba->cfg_oas_flags |= OAS_LUN_VALID;
3134
3135         len += snprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
3136
3137         return len;
3138 }
3139
3140 /**
3141  * lpfc_oas_lun_store - Sets the OAS state for lun
3142  * @dev: class device that is converted into a Scsi_host.
3143  * @attr: device attribute, not used.
3144  * @buf: buffer for passing information.
3145  *
3146  * This function sets the OAS state for lun.  Before this function is called,
3147  * the vport wwpn, target wwpn, and oas state need to be set.
3148  *
3149  * Returns:
3150  * SUCCESS: size of formatted string.
3151  * -EFAULT: target or vport wwpn was not set properly.
3152  * -EPERM: oas is not enabled.
3153  * size of formatted string.
3154  **/
3155 static ssize_t
3156 lpfc_oas_lun_store(struct device *dev, struct device_attribute *attr,
3157                    const char *buf, size_t count)
3158 {
3159         struct Scsi_Host *shost = class_to_shost(dev);
3160         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3161         uint64_t scsi_lun;
3162         uint32_t pri;
3163         ssize_t rc;
3164
3165         if (!phba->cfg_fof)
3166                 return -EPERM;
3167
3168         if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3169                 return -EFAULT;
3170
3171         if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3172                 return -EFAULT;
3173
3174         if (!isdigit(buf[0]))
3175                 return -EINVAL;
3176
3177         if (sscanf(buf, "0x%llx", &scsi_lun) != 1)
3178                 return -EINVAL;
3179
3180         pri = phba->cfg_oas_priority;
3181         if (pri == 0)
3182                 pri = phba->cfg_XLanePriority;
3183
3184         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3185                         "3372 Try to set vport 0x%llx target 0x%llx lun:0x%llx "
3186                         "priority 0x%x with oas state %d\n",
3187                         wwn_to_u64(phba->cfg_oas_vpt_wwpn),
3188                         wwn_to_u64(phba->cfg_oas_tgt_wwpn), scsi_lun,
3189                         pri, phba->cfg_oas_lun_state);
3190
3191         rc = lpfc_oas_lun_state_change(phba, phba->cfg_oas_vpt_wwpn,
3192                                        phba->cfg_oas_tgt_wwpn, scsi_lun,
3193                                        phba->cfg_oas_lun_state, pri);
3194         if (rc)
3195                 return rc;
3196
3197         return count;
3198 }
3199 static DEVICE_ATTR(lpfc_xlane_lun, S_IRUGO | S_IWUSR,
3200                    lpfc_oas_lun_show, lpfc_oas_lun_store);
3201
3202 int lpfc_enable_nvmet_cnt;
3203 unsigned long long lpfc_enable_nvmet[LPFC_NVMET_MAX_PORTS] = {
3204         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3205         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3206 module_param_array(lpfc_enable_nvmet, ullong, &lpfc_enable_nvmet_cnt, 0444);
3207 MODULE_PARM_DESC(lpfc_enable_nvmet, "Enable HBA port(s) WWPN as a NVME Target");
3208
3209 static int lpfc_poll = 0;
3210 module_param(lpfc_poll, int, S_IRUGO);
3211 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
3212                  " 0 - none,"
3213                  " 1 - poll with interrupts enabled"
3214                  " 3 - poll and disable FCP ring interrupts");
3215
3216 static DEVICE_ATTR_RW(lpfc_poll);
3217
3218 int lpfc_no_hba_reset_cnt;
3219 unsigned long lpfc_no_hba_reset[MAX_HBAS_NO_RESET] = {
3220         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3221 module_param_array(lpfc_no_hba_reset, ulong, &lpfc_no_hba_reset_cnt, 0444);
3222 MODULE_PARM_DESC(lpfc_no_hba_reset, "WWPN of HBAs that should not be reset");
3223
3224 LPFC_ATTR(sli_mode, 0, 0, 3,
3225         "SLI mode selector:"
3226         " 0 - auto (SLI-3 if supported),"
3227         " 2 - select SLI-2 even on SLI-3 capable HBAs,"
3228         " 3 - select SLI-3");
3229
3230 LPFC_ATTR_R(enable_npiv, 1, 0, 1,
3231         "Enable NPIV functionality");
3232
3233 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
3234         "FCF Fast failover=1 Priority failover=2");
3235
3236 /*
3237 # lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
3238 #       0x0 = disabled, XRI/OXID use not tracked.
3239 #       0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
3240 #       0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
3241 */
3242 LPFC_ATTR_R(enable_rrq, 2, 0, 2,
3243         "Enable RRQ functionality");
3244
3245 /*
3246 # lpfc_suppress_link_up:  Bring link up at initialization
3247 #            0x0  = bring link up (issue MBX_INIT_LINK)
3248 #            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
3249 #            0x2  = never bring up link
3250 # Default value is 0.
3251 */
3252 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
3253                 LPFC_DELAY_INIT_LINK_INDEFINITELY,
3254                 "Suppress Link Up at initialization");
3255 /*
3256 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
3257 #       1 - (1024)
3258 #       2 - (2048)
3259 #       3 - (3072)
3260 #       4 - (4096)
3261 #       5 - (5120)
3262 */
3263 static ssize_t
3264 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3265 {
3266         struct Scsi_Host  *shost = class_to_shost(dev);
3267         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3268
3269         return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
3270 }
3271
3272 static DEVICE_ATTR(iocb_hw, S_IRUGO,
3273                          lpfc_iocb_hw_show, NULL);
3274 static ssize_t
3275 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3276 {
3277         struct Scsi_Host  *shost = class_to_shost(dev);
3278         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3279         struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3280
3281         return snprintf(buf, PAGE_SIZE, "%d\n",
3282                         pring ? pring->txq_max : 0);
3283 }
3284
3285 static DEVICE_ATTR(txq_hw, S_IRUGO,
3286                          lpfc_txq_hw_show, NULL);
3287 static ssize_t
3288 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
3289  char *buf)
3290 {
3291         struct Scsi_Host  *shost = class_to_shost(dev);
3292         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3293         struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3294
3295         return snprintf(buf, PAGE_SIZE, "%d\n",
3296                         pring ? pring->txcmplq_max : 0);
3297 }
3298
3299 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
3300                          lpfc_txcmplq_hw_show, NULL);
3301
3302 LPFC_ATTR_R(iocb_cnt, 2, 1, 5,
3303         "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
3304
3305 /*
3306 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
3307 # until the timer expires. Value range is [0,255]. Default value is 30.
3308 */
3309 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3310 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
3311 module_param(lpfc_nodev_tmo, int, 0);
3312 MODULE_PARM_DESC(lpfc_nodev_tmo,
3313                  "Seconds driver will hold I/O waiting "
3314                  "for a device to come back");
3315
3316 /**
3317  * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
3318  * @dev: class converted to a Scsi_host structure.
3319  * @attr: device attribute, not used.
3320  * @buf: on return contains the dev loss timeout in decimal.
3321  *
3322  * Returns: size of formatted string.
3323  **/
3324 static ssize_t
3325 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
3326                     char *buf)
3327 {
3328         struct Scsi_Host  *shost = class_to_shost(dev);
3329         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3330
3331         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
3332 }
3333
3334 /**
3335  * lpfc_nodev_tmo_init - Set the hba nodev timeout value
3336  * @vport: lpfc vport structure pointer.
3337  * @val: contains the nodev timeout value.
3338  *
3339  * Description:
3340  * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
3341  * a kernel error message is printed and zero is returned.
3342  * Else if val is in range then nodev tmo and devloss tmo are set to val.
3343  * Otherwise nodev tmo is set to the default value.
3344  *
3345  * Returns:
3346  * zero if already set or if val is in range
3347  * -EINVAL val out of range
3348  **/
3349 static int
3350 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
3351 {
3352         if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
3353                 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
3354                 if (val != LPFC_DEF_DEVLOSS_TMO)
3355                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3356                                          "0407 Ignoring lpfc_nodev_tmo module "
3357                                          "parameter because lpfc_devloss_tmo "
3358                                          "is set.\n");
3359                 return 0;
3360         }
3361
3362         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3363                 vport->cfg_nodev_tmo = val;
3364                 vport->cfg_devloss_tmo = val;
3365                 return 0;
3366         }
3367         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3368                          "0400 lpfc_nodev_tmo attribute cannot be set to"
3369                          " %d, allowed range is [%d, %d]\n",
3370                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3371         vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3372         return -EINVAL;
3373 }
3374
3375 /**
3376  * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
3377  * @vport: lpfc vport structure pointer.
3378  *
3379  * Description:
3380  * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
3381  **/
3382 static void
3383 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
3384 {
3385         struct Scsi_Host  *shost;
3386         struct lpfc_nodelist  *ndlp;
3387 #if (IS_ENABLED(CONFIG_NVME_FC))
3388         struct lpfc_nvme_rport *rport;
3389 #endif
3390
3391         shost = lpfc_shost_from_vport(vport);
3392         spin_lock_irq(shost->host_lock);
3393         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3394                 if (!NLP_CHK_NODE_ACT(ndlp))
3395                         continue;
3396                 if (ndlp->rport)
3397                         ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
3398 #if (IS_ENABLED(CONFIG_NVME_FC))
3399                 rport = lpfc_ndlp_get_nrport(ndlp);
3400                 if (rport)
3401                         nvme_fc_set_remoteport_devloss(rport->remoteport,
3402                                                        vport->cfg_devloss_tmo);
3403 #endif
3404         }
3405         spin_unlock_irq(shost->host_lock);
3406 }
3407
3408 /**
3409  * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
3410  * @vport: lpfc vport structure pointer.
3411  * @val: contains the tmo value.
3412  *
3413  * Description:
3414  * If the devloss tmo is already set or the vport dev loss tmo has changed
3415  * then a kernel error message is printed and zero is returned.
3416  * Else if val is in range then nodev tmo and devloss tmo are set to val.
3417  * Otherwise nodev tmo is set to the default value.
3418  *
3419  * Returns:
3420  * zero if already set or if val is in range
3421  * -EINVAL val out of range
3422  **/
3423 static int
3424 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
3425 {
3426         if (vport->dev_loss_tmo_changed ||
3427             (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
3428                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3429                                  "0401 Ignoring change to lpfc_nodev_tmo "
3430                                  "because lpfc_devloss_tmo is set.\n");
3431                 return 0;
3432         }
3433         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3434                 vport->cfg_nodev_tmo = val;
3435                 vport->cfg_devloss_tmo = val;
3436                 /*
3437                  * For compat: set the fc_host dev loss so new rports
3438                  * will get the value.
3439                  */
3440                 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3441                 lpfc_update_rport_devloss_tmo(vport);
3442                 return 0;
3443         }
3444         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3445                          "0403 lpfc_nodev_tmo attribute cannot be set to "
3446                          "%d, allowed range is [%d, %d]\n",
3447                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3448         return -EINVAL;
3449 }
3450
3451 lpfc_vport_param_store(nodev_tmo)
3452
3453 static DEVICE_ATTR_RW(lpfc_nodev_tmo);
3454
3455 /*
3456 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
3457 # disappear until the timer expires. Value range is [0,255]. Default
3458 # value is 30.
3459 */
3460 module_param(lpfc_devloss_tmo, int, S_IRUGO);
3461 MODULE_PARM_DESC(lpfc_devloss_tmo,
3462                  "Seconds driver will hold I/O waiting "
3463                  "for a device to come back");
3464 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
3465                       LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
3466 lpfc_vport_param_show(devloss_tmo)
3467
3468 /**
3469  * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
3470  * @vport: lpfc vport structure pointer.
3471  * @val: contains the tmo value.
3472  *
3473  * Description:
3474  * If val is in a valid range then set the vport nodev tmo,
3475  * devloss tmo, also set the vport dev loss tmo changed flag.
3476  * Else a kernel error message is printed.
3477  *
3478  * Returns:
3479  * zero if val is in range
3480  * -EINVAL val out of range
3481  **/
3482 static int
3483 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
3484 {
3485         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3486                 vport->cfg_nodev_tmo = val;
3487                 vport->cfg_devloss_tmo = val;
3488                 vport->dev_loss_tmo_changed = 1;
3489                 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3490                 lpfc_update_rport_devloss_tmo(vport);
3491                 return 0;
3492         }
3493
3494         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3495                          "0404 lpfc_devloss_tmo attribute cannot be set to "
3496                          "%d, allowed range is [%d, %d]\n",
3497                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3498         return -EINVAL;
3499 }
3500
3501 lpfc_vport_param_store(devloss_tmo)
3502 static DEVICE_ATTR_RW(lpfc_devloss_tmo);
3503
3504 /*
3505  * lpfc_suppress_rsp: Enable suppress rsp feature is firmware supports it
3506  * lpfc_suppress_rsp = 0  Disable
3507  * lpfc_suppress_rsp = 1  Enable (default)
3508  *
3509  */
3510 LPFC_ATTR_R(suppress_rsp, 1, 0, 1,
3511             "Enable suppress rsp feature is firmware supports it");
3512
3513 /*
3514  * lpfc_nvmet_mrq: Specify number of RQ pairs for processing NVMET cmds
3515  * lpfc_nvmet_mrq = 0  driver will calcualte optimal number of RQ pairs
3516  * lpfc_nvmet_mrq = 1  use a single RQ pair
3517  * lpfc_nvmet_mrq >= 2  use specified RQ pairs for MRQ
3518  *
3519  */
3520 LPFC_ATTR_R(nvmet_mrq,
3521             LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_MAX,
3522             "Specify number of RQ pairs for processing NVMET cmds");
3523
3524 /*
3525  * lpfc_nvmet_mrq_post: Specify number of RQ buffer to initially post
3526  * to each NVMET RQ. Range 64 to 2048, default is 512.
3527  */
3528 LPFC_ATTR_R(nvmet_mrq_post,
3529             LPFC_NVMET_RQE_DEF_POST, LPFC_NVMET_RQE_MIN_POST,
3530             LPFC_NVMET_RQE_DEF_COUNT,
3531             "Specify number of RQ buffers to initially post");
3532
3533 /*
3534  * lpfc_enable_fc4_type: Defines what FC4 types are supported.
3535  * Supported Values:  1 - register just FCP
3536  *                    3 - register both FCP and NVME
3537  * Supported values are [1,3]. Default value is 1
3538  */
3539 LPFC_ATTR_R(enable_fc4_type, LPFC_ENABLE_FCP,
3540             LPFC_ENABLE_FCP, LPFC_ENABLE_BOTH,
3541             "Enable FC4 Protocol support - FCP / NVME");
3542
3543 /*
3544  * lpfc_xri_split: Defines the division of XRI resources between SCSI and NVME
3545  * This parameter is only used if:
3546  *     lpfc_enable_fc4_type is 3 - register both FCP and NVME and
3547  *     port is not configured for NVMET.
3548  *
3549  * ELS/CT always get 10% of XRIs, up to a maximum of 250
3550  * The remaining XRIs get split up based on lpfc_xri_split per port:
3551  *
3552  * Supported Values are in percentages
3553  * the xri_split value is the percentage the SCSI port will get. The remaining
3554  * percentage will go to NVME.
3555  */
3556 LPFC_ATTR_R(xri_split, 50, 10, 90,
3557             "Percentage of FCP XRI resources versus NVME");
3558
3559 /*
3560 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
3561 # deluged with LOTS of information.
3562 # You can set a bit mask to record specific types of verbose messages:
3563 # See lpfc_logmsh.h for definitions.
3564 */
3565 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
3566                        "Verbose logging bit-mask");
3567
3568 /*
3569 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
3570 # objects that have been registered with the nameserver after login.
3571 */
3572 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
3573                   "Deregister nameserver objects before LOGO");
3574
3575 /*
3576 # lun_queue_depth:  This parameter is used to limit the number of outstanding
3577 # commands per FCP LUN. Value range is [1,512]. Default value is 30.
3578 # If this parameter value is greater than 1/8th the maximum number of exchanges
3579 # supported by the HBA port, then the lun queue depth will be reduced to
3580 # 1/8th the maximum number of exchanges.
3581 */
3582 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 512,
3583                   "Max number of FCP commands we can queue to a specific LUN");
3584
3585 /*
3586 # tgt_queue_depth:  This parameter is used to limit the number of outstanding
3587 # commands per target port. Value range is [10,65535]. Default value is 65535.
3588 */
3589 static uint lpfc_tgt_queue_depth = LPFC_MAX_TGT_QDEPTH;
3590 module_param(lpfc_tgt_queue_depth, uint, 0444);
3591 MODULE_PARM_DESC(lpfc_tgt_queue_depth, "Set max Target queue depth");
3592 lpfc_vport_param_show(tgt_queue_depth);
3593 lpfc_vport_param_init(tgt_queue_depth, LPFC_MAX_TGT_QDEPTH,
3594                       LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH);
3595
3596 /**
3597  * lpfc_tgt_queue_depth_store: Sets an attribute value.
3598  * @phba: pointer the the adapter structure.
3599  * @val: integer attribute value.
3600  *
3601  * Description: Sets the parameter to the new value.
3602  *
3603  * Returns:
3604  * zero on success
3605  * -EINVAL if val is invalid
3606  */
3607 static int
3608 lpfc_tgt_queue_depth_set(struct lpfc_vport *vport, uint val)
3609 {
3610         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3611         struct lpfc_nodelist *ndlp;
3612
3613         if (!lpfc_rangecheck(val, LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH))
3614                 return -EINVAL;
3615
3616         if (val == vport->cfg_tgt_queue_depth)
3617                 return 0;
3618
3619         spin_lock_irq(shost->host_lock);
3620         vport->cfg_tgt_queue_depth = val;
3621
3622         /* Next loop thru nodelist and change cmd_qdepth */
3623         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
3624                 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
3625
3626         spin_unlock_irq(shost->host_lock);
3627         return 0;
3628 }
3629
3630 lpfc_vport_param_store(tgt_queue_depth);
3631 static DEVICE_ATTR_RW(lpfc_tgt_queue_depth);
3632
3633 /*
3634 # hba_queue_depth:  This parameter is used to limit the number of outstanding
3635 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
3636 # value is greater than the maximum number of exchanges supported by the HBA,
3637 # then maximum number of exchanges supported by the HBA is used to determine
3638 # the hba_queue_depth.
3639 */
3640 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
3641             "Max number of FCP commands we can queue to a lpfc HBA");
3642
3643 /*
3644 # peer_port_login:  This parameter allows/prevents logins
3645 # between peer ports hosted on the same physical port.
3646 # When this parameter is set 0 peer ports of same physical port
3647 # are not allowed to login to each other.
3648 # When this parameter is set 1 peer ports of same physical port
3649 # are allowed to login to each other.
3650 # Default value of this parameter is 0.
3651 */
3652 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
3653                   "Allow peer ports on the same physical port to login to each "
3654                   "other.");
3655
3656 /*
3657 # restrict_login:  This parameter allows/prevents logins
3658 # between Virtual Ports and remote initiators.
3659 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
3660 # other initiators and will attempt to PLOGI all remote ports.
3661 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
3662 # remote ports and will not attempt to PLOGI to other initiators.
3663 # This parameter does not restrict to the physical port.
3664 # This parameter does not restrict logins to Fabric resident remote ports.
3665 # Default value of this parameter is 1.
3666 */
3667 static int lpfc_restrict_login = 1;
3668 module_param(lpfc_restrict_login, int, S_IRUGO);
3669 MODULE_PARM_DESC(lpfc_restrict_login,
3670                  "Restrict virtual ports login to remote initiators.");
3671 lpfc_vport_param_show(restrict_login);
3672
3673 /**
3674  * lpfc_restrict_login_init - Set the vport restrict login flag
3675  * @vport: lpfc vport structure pointer.
3676  * @val: contains the restrict login value.
3677  *
3678  * Description:
3679  * If val is not in a valid range then log a kernel error message and set
3680  * the vport restrict login to one.
3681  * If the port type is physical clear the restrict login flag and return.
3682  * Else set the restrict login flag to val.
3683  *
3684  * Returns:
3685  * zero if val is in range
3686  * -EINVAL val out of range
3687  **/
3688 static int
3689 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
3690 {
3691         if (val < 0 || val > 1) {
3692                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3693                                  "0422 lpfc_restrict_login attribute cannot "
3694                                  "be set to %d, allowed range is [0, 1]\n",
3695                                  val);
3696                 vport->cfg_restrict_login = 1;
3697                 return -EINVAL;
3698         }
3699         if (vport->port_type == LPFC_PHYSICAL_PORT) {
3700                 vport->cfg_restrict_login = 0;
3701                 return 0;
3702         }
3703         vport->cfg_restrict_login = val;
3704         return 0;
3705 }
3706
3707 /**
3708  * lpfc_restrict_login_set - Set the vport restrict login flag
3709  * @vport: lpfc vport structure pointer.
3710  * @val: contains the restrict login value.
3711  *
3712  * Description:
3713  * If val is not in a valid range then log a kernel error message and set
3714  * the vport restrict login to one.
3715  * If the port type is physical and the val is not zero log a kernel
3716  * error message, clear the restrict login flag and return zero.
3717  * Else set the restrict login flag to val.
3718  *
3719  * Returns:
3720  * zero if val is in range
3721  * -EINVAL val out of range
3722  **/
3723 static int
3724 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
3725 {
3726         if (val < 0 || val > 1) {
3727                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3728                                  "0425 lpfc_restrict_login attribute cannot "
3729                                  "be set to %d, allowed range is [0, 1]\n",
3730                                  val);
3731                 vport->cfg_restrict_login = 1;
3732                 return -EINVAL;
3733         }
3734         if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
3735                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3736                                  "0468 lpfc_restrict_login must be 0 for "
3737                                  "Physical ports.\n");
3738                 vport->cfg_restrict_login = 0;
3739                 return 0;
3740         }
3741         vport->cfg_restrict_login = val;
3742         return 0;
3743 }
3744 lpfc_vport_param_store(restrict_login);
3745 static DEVICE_ATTR_RW(lpfc_restrict_login);
3746
3747 /*
3748 # Some disk devices have a "select ID" or "select Target" capability.
3749 # From a protocol standpoint "select ID" usually means select the
3750 # Fibre channel "ALPA".  In the FC-AL Profile there is an "informative
3751 # annex" which contains a table that maps a "select ID" (a number
3752 # between 0 and 7F) to an ALPA.  By default, for compatibility with
3753 # older drivers, the lpfc driver scans this table from low ALPA to high
3754 # ALPA.
3755 #
3756 # Turning on the scan-down variable (on  = 1, off = 0) will
3757 # cause the lpfc driver to use an inverted table, effectively
3758 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
3759 #
3760 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
3761 # and will not work across a fabric. Also this parameter will take
3762 # effect only in the case when ALPA map is not available.)
3763 */
3764 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
3765                   "Start scanning for devices from highest ALPA to lowest");
3766
3767 /*
3768 # lpfc_topology:  link topology for init link
3769 #            0x0  = attempt loop mode then point-to-point
3770 #            0x01 = internal loopback mode
3771 #            0x02 = attempt point-to-point mode only
3772 #            0x04 = attempt loop mode only
3773 #            0x06 = attempt point-to-point mode then loop
3774 # Set point-to-point mode if you want to run as an N_Port.
3775 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
3776 # Default value is 0.
3777 */
3778 LPFC_ATTR(topology, 0, 0, 6,
3779         "Select Fibre Channel topology");
3780
3781 /**
3782  * lpfc_topology_set - Set the adapters topology field
3783  * @phba: lpfc_hba pointer.
3784  * @val: topology value.
3785  *
3786  * Description:
3787  * If val is in a valid range then set the adapter's topology field and
3788  * issue a lip; if the lip fails reset the topology to the old value.
3789  *
3790  * If the value is not in range log a kernel error message and return an error.
3791  *
3792  * Returns:
3793  * zero if val is in range and lip okay
3794  * non-zero return value from lpfc_issue_lip()
3795  * -EINVAL val out of range
3796  **/
3797 static ssize_t
3798 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
3799                         const char *buf, size_t count)
3800 {
3801         struct Scsi_Host  *shost = class_to_shost(dev);
3802         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3803         struct lpfc_hba   *phba = vport->phba;
3804         int val = 0;
3805         int nolip = 0;
3806         const char *val_buf = buf;
3807         int err;
3808         uint32_t prev_val;
3809
3810         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
3811                 nolip = 1;
3812                 val_buf = &buf[strlen("nolip ")];
3813         }
3814
3815         if (!isdigit(val_buf[0]))
3816                 return -EINVAL;
3817         if (sscanf(val_buf, "%i", &val) != 1)
3818                 return -EINVAL;
3819
3820         if (val >= 0 && val <= 6) {
3821                 prev_val = phba->cfg_topology;
3822                 if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
3823                         val == 4) {
3824                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3825                                 "3113 Loop mode not supported at speed %d\n",
3826                                 val);
3827                         return -EINVAL;
3828                 }
3829                 if (phba->pcidev->device == PCI_DEVICE_ID_LANCER_G6_FC &&
3830                         val == 4) {
3831                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3832                                 "3114 Loop mode not supported\n");
3833                         return -EINVAL;
3834                 }
3835                 phba->cfg_topology = val;
3836                 if (nolip)
3837                         return strlen(buf);
3838
3839                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3840                         "3054 lpfc_topology changed from %d to %d\n",
3841                         prev_val, val);
3842                 if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
3843                         phba->fc_topology_changed = 1;
3844                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
3845                 if (err) {
3846                         phba->cfg_topology = prev_val;
3847                         return -EINVAL;
3848                 } else
3849                         return strlen(buf);
3850         }
3851         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3852                 "%d:0467 lpfc_topology attribute cannot be set to %d, "
3853                 "allowed range is [0, 6]\n",
3854                 phba->brd_no, val);
3855         return -EINVAL;
3856 }
3857
3858 lpfc_param_show(topology)
3859 static DEVICE_ATTR_RW(lpfc_topology);
3860
3861 /**
3862  * lpfc_static_vport_show: Read callback function for
3863  *   lpfc_static_vport sysfs file.
3864  * @dev: Pointer to class device object.
3865  * @attr: device attribute structure.
3866  * @buf: Data buffer.
3867  *
3868  * This function is the read call back function for
3869  * lpfc_static_vport sysfs file. The lpfc_static_vport
3870  * sysfs file report the mageability of the vport.
3871  **/
3872 static ssize_t
3873 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
3874                          char *buf)
3875 {
3876         struct Scsi_Host  *shost = class_to_shost(dev);
3877         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3878         if (vport->vport_flag & STATIC_VPORT)
3879                 sprintf(buf, "1\n");
3880         else
3881                 sprintf(buf, "0\n");
3882
3883         return strlen(buf);
3884 }
3885
3886 /*
3887  * Sysfs attribute to control the statistical data collection.
3888  */
3889 static DEVICE_ATTR_RO(lpfc_static_vport);
3890
3891 /**
3892  * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
3893  * @dev: Pointer to class device.
3894  * @buf: Data buffer.
3895  * @count: Size of the data buffer.
3896  *
3897  * This function get called when a user write to the lpfc_stat_data_ctrl
3898  * sysfs file. This function parse the command written to the sysfs file
3899  * and take appropriate action. These commands are used for controlling
3900  * driver statistical data collection.
3901  * Following are the command this function handles.
3902  *
3903  *    setbucket <bucket_type> <base> <step>
3904  *                             = Set the latency buckets.
3905  *    destroybucket            = destroy all the buckets.
3906  *    start                    = start data collection
3907  *    stop                     = stop data collection
3908  *    reset                    = reset the collected data
3909  **/
3910 static ssize_t
3911 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
3912                           const char *buf, size_t count)
3913 {
3914         struct Scsi_Host  *shost = class_to_shost(dev);
3915         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3916         struct lpfc_hba   *phba = vport->phba;
3917 #define LPFC_MAX_DATA_CTRL_LEN 1024
3918         static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
3919         unsigned long i;
3920         char *str_ptr, *token;
3921         struct lpfc_vport **vports;
3922         struct Scsi_Host *v_shost;
3923         char *bucket_type_str, *base_str, *step_str;
3924         unsigned long base, step, bucket_type;
3925
3926         if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
3927                 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
3928                         return -EINVAL;
3929
3930                 strncpy(bucket_data, buf, LPFC_MAX_DATA_CTRL_LEN);
3931                 str_ptr = &bucket_data[0];
3932                 /* Ignore this token - this is command token */
3933                 token = strsep(&str_ptr, "\t ");
3934                 if (!token)
3935                         return -EINVAL;
3936
3937                 bucket_type_str = strsep(&str_ptr, "\t ");
3938                 if (!bucket_type_str)
3939                         return -EINVAL;
3940
3941                 if (!strncmp(bucket_type_str, "linear", strlen("linear")))
3942                         bucket_type = LPFC_LINEAR_BUCKET;
3943                 else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
3944                         bucket_type = LPFC_POWER2_BUCKET;
3945                 else
3946                         return -EINVAL;
3947
3948                 base_str = strsep(&str_ptr, "\t ");
3949                 if (!base_str)
3950                         return -EINVAL;
3951                 base = simple_strtoul(base_str, NULL, 0);
3952
3953                 step_str = strsep(&str_ptr, "\t ");
3954                 if (!step_str)
3955                         return -EINVAL;
3956                 step = simple_strtoul(step_str, NULL, 0);
3957                 if (!step)
3958                         return -EINVAL;
3959
3960                 /* Block the data collection for every vport */
3961                 vports = lpfc_create_vport_work_array(phba);
3962                 if (vports == NULL)
3963                         return -ENOMEM;
3964
3965                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3966                         v_shost = lpfc_shost_from_vport(vports[i]);
3967                         spin_lock_irq(v_shost->host_lock);
3968                         /* Block and reset data collection */
3969                         vports[i]->stat_data_blocked = 1;
3970                         if (vports[i]->stat_data_enabled)
3971                                 lpfc_vport_reset_stat_data(vports[i]);
3972                         spin_unlock_irq(v_shost->host_lock);
3973                 }
3974
3975                 /* Set the bucket attributes */
3976                 phba->bucket_type = bucket_type;
3977                 phba->bucket_base = base;
3978                 phba->bucket_step = step;
3979
3980                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3981                         v_shost = lpfc_shost_from_vport(vports[i]);
3982
3983                         /* Unblock data collection */
3984                         spin_lock_irq(v_shost->host_lock);
3985                         vports[i]->stat_data_blocked = 0;
3986                         spin_unlock_irq(v_shost->host_lock);
3987                 }
3988                 lpfc_destroy_vport_work_array(phba, vports);
3989                 return strlen(buf);
3990         }
3991
3992         if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
3993                 vports = lpfc_create_vport_work_array(phba);
3994                 if (vports == NULL)
3995                         return -ENOMEM;
3996
3997                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3998                         v_shost = lpfc_shost_from_vport(vports[i]);
3999                         spin_lock_irq(shost->host_lock);
4000                         vports[i]->stat_data_blocked = 1;
4001                         lpfc_free_bucket(vport);
4002                         vport->stat_data_enabled = 0;
4003                         vports[i]->stat_data_blocked = 0;
4004                         spin_unlock_irq(shost->host_lock);
4005                 }
4006                 lpfc_destroy_vport_work_array(phba, vports);
4007                 phba->bucket_type = LPFC_NO_BUCKET;
4008                 phba->bucket_base = 0;
4009                 phba->bucket_step = 0;
4010                 return strlen(buf);
4011         }
4012
4013         if (!strncmp(buf, "start", strlen("start"))) {
4014                 /* If no buckets configured return error */
4015                 if (phba->bucket_type == LPFC_NO_BUCKET)
4016                         return -EINVAL;
4017                 spin_lock_irq(shost->host_lock);
4018                 if (vport->stat_data_enabled) {
4019                         spin_unlock_irq(shost->host_lock);
4020                         return strlen(buf);
4021                 }
4022                 lpfc_alloc_bucket(vport);
4023                 vport->stat_data_enabled = 1;
4024                 spin_unlock_irq(shost->host_lock);
4025                 return strlen(buf);
4026         }
4027
4028         if (!strncmp(buf, "stop", strlen("stop"))) {
4029                 spin_lock_irq(shost->host_lock);
4030                 if (vport->stat_data_enabled == 0) {
4031                         spin_unlock_irq(shost->host_lock);
4032                         return strlen(buf);
4033                 }
4034                 lpfc_free_bucket(vport);
4035                 vport->stat_data_enabled = 0;
4036                 spin_unlock_irq(shost->host_lock);
4037                 return strlen(buf);
4038         }
4039
4040         if (!strncmp(buf, "reset", strlen("reset"))) {
4041                 if ((phba->bucket_type == LPFC_NO_BUCKET)
4042                         || !vport->stat_data_enabled)
4043                         return strlen(buf);
4044                 spin_lock_irq(shost->host_lock);
4045                 vport->stat_data_blocked = 1;
4046                 lpfc_vport_reset_stat_data(vport);
4047                 vport->stat_data_blocked = 0;
4048                 spin_unlock_irq(shost->host_lock);
4049                 return strlen(buf);
4050         }
4051         return -EINVAL;
4052 }
4053
4054
4055 /**
4056  * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
4057  * @dev: Pointer to class device object.
4058  * @buf: Data buffer.
4059  *
4060  * This function is the read call back function for
4061  * lpfc_stat_data_ctrl sysfs file. This function report the
4062  * current statistical data collection state.
4063  **/
4064 static ssize_t
4065 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
4066                          char *buf)
4067 {
4068         struct Scsi_Host  *shost = class_to_shost(dev);
4069         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4070         struct lpfc_hba   *phba = vport->phba;
4071         int index = 0;
4072         int i;
4073         char *bucket_type;
4074         unsigned long bucket_value;
4075
4076         switch (phba->bucket_type) {
4077         case LPFC_LINEAR_BUCKET:
4078                 bucket_type = "linear";
4079                 break;
4080         case LPFC_POWER2_BUCKET:
4081                 bucket_type = "power2";
4082                 break;
4083         default:
4084                 bucket_type = "No Bucket";
4085                 break;
4086         }
4087
4088         sprintf(&buf[index], "Statistical Data enabled :%d, "
4089                 "blocked :%d, Bucket type :%s, Bucket base :%d,"
4090                 " Bucket step :%d\nLatency Ranges :",
4091                 vport->stat_data_enabled, vport->stat_data_blocked,
4092                 bucket_type, phba->bucket_base, phba->bucket_step);
4093         index = strlen(buf);
4094         if (phba->bucket_type != LPFC_NO_BUCKET) {
4095                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
4096                         if (phba->bucket_type == LPFC_LINEAR_BUCKET)
4097                                 bucket_value = phba->bucket_base +
4098                                         phba->bucket_step * i;
4099                         else
4100                                 bucket_value = phba->bucket_base +
4101                                 (1 << i) * phba->bucket_step;
4102
4103                         if (index + 10 > PAGE_SIZE)
4104                                 break;
4105                         sprintf(&buf[index], "%08ld ", bucket_value);
4106                         index = strlen(buf);
4107                 }
4108         }
4109         sprintf(&buf[index], "\n");
4110         return strlen(buf);
4111 }
4112
4113 /*
4114  * Sysfs attribute to control the statistical data collection.
4115  */
4116 static DEVICE_ATTR_RW(lpfc_stat_data_ctrl);
4117
4118 /*
4119  * lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
4120  */
4121
4122 /*
4123  * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
4124  * for each target.
4125  */
4126 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
4127 #define MAX_STAT_DATA_SIZE_PER_TARGET \
4128         STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
4129
4130
4131 /**
4132  * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
4133  * @filp: sysfs file
4134  * @kobj: Pointer to the kernel object
4135  * @bin_attr: Attribute object
4136  * @buff: Buffer pointer
4137  * @off: File offset
4138  * @count: Buffer size
4139  *
4140  * This function is the read call back function for lpfc_drvr_stat_data
4141  * sysfs file. This function export the statistical data to user
4142  * applications.
4143  **/
4144 static ssize_t
4145 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
4146                 struct bin_attribute *bin_attr,
4147                 char *buf, loff_t off, size_t count)
4148 {
4149         struct device *dev = container_of(kobj, struct device,
4150                 kobj);
4151         struct Scsi_Host  *shost = class_to_shost(dev);
4152         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4153         struct lpfc_hba   *phba = vport->phba;
4154         int i = 0, index = 0;
4155         unsigned long nport_index;
4156         struct lpfc_nodelist *ndlp = NULL;
4157         nport_index = (unsigned long)off /
4158                 MAX_STAT_DATA_SIZE_PER_TARGET;
4159
4160         if (!vport->stat_data_enabled || vport->stat_data_blocked
4161                 || (phba->bucket_type == LPFC_NO_BUCKET))
4162                 return 0;
4163
4164         spin_lock_irq(shost->host_lock);
4165         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
4166                 if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data)
4167                         continue;
4168
4169                 if (nport_index > 0) {
4170                         nport_index--;
4171                         continue;
4172                 }
4173
4174                 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
4175                         > count)
4176                         break;
4177
4178                 if (!ndlp->lat_data)
4179                         continue;
4180
4181                 /* Print the WWN */
4182                 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
4183                         ndlp->nlp_portname.u.wwn[0],
4184                         ndlp->nlp_portname.u.wwn[1],
4185                         ndlp->nlp_portname.u.wwn[2],
4186                         ndlp->nlp_portname.u.wwn[3],
4187                         ndlp->nlp_portname.u.wwn[4],
4188                         ndlp->nlp_portname.u.wwn[5],
4189                         ndlp->nlp_portname.u.wwn[6],
4190                         ndlp->nlp_portname.u.wwn[7]);
4191
4192                 index = strlen(buf);
4193
4194                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
4195                         sprintf(&buf[index], "%010u,",
4196                                 ndlp->lat_data[i].cmd_count);
4197                         index = strlen(buf);
4198                 }
4199                 sprintf(&buf[index], "\n");
4200                 index = strlen(buf);
4201         }
4202         spin_unlock_irq(shost->host_lock);
4203         return index;
4204 }
4205
4206 static struct bin_attribute sysfs_drvr_stat_data_attr = {
4207         .attr = {
4208                 .name = "lpfc_drvr_stat_data",
4209                 .mode = S_IRUSR,
4210         },
4211         .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
4212         .read = sysfs_drvr_stat_data_read,
4213         .write = NULL,
4214 };
4215
4216 /*
4217 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
4218 # connection.
4219 # Value range is [0,16]. Default value is 0.
4220 */
4221 /**
4222  * lpfc_link_speed_set - Set the adapters link speed
4223  * @phba: lpfc_hba pointer.
4224  * @val: link speed value.
4225  *
4226  * Description:
4227  * If val is in a valid range then set the adapter's link speed field and
4228  * issue a lip; if the lip fails reset the link speed to the old value.
4229  *
4230  * Notes:
4231  * If the value is not in range log a kernel error message and return an error.
4232  *
4233  * Returns:
4234  * zero if val is in range and lip okay.
4235  * non-zero return value from lpfc_issue_lip()
4236  * -EINVAL val out of range
4237  **/
4238 static ssize_t
4239 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
4240                 const char *buf, size_t count)
4241 {
4242         struct Scsi_Host  *shost = class_to_shost(dev);
4243         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4244         struct lpfc_hba   *phba = vport->phba;
4245         int val = LPFC_USER_LINK_SPEED_AUTO;
4246         int nolip = 0;
4247         const char *val_buf = buf;
4248         int err;
4249         uint32_t prev_val, if_type;
4250
4251         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
4252         if (if_type == LPFC_SLI_INTF_IF_TYPE_2 &&
4253             phba->hba_flag & HBA_FORCED_LINK_SPEED)
4254                 return -EPERM;
4255
4256         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4257                 nolip = 1;
4258                 val_buf = &buf[strlen("nolip ")];
4259         }
4260
4261         if (!isdigit(val_buf[0]))
4262                 return -EINVAL;
4263         if (sscanf(val_buf, "%i", &val) != 1)
4264                 return -EINVAL;
4265
4266         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4267                 "3055 lpfc_link_speed changed from %d to %d %s\n",
4268                 phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
4269
4270         if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
4271             ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
4272             ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
4273             ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
4274             ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
4275             ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) ||
4276             ((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb)) ||
4277             ((val == LPFC_USER_LINK_SPEED_64G) && !(phba->lmt & LMT_64Gb))) {
4278                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4279                                 "2879 lpfc_link_speed attribute cannot be set "
4280                                 "to %d. Speed is not supported by this port.\n",
4281                                 val);
4282                 return -EINVAL;
4283         }
4284         if (val >= LPFC_USER_LINK_SPEED_16G &&
4285             phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4286                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4287                                 "3112 lpfc_link_speed attribute cannot be set "
4288                                 "to %d. Speed is not supported in loop mode.\n",
4289                                 val);
4290                 return -EINVAL;
4291         }
4292
4293         switch (val) {
4294         case LPFC_USER_LINK_SPEED_AUTO:
4295         case LPFC_USER_LINK_SPEED_1G:
4296         case LPFC_USER_LINK_SPEED_2G:
4297         case LPFC_USER_LINK_SPEED_4G:
4298         case LPFC_USER_LINK_SPEED_8G:
4299         case LPFC_USER_LINK_SPEED_16G:
4300         case LPFC_USER_LINK_SPEED_32G:
4301         case LPFC_USER_LINK_SPEED_64G:
4302                 prev_val = phba->cfg_link_speed;
4303                 phba->cfg_link_speed = val;
4304                 if (nolip)
4305                         return strlen(buf);
4306
4307                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4308                 if (err) {
4309                         phba->cfg_link_speed = prev_val;
4310                         return -EINVAL;
4311                 }
4312                 return strlen(buf);
4313         default:
4314                 break;
4315         }
4316
4317         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4318                         "0469 lpfc_link_speed attribute cannot be set to %d, "
4319                         "allowed values are [%s]\n",
4320                         val, LPFC_LINK_SPEED_STRING);
4321         return -EINVAL;
4322
4323 }
4324
4325 static int lpfc_link_speed = 0;
4326 module_param(lpfc_link_speed, int, S_IRUGO);
4327 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
4328 lpfc_param_show(link_speed)
4329
4330 /**
4331  * lpfc_link_speed_init - Set the adapters link speed
4332  * @phba: lpfc_hba pointer.
4333  * @val: link speed value.
4334  *
4335  * Description:
4336  * If val is in a valid range then set the adapter's link speed field.
4337  *
4338  * Notes:
4339  * If the value is not in range log a kernel error message, clear the link
4340  * speed and return an error.
4341  *
4342  * Returns:
4343  * zero if val saved.
4344  * -EINVAL val out of range
4345  **/
4346 static int
4347 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
4348 {
4349         if (val >= LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
4350                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4351                         "3111 lpfc_link_speed of %d cannot "
4352                         "support loop mode, setting topology to default.\n",
4353                          val);
4354                 phba->cfg_topology = 0;
4355         }
4356
4357         switch (val) {
4358         case LPFC_USER_LINK_SPEED_AUTO:
4359         case LPFC_USER_LINK_SPEED_1G:
4360         case LPFC_USER_LINK_SPEED_2G:
4361         case LPFC_USER_LINK_SPEED_4G:
4362         case LPFC_USER_LINK_SPEED_8G:
4363         case LPFC_USER_LINK_SPEED_16G:
4364         case LPFC_USER_LINK_SPEED_32G:
4365         case LPFC_USER_LINK_SPEED_64G:
4366                 phba->cfg_link_speed = val;
4367                 return 0;
4368         default:
4369                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4370                                 "0405 lpfc_link_speed attribute cannot "
4371                                 "be set to %d, allowed values are "
4372                                 "["LPFC_LINK_SPEED_STRING"]\n", val);
4373                 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
4374                 return -EINVAL;
4375         }
4376 }
4377
4378 static DEVICE_ATTR_RW(lpfc_link_speed);
4379
4380 /*
4381 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
4382 #       0  = aer disabled or not supported
4383 #       1  = aer supported and enabled (default)
4384 # Value range is [0,1]. Default value is 1.
4385 */
4386 LPFC_ATTR(aer_support, 1, 0, 1,
4387         "Enable PCIe device AER support");
4388 lpfc_param_show(aer_support)
4389
4390 /**
4391  * lpfc_aer_support_store - Set the adapter for aer support
4392  *
4393  * @dev: class device that is converted into a Scsi_host.
4394  * @attr: device attribute, not used.
4395  * @buf: containing enable or disable aer flag.
4396  * @count: unused variable.
4397  *
4398  * Description:
4399  * If the val is 1 and currently the device's AER capability was not
4400  * enabled, invoke the kernel's enable AER helper routine, trying to
4401  * enable the device's AER capability. If the helper routine enabling
4402  * AER returns success, update the device's cfg_aer_support flag to
4403  * indicate AER is supported by the device; otherwise, if the device
4404  * AER capability is already enabled to support AER, then do nothing.
4405  *
4406  * If the val is 0 and currently the device's AER support was enabled,
4407  * invoke the kernel's disable AER helper routine. After that, update
4408  * the device's cfg_aer_support flag to indicate AER is not supported
4409  * by the device; otherwise, if the device AER capability is already
4410  * disabled from supporting AER, then do nothing.
4411  *
4412  * Returns:
4413  * length of the buf on success if val is in range the intended mode
4414  * is supported.
4415  * -EINVAL if val out of range or intended mode is not supported.
4416  **/
4417 static ssize_t
4418 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
4419                        const char *buf, size_t count)
4420 {
4421         struct Scsi_Host *shost = class_to_shost(dev);
4422         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4423         struct lpfc_hba *phba = vport->phba;
4424         int val = 0, rc = -EINVAL;
4425
4426         if (!isdigit(buf[0]))
4427                 return -EINVAL;
4428         if (sscanf(buf, "%i", &val) != 1)
4429                 return -EINVAL;
4430
4431         switch (val) {
4432         case 0:
4433                 if (phba->hba_flag & HBA_AER_ENABLED) {
4434                         rc = pci_disable_pcie_error_reporting(phba->pcidev);
4435                         if (!rc) {
4436                                 spin_lock_irq(&phba->hbalock);
4437                                 phba->hba_flag &= ~HBA_AER_ENABLED;
4438                                 spin_unlock_irq(&phba->hbalock);
4439                                 phba->cfg_aer_support = 0;
4440                                 rc = strlen(buf);
4441                         } else
4442                                 rc = -EPERM;
4443                 } else {
4444                         phba->cfg_aer_support = 0;
4445                         rc = strlen(buf);
4446                 }
4447                 break;
4448         case 1:
4449                 if (!(phba->hba_flag & HBA_AER_ENABLED)) {
4450                         rc = pci_enable_pcie_error_reporting(phba->pcidev);
4451                         if (!rc) {
4452                                 spin_lock_irq(&phba->hbalock);
4453                                 phba->hba_flag |= HBA_AER_ENABLED;
4454                                 spin_unlock_irq(&phba->hbalock);
4455                                 phba->cfg_aer_support = 1;
4456                                 rc = strlen(buf);
4457                         } else
4458                                  rc = -EPERM;
4459                 } else {
4460                         phba->cfg_aer_support = 1;
4461                         rc = strlen(buf);
4462                 }
4463                 break;
4464         default:
4465                 rc = -EINVAL;
4466                 break;
4467         }
4468         return rc;
4469 }
4470
4471 static DEVICE_ATTR_RW(lpfc_aer_support);
4472
4473 /**
4474  * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
4475  * @dev: class device that is converted into a Scsi_host.
4476  * @attr: device attribute, not used.
4477  * @buf: containing flag 1 for aer cleanup state.
4478  * @count: unused variable.
4479  *
4480  * Description:
4481  * If the @buf contains 1 and the device currently has the AER support
4482  * enabled, then invokes the kernel AER helper routine
4483  * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
4484  * error status register.
4485  *
4486  * Notes:
4487  *
4488  * Returns:
4489  * -EINVAL if the buf does not contain the 1 or the device is not currently
4490  * enabled with the AER support.
4491  **/
4492 static ssize_t
4493 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
4494                        const char *buf, size_t count)
4495 {
4496         struct Scsi_Host  *shost = class_to_shost(dev);
4497         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4498         struct lpfc_hba   *phba = vport->phba;
4499         int val, rc = -1;
4500
4501         if (!isdigit(buf[0]))
4502                 return -EINVAL;
4503         if (sscanf(buf, "%i", &val) != 1)
4504                 return -EINVAL;
4505         if (val != 1)
4506                 return -EINVAL;
4507
4508         if (phba->hba_flag & HBA_AER_ENABLED)
4509                 rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);
4510
4511         if (rc == 0)
4512                 return strlen(buf);
4513         else
4514                 return -EPERM;
4515 }
4516
4517 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
4518                    lpfc_aer_cleanup_state);
4519
4520 /**
4521  * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
4522  *
4523  * @dev: class device that is converted into a Scsi_host.
4524  * @attr: device attribute, not used.
4525  * @buf: containing the string the number of vfs to be enabled.
4526  * @count: unused variable.
4527  *
4528  * Description:
4529  * When this api is called either through user sysfs, the driver shall
4530  * try to enable or disable SR-IOV virtual functions according to the
4531  * following:
4532  *
4533  * If zero virtual function has been enabled to the physical function,
4534  * the driver shall invoke the pci enable virtual function api trying
4535  * to enable the virtual functions. If the nr_vfn provided is greater
4536  * than the maximum supported, the maximum virtual function number will
4537  * be used for invoking the api; otherwise, the nr_vfn provided shall
4538  * be used for invoking the api. If the api call returned success, the
4539  * actual number of virtual functions enabled will be set to the driver
4540  * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
4541  * cfg_sriov_nr_virtfn remains zero.
4542  *
4543  * If none-zero virtual functions have already been enabled to the
4544  * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
4545  * -EINVAL will be returned and the driver does nothing;
4546  *
4547  * If the nr_vfn provided is zero and none-zero virtual functions have
4548  * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
4549  * disabling virtual function api shall be invoded to disable all the
4550  * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
4551  * zero. Otherwise, if zero virtual function has been enabled, do
4552  * nothing.
4553  *
4554  * Returns:
4555  * length of the buf on success if val is in range the intended mode
4556  * is supported.
4557  * -EINVAL if val out of range or intended mode is not supported.
4558  **/
4559 static ssize_t
4560 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
4561                          const char *buf, size_t count)
4562 {
4563         struct Scsi_Host *shost = class_to_shost(dev);
4564         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4565         struct lpfc_hba *phba = vport->phba;
4566         struct pci_dev *pdev = phba->pcidev;
4567         int val = 0, rc = -EINVAL;
4568
4569         /* Sanity check on user data */
4570         if (!isdigit(buf[0]))
4571                 return -EINVAL;
4572         if (sscanf(buf, "%i", &val) != 1)
4573                 return -EINVAL;
4574         if (val < 0)
4575                 return -EINVAL;
4576
4577         /* Request disabling virtual functions */
4578         if (val == 0) {
4579                 if (phba->cfg_sriov_nr_virtfn > 0) {
4580                         pci_disable_sriov(pdev);
4581                         phba->cfg_sriov_nr_virtfn = 0;
4582                 }
4583                 return strlen(buf);
4584         }
4585
4586         /* Request enabling virtual functions */
4587         if (phba->cfg_sriov_nr_virtfn > 0) {
4588                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4589                                 "3018 There are %d virtual functions "
4590                                 "enabled on physical function.\n",
4591                                 phba->cfg_sriov_nr_virtfn);
4592                 return -EEXIST;
4593         }
4594
4595         if (val <= LPFC_MAX_VFN_PER_PFN)
4596                 phba->cfg_sriov_nr_virtfn = val;
4597         else {
4598                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4599                                 "3019 Enabling %d virtual functions is not "
4600                                 "allowed.\n", val);
4601                 return -EINVAL;
4602         }
4603
4604         rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
4605         if (rc) {
4606                 phba->cfg_sriov_nr_virtfn = 0;
4607                 rc = -EPERM;
4608         } else
4609                 rc = strlen(buf);
4610
4611         return rc;
4612 }
4613
4614 LPFC_ATTR(sriov_nr_virtfn, LPFC_DEF_VFN_PER_PFN, 0, LPFC_MAX_VFN_PER_PFN,
4615         "Enable PCIe device SR-IOV virtual fn");
4616
4617 lpfc_param_show(sriov_nr_virtfn)
4618 static DEVICE_ATTR_RW(lpfc_sriov_nr_virtfn);
4619
4620 /**
4621  * lpfc_request_firmware_store - Request for Linux generic firmware upgrade
4622  *
4623  * @dev: class device that is converted into a Scsi_host.
4624  * @attr: device attribute, not used.
4625  * @buf: containing the string the number of vfs to be enabled.
4626  * @count: unused variable.
4627  *
4628  * Description:
4629  *
4630  * Returns:
4631  * length of the buf on success if val is in range the intended mode
4632  * is supported.
4633  * -EINVAL if val out of range or intended mode is not supported.
4634  **/
4635 static ssize_t
4636 lpfc_request_firmware_upgrade_store(struct device *dev,
4637                                     struct device_attribute *attr,
4638                                     const char *buf, size_t count)
4639 {
4640         struct Scsi_Host *shost = class_to_shost(dev);
4641         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4642         struct lpfc_hba *phba = vport->phba;
4643         int val = 0, rc = -EINVAL;
4644
4645         /* Sanity check on user data */
4646         if (!isdigit(buf[0]))
4647                 return -EINVAL;
4648         if (sscanf(buf, "%i", &val) != 1)
4649                 return -EINVAL;
4650         if (val != 1)
4651                 return -EINVAL;
4652
4653         rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
4654         if (rc)
4655                 rc = -EPERM;
4656         else
4657                 rc = strlen(buf);
4658         return rc;
4659 }
4660
4661 static int lpfc_req_fw_upgrade;
4662 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
4663 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
4664 lpfc_param_show(request_firmware_upgrade)
4665
4666 /**
4667  * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
4668  * @phba: lpfc_hba pointer.
4669  * @val: 0 or 1.
4670  *
4671  * Description:
4672  * Set the initial Linux generic firmware upgrade enable or disable flag.
4673  *
4674  * Returns:
4675  * zero if val saved.
4676  * -EINVAL val out of range
4677  **/
4678 static int
4679 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
4680 {
4681         if (val >= 0 && val <= 1) {
4682                 phba->cfg_request_firmware_upgrade = val;
4683                 return 0;
4684         }
4685         return -EINVAL;
4686 }
4687 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
4688                    lpfc_request_firmware_upgrade_show,
4689                    lpfc_request_firmware_upgrade_store);
4690
4691 /**
4692  * lpfc_fcp_imax_store
4693  *
4694  * @dev: class device that is converted into a Scsi_host.
4695  * @attr: device attribute, not used.
4696  * @buf: string with the number of fast-path FCP interrupts per second.
4697  * @count: unused variable.
4698  *
4699  * Description:
4700  * If val is in a valid range [636,651042], then set the adapter's
4701  * maximum number of fast-path FCP interrupts per second.
4702  *
4703  * Returns:
4704  * length of the buf on success if val is in range the intended mode
4705  * is supported.
4706  * -EINVAL if val out of range or intended mode is not supported.
4707  **/
4708 static ssize_t
4709 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
4710                          const char *buf, size_t count)
4711 {
4712         struct Scsi_Host *shost = class_to_shost(dev);
4713         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4714         struct lpfc_hba *phba = vport->phba;
4715         int val = 0, i;
4716
4717         /* fcp_imax is only valid for SLI4 */
4718         if (phba->sli_rev != LPFC_SLI_REV4)
4719                 return -EINVAL;
4720
4721         /* Sanity check on user data */
4722         if (!isdigit(buf[0]))
4723                 return -EINVAL;
4724         if (sscanf(buf, "%i", &val) != 1)
4725                 return -EINVAL;
4726
4727         /*
4728          * Value range for the HBA is [5000,5000000]
4729          * The value for each EQ depends on how many EQs are configured.
4730          * Allow value == 0
4731          */
4732         if (val && (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX))
4733                 return -EINVAL;
4734
4735         phba->cfg_fcp_imax = (uint32_t)val;
4736         phba->initial_imax = phba->cfg_fcp_imax;
4737
4738         for (i = 0; i < phba->io_channel_irqs; i += LPFC_MAX_EQ_DELAY_EQID_CNT)
4739                 lpfc_modify_hba_eq_delay(phba, i, LPFC_MAX_EQ_DELAY_EQID_CNT,
4740                                          val);
4741
4742         return strlen(buf);
4743 }
4744
4745 /*
4746 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
4747 # for the HBA.
4748 #
4749 # Value range is [5,000 to 5,000,000]. Default value is 50,000.
4750 */
4751 static int lpfc_fcp_imax = LPFC_DEF_IMAX;
4752 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
4753 MODULE_PARM_DESC(lpfc_fcp_imax,
4754             "Set the maximum number of FCP interrupts per second per HBA");
4755 lpfc_param_show(fcp_imax)
4756
4757 /**
4758  * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
4759  * @phba: lpfc_hba pointer.
4760  * @val: link speed value.
4761  *
4762  * Description:
4763  * If val is in a valid range [636,651042], then initialize the adapter's
4764  * maximum number of fast-path FCP interrupts per second.
4765  *
4766  * Returns:
4767  * zero if val saved.
4768  * -EINVAL val out of range
4769  **/
4770 static int
4771 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
4772 {
4773         if (phba->sli_rev != LPFC_SLI_REV4) {
4774                 phba->cfg_fcp_imax = 0;
4775                 return 0;
4776         }
4777
4778         if ((val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) ||
4779             (val == 0)) {
4780                 phba->cfg_fcp_imax = val;
4781                 return 0;
4782         }
4783
4784         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4785                         "3016 lpfc_fcp_imax: %d out of range, using default\n",
4786                         val);
4787         phba->cfg_fcp_imax = LPFC_DEF_IMAX;
4788
4789         return 0;
4790 }
4791
4792 static DEVICE_ATTR_RW(lpfc_fcp_imax);
4793
4794 /*
4795  * lpfc_auto_imax: Controls Auto-interrupt coalescing values support.
4796  *       0       No auto_imax support
4797  *       1       auto imax on
4798  * Auto imax will change the value of fcp_imax on a per EQ basis, using
4799  * the EQ Delay Multiplier, depending on the activity for that EQ.
4800  * Value range [0,1]. Default value is 1.
4801  */
4802 LPFC_ATTR_RW(auto_imax, 1, 0, 1, "Enable Auto imax");
4803
4804 /**
4805  * lpfc_state_show - Display current driver CPU affinity
4806  * @dev: class converted to a Scsi_host structure.
4807  * @attr: device attribute, not used.
4808  * @buf: on return contains text describing the state of the link.
4809  *
4810  * Returns: size of formatted string.
4811  **/
4812 static ssize_t
4813 lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
4814                       char *buf)
4815 {
4816         struct Scsi_Host  *shost = class_to_shost(dev);
4817         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4818         struct lpfc_hba   *phba = vport->phba;
4819         struct lpfc_vector_map_info *cpup;
4820         int  len = 0;
4821
4822         if ((phba->sli_rev != LPFC_SLI_REV4) ||
4823             (phba->intr_type != MSIX))
4824                 return len;
4825
4826         switch (phba->cfg_fcp_cpu_map) {
4827         case 0:
4828                 len += snprintf(buf + len, PAGE_SIZE-len,
4829                                 "fcp_cpu_map: No mapping (%d)\n",
4830                                 phba->cfg_fcp_cpu_map);
4831                 return len;
4832         case 1:
4833                 len += snprintf(buf + len, PAGE_SIZE-len,
4834                                 "fcp_cpu_map: HBA centric mapping (%d): "
4835                                 "%d online CPUs\n",
4836                                 phba->cfg_fcp_cpu_map,
4837                                 phba->sli4_hba.num_online_cpu);
4838                 break;
4839         case 2:
4840                 len += snprintf(buf + len, PAGE_SIZE-len,
4841                                 "fcp_cpu_map: Driver centric mapping (%d): "
4842                                 "%d online CPUs\n",
4843                                 phba->cfg_fcp_cpu_map,
4844                                 phba->sli4_hba.num_online_cpu);
4845                 break;
4846         }
4847
4848         while (phba->sli4_hba.curr_disp_cpu < phba->sli4_hba.num_present_cpu) {
4849                 cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu];
4850
4851                 /* margin should fit in this and the truncated message */
4852                 if (cpup->irq == LPFC_VECTOR_MAP_EMPTY)
4853                         len += snprintf(buf + len, PAGE_SIZE-len,
4854                                         "CPU %02d io_chan %02d "
4855                                         "physid %d coreid %d\n",
4856                                         phba->sli4_hba.curr_disp_cpu,
4857                                         cpup->channel_id, cpup->phys_id,
4858                                         cpup->core_id);
4859                 else
4860                         len += snprintf(buf + len, PAGE_SIZE-len,
4861                                         "CPU %02d io_chan %02d "
4862                                         "physid %d coreid %d IRQ %d\n",
4863                                         phba->sli4_hba.curr_disp_cpu,
4864                                         cpup->channel_id, cpup->phys_id,
4865                                         cpup->core_id, cpup->irq);
4866
4867                 phba->sli4_hba.curr_disp_cpu++;
4868
4869                 /* display max number of CPUs keeping some margin */
4870                 if (phba->sli4_hba.curr_disp_cpu <
4871                                 phba->sli4_hba.num_present_cpu &&
4872                                 (len >= (PAGE_SIZE - 64))) {
4873                         len += snprintf(buf + len, PAGE_SIZE-len, "more...\n");
4874                         break;
4875                 }
4876         }
4877
4878         if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_present_cpu)
4879                 phba->sli4_hba.curr_disp_cpu = 0;
4880
4881         return len;
4882 }
4883
4884 /**
4885  * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
4886  * @dev: class device that is converted into a Scsi_host.
4887  * @attr: device attribute, not used.
4888  * @buf: one or more lpfc_polling_flags values.
4889  * @count: not used.
4890  *
4891  * Returns:
4892  * -EINVAL  - Not implemented yet.
4893  **/
4894 static ssize_t
4895 lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
4896                        const char *buf, size_t count)
4897 {
4898         int status = -EINVAL;
4899         return status;
4900 }
4901
4902 /*
4903 # lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
4904 # for the HBA.
4905 #
4906 # Value range is [0 to 2]. Default value is LPFC_DRIVER_CPU_MAP (2).
4907 #       0 - Do not affinitze IRQ vectors
4908 #       1 - Affintize HBA vectors with respect to each HBA
4909 #           (start with CPU0 for each HBA)
4910 #       2 - Affintize HBA vectors with respect to the entire driver
4911 #           (round robin thru all CPUs across all HBAs)
4912 */
4913 static int lpfc_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;
4914 module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
4915 MODULE_PARM_DESC(lpfc_fcp_cpu_map,
4916                  "Defines how to map CPUs to IRQ vectors per HBA");
4917
4918 /**
4919  * lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable
4920  * @phba: lpfc_hba pointer.
4921  * @val: link speed value.
4922  *
4923  * Description:
4924  * If val is in a valid range [0-2], then affinitze the adapter's
4925  * MSIX vectors.
4926  *
4927  * Returns:
4928  * zero if val saved.
4929  * -EINVAL val out of range
4930  **/
4931 static int
4932 lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
4933 {
4934         if (phba->sli_rev != LPFC_SLI_REV4) {
4935                 phba->cfg_fcp_cpu_map = 0;
4936                 return 0;
4937         }
4938
4939         if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
4940                 phba->cfg_fcp_cpu_map = val;
4941                 return 0;
4942         }
4943
4944         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4945                         "3326 lpfc_fcp_cpu_map: %d out of range, using "
4946                         "default\n", val);
4947         phba->cfg_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;
4948
4949         return 0;
4950 }
4951
4952 static DEVICE_ATTR_RW(lpfc_fcp_cpu_map);
4953
4954 /*
4955 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
4956 # Value range is [2,3]. Default value is 3.
4957 */
4958 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
4959                   "Select Fibre Channel class of service for FCP sequences");
4960
4961 /*
4962 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
4963 # is [0,1]. Default value is 0.
4964 */
4965 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
4966                    "Use ADISC on rediscovery to authenticate FCP devices");
4967
4968 /*
4969 # lpfc_first_burst_size: First burst size to use on the NPorts
4970 # that support first burst.
4971 # Value range is [0,65536]. Default value is 0.
4972 */
4973 LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536,
4974                    "First burst size for Targets that support first burst");
4975
4976 /*
4977 * lpfc_nvmet_fb_size: NVME Target mode supported first burst size.
4978 * When the driver is configured as an NVME target, this value is
4979 * communicated to the NVME initiator in the PRLI response.  It is
4980 * used only when the lpfc_nvme_enable_fb and lpfc_nvmet_support
4981 * parameters are set and the target is sending the PRLI RSP.
4982 * Parameter supported on physical port only - no NPIV support.
4983 * Value range is [0,65536]. Default value is 0.
4984 */
4985 LPFC_ATTR_RW(nvmet_fb_size, 0, 0, 65536,
4986              "NVME Target mode first burst size in 512B increments.");
4987
4988 /*
4989  * lpfc_nvme_enable_fb: Enable NVME first burst on I and T functions.
4990  * For the Initiator (I), enabling this parameter means that an NVMET
4991  * PRLI response with FBA enabled and an FB_SIZE set to a nonzero value will be
4992  * processed by the initiator for subsequent NVME FCP IO. For the target
4993  * function (T), enabling this parameter qualifies the lpfc_nvmet_fb_size
4994  * driver parameter as the target function's first burst size returned to the
4995  * initiator in the target's NVME PRLI response. Parameter supported on physical
4996  * port only - no NPIV support.
4997  * Value range is [0,1]. Default value is 0 (disabled).
4998  */
4999 LPFC_ATTR_RW(nvme_enable_fb, 0, 0, 1,
5000              "Enable First Burst feature on I and T functions.");
5001
5002 /*
5003 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
5004 # depth. Default value is 0. When the value of this parameter is zero the
5005 # SCSI command completion time is not used for controlling I/O queue depth. When
5006 # the parameter is set to a non-zero value, the I/O queue depth is controlled
5007 # to limit the I/O completion time to the parameter value.
5008 # The value is set in milliseconds.
5009 */
5010 LPFC_VPORT_ATTR(max_scsicmpl_time, 0, 0, 60000,
5011         "Use command completion time to control queue depth");
5012
5013 lpfc_vport_param_show(max_scsicmpl_time);
5014 static int
5015 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
5016 {
5017         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5018         struct lpfc_nodelist *ndlp, *next_ndlp;
5019
5020         if (val == vport->cfg_max_scsicmpl_time)
5021                 return 0;
5022         if ((val < 0) || (val > 60000))
5023                 return -EINVAL;
5024         vport->cfg_max_scsicmpl_time = val;
5025
5026         spin_lock_irq(shost->host_lock);
5027         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
5028                 if (!NLP_CHK_NODE_ACT(ndlp))
5029                         continue;
5030                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
5031                         continue;
5032                 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
5033         }
5034         spin_unlock_irq(shost->host_lock);
5035         return 0;
5036 }
5037 lpfc_vport_param_store(max_scsicmpl_time);
5038 static DEVICE_ATTR_RW(lpfc_max_scsicmpl_time);
5039
5040 /*
5041 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
5042 # range is [0,1]. Default value is 0.
5043 */
5044 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
5045
5046 /*
5047  * lpfc_io_sched: Determine scheduling algrithmn for issuing FCP cmds
5048  * range is [0,1]. Default value is 0.
5049  * For [0], FCP commands are issued to Work Queues ina round robin fashion.
5050  * For [1], FCP commands are issued to a Work Queue associated with the
5051  *          current CPU.
5052  *
5053  * LPFC_FCP_SCHED_ROUND_ROBIN == 0
5054  * LPFC_FCP_SCHED_BY_CPU == 1
5055  *
5056  * The driver dynamically sets this to 1 (BY_CPU) if it's able to set up cpu
5057  * affinity for FCP/NVME I/Os through Work Queues associated with the current
5058  * CPU. Otherwise, the default 0 (Round Robin) scheduling of FCP/NVME I/Os
5059  * through WQs will be used.
5060  */
5061 LPFC_ATTR_RW(fcp_io_sched, LPFC_FCP_SCHED_ROUND_ROBIN,
5062              LPFC_FCP_SCHED_ROUND_ROBIN,
5063              LPFC_FCP_SCHED_BY_CPU,
5064              "Determine scheduling algorithm for "
5065              "issuing commands [0] - Round Robin, [1] - Current CPU");
5066
5067 /*
5068 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
5069 # range is [0,1]. Default value is 0.
5070 # For [0], bus reset issues target reset to ALL devices
5071 # For [1], bus reset issues target reset to non-FCP2 devices
5072 */
5073 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
5074              "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");
5075
5076
5077 /*
5078 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
5079 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
5080 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
5081 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
5082 # cr_delay is set to 0.
5083 */
5084 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
5085                 "interrupt response is generated");
5086
5087 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
5088                 "interrupt response is generated");
5089
5090 /*
5091 # lpfc_multi_ring_support:  Determines how many rings to spread available
5092 # cmd/rsp IOCB entries across.
5093 # Value range is [1,2]. Default value is 1.
5094 */
5095 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
5096                 "SLI rings to spread IOCB entries across");
5097
5098 /*
5099 # lpfc_multi_ring_rctl:  If lpfc_multi_ring_support is enabled, this
5100 # identifies what rctl value to configure the additional ring for.
5101 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
5102 */
5103 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
5104              255, "Identifies RCTL for additional ring configuration");
5105
5106 /*
5107 # lpfc_multi_ring_type:  If lpfc_multi_ring_support is enabled, this
5108 # identifies what type value to configure the additional ring for.
5109 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
5110 */
5111 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
5112              255, "Identifies TYPE for additional ring configuration");
5113
5114 /*
5115 # lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN
5116 #       0  = SmartSAN functionality disabled (default)
5117 #       1  = SmartSAN functionality enabled
5118 # This parameter will override the value of lpfc_fdmi_on module parameter.
5119 # Value range is [0,1]. Default value is 0.
5120 */
5121 LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality");
5122
5123 /*
5124 # lpfc_fdmi_on: Controls FDMI support.
5125 #       0       No FDMI support
5126 #       1       Traditional FDMI support (default)
5127 # Traditional FDMI support means the driver will assume FDMI-2 support;
5128 # however, if that fails, it will fallback to FDMI-1.
5129 # If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on.
5130 # If lpfc_enable_SmartSAN is set 0, the driver uses the current value of
5131 # lpfc_fdmi_on.
5132 # Value range [0,1]. Default value is 1.
5133 */
5134 LPFC_ATTR_R(fdmi_on, 1, 0, 1, "Enable FDMI support");
5135
5136 /*
5137 # Specifies the maximum number of ELS cmds we can have outstanding (for
5138 # discovery). Value range is [1,64]. Default value = 32.
5139 */
5140 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
5141                  "during discovery");
5142
5143 /*
5144 # lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that
5145 #    will be scanned by the SCSI midlayer when sequential scanning is
5146 #    used; and is also the highest LUN ID allowed when the SCSI midlayer
5147 #    parses REPORT_LUN responses. The lpfc driver has no LUN count or
5148 #    LUN ID limit, but the SCSI midlayer requires this field for the uses
5149 #    above. The lpfc driver limits the default value to 255 for two reasons.
5150 #    As it bounds the sequential scan loop, scanning for thousands of luns
5151 #    on a target can take minutes of wall clock time.  Additionally,
5152 #    there are FC targets, such as JBODs, that only recognize 8-bits of
5153 #    LUN ID. When they receive a value greater than 8 bits, they chop off
5154 #    the high order bits. In other words, they see LUN IDs 0, 256, 512,
5155 #    and so on all as LUN ID 0. This causes the linux kernel, which sees
5156 #    valid responses at each of the LUN IDs, to believe there are multiple
5157 #    devices present, when in fact, there is only 1.
5158 #    A customer that is aware of their target behaviors, and the results as
5159 #    indicated above, is welcome to increase the lpfc_max_luns value.
5160 #    As mentioned, this value is not used by the lpfc driver, only the
5161 #    SCSI midlayer.
5162 # Value range is [0,65535]. Default value is 255.
5163 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
5164 */
5165 LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID");
5166
5167 /*
5168 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
5169 # Value range is [1,255], default value is 10.
5170 */
5171 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
5172              "Milliseconds driver will wait between polling FCP ring");
5173
5174 /*
5175 # lpfc_task_mgmt_tmo: Maximum time to wait for task management commands
5176 # to complete in seconds. Value range is [5,180], default value is 60.
5177 */
5178 LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180,
5179              "Maximum time to wait for task management commands to complete");
5180 /*
5181 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
5182 #               support this feature
5183 #       0  = MSI disabled
5184 #       1  = MSI enabled
5185 #       2  = MSI-X enabled (default)
5186 # Value range is [0,2]. Default value is 2.
5187 */
5188 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
5189             "MSI-X (2), if possible");
5190
5191 /*
5192  * lpfc_nvme_oas: Use the oas bit when sending NVME/NVMET IOs
5193  *
5194  *      0  = NVME OAS disabled
5195  *      1  = NVME OAS enabled
5196  *
5197  * Value range is [0,1]. Default value is 0.
5198  */
5199 LPFC_ATTR_RW(nvme_oas, 0, 0, 1,
5200              "Use OAS bit on NVME IOs");
5201
5202 /*
5203  * lpfc_nvme_embed_cmd: Use the oas bit when sending NVME/NVMET IOs
5204  *
5205  *      0  = Put NVME Command in SGL
5206  *      1  = Embed NVME Command in WQE (unless G7)
5207  *      2 =  Embed NVME Command in WQE (force)
5208  *
5209  * Value range is [0,2]. Default value is 1.
5210  */
5211 LPFC_ATTR_RW(nvme_embed_cmd, 1, 0, 2,
5212              "Embed NVME Command in WQE");
5213
5214 /*
5215  * lpfc_fcp_io_channel: Set the number of FCP IO channels the driver
5216  * will advertise it supports to the SCSI layer. This also will map to
5217  * the number of WQs the driver will create.
5218  *
5219  *      0    = Configure the number of io channels to the number of active CPUs.
5220  *      1,32 = Manually specify how many io channels to use.
5221  *
5222  * Value range is [0,32]. Default value is 4.
5223  */
5224 LPFC_ATTR_R(fcp_io_channel,
5225             LPFC_FCP_IO_CHAN_DEF,
5226             LPFC_HBA_IO_CHAN_MIN, LPFC_HBA_IO_CHAN_MAX,
5227             "Set the number of FCP I/O channels");
5228
5229 /*
5230  * lpfc_nvme_io_channel: Set the number of IO hardware queues the driver
5231  * will advertise it supports to the NVME layer. This also will map to
5232  * the number of WQs the driver will create.
5233  *
5234  * This module parameter is valid when lpfc_enable_fc4_type is set
5235  * to support NVME.
5236  *
5237  * The NVME Layer will try to create this many, plus 1 administrative
5238  * hardware queue. The administrative queue will always map to WQ 0
5239  * A hardware IO queue maps (qidx) to a specific driver WQ.
5240  *
5241  *      0    = Configure the number of io channels to the number of active CPUs.
5242  *      1,32 = Manually specify how many io channels to use.
5243  *
5244  * Value range is [0,32]. Default value is 0.
5245  */
5246 LPFC_ATTR_R(nvme_io_channel,
5247             LPFC_NVME_IO_CHAN_DEF,
5248             LPFC_HBA_IO_CHAN_MIN, LPFC_HBA_IO_CHAN_MAX,
5249             "Set the number of NVME I/O channels");
5250
5251 /*
5252 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
5253 #       0  = HBA resets disabled
5254 #       1  = HBA resets enabled (default)
5255 # Value range is [0,1]. Default value is 1.
5256 */
5257 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
5258
5259 /*
5260 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
5261 #       0  = HBA Heartbeat disabled
5262 #       1  = HBA Heartbeat enabled (default)
5263 # Value range is [0,1]. Default value is 1.
5264 */
5265 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
5266
5267 /*
5268 # lpfc_EnableXLane: Enable Express Lane Feature
5269 #      0x0   Express Lane Feature disabled
5270 #      0x1   Express Lane Feature enabled
5271 # Value range is [0,1]. Default value is 0.
5272 */
5273 LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature.");
5274
5275 /*
5276 # lpfc_XLanePriority:  Define CS_CTL priority for Express Lane Feature
5277 #       0x0 - 0x7f  = CS_CTL field in FC header (high 7 bits)
5278 # Value range is [0x0,0x7f]. Default value is 0
5279 */
5280 LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature.");
5281
5282 /*
5283 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
5284 #       0  = BlockGuard disabled (default)
5285 #       1  = BlockGuard enabled
5286 # Value range is [0,1]. Default value is 0.
5287 */
5288 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
5289
5290 /*
5291 # lpfc_fcp_look_ahead: Look ahead for completions in FCP start routine
5292 #       0  = disabled (default)
5293 #       1  = enabled
5294 # Value range is [0,1]. Default value is 0.
5295 #
5296 # This feature in under investigation and may be supported in the future.
5297 */
5298 unsigned int lpfc_fcp_look_ahead = LPFC_LOOK_AHEAD_OFF;
5299
5300 /*
5301 # lpfc_prot_mask: i
5302 #       - Bit mask of host protection capabilities used to register with the
5303 #         SCSI mid-layer
5304 #       - Only meaningful if BG is turned on (lpfc_enable_bg=1).
5305 #       - Allows you to ultimately specify which profiles to use
5306 #       - Default will result in registering capabilities for all profiles.
5307 #       - SHOST_DIF_TYPE1_PROTECTION    1
5308 #               HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
5309 #       - SHOST_DIX_TYPE0_PROTECTION    8
5310 #               HBA supports DIX Type 0: Host to HBA protection only
5311 #       - SHOST_DIX_TYPE1_PROTECTION    16
5312 #               HBA supports DIX Type 1: Host to HBA  Type 1 protection
5313 #
5314 */
5315 LPFC_ATTR(prot_mask,
5316         (SHOST_DIF_TYPE1_PROTECTION |
5317         SHOST_DIX_TYPE0_PROTECTION |
5318         SHOST_DIX_TYPE1_PROTECTION),
5319         0,
5320         (SHOST_DIF_TYPE1_PROTECTION |
5321         SHOST_DIX_TYPE0_PROTECTION |
5322         SHOST_DIX_TYPE1_PROTECTION),
5323         "T10-DIF host protection capabilities mask");
5324
5325 /*
5326 # lpfc_prot_guard: i
5327 #       - Bit mask of protection guard types to register with the SCSI mid-layer
5328 #       - Guard types are currently either 1) T10-DIF CRC 2) IP checksum
5329 #       - Allows you to ultimately specify which profiles to use
5330 #       - Default will result in registering capabilities for all guard types
5331 #
5332 */
5333 LPFC_ATTR(prot_guard,
5334         SHOST_DIX_GUARD_IP, SHOST_DIX_GUARD_CRC, SHOST_DIX_GUARD_IP,
5335         "T10-DIF host protection guard type");
5336
5337 /*
5338  * Delay initial NPort discovery when Clean Address bit is cleared in
5339  * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
5340  * This parameter can have value 0 or 1.
5341  * When this parameter is set to 0, no delay is added to the initial
5342  * discovery.
5343  * When this parameter is set to non-zero value, initial Nport discovery is
5344  * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
5345  * accept and FCID/Fabric name/Fabric portname is changed.
5346  * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
5347  * when Clean Address bit is cleared in FLOGI/FDISC
5348  * accept and FCID/Fabric name/Fabric portname is changed.
5349  * Default value is 0.
5350  */
5351 LPFC_ATTR(delay_discovery, 0, 0, 1,
5352         "Delay NPort discovery when Clean Address bit is cleared.");
5353
5354 /*
5355  * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
5356  * This value can be set to values between 64 and 4096. The default value is
5357  * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
5358  * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
5359  * Because of the additional overhead involved in setting up T10-DIF,
5360  * this parameter will be limited to 128 if BlockGuard is enabled under SLI4
5361  * and will be limited to 512 if BlockGuard is enabled under SLI3.
5362  */
5363 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_MIN_SG_SEG_CNT,
5364             LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
5365
5366 /*
5367  * lpfc_enable_mds_diags: Enable MDS Diagnostics
5368  *       0  = MDS Diagnostics disabled (default)
5369  *       1  = MDS Diagnostics enabled
5370  * Value range is [0,1]. Default value is 0.
5371  */
5372 LPFC_ATTR_R(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");
5373
5374 /*
5375  * lpfc_enable_bbcr: Enable BB Credit Recovery
5376  *       0  = BB Credit Recovery disabled
5377  *       1  = BB Credit Recovery enabled (default)
5378  * Value range is [0,1]. Default value is 1.
5379  */
5380 LPFC_BBCR_ATTR_RW(enable_bbcr, 1, 0, 1, "Enable BBC Recovery");
5381
5382 /*
5383  * lpfc_enable_dpp: Enable DPP on G7
5384  *       0  = DPP on G7 disabled
5385  *       1  = DPP on G7 enabled (default)
5386  * Value range is [0,1]. Default value is 1.
5387  */
5388 LPFC_ATTR_RW(enable_dpp, 1, 0, 1, "Enable Direct Packet Push");
5389
5390 struct device_attribute *lpfc_hba_attrs[] = {
5391         &dev_attr_nvme_info,
5392         &dev_attr_bg_info,
5393         &dev_attr_bg_guard_err,
5394         &dev_attr_bg_apptag_err,
5395         &dev_attr_bg_reftag_err,
5396         &dev_attr_info,
5397         &dev_attr_serialnum,
5398         &dev_attr_modeldesc,
5399         &dev_attr_modelname,
5400         &dev_attr_programtype,
5401         &dev_attr_portnum,
5402         &dev_attr_fwrev,
5403         &dev_attr_hdw,
5404         &dev_attr_option_rom_version,
5405         &dev_attr_link_state,
5406         &dev_attr_num_discovered_ports,
5407         &dev_attr_menlo_mgmt_mode,
5408         &dev_attr_lpfc_drvr_version,
5409         &dev_attr_lpfc_enable_fip,
5410         &dev_attr_lpfc_temp_sensor,
5411         &dev_attr_lpfc_log_verbose,
5412         &dev_attr_lpfc_lun_queue_depth,
5413         &dev_attr_lpfc_tgt_queue_depth,
5414         &dev_attr_lpfc_hba_queue_depth,
5415         &dev_attr_lpfc_peer_port_login,
5416         &dev_attr_lpfc_nodev_tmo,
5417         &dev_attr_lpfc_devloss_tmo,
5418         &dev_attr_lpfc_enable_fc4_type,
5419         &dev_attr_lpfc_xri_split,
5420         &dev_attr_lpfc_fcp_class,
5421         &dev_attr_lpfc_use_adisc,
5422         &dev_attr_lpfc_first_burst_size,
5423         &dev_attr_lpfc_ack0,
5424         &dev_attr_lpfc_topology,
5425         &dev_attr_lpfc_scan_down,
5426         &dev_attr_lpfc_link_speed,
5427         &dev_attr_lpfc_fcp_io_sched,
5428         &dev_attr_lpfc_fcp2_no_tgt_reset,
5429         &dev_attr_lpfc_cr_delay,
5430         &dev_attr_lpfc_cr_count,
5431         &dev_attr_lpfc_multi_ring_support,
5432         &dev_attr_lpfc_multi_ring_rctl,
5433         &dev_attr_lpfc_multi_ring_type,
5434         &dev_attr_lpfc_fdmi_on,
5435         &dev_attr_lpfc_enable_SmartSAN,
5436         &dev_attr_lpfc_max_luns,
5437         &dev_attr_lpfc_enable_npiv,
5438         &dev_attr_lpfc_fcf_failover_policy,
5439         &dev_attr_lpfc_enable_rrq,
5440         &dev_attr_nport_evt_cnt,
5441         &dev_attr_board_mode,
5442         &dev_attr_max_vpi,
5443         &dev_attr_used_vpi,
5444         &dev_attr_max_rpi,
5445         &dev_attr_used_rpi,
5446         &dev_attr_max_xri,
5447         &dev_attr_used_xri,
5448         &dev_attr_npiv_info,
5449         &dev_attr_issue_reset,
5450         &dev_attr_lpfc_poll,
5451         &dev_attr_lpfc_poll_tmo,
5452         &dev_attr_lpfc_task_mgmt_tmo,
5453         &dev_attr_lpfc_use_msi,
5454         &dev_attr_lpfc_nvme_oas,
5455         &dev_attr_lpfc_nvme_embed_cmd,
5456         &dev_attr_lpfc_auto_imax,
5457         &dev_attr_lpfc_fcp_imax,
5458         &dev_attr_lpfc_fcp_cpu_map,
5459         &dev_attr_lpfc_fcp_io_channel,
5460         &dev_attr_lpfc_suppress_rsp,
5461         &dev_attr_lpfc_nvme_io_channel,
5462         &dev_attr_lpfc_nvmet_mrq,
5463         &dev_attr_lpfc_nvmet_mrq_post,
5464         &dev_attr_lpfc_nvme_enable_fb,
5465         &dev_attr_lpfc_nvmet_fb_size,
5466         &dev_attr_lpfc_enable_bg,
5467         &dev_attr_lpfc_soft_wwnn,
5468         &dev_attr_lpfc_soft_wwpn,
5469         &dev_attr_lpfc_soft_wwn_enable,
5470         &dev_attr_lpfc_enable_hba_reset,
5471         &dev_attr_lpfc_enable_hba_heartbeat,
5472         &dev_attr_lpfc_EnableXLane,
5473         &dev_attr_lpfc_XLanePriority,
5474         &dev_attr_lpfc_xlane_lun,
5475         &dev_attr_lpfc_xlane_tgt,
5476         &dev_attr_lpfc_xlane_vpt,
5477         &dev_attr_lpfc_xlane_lun_state,
5478         &dev_attr_lpfc_xlane_lun_status,
5479         &dev_attr_lpfc_xlane_priority,
5480         &dev_attr_lpfc_sg_seg_cnt,
5481         &dev_attr_lpfc_max_scsicmpl_time,
5482         &dev_attr_lpfc_stat_data_ctrl,
5483         &dev_attr_lpfc_aer_support,
5484         &dev_attr_lpfc_aer_state_cleanup,
5485         &dev_attr_lpfc_sriov_nr_virtfn,
5486         &dev_attr_lpfc_req_fw_upgrade,
5487         &dev_attr_lpfc_suppress_link_up,
5488         &dev_attr_lpfc_iocb_cnt,
5489         &dev_attr_iocb_hw,
5490         &dev_attr_txq_hw,
5491         &dev_attr_txcmplq_hw,
5492         &dev_attr_lpfc_fips_level,
5493         &dev_attr_lpfc_fips_rev,
5494         &dev_attr_lpfc_dss,
5495         &dev_attr_lpfc_sriov_hw_max_virtfn,
5496         &dev_attr_protocol,
5497         &dev_attr_lpfc_xlane_supported,
5498         &dev_attr_lpfc_enable_mds_diags,
5499         &dev_attr_lpfc_enable_bbcr,
5500         &dev_attr_lpfc_enable_dpp,
5501         NULL,
5502 };
5503
5504 struct device_attribute *lpfc_vport_attrs[] = {
5505         &dev_attr_info,
5506         &dev_attr_link_state,
5507         &dev_attr_num_discovered_ports,
5508         &dev_attr_lpfc_drvr_version,
5509         &dev_attr_lpfc_log_verbose,
5510         &dev_attr_lpfc_lun_queue_depth,
5511         &dev_attr_lpfc_tgt_queue_depth,
5512         &dev_attr_lpfc_nodev_tmo,
5513         &dev_attr_lpfc_devloss_tmo,
5514         &dev_attr_lpfc_hba_queue_depth,
5515         &dev_attr_lpfc_peer_port_login,
5516         &dev_attr_lpfc_restrict_login,
5517         &dev_attr_lpfc_fcp_class,
5518         &dev_attr_lpfc_use_adisc,
5519         &dev_attr_lpfc_first_burst_size,
5520         &dev_attr_lpfc_max_luns,
5521         &dev_attr_nport_evt_cnt,
5522         &dev_attr_npiv_info,
5523         &dev_attr_lpfc_enable_da_id,
5524         &dev_attr_lpfc_max_scsicmpl_time,
5525         &dev_attr_lpfc_stat_data_ctrl,
5526         &dev_attr_lpfc_static_vport,
5527         &dev_attr_lpfc_fips_level,
5528         &dev_attr_lpfc_fips_rev,
5529         NULL,
5530 };
5531
5532 /**
5533  * sysfs_ctlreg_write - Write method for writing to ctlreg
5534  * @filp: open sysfs file
5535  * @kobj: kernel kobject that contains the kernel class device.
5536  * @bin_attr: kernel attributes passed to us.
5537  * @buf: contains the data to be written to the adapter IOREG space.
5538  * @off: offset into buffer to beginning of data.
5539  * @count: bytes to transfer.
5540  *
5541  * Description:
5542  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
5543  * Uses the adapter io control registers to send buf contents to the adapter.
5544  *
5545  * Returns:
5546  * -ERANGE off and count combo out of range
5547  * -EINVAL off, count or buff address invalid
5548  * -EPERM adapter is offline
5549  * value of count, buf contents written
5550  **/
5551 static ssize_t
5552 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
5553                    struct bin_attribute *bin_attr,
5554                    char *buf, loff_t off, size_t count)
5555 {
5556         size_t buf_off;
5557         struct device *dev = container_of(kobj, struct device, kobj);
5558         struct Scsi_Host  *shost = class_to_shost(dev);
5559         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5560         struct lpfc_hba   *phba = vport->phba;
5561
5562         if (phba->sli_rev >= LPFC_SLI_REV4)
5563                 return -EPERM;
5564
5565         if ((off + count) > FF_REG_AREA_SIZE)
5566                 return -ERANGE;
5567
5568         if (count <= LPFC_REG_WRITE_KEY_SIZE)
5569                 return 0;
5570
5571         if (off % 4 || count % 4 || (unsigned long)buf % 4)
5572                 return -EINVAL;
5573
5574         /* This is to protect HBA registers from accidental writes. */
5575         if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
5576                 return -EINVAL;
5577
5578         if (!(vport->fc_flag & FC_OFFLINE_MODE))
5579                 return -EPERM;
5580
5581         spin_lock_irq(&phba->hbalock);
5582         for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
5583                         buf_off += sizeof(uint32_t))
5584                 writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
5585                        phba->ctrl_regs_memmap_p + off + buf_off);
5586
5587         spin_unlock_irq(&phba->hbalock);
5588
5589         return count;
5590 }
5591
5592 /**
5593  * sysfs_ctlreg_read - Read method for reading from ctlreg
5594  * @filp: open sysfs file
5595  * @kobj: kernel kobject that contains the kernel class device.
5596  * @bin_attr: kernel attributes passed to us.
5597  * @buf: if successful contains the data from the adapter IOREG space.
5598  * @off: offset into buffer to beginning of data.
5599  * @count: bytes to transfer.
5600  *
5601  * Description:
5602  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
5603  * Uses the adapter io control registers to read data into buf.
5604  *
5605  * Returns:
5606  * -ERANGE off and count combo out of range
5607  * -EINVAL off, count or buff address invalid
5608  * value of count, buf contents read
5609  **/
5610 static ssize_t
5611 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
5612                   struct bin_attribute *bin_attr,
5613                   char *buf, loff_t off, size_t count)
5614 {
5615         size_t buf_off;
5616         uint32_t * tmp_ptr;
5617         struct device *dev = container_of(kobj, struct device, kobj);
5618         struct Scsi_Host  *shost = class_to_shost(dev);
5619         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5620         struct lpfc_hba   *phba = vport->phba;
5621
5622         if (phba->sli_rev >= LPFC_SLI_REV4)
5623                 return -EPERM;
5624
5625         if (off > FF_REG_AREA_SIZE)
5626                 return -ERANGE;
5627
5628         if ((off + count) > FF_REG_AREA_SIZE)
5629                 count = FF_REG_AREA_SIZE - off;
5630
5631         if (count == 0) return 0;
5632
5633         if (off % 4 || count % 4 || (unsigned long)buf % 4)
5634                 return -EINVAL;
5635
5636         spin_lock_irq(&phba->hbalock);
5637
5638         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
5639                 tmp_ptr = (uint32_t *)(buf + buf_off);
5640                 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
5641         }
5642
5643         spin_unlock_irq(&phba->hbalock);
5644
5645         return count;
5646 }
5647
5648 static struct bin_attribute sysfs_ctlreg_attr = {
5649         .attr = {
5650                 .name = "ctlreg",
5651                 .mode = S_IRUSR | S_IWUSR,
5652         },
5653         .size = 256,
5654         .read = sysfs_ctlreg_read,
5655         .write = sysfs_ctlreg_write,
5656 };
5657
5658 /**
5659  * sysfs_mbox_write - Write method for writing information via mbox
5660  * @filp: open sysfs file
5661  * @kobj: kernel kobject that contains the kernel class device.
5662  * @bin_attr: kernel attributes passed to us.
5663  * @buf: contains the data to be written to sysfs mbox.
5664  * @off: offset into buffer to beginning of data.
5665  * @count: bytes to transfer.
5666  *
5667  * Description:
5668  * Deprecated function. All mailbox access from user space is performed via the
5669  * bsg interface.
5670  *
5671  * Returns:
5672  * -EPERM operation not permitted
5673  **/
5674 static ssize_t
5675 sysfs_mbox_write(struct file *filp, struct kobject *kobj,
5676                  struct bin_attribute *bin_attr,
5677                  char *buf, loff_t off, size_t count)
5678 {
5679         return -EPERM;
5680 }
5681
5682 /**
5683  * sysfs_mbox_read - Read method for reading information via mbox
5684  * @filp: open sysfs file
5685  * @kobj: kernel kobject that contains the kernel class device.
5686  * @bin_attr: kernel attributes passed to us.
5687  * @buf: contains the data to be read from sysfs mbox.
5688  * @off: offset into buffer to beginning of data.
5689  * @count: bytes to transfer.
5690  *
5691  * Description:
5692  * Deprecated function. All mailbox access from user space is performed via the
5693  * bsg interface.
5694  *
5695  * Returns:
5696  * -EPERM operation not permitted
5697  **/
5698 static ssize_t
5699 sysfs_mbox_read(struct file *filp, struct kobject *kobj,
5700                 struct bin_attribute *bin_attr,
5701                 char *buf, loff_t off, size_t count)
5702 {
5703         return -EPERM;
5704 }
5705
5706 static struct bin_attribute sysfs_mbox_attr = {
5707         .attr = {
5708                 .name = "mbox",
5709                 .mode = S_IRUSR | S_IWUSR,
5710         },
5711         .size = MAILBOX_SYSFS_MAX,
5712         .read = sysfs_mbox_read,
5713         .write = sysfs_mbox_write,
5714 };
5715
5716 /**
5717  * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
5718  * @vport: address of lpfc vport structure.
5719  *
5720  * Return codes:
5721  * zero on success
5722  * error return code from sysfs_create_bin_file()
5723  **/
5724 int
5725 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
5726 {
5727         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5728         int error;
5729
5730         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5731                                       &sysfs_drvr_stat_data_attr);
5732
5733         /* Virtual ports do not need ctrl_reg and mbox */
5734         if (error || vport->port_type == LPFC_NPIV_PORT)
5735                 goto out;
5736
5737         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5738                                       &sysfs_ctlreg_attr);
5739         if (error)
5740                 goto out_remove_stat_attr;
5741
5742         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5743                                       &sysfs_mbox_attr);
5744         if (error)
5745                 goto out_remove_ctlreg_attr;
5746
5747         return 0;
5748 out_remove_ctlreg_attr:
5749         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
5750 out_remove_stat_attr:
5751         sysfs_remove_bin_file(&shost->shost_dev.kobj,
5752                         &sysfs_drvr_stat_data_attr);
5753 out:
5754         return error;
5755 }
5756
5757 /**
5758  * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
5759  * @vport: address of lpfc vport structure.
5760  **/
5761 void
5762 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
5763 {
5764         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5765         sysfs_remove_bin_file(&shost->shost_dev.kobj,
5766                 &sysfs_drvr_stat_data_attr);
5767         /* Virtual ports do not need ctrl_reg and mbox */
5768         if (vport->port_type == LPFC_NPIV_PORT)
5769                 return;
5770         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
5771         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
5772 }
5773
5774 /*
5775  * Dynamic FC Host Attributes Support
5776  */
5777
5778 /**
5779  * lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host
5780  * @shost: kernel scsi host pointer.
5781  **/
5782 static void
5783 lpfc_get_host_symbolic_name(struct Scsi_Host *shost)
5784 {
5785         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5786
5787         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
5788                                       sizeof fc_host_symbolic_name(shost));
5789 }
5790
5791 /**
5792  * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
5793  * @shost: kernel scsi host pointer.
5794  **/
5795 static void
5796 lpfc_get_host_port_id(struct Scsi_Host *shost)
5797 {
5798         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5799
5800         /* note: fc_myDID already in cpu endianness */
5801         fc_host_port_id(shost) = vport->fc_myDID;
5802 }
5803
5804 /**
5805  * lpfc_get_host_port_type - Set the value of the scsi host port type
5806  * @shost: kernel scsi host pointer.
5807  **/
5808 static void
5809 lpfc_get_host_port_type(struct Scsi_Host *shost)
5810 {
5811         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5812         struct lpfc_hba   *phba = vport->phba;
5813
5814         spin_lock_irq(shost->host_lock);
5815
5816         if (vport->port_type == LPFC_NPIV_PORT) {
5817                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
5818         } else if (lpfc_is_link_up(phba)) {
5819                 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
5820                         if (vport->fc_flag & FC_PUBLIC_LOOP)
5821                                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
5822                         else
5823                                 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
5824                 } else {
5825                         if (vport->fc_flag & FC_FABRIC)
5826                                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
5827                         else
5828                                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
5829                 }
5830         } else
5831                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
5832
5833         spin_unlock_irq(shost->host_lock);
5834 }
5835
5836 /**
5837  * lpfc_get_host_port_state - Set the value of the scsi host port state
5838  * @shost: kernel scsi host pointer.
5839  **/
5840 static void
5841 lpfc_get_host_port_state(struct Scsi_Host *shost)
5842 {
5843         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5844         struct lpfc_hba   *phba = vport->phba;
5845
5846         spin_lock_irq(shost->host_lock);
5847
5848         if (vport->fc_flag & FC_OFFLINE_MODE)
5849                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
5850         else {
5851                 switch (phba->link_state) {
5852                 case LPFC_LINK_UNKNOWN:
5853                 case LPFC_LINK_DOWN:
5854                         fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
5855                         break;
5856                 case LPFC_LINK_UP:
5857                 case LPFC_CLEAR_LA:
5858                 case LPFC_HBA_READY:
5859                         /* Links up, reports port state accordingly */
5860                         if (vport->port_state < LPFC_VPORT_READY)
5861                                 fc_host_port_state(shost) =
5862                                                         FC_PORTSTATE_BYPASSED;
5863                         else
5864                                 fc_host_port_state(shost) =
5865                                                         FC_PORTSTATE_ONLINE;
5866                         break;
5867                 case LPFC_HBA_ERROR:
5868                         fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
5869                         break;
5870                 default:
5871                         fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
5872                         break;
5873                 }
5874         }
5875
5876         spin_unlock_irq(shost->host_lock);
5877 }
5878
5879 /**
5880  * lpfc_get_host_speed - Set the value of the scsi host speed
5881  * @shost: kernel scsi host pointer.
5882  **/
5883 static void
5884 lpfc_get_host_speed(struct Scsi_Host *shost)
5885 {
5886         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5887         struct lpfc_hba   *phba = vport->phba;
5888
5889         spin_lock_irq(shost->host_lock);
5890
5891         if ((lpfc_is_link_up(phba)) && (!(phba->hba_flag & HBA_FCOE_MODE))) {
5892                 switch(phba->fc_linkspeed) {
5893                 case LPFC_LINK_SPEED_1GHZ:
5894                         fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
5895                         break;
5896                 case LPFC_LINK_SPEED_2GHZ:
5897                         fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
5898                         break;
5899                 case LPFC_LINK_SPEED_4GHZ:
5900                         fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
5901                         break;
5902                 case LPFC_LINK_SPEED_8GHZ:
5903                         fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
5904                         break;
5905                 case LPFC_LINK_SPEED_10GHZ:
5906                         fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
5907                         break;
5908                 case LPFC_LINK_SPEED_16GHZ:
5909                         fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
5910                         break;
5911                 case LPFC_LINK_SPEED_32GHZ:
5912                         fc_host_speed(shost) = FC_PORTSPEED_32GBIT;
5913                         break;
5914                 case LPFC_LINK_SPEED_64GHZ:
5915                         fc_host_speed(shost) = FC_PORTSPEED_64GBIT;
5916                         break;
5917                 default:
5918                         fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
5919                         break;
5920                 }
5921         } else if (lpfc_is_link_up(phba) && (phba->hba_flag & HBA_FCOE_MODE)) {
5922                 switch (phba->fc_linkspeed) {
5923                 case LPFC_ASYNC_LINK_SPEED_10GBPS:
5924                         fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
5925                         break;
5926                 case LPFC_ASYNC_LINK_SPEED_25GBPS:
5927                         fc_host_speed(shost) = FC_PORTSPEED_25GBIT;
5928                         break;
5929                 case LPFC_ASYNC_LINK_SPEED_40GBPS:
5930                         fc_host_speed(shost) = FC_PORTSPEED_40GBIT;
5931                         break;
5932                 case LPFC_ASYNC_LINK_SPEED_100GBPS:
5933                         fc_host_speed(shost) = FC_PORTSPEED_100GBIT;
5934                         break;
5935                 default:
5936                         fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
5937                         break;
5938                 }
5939         } else
5940                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
5941
5942         spin_unlock_irq(shost->host_lock);
5943 }
5944
5945 /**
5946  * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
5947  * @shost: kernel scsi host pointer.
5948  **/
5949 static void
5950 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
5951 {
5952         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5953         struct lpfc_hba   *phba = vport->phba;
5954         u64 node_name;
5955
5956         spin_lock_irq(shost->host_lock);
5957
5958         if ((vport->port_state > LPFC_FLOGI) &&
5959             ((vport->fc_flag & FC_FABRIC) ||
5960              ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
5961               (vport->fc_flag & FC_PUBLIC_LOOP))))
5962                 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
5963         else
5964                 /* fabric is local port if there is no F/FL_Port */
5965                 node_name = 0;
5966
5967         spin_unlock_irq(shost->host_lock);
5968
5969         fc_host_fabric_name(shost) = node_name;
5970 }
5971
5972 /**
5973  * lpfc_get_stats - Return statistical information about the adapter
5974  * @shost: kernel scsi host pointer.
5975  *
5976  * Notes:
5977  * NULL on error for link down, no mbox pool, sli2 active,
5978  * management not allowed, memory allocation error, or mbox error.
5979  *
5980  * Returns:
5981  * NULL for error
5982  * address of the adapter host statistics
5983  **/
5984 static struct fc_host_statistics *
5985 lpfc_get_stats(struct Scsi_Host *shost)
5986 {
5987         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5988         struct lpfc_hba   *phba = vport->phba;
5989         struct lpfc_sli   *psli = &phba->sli;
5990         struct fc_host_statistics *hs = &phba->link_stats;
5991         struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
5992         LPFC_MBOXQ_t *pmboxq;
5993         MAILBOX_t *pmb;
5994         int rc = 0;
5995
5996         /*
5997          * prevent udev from issuing mailbox commands until the port is
5998          * configured.
5999          */
6000         if (phba->link_state < LPFC_LINK_DOWN ||
6001             !phba->mbox_mem_pool ||
6002             (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
6003                 return NULL;
6004
6005         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
6006                 return NULL;
6007
6008         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6009         if (!pmboxq)
6010                 return NULL;
6011         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6012
6013         pmb = &pmboxq->u.mb;
6014         pmb->mbxCommand = MBX_READ_STATUS;
6015         pmb->mbxOwner = OWN_HOST;
6016         pmboxq->context1 = NULL;
6017         pmboxq->vport = vport;
6018
6019         if (vport->fc_flag & FC_OFFLINE_MODE)
6020                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6021         else
6022                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6023
6024         if (rc != MBX_SUCCESS) {
6025                 if (rc != MBX_TIMEOUT)
6026                         mempool_free(pmboxq, phba->mbox_mem_pool);
6027                 return NULL;
6028         }
6029
6030         memset(hs, 0, sizeof (struct fc_host_statistics));
6031
6032         hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
6033         /*
6034          * The MBX_READ_STATUS returns tx_k_bytes which has to
6035          * converted to words
6036          */
6037         hs->tx_words = (uint64_t)
6038                         ((uint64_t)pmb->un.varRdStatus.xmitByteCnt
6039                         * (uint64_t)256);
6040         hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
6041         hs->rx_words = (uint64_t)
6042                         ((uint64_t)pmb->un.varRdStatus.rcvByteCnt
6043                          * (uint64_t)256);
6044
6045         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6046         pmb->mbxCommand = MBX_READ_LNK_STAT;
6047         pmb->mbxOwner = OWN_HOST;
6048         pmboxq->context1 = NULL;
6049         pmboxq->vport = vport;
6050
6051         if (vport->fc_flag & FC_OFFLINE_MODE)
6052                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6053         else
6054                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6055
6056         if (rc != MBX_SUCCESS) {
6057                 if (rc != MBX_TIMEOUT)
6058                         mempool_free(pmboxq, phba->mbox_mem_pool);
6059                 return NULL;
6060         }
6061
6062         hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
6063         hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
6064         hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
6065         hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
6066         hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
6067         hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
6068         hs->error_frames = pmb->un.varRdLnk.crcCnt;
6069
6070         hs->link_failure_count -= lso->link_failure_count;
6071         hs->loss_of_sync_count -= lso->loss_of_sync_count;
6072         hs->loss_of_signal_count -= lso->loss_of_signal_count;
6073         hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
6074         hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
6075         hs->invalid_crc_count -= lso->invalid_crc_count;
6076         hs->error_frames -= lso->error_frames;
6077
6078         if (phba->hba_flag & HBA_FCOE_MODE) {
6079                 hs->lip_count = -1;
6080                 hs->nos_count = (phba->link_events >> 1);
6081                 hs->nos_count -= lso->link_events;
6082         } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
6083                 hs->lip_count = (phba->fc_eventTag >> 1);
6084                 hs->lip_count -= lso->link_events;
6085                 hs->nos_count = -1;
6086         } else {
6087                 hs->lip_count = -1;
6088                 hs->nos_count = (phba->fc_eventTag >> 1);
6089                 hs->nos_count -= lso->link_events;
6090         }
6091
6092         hs->dumped_frames = -1;
6093
6094         hs->seconds_since_last_reset = ktime_get_seconds() - psli->stats_start;
6095
6096         mempool_free(pmboxq, phba->mbox_mem_pool);
6097
6098         return hs;
6099 }
6100
6101 /**
6102  * lpfc_reset_stats - Copy the adapter link stats information
6103  * @shost: kernel scsi host pointer.
6104  **/
6105 static void
6106 lpfc_reset_stats(struct Scsi_Host *shost)
6107 {
6108         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6109         struct lpfc_hba   *phba = vport->phba;
6110         struct lpfc_sli   *psli = &phba->sli;
6111         struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
6112         LPFC_MBOXQ_t *pmboxq;
6113         MAILBOX_t *pmb;
6114         int rc = 0;
6115
6116         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
6117                 return;
6118
6119         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6120         if (!pmboxq)
6121                 return;
6122         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
6123
6124         pmb = &pmboxq->u.mb;
6125         pmb->mbxCommand = MBX_READ_STATUS;
6126         pmb->mbxOwner = OWN_HOST;
6127         pmb->un.varWords[0] = 0x1; /* reset request */
6128         pmboxq->context1 = NULL;
6129         pmboxq->vport = vport;
6130
6131         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
6132                 (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
6133                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6134         else
6135                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6136
6137         if (rc != MBX_SUCCESS) {
6138                 if (rc != MBX_TIMEOUT)
6139                         mempool_free(pmboxq, phba->mbox_mem_pool);
6140                 return;
6141         }
6142
6143         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
6144         pmb->mbxCommand = MBX_READ_LNK_STAT;
6145         pmb->mbxOwner = OWN_HOST;
6146         pmboxq->context1 = NULL;
6147         pmboxq->vport = vport;
6148
6149         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
6150             (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
6151                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6152         else
6153                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6154
6155         if (rc != MBX_SUCCESS) {
6156                 if (rc != MBX_TIMEOUT)
6157                         mempool_free( pmboxq, phba->mbox_mem_pool);
6158                 return;
6159         }
6160
6161         lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
6162         lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
6163         lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
6164         lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
6165         lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
6166         lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
6167         lso->error_frames = pmb->un.varRdLnk.crcCnt;
6168         if (phba->hba_flag & HBA_FCOE_MODE)
6169                 lso->link_events = (phba->link_events >> 1);
6170         else
6171                 lso->link_events = (phba->fc_eventTag >> 1);
6172
6173         psli->stats_start = ktime_get_seconds();
6174
6175         mempool_free(pmboxq, phba->mbox_mem_pool);
6176
6177         return;
6178 }
6179
6180 /*
6181  * The LPFC driver treats linkdown handling as target loss events so there
6182  * are no sysfs handlers for link_down_tmo.
6183  */
6184
6185 /**
6186  * lpfc_get_node_by_target - Return the nodelist for a target
6187  * @starget: kernel scsi target pointer.
6188  *
6189  * Returns:
6190  * address of the node list if found
6191  * NULL target not found
6192  **/
6193 static struct lpfc_nodelist *
6194 lpfc_get_node_by_target(struct scsi_target *starget)
6195 {
6196         struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
6197         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6198         struct lpfc_nodelist *ndlp;
6199
6200         spin_lock_irq(shost->host_lock);
6201         /* Search for this, mapped, target ID */
6202         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
6203                 if (NLP_CHK_NODE_ACT(ndlp) &&
6204                     ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
6205                     starget->id == ndlp->nlp_sid) {
6206                         spin_unlock_irq(shost->host_lock);
6207                         return ndlp;
6208                 }
6209         }
6210         spin_unlock_irq(shost->host_lock);
6211         return NULL;
6212 }
6213
6214 /**
6215  * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
6216  * @starget: kernel scsi target pointer.
6217  **/
6218 static void
6219 lpfc_get_starget_port_id(struct scsi_target *starget)
6220 {
6221         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6222
6223         fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
6224 }
6225
6226 /**
6227  * lpfc_get_starget_node_name - Set the target node name
6228  * @starget: kernel scsi target pointer.
6229  *
6230  * Description: Set the target node name to the ndlp node name wwn or zero.
6231  **/
6232 static void
6233 lpfc_get_starget_node_name(struct scsi_target *starget)
6234 {
6235         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6236
6237         fc_starget_node_name(starget) =
6238                 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
6239 }
6240
6241 /**
6242  * lpfc_get_starget_port_name - Set the target port name
6243  * @starget: kernel scsi target pointer.
6244  *
6245  * Description:  set the target port name to the ndlp port name wwn or zero.
6246  **/
6247 static void
6248 lpfc_get_starget_port_name(struct scsi_target *starget)
6249 {
6250         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6251
6252         fc_starget_port_name(starget) =
6253                 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
6254 }
6255
6256 /**
6257  * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
6258  * @rport: fc rport address.
6259  * @timeout: new value for dev loss tmo.
6260  *
6261  * Description:
6262  * If timeout is non zero set the dev_loss_tmo to timeout, else set
6263  * dev_loss_tmo to one.
6264  **/
6265 static void
6266 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
6267 {
6268         if (timeout)
6269                 rport->dev_loss_tmo = timeout;
6270         else
6271                 rport->dev_loss_tmo = 1;
6272 }
6273
6274 /**
6275  * lpfc_rport_show_function - Return rport target information
6276  *
6277  * Description:
6278  * Macro that uses field to generate a function with the name lpfc_show_rport_
6279  *
6280  * lpfc_show_rport_##field: returns the bytes formatted in buf
6281  * @cdev: class converted to an fc_rport.
6282  * @buf: on return contains the target_field or zero.
6283  *
6284  * Returns: size of formatted string.
6285  **/
6286 #define lpfc_rport_show_function(field, format_string, sz, cast)        \
6287 static ssize_t                                                          \
6288 lpfc_show_rport_##field (struct device *dev,                            \
6289                          struct device_attribute *attr,                 \
6290                          char *buf)                                     \
6291 {                                                                       \
6292         struct fc_rport *rport = transport_class_to_rport(dev);         \
6293         struct lpfc_rport_data *rdata = rport->hostdata;                \
6294         return snprintf(buf, sz, format_string,                         \
6295                 (rdata->target) ? cast rdata->target->field : 0);       \
6296 }
6297
6298 #define lpfc_rport_rd_attr(field, format_string, sz)                    \
6299         lpfc_rport_show_function(field, format_string, sz, )            \
6300 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
6301
6302 /**
6303  * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
6304  * @fc_vport: The fc_vport who's symbolic name has been changed.
6305  *
6306  * Description:
6307  * This function is called by the transport after the @fc_vport's symbolic name
6308  * has been changed. This function re-registers the symbolic name with the
6309  * switch to propagate the change into the fabric if the vport is active.
6310  **/
6311 static void
6312 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
6313 {
6314         struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
6315
6316         if (vport->port_state == LPFC_VPORT_READY)
6317                 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
6318 }
6319
6320 /**
6321  * lpfc_hba_log_verbose_init - Set hba's log verbose level
6322  * @phba: Pointer to lpfc_hba struct.
6323  *
6324  * This function is called by the lpfc_get_cfgparam() routine to set the
6325  * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
6326  * log message according to the module's lpfc_log_verbose parameter setting
6327  * before hba port or vport created.
6328  **/
6329 static void
6330 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
6331 {
6332         phba->cfg_log_verbose = verbose;
6333 }
6334
6335 struct fc_function_template lpfc_transport_functions = {
6336         /* fixed attributes the driver supports */
6337         .show_host_node_name = 1,
6338         .show_host_port_name = 1,
6339         .show_host_supported_classes = 1,
6340         .show_host_supported_fc4s = 1,
6341         .show_host_supported_speeds = 1,
6342         .show_host_maxframe_size = 1,
6343
6344         .get_host_symbolic_name = lpfc_get_host_symbolic_name,
6345         .show_host_symbolic_name = 1,
6346
6347         /* dynamic attributes the driver supports */
6348         .get_host_port_id = lpfc_get_host_port_id,
6349         .show_host_port_id = 1,
6350
6351         .get_host_port_type = lpfc_get_host_port_type,
6352         .show_host_port_type = 1,
6353
6354         .get_host_port_state = lpfc_get_host_port_state,
6355         .show_host_port_state = 1,
6356
6357         /* active_fc4s is shown but doesn't change (thus no get function) */
6358         .show_host_active_fc4s = 1,
6359
6360         .get_host_speed = lpfc_get_host_speed,
6361         .show_host_speed = 1,
6362
6363         .get_host_fabric_name = lpfc_get_host_fabric_name,
6364         .show_host_fabric_name = 1,
6365
6366         /*
6367          * The LPFC driver treats linkdown handling as target loss events
6368          * so there are no sysfs handlers for link_down_tmo.
6369          */
6370
6371         .get_fc_host_stats = lpfc_get_stats,
6372         .reset_fc_host_stats = lpfc_reset_stats,
6373
6374         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
6375         .show_rport_maxframe_size = 1,
6376         .show_rport_supported_classes = 1,
6377
6378         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
6379         .show_rport_dev_loss_tmo = 1,
6380
6381         .get_starget_port_id  = lpfc_get_starget_port_id,
6382         .show_starget_port_id = 1,
6383
6384         .get_starget_node_name = lpfc_get_starget_node_name,
6385         .show_starget_node_name = 1,
6386
6387         .get_starget_port_name = lpfc_get_starget_port_name,
6388         .show_starget_port_name = 1,
6389
6390         .issue_fc_host_lip = lpfc_issue_lip,
6391         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
6392         .terminate_rport_io = lpfc_terminate_rport_io,
6393
6394         .dd_fcvport_size = sizeof(struct lpfc_vport *),
6395
6396         .vport_disable = lpfc_vport_disable,
6397
6398         .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
6399
6400         .bsg_request = lpfc_bsg_request,
6401         .bsg_timeout = lpfc_bsg_timeout,
6402 };
6403
6404 struct fc_function_template lpfc_vport_transport_functions = {
6405         /* fixed attributes the driver supports */
6406         .show_host_node_name = 1,
6407         .show_host_port_name = 1,
6408         .show_host_supported_classes = 1,
6409         .show_host_supported_fc4s = 1,
6410         .show_host_supported_speeds = 1,
6411         .show_host_maxframe_size = 1,
6412
6413         .get_host_symbolic_name = lpfc_get_host_symbolic_name,
6414         .show_host_symbolic_name = 1,
6415
6416         /* dynamic attributes the driver supports */
6417         .get_host_port_id = lpfc_get_host_port_id,
6418         .show_host_port_id = 1,
6419
6420         .get_host_port_type = lpfc_get_host_port_type,
6421         .show_host_port_type = 1,
6422
6423         .get_host_port_state = lpfc_get_host_port_state,
6424         .show_host_port_state = 1,
6425
6426         /* active_fc4s is shown but doesn't change (thus no get function) */
6427         .show_host_active_fc4s = 1,
6428
6429         .get_host_speed = lpfc_get_host_speed,
6430         .show_host_speed = 1,
6431
6432         .get_host_fabric_name = lpfc_get_host_fabric_name,
6433         .show_host_fabric_name = 1,
6434
6435         /*
6436          * The LPFC driver treats linkdown handling as target loss events
6437          * so there are no sysfs handlers for link_down_tmo.
6438          */
6439
6440         .get_fc_host_stats = lpfc_get_stats,
6441         .reset_fc_host_stats = lpfc_reset_stats,
6442
6443         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
6444         .show_rport_maxframe_size = 1,
6445         .show_rport_supported_classes = 1,
6446
6447         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
6448         .show_rport_dev_loss_tmo = 1,
6449
6450         .get_starget_port_id  = lpfc_get_starget_port_id,
6451         .show_starget_port_id = 1,
6452
6453         .get_starget_node_name = lpfc_get_starget_node_name,
6454         .show_starget_node_name = 1,
6455
6456         .get_starget_port_name = lpfc_get_starget_port_name,
6457         .show_starget_port_name = 1,
6458
6459         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
6460         .terminate_rport_io = lpfc_terminate_rport_io,
6461
6462         .vport_disable = lpfc_vport_disable,
6463
6464         .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
6465 };
6466
6467 /**
6468  * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
6469  * @phba: lpfc_hba pointer.
6470  **/
6471 void
6472 lpfc_get_cfgparam(struct lpfc_hba *phba)
6473 {
6474         lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
6475         lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
6476         lpfc_cr_delay_init(phba, lpfc_cr_delay);
6477         lpfc_cr_count_init(phba, lpfc_cr_count);
6478         lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
6479         lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
6480         lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
6481         lpfc_ack0_init(phba, lpfc_ack0);
6482         lpfc_topology_init(phba, lpfc_topology);
6483         lpfc_link_speed_init(phba, lpfc_link_speed);
6484         lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
6485         lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo);
6486         lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
6487         lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
6488         lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
6489         lpfc_fdmi_on_init(phba, lpfc_fdmi_on);
6490         lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN);
6491         lpfc_use_msi_init(phba, lpfc_use_msi);
6492         lpfc_nvme_oas_init(phba, lpfc_nvme_oas);
6493         lpfc_nvme_embed_cmd_init(phba, lpfc_nvme_embed_cmd);
6494         lpfc_auto_imax_init(phba, lpfc_auto_imax);
6495         lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
6496         lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
6497         lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
6498         lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
6499
6500         lpfc_EnableXLane_init(phba, lpfc_EnableXLane);
6501         if (phba->sli_rev != LPFC_SLI_REV4)
6502                 phba->cfg_EnableXLane = 0;
6503         lpfc_XLanePriority_init(phba, lpfc_XLanePriority);
6504
6505         memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t)));
6506         memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t)));
6507         phba->cfg_oas_lun_state = 0;
6508         phba->cfg_oas_lun_status = 0;
6509         phba->cfg_oas_flags = 0;
6510         phba->cfg_oas_priority = 0;
6511         lpfc_enable_bg_init(phba, lpfc_enable_bg);
6512         lpfc_prot_mask_init(phba, lpfc_prot_mask);
6513         lpfc_prot_guard_init(phba, lpfc_prot_guard);
6514         if (phba->sli_rev == LPFC_SLI_REV4)
6515                 phba->cfg_poll = 0;
6516         else
6517                 phba->cfg_poll = lpfc_poll;
6518
6519         if (phba->cfg_enable_bg)
6520                 phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
6521
6522         lpfc_suppress_rsp_init(phba, lpfc_suppress_rsp);
6523
6524         lpfc_enable_fc4_type_init(phba, lpfc_enable_fc4_type);
6525         lpfc_nvmet_mrq_init(phba, lpfc_nvmet_mrq);
6526         lpfc_nvmet_mrq_post_init(phba, lpfc_nvmet_mrq_post);
6527
6528         /* Initialize first burst. Target vs Initiator are different. */
6529         lpfc_nvme_enable_fb_init(phba, lpfc_nvme_enable_fb);
6530         lpfc_nvmet_fb_size_init(phba, lpfc_nvmet_fb_size);
6531         lpfc_fcp_io_channel_init(phba, lpfc_fcp_io_channel);
6532         lpfc_nvme_io_channel_init(phba, lpfc_nvme_io_channel);
6533         lpfc_enable_bbcr_init(phba, lpfc_enable_bbcr);
6534         lpfc_enable_dpp_init(phba, lpfc_enable_dpp);
6535
6536         if (phba->sli_rev != LPFC_SLI_REV4) {
6537                 /* NVME only supported on SLI4 */
6538                 phba->nvmet_support = 0;
6539                 phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
6540                 phba->cfg_enable_bbcr = 0;
6541         } else {
6542                 /* We MUST have FCP support */
6543                 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
6544                         phba->cfg_enable_fc4_type |= LPFC_ENABLE_FCP;
6545         }
6546
6547         if (phba->cfg_auto_imax && !phba->cfg_fcp_imax)
6548                 phba->cfg_auto_imax = 0;
6549         phba->initial_imax = phba->cfg_fcp_imax;
6550
6551         phba->cfg_enable_pbde = 0;
6552
6553         /* A value of 0 means use the number of CPUs found in the system */
6554         if (phba->cfg_fcp_io_channel == 0)
6555                 phba->cfg_fcp_io_channel = phba->sli4_hba.num_present_cpu;
6556         if (phba->cfg_nvme_io_channel == 0)
6557                 phba->cfg_nvme_io_channel = phba->sli4_hba.num_present_cpu;
6558
6559         if (phba->cfg_enable_fc4_type == LPFC_ENABLE_NVME)
6560                 phba->cfg_fcp_io_channel = 0;
6561
6562         if (phba->cfg_enable_fc4_type == LPFC_ENABLE_FCP)
6563                 phba->cfg_nvme_io_channel = 0;
6564
6565         if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel)
6566                 phba->io_channel_irqs = phba->cfg_fcp_io_channel;
6567         else
6568                 phba->io_channel_irqs = phba->cfg_nvme_io_channel;
6569
6570         phba->cfg_soft_wwnn = 0L;
6571         phba->cfg_soft_wwpn = 0L;
6572         lpfc_xri_split_init(phba, lpfc_xri_split);
6573         lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
6574         lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
6575         lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
6576         lpfc_aer_support_init(phba, lpfc_aer_support);
6577         lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
6578         lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
6579         lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
6580         lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
6581         lpfc_delay_discovery_init(phba, lpfc_delay_discovery);
6582         lpfc_sli_mode_init(phba, lpfc_sli_mode);
6583         phba->cfg_enable_dss = 1;
6584         lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
6585         return;
6586 }
6587
6588 /**
6589  * lpfc_nvme_mod_param_dep - Adjust module parameter value based on
6590  * dependencies between protocols and roles.
6591  * @phba: lpfc_hba pointer.
6592  **/
6593 void
6594 lpfc_nvme_mod_param_dep(struct lpfc_hba *phba)
6595 {
6596         if (phba->cfg_nvme_io_channel > phba->sli4_hba.num_present_cpu)
6597                 phba->cfg_nvme_io_channel = phba->sli4_hba.num_present_cpu;
6598
6599         if (phba->cfg_fcp_io_channel > phba->sli4_hba.num_present_cpu)
6600                 phba->cfg_fcp_io_channel = phba->sli4_hba.num_present_cpu;
6601
6602         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME &&
6603             phba->nvmet_support) {
6604                 phba->cfg_enable_fc4_type &= ~LPFC_ENABLE_FCP;
6605                 phba->cfg_fcp_io_channel = 0;
6606
6607                 lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
6608                                 "6013 %s x%x fb_size x%x, fb_max x%x\n",
6609                                 "NVME Target PRLI ACC enable_fb ",
6610                                 phba->cfg_nvme_enable_fb,
6611                                 phba->cfg_nvmet_fb_size,
6612                                 LPFC_NVMET_FB_SZ_MAX);
6613
6614                 if (phba->cfg_nvme_enable_fb == 0)
6615                         phba->cfg_nvmet_fb_size = 0;
6616                 else {
6617                         if (phba->cfg_nvmet_fb_size > LPFC_NVMET_FB_SZ_MAX)
6618                                 phba->cfg_nvmet_fb_size = LPFC_NVMET_FB_SZ_MAX;
6619                 }
6620
6621                 if (!phba->cfg_nvmet_mrq)
6622                         phba->cfg_nvmet_mrq = phba->cfg_nvme_io_channel;
6623
6624                 /* Adjust lpfc_nvmet_mrq to avoid running out of WQE slots */
6625                 if (phba->cfg_nvmet_mrq > phba->cfg_nvme_io_channel) {
6626                         phba->cfg_nvmet_mrq = phba->cfg_nvme_io_channel;
6627                         lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
6628                                         "6018 Adjust lpfc_nvmet_mrq to %d\n",
6629                                         phba->cfg_nvmet_mrq);
6630                 }
6631                 if (phba->cfg_nvmet_mrq > LPFC_NVMET_MRQ_MAX)
6632                         phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_MAX;
6633
6634         } else {
6635                 /* Not NVME Target mode.  Turn off Target parameters. */
6636                 phba->nvmet_support = 0;
6637                 phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_OFF;
6638                 phba->cfg_nvmet_fb_size = 0;
6639         }
6640
6641         if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel)
6642                 phba->io_channel_irqs = phba->cfg_fcp_io_channel;
6643         else
6644                 phba->io_channel_irqs = phba->cfg_nvme_io_channel;
6645 }
6646
6647 /**
6648  * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
6649  * @vport: lpfc_vport pointer.
6650  **/
6651 void
6652 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
6653 {
6654         lpfc_log_verbose_init(vport, lpfc_log_verbose);
6655         lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
6656         lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
6657         lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
6658         lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
6659         lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
6660         lpfc_restrict_login_init(vport, lpfc_restrict_login);
6661         lpfc_fcp_class_init(vport, lpfc_fcp_class);
6662         lpfc_use_adisc_init(vport, lpfc_use_adisc);
6663         lpfc_first_burst_size_init(vport, lpfc_first_burst_size);
6664         lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
6665         lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
6666         lpfc_max_luns_init(vport, lpfc_max_luns);
6667         lpfc_scan_down_init(vport, lpfc_scan_down);
6668         lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
6669         return;
6670 }