drivers/scsi/lpfc/lpfc_attr.c

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