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