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         /* wait for the SLI port firmware ready after firmware reset */
1648         for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
1649                 msleep(10);
1650                 if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1651                                &portstat_reg.word0))
1652                         continue;
1653                 if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
1654                         continue;
1655                 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
1656                         continue;
1657                 if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
1658                         continue;
1659                 break;
1660         }
1661
1662         if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
1663                 return 0;
1664         else
1665                 return -EIO;
1666 }
1667
1668 /**
1669  * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
1670  * @phba: lpfc_hba pointer.
1671  * @opcode: The sli4 config command opcode.
1672  *
1673  * Description:
1674  * Request SLI4 interface type-2 device to perform a physical register set
1675  * access.
1676  *
1677  * Returns:
1678  * zero for success
1679  **/
1680 static ssize_t
1681 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
1682 {
1683         struct completion online_compl;
1684         struct pci_dev *pdev = phba->pcidev;
1685         uint32_t before_fc_flag;
1686         uint32_t sriov_nr_virtfn;
1687         uint32_t reg_val;
1688         int status = 0, rc = 0;
1689         int job_posted = 1, sriov_err;
1690
1691         if (!phba->cfg_enable_hba_reset)
1692                 return -EACCES;
1693
1694         if ((phba->sli_rev < LPFC_SLI_REV4) ||
1695             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <
1696              LPFC_SLI_INTF_IF_TYPE_2))
1697                 return -EPERM;
1698
1699         /* Keep state if we need to restore back */
1700         before_fc_flag = phba->pport->fc_flag;
1701         sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
1702
1703         if (opcode == LPFC_FW_DUMP) {
1704                 init_completion(&online_compl);
1705                 phba->fw_dump_cmpl = &online_compl;
1706         } else {
1707                 /* Disable SR-IOV virtual functions if enabled */
1708                 if (phba->cfg_sriov_nr_virtfn) {
1709                         pci_disable_sriov(pdev);
1710                         phba->cfg_sriov_nr_virtfn = 0;
1711                 }
1712
1713                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1714
1715                 if (status != 0)
1716                         return status;
1717
1718                 /* wait for the device to be quiesced before firmware reset */
1719                 msleep(100);
1720         }
1721
1722         reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
1723                         LPFC_CTL_PDEV_CTL_OFFSET);
1724
1725         if (opcode == LPFC_FW_DUMP)
1726                 reg_val |= LPFC_FW_DUMP_REQUEST;
1727         else if (opcode == LPFC_FW_RESET)
1728                 reg_val |= LPFC_CTL_PDEV_CTL_FRST;
1729         else if (opcode == LPFC_DV_RESET)
1730                 reg_val |= LPFC_CTL_PDEV_CTL_DRST;
1731
1732         writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
1733                LPFC_CTL_PDEV_CTL_OFFSET);
1734         /* flush */
1735         readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
1736
1737         /* delay driver action following IF_TYPE_2 reset */
1738         rc = lpfc_sli4_pdev_status_reg_wait(phba);
1739
1740         if (rc == -EPERM) {
1741                 /* no privilege for reset */
1742                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1743                                 "3150 No privilege to perform the requested "
1744                                 "access: x%x\n", reg_val);
1745         } else if (rc == -EIO) {
1746                 /* reset failed, there is nothing more we can do */
1747                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1748                                 "3153 Fail to perform the requested "
1749                                 "access: x%x\n", reg_val);
1750                 if (phba->fw_dump_cmpl)
1751                         phba->fw_dump_cmpl = NULL;
1752                 return rc;
1753         }
1754
1755         /* keep the original port state */
1756         if (before_fc_flag & FC_OFFLINE_MODE) {
1757                 if (phba->fw_dump_cmpl)
1758                         phba->fw_dump_cmpl = NULL;
1759                 goto out;
1760         }
1761
1762         /* Firmware dump will trigger an HA_ERATT event, and
1763          * lpfc_handle_eratt_s4 routine already handles bringing the port back
1764          * online.
1765          */
1766         if (opcode == LPFC_FW_DUMP) {
1767                 wait_for_completion(phba->fw_dump_cmpl);
1768         } else  {
1769                 init_completion(&online_compl);
1770                 job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
1771                                                    LPFC_EVT_ONLINE);
1772                 if (!job_posted)
1773                         goto out;
1774
1775                 wait_for_completion(&online_compl);
1776         }
1777 out:
1778         /* in any case, restore the virtual functions enabled as before */
1779         if (sriov_nr_virtfn) {
1780                 /* If fw_dump was performed, first disable to clean up */
1781                 if (opcode == LPFC_FW_DUMP) {
1782                         pci_disable_sriov(pdev);
1783                         phba->cfg_sriov_nr_virtfn = 0;
1784                 }
1785
1786                 sriov_err =
1787                         lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
1788                 if (!sriov_err)
1789                         phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
1790         }
1791
1792         /* return proper error code */
1793         if (!rc) {
1794                 if (!job_posted)
1795                         rc = -ENOMEM;
1796                 else if (status)
1797                         rc = -EIO;
1798         }
1799         return rc;
1800 }
1801
1802 /**
1803  * lpfc_nport_evt_cnt_show - Return the number of nport events
1804  * @dev: class device that is converted into a Scsi_host.
1805  * @attr: device attribute, not used.
1806  * @buf: on return contains the ascii number of nport events.
1807  *
1808  * Returns: size of formatted string.
1809  **/
1810 static ssize_t
1811 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
1812                         char *buf)
1813 {
1814         struct Scsi_Host  *shost = class_to_shost(dev);
1815         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1816         struct lpfc_hba   *phba = vport->phba;
1817
1818         return scnprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
1819 }
1820
1821 static int
1822 lpfc_set_trunking(struct lpfc_hba *phba, char *buff_out)
1823 {
1824         LPFC_MBOXQ_t *mbox = NULL;
1825         unsigned long val = 0;
1826         char *pval = NULL;
1827         int rc = 0;
1828
1829         if (!strncmp("enable", buff_out,
1830                                  strlen("enable"))) {
1831                 pval = buff_out + strlen("enable") + 1;
1832                 rc = kstrtoul(pval, 0, &val);
1833                 if (rc)
1834                         return rc; /* Invalid  number */
1835         } else if (!strncmp("disable", buff_out,
1836                                  strlen("disable"))) {
1837                 val = 0;
1838         } else {
1839                 return -EINVAL;  /* Invalid command */
1840         }
1841
1842         switch (val) {
1843         case 0:
1844                 val = 0x0; /* Disable */
1845                 break;
1846         case 2:
1847                 val = 0x1; /* Enable two port trunk */
1848                 break;
1849         case 4:
1850                 val = 0x2; /* Enable four port trunk */
1851                 break;
1852         default:
1853                 return -EINVAL;
1854         }
1855
1856         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1857                         "0070 Set trunk mode with val %ld ", val);
1858
1859         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1860         if (!mbox)
1861                 return -ENOMEM;
1862
1863         lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
1864                          LPFC_MBOX_OPCODE_FCOE_FC_SET_TRUNK_MODE,
1865                          12, LPFC_SLI4_MBX_EMBED);
1866
1867         bf_set(lpfc_mbx_set_trunk_mode,
1868                &mbox->u.mqe.un.set_trunk_mode,
1869                val);
1870         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
1871         if (rc)
1872                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1873                                 "0071 Set trunk mode failed with status: %d",
1874                                 rc);
1875         mempool_free(mbox, phba->mbox_mem_pool);
1876
1877         return 0;
1878 }
1879
1880 static ssize_t
1881 lpfc_xcvr_data_show(struct device *dev, struct device_attribute *attr,
1882                     char *buf)
1883 {
1884         struct Scsi_Host  *shost = class_to_shost(dev);
1885         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
1886         struct lpfc_hba   *phba = vport->phba;
1887         int rc;
1888         int len = 0;
1889         struct lpfc_rdp_context *rdp_context;
1890         u16 temperature;
1891         u16 rx_power;
1892         u16 tx_bias;
1893         u16 tx_power;
1894         u16 vcc;
1895         char chbuf[128];
1896         u16 wavelength = 0;
1897         struct sff_trasnceiver_codes_byte7 *trasn_code_byte7;
1898
1899         /* Get transceiver information */
1900         rdp_context = kmalloc(sizeof(*rdp_context), GFP_KERNEL);
1901
1902         rc = lpfc_get_sfp_info_wait(phba, rdp_context);
1903         if (rc) {
1904                 len = scnprintf(buf, PAGE_SIZE - len, "SFP info NA:\n");
1905                 goto out_free_rdp;
1906         }
1907
1908         strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_NAME], 16);
1909
1910         len = scnprintf(buf, PAGE_SIZE - len, "VendorName:\t%s\n", chbuf);
1911         len += scnprintf(buf + len, PAGE_SIZE - len,
1912                          "VendorOUI:\t%02x-%02x-%02x\n",
1913                          (uint8_t)rdp_context->page_a0[SSF_VENDOR_OUI],
1914                          (uint8_t)rdp_context->page_a0[SSF_VENDOR_OUI + 1],
1915                          (uint8_t)rdp_context->page_a0[SSF_VENDOR_OUI + 2]);
1916         strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_PN], 16);
1917         len += scnprintf(buf + len, PAGE_SIZE - len, "VendorPN:\t%s\n", chbuf);
1918         strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_SN], 16);
1919         len += scnprintf(buf + len, PAGE_SIZE - len, "VendorSN:\t%s\n", chbuf);
1920         strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_REV], 4);
1921         len += scnprintf(buf + len, PAGE_SIZE - len, "VendorRev:\t%s\n", chbuf);
1922         strscpy(chbuf, &rdp_context->page_a0[SSF_DATE_CODE], 8);
1923         len += scnprintf(buf + len, PAGE_SIZE - len, "DateCode:\t%s\n", chbuf);
1924         len += scnprintf(buf + len, PAGE_SIZE - len, "Identifier:\t%xh\n",
1925                          (uint8_t)rdp_context->page_a0[SSF_IDENTIFIER]);
1926         len += scnprintf(buf + len, PAGE_SIZE - len, "ExtIdentifier:\t%xh\n",
1927                          (uint8_t)rdp_context->page_a0[SSF_EXT_IDENTIFIER]);
1928         len += scnprintf(buf + len, PAGE_SIZE - len, "Connector:\t%xh\n",
1929                          (uint8_t)rdp_context->page_a0[SSF_CONNECTOR]);
1930         wavelength = (rdp_context->page_a0[SSF_WAVELENGTH_B1] << 8) |
1931                       rdp_context->page_a0[SSF_WAVELENGTH_B0];
1932
1933         len += scnprintf(buf + len, PAGE_SIZE - len, "Wavelength:\t%d nm\n",
1934                          wavelength);
1935         trasn_code_byte7 = (struct sff_trasnceiver_codes_byte7 *)
1936                         &rdp_context->page_a0[SSF_TRANSCEIVER_CODE_B7];
1937
1938         len += scnprintf(buf + len, PAGE_SIZE - len, "Speeds: \t");
1939         if (*(uint8_t *)trasn_code_byte7 == 0) {
1940                 len += scnprintf(buf + len, PAGE_SIZE - len, "Unknown\n");
1941         } else {
1942                 if (trasn_code_byte7->fc_sp_100MB)
1943                         len += scnprintf(buf + len, PAGE_SIZE - len, "1 ");
1944                 if (trasn_code_byte7->fc_sp_200mb)
1945                         len += scnprintf(buf + len, PAGE_SIZE - len, "2 ");
1946                 if (trasn_code_byte7->fc_sp_400MB)
1947                         len += scnprintf(buf + len, PAGE_SIZE - len, "4 ");
1948                 if (trasn_code_byte7->fc_sp_800MB)
1949                         len += scnprintf(buf + len, PAGE_SIZE - len, "8 ");
1950                 if (trasn_code_byte7->fc_sp_1600MB)
1951                         len += scnprintf(buf + len, PAGE_SIZE - len, "16 ");
1952                 if (trasn_code_byte7->fc_sp_3200MB)
1953                         len += scnprintf(buf + len, PAGE_SIZE - len, "32 ");
1954                 if (trasn_code_byte7->speed_chk_ecc)
1955                         len += scnprintf(buf + len, PAGE_SIZE - len, "64 ");
1956                 len += scnprintf(buf + len, PAGE_SIZE - len, "GB\n");
1957         }
1958         temperature = (rdp_context->page_a2[SFF_TEMPERATURE_B1] << 8 |
1959                        rdp_context->page_a2[SFF_TEMPERATURE_B0]);
1960         vcc = (rdp_context->page_a2[SFF_VCC_B1] << 8 |
1961                rdp_context->page_a2[SFF_VCC_B0]);
1962         tx_power = (rdp_context->page_a2[SFF_TXPOWER_B1] << 8 |
1963                     rdp_context->page_a2[SFF_TXPOWER_B0]);
1964         tx_bias = (rdp_context->page_a2[SFF_TX_BIAS_CURRENT_B1] << 8 |
1965                    rdp_context->page_a2[SFF_TX_BIAS_CURRENT_B0]);
1966         rx_power = (rdp_context->page_a2[SFF_RXPOWER_B1] << 8 |
1967                     rdp_context->page_a2[SFF_RXPOWER_B0]);
1968
1969         len += scnprintf(buf + len, PAGE_SIZE - len,
1970                          "Temperature:\tx%04x C\n", temperature);
1971         len += scnprintf(buf + len, PAGE_SIZE - len, "Vcc:\t\tx%04x V\n", vcc);
1972         len += scnprintf(buf + len, PAGE_SIZE - len,
1973                          "TxBiasCurrent:\tx%04x mA\n", tx_bias);
1974         len += scnprintf(buf + len, PAGE_SIZE - len, "TxPower:\tx%04x mW\n",
1975                          tx_power);
1976         len += scnprintf(buf + len, PAGE_SIZE - len, "RxPower:\tx%04x mW\n",
1977                          rx_power);
1978 out_free_rdp:
1979         kfree(rdp_context);
1980         return len;
1981 }
1982
1983 /**
1984  * lpfc_board_mode_show - Return the state of the board
1985  * @dev: class device that is converted into a Scsi_host.
1986  * @attr: device attribute, not used.
1987  * @buf: on return contains the state of the adapter.
1988  *
1989  * Returns: size of formatted string.
1990  **/
1991 static ssize_t
1992 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
1993                      char *buf)
1994 {
1995         struct Scsi_Host  *shost = class_to_shost(dev);
1996         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1997         struct lpfc_hba   *phba = vport->phba;
1998         char  * state;
1999
2000         if (phba->link_state == LPFC_HBA_ERROR)
2001                 state = "error";
2002         else if (phba->link_state == LPFC_WARM_START)
2003                 state = "warm start";
2004         else if (phba->link_state == LPFC_INIT_START)
2005                 state = "offline";
2006         else
2007                 state = "online";
2008
2009         return scnprintf(buf, PAGE_SIZE, "%s\n", state);
2010 }
2011
2012 /**
2013  * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
2014  * @dev: class device that is converted into a Scsi_host.
2015  * @attr: device attribute, not used.
2016  * @buf: containing one of the strings "online", "offline", "warm" or "error".
2017  * @count: unused variable.
2018  *
2019  * Returns:
2020  * -EACCES if enable hba reset not enabled
2021  * -EINVAL if the buffer does not contain a valid string (see above)
2022  * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
2023  * buf length greater than zero indicates success
2024  **/
2025 static ssize_t
2026 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
2027                       const char *buf, size_t count)
2028 {
2029         struct Scsi_Host  *shost = class_to_shost(dev);
2030         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2031         struct lpfc_hba   *phba = vport->phba;
2032         struct completion online_compl;
2033         char *board_mode_str = NULL;
2034         int status = 0;
2035         int rc;
2036
2037         if (!phba->cfg_enable_hba_reset) {
2038                 status = -EACCES;
2039                 goto board_mode_out;
2040         }
2041
2042         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2043                          "3050 lpfc_board_mode set to %s\n", buf);
2044
2045         init_completion(&online_compl);
2046
2047         if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
2048                 rc = lpfc_workq_post_event(phba, &status, &online_compl,
2049                                       LPFC_EVT_ONLINE);
2050                 if (rc == 0) {
2051                         status = -ENOMEM;
2052                         goto board_mode_out;
2053                 }
2054                 wait_for_completion(&online_compl);
2055                 if (status)
2056                         status = -EIO;
2057         } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
2058                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2059         else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
2060                 if (phba->sli_rev == LPFC_SLI_REV4)
2061                         status = -EINVAL;
2062                 else
2063                         status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
2064         else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
2065                 if (phba->sli_rev == LPFC_SLI_REV4)
2066                         status = -EINVAL;
2067                 else
2068                         status = lpfc_do_offline(phba, LPFC_EVT_KILL);
2069         else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
2070                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
2071         else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
2072                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
2073         else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
2074                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
2075         else if (strncmp(buf, "pci_bus_reset", sizeof("pci_bus_reset") - 1)
2076                  == 0)
2077                 status = lpfc_reset_pci_bus(phba);
2078         else if (strncmp(buf, "heartbeat", sizeof("heartbeat") - 1) == 0)
2079                 lpfc_issue_hb_tmo(phba);
2080         else if (strncmp(buf, "trunk", sizeof("trunk") - 1) == 0)
2081                 status = lpfc_set_trunking(phba, (char *)buf + sizeof("trunk"));
2082         else
2083                 status = -EINVAL;
2084
2085 board_mode_out:
2086         if (!status)
2087                 return strlen(buf);
2088         else {
2089                 board_mode_str = strchr(buf, '\n');
2090                 if (board_mode_str)
2091                         *board_mode_str = '\0';
2092                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2093                                  "3097 Failed \"%s\", status(%d), "
2094                                  "fc_flag(x%x)\n",
2095                                  buf, status, phba->pport->fc_flag);
2096                 return status;
2097         }
2098 }
2099
2100 /**
2101  * lpfc_get_hba_info - Return various bits of informaton about the adapter
2102  * @phba: pointer to the adapter structure.
2103  * @mxri: max xri count.
2104  * @axri: available xri count.
2105  * @mrpi: max rpi count.
2106  * @arpi: available rpi count.
2107  * @mvpi: max vpi count.
2108  * @avpi: available vpi count.
2109  *
2110  * Description:
2111  * If an integer pointer for an count is not null then the value for the
2112  * count is returned.
2113  *
2114  * Returns:
2115  * zero on error
2116  * one for success
2117  **/
2118 static int
2119 lpfc_get_hba_info(struct lpfc_hba *phba,
2120                   uint32_t *mxri, uint32_t *axri,
2121                   uint32_t *mrpi, uint32_t *arpi,
2122                   uint32_t *mvpi, uint32_t *avpi)
2123 {
2124         struct lpfc_mbx_read_config *rd_config;
2125         LPFC_MBOXQ_t *pmboxq;
2126         MAILBOX_t *pmb;
2127         int rc = 0;
2128         uint32_t max_vpi;
2129
2130         /*
2131          * prevent udev from issuing mailbox commands until the port is
2132          * configured.
2133          */
2134         if (phba->link_state < LPFC_LINK_DOWN ||
2135             !phba->mbox_mem_pool ||
2136             (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
2137                 return 0;
2138
2139         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2140                 return 0;
2141
2142         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2143         if (!pmboxq)
2144                 return 0;
2145         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2146
2147         pmb = &pmboxq->u.mb;
2148         pmb->mbxCommand = MBX_READ_CONFIG;
2149         pmb->mbxOwner = OWN_HOST;
2150         pmboxq->ctx_buf = NULL;
2151
2152         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
2153                 rc = MBX_NOT_FINISHED;
2154         else
2155                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2156
2157         if (rc != MBX_SUCCESS) {
2158                 if (rc != MBX_TIMEOUT)
2159                         mempool_free(pmboxq, phba->mbox_mem_pool);
2160                 return 0;
2161         }
2162
2163         if (phba->sli_rev == LPFC_SLI_REV4) {
2164                 rd_config = &pmboxq->u.mqe.un.rd_config;
2165                 if (mrpi)
2166                         *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
2167                 if (arpi)
2168                         *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
2169                                         phba->sli4_hba.max_cfg_param.rpi_used;
2170                 if (mxri)
2171                         *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
2172                 if (axri)
2173                         *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
2174                                         phba->sli4_hba.max_cfg_param.xri_used;
2175
2176                 /* Account for differences with SLI-3.  Get vpi count from
2177                  * mailbox data and subtract one for max vpi value.
2178                  */
2179                 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
2180                         (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
2181
2182                 /* Limit the max we support */
2183                 if (max_vpi > LPFC_MAX_VPI)
2184                         max_vpi = LPFC_MAX_VPI;
2185                 if (mvpi)
2186                         *mvpi = max_vpi;
2187                 if (avpi)
2188                         *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
2189         } else {
2190                 if (mrpi)
2191                         *mrpi = pmb->un.varRdConfig.max_rpi;
2192                 if (arpi)
2193                         *arpi = pmb->un.varRdConfig.avail_rpi;
2194                 if (mxri)
2195                         *mxri = pmb->un.varRdConfig.max_xri;
2196                 if (axri)
2197                         *axri = pmb->un.varRdConfig.avail_xri;
2198                 if (mvpi)
2199                         *mvpi = pmb->un.varRdConfig.max_vpi;
2200                 if (avpi) {
2201                         /* avail_vpi is only valid if link is up and ready */
2202                         if (phba->link_state == LPFC_HBA_READY)
2203                                 *avpi = pmb->un.varRdConfig.avail_vpi;
2204                         else
2205                                 *avpi = pmb->un.varRdConfig.max_vpi;
2206                 }
2207         }
2208
2209         mempool_free(pmboxq, phba->mbox_mem_pool);
2210         return 1;
2211 }
2212
2213 /**
2214  * lpfc_max_rpi_show - Return maximum rpi
2215  * @dev: class device that is converted into a Scsi_host.
2216  * @attr: device attribute, not used.
2217  * @buf: on return contains the maximum rpi count in decimal or "Unknown".
2218  *
2219  * Description:
2220  * Calls lpfc_get_hba_info() asking for just the mrpi count.
2221  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2222  * to "Unknown" and the buffer length is returned, therefore the caller
2223  * must check for "Unknown" in the buffer to detect a failure.
2224  *
2225  * Returns: size of formatted string.
2226  **/
2227 static ssize_t
2228 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
2229                   char *buf)
2230 {
2231         struct Scsi_Host  *shost = class_to_shost(dev);
2232         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2233         struct lpfc_hba   *phba = vport->phba;
2234         uint32_t cnt;
2235
2236         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
2237                 return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2238         return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2239 }
2240
2241 /**
2242  * lpfc_used_rpi_show - Return maximum rpi minus available rpi
2243  * @dev: class device that is converted into a Scsi_host.
2244  * @attr: device attribute, not used.
2245  * @buf: containing the used rpi count in decimal or "Unknown".
2246  *
2247  * Description:
2248  * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
2249  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2250  * to "Unknown" and the buffer length is returned, therefore the caller
2251  * must check for "Unknown" in the buffer to detect a failure.
2252  *
2253  * Returns: size of formatted string.
2254  **/
2255 static ssize_t
2256 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
2257                    char *buf)
2258 {
2259         struct Scsi_Host  *shost = class_to_shost(dev);
2260         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2261         struct lpfc_hba   *phba = vport->phba;
2262         uint32_t cnt, acnt;
2263
2264         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
2265                 return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2266         return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2267 }
2268
2269 /**
2270  * lpfc_max_xri_show - Return maximum xri
2271  * @dev: class device that is converted into a Scsi_host.
2272  * @attr: device attribute, not used.
2273  * @buf: on return contains the maximum xri count in decimal or "Unknown".
2274  *
2275  * Description:
2276  * Calls lpfc_get_hba_info() asking for just the mrpi count.
2277  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2278  * to "Unknown" and the buffer length is returned, therefore the caller
2279  * must check for "Unknown" in the buffer to detect a failure.
2280  *
2281  * Returns: size of formatted string.
2282  **/
2283 static ssize_t
2284 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
2285                   char *buf)
2286 {
2287         struct Scsi_Host  *shost = class_to_shost(dev);
2288         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2289         struct lpfc_hba   *phba = vport->phba;
2290         uint32_t cnt;
2291
2292         if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
2293                 return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2294         return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2295 }
2296
2297 /**
2298  * lpfc_used_xri_show - Return maximum xpi minus the available xpi
2299  * @dev: class device that is converted into a Scsi_host.
2300  * @attr: device attribute, not used.
2301  * @buf: on return contains the used xri count in decimal or "Unknown".
2302  *
2303  * Description:
2304  * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
2305  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2306  * to "Unknown" and the buffer length is returned, therefore the caller
2307  * must check for "Unknown" in the buffer to detect a failure.
2308  *
2309  * Returns: size of formatted string.
2310  **/
2311 static ssize_t
2312 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
2313                    char *buf)
2314 {
2315         struct Scsi_Host  *shost = class_to_shost(dev);
2316         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2317         struct lpfc_hba   *phba = vport->phba;
2318         uint32_t cnt, acnt;
2319
2320         if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
2321                 return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2322         return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2323 }
2324
2325 /**
2326  * lpfc_max_vpi_show - Return maximum vpi
2327  * @dev: class device that is converted into a Scsi_host.
2328  * @attr: device attribute, not used.
2329  * @buf: on return contains the maximum vpi count in decimal or "Unknown".
2330  *
2331  * Description:
2332  * Calls lpfc_get_hba_info() asking for just the mvpi count.
2333  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2334  * to "Unknown" and the buffer length is returned, therefore the caller
2335  * must check for "Unknown" in the buffer to detect a failure.
2336  *
2337  * Returns: size of formatted string.
2338  **/
2339 static ssize_t
2340 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
2341                   char *buf)
2342 {
2343         struct Scsi_Host  *shost = class_to_shost(dev);
2344         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2345         struct lpfc_hba   *phba = vport->phba;
2346         uint32_t cnt;
2347
2348         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
2349                 return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2350         return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2351 }
2352
2353 /**
2354  * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
2355  * @dev: class device that is converted into a Scsi_host.
2356  * @attr: device attribute, not used.
2357  * @buf: on return contains the used vpi count in decimal or "Unknown".
2358  *
2359  * Description:
2360  * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
2361  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2362  * to "Unknown" and the buffer length is returned, therefore the caller
2363  * must check for "Unknown" in the buffer to detect a failure.
2364  *
2365  * Returns: size of formatted string.
2366  **/
2367 static ssize_t
2368 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
2369                    char *buf)
2370 {
2371         struct Scsi_Host  *shost = class_to_shost(dev);
2372         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2373         struct lpfc_hba   *phba = vport->phba;
2374         uint32_t cnt, acnt;
2375
2376         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
2377                 return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2378         return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2379 }
2380
2381 /**
2382  * lpfc_npiv_info_show - Return text about NPIV support for the adapter
2383  * @dev: class device that is converted into a Scsi_host.
2384  * @attr: device attribute, not used.
2385  * @buf: text that must be interpreted to determine if npiv is supported.
2386  *
2387  * Description:
2388  * Buffer will contain text indicating npiv is not suppoerted on the port,
2389  * the port is an NPIV physical port, or it is an npiv virtual port with
2390  * the id of the vport.
2391  *
2392  * Returns: size of formatted string.
2393  **/
2394 static ssize_t
2395 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
2396                     char *buf)
2397 {
2398         struct Scsi_Host  *shost = class_to_shost(dev);
2399         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2400         struct lpfc_hba   *phba = vport->phba;
2401
2402         if (!(phba->max_vpi))
2403                 return scnprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
2404         if (vport->port_type == LPFC_PHYSICAL_PORT)
2405                 return scnprintf(buf, PAGE_SIZE, "NPIV Physical\n");
2406         return scnprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
2407 }
2408
2409 /**
2410  * lpfc_poll_show - Return text about poll support for the adapter
2411  * @dev: class device that is converted into a Scsi_host.
2412  * @attr: device attribute, not used.
2413  * @buf: on return contains the cfg_poll in hex.
2414  *
2415  * Notes:
2416  * cfg_poll should be a lpfc_polling_flags type.
2417  *
2418  * Returns: size of formatted string.
2419  **/
2420 static ssize_t
2421 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
2422                char *buf)
2423 {
2424         struct Scsi_Host  *shost = class_to_shost(dev);
2425         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2426         struct lpfc_hba   *phba = vport->phba;
2427
2428         return scnprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
2429 }
2430
2431 /**
2432  * lpfc_poll_store - Set the value of cfg_poll for the adapter
2433  * @dev: class device that is converted into a Scsi_host.
2434  * @attr: device attribute, not used.
2435  * @buf: one or more lpfc_polling_flags values.
2436  * @count: not used.
2437  *
2438  * Notes:
2439  * buf contents converted to integer and checked for a valid value.
2440  *
2441  * Returns:
2442  * -EINVAL if the buffer connot be converted or is out of range
2443  * length of the buf on success
2444  **/
2445 static ssize_t
2446 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
2447                 const char *buf, size_t count)
2448 {
2449         struct Scsi_Host  *shost = class_to_shost(dev);
2450         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2451         struct lpfc_hba   *phba = vport->phba;
2452         uint32_t creg_val;
2453         uint32_t old_val;
2454         int val=0;
2455
2456         if (!isdigit(buf[0]))
2457                 return -EINVAL;
2458
2459         if (sscanf(buf, "%i", &val) != 1)
2460                 return -EINVAL;
2461
2462         if ((val & 0x3) != val)
2463                 return -EINVAL;
2464
2465         if (phba->sli_rev == LPFC_SLI_REV4)
2466                 val = 0;
2467
2468         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2469                 "3051 lpfc_poll changed from %d to %d\n",
2470                 phba->cfg_poll, val);
2471
2472         spin_lock_irq(&phba->hbalock);
2473
2474         old_val = phba->cfg_poll;
2475
2476         if (val & ENABLE_FCP_RING_POLLING) {
2477                 if ((val & DISABLE_FCP_RING_INT) &&
2478                     !(old_val & DISABLE_FCP_RING_INT)) {
2479                         if (lpfc_readl(phba->HCregaddr, &creg_val)) {
2480                                 spin_unlock_irq(&phba->hbalock);
2481                                 return -EINVAL;
2482                         }
2483                         creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
2484                         writel(creg_val, phba->HCregaddr);
2485                         readl(phba->HCregaddr); /* flush */
2486
2487                         lpfc_poll_start_timer(phba);
2488                 }
2489         } else if (val != 0x0) {
2490                 spin_unlock_irq(&phba->hbalock);
2491                 return -EINVAL;
2492         }
2493
2494         if (!(val & DISABLE_FCP_RING_INT) &&
2495             (old_val & DISABLE_FCP_RING_INT))
2496         {
2497                 spin_unlock_irq(&phba->hbalock);
2498                 del_timer(&phba->fcp_poll_timer);
2499                 spin_lock_irq(&phba->hbalock);
2500                 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
2501                         spin_unlock_irq(&phba->hbalock);
2502                         return -EINVAL;
2503                 }
2504                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
2505                 writel(creg_val, phba->HCregaddr);
2506                 readl(phba->HCregaddr); /* flush */
2507         }
2508
2509         phba->cfg_poll = val;
2510
2511         spin_unlock_irq(&phba->hbalock);
2512
2513         return strlen(buf);
2514 }
2515
2516 /**
2517  * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
2518  * @dev: class converted to a Scsi_host structure.
2519  * @attr: device attribute, not used.
2520  * @buf: on return contains the formatted support level.
2521  *
2522  * Description:
2523  * Returns the maximum number of virtual functions a physical function can
2524  * support, 0 will be returned if called on virtual function.
2525  *
2526  * Returns: size of formatted string.
2527  **/
2528 static ssize_t
2529 lpfc_sriov_hw_max_virtfn_show(struct device *dev,
2530                               struct device_attribute *attr,
2531                               char *buf)
2532 {
2533         struct Scsi_Host *shost = class_to_shost(dev);
2534         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2535         struct lpfc_hba *phba = vport->phba;
2536         uint16_t max_nr_virtfn;
2537
2538         max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
2539         return scnprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
2540 }
2541
2542 /**
2543  * lpfc_enable_bbcr_set: Sets an attribute value.
2544  * @phba: pointer to the adapter structure.
2545  * @val: integer attribute value.
2546  *
2547  * Description:
2548  * Validates the min and max values then sets the
2549  * adapter config field if in the valid range. prints error message
2550  * and does not set the parameter if invalid.
2551  *
2552  * Returns:
2553  * zero on success
2554  * -EINVAL if val is invalid
2555  */
2556 static ssize_t
2557 lpfc_enable_bbcr_set(struct lpfc_hba *phba, uint val)
2558 {
2559         if (lpfc_rangecheck(val, 0, 1) && phba->sli_rev == LPFC_SLI_REV4) {
2560                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2561                                 "3068 lpfc_enable_bbcr changed from %d to "
2562                                 "%d\n", phba->cfg_enable_bbcr, val);
2563                 phba->cfg_enable_bbcr = val;
2564                 return 0;
2565         }
2566         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2567                         "0451 lpfc_enable_bbcr cannot set to %d, range is 0, "
2568                         "1\n", val);
2569         return -EINVAL;
2570 }
2571
2572 /*
2573  * lpfc_param_show - Return a cfg attribute value in decimal
2574  *
2575  * Description:
2576  * Macro that given an attr e.g. hba_queue_depth expands
2577  * into a function with the name lpfc_hba_queue_depth_show.
2578  *
2579  * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
2580  * @dev: class device that is converted into a Scsi_host.
2581  * @attr: device attribute, not used.
2582  * @buf: on return contains the attribute value in decimal.
2583  *
2584  * Returns: size of formatted string.
2585  **/
2586 #define lpfc_param_show(attr)   \
2587 static ssize_t \
2588 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2589                    char *buf) \
2590 { \
2591         struct Scsi_Host  *shost = class_to_shost(dev);\
2592         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2593         struct lpfc_hba   *phba = vport->phba;\
2594         return scnprintf(buf, PAGE_SIZE, "%d\n",\
2595                         phba->cfg_##attr);\
2596 }
2597
2598 /*
2599  * lpfc_param_hex_show - Return a cfg attribute value in hex
2600  *
2601  * Description:
2602  * Macro that given an attr e.g. hba_queue_depth expands
2603  * into a function with the name lpfc_hba_queue_depth_show
2604  *
2605  * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
2606  * @dev: class device that is converted into a Scsi_host.
2607  * @attr: device attribute, not used.
2608  * @buf: on return contains the attribute value in hexadecimal.
2609  *
2610  * Returns: size of formatted string.
2611  **/
2612 #define lpfc_param_hex_show(attr)       \
2613 static ssize_t \
2614 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2615                    char *buf) \
2616 { \
2617         struct Scsi_Host  *shost = class_to_shost(dev);\
2618         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2619         struct lpfc_hba   *phba = vport->phba;\
2620         uint val = 0;\
2621         val = phba->cfg_##attr;\
2622         return scnprintf(buf, PAGE_SIZE, "%#x\n",\
2623                         phba->cfg_##attr);\
2624 }
2625
2626 /*
2627  * lpfc_param_init - Initializes a cfg attribute
2628  *
2629  * Description:
2630  * Macro that given an attr e.g. hba_queue_depth expands
2631  * into a function with the name lpfc_hba_queue_depth_init. The macro also
2632  * takes a default argument, a minimum and maximum argument.
2633  *
2634  * lpfc_##attr##_init: Initializes an attribute.
2635  * @phba: pointer to the adapter structure.
2636  * @val: integer attribute value.
2637  *
2638  * Validates the min and max values then sets the adapter config field
2639  * accordingly, or uses the default if out of range and prints an error message.
2640  *
2641  * Returns:
2642  * zero on success
2643  * -EINVAL if default used
2644  **/
2645 #define lpfc_param_init(attr, default, minval, maxval)  \
2646 static int \
2647 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
2648 { \
2649         if (lpfc_rangecheck(val, minval, maxval)) {\
2650                 phba->cfg_##attr = val;\
2651                 return 0;\
2652         }\
2653         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2654                         "0449 lpfc_"#attr" attribute cannot be set to %d, "\
2655                         "allowed range is ["#minval", "#maxval"]\n", val); \
2656         phba->cfg_##attr = default;\
2657         return -EINVAL;\
2658 }
2659
2660 /*
2661  * lpfc_param_set - Set a cfg attribute value
2662  *
2663  * Description:
2664  * Macro that given an attr e.g. hba_queue_depth expands
2665  * into a function with the name lpfc_hba_queue_depth_set
2666  *
2667  * lpfc_##attr##_set: Sets an attribute value.
2668  * @phba: pointer to the adapter structure.
2669  * @val: integer attribute value.
2670  *
2671  * Description:
2672  * Validates the min and max values then sets the
2673  * adapter config field if in the valid range. prints error message
2674  * and does not set the parameter if invalid.
2675  *
2676  * Returns:
2677  * zero on success
2678  * -EINVAL if val is invalid
2679  **/
2680 #define lpfc_param_set(attr, default, minval, maxval)   \
2681 static int \
2682 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
2683 { \
2684         if (lpfc_rangecheck(val, minval, maxval)) {\
2685                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2686                         "3052 lpfc_" #attr " changed from %d to %d\n", \
2687                         phba->cfg_##attr, val); \
2688                 phba->cfg_##attr = val;\
2689                 return 0;\
2690         }\
2691         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2692                         "0450 lpfc_"#attr" attribute cannot be set to %d, "\
2693                         "allowed range is ["#minval", "#maxval"]\n", val); \
2694         return -EINVAL;\
2695 }
2696
2697 /*
2698  * lpfc_param_store - Set a vport attribute value
2699  *
2700  * Description:
2701  * Macro that given an attr e.g. hba_queue_depth expands
2702  * into a function with the name lpfc_hba_queue_depth_store.
2703  *
2704  * lpfc_##attr##_store: Set an sttribute value.
2705  * @dev: class device that is converted into a Scsi_host.
2706  * @attr: device attribute, not used.
2707  * @buf: contains the attribute value in ascii.
2708  * @count: not used.
2709  *
2710  * Description:
2711  * Convert the ascii text number to an integer, then
2712  * use the lpfc_##attr##_set function to set the value.
2713  *
2714  * Returns:
2715  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2716  * length of buffer upon success.
2717  **/
2718 #define lpfc_param_store(attr)  \
2719 static ssize_t \
2720 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2721                     const char *buf, size_t count) \
2722 { \
2723         struct Scsi_Host  *shost = class_to_shost(dev);\
2724         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2725         struct lpfc_hba   *phba = vport->phba;\
2726         uint val = 0;\
2727         if (!isdigit(buf[0]))\
2728                 return -EINVAL;\
2729         if (sscanf(buf, "%i", &val) != 1)\
2730                 return -EINVAL;\
2731         if (lpfc_##attr##_set(phba, val) == 0) \
2732                 return strlen(buf);\
2733         else \
2734                 return -EINVAL;\
2735 }
2736
2737 /*
2738  * lpfc_vport_param_show - Return decimal formatted cfg attribute value
2739  *
2740  * Description:
2741  * Macro that given an attr e.g. hba_queue_depth expands
2742  * into a function with the name lpfc_hba_queue_depth_show
2743  *
2744  * lpfc_##attr##_show: prints the attribute value in decimal.
2745  * @dev: class device that is converted into a Scsi_host.
2746  * @attr: device attribute, not used.
2747  * @buf: on return contains the attribute value in decimal.
2748  *
2749  * Returns: length of formatted string.
2750  **/
2751 #define lpfc_vport_param_show(attr)     \
2752 static ssize_t \
2753 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2754                    char *buf) \
2755 { \
2756         struct Scsi_Host  *shost = class_to_shost(dev);\
2757         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2758         return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
2759 }
2760
2761 /*
2762  * lpfc_vport_param_hex_show - Return hex formatted attribute value
2763  *
2764  * Description:
2765  * Macro that given an attr e.g.
2766  * hba_queue_depth expands into a function with the name
2767  * lpfc_hba_queue_depth_show
2768  *
2769  * lpfc_##attr##_show: prints the attribute value in hexadecimal.
2770  * @dev: class device that is converted into a Scsi_host.
2771  * @attr: device attribute, not used.
2772  * @buf: on return contains the attribute value in hexadecimal.
2773  *
2774  * Returns: length of formatted string.
2775  **/
2776 #define lpfc_vport_param_hex_show(attr) \
2777 static ssize_t \
2778 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2779                    char *buf) \
2780 { \
2781         struct Scsi_Host  *shost = class_to_shost(dev);\
2782         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2783         return scnprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
2784 }
2785
2786 /*
2787  * lpfc_vport_param_init - Initialize a vport cfg attribute
2788  *
2789  * Description:
2790  * Macro that given an attr e.g. hba_queue_depth expands
2791  * into a function with the name lpfc_hba_queue_depth_init. The macro also
2792  * takes a default argument, a minimum and maximum argument.
2793  *
2794  * lpfc_##attr##_init: validates the min and max values then sets the
2795  * adapter config field accordingly, or uses the default if out of range
2796  * and prints an error message.
2797  * @phba: pointer to the adapter structure.
2798  * @val: integer attribute value.
2799  *
2800  * Returns:
2801  * zero on success
2802  * -EINVAL if default used
2803  **/
2804 #define lpfc_vport_param_init(attr, default, minval, maxval)    \
2805 static int \
2806 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
2807 { \
2808         if (lpfc_rangecheck(val, minval, maxval)) {\
2809                 vport->cfg_##attr = val;\
2810                 return 0;\
2811         }\
2812         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2813                          "0423 lpfc_"#attr" attribute cannot be set to %d, "\
2814                          "allowed range is ["#minval", "#maxval"]\n", val); \
2815         vport->cfg_##attr = default;\
2816         return -EINVAL;\
2817 }
2818
2819 /*
2820  * lpfc_vport_param_set - Set a vport cfg attribute
2821  *
2822  * Description:
2823  * Macro that given an attr e.g. hba_queue_depth expands
2824  * into a function with the name lpfc_hba_queue_depth_set
2825  *
2826  * lpfc_##attr##_set: validates the min and max values then sets the
2827  * adapter config field if in the valid range. prints error message
2828  * and does not set the parameter if invalid.
2829  * @phba: pointer to the adapter structure.
2830  * @val:        integer attribute value.
2831  *
2832  * Returns:
2833  * zero on success
2834  * -EINVAL if val is invalid
2835  **/
2836 #define lpfc_vport_param_set(attr, default, minval, maxval)     \
2837 static int \
2838 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
2839 { \
2840         if (lpfc_rangecheck(val, minval, maxval)) {\
2841                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2842                         "3053 lpfc_" #attr \
2843                         " changed from %d (x%x) to %d (x%x)\n", \
2844                         vport->cfg_##attr, vport->cfg_##attr, \
2845                         val, val); \
2846                 vport->cfg_##attr = val;\
2847                 return 0;\
2848         }\
2849         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2850                          "0424 lpfc_"#attr" attribute cannot be set to %d, "\
2851                          "allowed range is ["#minval", "#maxval"]\n", val); \
2852         return -EINVAL;\
2853 }
2854
2855 /*
2856  * lpfc_vport_param_store - Set a vport attribute
2857  *
2858  * Description:
2859  * Macro that given an attr e.g. hba_queue_depth
2860  * expands into a function with the name lpfc_hba_queue_depth_store
2861  *
2862  * lpfc_##attr##_store: convert the ascii text number to an integer, then
2863  * use the lpfc_##attr##_set function to set the value.
2864  * @cdev: class device that is converted into a Scsi_host.
2865  * @buf:        contains the attribute value in decimal.
2866  * @count: not used.
2867  *
2868  * Returns:
2869  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2870  * length of buffer upon success.
2871  **/
2872 #define lpfc_vport_param_store(attr)    \
2873 static ssize_t \
2874 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2875                     const char *buf, size_t count) \
2876 { \
2877         struct Scsi_Host  *shost = class_to_shost(dev);\
2878         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2879         uint val = 0;\
2880         if (!isdigit(buf[0]))\
2881                 return -EINVAL;\
2882         if (sscanf(buf, "%i", &val) != 1)\
2883                 return -EINVAL;\
2884         if (lpfc_##attr##_set(vport, val) == 0) \
2885                 return strlen(buf);\
2886         else \
2887                 return -EINVAL;\
2888 }
2889
2890
2891 static DEVICE_ATTR(nvme_info, 0444, lpfc_nvme_info_show, NULL);
2892 static DEVICE_ATTR(scsi_stat, 0444, lpfc_scsi_stat_show, NULL);
2893 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
2894 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
2895 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
2896 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
2897 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
2898 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
2899 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
2900 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
2901 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
2902 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
2903 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
2904 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
2905 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
2906                 lpfc_link_state_store);
2907 static DEVICE_ATTR(option_rom_version, S_IRUGO,
2908                    lpfc_option_rom_version_show, NULL);
2909 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
2910                    lpfc_num_discovered_ports_show, NULL);
2911 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
2912 static DEVICE_ATTR_RO(lpfc_drvr_version);
2913 static DEVICE_ATTR_RO(lpfc_enable_fip);
2914 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
2915                    lpfc_board_mode_show, lpfc_board_mode_store);
2916 static DEVICE_ATTR_RO(lpfc_xcvr_data);
2917 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
2918 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
2919 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
2920 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
2921 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
2922 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
2923 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
2924 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
2925 static DEVICE_ATTR_RO(lpfc_temp_sensor);
2926 static DEVICE_ATTR_RO(lpfc_sriov_hw_max_virtfn);
2927 static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
2928 static DEVICE_ATTR(lpfc_xlane_supported, S_IRUGO, lpfc_oas_supported_show,
2929                    NULL);
2930 static DEVICE_ATTR(cmf_info, 0444, lpfc_cmf_info_show, NULL);
2931
2932 #define WWN_SZ 8
2933 /**
2934  * lpfc_wwn_set - Convert string to the 8 byte WWN value.
2935  * @buf: WWN string.
2936  * @cnt: Length of string.
2937  * @wwn: Array to receive converted wwn value.
2938  *
2939  * Returns:
2940  * -EINVAL if the buffer does not contain a valid wwn
2941  * 0 success
2942  **/
2943 static size_t
2944 lpfc_wwn_set(const char *buf, size_t cnt, char wwn[])
2945 {
2946         unsigned int i, j;
2947
2948         /* Count may include a LF at end of string */
2949         if (buf[cnt-1] == '\n')
2950                 cnt--;
2951
2952         if ((cnt < 16) || (cnt > 18) || ((cnt == 17) && (*buf++ != 'x')) ||
2953             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2954                 return -EINVAL;
2955
2956         memset(wwn, 0, WWN_SZ);
2957
2958         /* Validate and store the new name */
2959         for (i = 0, j = 0; i < 16; i++) {
2960                 if ((*buf >= 'a') && (*buf <= 'f'))
2961                         j = ((j << 4) | ((*buf++ - 'a') + 10));
2962                 else if ((*buf >= 'A') && (*buf <= 'F'))
2963                         j = ((j << 4) | ((*buf++ - 'A') + 10));
2964                 else if ((*buf >= '0') && (*buf <= '9'))
2965                         j = ((j << 4) | (*buf++ - '0'));
2966                 else
2967                         return -EINVAL;
2968                 if (i % 2) {
2969                         wwn[i/2] = j & 0xff;
2970                         j = 0;
2971                 }
2972         }
2973         return 0;
2974 }
2975
2976
2977 /**
2978  * lpfc_oas_tgt_show - Return wwpn of target whose luns maybe enabled for
2979  *                    Optimized Access Storage (OAS) operations.
2980  * @dev: class device that is converted into a Scsi_host.
2981  * @attr: device attribute, not used.
2982  * @buf: buffer for passing information.
2983  *
2984  * Returns:
2985  * value of count
2986  **/
2987 static ssize_t
2988 lpfc_oas_tgt_show(struct device *dev, struct device_attribute *attr,
2989                   char *buf)
2990 {
2991         struct Scsi_Host *shost = class_to_shost(dev);
2992         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2993
2994         return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
2995                         wwn_to_u64(phba->cfg_oas_tgt_wwpn));
2996 }
2997
2998 /**
2999  * lpfc_oas_tgt_store - Store wwpn of target whose luns maybe enabled for
3000  *                    Optimized Access Storage (OAS) operations.
3001  * @dev: class device that is converted into a Scsi_host.
3002  * @attr: device attribute, not used.
3003  * @buf: buffer for passing information.
3004  * @count: Size of the data buffer.
3005  *
3006  * Returns:
3007  * -EINVAL count is invalid, invalid wwpn byte invalid
3008  * -EPERM oas is not supported by hba
3009  * value of count on success
3010  **/
3011 static ssize_t
3012 lpfc_oas_tgt_store(struct device *dev, struct device_attribute *attr,
3013                    const char *buf, size_t count)
3014 {
3015         struct Scsi_Host *shost = class_to_shost(dev);
3016         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3017         unsigned int cnt = count;
3018         uint8_t wwpn[WWN_SZ];
3019         int rc;
3020
3021         if (!phba->cfg_fof)
3022                 return -EPERM;
3023
3024         /* count may include a LF at end of string */
3025         if (buf[cnt-1] == '\n')
3026                 cnt--;
3027
3028         rc = lpfc_wwn_set(buf, cnt, wwpn);
3029         if (rc)
3030                 return rc;
3031
3032         memcpy(phba->cfg_oas_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3033         memcpy(phba->sli4_hba.oas_next_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3034         if (wwn_to_u64(wwpn) == 0)
3035                 phba->cfg_oas_flags |= OAS_FIND_ANY_TARGET;
3036         else
3037                 phba->cfg_oas_flags &= ~OAS_FIND_ANY_TARGET;
3038         phba->cfg_oas_flags &= ~OAS_LUN_VALID;
3039         phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
3040         return count;
3041 }
3042 static DEVICE_ATTR(lpfc_xlane_tgt, S_IRUGO | S_IWUSR,
3043                    lpfc_oas_tgt_show, lpfc_oas_tgt_store);
3044
3045 /**
3046  * lpfc_oas_priority_show - Return wwpn of target whose luns maybe enabled for
3047  *                    Optimized Access Storage (OAS) operations.
3048  * @dev: class device that is converted into a Scsi_host.
3049  * @attr: device attribute, not used.
3050  * @buf: buffer for passing information.
3051  *
3052  * Returns:
3053  * value of count
3054  **/
3055 static ssize_t
3056 lpfc_oas_priority_show(struct device *dev, struct device_attribute *attr,
3057                        char *buf)
3058 {
3059         struct Scsi_Host *shost = class_to_shost(dev);
3060         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3061
3062         return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
3063 }
3064
3065 /**
3066  * lpfc_oas_priority_store - Store wwpn of target whose luns maybe enabled for
3067  *                    Optimized Access Storage (OAS) operations.
3068  * @dev: class device that is converted into a Scsi_host.
3069  * @attr: device attribute, not used.
3070  * @buf: buffer for passing information.
3071  * @count: Size of the data buffer.
3072  *
3073  * Returns:
3074  * -EINVAL count is invalid, invalid wwpn byte invalid
3075  * -EPERM oas is not supported by hba
3076  * value of count on success
3077  **/
3078 static ssize_t
3079 lpfc_oas_priority_store(struct device *dev, struct device_attribute *attr,
3080                         const char *buf, size_t count)
3081 {
3082         struct Scsi_Host *shost = class_to_shost(dev);
3083         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3084         unsigned int cnt = count;
3085         unsigned long val;
3086         int ret;
3087
3088         if (!phba->cfg_fof)
3089                 return -EPERM;
3090
3091         /* count may include a LF at end of string */
3092         if (buf[cnt-1] == '\n')
3093                 cnt--;
3094
3095         ret = kstrtoul(buf, 0, &val);
3096         if (ret || (val > 0x7f))
3097                 return -EINVAL;
3098
3099         if (val)
3100                 phba->cfg_oas_priority = (uint8_t)val;
3101         else
3102                 phba->cfg_oas_priority = phba->cfg_XLanePriority;
3103         return count;
3104 }
3105 static DEVICE_ATTR(lpfc_xlane_priority, S_IRUGO | S_IWUSR,
3106                    lpfc_oas_priority_show, lpfc_oas_priority_store);
3107
3108 /**
3109  * lpfc_oas_vpt_show - Return wwpn of vport whose targets maybe enabled
3110  *                    for Optimized Access Storage (OAS) operations.
3111  * @dev: class device that is converted into a Scsi_host.
3112  * @attr: device attribute, not used.
3113  * @buf: buffer for passing information.
3114  *
3115  * Returns:
3116  * value of count on success
3117  **/
3118 static ssize_t
3119 lpfc_oas_vpt_show(struct device *dev, struct device_attribute *attr,
3120                   char *buf)
3121 {
3122         struct Scsi_Host *shost = class_to_shost(dev);
3123         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3124
3125         return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
3126                         wwn_to_u64(phba->cfg_oas_vpt_wwpn));
3127 }
3128
3129 /**
3130  * lpfc_oas_vpt_store - Store wwpn of vport whose targets maybe enabled
3131  *                    for Optimized Access Storage (OAS) operations.
3132  * @dev: class device that is converted into a Scsi_host.
3133  * @attr: device attribute, not used.
3134  * @buf: buffer for passing information.
3135  * @count: Size of the data buffer.
3136  *
3137  * Returns:
3138  * -EINVAL count is invalid, invalid wwpn byte invalid
3139  * -EPERM oas is not supported by hba
3140  * value of count on success
3141  **/
3142 static ssize_t
3143 lpfc_oas_vpt_store(struct device *dev, struct device_attribute *attr,
3144                    const char *buf, size_t count)
3145 {
3146         struct Scsi_Host *shost = class_to_shost(dev);
3147         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3148         unsigned int cnt = count;
3149         uint8_t wwpn[WWN_SZ];
3150         int rc;
3151
3152         if (!phba->cfg_fof)
3153                 return -EPERM;
3154
3155         /* count may include a LF at end of string */
3156         if (buf[cnt-1] == '\n')
3157                 cnt--;
3158
3159         rc = lpfc_wwn_set(buf, cnt, wwpn);
3160         if (rc)
3161                 return rc;
3162
3163         memcpy(phba->cfg_oas_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3164         memcpy(phba->sli4_hba.oas_next_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3165         if (wwn_to_u64(wwpn) == 0)
3166                 phba->cfg_oas_flags |= OAS_FIND_ANY_VPORT;
3167         else
3168                 phba->cfg_oas_flags &= ~OAS_FIND_ANY_VPORT;
3169         phba->cfg_oas_flags &= ~OAS_LUN_VALID;
3170         if (phba->cfg_oas_priority == 0)
3171                 phba->cfg_oas_priority = phba->cfg_XLanePriority;
3172         phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
3173         return count;
3174 }
3175 static DEVICE_ATTR(lpfc_xlane_vpt, S_IRUGO | S_IWUSR,
3176                    lpfc_oas_vpt_show, lpfc_oas_vpt_store);
3177
3178 /**
3179  * lpfc_oas_lun_state_show - Return the current state (enabled or disabled)
3180  *                          of whether luns will be enabled or disabled
3181  *                          for Optimized Access Storage (OAS) operations.
3182  * @dev: class device that is converted into a Scsi_host.
3183  * @attr: device attribute, not used.
3184  * @buf: buffer for passing information.
3185  *
3186  * Returns:
3187  * size of formatted string.
3188  **/
3189 static ssize_t
3190 lpfc_oas_lun_state_show(struct device *dev, struct device_attribute *attr,
3191                         char *buf)
3192 {
3193         struct Scsi_Host *shost = class_to_shost(dev);
3194         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3195
3196         return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
3197 }
3198
3199 /**
3200  * lpfc_oas_lun_state_store - Store the state (enabled or disabled)
3201  *                          of whether luns will be enabled or disabled
3202  *                          for Optimized Access Storage (OAS) operations.
3203  * @dev: class device that is converted into a Scsi_host.
3204  * @attr: device attribute, not used.
3205  * @buf: buffer for passing information.
3206  * @count: Size of the data buffer.
3207  *
3208  * Returns:
3209  * -EINVAL count is invalid, invalid wwpn byte invalid
3210  * -EPERM oas is not supported by hba
3211  * value of count on success
3212  **/
3213 static ssize_t
3214 lpfc_oas_lun_state_store(struct device *dev, struct device_attribute *attr,
3215                          const char *buf, size_t count)
3216 {
3217         struct Scsi_Host *shost = class_to_shost(dev);
3218         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3219         int val = 0;
3220
3221         if (!phba->cfg_fof)
3222                 return -EPERM;
3223
3224         if (!isdigit(buf[0]))
3225                 return -EINVAL;
3226
3227         if (sscanf(buf, "%i", &val) != 1)
3228                 return -EINVAL;
3229
3230         if ((val != 0) && (val != 1))
3231                 return -EINVAL;
3232
3233         phba->cfg_oas_lun_state = val;
3234         return strlen(buf);
3235 }
3236 static DEVICE_ATTR(lpfc_xlane_lun_state, S_IRUGO | S_IWUSR,
3237                    lpfc_oas_lun_state_show, lpfc_oas_lun_state_store);
3238
3239 /**
3240  * lpfc_oas_lun_status_show - Return the status of the Optimized Access
3241  *                          Storage (OAS) lun returned by the
3242  *                          lpfc_oas_lun_show function.
3243  * @dev: class device that is converted into a Scsi_host.
3244  * @attr: device attribute, not used.
3245  * @buf: buffer for passing information.
3246  *
3247  * Returns:
3248  * size of formatted string.
3249  **/
3250 static ssize_t
3251 lpfc_oas_lun_status_show(struct device *dev, struct device_attribute *attr,
3252                          char *buf)
3253 {
3254         struct Scsi_Host *shost = class_to_shost(dev);
3255         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3256
3257         if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
3258                 return -EFAULT;
3259
3260         return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
3261 }
3262 static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
3263                    lpfc_oas_lun_status_show, NULL);
3264
3265
3266 /**
3267  * lpfc_oas_lun_state_set - enable or disable a lun for Optimized Access Storage
3268  *                         (OAS) operations.
3269  * @phba: lpfc_hba pointer.
3270  * @vpt_wwpn: wwpn of the vport associated with the returned lun
3271  * @tgt_wwpn: wwpn of the target associated with the returned lun
3272  * @lun: the fc lun for setting oas state.
3273  * @oas_state: the oas state to be set to the lun.
3274  * @pri: priority
3275  *
3276  * Returns:
3277  * SUCCESS : 0
3278  * -EPERM OAS is not enabled or not supported by this port.
3279  *
3280  */
3281 static size_t
3282 lpfc_oas_lun_state_set(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3283                        uint8_t tgt_wwpn[], uint64_t lun,
3284                        uint32_t oas_state, uint8_t pri)
3285 {
3286
3287         int rc = 0;
3288
3289         if (!phba->cfg_fof)
3290                 return -EPERM;
3291
3292         if (oas_state) {
3293                 if (!lpfc_enable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3294                                          (struct lpfc_name *)tgt_wwpn,
3295                                          lun, pri))
3296                         rc = -ENOMEM;
3297         } else {
3298                 lpfc_disable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3299                                      (struct lpfc_name *)tgt_wwpn, lun, pri);
3300         }
3301         return rc;
3302
3303 }
3304
3305 /**
3306  * lpfc_oas_lun_get_next - get the next lun that has been enabled for Optimized
3307  *                        Access Storage (OAS) operations.
3308  * @phba: lpfc_hba pointer.
3309  * @vpt_wwpn: wwpn of the vport associated with the returned lun
3310  * @tgt_wwpn: wwpn of the target associated with the returned lun
3311  * @lun_status: status of the lun returned lun
3312  * @lun_pri: priority of the lun returned lun
3313  *
3314  * Returns the first or next lun enabled for OAS operations for the vport/target
3315  * specified.  If a lun is found, its vport wwpn, target wwpn and status is
3316  * returned.  If the lun is not found, NOT_OAS_ENABLED_LUN is returned.
3317  *
3318  * Return:
3319  * lun that is OAS enabled for the vport/target
3320  * NOT_OAS_ENABLED_LUN when no oas enabled lun found.
3321  */
3322 static uint64_t
3323 lpfc_oas_lun_get_next(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3324                       uint8_t tgt_wwpn[], uint32_t *lun_status,
3325                       uint32_t *lun_pri)
3326 {
3327         uint64_t found_lun;
3328
3329         if (unlikely(!phba) || !vpt_wwpn || !tgt_wwpn)
3330                 return NOT_OAS_ENABLED_LUN;
3331         if (lpfc_find_next_oas_lun(phba, (struct lpfc_name *)
3332                                    phba->sli4_hba.oas_next_vpt_wwpn,
3333                                    (struct lpfc_name *)
3334                                    phba->sli4_hba.oas_next_tgt_wwpn,
3335                                    &phba->sli4_hba.oas_next_lun,
3336                                    (struct lpfc_name *)vpt_wwpn,
3337                                    (struct lpfc_name *)tgt_wwpn,
3338                                    &found_lun, lun_status, lun_pri))
3339                 return found_lun;
3340         else
3341                 return NOT_OAS_ENABLED_LUN;
3342 }
3343
3344 /**
3345  * lpfc_oas_lun_state_change - enable/disable a lun for OAS operations
3346  * @phba: lpfc_hba pointer.
3347  * @vpt_wwpn: vport wwpn by reference.
3348  * @tgt_wwpn: target wwpn by reference.
3349  * @lun: the fc lun for setting oas state.
3350  * @oas_state: the oas state to be set to the oas_lun.
3351  * @pri: priority
3352  *
3353  * This routine enables (OAS_LUN_ENABLE) or disables (OAS_LUN_DISABLE)
3354  * a lun for OAS operations.
3355  *
3356  * Return:
3357  * SUCCESS: 0
3358  * -ENOMEM: failed to enable an lun for OAS operations
3359  * -EPERM: OAS is not enabled
3360  */
3361 static ssize_t
3362 lpfc_oas_lun_state_change(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3363                           uint8_t tgt_wwpn[], uint64_t lun,
3364                           uint32_t oas_state, uint8_t pri)
3365 {
3366
3367         int rc;
3368
3369         rc = lpfc_oas_lun_state_set(phba, vpt_wwpn, tgt_wwpn, lun,
3370                                     oas_state, pri);
3371         return rc;
3372 }
3373
3374 /**
3375  * lpfc_oas_lun_show - Return oas enabled luns from a chosen target
3376  * @dev: class device that is converted into a Scsi_host.
3377  * @attr: device attribute, not used.
3378  * @buf: buffer for passing information.
3379  *
3380  * This routine returns a lun enabled for OAS each time the function
3381  * is called.
3382  *
3383  * Returns:
3384  * SUCCESS: size of formatted string.
3385  * -EFAULT: target or vport wwpn was not set properly.
3386  * -EPERM: oas is not enabled.
3387  **/
3388 static ssize_t
3389 lpfc_oas_lun_show(struct device *dev, struct device_attribute *attr,
3390                   char *buf)
3391 {
3392         struct Scsi_Host *shost = class_to_shost(dev);
3393         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3394
3395         uint64_t oas_lun;
3396         int len = 0;
3397
3398         if (!phba->cfg_fof)
3399                 return -EPERM;
3400
3401         if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3402                 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_VPORT))
3403                         return -EFAULT;
3404
3405         if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3406                 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_TARGET))
3407                         return -EFAULT;
3408
3409         oas_lun = lpfc_oas_lun_get_next(phba, phba->cfg_oas_vpt_wwpn,
3410                                         phba->cfg_oas_tgt_wwpn,
3411                                         &phba->cfg_oas_lun_status,
3412                                         &phba->cfg_oas_priority);
3413         if (oas_lun != NOT_OAS_ENABLED_LUN)
3414                 phba->cfg_oas_flags |= OAS_LUN_VALID;
3415
3416         len += scnprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
3417
3418         return len;
3419 }
3420
3421 /**
3422  * lpfc_oas_lun_store - Sets the OAS state for lun
3423  * @dev: class device that is converted into a Scsi_host.
3424  * @attr: device attribute, not used.
3425  * @buf: buffer for passing information.
3426  * @count: size of the formatting string
3427  *
3428  * This function sets the OAS state for lun.  Before this function is called,
3429  * the vport wwpn, target wwpn, and oas state need to be set.
3430  *
3431  * Returns:
3432  * SUCCESS: size of formatted string.
3433  * -EFAULT: target or vport wwpn was not set properly.
3434  * -EPERM: oas is not enabled.
3435  * size of formatted string.
3436  **/
3437 static ssize_t
3438 lpfc_oas_lun_store(struct device *dev, struct device_attribute *attr,
3439                    const char *buf, size_t count)
3440 {
3441         struct Scsi_Host *shost = class_to_shost(dev);
3442         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3443         uint64_t scsi_lun;
3444         uint32_t pri;
3445         ssize_t rc;
3446
3447         if (!phba->cfg_fof)
3448                 return -EPERM;
3449
3450         if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3451                 return -EFAULT;
3452
3453         if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3454                 return -EFAULT;
3455
3456         if (!isdigit(buf[0]))
3457                 return -EINVAL;
3458
3459         if (sscanf(buf, "0x%llx", &scsi_lun) != 1)
3460                 return -EINVAL;
3461
3462         pri = phba->cfg_oas_priority;
3463         if (pri == 0)
3464                 pri = phba->cfg_XLanePriority;
3465
3466         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3467                         "3372 Try to set vport 0x%llx target 0x%llx lun:0x%llx "
3468                         "priority 0x%x with oas state %d\n",
3469                         wwn_to_u64(phba->cfg_oas_vpt_wwpn),
3470                         wwn_to_u64(phba->cfg_oas_tgt_wwpn), scsi_lun,
3471                         pri, phba->cfg_oas_lun_state);
3472
3473         rc = lpfc_oas_lun_state_change(phba, phba->cfg_oas_vpt_wwpn,
3474                                        phba->cfg_oas_tgt_wwpn, scsi_lun,
3475                                        phba->cfg_oas_lun_state, pri);
3476         if (rc)
3477                 return rc;
3478
3479         return count;
3480 }
3481 static DEVICE_ATTR(lpfc_xlane_lun, S_IRUGO | S_IWUSR,
3482                    lpfc_oas_lun_show, lpfc_oas_lun_store);
3483
3484 int lpfc_enable_nvmet_cnt;
3485 unsigned long long lpfc_enable_nvmet[LPFC_NVMET_MAX_PORTS] = {
3486         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3487         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3488 module_param_array(lpfc_enable_nvmet, ullong, &lpfc_enable_nvmet_cnt, 0444);
3489 MODULE_PARM_DESC(lpfc_enable_nvmet, "Enable HBA port(s) WWPN as a NVME Target");
3490
3491 static int lpfc_poll = 0;
3492 module_param(lpfc_poll, int, S_IRUGO);
3493 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
3494                  " 0 - none,"
3495                  " 1 - poll with interrupts enabled"
3496                  " 3 - poll and disable FCP ring interrupts");
3497
3498 static DEVICE_ATTR_RW(lpfc_poll);
3499
3500 int lpfc_no_hba_reset_cnt;
3501 unsigned long lpfc_no_hba_reset[MAX_HBAS_NO_RESET] = {
3502         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3503 module_param_array(lpfc_no_hba_reset, ulong, &lpfc_no_hba_reset_cnt, 0444);
3504 MODULE_PARM_DESC(lpfc_no_hba_reset, "WWPN of HBAs that should not be reset");
3505
3506 LPFC_ATTR(sli_mode, 3, 3, 3,
3507         "SLI mode selector: 3 - select SLI-3");
3508
3509 LPFC_ATTR_R(enable_npiv, 1, 0, 1,
3510         "Enable NPIV functionality");
3511
3512 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
3513         "FCF Fast failover=1 Priority failover=2");
3514
3515 /*
3516  * lpfc_fcp_wait_abts_rsp: Modifies criteria for reporting completion of
3517  * aborted IO.
3518  * The range is [0,1]. Default value is 0
3519  *      0, IO completes after ABTS issued (default).
3520  *      1, IO completes after receipt of ABTS response or timeout.
3521  */
3522 LPFC_ATTR_R(fcp_wait_abts_rsp, 0, 0, 1, "Wait for FCP ABTS completion");
3523
3524 /*
3525 # lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
3526 #       0x0 = disabled, XRI/OXID use not tracked.
3527 #       0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
3528 #       0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
3529 */
3530 LPFC_ATTR_R(enable_rrq, 2, 0, 2,
3531         "Enable RRQ functionality");
3532
3533 /*
3534 # lpfc_suppress_link_up:  Bring link up at initialization
3535 #            0x0  = bring link up (issue MBX_INIT_LINK)
3536 #            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
3537 #            0x2  = never bring up link
3538 # Default value is 0.
3539 */
3540 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
3541                 LPFC_DELAY_INIT_LINK_INDEFINITELY,
3542                 "Suppress Link Up at initialization");
3543
3544 static ssize_t
3545 lpfc_pls_show(struct device *dev, struct device_attribute *attr, char *buf)
3546 {
3547         struct Scsi_Host  *shost = class_to_shost(dev);
3548         struct lpfc_hba   *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3549
3550         return scnprintf(buf, PAGE_SIZE, "%d\n",
3551                          phba->sli4_hba.pc_sli4_params.pls);
3552 }
3553 static DEVICE_ATTR(pls, 0444,
3554                          lpfc_pls_show, NULL);
3555
3556 static ssize_t
3557 lpfc_pt_show(struct device *dev, struct device_attribute *attr, char *buf)
3558 {
3559         struct Scsi_Host  *shost = class_to_shost(dev);
3560         struct lpfc_hba   *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3561
3562         return scnprintf(buf, PAGE_SIZE, "%d\n",
3563                          (phba->hba_flag & HBA_PERSISTENT_TOPO) ? 1 : 0);
3564 }
3565 static DEVICE_ATTR(pt, 0444,
3566                          lpfc_pt_show, NULL);
3567
3568 /*
3569 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
3570 #       1 - (1024)
3571 #       2 - (2048)
3572 #       3 - (3072)
3573 #       4 - (4096)
3574 #       5 - (5120)
3575 */
3576 static ssize_t
3577 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3578 {
3579         struct Scsi_Host  *shost = class_to_shost(dev);
3580         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3581
3582         return scnprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
3583 }
3584
3585 static DEVICE_ATTR(iocb_hw, S_IRUGO,
3586                          lpfc_iocb_hw_show, NULL);
3587 static ssize_t
3588 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3589 {
3590         struct Scsi_Host  *shost = class_to_shost(dev);
3591         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3592         struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3593
3594         return scnprintf(buf, PAGE_SIZE, "%d\n",
3595                         pring ? pring->txq_max : 0);
3596 }
3597
3598 static DEVICE_ATTR(txq_hw, S_IRUGO,
3599                          lpfc_txq_hw_show, NULL);
3600 static ssize_t
3601 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
3602  char *buf)
3603 {
3604         struct Scsi_Host  *shost = class_to_shost(dev);
3605         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3606         struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3607
3608         return scnprintf(buf, PAGE_SIZE, "%d\n",
3609                         pring ? pring->txcmplq_max : 0);
3610 }
3611
3612 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
3613                          lpfc_txcmplq_hw_show, NULL);
3614
3615 /*
3616 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
3617 # until the timer expires. Value range is [0,255]. Default value is 30.
3618 */
3619 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3620 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
3621 module_param(lpfc_nodev_tmo, int, 0);
3622 MODULE_PARM_DESC(lpfc_nodev_tmo,
3623                  "Seconds driver will hold I/O waiting "
3624                  "for a device to come back");
3625
3626 /**
3627  * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
3628  * @dev: class converted to a Scsi_host structure.
3629  * @attr: device attribute, not used.
3630  * @buf: on return contains the dev loss timeout in decimal.
3631  *
3632  * Returns: size of formatted string.
3633  **/
3634 static ssize_t
3635 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
3636                     char *buf)
3637 {
3638         struct Scsi_Host  *shost = class_to_shost(dev);
3639         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3640
3641         return scnprintf(buf, PAGE_SIZE, "%d\n",        vport->cfg_devloss_tmo);
3642 }
3643
3644 /**
3645  * lpfc_nodev_tmo_init - Set the hba nodev timeout value
3646  * @vport: lpfc vport structure pointer.
3647  * @val: contains the nodev timeout value.
3648  *
3649  * Description:
3650  * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
3651  * a kernel error message is printed and zero is returned.
3652  * Else if val is in range then nodev tmo and devloss tmo are set to val.
3653  * Otherwise nodev tmo is set to the default value.
3654  *
3655  * Returns:
3656  * zero if already set or if val is in range
3657  * -EINVAL val out of range
3658  **/
3659 static int
3660 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
3661 {
3662         if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
3663                 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
3664                 if (val != LPFC_DEF_DEVLOSS_TMO)
3665                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3666                                          "0407 Ignoring lpfc_nodev_tmo module "
3667                                          "parameter because lpfc_devloss_tmo "
3668                                          "is set.\n");
3669                 return 0;
3670         }
3671
3672         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3673                 vport->cfg_nodev_tmo = val;
3674                 vport->cfg_devloss_tmo = val;
3675                 return 0;
3676         }
3677         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3678                          "0400 lpfc_nodev_tmo attribute cannot be set to"
3679                          " %d, allowed range is [%d, %d]\n",
3680                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3681         vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3682         return -EINVAL;
3683 }
3684
3685 /**
3686  * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
3687  * @vport: lpfc vport structure pointer.
3688  *
3689  * Description:
3690  * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
3691  **/
3692 static void
3693 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
3694 {
3695         struct Scsi_Host  *shost;
3696         struct lpfc_nodelist  *ndlp;
3697 #if (IS_ENABLED(CONFIG_NVME_FC))
3698         struct lpfc_nvme_rport *rport;
3699         struct nvme_fc_remote_port *remoteport = NULL;
3700 #endif
3701
3702         shost = lpfc_shost_from_vport(vport);
3703         spin_lock_irq(shost->host_lock);
3704         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3705                 if (ndlp->rport)
3706                         ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
3707 #if (IS_ENABLED(CONFIG_NVME_FC))
3708                 spin_lock(&ndlp->lock);
3709                 rport = lpfc_ndlp_get_nrport(ndlp);
3710                 if (rport)
3711                         remoteport = rport->remoteport;
3712                 spin_unlock(&ndlp->lock);
3713                 if (rport && remoteport)
3714                         nvme_fc_set_remoteport_devloss(remoteport,
3715                                                        vport->cfg_devloss_tmo);
3716 #endif
3717         }
3718         spin_unlock_irq(shost->host_lock);
3719 }
3720
3721 /**
3722  * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
3723  * @vport: lpfc vport structure pointer.
3724  * @val: contains the tmo value.
3725  *
3726  * Description:
3727  * If the devloss tmo is already set or the vport dev loss tmo has changed
3728  * then a kernel error message is printed and zero is returned.
3729  * Else if val is in range then nodev tmo and devloss tmo are set to val.
3730  * Otherwise nodev tmo is set to the default value.
3731  *
3732  * Returns:
3733  * zero if already set or if val is in range
3734  * -EINVAL val out of range
3735  **/
3736 static int
3737 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
3738 {
3739         if (vport->dev_loss_tmo_changed ||
3740             (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
3741                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3742                                  "0401 Ignoring change to lpfc_nodev_tmo "
3743                                  "because lpfc_devloss_tmo is set.\n");
3744                 return 0;
3745         }
3746         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3747                 vport->cfg_nodev_tmo = val;
3748                 vport->cfg_devloss_tmo = val;
3749                 /*
3750                  * For compat: set the fc_host dev loss so new rports
3751                  * will get the value.
3752                  */
3753                 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3754                 lpfc_update_rport_devloss_tmo(vport);
3755                 return 0;
3756         }
3757         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3758                          "0403 lpfc_nodev_tmo attribute cannot be set to "
3759                          "%d, allowed range is [%d, %d]\n",
3760                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3761         return -EINVAL;
3762 }
3763
3764 lpfc_vport_param_store(nodev_tmo)
3765
3766 static DEVICE_ATTR_RW(lpfc_nodev_tmo);
3767
3768 /*
3769 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
3770 # disappear until the timer expires. Value range is [0,255]. Default
3771 # value is 30.
3772 */
3773 module_param(lpfc_devloss_tmo, int, S_IRUGO);
3774 MODULE_PARM_DESC(lpfc_devloss_tmo,
3775                  "Seconds driver will hold I/O waiting "
3776                  "for a device to come back");
3777 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
3778                       LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
3779 lpfc_vport_param_show(devloss_tmo)
3780
3781 /**
3782  * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
3783  * @vport: lpfc vport structure pointer.
3784  * @val: contains the tmo value.
3785  *
3786  * Description:
3787  * If val is in a valid range then set the vport nodev tmo,
3788  * devloss tmo, also set the vport dev loss tmo changed flag.
3789  * Else a kernel error message is printed.
3790  *
3791  * Returns:
3792  * zero if val is in range
3793  * -EINVAL val out of range
3794  **/
3795 static int
3796 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
3797 {
3798         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3799                 vport->cfg_nodev_tmo = val;
3800                 vport->cfg_devloss_tmo = val;
3801                 vport->dev_loss_tmo_changed = 1;
3802                 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3803                 lpfc_update_rport_devloss_tmo(vport);
3804                 return 0;
3805         }
3806
3807         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3808                          "0404 lpfc_devloss_tmo attribute cannot be set to "
3809                          "%d, allowed range is [%d, %d]\n",
3810                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3811         return -EINVAL;
3812 }
3813
3814 lpfc_vport_param_store(devloss_tmo)
3815 static DEVICE_ATTR_RW(lpfc_devloss_tmo);
3816
3817 /*
3818  * lpfc_suppress_rsp: Enable suppress rsp feature is firmware supports it
3819  * lpfc_suppress_rsp = 0  Disable
3820  * lpfc_suppress_rsp = 1  Enable (default)
3821  *
3822  */
3823 LPFC_ATTR_R(suppress_rsp, 1, 0, 1,
3824             "Enable suppress rsp feature is firmware supports it");
3825
3826 /*
3827  * lpfc_nvmet_mrq: Specify number of RQ pairs for processing NVMET cmds
3828  * lpfc_nvmet_mrq = 0  driver will calcualte optimal number of RQ pairs
3829  * lpfc_nvmet_mrq = 1  use a single RQ pair
3830  * lpfc_nvmet_mrq >= 2  use specified RQ pairs for MRQ
3831  *
3832  */
3833 LPFC_ATTR_R(nvmet_mrq,
3834             LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_MAX,
3835             "Specify number of RQ pairs for processing NVMET cmds");
3836
3837 /*
3838  * lpfc_nvmet_mrq_post: Specify number of RQ buffer to initially post
3839  * to each NVMET RQ. Range 64 to 2048, default is 512.
3840  */
3841 LPFC_ATTR_R(nvmet_mrq_post,
3842             LPFC_NVMET_RQE_DEF_POST, LPFC_NVMET_RQE_MIN_POST,
3843             LPFC_NVMET_RQE_DEF_COUNT,
3844             "Specify number of RQ buffers to initially post");
3845
3846 /*
3847  * lpfc_enable_fc4_type: Defines what FC4 types are supported.
3848  * Supported Values:  1 - register just FCP
3849  *                    3 - register both FCP and NVME
3850  * Supported values are [1,3]. Default value is 3
3851  */
3852 LPFC_ATTR_R(enable_fc4_type, LPFC_DEF_ENBL_FC4_TYPE,
3853             LPFC_ENABLE_FCP, LPFC_MAX_ENBL_FC4_TYPE,
3854             "Enable FC4 Protocol support - FCP / NVME");
3855
3856 /*
3857 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
3858 # deluged with LOTS of information.
3859 # You can set a bit mask to record specific types of verbose messages:
3860 # See lpfc_logmsh.h for definitions.
3861 */
3862 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
3863                        "Verbose logging bit-mask");
3864
3865 /*
3866 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
3867 # objects that have been registered with the nameserver after login.
3868 */
3869 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
3870                   "Deregister nameserver objects before LOGO");
3871
3872 /*
3873 # lun_queue_depth:  This parameter is used to limit the number of outstanding
3874 # commands per FCP LUN.
3875 */
3876 LPFC_VPORT_ATTR_R(lun_queue_depth, 64, 1, 512,
3877                   "Max number of FCP commands we can queue to a specific LUN");
3878
3879 /*
3880 # tgt_queue_depth:  This parameter is used to limit the number of outstanding
3881 # commands per target port. Value range is [10,65535]. Default value is 65535.
3882 */
3883 static uint lpfc_tgt_queue_depth = LPFC_MAX_TGT_QDEPTH;
3884 module_param(lpfc_tgt_queue_depth, uint, 0444);
3885 MODULE_PARM_DESC(lpfc_tgt_queue_depth, "Set max Target queue depth");
3886 lpfc_vport_param_show(tgt_queue_depth);
3887 lpfc_vport_param_init(tgt_queue_depth, LPFC_MAX_TGT_QDEPTH,
3888                       LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH);
3889
3890 /**
3891  * lpfc_tgt_queue_depth_set: Sets an attribute value.
3892  * @vport: lpfc vport structure pointer.
3893  * @val: integer attribute value.
3894  *
3895  * Description: Sets the parameter to the new value.
3896  *
3897  * Returns:
3898  * zero on success
3899  * -EINVAL if val is invalid
3900  */
3901 static int
3902 lpfc_tgt_queue_depth_set(struct lpfc_vport *vport, uint val)
3903 {
3904         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3905         struct lpfc_nodelist *ndlp;
3906
3907         if (!lpfc_rangecheck(val, LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH))
3908                 return -EINVAL;
3909
3910         if (val == vport->cfg_tgt_queue_depth)
3911                 return 0;
3912
3913         spin_lock_irq(shost->host_lock);
3914         vport->cfg_tgt_queue_depth = val;
3915
3916         /* Next loop thru nodelist and change cmd_qdepth */
3917         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
3918                 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
3919
3920         spin_unlock_irq(shost->host_lock);
3921         return 0;
3922 }
3923
3924 lpfc_vport_param_store(tgt_queue_depth);
3925 static DEVICE_ATTR_RW(lpfc_tgt_queue_depth);
3926
3927 /*
3928 # hba_queue_depth:  This parameter is used to limit the number of outstanding
3929 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
3930 # value is greater than the maximum number of exchanges supported by the HBA,
3931 # then maximum number of exchanges supported by the HBA is used to determine
3932 # the hba_queue_depth.
3933 */
3934 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
3935             "Max number of FCP commands we can queue to a lpfc HBA");
3936
3937 /*
3938 # peer_port_login:  This parameter allows/prevents logins
3939 # between peer ports hosted on the same physical port.
3940 # When this parameter is set 0 peer ports of same physical port
3941 # are not allowed to login to each other.
3942 # When this parameter is set 1 peer ports of same physical port
3943 # are allowed to login to each other.
3944 # Default value of this parameter is 0.
3945 */
3946 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
3947                   "Allow peer ports on the same physical port to login to each "
3948                   "other.");
3949
3950 /*
3951 # restrict_login:  This parameter allows/prevents logins
3952 # between Virtual Ports and remote initiators.
3953 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
3954 # other initiators and will attempt to PLOGI all remote ports.
3955 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
3956 # remote ports and will not attempt to PLOGI to other initiators.
3957 # This parameter does not restrict to the physical port.
3958 # This parameter does not restrict logins to Fabric resident remote ports.
3959 # Default value of this parameter is 1.
3960 */
3961 static int lpfc_restrict_login = 1;
3962 module_param(lpfc_restrict_login, int, S_IRUGO);
3963 MODULE_PARM_DESC(lpfc_restrict_login,
3964                  "Restrict virtual ports login to remote initiators.");
3965 lpfc_vport_param_show(restrict_login);
3966
3967 /**
3968  * lpfc_restrict_login_init - Set the vport restrict login flag
3969  * @vport: lpfc vport structure pointer.
3970  * @val: contains the restrict login value.
3971  *
3972  * Description:
3973  * If val is not in a valid range then log a kernel error message and set
3974  * the vport restrict login to one.
3975  * If the port type is physical clear the restrict login flag and return.
3976  * Else set the restrict login flag to val.
3977  *
3978  * Returns:
3979  * zero if val is in range
3980  * -EINVAL val out of range
3981  **/
3982 static int
3983 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
3984 {
3985         if (val < 0 || val > 1) {
3986                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3987                                  "0422 lpfc_restrict_login attribute cannot "
3988                                  "be set to %d, allowed range is [0, 1]\n",
3989                                  val);
3990                 vport->cfg_restrict_login = 1;
3991                 return -EINVAL;
3992         }
3993         if (vport->port_type == LPFC_PHYSICAL_PORT) {
3994                 vport->cfg_restrict_login = 0;
3995                 return 0;
3996         }
3997         vport->cfg_restrict_login = val;
3998         return 0;
3999 }
4000
4001 /**
4002  * lpfc_restrict_login_set - Set the vport restrict login flag
4003  * @vport: lpfc vport structure pointer.
4004  * @val: contains the restrict login value.
4005  *
4006  * Description:
4007  * If val is not in a valid range then log a kernel error message and set
4008  * the vport restrict login to one.
4009  * If the port type is physical and the val is not zero log a kernel
4010  * error message, clear the restrict login flag and return zero.
4011  * Else set the restrict login flag to val.
4012  *
4013  * Returns:
4014  * zero if val is in range
4015  * -EINVAL val out of range
4016  **/
4017 static int
4018 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
4019 {
4020         if (val < 0 || val > 1) {
4021                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4022                                  "0425 lpfc_restrict_login attribute cannot "
4023                                  "be set to %d, allowed range is [0, 1]\n",
4024                                  val);
4025                 vport->cfg_restrict_login = 1;
4026                 return -EINVAL;
4027         }
4028         if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
4029                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4030                                  "0468 lpfc_restrict_login must be 0 for "
4031                                  "Physical ports.\n");
4032                 vport->cfg_restrict_login = 0;
4033                 return 0;
4034         }
4035         vport->cfg_restrict_login = val;
4036         return 0;
4037 }
4038 lpfc_vport_param_store(restrict_login);
4039 static DEVICE_ATTR_RW(lpfc_restrict_login);
4040
4041 /*
4042 # Some disk devices have a "select ID" or "select Target" capability.
4043 # From a protocol standpoint "select ID" usually means select the
4044 # Fibre channel "ALPA".  In the FC-AL Profile there is an "informative
4045 # annex" which contains a table that maps a "select ID" (a number
4046 # between 0 and 7F) to an ALPA.  By default, for compatibility with
4047 # older drivers, the lpfc driver scans this table from low ALPA to high
4048 # ALPA.
4049 #
4050 # Turning on the scan-down variable (on  = 1, off = 0) will
4051 # cause the lpfc driver to use an inverted table, effectively
4052 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
4053 #
4054 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
4055 # and will not work across a fabric. Also this parameter will take
4056 # effect only in the case when ALPA map is not available.)
4057 */
4058 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
4059                   "Start scanning for devices from highest ALPA to lowest");
4060
4061 /*
4062 # lpfc_topology:  link topology for init link
4063 #            0x0  = attempt loop mode then point-to-point
4064 #            0x01 = internal loopback mode
4065 #            0x02 = attempt point-to-point mode only
4066 #            0x04 = attempt loop mode only
4067 #            0x06 = attempt point-to-point mode then loop
4068 # Set point-to-point mode if you want to run as an N_Port.
4069 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
4070 # Default value is 0.
4071 */
4072 LPFC_ATTR(topology, 0, 0, 6,
4073         "Select Fibre Channel topology");
4074
4075 /**
4076  * lpfc_topology_store - Set the adapters topology field
4077  * @dev: class device that is converted into a scsi_host.
4078  * @attr:device attribute, not used.
4079  * @buf: buffer for passing information.
4080  * @count: size of the data buffer.
4081  *
4082  * Description:
4083  * If val is in a valid range then set the adapter's topology field and
4084  * issue a lip; if the lip fails reset the topology to the old value.
4085  *
4086  * If the value is not in range log a kernel error message and return an error.
4087  *
4088  * Returns:
4089  * zero if val is in range and lip okay
4090  * non-zero return value from lpfc_issue_lip()
4091  * -EINVAL val out of range
4092  **/
4093 static ssize_t
4094 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
4095                         const char *buf, size_t count)
4096 {
4097         struct Scsi_Host  *shost = class_to_shost(dev);
4098         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4099         struct lpfc_hba   *phba = vport->phba;
4100         int val = 0;
4101         int nolip = 0;
4102         const char *val_buf = buf;
4103         int err;
4104         uint32_t prev_val;
4105         u8 sli_family, if_type;
4106
4107         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4108                 nolip = 1;
4109                 val_buf = &buf[strlen("nolip ")];
4110         }
4111
4112         if (!isdigit(val_buf[0]))
4113                 return -EINVAL;
4114         if (sscanf(val_buf, "%i", &val) != 1)
4115                 return -EINVAL;
4116
4117         if (val >= 0 && val <= 6) {
4118                 prev_val = phba->cfg_topology;
4119                 if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
4120                         val == 4) {
4121                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4122                                 "3113 Loop mode not supported at speed %d\n",
4123                                 val);
4124                         return -EINVAL;
4125                 }
4126                 /*
4127                  * The 'topology' is not a configurable parameter if :
4128                  *   - persistent topology enabled
4129                  *   - ASIC_GEN_NUM >= 0xC, with no private loop support
4130                  */
4131                 sli_family = bf_get(lpfc_sli_intf_sli_family,
4132                                     &phba->sli4_hba.sli_intf);
4133                 if_type = bf_get(lpfc_sli_intf_if_type,
4134                                  &phba->sli4_hba.sli_intf);
4135                 if ((phba->hba_flag & HBA_PERSISTENT_TOPO ||
4136                     (!phba->sli4_hba.pc_sli4_params.pls &&
4137                      (sli_family == LPFC_SLI_INTF_FAMILY_G6 ||
4138                       if_type == LPFC_SLI_INTF_IF_TYPE_6))) &&
4139                     val == 4) {
4140                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4141                                 "3114 Loop mode not supported\n");
4142                         return -EINVAL;
4143                 }
4144                 phba->cfg_topology = val;
4145                 if (nolip)
4146                         return strlen(buf);
4147
4148                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4149                         "3054 lpfc_topology changed from %d to %d\n",
4150                         prev_val, val);
4151                 if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
4152                         phba->fc_topology_changed = 1;
4153                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4154                 if (err) {
4155                         phba->cfg_topology = prev_val;
4156                         return -EINVAL;
4157                 } else
4158                         return strlen(buf);
4159         }
4160         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4161                 "%d:0467 lpfc_topology attribute cannot be set to %d, "
4162                 "allowed range is [0, 6]\n",
4163                 phba->brd_no, val);
4164         return -EINVAL;
4165 }
4166
4167 lpfc_param_show(topology)
4168 static DEVICE_ATTR_RW(lpfc_topology);
4169
4170 /**
4171  * lpfc_static_vport_show: Read callback function for
4172  *   lpfc_static_vport sysfs file.
4173  * @dev: Pointer to class device object.
4174  * @attr: device attribute structure.
4175  * @buf: Data buffer.
4176  *
4177  * This function is the read call back function for
4178  * lpfc_static_vport sysfs file. The lpfc_static_vport
4179  * sysfs file report the mageability of the vport.
4180  **/
4181 static ssize_t
4182 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
4183                          char *buf)
4184 {
4185         struct Scsi_Host  *shost = class_to_shost(dev);
4186         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4187         if (vport->vport_flag & STATIC_VPORT)
4188                 sprintf(buf, "1\n");
4189         else
4190                 sprintf(buf, "0\n");
4191
4192         return strlen(buf);
4193 }
4194
4195 /*
4196  * Sysfs attribute to control the statistical data collection.
4197  */
4198 static DEVICE_ATTR_RO(lpfc_static_vport);
4199
4200 /*
4201 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
4202 # connection.
4203 # Value range is [0,16]. Default value is 0.
4204 */
4205 /**
4206  * lpfc_link_speed_store - Set the adapters link speed
4207  * @dev: Pointer to class device.
4208  * @attr: Unused.
4209  * @buf: Data buffer.
4210  * @count: Size of the data buffer.
4211  *
4212  * Description:
4213  * If val is in a valid range then set the adapter's link speed field and
4214  * issue a lip; if the lip fails reset the link speed to the old value.
4215  *
4216  * Notes:
4217  * If the value is not in range log a kernel error message and return an error.
4218  *
4219  * Returns:
4220  * zero if val is in range and lip okay.
4221  * non-zero return value from lpfc_issue_lip()
4222  * -EINVAL val out of range
4223  **/
4224 static ssize_t
4225 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
4226                 const char *buf, size_t count)
4227 {
4228         struct Scsi_Host  *shost = class_to_shost(dev);
4229         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4230         struct lpfc_hba   *phba = vport->phba;
4231         int val = LPFC_USER_LINK_SPEED_AUTO;
4232         int nolip = 0;
4233         const char *val_buf = buf;
4234         int err;
4235         uint32_t prev_val, if_type;
4236
4237         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
4238         if (if_type >= LPFC_SLI_INTF_IF_TYPE_2 &&
4239             phba->hba_flag & HBA_FORCED_LINK_SPEED)
4240                 return -EPERM;
4241
4242         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4243                 nolip = 1;
4244                 val_buf = &buf[strlen("nolip ")];
4245         }
4246
4247         if (!isdigit(val_buf[0]))
4248                 return -EINVAL;
4249         if (sscanf(val_buf, "%i", &val) != 1)
4250                 return -EINVAL;
4251
4252         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4253                 "3055 lpfc_link_speed changed from %d to %d %s\n",
4254                 phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
4255
4256         if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
4257             ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
4258             ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
4259             ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
4260             ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
4261             ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) ||
4262             ((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb)) ||
4263             ((val == LPFC_USER_LINK_SPEED_64G) && !(phba->lmt & LMT_64Gb))) {
4264                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4265                                 "2879 lpfc_link_speed attribute cannot be set "
4266                                 "to %d. Speed is not supported by this port.\n",
4267                                 val);
4268                 return -EINVAL;
4269         }
4270         if (val >= LPFC_USER_LINK_SPEED_16G &&
4271             phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4272                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4273                                 "3112 lpfc_link_speed attribute cannot be set "
4274                                 "to %d. Speed is not supported in loop mode.\n",
4275                                 val);
4276                 return -EINVAL;
4277         }
4278
4279         switch (val) {
4280         case LPFC_USER_LINK_SPEED_AUTO:
4281         case LPFC_USER_LINK_SPEED_1G:
4282         case LPFC_USER_LINK_SPEED_2G:
4283         case LPFC_USER_LINK_SPEED_4G:
4284         case LPFC_USER_LINK_SPEED_8G:
4285         case LPFC_USER_LINK_SPEED_16G:
4286         case LPFC_USER_LINK_SPEED_32G:
4287         case LPFC_USER_LINK_SPEED_64G:
4288                 prev_val = phba->cfg_link_speed;
4289                 phba->cfg_link_speed = val;
4290                 if (nolip)
4291                         return strlen(buf);
4292
4293                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4294                 if (err) {
4295                         phba->cfg_link_speed = prev_val;
4296                         return -EINVAL;
4297                 }
4298                 return strlen(buf);
4299         default:
4300                 break;
4301         }
4302
4303         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4304                         "0469 lpfc_link_speed attribute cannot be set to %d, "
4305                         "allowed values are [%s]\n",
4306                         val, LPFC_LINK_SPEED_STRING);
4307         return -EINVAL;
4308
4309 }
4310
4311 static int lpfc_link_speed = 0;
4312 module_param(lpfc_link_speed, int, S_IRUGO);
4313 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
4314 lpfc_param_show(link_speed)
4315
4316 /**
4317  * lpfc_link_speed_init - Set the adapters link speed
4318  * @phba: lpfc_hba pointer.
4319  * @val: link speed value.
4320  *
4321  * Description:
4322  * If val is in a valid range then set the adapter's link speed field.
4323  *
4324  * Notes:
4325  * If the value is not in range log a kernel error message, clear the link
4326  * speed and return an error.
4327  *
4328  * Returns:
4329  * zero if val saved.
4330  * -EINVAL val out of range
4331  **/
4332 static int
4333 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
4334 {
4335         if (val >= LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
4336                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4337                         "3111 lpfc_link_speed of %d cannot "
4338                         "support loop mode, setting topology to default.\n",
4339                          val);
4340                 phba->cfg_topology = 0;
4341         }
4342
4343         switch (val) {
4344         case LPFC_USER_LINK_SPEED_AUTO:
4345         case LPFC_USER_LINK_SPEED_1G:
4346         case LPFC_USER_LINK_SPEED_2G:
4347         case LPFC_USER_LINK_SPEED_4G:
4348         case LPFC_USER_LINK_SPEED_8G:
4349         case LPFC_USER_LINK_SPEED_16G:
4350         case LPFC_USER_LINK_SPEED_32G:
4351         case LPFC_USER_LINK_SPEED_64G:
4352                 phba->cfg_link_speed = val;
4353                 return 0;
4354         default:
4355                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4356                                 "0405 lpfc_link_speed attribute cannot "
4357                                 "be set to %d, allowed values are "
4358                                 "["LPFC_LINK_SPEED_STRING"]\n", val);
4359                 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
4360                 return -EINVAL;
4361         }
4362 }
4363
4364 static DEVICE_ATTR_RW(lpfc_link_speed);
4365
4366 /*
4367 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
4368 #       0  = aer disabled or not supported
4369 #       1  = aer supported and enabled (default)
4370 # Value range is [0,1]. Default value is 1.
4371 */
4372 LPFC_ATTR(aer_support, 1, 0, 1,
4373         "Enable PCIe device AER support");
4374 lpfc_param_show(aer_support)
4375
4376 /**
4377  * lpfc_aer_support_store - Set the adapter for aer support
4378  *
4379  * @dev: class device that is converted into a Scsi_host.
4380  * @attr: device attribute, not used.
4381  * @buf: containing enable or disable aer flag.
4382  * @count: unused variable.
4383  *
4384  * Description:
4385  * If the val is 1 and currently the device's AER capability was not
4386  * enabled, invoke the kernel's enable AER helper routine, trying to
4387  * enable the device's AER capability. If the helper routine enabling
4388  * AER returns success, update the device's cfg_aer_support flag to
4389  * indicate AER is supported by the device; otherwise, if the device
4390  * AER capability is already enabled to support AER, then do nothing.
4391  *
4392  * If the val is 0 and currently the device's AER support was enabled,
4393  * invoke the kernel's disable AER helper routine. After that, update
4394  * the device's cfg_aer_support flag to indicate AER is not supported
4395  * by the device; otherwise, if the device AER capability is already
4396  * disabled from supporting AER, then do nothing.
4397  *
4398  * Returns:
4399  * length of the buf on success if val is in range the intended mode
4400  * is supported.
4401  * -EINVAL if val out of range or intended mode is not supported.
4402  **/
4403 static ssize_t
4404 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
4405                        const char *buf, size_t count)
4406 {
4407         struct Scsi_Host *shost = class_to_shost(dev);
4408         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4409         struct lpfc_hba *phba = vport->phba;
4410         int val = 0, rc = -EINVAL;
4411
4412         if (!isdigit(buf[0]))
4413                 return -EINVAL;
4414         if (sscanf(buf, "%i", &val) != 1)
4415                 return -EINVAL;
4416
4417         switch (val) {
4418         case 0:
4419                 if (phba->hba_flag & HBA_AER_ENABLED) {
4420                         rc = pci_disable_pcie_error_reporting(phba->pcidev);
4421                         if (!rc) {
4422                                 spin_lock_irq(&phba->hbalock);
4423                                 phba->hba_flag &= ~HBA_AER_ENABLED;
4424                                 spin_unlock_irq(&phba->hbalock);
4425                                 phba->cfg_aer_support = 0;
4426                                 rc = strlen(buf);
4427                         } else
4428                                 rc = -EPERM;
4429                 } else {
4430                         phba->cfg_aer_support = 0;
4431                         rc = strlen(buf);
4432                 }
4433                 break;
4434         case 1:
4435                 if (!(phba->hba_flag & HBA_AER_ENABLED)) {
4436                         rc = pci_enable_pcie_error_reporting(phba->pcidev);
4437                         if (!rc) {
4438                                 spin_lock_irq(&phba->hbalock);
4439                                 phba->hba_flag |= HBA_AER_ENABLED;
4440                                 spin_unlock_irq(&phba->hbalock);
4441                                 phba->cfg_aer_support = 1;
4442                                 rc = strlen(buf);
4443                         } else
4444                                  rc = -EPERM;
4445                 } else {
4446                         phba->cfg_aer_support = 1;
4447                         rc = strlen(buf);
4448                 }
4449                 break;
4450         default:
4451                 rc = -EINVAL;
4452                 break;
4453         }
4454         return rc;
4455 }
4456
4457 static DEVICE_ATTR_RW(lpfc_aer_support);
4458
4459 /**
4460  * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
4461  * @dev: class device that is converted into a Scsi_host.
4462  * @attr: device attribute, not used.
4463  * @buf: containing flag 1 for aer cleanup state.
4464  * @count: unused variable.
4465  *
4466  * Description:
4467  * If the @buf contains 1 and the device currently has the AER support
4468  * enabled, then invokes the kernel AER helper routine
4469  * pci_aer_clear_nonfatal_status() to clean up the uncorrectable
4470  * error status register.
4471  *
4472  * Notes:
4473  *
4474  * Returns:
4475  * -EINVAL if the buf does not contain the 1 or the device is not currently
4476  * enabled with the AER support.
4477  **/
4478 static ssize_t
4479 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
4480                        const char *buf, size_t count)
4481 {
4482         struct Scsi_Host  *shost = class_to_shost(dev);
4483         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4484         struct lpfc_hba   *phba = vport->phba;
4485         int val, rc = -1;
4486
4487         if (!isdigit(buf[0]))
4488                 return -EINVAL;
4489         if (sscanf(buf, "%i", &val) != 1)
4490                 return -EINVAL;
4491         if (val != 1)
4492                 return -EINVAL;
4493
4494         if (phba->hba_flag & HBA_AER_ENABLED)
4495                 rc = pci_aer_clear_nonfatal_status(phba->pcidev);
4496
4497         if (rc == 0)
4498                 return strlen(buf);
4499         else
4500                 return -EPERM;
4501 }
4502
4503 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
4504                    lpfc_aer_cleanup_state);
4505
4506 /**
4507  * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
4508  *
4509  * @dev: class device that is converted into a Scsi_host.
4510  * @attr: device attribute, not used.
4511  * @buf: containing the string the number of vfs to be enabled.
4512  * @count: unused variable.
4513  *
4514  * Description:
4515  * When this api is called either through user sysfs, the driver shall
4516  * try to enable or disable SR-IOV virtual functions according to the
4517  * following:
4518  *
4519  * If zero virtual function has been enabled to the physical function,
4520  * the driver shall invoke the pci enable virtual function api trying
4521  * to enable the virtual functions. If the nr_vfn provided is greater
4522  * than the maximum supported, the maximum virtual function number will
4523  * be used for invoking the api; otherwise, the nr_vfn provided shall
4524  * be used for invoking the api. If the api call returned success, the
4525  * actual number of virtual functions enabled will be set to the driver
4526  * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
4527  * cfg_sriov_nr_virtfn remains zero.
4528  *
4529  * If none-zero virtual functions have already been enabled to the
4530  * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
4531  * -EINVAL will be returned and the driver does nothing;
4532  *
4533  * If the nr_vfn provided is zero and none-zero virtual functions have
4534  * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
4535  * disabling virtual function api shall be invoded to disable all the
4536  * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
4537  * zero. Otherwise, if zero virtual function has been enabled, do
4538  * nothing.
4539  *
4540  * Returns:
4541  * length of the buf on success if val is in range the intended mode
4542  * is supported.
4543  * -EINVAL if val out of range or intended mode is not supported.
4544  **/
4545 static ssize_t
4546 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
4547                          const char *buf, size_t count)
4548 {
4549         struct Scsi_Host *shost = class_to_shost(dev);
4550         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4551         struct lpfc_hba *phba = vport->phba;
4552         struct pci_dev *pdev = phba->pcidev;
4553         int val = 0, rc = -EINVAL;
4554
4555         /* Sanity check on user data */
4556         if (!isdigit(buf[0]))
4557                 return -EINVAL;
4558         if (sscanf(buf, "%i", &val) != 1)
4559                 return -EINVAL;
4560         if (val < 0)
4561                 return -EINVAL;
4562
4563         /* Request disabling virtual functions */
4564         if (val == 0) {
4565                 if (phba->cfg_sriov_nr_virtfn > 0) {
4566                         pci_disable_sriov(pdev);
4567                         phba->cfg_sriov_nr_virtfn = 0;
4568                 }
4569                 return strlen(buf);
4570         }
4571
4572         /* Request enabling virtual functions */
4573         if (phba->cfg_sriov_nr_virtfn > 0) {
4574                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4575                                 "3018 There are %d virtual functions "
4576                                 "enabled on physical function.\n",
4577                                 phba->cfg_sriov_nr_virtfn);
4578                 return -EEXIST;
4579         }
4580
4581         if (val <= LPFC_MAX_VFN_PER_PFN)
4582                 phba->cfg_sriov_nr_virtfn = val;
4583         else {
4584                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4585                                 "3019 Enabling %d virtual functions is not "
4586                                 "allowed.\n", val);
4587                 return -EINVAL;
4588         }
4589
4590         rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
4591         if (rc) {
4592                 phba->cfg_sriov_nr_virtfn = 0;
4593                 rc = -EPERM;
4594         } else
4595                 rc = strlen(buf);
4596
4597         return rc;
4598 }
4599
4600 LPFC_ATTR(sriov_nr_virtfn, LPFC_DEF_VFN_PER_PFN, 0, LPFC_MAX_VFN_PER_PFN,
4601         "Enable PCIe device SR-IOV virtual fn");
4602
4603 lpfc_param_show(sriov_nr_virtfn)
4604 static DEVICE_ATTR_RW(lpfc_sriov_nr_virtfn);
4605
4606 /**
4607  * lpfc_request_firmware_upgrade_store - Request for Linux generic firmware upgrade
4608  *
4609  * @dev: class device that is converted into a Scsi_host.
4610  * @attr: device attribute, not used.
4611  * @buf: containing the string the number of vfs to be enabled.
4612  * @count: unused variable.
4613  *
4614  * Description:
4615  *
4616  * Returns:
4617  * length of the buf on success if val is in range the intended mode
4618  * is supported.
4619  * -EINVAL if val out of range or intended mode is not supported.
4620  **/
4621 static ssize_t
4622 lpfc_request_firmware_upgrade_store(struct device *dev,
4623                                     struct device_attribute *attr,
4624                                     const char *buf, size_t count)
4625 {
4626         struct Scsi_Host *shost = class_to_shost(dev);
4627         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4628         struct lpfc_hba *phba = vport->phba;
4629         int val = 0, rc;
4630
4631         /* Sanity check on user data */
4632         if (!isdigit(buf[0]))
4633                 return -EINVAL;
4634         if (sscanf(buf, "%i", &val) != 1)
4635                 return -EINVAL;
4636         if (val != 1)
4637                 return -EINVAL;
4638
4639         rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
4640         if (rc)
4641                 rc = -EPERM;
4642         else
4643                 rc = strlen(buf);
4644         return rc;
4645 }
4646
4647 static int lpfc_req_fw_upgrade;
4648 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
4649 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
4650 lpfc_param_show(request_firmware_upgrade)
4651
4652 /**
4653  * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
4654  * @phba: lpfc_hba pointer.
4655  * @val: 0 or 1.
4656  *
4657  * Description:
4658  * Set the initial Linux generic firmware upgrade enable or disable flag.
4659  *
4660  * Returns:
4661  * zero if val saved.
4662  * -EINVAL val out of range
4663  **/
4664 static int
4665 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
4666 {
4667         if (val >= 0 && val <= 1) {
4668                 phba->cfg_request_firmware_upgrade = val;
4669                 return 0;
4670         }
4671         return -EINVAL;
4672 }
4673 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
4674                    lpfc_request_firmware_upgrade_show,
4675                    lpfc_request_firmware_upgrade_store);
4676
4677 /**
4678  * lpfc_force_rscn_store
4679  *
4680  * @dev: class device that is converted into a Scsi_host.
4681  * @attr: device attribute, not used.
4682  * @buf: unused string
4683  * @count: unused variable.
4684  *
4685  * Description:
4686  * Force the switch to send a RSCN to all other NPorts in our zone
4687  * If we are direct connect pt2pt, build the RSCN command ourself
4688  * and send to the other NPort. Not supported for private loop.
4689  *
4690  * Returns:
4691  * 0      - on success
4692  * -EIO   - if command is not sent
4693  **/
4694 static ssize_t
4695 lpfc_force_rscn_store(struct device *dev, struct device_attribute *attr,
4696                       const char *buf, size_t count)
4697 {
4698         struct Scsi_Host *shost = class_to_shost(dev);
4699         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4700         int i;
4701
4702         i = lpfc_issue_els_rscn(vport, 0);
4703         if (i)
4704                 return -EIO;
4705         return strlen(buf);
4706 }
4707
4708 /*
4709  * lpfc_force_rscn: Force an RSCN to be sent to all remote NPorts
4710  * connected to  the HBA.
4711  *
4712  * Value range is any ascii value
4713  */
4714 static int lpfc_force_rscn;
4715 module_param(lpfc_force_rscn, int, 0644);
4716 MODULE_PARM_DESC(lpfc_force_rscn,
4717                  "Force an RSCN to be sent to all remote NPorts");
4718 lpfc_param_show(force_rscn)
4719
4720 /**
4721  * lpfc_force_rscn_init - Force an RSCN to be sent to all remote NPorts
4722  * @phba: lpfc_hba pointer.
4723  * @val: unused value.
4724  *
4725  * Returns:
4726  * zero if val saved.
4727  **/
4728 static int
4729 lpfc_force_rscn_init(struct lpfc_hba *phba, int val)
4730 {
4731         return 0;
4732 }
4733 static DEVICE_ATTR_RW(lpfc_force_rscn);
4734
4735 /**
4736  * lpfc_fcp_imax_store
4737  *
4738  * @dev: class device that is converted into a Scsi_host.
4739  * @attr: device attribute, not used.
4740  * @buf: string with the number of fast-path FCP interrupts per second.
4741  * @count: unused variable.
4742  *
4743  * Description:
4744  * If val is in a valid range [636,651042], then set the adapter's
4745  * maximum number of fast-path FCP interrupts per second.
4746  *
4747  * Returns:
4748  * length of the buf on success if val is in range the intended mode
4749  * is supported.
4750  * -EINVAL if val out of range or intended mode is not supported.
4751  **/
4752 static ssize_t
4753 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
4754                          const char *buf, size_t count)
4755 {
4756         struct Scsi_Host *shost = class_to_shost(dev);
4757         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4758         struct lpfc_hba *phba = vport->phba;
4759         struct lpfc_eq_intr_info *eqi;
4760         uint32_t usdelay;
4761         int val = 0, i;
4762
4763         /* fcp_imax is only valid for SLI4 */
4764         if (phba->sli_rev != LPFC_SLI_REV4)
4765                 return -EINVAL;
4766
4767         /* Sanity check on user data */
4768         if (!isdigit(buf[0]))
4769                 return -EINVAL;
4770         if (sscanf(buf, "%i", &val) != 1)
4771                 return -EINVAL;
4772
4773         /*
4774          * Value range for the HBA is [5000,5000000]
4775          * The value for each EQ depends on how many EQs are configured.
4776          * Allow value == 0
4777          */
4778         if (val && (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX))
4779                 return -EINVAL;
4780
4781         phba->cfg_auto_imax = (val) ? 0 : 1;
4782         if (phba->cfg_fcp_imax && !val) {
4783                 queue_delayed_work(phba->wq, &phba->eq_delay_work,
4784                                    msecs_to_jiffies(LPFC_EQ_DELAY_MSECS));
4785
4786                 for_each_present_cpu(i) {
4787                         eqi = per_cpu_ptr(phba->sli4_hba.eq_info, i);
4788                         eqi->icnt = 0;
4789                 }
4790         }
4791
4792         phba->cfg_fcp_imax = (uint32_t)val;
4793
4794         if (phba->cfg_fcp_imax)
4795                 usdelay = LPFC_SEC_TO_USEC / phba->cfg_fcp_imax;
4796         else
4797                 usdelay = 0;
4798
4799         for (i = 0; i < phba->cfg_irq_chann; i += LPFC_MAX_EQ_DELAY_EQID_CNT)
4800                 lpfc_modify_hba_eq_delay(phba, i, LPFC_MAX_EQ_DELAY_EQID_CNT,
4801                                          usdelay);
4802
4803         return strlen(buf);
4804 }
4805
4806 /*
4807 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
4808 # for the HBA.
4809 #
4810 # Value range is [5,000 to 5,000,000]. Default value is 50,000.
4811 */
4812 static int lpfc_fcp_imax = LPFC_DEF_IMAX;
4813 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
4814 MODULE_PARM_DESC(lpfc_fcp_imax,
4815             "Set the maximum number of FCP interrupts per second per HBA");
4816 lpfc_param_show(fcp_imax)
4817
4818 /**
4819  * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
4820  * @phba: lpfc_hba pointer.
4821  * @val: link speed value.
4822  *
4823  * Description:
4824  * If val is in a valid range [636,651042], then initialize the adapter's
4825  * maximum number of fast-path FCP interrupts per second.
4826  *
4827  * Returns:
4828  * zero if val saved.
4829  * -EINVAL val out of range
4830  **/
4831 static int
4832 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
4833 {
4834         if (phba->sli_rev != LPFC_SLI_REV4) {
4835                 phba->cfg_fcp_imax = 0;
4836                 return 0;
4837         }
4838
4839         if ((val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) ||
4840             (val == 0)) {
4841                 phba->cfg_fcp_imax = val;
4842                 return 0;
4843         }
4844
4845         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4846                         "3016 lpfc_fcp_imax: %d out of range, using default\n",
4847                         val);
4848         phba->cfg_fcp_imax = LPFC_DEF_IMAX;
4849
4850         return 0;
4851 }
4852
4853 static DEVICE_ATTR_RW(lpfc_fcp_imax);
4854
4855 /**
4856  * lpfc_cq_max_proc_limit_store
4857  *
4858  * @dev: class device that is converted into a Scsi_host.
4859  * @attr: device attribute, not used.
4860  * @buf: string with the cq max processing limit of cqes
4861  * @count: unused variable.
4862  *
4863  * Description:
4864  * If val is in a valid range, then set value on each cq
4865  *
4866  * Returns:
4867  * The length of the buf: if successful
4868  * -ERANGE: if val is not in the valid range
4869  * -EINVAL: if bad value format or intended mode is not supported.
4870  **/
4871 static ssize_t
4872 lpfc_cq_max_proc_limit_store(struct device *dev, struct device_attribute *attr,
4873                          const char *buf, size_t count)
4874 {
4875         struct Scsi_Host *shost = class_to_shost(dev);
4876         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4877         struct lpfc_hba *phba = vport->phba;
4878         struct lpfc_queue *eq, *cq;
4879         unsigned long val;
4880         int i;
4881
4882         /* cq_max_proc_limit is only valid for SLI4 */
4883         if (phba->sli_rev != LPFC_SLI_REV4)
4884                 return -EINVAL;
4885
4886         /* Sanity check on user data */
4887         if (!isdigit(buf[0]))
4888                 return -EINVAL;
4889         if (kstrtoul(buf, 0, &val))
4890                 return -EINVAL;
4891
4892         if (val < LPFC_CQ_MIN_PROC_LIMIT || val > LPFC_CQ_MAX_PROC_LIMIT)
4893                 return -ERANGE;
4894
4895         phba->cfg_cq_max_proc_limit = (uint32_t)val;
4896
4897         /* set the values on the cq's */
4898         for (i = 0; i < phba->cfg_irq_chann; i++) {
4899                 /* Get the EQ corresponding to the IRQ vector */
4900                 eq = phba->sli4_hba.hba_eq_hdl[i].eq;
4901                 if (!eq)
4902                         continue;
4903
4904                 list_for_each_entry(cq, &eq->child_list, list)
4905                         cq->max_proc_limit = min(phba->cfg_cq_max_proc_limit,
4906                                                  cq->entry_count);
4907         }
4908
4909         return strlen(buf);
4910 }
4911
4912 /*
4913  * lpfc_cq_max_proc_limit: The maximum number CQE entries processed in an
4914  *   itteration of CQ processing.
4915  */
4916 static int lpfc_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
4917 module_param(lpfc_cq_max_proc_limit, int, 0644);
4918 MODULE_PARM_DESC(lpfc_cq_max_proc_limit,
4919             "Set the maximum number CQEs processed in an iteration of "
4920             "CQ processing");
4921 lpfc_param_show(cq_max_proc_limit)
4922
4923 /*
4924  * lpfc_cq_poll_threshold: Set the threshold of CQE completions in a
4925  *   single handler call which should request a polled completion rather
4926  *   than re-enabling interrupts.
4927  */
4928 LPFC_ATTR_RW(cq_poll_threshold, LPFC_CQ_DEF_THRESHOLD_TO_POLL,
4929              LPFC_CQ_MIN_THRESHOLD_TO_POLL,
4930              LPFC_CQ_MAX_THRESHOLD_TO_POLL,
4931              "CQE Processing Threshold to enable Polling");
4932
4933 /**
4934  * lpfc_cq_max_proc_limit_init - Set the initial cq max_proc_limit
4935  * @phba: lpfc_hba pointer.
4936  * @val: entry limit
4937  *
4938  * Description:
4939  * If val is in a valid range, then initialize the adapter's maximum
4940  * value.
4941  *
4942  * Returns:
4943  *  Always returns 0 for success, even if value not always set to
4944  *  requested value. If value out of range or not supported, will fall
4945  *  back to default.
4946  **/
4947 static int
4948 lpfc_cq_max_proc_limit_init(struct lpfc_hba *phba, int val)
4949 {
4950         phba->cfg_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
4951
4952         if (phba->sli_rev != LPFC_SLI_REV4)
4953                 return 0;
4954
4955         if (val >= LPFC_CQ_MIN_PROC_LIMIT && val <= LPFC_CQ_MAX_PROC_LIMIT) {
4956                 phba->cfg_cq_max_proc_limit = val;
4957                 return 0;
4958         }
4959
4960         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4961                         "0371 lpfc_cq_max_proc_limit: %d out of range, using "
4962                         "default\n",
4963                         phba->cfg_cq_max_proc_limit);
4964
4965         return 0;
4966 }
4967
4968 static DEVICE_ATTR_RW(lpfc_cq_max_proc_limit);
4969
4970 /**
4971  * lpfc_fcp_cpu_map_show - Display current driver CPU affinity
4972  * @dev: class converted to a Scsi_host structure.
4973  * @attr: device attribute, not used.
4974  * @buf: on return contains text describing the state of the link.
4975  *
4976  * Returns: size of formatted string.
4977  **/
4978 static ssize_t
4979 lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
4980                       char *buf)
4981 {
4982         struct Scsi_Host  *shost = class_to_shost(dev);
4983         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4984         struct lpfc_hba   *phba = vport->phba;
4985         struct lpfc_vector_map_info *cpup;
4986         int  len = 0;
4987
4988         if ((phba->sli_rev != LPFC_SLI_REV4) ||
4989             (phba->intr_type != MSIX))
4990                 return len;
4991
4992         switch (phba->cfg_fcp_cpu_map) {
4993         case 0:
4994                 len += scnprintf(buf + len, PAGE_SIZE-len,
4995                                 "fcp_cpu_map: No mapping (%d)\n",
4996                                 phba->cfg_fcp_cpu_map);
4997                 return len;
4998         case 1:
4999                 len += scnprintf(buf + len, PAGE_SIZE-len,
5000                                 "fcp_cpu_map: HBA centric mapping (%d): "
5001                                 "%d of %d CPUs online from %d possible CPUs\n",
5002                                 phba->cfg_fcp_cpu_map, num_online_cpus(),
5003                                 num_present_cpus(),
5004                                 phba->sli4_hba.num_possible_cpu);
5005                 break;
5006         }
5007
5008         while (phba->sli4_hba.curr_disp_cpu <
5009                phba->sli4_hba.num_possible_cpu) {
5010                 cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu];
5011
5012                 if (!cpu_present(phba->sli4_hba.curr_disp_cpu))
5013                         len += scnprintf(buf + len, PAGE_SIZE - len,
5014                                         "CPU %02d not present\n",
5015                                         phba->sli4_hba.curr_disp_cpu);
5016                 else if (cpup->eq == LPFC_VECTOR_MAP_EMPTY) {
5017                         if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
5018                                 len += scnprintf(
5019                                         buf + len, PAGE_SIZE - len,
5020                                         "CPU %02d hdwq None "
5021                                         "physid %d coreid %d ht %d ua %d\n",
5022                                         phba->sli4_hba.curr_disp_cpu,
5023                                         cpup->phys_id, cpup->core_id,
5024                                         (cpup->flag & LPFC_CPU_MAP_HYPER),
5025                                         (cpup->flag & LPFC_CPU_MAP_UNASSIGN));
5026                         else
5027                                 len += scnprintf(
5028                                         buf + len, PAGE_SIZE - len,
5029                                         "CPU %02d EQ None hdwq %04d "
5030                                         "physid %d coreid %d ht %d ua %d\n",
5031                                         phba->sli4_hba.curr_disp_cpu,
5032                                         cpup->hdwq, cpup->phys_id,
5033                                         cpup->core_id,
5034                                         (cpup->flag & LPFC_CPU_MAP_HYPER),
5035                                         (cpup->flag & LPFC_CPU_MAP_UNASSIGN));
5036                 } else {
5037                         if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
5038                                 len += scnprintf(
5039                                         buf + len, PAGE_SIZE - len,
5040                                         "CPU %02d hdwq None "
5041                                         "physid %d coreid %d ht %d ua %d IRQ %d\n",
5042                                         phba->sli4_hba.curr_disp_cpu,
5043                                         cpup->phys_id,
5044                                         cpup->core_id,
5045                                         (cpup->flag & LPFC_CPU_MAP_HYPER),
5046                                         (cpup->flag & LPFC_CPU_MAP_UNASSIGN),
5047                                         lpfc_get_irq(cpup->eq));
5048                         else
5049                                 len += scnprintf(
5050                                         buf + len, PAGE_SIZE - len,
5051                                         "CPU %02d EQ %04d hdwq %04d "
5052                                         "physid %d coreid %d ht %d ua %d IRQ %d\n",
5053                                         phba->sli4_hba.curr_disp_cpu,
5054                                         cpup->eq, cpup->hdwq, cpup->phys_id,
5055                                         cpup->core_id,
5056                                         (cpup->flag & LPFC_CPU_MAP_HYPER),
5057                                         (cpup->flag & LPFC_CPU_MAP_UNASSIGN),
5058                                         lpfc_get_irq(cpup->eq));
5059                 }
5060
5061                 phba->sli4_hba.curr_disp_cpu++;
5062
5063                 /* display max number of CPUs keeping some margin */
5064                 if (phba->sli4_hba.curr_disp_cpu <
5065                                 phba->sli4_hba.num_possible_cpu &&
5066                                 (len >= (PAGE_SIZE - 64))) {
5067                         len += scnprintf(buf + len,
5068                                         PAGE_SIZE - len, "more...\n");
5069                         break;
5070                 }
5071         }
5072
5073         if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_possible_cpu)
5074                 phba->sli4_hba.curr_disp_cpu = 0;
5075
5076         return len;
5077 }
5078
5079 /**
5080  * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
5081  * @dev: class device that is converted into a Scsi_host.
5082  * @attr: device attribute, not used.
5083  * @buf: one or more lpfc_polling_flags values.
5084  * @count: not used.
5085  *
5086  * Returns:
5087  * -EINVAL  - Not implemented yet.
5088  **/
5089 static ssize_t
5090 lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
5091                        const char *buf, size_t count)
5092 {
5093         return -EINVAL;
5094 }
5095
5096 /*
5097 # lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
5098 # for the HBA.
5099 #
5100 # Value range is [0 to 1]. Default value is LPFC_HBA_CPU_MAP (1).
5101 #       0 - Do not affinitze IRQ vectors
5102 #       1 - Affintize HBA vectors with respect to each HBA
5103 #           (start with CPU0 for each HBA)
5104 # This also defines how Hardware Queues are mapped to specific CPUs.
5105 */
5106 static int lpfc_fcp_cpu_map = LPFC_HBA_CPU_MAP;
5107 module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
5108 MODULE_PARM_DESC(lpfc_fcp_cpu_map,
5109                  "Defines how to map CPUs to IRQ vectors per HBA");
5110
5111 /**
5112  * lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable
5113  * @phba: lpfc_hba pointer.
5114  * @val: link speed value.
5115  *
5116  * Description:
5117  * If val is in a valid range [0-2], then affinitze the adapter's
5118  * MSIX vectors.
5119  *
5120  * Returns:
5121  * zero if val saved.
5122  * -EINVAL val out of range
5123  **/
5124 static int
5125 lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
5126 {
5127         if (phba->sli_rev != LPFC_SLI_REV4) {
5128                 phba->cfg_fcp_cpu_map = 0;
5129                 return 0;
5130         }
5131
5132         if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
5133                 phba->cfg_fcp_cpu_map = val;
5134                 return 0;
5135         }
5136
5137         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5138                         "3326 lpfc_fcp_cpu_map: %d out of range, using "
5139                         "default\n", val);
5140         phba->cfg_fcp_cpu_map = LPFC_HBA_CPU_MAP;
5141
5142         return 0;
5143 }
5144
5145 static DEVICE_ATTR_RW(lpfc_fcp_cpu_map);
5146
5147 /*
5148 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
5149 # Value range is [2,3]. Default value is 3.
5150 */
5151 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
5152                   "Select Fibre Channel class of service for FCP sequences");
5153
5154 /*
5155 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
5156 # is [0,1]. Default value is 1.
5157 */
5158 LPFC_VPORT_ATTR_RW(use_adisc, 1, 0, 1,
5159                    "Use ADISC on rediscovery to authenticate FCP devices");
5160
5161 /*
5162 # lpfc_first_burst_size: First burst size to use on the NPorts
5163 # that support first burst.
5164 # Value range is [0,65536]. Default value is 0.
5165 */
5166 LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536,
5167                    "First burst size for Targets that support first burst");
5168
5169 /*
5170 * lpfc_nvmet_fb_size: NVME Target mode supported first burst size.
5171 * When the driver is configured as an NVME target, this value is
5172 * communicated to the NVME initiator in the PRLI response.  It is
5173 * used only when the lpfc_nvme_enable_fb and lpfc_nvmet_support
5174 * parameters are set and the target is sending the PRLI RSP.
5175 * Parameter supported on physical port only - no NPIV support.
5176 * Value range is [0,65536]. Default value is 0.
5177 */
5178 LPFC_ATTR_RW(nvmet_fb_size, 0, 0, 65536,
5179              "NVME Target mode first burst size in 512B increments.");
5180
5181 /*
5182  * lpfc_nvme_enable_fb: Enable NVME first burst on I and T functions.
5183  * For the Initiator (I), enabling this parameter means that an NVMET
5184  * PRLI response with FBA enabled and an FB_SIZE set to a nonzero value will be
5185  * processed by the initiator for subsequent NVME FCP IO.
5186  * Currently, this feature is not supported on the NVME target
5187  * Value range is [0,1]. Default value is 0 (disabled).
5188  */
5189 LPFC_ATTR_RW(nvme_enable_fb, 0, 0, 1,
5190              "Enable First Burst feature for NVME Initiator.");
5191
5192 /*
5193 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
5194 # depth. Default value is 0. When the value of this parameter is zero the
5195 # SCSI command completion time is not used for controlling I/O queue depth. When
5196 # the parameter is set to a non-zero value, the I/O queue depth is controlled
5197 # to limit the I/O completion time to the parameter value.
5198 # The value is set in milliseconds.
5199 */
5200 LPFC_VPORT_ATTR(max_scsicmpl_time, 0, 0, 60000,
5201         "Use command completion time to control queue depth");
5202
5203 lpfc_vport_param_show(max_scsicmpl_time);
5204 static int
5205 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
5206 {
5207         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5208         struct lpfc_nodelist *ndlp, *next_ndlp;
5209
5210         if (val == vport->cfg_max_scsicmpl_time)
5211                 return 0;
5212         if ((val < 0) || (val > 60000))
5213                 return -EINVAL;
5214         vport->cfg_max_scsicmpl_time = val;
5215
5216         spin_lock_irq(shost->host_lock);
5217         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
5218                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
5219                         continue;
5220                 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
5221         }
5222         spin_unlock_irq(shost->host_lock);
5223         return 0;
5224 }
5225 lpfc_vport_param_store(max_scsicmpl_time);
5226 static DEVICE_ATTR_RW(lpfc_max_scsicmpl_time);
5227
5228 /*
5229 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
5230 # range is [0,1]. Default value is 0.
5231 */
5232 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
5233
5234 /*
5235 # lpfc_xri_rebalancing: enable or disable XRI rebalancing feature
5236 # range is [0,1]. Default value is 1.
5237 */
5238 LPFC_ATTR_R(xri_rebalancing, 1, 0, 1, "Enable/Disable XRI rebalancing");
5239
5240 /*
5241  * lpfc_io_sched: Determine scheduling algrithmn for issuing FCP cmds
5242  * range is [0,1]. Default value is 0.
5243  * For [0], FCP commands are issued to Work Queues based on upper layer
5244  * hardware queue index.
5245  * For [1], FCP commands are issued to a Work Queue associated with the
5246  *          current CPU.
5247  *
5248  * LPFC_FCP_SCHED_BY_HDWQ == 0
5249  * LPFC_FCP_SCHED_BY_CPU == 1
5250  *
5251  * The driver dynamically sets this to 1 (BY_CPU) if it's able to set up cpu
5252  * affinity for FCP/NVME I/Os through Work Queues associated with the current
5253  * CPU. Otherwise, the default 0 (Round Robin) scheduling of FCP/NVME I/Os
5254  * through WQs will be used.
5255  */
5256 LPFC_ATTR_RW(fcp_io_sched, LPFC_FCP_SCHED_BY_CPU,
5257              LPFC_FCP_SCHED_BY_HDWQ,
5258              LPFC_FCP_SCHED_BY_CPU,
5259              "Determine scheduling algorithm for "
5260              "issuing commands [0] - Hardware Queue, [1] - Current CPU");
5261
5262 /*
5263  * lpfc_ns_query: Determine algrithmn for NameServer queries after RSCN
5264  * range is [0,1]. Default value is 0.
5265  * For [0], GID_FT is used for NameServer queries after RSCN (default)
5266  * For [1], GID_PT is used for NameServer queries after RSCN
5267  *
5268  */
5269 LPFC_ATTR_RW(ns_query, LPFC_NS_QUERY_GID_FT,
5270              LPFC_NS_QUERY_GID_FT, LPFC_NS_QUERY_GID_PT,
5271              "Determine algorithm NameServer queries after RSCN "
5272              "[0] - GID_FT, [1] - GID_PT");
5273
5274 /*
5275 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
5276 # range is [0,1]. Default value is 0.
5277 # For [0], bus reset issues target reset to ALL devices
5278 # For [1], bus reset issues target reset to non-FCP2 devices
5279 */
5280 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
5281              "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");
5282
5283
5284 /*
5285 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
5286 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
5287 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
5288 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
5289 # cr_delay is set to 0.
5290 */
5291 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
5292                 "interrupt response is generated");
5293
5294 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
5295                 "interrupt response is generated");
5296
5297 /*
5298 # lpfc_multi_ring_support:  Determines how many rings to spread available
5299 # cmd/rsp IOCB entries across.
5300 # Value range is [1,2]. Default value is 1.
5301 */
5302 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
5303                 "SLI rings to spread IOCB entries across");
5304
5305 /*
5306 # lpfc_multi_ring_rctl:  If lpfc_multi_ring_support is enabled, this
5307 # identifies what rctl value to configure the additional ring for.
5308 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
5309 */
5310 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
5311              255, "Identifies RCTL for additional ring configuration");
5312
5313 /*
5314 # lpfc_multi_ring_type:  If lpfc_multi_ring_support is enabled, this
5315 # identifies what type value to configure the additional ring for.
5316 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
5317 */
5318 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
5319              255, "Identifies TYPE for additional ring configuration");
5320
5321 /*
5322 # lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN
5323 #       0  = SmartSAN functionality disabled (default)
5324 #       1  = SmartSAN functionality enabled
5325 # This parameter will override the value of lpfc_fdmi_on module parameter.
5326 # Value range is [0,1]. Default value is 0.
5327 */
5328 LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality");
5329
5330 /*
5331 # lpfc_fdmi_on: Controls FDMI support.
5332 #       0       No FDMI support
5333 #       1       Traditional FDMI support (default)
5334 # Traditional FDMI support means the driver will assume FDMI-2 support;
5335 # however, if that fails, it will fallback to FDMI-1.
5336 # If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on.
5337 # If lpfc_enable_SmartSAN is set 0, the driver uses the current value of
5338 # lpfc_fdmi_on.
5339 # Value range [0,1]. Default value is 1.
5340 */
5341 LPFC_ATTR_R(fdmi_on, 1, 0, 1, "Enable FDMI support");
5342
5343 /*
5344 # Specifies the maximum number of ELS cmds we can have outstanding (for
5345 # discovery). Value range is [1,64]. Default value = 32.
5346 */
5347 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
5348                  "during discovery");
5349
5350 /*
5351 # lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that
5352 #    will be scanned by the SCSI midlayer when sequential scanning is
5353 #    used; and is also the highest LUN ID allowed when the SCSI midlayer
5354 #    parses REPORT_LUN responses. The lpfc driver has no LUN count or
5355 #    LUN ID limit, but the SCSI midlayer requires this field for the uses
5356 #    above. The lpfc driver limits the default value to 255 for two reasons.
5357 #    As it bounds the sequential scan loop, scanning for thousands of luns
5358 #    on a target can take minutes of wall clock time.  Additionally,
5359 #    there are FC targets, such as JBODs, that only recognize 8-bits of
5360 #    LUN ID. When they receive a value greater than 8 bits, they chop off
5361 #    the high order bits. In other words, they see LUN IDs 0, 256, 512,
5362 #    and so on all as LUN ID 0. This causes the linux kernel, which sees
5363 #    valid responses at each of the LUN IDs, to believe there are multiple
5364 #    devices present, when in fact, there is only 1.
5365 #    A customer that is aware of their target behaviors, and the results as
5366 #    indicated above, is welcome to increase the lpfc_max_luns value.
5367 #    As mentioned, this value is not used by the lpfc driver, only the
5368 #    SCSI midlayer.
5369 # Value range is [0,65535]. Default value is 255.
5370 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
5371 */
5372 LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID");
5373
5374 /*
5375 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
5376 # Value range is [1,255], default value is 10.
5377 */
5378 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
5379              "Milliseconds driver will wait between polling FCP ring");
5380
5381 /*
5382 # lpfc_task_mgmt_tmo: Maximum time to wait for task management commands
5383 # to complete in seconds. Value range is [5,180], default value is 60.
5384 */
5385 LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180,
5386              "Maximum time to wait for task management commands to complete");
5387 /*
5388 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
5389 #               support this feature
5390 #       0  = MSI disabled
5391 #       1  = MSI enabled
5392 #       2  = MSI-X enabled (default)
5393 # Value range is [0,2]. Default value is 2.
5394 */
5395 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
5396             "MSI-X (2), if possible");
5397
5398 /*
5399  * lpfc_nvme_oas: Use the oas bit when sending NVME/NVMET IOs
5400  *
5401  *      0  = NVME OAS disabled
5402  *      1  = NVME OAS enabled
5403  *
5404  * Value range is [0,1]. Default value is 0.
5405  */
5406 LPFC_ATTR_RW(nvme_oas, 0, 0, 1,
5407              "Use OAS bit on NVME IOs");
5408
5409 /*
5410  * lpfc_nvme_embed_cmd: Use the oas bit when sending NVME/NVMET IOs
5411  *
5412  *      0  = Put NVME Command in SGL
5413  *      1  = Embed NVME Command in WQE (unless G7)
5414  *      2 =  Embed NVME Command in WQE (force)
5415  *
5416  * Value range is [0,2]. Default value is 1.
5417  */
5418 LPFC_ATTR_RW(nvme_embed_cmd, 1, 0, 2,
5419              "Embed NVME Command in WQE");
5420
5421 /*
5422  * lpfc_fcp_mq_threshold: Set the maximum number of Hardware Queues
5423  * the driver will advertise it supports to the SCSI layer.
5424  *
5425  *      0    = Set nr_hw_queues by the number of CPUs or HW queues.
5426  *      1,256 = Manually specify nr_hw_queue value to be advertised,
5427  *
5428  * Value range is [0,256]. Default value is 8.
5429  */
5430 LPFC_ATTR_R(fcp_mq_threshold, LPFC_FCP_MQ_THRESHOLD_DEF,
5431             LPFC_FCP_MQ_THRESHOLD_MIN, LPFC_FCP_MQ_THRESHOLD_MAX,
5432             "Set the number of SCSI Queues advertised");
5433
5434 /*
5435  * lpfc_hdw_queue: Set the number of Hardware Queues the driver
5436  * will advertise it supports to the NVME and  SCSI layers. This also
5437  * will map to the number of CQ/WQ pairs the driver will create.
5438  *
5439  * The NVME Layer will try to create this many, plus 1 administrative
5440  * hardware queue. The administrative queue will always map to WQ 0
5441  * A hardware IO queue maps (qidx) to a specific driver CQ/WQ.
5442  *
5443  *      0    = Configure the number of hdw queues to the number of active CPUs.
5444  *      1,256 = Manually specify how many hdw queues to use.
5445  *
5446  * Value range is [0,256]. Default value is 0.
5447  */
5448 LPFC_ATTR_R(hdw_queue,
5449             LPFC_HBA_HDWQ_DEF,
5450             LPFC_HBA_HDWQ_MIN, LPFC_HBA_HDWQ_MAX,
5451             "Set the number of I/O Hardware Queues");
5452
5453 #if IS_ENABLED(CONFIG_X86)
5454 /**
5455  * lpfc_cpumask_irq_mode_init - initalizes cpumask of phba based on
5456  *                              irq_chann_mode
5457  * @phba: Pointer to HBA context object.
5458  **/
5459 static void
5460 lpfc_cpumask_irq_mode_init(struct lpfc_hba *phba)
5461 {
5462         unsigned int cpu, first_cpu, numa_node = NUMA_NO_NODE;
5463         const struct cpumask *sibling_mask;
5464         struct cpumask *aff_mask = &phba->sli4_hba.irq_aff_mask;
5465
5466         cpumask_clear(aff_mask);
5467
5468         if (phba->irq_chann_mode == NUMA_MODE) {
5469                 /* Check if we're a NUMA architecture */
5470                 numa_node = dev_to_node(&phba->pcidev->dev);
5471                 if (numa_node == NUMA_NO_NODE) {
5472                         phba->irq_chann_mode = NORMAL_MODE;
5473                         return;
5474                 }
5475         }
5476
5477         for_each_possible_cpu(cpu) {
5478                 switch (phba->irq_chann_mode) {
5479                 case NUMA_MODE:
5480                         if (cpu_to_node(cpu) == numa_node)
5481                                 cpumask_set_cpu(cpu, aff_mask);
5482                         break;
5483                 case NHT_MODE:
5484                         sibling_mask = topology_sibling_cpumask(cpu);
5485                         first_cpu = cpumask_first(sibling_mask);
5486                         if (first_cpu < nr_cpu_ids)
5487                                 cpumask_set_cpu(first_cpu, aff_mask);
5488                         break;
5489                 default:
5490                         break;
5491                 }
5492         }
5493 }
5494 #endif
5495
5496 static void
5497 lpfc_assign_default_irq_chann(struct lpfc_hba *phba)
5498 {
5499 #if IS_ENABLED(CONFIG_X86)
5500         switch (boot_cpu_data.x86_vendor) {
5501         case X86_VENDOR_AMD:
5502                 /* If AMD architecture, then default is NUMA_MODE */
5503                 phba->irq_chann_mode = NUMA_MODE;
5504                 break;
5505         case X86_VENDOR_INTEL:
5506                 /* If Intel architecture, then default is no hyperthread mode */
5507                 phba->irq_chann_mode = NHT_MODE;
5508                 break;
5509         default:
5510                 phba->irq_chann_mode = NORMAL_MODE;
5511                 break;
5512         }
5513         lpfc_cpumask_irq_mode_init(phba);
5514 #else
5515         phba->irq_chann_mode = NORMAL_MODE;
5516 #endif
5517 }
5518
5519 /*
5520  * lpfc_irq_chann: Set the number of IRQ vectors that are available
5521  * for Hardware Queues to utilize.  This also will map to the number
5522  * of EQ / MSI-X vectors the driver will create. This should never be
5523  * more than the number of Hardware Queues
5524  *
5525  *      0               = Configure number of IRQ Channels to:
5526  *                        if AMD architecture, number of CPUs on HBA's NUMA node
5527  *                        if Intel architecture, number of physical CPUs.
5528  *                        otherwise, number of active CPUs.
5529  *      [1,256]         = Manually specify how many IRQ Channels to use.
5530  *
5531  * Value range is [0,256]. Default value is [0].
5532  */
5533 static uint lpfc_irq_chann = LPFC_IRQ_CHANN_DEF;
5534 module_param(lpfc_irq_chann, uint, 0444);
5535 MODULE_PARM_DESC(lpfc_irq_chann, "Set number of interrupt vectors to allocate");
5536
5537 /* lpfc_irq_chann_init - Set the hba irq_chann initial value
5538  * @phba: lpfc_hba pointer.
5539  * @val: contains the initial value
5540  *
5541  * Description:
5542  * Validates the initial value is within range and assigns it to the
5543  * adapter. If not in range, an error message is posted and the
5544  * default value is assigned.
5545  *
5546  * Returns:
5547  * zero if value is in range and is set
5548  * -EINVAL if value was out of range
5549  **/
5550 static int
5551 lpfc_irq_chann_init(struct lpfc_hba *phba, uint32_t val)
5552 {
5553         const struct cpumask *aff_mask;
5554
5555         if (phba->cfg_use_msi != 2) {
5556                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5557                                 "8532 use_msi = %u ignoring cfg_irq_numa\n",
5558                                 phba->cfg_use_msi);
5559                 phba->irq_chann_mode = NORMAL_MODE;
5560                 phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5561                 return 0;
5562         }
5563
5564         /* Check if default setting was passed */
5565         if (val == LPFC_IRQ_CHANN_DEF &&
5566             phba->cfg_hdw_queue == LPFC_HBA_HDWQ_DEF &&
5567             phba->sli_rev == LPFC_SLI_REV4)
5568                 lpfc_assign_default_irq_chann(phba);
5569
5570         if (phba->irq_chann_mode != NORMAL_MODE) {
5571                 aff_mask = &phba->sli4_hba.irq_aff_mask;
5572
5573                 if (cpumask_empty(aff_mask)) {
5574                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5575                                         "8533 Could not identify CPUS for "
5576                                         "mode %d, ignoring\n",
5577                                         phba->irq_chann_mode);
5578                         phba->irq_chann_mode = NORMAL_MODE;
5579                         phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5580                 } else {
5581                         phba->cfg_irq_chann = cpumask_weight(aff_mask);
5582
5583                         /* If no hyperthread mode, then set hdwq count to
5584                          * aff_mask weight as well
5585                          */
5586                         if (phba->irq_chann_mode == NHT_MODE)
5587                                 phba->cfg_hdw_queue = phba->cfg_irq_chann;
5588
5589                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5590                                         "8543 lpfc_irq_chann set to %u "
5591                                         "(mode: %d)\n", phba->cfg_irq_chann,
5592                                         phba->irq_chann_mode);
5593                 }
5594         } else {
5595                 if (val > LPFC_IRQ_CHANN_MAX) {
5596                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5597                                         "8545 lpfc_irq_chann attribute cannot "
5598                                         "be set to %u, allowed range is "
5599                                         "[%u,%u]\n",
5600                                         val,
5601                                         LPFC_IRQ_CHANN_MIN,
5602                                         LPFC_IRQ_CHANN_MAX);
5603                         phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5604                         return -EINVAL;
5605                 }
5606                 if (phba->sli_rev == LPFC_SLI_REV4) {
5607                         phba->cfg_irq_chann = val;
5608                 } else {
5609                         phba->cfg_irq_chann = 2;
5610                         phba->cfg_hdw_queue = 1;
5611                 }
5612         }
5613
5614         return 0;
5615 }
5616
5617 /**
5618  * lpfc_irq_chann_show - Display value of irq_chann
5619  * @dev: class converted to a Scsi_host structure.
5620  * @attr: device attribute, not used.
5621  * @buf: on return contains a string with the list sizes
5622  *
5623  * Returns: size of formatted string.
5624  **/
5625 static ssize_t
5626 lpfc_irq_chann_show(struct device *dev, struct device_attribute *attr,
5627                     char *buf)
5628 {
5629         struct Scsi_Host *shost = class_to_shost(dev);
5630         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5631         struct lpfc_hba *phba = vport->phba;
5632
5633         return scnprintf(buf, PAGE_SIZE, "%u\n", phba->cfg_irq_chann);
5634 }
5635
5636 static DEVICE_ATTR_RO(lpfc_irq_chann);
5637
5638 /*
5639 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
5640 #       0  = HBA resets disabled
5641 #       1  = HBA resets enabled (default)
5642 #       2  = HBA reset via PCI bus reset enabled
5643 # Value range is [0,2]. Default value is 1.
5644 */
5645 LPFC_ATTR_RW(enable_hba_reset, 1, 0, 2, "Enable HBA resets from the driver.");
5646
5647 /*
5648 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
5649 #       0  = HBA Heartbeat disabled
5650 #       1  = HBA Heartbeat enabled (default)
5651 # Value range is [0,1]. Default value is 1.
5652 */
5653 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
5654
5655 /*
5656 # lpfc_EnableXLane: Enable Express Lane Feature
5657 #      0x0   Express Lane Feature disabled
5658 #      0x1   Express Lane Feature enabled
5659 # Value range is [0,1]. Default value is 0.
5660 */
5661 LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature.");
5662
5663 /*
5664 # lpfc_XLanePriority:  Define CS_CTL priority for Express Lane Feature
5665 #       0x0 - 0x7f  = CS_CTL field in FC header (high 7 bits)
5666 # Value range is [0x0,0x7f]. Default value is 0
5667 */
5668 LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature.");
5669
5670 /*
5671 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
5672 #       0  = BlockGuard disabled (default)
5673 #       1  = BlockGuard enabled
5674 # Value range is [0,1]. Default value is 0.
5675 */
5676 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
5677
5678 /*
5679 # lpfc_prot_mask:
5680 #       - Bit mask of host protection capabilities used to register with the
5681 #         SCSI mid-layer
5682 #       - Only meaningful if BG is turned on (lpfc_enable_bg=1).
5683 #       - Allows you to ultimately specify which profiles to use
5684 #       - Default will result in registering capabilities for all profiles.
5685 #       - SHOST_DIF_TYPE1_PROTECTION    1
5686 #               HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
5687 #       - SHOST_DIX_TYPE0_PROTECTION    8
5688 #               HBA supports DIX Type 0: Host to HBA protection only
5689 #       - SHOST_DIX_TYPE1_PROTECTION    16
5690 #               HBA supports DIX Type 1: Host to HBA  Type 1 protection
5691 #
5692 */
5693 LPFC_ATTR(prot_mask,
5694         (SHOST_DIF_TYPE1_PROTECTION |
5695         SHOST_DIX_TYPE0_PROTECTION |
5696         SHOST_DIX_TYPE1_PROTECTION),
5697         0,
5698         (SHOST_DIF_TYPE1_PROTECTION |
5699         SHOST_DIX_TYPE0_PROTECTION |
5700         SHOST_DIX_TYPE1_PROTECTION),
5701         "T10-DIF host protection capabilities mask");
5702
5703 /*
5704 # lpfc_prot_guard:
5705 #       - Bit mask of protection guard types to register with the SCSI mid-layer
5706 #       - Guard types are currently either 1) T10-DIF CRC 2) IP checksum
5707 #       - Allows you to ultimately specify which profiles to use
5708 #       - Default will result in registering capabilities for all guard types
5709 #
5710 */
5711 LPFC_ATTR(prot_guard,
5712         SHOST_DIX_GUARD_IP, SHOST_DIX_GUARD_CRC, SHOST_DIX_GUARD_IP,
5713         "T10-DIF host protection guard type");
5714
5715 /*
5716  * Delay initial NPort discovery when Clean Address bit is cleared in
5717  * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
5718  * This parameter can have value 0 or 1.
5719  * When this parameter is set to 0, no delay is added to the initial
5720  * discovery.
5721  * When this parameter is set to non-zero value, initial Nport discovery is
5722  * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
5723  * accept and FCID/Fabric name/Fabric portname is changed.
5724  * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
5725  * when Clean Address bit is cleared in FLOGI/FDISC
5726  * accept and FCID/Fabric name/Fabric portname is changed.
5727  * Default value is 0.
5728  */
5729 LPFC_ATTR(delay_discovery, 0, 0, 1,
5730         "Delay NPort discovery when Clean Address bit is cleared.");
5731
5732 /*
5733  * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
5734  * This value can be set to values between 64 and 4096. The default value
5735  * is 64, but may be increased to allow for larger Max I/O sizes. The scsi
5736  * and nvme layers will allow I/O sizes up to (MAX_SEG_COUNT * SEG_SIZE).
5737  * Because of the additional overhead involved in setting up T10-DIF,
5738  * this parameter will be limited to 128 if BlockGuard is enabled under SLI4
5739  * and will be limited to 512 if BlockGuard is enabled under SLI3.
5740  */
5741 static uint lpfc_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
5742 module_param(lpfc_sg_seg_cnt, uint, 0444);
5743 MODULE_PARM_DESC(lpfc_sg_seg_cnt, "Max Scatter Gather Segment Count");
5744
5745 /**
5746  * lpfc_sg_seg_cnt_show - Display the scatter/gather list sizes
5747  *    configured for the adapter
5748  * @dev: class converted to a Scsi_host structure.
5749  * @attr: device attribute, not used.
5750  * @buf: on return contains a string with the list sizes
5751  *
5752  * Returns: size of formatted string.
5753  **/
5754 static ssize_t
5755 lpfc_sg_seg_cnt_show(struct device *dev, struct device_attribute *attr,
5756                      char *buf)
5757 {
5758         struct Scsi_Host  *shost = class_to_shost(dev);
5759         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5760         struct lpfc_hba   *phba = vport->phba;
5761         int len;
5762
5763         len = scnprintf(buf, PAGE_SIZE, "SGL sz: %d  total SGEs: %d\n",
5764                        phba->cfg_sg_dma_buf_size, phba->cfg_total_seg_cnt);
5765
5766         len += scnprintf(buf + len, PAGE_SIZE - len,
5767                         "Cfg: %d  SCSI: %d  NVME: %d\n",
5768                         phba->cfg_sg_seg_cnt, phba->cfg_scsi_seg_cnt,
5769                         phba->cfg_nvme_seg_cnt);
5770         return len;
5771 }
5772
5773 static DEVICE_ATTR_RO(lpfc_sg_seg_cnt);
5774
5775 /**
5776  * lpfc_sg_seg_cnt_init - Set the hba sg_seg_cnt initial value
5777  * @phba: lpfc_hba pointer.
5778  * @val: contains the initial value
5779  *
5780  * Description:
5781  * Validates the initial value is within range and assigns it to the
5782  * adapter. If not in range, an error message is posted and the
5783  * default value is assigned.
5784  *
5785  * Returns:
5786  * zero if value is in range and is set
5787  * -EINVAL if value was out of range
5788  **/
5789 static int
5790 lpfc_sg_seg_cnt_init(struct lpfc_hba *phba, int val)
5791 {
5792         if (val >= LPFC_MIN_SG_SEG_CNT && val <= LPFC_MAX_SG_SEG_CNT) {
5793                 phba->cfg_sg_seg_cnt = val;
5794                 return 0;
5795         }
5796         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5797                         "0409 lpfc_sg_seg_cnt attribute cannot be set to %d, "
5798                         "allowed range is [%d, %d]\n",
5799                         val, LPFC_MIN_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT);
5800         phba->cfg_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
5801         return -EINVAL;
5802 }
5803
5804 /*
5805  * lpfc_enable_mds_diags: Enable MDS Diagnostics
5806  *       0  = MDS Diagnostics disabled (default)
5807  *       1  = MDS Diagnostics enabled
5808  * Value range is [0,1]. Default value is 0.
5809  */
5810 LPFC_ATTR_RW(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");
5811
5812 /*
5813  * lpfc_ras_fwlog_buffsize: Firmware logging host buffer size
5814  *      0 = Disable firmware logging (default)
5815  *      [1-4] = Multiple of 1/4th Mb of host memory for FW logging
5816  * Value range [0..4]. Default value is 0
5817  */
5818 LPFC_ATTR(ras_fwlog_buffsize, 0, 0, 4, "Host memory for FW logging");
5819 lpfc_param_show(ras_fwlog_buffsize);
5820
5821 static ssize_t
5822 lpfc_ras_fwlog_buffsize_set(struct lpfc_hba  *phba, uint val)
5823 {
5824         int ret = 0;
5825         enum ras_state state;
5826
5827         if (!lpfc_rangecheck(val, 0, 4))
5828                 return -EINVAL;
5829
5830         if (phba->cfg_ras_fwlog_buffsize == val)
5831                 return 0;
5832
5833         if (phba->cfg_ras_fwlog_func != PCI_FUNC(phba->pcidev->devfn))
5834                 return -EINVAL;
5835
5836         spin_lock_irq(&phba->hbalock);
5837         state = phba->ras_fwlog.state;
5838         spin_unlock_irq(&phba->hbalock);
5839
5840         if (state == REG_INPROGRESS) {
5841                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, "6147 RAS Logging "
5842                                 "registration is in progress\n");
5843                 return -EBUSY;
5844         }
5845
5846         /* For disable logging: stop the logs and free the DMA.
5847          * For ras_fwlog_buffsize size change we still need to free and
5848          * reallocate the DMA in lpfc_sli4_ras_fwlog_init.
5849          */
5850         phba->cfg_ras_fwlog_buffsize = val;
5851         if (state == ACTIVE) {
5852                 lpfc_ras_stop_fwlog(phba);
5853                 lpfc_sli4_ras_dma_free(phba);
5854         }
5855
5856         lpfc_sli4_ras_init(phba);
5857         if (phba->ras_fwlog.ras_enabled)
5858                 ret = lpfc_sli4_ras_fwlog_init(phba, phba->cfg_ras_fwlog_level,
5859                                                LPFC_RAS_ENABLE_LOGGING);
5860         return ret;
5861 }
5862
5863 lpfc_param_store(ras_fwlog_buffsize);
5864 static DEVICE_ATTR_RW(lpfc_ras_fwlog_buffsize);
5865
5866 /*
5867  * lpfc_ras_fwlog_level: Firmware logging verbosity level
5868  * Valid only if firmware logging is enabled
5869  * 0(Least Verbosity) 4 (most verbosity)
5870  * Value range is [0..4]. Default value is 0
5871  */
5872 LPFC_ATTR_RW(ras_fwlog_level, 0, 0, 4, "Firmware Logging Level");
5873
5874 /*
5875  * lpfc_ras_fwlog_func: Firmware logging enabled on function number
5876  * Default function which has RAS support : 0
5877  * Value Range is [0..7].
5878  * FW logging is a global action and enablement is via a specific
5879  * port.
5880  */
5881 LPFC_ATTR_RW(ras_fwlog_func, 0, 0, 7, "Firmware Logging Enabled on Function");
5882
5883 /*
5884  * lpfc_enable_bbcr: Enable BB Credit Recovery
5885  *       0  = BB Credit Recovery disabled
5886  *       1  = BB Credit Recovery enabled (default)
5887  * Value range is [0,1]. Default value is 1.
5888  */
5889 LPFC_BBCR_ATTR_RW(enable_bbcr, 1, 0, 1, "Enable BBC Recovery");
5890
5891 /* Signaling module parameters */
5892 int lpfc_fabric_cgn_frequency = 100; /* 100 ms default */
5893 module_param(lpfc_fabric_cgn_frequency, int, 0444);
5894 MODULE_PARM_DESC(lpfc_fabric_cgn_frequency, "Congestion signaling fabric freq");
5895
5896 int lpfc_acqe_cgn_frequency = 10; /* 10 sec default */
5897 module_param(lpfc_acqe_cgn_frequency, int, 0444);
5898 MODULE_PARM_DESC(lpfc_acqe_cgn_frequency, "Congestion signaling ACQE freq");
5899
5900 int lpfc_use_cgn_signal = 1; /* 0 - only use FPINs, 1 - Use signals if avail  */
5901 module_param(lpfc_use_cgn_signal, int, 0444);
5902 MODULE_PARM_DESC(lpfc_use_cgn_signal, "Use Congestion signaling if available");
5903
5904 /*
5905  * lpfc_enable_dpp: Enable DPP on G7
5906  *       0  = DPP on G7 disabled
5907  *       1  = DPP on G7 enabled (default)
5908  * Value range is [0,1]. Default value is 1.
5909  */
5910 LPFC_ATTR_RW(enable_dpp, 1, 0, 1, "Enable Direct Packet Push");
5911
5912 /*
5913  * lpfc_enable_mi: Enable FDMI MIB
5914  *       0  = disabled
5915  *       1  = enabled (default)
5916  * Value range is [0,1].
5917  */
5918 LPFC_ATTR_R(enable_mi, 1, 0, 1, "Enable MI");
5919
5920 /*
5921  * lpfc_max_vmid: Maximum number of VMs to be tagged. This is valid only if
5922  * either vmid_app_header or vmid_priority_tagging is enabled.
5923  *       4 - 255  = vmid support enabled for 4-255 VMs
5924  *       Value range is [4,255].
5925  */
5926 LPFC_ATTR_RW(max_vmid, LPFC_MIN_VMID, LPFC_MIN_VMID, LPFC_MAX_VMID,
5927              "Maximum number of VMs supported");
5928
5929 /*
5930  * lpfc_vmid_inactivity_timeout: Inactivity timeout duration in hours
5931  *       0  = Timeout is disabled
5932  * Value range is [0,24].
5933  */
5934 LPFC_ATTR_RW(vmid_inactivity_timeout, 4, 0, 24,
5935              "Inactivity timeout in hours");
5936
5937 /*
5938  * lpfc_vmid_app_header: Enable App Header VMID support
5939  *       0  = Support is disabled (default)
5940  *       1  = Support is enabled
5941  * Value range is [0,1].
5942  */
5943 LPFC_ATTR_RW(vmid_app_header, LPFC_VMID_APP_HEADER_DISABLE,
5944              LPFC_VMID_APP_HEADER_DISABLE, LPFC_VMID_APP_HEADER_ENABLE,
5945              "Enable App Header VMID support");
5946
5947 /*
5948  * lpfc_vmid_priority_tagging: Enable Priority Tagging VMID support
5949  *       0  = Support is disabled (default)
5950  *       1  = Allow supported targets only
5951  *       2  = Allow all targets
5952  * Value range is [0,2].
5953  */
5954 LPFC_ATTR_RW(vmid_priority_tagging, LPFC_VMID_PRIO_TAG_DISABLE,
5955              LPFC_VMID_PRIO_TAG_DISABLE,
5956              LPFC_VMID_PRIO_TAG_ALL_TARGETS,
5957              "Enable Priority Tagging VMID support");
5958
5959 static struct attribute *lpfc_hba_attrs[] = {
5960         &dev_attr_nvme_info.attr,
5961         &dev_attr_scsi_stat.attr,
5962         &dev_attr_bg_info.attr,
5963         &dev_attr_bg_guard_err.attr,
5964         &dev_attr_bg_apptag_err.attr,
5965         &dev_attr_bg_reftag_err.attr,
5966         &dev_attr_info.attr,
5967         &dev_attr_serialnum.attr,
5968         &dev_attr_modeldesc.attr,
5969         &dev_attr_modelname.attr,
5970         &dev_attr_programtype.attr,
5971         &dev_attr_portnum.attr,
5972         &dev_attr_fwrev.attr,
5973         &dev_attr_hdw.attr,
5974         &dev_attr_option_rom_version.attr,
5975         &dev_attr_link_state.attr,
5976         &dev_attr_num_discovered_ports.attr,
5977         &dev_attr_lpfc_drvr_version.attr,
5978         &dev_attr_lpfc_enable_fip.attr,
5979         &dev_attr_lpfc_temp_sensor.attr,
5980         &dev_attr_lpfc_log_verbose.attr,
5981         &dev_attr_lpfc_lun_queue_depth.attr,
5982         &dev_attr_lpfc_tgt_queue_depth.attr,
5983         &dev_attr_lpfc_hba_queue_depth.attr,
5984         &dev_attr_lpfc_peer_port_login.attr,
5985         &dev_attr_lpfc_nodev_tmo.attr,
5986         &dev_attr_lpfc_devloss_tmo.attr,
5987         &dev_attr_lpfc_enable_fc4_type.attr,
5988         &dev_attr_lpfc_fcp_class.attr,
5989         &dev_attr_lpfc_use_adisc.attr,
5990         &dev_attr_lpfc_first_burst_size.attr,
5991         &dev_attr_lpfc_ack0.attr,
5992         &dev_attr_lpfc_xri_rebalancing.attr,
5993         &dev_attr_lpfc_topology.attr,
5994         &dev_attr_lpfc_scan_down.attr,
5995         &dev_attr_lpfc_link_speed.attr,
5996         &dev_attr_lpfc_fcp_io_sched.attr,
5997         &dev_attr_lpfc_ns_query.attr,
5998         &dev_attr_lpfc_fcp2_no_tgt_reset.attr,
5999         &dev_attr_lpfc_cr_delay.attr,
6000         &dev_attr_lpfc_cr_count.attr,
6001         &dev_attr_lpfc_multi_ring_support.attr,
6002         &dev_attr_lpfc_multi_ring_rctl.attr,
6003         &dev_attr_lpfc_multi_ring_type.attr,
6004         &dev_attr_lpfc_fdmi_on.attr,
6005         &dev_attr_lpfc_enable_SmartSAN.attr,
6006         &dev_attr_lpfc_max_luns.attr,
6007         &dev_attr_lpfc_enable_npiv.attr,
6008         &dev_attr_lpfc_fcf_failover_policy.attr,
6009         &dev_attr_lpfc_enable_rrq.attr,
6010         &dev_attr_lpfc_fcp_wait_abts_rsp.attr,
6011         &dev_attr_nport_evt_cnt.attr,
6012         &dev_attr_board_mode.attr,
6013         &dev_attr_lpfc_xcvr_data.attr,
6014         &dev_attr_max_vpi.attr,
6015         &dev_attr_used_vpi.attr,
6016         &dev_attr_max_rpi.attr,
6017         &dev_attr_used_rpi.attr,
6018         &dev_attr_max_xri.attr,
6019         &dev_attr_used_xri.attr,
6020         &dev_attr_npiv_info.attr,
6021         &dev_attr_issue_reset.attr,
6022         &dev_attr_lpfc_poll.attr,
6023         &dev_attr_lpfc_poll_tmo.attr,
6024         &dev_attr_lpfc_task_mgmt_tmo.attr,
6025         &dev_attr_lpfc_use_msi.attr,
6026         &dev_attr_lpfc_nvme_oas.attr,
6027         &dev_attr_lpfc_nvme_embed_cmd.attr,
6028         &dev_attr_lpfc_fcp_imax.attr,
6029         &dev_attr_lpfc_force_rscn.attr,
6030         &dev_attr_lpfc_cq_poll_threshold.attr,
6031         &dev_attr_lpfc_cq_max_proc_limit.attr,
6032         &dev_attr_lpfc_fcp_cpu_map.attr,
6033         &dev_attr_lpfc_fcp_mq_threshold.attr,
6034         &dev_attr_lpfc_hdw_queue.attr,
6035         &dev_attr_lpfc_irq_chann.attr,
6036         &dev_attr_lpfc_suppress_rsp.attr,
6037         &dev_attr_lpfc_nvmet_mrq.attr,
6038         &dev_attr_lpfc_nvmet_mrq_post.attr,
6039         &dev_attr_lpfc_nvme_enable_fb.attr,
6040         &dev_attr_lpfc_nvmet_fb_size.attr,
6041         &dev_attr_lpfc_enable_bg.attr,
6042         &dev_attr_lpfc_enable_hba_reset.attr,
6043         &dev_attr_lpfc_enable_hba_heartbeat.attr,
6044         &dev_attr_lpfc_EnableXLane.attr,
6045         &dev_attr_lpfc_XLanePriority.attr,
6046         &dev_attr_lpfc_xlane_lun.attr,
6047         &dev_attr_lpfc_xlane_tgt.attr,
6048         &dev_attr_lpfc_xlane_vpt.attr,
6049         &dev_attr_lpfc_xlane_lun_state.attr,
6050         &dev_attr_lpfc_xlane_lun_status.attr,
6051         &dev_attr_lpfc_xlane_priority.attr,
6052         &dev_attr_lpfc_sg_seg_cnt.attr,
6053         &dev_attr_lpfc_max_scsicmpl_time.attr,
6054         &dev_attr_lpfc_aer_support.attr,
6055         &dev_attr_lpfc_aer_state_cleanup.attr,
6056         &dev_attr_lpfc_sriov_nr_virtfn.attr,
6057         &dev_attr_lpfc_req_fw_upgrade.attr,
6058         &dev_attr_lpfc_suppress_link_up.attr,
6059         &dev_attr_iocb_hw.attr,
6060         &dev_attr_pls.attr,
6061         &dev_attr_pt.attr,
6062         &dev_attr_txq_hw.attr,
6063         &dev_attr_txcmplq_hw.attr,
6064         &dev_attr_lpfc_sriov_hw_max_virtfn.attr,
6065         &dev_attr_protocol.attr,
6066         &dev_attr_lpfc_xlane_supported.attr,
6067         &dev_attr_lpfc_enable_mds_diags.attr,
6068         &dev_attr_lpfc_ras_fwlog_buffsize.attr,
6069         &dev_attr_lpfc_ras_fwlog_level.attr,
6070         &dev_attr_lpfc_ras_fwlog_func.attr,
6071         &dev_attr_lpfc_enable_bbcr.attr,
6072         &dev_attr_lpfc_enable_dpp.attr,
6073         &dev_attr_lpfc_enable_mi.attr,
6074         &dev_attr_cmf_info.attr,
6075         &dev_attr_lpfc_max_vmid.attr,
6076         &dev_attr_lpfc_vmid_inactivity_timeout.attr,
6077         &dev_attr_lpfc_vmid_app_header.attr,
6078         &dev_attr_lpfc_vmid_priority_tagging.attr,
6079         NULL,
6080 };
6081
6082 static const struct attribute_group lpfc_hba_attr_group = {
6083         .attrs = lpfc_hba_attrs
6084 };
6085
6086 const struct attribute_group *lpfc_hba_groups[] = {
6087         &lpfc_hba_attr_group,
6088         NULL
6089 };
6090
6091 static struct attribute *lpfc_vport_attrs[] = {
6092         &dev_attr_info.attr,
6093         &dev_attr_link_state.attr,
6094         &dev_attr_num_discovered_ports.attr,
6095         &dev_attr_lpfc_drvr_version.attr,
6096         &dev_attr_lpfc_log_verbose.attr,
6097         &dev_attr_lpfc_lun_queue_depth.attr,
6098         &dev_attr_lpfc_tgt_queue_depth.attr,
6099         &dev_attr_lpfc_nodev_tmo.attr,
6100         &dev_attr_lpfc_devloss_tmo.attr,
6101         &dev_attr_lpfc_hba_queue_depth.attr,
6102         &dev_attr_lpfc_peer_port_login.attr,
6103         &dev_attr_lpfc_restrict_login.attr,
6104         &dev_attr_lpfc_fcp_class.attr,
6105         &dev_attr_lpfc_use_adisc.attr,
6106         &dev_attr_lpfc_first_burst_size.attr,
6107         &dev_attr_lpfc_max_luns.attr,
6108         &dev_attr_nport_evt_cnt.attr,
6109         &dev_attr_npiv_info.attr,
6110         &dev_attr_lpfc_enable_da_id.attr,
6111         &dev_attr_lpfc_max_scsicmpl_time.attr,
6112         &dev_attr_lpfc_static_vport.attr,
6113         &dev_attr_cmf_info.attr,
6114         NULL,
6115 };
6116
6117 static const struct attribute_group lpfc_vport_attr_group = {
6118         .attrs = lpfc_vport_attrs
6119 };
6120
6121 const struct attribute_group *lpfc_vport_groups[] = {
6122         &lpfc_vport_attr_group,
6123         NULL
6124 };
6125
6126 /**
6127  * sysfs_ctlreg_write - Write method for writing to ctlreg
6128  * @filp: open sysfs file
6129  * @kobj: kernel kobject that contains the kernel class device.
6130  * @bin_attr: kernel attributes passed to us.
6131  * @buf: contains the data to be written to the adapter IOREG space.
6132  * @off: offset into buffer to beginning of data.
6133  * @count: bytes to transfer.
6134  *
6135  * Description:
6136  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
6137  * Uses the adapter io control registers to send buf contents to the adapter.
6138  *
6139  * Returns:
6140  * -ERANGE off and count combo out of range
6141  * -EINVAL off, count or buff address invalid
6142  * -EPERM adapter is offline
6143  * value of count, buf contents written
6144  **/
6145 static ssize_t
6146 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
6147                    struct bin_attribute *bin_attr,
6148                    char *buf, loff_t off, size_t count)
6149 {
6150         size_t buf_off;
6151         struct device *dev = container_of(kobj, struct device, kobj);
6152         struct Scsi_Host  *shost = class_to_shost(dev);
6153         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6154         struct lpfc_hba   *phba = vport->phba;
6155
6156         if (phba->sli_rev >= LPFC_SLI_REV4)
6157                 return -EPERM;
6158
6159         if ((off + count) > FF_REG_AREA_SIZE)
6160                 return -ERANGE;
6161
6162         if (count <= LPFC_REG_WRITE_KEY_SIZE)
6163                 return 0;
6164
6165         if (off % 4 || count % 4 || (unsigned long)buf % 4)
6166                 return -EINVAL;
6167
6168         /* This is to protect HBA registers from accidental writes. */
6169         if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
6170                 return -EINVAL;
6171
6172         if (!(vport->fc_flag & FC_OFFLINE_MODE))
6173                 return -EPERM;
6174
6175         spin_lock_irq(&phba->hbalock);
6176         for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
6177                         buf_off += sizeof(uint32_t))
6178                 writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
6179                        phba->ctrl_regs_memmap_p + off + buf_off);
6180
6181         spin_unlock_irq(&phba->hbalock);
6182
6183         return count;
6184 }
6185
6186 /**
6187  * sysfs_ctlreg_read - Read method for reading from ctlreg
6188  * @filp: open sysfs file
6189  * @kobj: kernel kobject that contains the kernel class device.
6190  * @bin_attr: kernel attributes passed to us.
6191  * @buf: if successful contains the data from the adapter IOREG space.
6192  * @off: offset into buffer to beginning of data.
6193  * @count: bytes to transfer.
6194  *
6195  * Description:
6196  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
6197  * Uses the adapter io control registers to read data into buf.
6198  *
6199  * Returns:
6200  * -ERANGE off and count combo out of range
6201  * -EINVAL off, count or buff address invalid
6202  * value of count, buf contents read
6203  **/
6204 static ssize_t
6205 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
6206                   struct bin_attribute *bin_attr,
6207                   char *buf, loff_t off, size_t count)
6208 {
6209         size_t buf_off;
6210         uint32_t * tmp_ptr;
6211         struct device *dev = container_of(kobj, struct device, kobj);
6212         struct Scsi_Host  *shost = class_to_shost(dev);
6213         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6214         struct lpfc_hba   *phba = vport->phba;
6215
6216         if (phba->sli_rev >= LPFC_SLI_REV4)
6217                 return -EPERM;
6218
6219         if (off > FF_REG_AREA_SIZE)
6220                 return -ERANGE;
6221
6222         if ((off + count) > FF_REG_AREA_SIZE)
6223                 count = FF_REG_AREA_SIZE - off;
6224
6225         if (count == 0) return 0;
6226
6227         if (off % 4 || count % 4 || (unsigned long)buf % 4)
6228                 return -EINVAL;
6229
6230         spin_lock_irq(&phba->hbalock);
6231
6232         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
6233                 tmp_ptr = (uint32_t *)(buf + buf_off);
6234                 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
6235         }
6236
6237         spin_unlock_irq(&phba->hbalock);
6238
6239         return count;
6240 }
6241
6242 static struct bin_attribute sysfs_ctlreg_attr = {
6243         .attr = {
6244                 .name = "ctlreg",
6245                 .mode = S_IRUSR | S_IWUSR,
6246         },
6247         .size = 256,
6248         .read = sysfs_ctlreg_read,
6249         .write = sysfs_ctlreg_write,
6250 };
6251
6252 /**
6253  * sysfs_mbox_write - Write method for writing information via mbox
6254  * @filp: open sysfs file
6255  * @kobj: kernel kobject that contains the kernel class device.
6256  * @bin_attr: kernel attributes passed to us.
6257  * @buf: contains the data to be written to sysfs mbox.
6258  * @off: offset into buffer to beginning of data.
6259  * @count: bytes to transfer.
6260  *
6261  * Description:
6262  * Deprecated function. All mailbox access from user space is performed via the
6263  * bsg interface.
6264  *
6265  * Returns:
6266  * -EPERM operation not permitted
6267  **/
6268 static ssize_t
6269 sysfs_mbox_write(struct file *filp, struct kobject *kobj,
6270                  struct bin_attribute *bin_attr,
6271                  char *buf, loff_t off, size_t count)
6272 {
6273         return -EPERM;
6274 }
6275
6276 /**
6277  * sysfs_mbox_read - Read method for reading information via mbox
6278  * @filp: open sysfs file
6279  * @kobj: kernel kobject that contains the kernel class device.
6280  * @bin_attr: kernel attributes passed to us.
6281  * @buf: contains the data to be read from sysfs mbox.
6282  * @off: offset into buffer to beginning of data.
6283  * @count: bytes to transfer.
6284  *
6285  * Description:
6286  * Deprecated function. All mailbox access from user space is performed via the
6287  * bsg interface.
6288  *
6289  * Returns:
6290  * -EPERM operation not permitted
6291  **/
6292 static ssize_t
6293 sysfs_mbox_read(struct file *filp, struct kobject *kobj,
6294                 struct bin_attribute *bin_attr,
6295                 char *buf, loff_t off, size_t count)
6296 {
6297         return -EPERM;
6298 }
6299
6300 static struct bin_attribute sysfs_mbox_attr = {
6301         .attr = {
6302                 .name = "mbox",
6303                 .mode = S_IRUSR | S_IWUSR,
6304         },
6305         .size = MAILBOX_SYSFS_MAX,
6306         .read = sysfs_mbox_read,
6307         .write = sysfs_mbox_write,
6308 };
6309
6310 /**
6311  * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
6312  * @vport: address of lpfc vport structure.
6313  *
6314  * Return codes:
6315  * zero on success
6316  * error return code from sysfs_create_bin_file()
6317  **/
6318 int
6319 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
6320 {
6321         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
6322         int error;
6323
6324         /* Virtual ports do not need ctrl_reg and mbox */
6325         if (vport->port_type == LPFC_NPIV_PORT)
6326                 return 0;
6327
6328         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
6329                                       &sysfs_ctlreg_attr);
6330         if (error)
6331                 goto out;
6332
6333         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
6334                                       &sysfs_mbox_attr);
6335         if (error)
6336                 goto out_remove_ctlreg_attr;
6337
6338         return 0;
6339 out_remove_ctlreg_attr:
6340         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
6341 out:
6342         return error;
6343 }
6344
6345 /**
6346  * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
6347  * @vport: address of lpfc vport structure.
6348  **/
6349 void
6350 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
6351 {
6352         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
6353
6354         /* Virtual ports do not need ctrl_reg and mbox */
6355         if (vport->port_type == LPFC_NPIV_PORT)
6356                 return;
6357         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
6358         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
6359 }
6360
6361 /*
6362  * Dynamic FC Host Attributes Support
6363  */
6364
6365 /**
6366  * lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host
6367  * @shost: kernel scsi host pointer.
6368  **/
6369 static void
6370 lpfc_get_host_symbolic_name(struct Scsi_Host *shost)
6371 {
6372         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
6373
6374         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
6375                                       sizeof fc_host_symbolic_name(shost));
6376 }
6377
6378 /**
6379  * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
6380  * @shost: kernel scsi host pointer.
6381  **/
6382 static void
6383 lpfc_get_host_port_id(struct Scsi_Host *shost)
6384 {
6385         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6386
6387         /* note: fc_myDID already in cpu endianness */
6388         fc_host_port_id(shost) = vport->fc_myDID;
6389 }
6390
6391 /**
6392  * lpfc_get_host_port_type - Set the value of the scsi host port type
6393  * @shost: kernel scsi host pointer.
6394  **/
6395 static void
6396 lpfc_get_host_port_type(struct Scsi_Host *shost)
6397 {
6398         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6399         struct lpfc_hba   *phba = vport->phba;
6400
6401         spin_lock_irq(shost->host_lock);
6402
6403         if (vport->port_type == LPFC_NPIV_PORT) {
6404                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
6405         } else if (lpfc_is_link_up(phba)) {
6406                 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
6407                         if (vport->fc_flag & FC_PUBLIC_LOOP)
6408                                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
6409                         else
6410                                 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
6411                 } else {
6412                         if (vport->fc_flag & FC_FABRIC)
6413                                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
6414                         else
6415                                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
6416                 }
6417         } else
6418                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
6419
6420         spin_unlock_irq(shost->host_lock);
6421 }
6422
6423 /**
6424  * lpfc_get_host_port_state - Set the value of the scsi host port state
6425  * @shost: kernel scsi host pointer.
6426  **/
6427 static void
6428 lpfc_get_host_port_state(struct Scsi_Host *shost)
6429 {
6430         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6431         struct lpfc_hba   *phba = vport->phba;
6432
6433         spin_lock_irq(shost->host_lock);
6434
6435         if (vport->fc_flag & FC_OFFLINE_MODE)
6436                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
6437         else {
6438                 switch (phba->link_state) {
6439                 case LPFC_LINK_UNKNOWN:
6440                 case LPFC_LINK_DOWN:
6441                         fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
6442                         break;
6443                 case LPFC_LINK_UP:
6444                 case LPFC_CLEAR_LA:
6445                 case LPFC_HBA_READY:
6446                         /* Links up, reports port state accordingly */
6447                         if (vport->port_state < LPFC_VPORT_READY)
6448                                 fc_host_port_state(shost) =
6449                                                         FC_PORTSTATE_BYPASSED;
6450                         else
6451                                 fc_host_port_state(shost) =
6452                                                         FC_PORTSTATE_ONLINE;
6453                         break;
6454                 case LPFC_HBA_ERROR:
6455                         fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
6456                         break;
6457                 default:
6458                         fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
6459                         break;
6460                 }
6461         }
6462
6463         spin_unlock_irq(shost->host_lock);
6464 }
6465
6466 /**
6467  * lpfc_get_host_speed - Set the value of the scsi host speed
6468  * @shost: kernel scsi host pointer.
6469  **/
6470 static void
6471 lpfc_get_host_speed(struct Scsi_Host *shost)
6472 {
6473         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6474         struct lpfc_hba   *phba = vport->phba;
6475
6476         spin_lock_irq(shost->host_lock);
6477
6478         if ((lpfc_is_link_up(phba)) && (!(phba->hba_flag & HBA_FCOE_MODE))) {
6479                 switch(phba->fc_linkspeed) {
6480                 case LPFC_LINK_SPEED_1GHZ:
6481                         fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
6482                         break;
6483                 case LPFC_LINK_SPEED_2GHZ:
6484                         fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
6485                         break;
6486                 case LPFC_LINK_SPEED_4GHZ:
6487                         fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
6488                         break;
6489                 case LPFC_LINK_SPEED_8GHZ:
6490                         fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
6491                         break;
6492                 case LPFC_LINK_SPEED_10GHZ:
6493                         fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
6494                         break;
6495                 case LPFC_LINK_SPEED_16GHZ:
6496                         fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
6497                         break;
6498                 case LPFC_LINK_SPEED_32GHZ:
6499                         fc_host_speed(shost) = FC_PORTSPEED_32GBIT;
6500                         break;
6501                 case LPFC_LINK_SPEED_64GHZ:
6502                         fc_host_speed(shost) = FC_PORTSPEED_64GBIT;
6503                         break;
6504                 case LPFC_LINK_SPEED_128GHZ:
6505                         fc_host_speed(shost) = FC_PORTSPEED_128GBIT;
6506                         break;
6507                 case LPFC_LINK_SPEED_256GHZ:
6508                         fc_host_speed(shost) = FC_PORTSPEED_256GBIT;
6509                         break;
6510                 default:
6511                         fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6512                         break;
6513                 }
6514         } else if (lpfc_is_link_up(phba) && (phba->hba_flag & HBA_FCOE_MODE)) {
6515                 switch (phba->fc_linkspeed) {
6516                 case LPFC_ASYNC_LINK_SPEED_1GBPS:
6517                         fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
6518                         break;
6519                 case LPFC_ASYNC_LINK_SPEED_10GBPS:
6520                         fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
6521                         break;
6522                 case LPFC_ASYNC_LINK_SPEED_20GBPS:
6523                         fc_host_speed(shost) = FC_PORTSPEED_20GBIT;
6524                         break;
6525                 case LPFC_ASYNC_LINK_SPEED_25GBPS:
6526                         fc_host_speed(shost) = FC_PORTSPEED_25GBIT;
6527                         break;
6528                 case LPFC_ASYNC_LINK_SPEED_40GBPS:
6529                         fc_host_speed(shost) = FC_PORTSPEED_40GBIT;
6530                         break;
6531                 case LPFC_ASYNC_LINK_SPEED_100GBPS:
6532                         fc_host_speed(shost) = FC_PORTSPEED_100GBIT;
6533                         break;
6534                 default:
6535                         fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6536                         break;
6537                 }
6538         } else
6539                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6540
6541         spin_unlock_irq(shost->host_lock);
6542 }
6543
6544 /**
6545  * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
6546  * @shost: kernel scsi host pointer.
6547  **/
6548 static void
6549 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
6550 {
6551         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6552         struct lpfc_hba   *phba = vport->phba;
6553         u64 node_name;
6554
6555         spin_lock_irq(shost->host_lock);
6556
6557         if ((vport->port_state > LPFC_FLOGI) &&
6558             ((vport->fc_flag & FC_FABRIC) ||
6559              ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
6560               (vport->fc_flag & FC_PUBLIC_LOOP))))
6561                 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
6562         else
6563                 /* fabric is local port if there is no F/FL_Port */
6564                 node_name = 0;
6565
6566         spin_unlock_irq(shost->host_lock);
6567
6568         fc_host_fabric_name(shost) = node_name;
6569 }
6570
6571 /**
6572  * lpfc_get_stats - Return statistical information about the adapter
6573  * @shost: kernel scsi host pointer.
6574  *
6575  * Notes:
6576  * NULL on error for link down, no mbox pool, sli2 active,
6577  * management not allowed, memory allocation error, or mbox error.
6578  *
6579  * Returns:
6580  * NULL for error
6581  * address of the adapter host statistics
6582  **/
6583 static struct fc_host_statistics *
6584 lpfc_get_stats(struct Scsi_Host *shost)
6585 {
6586         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6587         struct lpfc_hba   *phba = vport->phba;
6588         struct lpfc_sli   *psli = &phba->sli;
6589         struct fc_host_statistics *hs = &phba->link_stats;
6590         struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
6591         LPFC_MBOXQ_t *pmboxq;
6592         MAILBOX_t *pmb;
6593         int rc = 0;
6594
6595         /*
6596          * prevent udev from issuing mailbox commands until the port is
6597          * configured.
6598          */
6599         if (phba->link_state < LPFC_LINK_DOWN ||
6600             !phba->mbox_mem_pool ||
6601             (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
6602                 return NULL;
6603
6604         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
6605                 return NULL;
6606
6607         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6608         if (!pmboxq)
6609                 return NULL;
6610         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6611
6612         pmb = &pmboxq->u.mb;
6613         pmb->mbxCommand = MBX_READ_STATUS;
6614         pmb->mbxOwner = OWN_HOST;
6615         pmboxq->ctx_buf = NULL;
6616         pmboxq->vport = vport;
6617
6618         if (vport->fc_flag & FC_OFFLINE_MODE) {
6619                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6620                 if (rc != MBX_SUCCESS) {
6621                         mempool_free(pmboxq, phba->mbox_mem_pool);
6622                         return NULL;
6623                 }
6624         } else {
6625                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6626                 if (rc != MBX_SUCCESS) {
6627                         if (rc != MBX_TIMEOUT)
6628                                 mempool_free(pmboxq, phba->mbox_mem_pool);
6629                         return NULL;
6630                 }
6631         }
6632
6633         memset(hs, 0, sizeof (struct fc_host_statistics));
6634
6635         hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
6636         hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
6637
6638         /*
6639          * The MBX_READ_STATUS returns tx_k_bytes which has to be
6640          * converted to words.
6641          *
6642          * Check if extended byte flag is set, to know when to collect upper
6643          * bits of 64 bit wide statistics counter.
6644          */
6645         if (pmb->un.varRdStatus.xkb & RD_ST_XKB) {
6646                 hs->tx_words = (u64)
6647                                ((((u64)(pmb->un.varRdStatus.xmit_xkb &
6648                                         RD_ST_XMIT_XKB_MASK) << 32) |
6649                                 (u64)pmb->un.varRdStatus.xmitByteCnt) *
6650                                 (u64)256);
6651                 hs->rx_words = (u64)
6652                                ((((u64)(pmb->un.varRdStatus.rcv_xkb &
6653                                         RD_ST_RCV_XKB_MASK) << 32) |
6654                                 (u64)pmb->un.varRdStatus.rcvByteCnt) *
6655                                 (u64)256);
6656         } else {
6657                 hs->tx_words = (uint64_t)
6658                                 ((uint64_t)pmb->un.varRdStatus.xmitByteCnt
6659                                 * (uint64_t)256);
6660                 hs->rx_words = (uint64_t)
6661                                 ((uint64_t)pmb->un.varRdStatus.rcvByteCnt
6662                                  * (uint64_t)256);
6663         }
6664
6665         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6666         pmb->mbxCommand = MBX_READ_LNK_STAT;
6667         pmb->mbxOwner = OWN_HOST;
6668         pmboxq->ctx_buf = NULL;
6669         pmboxq->vport = vport;
6670
6671         if (vport->fc_flag & FC_OFFLINE_MODE) {
6672                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6673                 if (rc != MBX_SUCCESS) {
6674                         mempool_free(pmboxq, phba->mbox_mem_pool);
6675                         return NULL;
6676                 }
6677         } else {
6678                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6679                 if (rc != MBX_SUCCESS) {
6680                         if (rc != MBX_TIMEOUT)
6681                                 mempool_free(pmboxq, phba->mbox_mem_pool);
6682                         return NULL;
6683                 }
6684         }
6685
6686         hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
6687         hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
6688         hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
6689         hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
6690         hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
6691         hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
6692         hs->error_frames = pmb->un.varRdLnk.crcCnt;
6693
6694         hs->cn_sig_warn = atomic64_read(&phba->cgn_acqe_stat.warn);
6695         hs->cn_sig_alarm = atomic64_read(&phba->cgn_acqe_stat.alarm);
6696
6697         hs->link_failure_count -= lso->link_failure_count;
6698         hs->loss_of_sync_count -= lso->loss_of_sync_count;
6699         hs->loss_of_signal_count -= lso->loss_of_signal_count;
6700         hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
6701         hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
6702         hs->invalid_crc_count -= lso->invalid_crc_count;
6703         hs->error_frames -= lso->error_frames;
6704
6705         if (phba->hba_flag & HBA_FCOE_MODE) {
6706                 hs->lip_count = -1;
6707                 hs->nos_count = (phba->link_events >> 1);
6708                 hs->nos_count -= lso->link_events;
6709         } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
6710                 hs->lip_count = (phba->fc_eventTag >> 1);
6711                 hs->lip_count -= lso->link_events;
6712                 hs->nos_count = -1;
6713         } else {
6714                 hs->lip_count = -1;
6715                 hs->nos_count = (phba->fc_eventTag >> 1);
6716                 hs->nos_count -= lso->link_events;
6717         }
6718
6719         hs->dumped_frames = -1;
6720
6721         hs->seconds_since_last_reset = ktime_get_seconds() - psli->stats_start;
6722
6723         mempool_free(pmboxq, phba->mbox_mem_pool);
6724
6725         return hs;
6726 }
6727
6728 /**
6729  * lpfc_reset_stats - Copy the adapter link stats information
6730  * @shost: kernel scsi host pointer.
6731  **/
6732 static void
6733 lpfc_reset_stats(struct Scsi_Host *shost)
6734 {
6735         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6736         struct lpfc_hba   *phba = vport->phba;
6737         struct lpfc_sli   *psli = &phba->sli;
6738         struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
6739         LPFC_MBOXQ_t *pmboxq;
6740         MAILBOX_t *pmb;
6741         int rc = 0;
6742
6743         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
6744                 return;
6745
6746         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6747         if (!pmboxq)
6748                 return;
6749         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
6750
6751         pmb = &pmboxq->u.mb;
6752         pmb->mbxCommand = MBX_READ_STATUS;
6753         pmb->mbxOwner = OWN_HOST;
6754         pmb->un.varWords[0] = 0x1; /* reset request */
6755         pmboxq->ctx_buf = NULL;
6756         pmboxq->vport = vport;
6757
6758         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
6759                 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
6760                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6761                 if (rc != MBX_SUCCESS) {
6762                         mempool_free(pmboxq, phba->mbox_mem_pool);
6763                         return;
6764                 }
6765         } else {
6766                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6767                 if (rc != MBX_SUCCESS) {
6768                         if (rc != MBX_TIMEOUT)
6769                                 mempool_free(pmboxq, phba->mbox_mem_pool);
6770                         return;
6771                 }
6772         }
6773
6774         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
6775         pmb->mbxCommand = MBX_READ_LNK_STAT;
6776         pmb->mbxOwner = OWN_HOST;
6777         pmboxq->ctx_buf = NULL;
6778         pmboxq->vport = vport;
6779
6780         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
6781             (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
6782                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6783                 if (rc != MBX_SUCCESS) {
6784                         mempool_free(pmboxq, phba->mbox_mem_pool);
6785                         return;
6786                 }
6787         } else {
6788                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6789                 if (rc != MBX_SUCCESS) {
6790                         if (rc != MBX_TIMEOUT)
6791                                 mempool_free(pmboxq, phba->mbox_mem_pool);
6792                         return;
6793                 }
6794         }
6795
6796         lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
6797         lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
6798         lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
6799         lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
6800         lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
6801         lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
6802         lso->error_frames = pmb->un.varRdLnk.crcCnt;
6803         if (phba->hba_flag & HBA_FCOE_MODE)
6804                 lso->link_events = (phba->link_events >> 1);
6805         else
6806                 lso->link_events = (phba->fc_eventTag >> 1);
6807
6808         atomic64_set(&phba->cgn_acqe_stat.warn, 0);
6809         atomic64_set(&phba->cgn_acqe_stat.alarm, 0);
6810
6811         memset(&shost_to_fc_host(shost)->fpin_stats, 0,
6812                sizeof(shost_to_fc_host(shost)->fpin_stats));
6813
6814         psli->stats_start = ktime_get_seconds();
6815
6816         mempool_free(pmboxq, phba->mbox_mem_pool);
6817
6818         return;
6819 }
6820
6821 /*
6822  * The LPFC driver treats linkdown handling as target loss events so there
6823  * are no sysfs handlers for link_down_tmo.
6824  */
6825
6826 /**
6827  * lpfc_get_node_by_target - Return the nodelist for a target
6828  * @starget: kernel scsi target pointer.
6829  *
6830  * Returns:
6831  * address of the node list if found
6832  * NULL target not found
6833  **/
6834 static struct lpfc_nodelist *
6835 lpfc_get_node_by_target(struct scsi_target *starget)
6836 {
6837         struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
6838         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6839         struct lpfc_nodelist *ndlp;
6840
6841         spin_lock_irq(shost->host_lock);
6842         /* Search for this, mapped, target ID */
6843         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
6844                 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
6845                     starget->id == ndlp->nlp_sid) {
6846                         spin_unlock_irq(shost->host_lock);
6847                         return ndlp;
6848                 }
6849         }
6850         spin_unlock_irq(shost->host_lock);
6851         return NULL;
6852 }
6853
6854 /**
6855  * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
6856  * @starget: kernel scsi target pointer.
6857  **/
6858 static void
6859 lpfc_get_starget_port_id(struct scsi_target *starget)
6860 {
6861         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6862
6863         fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
6864 }
6865
6866 /**
6867  * lpfc_get_starget_node_name - Set the target node name
6868  * @starget: kernel scsi target pointer.
6869  *
6870  * Description: Set the target node name to the ndlp node name wwn or zero.
6871  **/
6872 static void
6873 lpfc_get_starget_node_name(struct scsi_target *starget)
6874 {
6875         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6876
6877         fc_starget_node_name(starget) =
6878                 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
6879 }
6880
6881 /**
6882  * lpfc_get_starget_port_name - Set the target port name
6883  * @starget: kernel scsi target pointer.
6884  *
6885  * Description:  set the target port name to the ndlp port name wwn or zero.
6886  **/
6887 static void
6888 lpfc_get_starget_port_name(struct scsi_target *starget)
6889 {
6890         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6891
6892         fc_starget_port_name(starget) =
6893                 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
6894 }
6895
6896 /**
6897  * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
6898  * @rport: fc rport address.
6899  * @timeout: new value for dev loss tmo.
6900  *
6901  * Description:
6902  * If timeout is non zero set the dev_loss_tmo to timeout, else set
6903  * dev_loss_tmo to one.
6904  **/
6905 static void
6906 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
6907 {
6908         struct lpfc_rport_data *rdata = rport->dd_data;
6909         struct lpfc_nodelist *ndlp = rdata->pnode;
6910 #if (IS_ENABLED(CONFIG_NVME_FC))
6911         struct lpfc_nvme_rport *nrport = NULL;
6912 #endif
6913
6914         if (timeout)
6915                 rport->dev_loss_tmo = timeout;
6916         else
6917                 rport->dev_loss_tmo = 1;
6918
6919         if (!ndlp) {
6920                 dev_info(&rport->dev, "Cannot find remote node to "
6921                                       "set rport dev loss tmo, port_id x%x\n",
6922                                       rport->port_id);
6923                 return;
6924         }
6925
6926 #if (IS_ENABLED(CONFIG_NVME_FC))
6927         nrport = lpfc_ndlp_get_nrport(ndlp);
6928
6929         if (nrport && nrport->remoteport)
6930                 nvme_fc_set_remoteport_devloss(nrport->remoteport,
6931                                                rport->dev_loss_tmo);
6932 #endif
6933 }
6934
6935 /*
6936  * lpfc_rport_show_function - Return rport target information
6937  *
6938  * Description:
6939  * Macro that uses field to generate a function with the name lpfc_show_rport_
6940  *
6941  * lpfc_show_rport_##field: returns the bytes formatted in buf
6942  * @cdev: class converted to an fc_rport.
6943  * @buf: on return contains the target_field or zero.
6944  *
6945  * Returns: size of formatted string.
6946  **/
6947 #define lpfc_rport_show_function(field, format_string, sz, cast)        \
6948 static ssize_t                                                          \
6949 lpfc_show_rport_##field (struct device *dev,                            \
6950                          struct device_attribute *attr,                 \
6951                          char *buf)                                     \
6952 {                                                                       \
6953         struct fc_rport *rport = transport_class_to_rport(dev);         \
6954         struct lpfc_rport_data *rdata = rport->hostdata;                \
6955         return scnprintf(buf, sz, format_string,                        \
6956                 (rdata->target) ? cast rdata->target->field : 0);       \
6957 }
6958
6959 #define lpfc_rport_rd_attr(field, format_string, sz)                    \
6960         lpfc_rport_show_function(field, format_string, sz, )            \
6961 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
6962
6963 /**
6964  * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
6965  * @fc_vport: The fc_vport who's symbolic name has been changed.
6966  *
6967  * Description:
6968  * This function is called by the transport after the @fc_vport's symbolic name
6969  * has been changed. This function re-registers the symbolic name with the
6970  * switch to propagate the change into the fabric if the vport is active.
6971  **/
6972 static void
6973 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
6974 {
6975         struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
6976
6977         if (vport->port_state == LPFC_VPORT_READY)
6978                 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
6979 }
6980
6981 /**
6982  * lpfc_hba_log_verbose_init - Set hba's log verbose level
6983  * @phba: Pointer to lpfc_hba struct.
6984  * @verbose: Verbose level to set.
6985  *
6986  * This function is called by the lpfc_get_cfgparam() routine to set the
6987  * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
6988  * log message according to the module's lpfc_log_verbose parameter setting
6989  * before hba port or vport created.
6990  **/
6991 static void
6992 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
6993 {
6994         phba->cfg_log_verbose = verbose;
6995 }
6996
6997 struct fc_function_template lpfc_transport_functions = {
6998         /* fixed attributes the driver supports */
6999         .show_host_node_name = 1,
7000         .show_host_port_name = 1,
7001         .show_host_supported_classes = 1,
7002         .show_host_supported_fc4s = 1,
7003         .show_host_supported_speeds = 1,
7004         .show_host_maxframe_size = 1,
7005
7006         .get_host_symbolic_name = lpfc_get_host_symbolic_name,
7007         .show_host_symbolic_name = 1,
7008
7009         /* dynamic attributes the driver supports */
7010         .get_host_port_id = lpfc_get_host_port_id,
7011         .show_host_port_id = 1,
7012
7013         .get_host_port_type = lpfc_get_host_port_type,
7014         .show_host_port_type = 1,
7015
7016         .get_host_port_state = lpfc_get_host_port_state,
7017         .show_host_port_state = 1,
7018
7019         /* active_fc4s is shown but doesn't change (thus no get function) */
7020         .show_host_active_fc4s = 1,
7021
7022         .get_host_speed = lpfc_get_host_speed,
7023         .show_host_speed = 1,
7024
7025         .get_host_fabric_name = lpfc_get_host_fabric_name,
7026         .show_host_fabric_name = 1,
7027
7028         /*
7029          * The LPFC driver treats linkdown handling as target loss events
7030          * so there are no sysfs handlers for link_down_tmo.
7031          */
7032
7033         .get_fc_host_stats = lpfc_get_stats,
7034         .reset_fc_host_stats = lpfc_reset_stats,
7035
7036         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
7037         .show_rport_maxframe_size = 1,
7038         .show_rport_supported_classes = 1,
7039
7040         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
7041         .show_rport_dev_loss_tmo = 1,
7042
7043         .get_starget_port_id  = lpfc_get_starget_port_id,
7044         .show_starget_port_id = 1,
7045
7046         .get_starget_node_name = lpfc_get_starget_node_name,
7047         .show_starget_node_name = 1,
7048
7049         .get_starget_port_name = lpfc_get_starget_port_name,
7050         .show_starget_port_name = 1,
7051
7052         .issue_fc_host_lip = lpfc_issue_lip,
7053         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
7054         .terminate_rport_io = lpfc_terminate_rport_io,
7055
7056         .dd_fcvport_size = sizeof(struct lpfc_vport *),
7057
7058         .vport_disable = lpfc_vport_disable,
7059
7060         .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
7061
7062         .bsg_request = lpfc_bsg_request,
7063         .bsg_timeout = lpfc_bsg_timeout,
7064 };
7065
7066 struct fc_function_template lpfc_vport_transport_functions = {
7067         /* fixed attributes the driver supports */
7068         .show_host_node_name = 1,
7069         .show_host_port_name = 1,
7070         .show_host_supported_classes = 1,
7071         .show_host_supported_fc4s = 1,
7072         .show_host_supported_speeds = 1,
7073         .show_host_maxframe_size = 1,
7074
7075         .get_host_symbolic_name = lpfc_get_host_symbolic_name,
7076         .show_host_symbolic_name = 1,
7077
7078         /* dynamic attributes the driver supports */
7079         .get_host_port_id = lpfc_get_host_port_id,
7080         .show_host_port_id = 1,
7081
7082         .get_host_port_type = lpfc_get_host_port_type,
7083         .show_host_port_type = 1,
7084
7085         .get_host_port_state = lpfc_get_host_port_state,
7086         .show_host_port_state = 1,
7087
7088         /* active_fc4s is shown but doesn't change (thus no get function) */
7089         .show_host_active_fc4s = 1,
7090
7091         .get_host_speed = lpfc_get_host_speed,
7092         .show_host_speed = 1,
7093
7094         .get_host_fabric_name = lpfc_get_host_fabric_name,
7095         .show_host_fabric_name = 1,
7096
7097         /*
7098          * The LPFC driver treats linkdown handling as target loss events
7099          * so there are no sysfs handlers for link_down_tmo.
7100          */
7101
7102         .get_fc_host_stats = lpfc_get_stats,
7103         .reset_fc_host_stats = lpfc_reset_stats,
7104
7105         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
7106         .show_rport_maxframe_size = 1,
7107         .show_rport_supported_classes = 1,
7108
7109         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
7110         .show_rport_dev_loss_tmo = 1,
7111
7112         .get_starget_port_id  = lpfc_get_starget_port_id,
7113         .show_starget_port_id = 1,
7114
7115         .get_starget_node_name = lpfc_get_starget_node_name,
7116         .show_starget_node_name = 1,
7117
7118         .get_starget_port_name = lpfc_get_starget_port_name,
7119         .show_starget_port_name = 1,
7120
7121         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
7122         .terminate_rport_io = lpfc_terminate_rport_io,
7123
7124         .vport_disable = lpfc_vport_disable,
7125
7126         .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
7127 };
7128
7129 /**
7130  * lpfc_get_hba_function_mode - Used to determine the HBA function in FCoE
7131  * Mode
7132  * @phba: lpfc_hba pointer.
7133  **/
7134 static void
7135 lpfc_get_hba_function_mode(struct lpfc_hba *phba)
7136 {
7137         /* If the adapter supports FCoE mode */
7138         switch (phba->pcidev->device) {
7139         case PCI_DEVICE_ID_SKYHAWK:
7140         case PCI_DEVICE_ID_SKYHAWK_VF:
7141         case PCI_DEVICE_ID_LANCER_FCOE:
7142         case PCI_DEVICE_ID_LANCER_FCOE_VF:
7143         case PCI_DEVICE_ID_ZEPHYR_DCSP:
7144         case PCI_DEVICE_ID_TIGERSHARK:
7145         case PCI_DEVICE_ID_TOMCAT:
7146                 phba->hba_flag |= HBA_FCOE_MODE;
7147                 break;
7148         default:
7149         /* for others, clear the flag */
7150                 phba->hba_flag &= ~HBA_FCOE_MODE;
7151         }
7152 }
7153
7154 /**
7155  * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
7156  * @phba: lpfc_hba pointer.
7157  **/
7158 void
7159 lpfc_get_cfgparam(struct lpfc_hba *phba)
7160 {
7161         lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
7162         lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
7163         lpfc_ns_query_init(phba, lpfc_ns_query);
7164         lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
7165         lpfc_cr_delay_init(phba, lpfc_cr_delay);
7166         lpfc_cr_count_init(phba, lpfc_cr_count);
7167         lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
7168         lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
7169         lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
7170         lpfc_ack0_init(phba, lpfc_ack0);
7171         lpfc_xri_rebalancing_init(phba, lpfc_xri_rebalancing);
7172         lpfc_topology_init(phba, lpfc_topology);
7173         lpfc_link_speed_init(phba, lpfc_link_speed);
7174         lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
7175         lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo);
7176         lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
7177         lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
7178         lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
7179         lpfc_fcp_wait_abts_rsp_init(phba, lpfc_fcp_wait_abts_rsp);
7180         lpfc_fdmi_on_init(phba, lpfc_fdmi_on);
7181         lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN);
7182         lpfc_use_msi_init(phba, lpfc_use_msi);
7183         lpfc_nvme_oas_init(phba, lpfc_nvme_oas);
7184         lpfc_nvme_embed_cmd_init(phba, lpfc_nvme_embed_cmd);
7185         lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
7186         lpfc_force_rscn_init(phba, lpfc_force_rscn);
7187         lpfc_cq_poll_threshold_init(phba, lpfc_cq_poll_threshold);
7188         lpfc_cq_max_proc_limit_init(phba, lpfc_cq_max_proc_limit);
7189         lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
7190         lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
7191         lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
7192
7193         lpfc_EnableXLane_init(phba, lpfc_EnableXLane);
7194         /* VMID Inits */
7195         lpfc_max_vmid_init(phba, lpfc_max_vmid);
7196         lpfc_vmid_inactivity_timeout_init(phba, lpfc_vmid_inactivity_timeout);
7197         lpfc_vmid_app_header_init(phba, lpfc_vmid_app_header);
7198         lpfc_vmid_priority_tagging_init(phba, lpfc_vmid_priority_tagging);
7199         if (phba->sli_rev != LPFC_SLI_REV4)
7200                 phba->cfg_EnableXLane = 0;
7201         lpfc_XLanePriority_init(phba, lpfc_XLanePriority);
7202
7203         memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t)));
7204         memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t)));
7205         phba->cfg_oas_lun_state = 0;
7206         phba->cfg_oas_lun_status = 0;
7207         phba->cfg_oas_flags = 0;
7208         phba->cfg_oas_priority = 0;
7209         lpfc_enable_bg_init(phba, lpfc_enable_bg);
7210         lpfc_prot_mask_init(phba, lpfc_prot_mask);
7211         lpfc_prot_guard_init(phba, lpfc_prot_guard);
7212         if (phba->sli_rev == LPFC_SLI_REV4)
7213                 phba->cfg_poll = 0;
7214         else
7215                 phba->cfg_poll = lpfc_poll;
7216
7217         /* Get the function mode */
7218         lpfc_get_hba_function_mode(phba);
7219
7220         /* BlockGuard allowed for FC only. */
7221         if (phba->cfg_enable_bg && phba->hba_flag & HBA_FCOE_MODE) {
7222                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7223                                 "0581 BlockGuard feature not supported\n");
7224                 /* If set, clear the BlockGuard support param */
7225                 phba->cfg_enable_bg = 0;
7226         } else if (phba->cfg_enable_bg) {
7227                 phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
7228         }
7229
7230         lpfc_suppress_rsp_init(phba, lpfc_suppress_rsp);
7231
7232         lpfc_enable_fc4_type_init(phba, lpfc_enable_fc4_type);
7233         lpfc_nvmet_mrq_init(phba, lpfc_nvmet_mrq);
7234         lpfc_nvmet_mrq_post_init(phba, lpfc_nvmet_mrq_post);
7235
7236         /* Initialize first burst. Target vs Initiator are different. */
7237         lpfc_nvme_enable_fb_init(phba, lpfc_nvme_enable_fb);
7238         lpfc_nvmet_fb_size_init(phba, lpfc_nvmet_fb_size);
7239         lpfc_fcp_mq_threshold_init(phba, lpfc_fcp_mq_threshold);
7240         lpfc_hdw_queue_init(phba, lpfc_hdw_queue);
7241         lpfc_irq_chann_init(phba, lpfc_irq_chann);
7242         lpfc_enable_bbcr_init(phba, lpfc_enable_bbcr);
7243         lpfc_enable_dpp_init(phba, lpfc_enable_dpp);
7244         lpfc_enable_mi_init(phba, lpfc_enable_mi);
7245
7246         phba->cgn_p.cgn_param_mode = LPFC_CFG_OFF;
7247         phba->cmf_active_mode = LPFC_CFG_OFF;
7248         if (lpfc_fabric_cgn_frequency > EDC_CG_SIGFREQ_CNT_MAX ||
7249            lpfc_fabric_cgn_frequency < EDC_CG_SIGFREQ_CNT_MIN)
7250                 lpfc_fabric_cgn_frequency = 100; /* 100 ms default */
7251
7252         if (phba->sli_rev != LPFC_SLI_REV4) {
7253                 /* NVME only supported on SLI4 */
7254                 phba->nvmet_support = 0;
7255                 phba->cfg_nvmet_mrq = 0;
7256                 phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
7257                 phba->cfg_enable_bbcr = 0;
7258                 phba->cfg_xri_rebalancing = 0;
7259         } else {
7260                 /* We MUST have FCP support */
7261                 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
7262                         phba->cfg_enable_fc4_type |= LPFC_ENABLE_FCP;
7263         }
7264
7265         phba->cfg_auto_imax = (phba->cfg_fcp_imax) ? 0 : 1;
7266
7267         phba->cfg_enable_pbde = 0;
7268
7269         /* A value of 0 means use the number of CPUs found in the system */
7270         if (phba->cfg_hdw_queue == 0)
7271                 phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
7272         if (phba->cfg_irq_chann == 0)
7273                 phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
7274         if (phba->cfg_irq_chann > phba->cfg_hdw_queue &&
7275             phba->sli_rev == LPFC_SLI_REV4)
7276                 phba->cfg_irq_chann = phba->cfg_hdw_queue;
7277
7278         lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
7279         lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
7280         lpfc_aer_support_init(phba, lpfc_aer_support);
7281         lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
7282         lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
7283         lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
7284         lpfc_delay_discovery_init(phba, lpfc_delay_discovery);
7285         lpfc_sli_mode_init(phba, lpfc_sli_mode);
7286         lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
7287         lpfc_ras_fwlog_buffsize_init(phba, lpfc_ras_fwlog_buffsize);
7288         lpfc_ras_fwlog_level_init(phba, lpfc_ras_fwlog_level);
7289         lpfc_ras_fwlog_func_init(phba, lpfc_ras_fwlog_func);
7290
7291         return;
7292 }
7293
7294 /**
7295  * lpfc_nvme_mod_param_dep - Adjust module parameter value based on
7296  * dependencies between protocols and roles.
7297  * @phba: lpfc_hba pointer.
7298  **/
7299 void
7300 lpfc_nvme_mod_param_dep(struct lpfc_hba *phba)
7301 {
7302         int  logit = 0;
7303
7304         if (phba->cfg_hdw_queue > phba->sli4_hba.num_present_cpu) {
7305                 phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
7306                 logit = 1;
7307         }
7308         if (phba->cfg_irq_chann > phba->sli4_hba.num_present_cpu) {
7309                 phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
7310                 logit = 1;
7311         }
7312         if (phba->cfg_irq_chann > phba->cfg_hdw_queue) {
7313                 phba->cfg_irq_chann = phba->cfg_hdw_queue;
7314                 logit = 1;
7315         }
7316         if (logit)
7317                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7318                                 "2006 Reducing Queues - CPU limitation: "
7319                                 "IRQ %d HDWQ %d\n",
7320                                 phba->cfg_irq_chann,
7321                                 phba->cfg_hdw_queue);
7322
7323         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME &&
7324             phba->nvmet_support) {
7325                 phba->cfg_enable_fc4_type &= ~LPFC_ENABLE_FCP;
7326
7327                 lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
7328                                 "6013 %s x%x fb_size x%x, fb_max x%x\n",
7329                                 "NVME Target PRLI ACC enable_fb ",
7330                                 phba->cfg_nvme_enable_fb,
7331                                 phba->cfg_nvmet_fb_size,
7332                                 LPFC_NVMET_FB_SZ_MAX);
7333
7334                 if (phba->cfg_nvme_enable_fb == 0)
7335                         phba->cfg_nvmet_fb_size = 0;
7336                 else {
7337                         if (phba->cfg_nvmet_fb_size > LPFC_NVMET_FB_SZ_MAX)
7338                                 phba->cfg_nvmet_fb_size = LPFC_NVMET_FB_SZ_MAX;
7339                 }
7340
7341                 if (!phba->cfg_nvmet_mrq)
7342                         phba->cfg_nvmet_mrq = phba->cfg_hdw_queue;
7343
7344                 /* Adjust lpfc_nvmet_mrq to avoid running out of WQE slots */
7345                 if (phba->cfg_nvmet_mrq > phba->cfg_hdw_queue) {
7346                         phba->cfg_nvmet_mrq = phba->cfg_hdw_queue;
7347                         lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
7348                                         "6018 Adjust lpfc_nvmet_mrq to %d\n",
7349                                         phba->cfg_nvmet_mrq);
7350                 }
7351                 if (phba->cfg_nvmet_mrq > LPFC_NVMET_MRQ_MAX)
7352                         phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_MAX;
7353
7354         } else {
7355                 /* Not NVME Target mode.  Turn off Target parameters. */
7356                 phba->nvmet_support = 0;
7357                 phba->cfg_nvmet_mrq = 0;
7358                 phba->cfg_nvmet_fb_size = 0;
7359         }
7360 }
7361
7362 /**
7363  * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
7364  * @vport: lpfc_vport pointer.
7365  **/
7366 void
7367 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
7368 {
7369         lpfc_log_verbose_init(vport, lpfc_log_verbose);
7370         lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
7371         lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
7372         lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
7373         lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
7374         lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
7375         lpfc_restrict_login_init(vport, lpfc_restrict_login);
7376         lpfc_fcp_class_init(vport, lpfc_fcp_class);
7377         lpfc_use_adisc_init(vport, lpfc_use_adisc);
7378         lpfc_first_burst_size_init(vport, lpfc_first_burst_size);
7379         lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
7380         lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
7381         lpfc_max_luns_init(vport, lpfc_max_luns);
7382         lpfc_scan_down_init(vport, lpfc_scan_down);
7383         lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
7384         return;
7385 }