drivers/scsi/lpfc/lpfc

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

DEFINITIONS
