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