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) 2004-2008 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/ctype.h>
  23 #include <linux/delay.h>
  24 #include <linux/pci.h>
  25 #include <linux/interrupt.h>
  26
  27 #include <scsi/scsi.h>
  28 #include <scsi/scsi_device.h>
  29 #include <scsi/scsi_host.h>
  30 #include <scsi/scsi_tcq.h>
  31 #include <scsi/scsi_transport_fc.h>
  32
  33 #include "lpfc_hw.h"
  34 #include "lpfc_sli.h"
  35 #include "lpfc_disc.h"
  36 #include "lpfc_scsi.h"
  37 #include "lpfc.h"
  38 #include "lpfc_logmsg.h"
  39 #include "lpfc_version.h"
  40 #include "lpfc_compat.h"
  41 #include "lpfc_crtn.h"
  42 #include "lpfc_vport.h"
  43
  44 #define LPFC_DEF_DEVLOSS_TMO 30
  45 #define LPFC_MIN_DEVLOSS_TMO 1
  46 #define LPFC_MAX_DEVLOSS_TMO 255
  47
  48 #define LPFC_MAX_LINK_SPEED 8
  49 #define LPFC_LINK_SPEED_BITMAP 0x00000117
  50 #define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8"
  51
  52 static void
  53 lpfc_jedec_to_ascii(int incr, char hdw[])
  54 {
  55         int i, j;
  56         for (i = 0; i < 8; i++) {
  57                 j = (incr & 0xf);
  58                 if (j <= 9)
  59                         hdw[7 - i] = 0x30 +  j;
  60                  else
  61                         hdw[7 - i] = 0x61 + j - 10;
  62                 incr = (incr >> 4);
  63         }
  64         hdw[8] = 0;
  65         return;
  66 }
  67
  68 static ssize_t
  69 lpfc_drvr_version_show(struct class_device *cdev, char *buf)
  70 {
  71         return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
  72 }
  73
  74 static ssize_t
  75 lpfc_info_show(struct class_device *cdev, char *buf)
  76 {
  77         struct Scsi_Host *host = class_to_shost(cdev);
  78
  79         return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
  80 }
  81
  82 static ssize_t
  83 lpfc_serialnum_show(struct class_device *cdev, char *buf)
  84 {
  85         struct Scsi_Host  *shost = class_to_shost(cdev);
  86         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
  87         struct lpfc_hba   *phba = vport->phba;
  88
  89         return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
  90 }
  91
  92 static ssize_t
  93 lpfc_temp_sensor_show(struct class_device *cdev, char *buf)
  94 {
  95         struct Scsi_Host *shost = class_to_shost(cdev);
  96         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
  97         struct lpfc_hba   *phba = vport->phba;
  98         return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
  99 }
 100
 101 static ssize_t
 102 lpfc_modeldesc_show(struct class_device *cdev, char *buf)
 103 {
 104         struct Scsi_Host  *shost = class_to_shost(cdev);
 105         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 106         struct lpfc_hba   *phba = vport->phba;
 107
 108         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
 109 }
 110
 111 static ssize_t
 112 lpfc_modelname_show(struct class_device *cdev, char *buf)
 113 {
 114         struct Scsi_Host  *shost = class_to_shost(cdev);
 115         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 116         struct lpfc_hba   *phba = vport->phba;
 117
 118         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
 119 }
 120
 121 static ssize_t
 122 lpfc_programtype_show(struct class_device *cdev, char *buf)
 123 {
 124         struct Scsi_Host  *shost = class_to_shost(cdev);
 125         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 126         struct lpfc_hba   *phba = vport->phba;
 127
 128         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
 129 }
 130
 131 static ssize_t
 132 lpfc_vportnum_show(struct class_device *cdev, char *buf)
 133 {
 134         struct Scsi_Host  *shost = class_to_shost(cdev);
 135         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 136         struct lpfc_hba   *phba = vport->phba;
 137
 138         return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
 139 }
 140
 141 static ssize_t
 142 lpfc_fwrev_show(struct class_device *cdev, char *buf)
 143 {
 144         struct Scsi_Host  *shost = class_to_shost(cdev);
 145         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 146         struct lpfc_hba   *phba = vport->phba;
 147         char fwrev[32];
 148
 149         lpfc_decode_firmware_rev(phba, fwrev, 1);
 150         return snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", fwrev, phba->sli_rev);
 151 }
 152
 153 static ssize_t
 154 lpfc_hdw_show(struct class_device *cdev, char *buf)
 155 {
 156         char hdw[9];
 157         struct Scsi_Host  *shost = class_to_shost(cdev);
 158         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 159         struct lpfc_hba   *phba = vport->phba;
 160         lpfc_vpd_t *vp = &phba->vpd;
 161
 162         lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
 163         return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
 164 }
 165 static ssize_t
 166 lpfc_option_rom_version_show(struct class_device *cdev, char *buf)
 167 {
 168         struct Scsi_Host  *shost = class_to_shost(cdev);
 169         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 170         struct lpfc_hba   *phba = vport->phba;
 171
 172         return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
 173 }
 174 static ssize_t
 175 lpfc_state_show(struct class_device *cdev, char *buf)
 176 {
 177         struct Scsi_Host  *shost = class_to_shost(cdev);
 178         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 179         struct lpfc_hba   *phba = vport->phba;
 180         int  len = 0;
 181
 182         switch (phba->link_state) {
 183         case LPFC_LINK_UNKNOWN:
 184         case LPFC_WARM_START:
 185         case LPFC_INIT_START:
 186         case LPFC_INIT_MBX_CMDS:
 187         case LPFC_LINK_DOWN:
 188         case LPFC_HBA_ERROR:
 189                 len += snprintf(buf + len, PAGE_SIZE-len, "Link Down\n");
 190                 break;
 191         case LPFC_LINK_UP:
 192         case LPFC_CLEAR_LA:
 193         case LPFC_HBA_READY:
 194                 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
 195
 196                 switch (vport->port_state) {
 197                 case LPFC_LOCAL_CFG_LINK:
 198                         len += snprintf(buf + len, PAGE_SIZE-len,
 199                                         "Configuring Link\n");
 200                         break;
 201                 case LPFC_FDISC:
 202                 case LPFC_FLOGI:
 203                 case LPFC_FABRIC_CFG_LINK:
 204                 case LPFC_NS_REG:
 205                 case LPFC_NS_QRY:
 206                 case LPFC_BUILD_DISC_LIST:
 207                 case LPFC_DISC_AUTH:
 208                         len += snprintf(buf + len, PAGE_SIZE - len,
 209                                         "Discovery\n");
 210                         break;
 211                 case LPFC_VPORT_READY:
 212                         len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
 213                         break;
 214
 215                 case LPFC_VPORT_FAILED:
 216                         len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
 217                         break;
 218
 219                 case LPFC_VPORT_UNKNOWN:
 220                         len += snprintf(buf + len, PAGE_SIZE - len,
 221                                         "Unknown\n");
 222                         break;
 223                 }
 224
 225                 if (phba->fc_topology == TOPOLOGY_LOOP) {
 226                         if (vport->fc_flag & FC_PUBLIC_LOOP)
 227                                 len += snprintf(buf + len, PAGE_SIZE-len,
 228                                                 "   Public Loop\n");
 229                         else
 230                                 len += snprintf(buf + len, PAGE_SIZE-len,
 231                                                 "   Private Loop\n");
 232                 } else {
 233                         if (vport->fc_flag & FC_FABRIC)
 234                                 len += snprintf(buf + len, PAGE_SIZE-len,
 235                                                 "   Fabric\n");
 236                         else
 237                                 len += snprintf(buf + len, PAGE_SIZE-len,
 238                                                 "   Point-2-Point\n");
 239                 }
 240         }
 241
 242         return len;
 243 }
 244
 245 static ssize_t
 246 lpfc_num_discovered_ports_show(struct class_device *cdev, char *buf)
 247 {
 248         struct Scsi_Host  *shost = class_to_shost(cdev);
 249         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 250
 251         return snprintf(buf, PAGE_SIZE, "%d\n",
 252                         vport->fc_map_cnt + vport->fc_unmap_cnt);
 253 }
 254
 255
 256 static int
 257 lpfc_issue_lip(struct Scsi_Host *shost)
 258 {
 259         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 260         struct lpfc_hba   *phba = vport->phba;
 261         LPFC_MBOXQ_t *pmboxq;
 262         int mbxstatus = MBXERR_ERROR;
 263
 264         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
 265             (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
 266                 return -EPERM;
 267
 268         pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
 269
 270         if (!pmboxq)
 271                 return -ENOMEM;
 272
 273         memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
 274         pmboxq->mb.mbxCommand = MBX_DOWN_LINK;
 275         pmboxq->mb.mbxOwner = OWN_HOST;
 276
 277         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
 278
 279         if ((mbxstatus == MBX_SUCCESS) && (pmboxq->mb.mbxStatus == 0)) {
 280                 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
 281                 lpfc_init_link(phba, pmboxq, phba->cfg_topology,
 282                                phba->cfg_link_speed);
 283                 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
 284                                                      phba->fc_ratov * 2);
 285         }
 286
 287         lpfc_set_loopback_flag(phba);
 288         if (mbxstatus != MBX_TIMEOUT)
 289                 mempool_free(pmboxq, phba->mbox_mem_pool);
 290
 291         if (mbxstatus == MBXERR_ERROR)
 292                 return -EIO;
 293
 294         return 0;
 295 }
 296
 297 static int
 298 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
 299 {
 300         struct completion online_compl;
 301         struct lpfc_sli_ring *pring;
 302         struct lpfc_sli *psli;
 303         int status = 0;
 304         int cnt = 0;
 305         int i;
 306
 307         init_completion(&online_compl);
 308         lpfc_workq_post_event(phba, &status, &online_compl,
 309                               LPFC_EVT_OFFLINE_PREP);
 310         wait_for_completion(&online_compl);
 311
 312         if (status != 0)
 313                 return -EIO;
 314
 315         psli = &phba->sli;
 316
 317         /* Wait a little for things to settle down, but not
 318          * long enough for dev loss timeout to expire.
 319          */
 320         for (i = 0; i < psli->num_rings; i++) {
 321                 pring = &psli->ring[i];
 322                 while (pring->txcmplq_cnt) {
 323                         msleep(10);
 324                         if (cnt++ > 500) {  /* 5 secs */
 325                                 lpfc_printf_log(phba,
 326                                         KERN_WARNING, LOG_INIT,
 327                                         "0466 Outstanding IO when "
 328                                         "bringing Adapter offline\n");
 329                                 break;
 330                         }
 331                 }
 332         }
 333
 334         init_completion(&online_compl);
 335         lpfc_workq_post_event(phba, &status, &online_compl, type);
 336         wait_for_completion(&online_compl);
 337
 338         if (status != 0)
 339                 return -EIO;
 340
 341         return 0;
 342 }
 343
 344 static int
 345 lpfc_selective_reset(struct lpfc_hba *phba)
 346 {
 347         struct completion online_compl;
 348         int status = 0;
 349
 350         if (!phba->cfg_enable_hba_reset)
 351                 return -EIO;
 352
 353         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
 354
 355         if (status != 0)
 356                 return status;
 357
 358         init_completion(&online_compl);
 359         lpfc_workq_post_event(phba, &status, &online_compl,
 360                               LPFC_EVT_ONLINE);
 361         wait_for_completion(&online_compl);
 362
 363         if (status != 0)
 364                 return -EIO;
 365
 366         return 0;
 367 }
 368
 369 static ssize_t
 370 lpfc_issue_reset(struct class_device *cdev, const char *buf, size_t count)
 371 {
 372         struct Scsi_Host  *shost = class_to_shost(cdev);
 373         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 374         struct lpfc_hba   *phba = vport->phba;
 375
 376         int status = -EINVAL;
 377
 378         if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
 379                 status = lpfc_selective_reset(phba);
 380
 381         if (status == 0)
 382                 return strlen(buf);
 383         else
 384                 return status;
 385 }
 386
 387 static ssize_t
 388 lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf)
 389 {
 390         struct Scsi_Host  *shost = class_to_shost(cdev);
 391         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 392         struct lpfc_hba   *phba = vport->phba;
 393
 394         return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
 395 }
 396
 397 static ssize_t
 398 lpfc_board_mode_show(struct class_device *cdev, char *buf)
 399 {
 400         struct Scsi_Host  *shost = class_to_shost(cdev);
 401         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 402         struct lpfc_hba   *phba = vport->phba;
 403         char  * state;
 404
 405         if (phba->link_state == LPFC_HBA_ERROR)
 406                 state = "error";
 407         else if (phba->link_state == LPFC_WARM_START)
 408                 state = "warm start";
 409         else if (phba->link_state == LPFC_INIT_START)
 410                 state = "offline";
 411         else
 412                 state = "online";
 413
 414         return snprintf(buf, PAGE_SIZE, "%s\n", state);
 415 }
 416
 417 static ssize_t
 418 lpfc_board_mode_store(struct class_device *cdev, const char *buf, size_t count)
 419 {
 420         struct Scsi_Host  *shost = class_to_shost(cdev);
 421         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 422         struct lpfc_hba   *phba = vport->phba;
 423         struct completion online_compl;
 424         int status=0;
 425
 426         if (!phba->cfg_enable_hba_reset)
 427                 return -EACCES;
 428         init_completion(&online_compl);
 429
 430         if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
 431                 lpfc_workq_post_event(phba, &status, &online_compl,
 432                                       LPFC_EVT_ONLINE);
 433                 wait_for_completion(&online_compl);
 434         } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
 435                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
 436         else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
 437                 status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
 438         else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
 439                 status = lpfc_do_offline(phba, LPFC_EVT_KILL);
 440         else
 441                 return -EINVAL;
 442
 443         if (!status)
 444                 return strlen(buf);
 445         else
 446                 return -EIO;
 447 }
 448
 449 static int
 450 lpfc_get_hba_info(struct lpfc_hba *phba,
 451                   uint32_t *mxri, uint32_t *axri,
 452                   uint32_t *mrpi, uint32_t *arpi,
 453                   uint32_t *mvpi, uint32_t *avpi)
 454 {
 455         struct lpfc_sli   *psli = &phba->sli;
 456         LPFC_MBOXQ_t *pmboxq;
 457         MAILBOX_t *pmb;
 458         int rc = 0;
 459
 460         /*
 461          * prevent udev from issuing mailbox commands until the port is
 462          * configured.
 463          */
 464         if (phba->link_state < LPFC_LINK_DOWN ||
 465             !phba->mbox_mem_pool ||
 466             (phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0)
 467                 return 0;
 468
 469         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
 470                 return 0;
 471
 472         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 473         if (!pmboxq)
 474                 return 0;
 475         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
 476
 477         pmb = &pmboxq->mb;
 478         pmb->mbxCommand = MBX_READ_CONFIG;
 479         pmb->mbxOwner = OWN_HOST;
 480         pmboxq->context1 = NULL;
 481
 482         if ((phba->pport->fc_flag & FC_OFFLINE_MODE) ||
 483                 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
 484                 rc = MBX_NOT_FINISHED;
 485         else
 486                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
 487
 488         if (rc != MBX_SUCCESS) {
 489                 if (rc != MBX_TIMEOUT)
 490                         mempool_free(pmboxq, phba->mbox_mem_pool);
 491                 return 0;
 492         }
 493
 494         if (mrpi)
 495                 *mrpi = pmb->un.varRdConfig.max_rpi;
 496         if (arpi)
 497                 *arpi = pmb->un.varRdConfig.avail_rpi;
 498         if (mxri)
 499                 *mxri = pmb->un.varRdConfig.max_xri;
 500         if (axri)
 501                 *axri = pmb->un.varRdConfig.avail_xri;
 502         if (mvpi)
 503                 *mvpi = pmb->un.varRdConfig.max_vpi;
 504         if (avpi)
 505                 *avpi = pmb->un.varRdConfig.avail_vpi;
 506
 507         mempool_free(pmboxq, phba->mbox_mem_pool);
 508         return 1;
 509 }
 510
 511 static ssize_t
 512 lpfc_max_rpi_show(struct class_device *cdev, char *buf)
 513 {
 514         struct Scsi_Host  *shost = class_to_shost(cdev);
 515         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 516         struct lpfc_hba   *phba = vport->phba;
 517         uint32_t cnt;
 518
 519         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
 520                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
 521         return snprintf(buf, PAGE_SIZE, "Unknown\n");
 522 }
 523
 524 static ssize_t
 525 lpfc_used_rpi_show(struct class_device *cdev, char *buf)
 526 {
 527         struct Scsi_Host  *shost = class_to_shost(cdev);
 528         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 529         struct lpfc_hba   *phba = vport->phba;
 530         uint32_t cnt, acnt;
 531
 532         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
 533                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
 534         return snprintf(buf, PAGE_SIZE, "Unknown\n");
 535 }
 536
 537 static ssize_t
 538 lpfc_max_xri_show(struct class_device *cdev, char *buf)
 539 {
 540         struct Scsi_Host  *shost = class_to_shost(cdev);
 541         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 542         struct lpfc_hba   *phba = vport->phba;
 543         uint32_t cnt;
 544
 545         if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
 546                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
 547         return snprintf(buf, PAGE_SIZE, "Unknown\n");
 548 }
 549
 550 static ssize_t
 551 lpfc_used_xri_show(struct class_device *cdev, char *buf)
 552 {
 553         struct Scsi_Host  *shost = class_to_shost(cdev);
 554         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 555         struct lpfc_hba   *phba = vport->phba;
 556         uint32_t cnt, acnt;
 557
 558         if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
 559                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
 560         return snprintf(buf, PAGE_SIZE, "Unknown\n");
 561 }
 562
 563 static ssize_t
 564 lpfc_max_vpi_show(struct class_device *cdev, char *buf)
 565 {
 566         struct Scsi_Host  *shost = class_to_shost(cdev);
 567         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 568         struct lpfc_hba   *phba = vport->phba;
 569         uint32_t cnt;
 570
 571         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
 572                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
 573         return snprintf(buf, PAGE_SIZE, "Unknown\n");
 574 }
 575
 576 static ssize_t
 577 lpfc_used_vpi_show(struct class_device *cdev, char *buf)
 578 {
 579         struct Scsi_Host  *shost = class_to_shost(cdev);
 580         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 581         struct lpfc_hba   *phba = vport->phba;
 582         uint32_t cnt, acnt;
 583
 584         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
 585                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
 586         return snprintf(buf, PAGE_SIZE, "Unknown\n");
 587 }
 588
 589 static ssize_t
 590 lpfc_npiv_info_show(struct class_device *cdev, char *buf)
 591 {
 592         struct Scsi_Host  *shost = class_to_shost(cdev);
 593         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 594         struct lpfc_hba   *phba = vport->phba;
 595
 596         if (!(phba->max_vpi))
 597                 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
 598         if (vport->port_type == LPFC_PHYSICAL_PORT)
 599                 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
 600         return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
 601 }
 602
 603 static ssize_t
 604 lpfc_poll_show(struct class_device *cdev, char *buf)
 605 {
 606         struct Scsi_Host  *shost = class_to_shost(cdev);
 607         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 608         struct lpfc_hba   *phba = vport->phba;
 609
 610         return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
 611 }
 612
 613 static ssize_t
 614 lpfc_poll_store(struct class_device *cdev, const char *buf,
 615                 size_t count)
 616 {
 617         struct Scsi_Host  *shost = class_to_shost(cdev);
 618         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 619         struct lpfc_hba   *phba = vport->phba;
 620         uint32_t creg_val;
 621         uint32_t old_val;
 622         int val=0;
 623
 624         if (!isdigit(buf[0]))
 625                 return -EINVAL;
 626
 627         if (sscanf(buf, "%i", &val) != 1)
 628                 return -EINVAL;
 629
 630         if ((val & 0x3) != val)
 631                 return -EINVAL;
 632
 633         spin_lock_irq(&phba->hbalock);
 634
 635         old_val = phba->cfg_poll;
 636
 637         if (val & ENABLE_FCP_RING_POLLING) {
 638                 if ((val & DISABLE_FCP_RING_INT) &&
 639                     !(old_val & DISABLE_FCP_RING_INT)) {
 640                         creg_val = readl(phba->HCregaddr);
 641                         creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
 642                         writel(creg_val, phba->HCregaddr);
 643                         readl(phba->HCregaddr); /* flush */
 644
 645                         lpfc_poll_start_timer(phba);
 646                 }
 647         } else if (val != 0x0) {
 648                 spin_unlock_irq(&phba->hbalock);
 649                 return -EINVAL;
 650         }
 651
 652         if (!(val & DISABLE_FCP_RING_INT) &&
 653             (old_val & DISABLE_FCP_RING_INT))
 654         {
 655                 spin_unlock_irq(&phba->hbalock);
 656                 del_timer(&phba->fcp_poll_timer);
 657                 spin_lock_irq(&phba->hbalock);
 658                 creg_val = readl(phba->HCregaddr);
 659                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
 660                 writel(creg_val, phba->HCregaddr);
 661                 readl(phba->HCregaddr); /* flush */
 662         }
 663
 664         phba->cfg_poll = val;
 665
 666         spin_unlock_irq(&phba->hbalock);
 667
 668         return strlen(buf);
 669 }
 670
 671 #define lpfc_param_show(attr)   \
 672 static ssize_t \
 673 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
 674 { \
 675         struct Scsi_Host  *shost = class_to_shost(cdev);\
 676         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
 677         struct lpfc_hba   *phba = vport->phba;\
 678         int val = 0;\
 679         val = phba->cfg_##attr;\
 680         return snprintf(buf, PAGE_SIZE, "%d\n",\
 681                         phba->cfg_##attr);\
 682 }
 683
 684 #define lpfc_param_hex_show(attr)       \
 685 static ssize_t \
 686 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
 687 { \
 688         struct Scsi_Host  *shost = class_to_shost(cdev);\
 689         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
 690         struct lpfc_hba   *phba = vport->phba;\
 691         int val = 0;\
 692         val = phba->cfg_##attr;\
 693         return snprintf(buf, PAGE_SIZE, "%#x\n",\
 694                         phba->cfg_##attr);\
 695 }
 696
 697 #define lpfc_param_init(attr, default, minval, maxval)  \
 698 static int \
 699 lpfc_##attr##_init(struct lpfc_hba *phba, int val) \
 700 { \
 701         if (val >= minval && val <= maxval) {\
 702                 phba->cfg_##attr = val;\
 703                 return 0;\
 704         }\
 705         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
 706                         "0449 lpfc_"#attr" attribute cannot be set to %d, "\
 707                         "allowed range is ["#minval", "#maxval"]\n", val); \
 708         phba->cfg_##attr = default;\
 709         return -EINVAL;\
 710 }
 711
 712 #define lpfc_param_set(attr, default, minval, maxval)   \
 713 static int \
 714 lpfc_##attr##_set(struct lpfc_hba *phba, int val) \
 715 { \
 716         if (val >= minval && val <= maxval) {\
 717                 phba->cfg_##attr = val;\
 718                 return 0;\
 719         }\
 720         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
 721                         "0450 lpfc_"#attr" attribute cannot be set to %d, "\
 722                         "allowed range is ["#minval", "#maxval"]\n", val); \
 723         return -EINVAL;\
 724 }
 725
 726 #define lpfc_param_store(attr)  \
 727 static ssize_t \
 728 lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
 729 { \
 730         struct Scsi_Host  *shost = class_to_shost(cdev);\
 731         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
 732         struct lpfc_hba   *phba = vport->phba;\
 733         int val=0;\
 734         if (!isdigit(buf[0]))\
 735                 return -EINVAL;\
 736         if (sscanf(buf, "%i", &val) != 1)\
 737                 return -EINVAL;\
 738         if (lpfc_##attr##_set(phba, val) == 0) \
 739                 return strlen(buf);\
 740         else \
 741                 return -EINVAL;\
 742 }
 743
 744 #define lpfc_vport_param_show(attr)     \
 745 static ssize_t \
 746 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
 747 { \
 748         struct Scsi_Host  *shost = class_to_shost(cdev);\
 749         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
 750         int val = 0;\
 751         val = vport->cfg_##attr;\
 752         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
 753 }
 754
 755 #define lpfc_vport_param_hex_show(attr) \
 756 static ssize_t \
 757 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
 758 { \
 759         struct Scsi_Host  *shost = class_to_shost(cdev);\
 760         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
 761         int val = 0;\
 762         val = vport->cfg_##attr;\
 763         return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
 764 }
 765
 766 #define lpfc_vport_param_init(attr, default, minval, maxval)    \
 767 static int \
 768 lpfc_##attr##_init(struct lpfc_vport *vport, int val) \
 769 { \
 770         if (val >= minval && val <= maxval) {\
 771                 vport->cfg_##attr = val;\
 772                 return 0;\
 773         }\
 774         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
 775                          "0449 lpfc_"#attr" attribute cannot be set to %d, "\
 776                          "allowed range is ["#minval", "#maxval"]\n", val); \
 777         vport->cfg_##attr = default;\
 778         return -EINVAL;\
 779 }
 780
 781 #define lpfc_vport_param_set(attr, default, minval, maxval)     \
 782 static int \
 783 lpfc_##attr##_set(struct lpfc_vport *vport, int val) \
 784 { \
 785         if (val >= minval && val <= maxval) {\
 786                 vport->cfg_##attr = val;\
 787                 return 0;\
 788         }\
 789         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
 790                          "0450 lpfc_"#attr" attribute cannot be set to %d, "\
 791                          "allowed range is ["#minval", "#maxval"]\n", val); \
 792         return -EINVAL;\
 793 }
 794
 795 #define lpfc_vport_param_store(attr)    \
 796 static ssize_t \
 797 lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
 798 { \
 799         struct Scsi_Host  *shost = class_to_shost(cdev);\
 800         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
 801         int val=0;\
 802         if (!isdigit(buf[0]))\
 803                 return -EINVAL;\
 804         if (sscanf(buf, "%i", &val) != 1)\
 805                 return -EINVAL;\
 806         if (lpfc_##attr##_set(vport, val) == 0) \
 807                 return strlen(buf);\
 808         else \
 809                 return -EINVAL;\
 810 }
 811
 812
 813 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
 814 static int lpfc_##name = defval;\
 815 module_param(lpfc_##name, int, 0);\
 816 MODULE_PARM_DESC(lpfc_##name, desc);\
 817 lpfc_param_init(name, defval, minval, maxval)
 818
 819 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
 820 static int lpfc_##name = defval;\
 821 module_param(lpfc_##name, int, 0);\
 822 MODULE_PARM_DESC(lpfc_##name, desc);\
 823 lpfc_param_show(name)\
 824 lpfc_param_init(name, defval, minval, maxval)\
 825 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 826
 827 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
 828 static int lpfc_##name = defval;\
 829 module_param(lpfc_##name, int, 0);\
 830 MODULE_PARM_DESC(lpfc_##name, desc);\
 831 lpfc_param_show(name)\
 832 lpfc_param_init(name, defval, minval, maxval)\
 833 lpfc_param_set(name, defval, minval, maxval)\
 834 lpfc_param_store(name)\
 835 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
 836                          lpfc_##name##_show, lpfc_##name##_store)
 837
 838 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
 839 static int lpfc_##name = defval;\
 840 module_param(lpfc_##name, int, 0);\
 841 MODULE_PARM_DESC(lpfc_##name, desc);\
 842 lpfc_param_hex_show(name)\
 843 lpfc_param_init(name, defval, minval, maxval)\
 844 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 845
 846 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
 847 static int lpfc_##name = defval;\
 848 module_param(lpfc_##name, int, 0);\
 849 MODULE_PARM_DESC(lpfc_##name, desc);\
 850 lpfc_param_hex_show(name)\
 851 lpfc_param_init(name, defval, minval, maxval)\
 852 lpfc_param_set(name, defval, minval, maxval)\
 853 lpfc_param_store(name)\
 854 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
 855                          lpfc_##name##_show, lpfc_##name##_store)
 856
 857 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
 858 static int lpfc_##name = defval;\
 859 module_param(lpfc_##name, int, 0);\
 860 MODULE_PARM_DESC(lpfc_##name, desc);\
 861 lpfc_vport_param_init(name, defval, minval, maxval)
 862
 863 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
 864 static int lpfc_##name = defval;\
 865 module_param(lpfc_##name, int, 0);\
 866 MODULE_PARM_DESC(lpfc_##name, desc);\
 867 lpfc_vport_param_show(name)\
 868 lpfc_vport_param_init(name, defval, minval, maxval)\
 869 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 870
 871 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
 872 static int lpfc_##name = defval;\
 873 module_param(lpfc_##name, int, 0);\
 874 MODULE_PARM_DESC(lpfc_##name, desc);\
 875 lpfc_vport_param_show(name)\
 876 lpfc_vport_param_init(name, defval, minval, maxval)\
 877 lpfc_vport_param_set(name, defval, minval, maxval)\
 878 lpfc_vport_param_store(name)\
 879 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
 880                          lpfc_##name##_show, lpfc_##name##_store)
 881
 882 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
 883 static int lpfc_##name = defval;\
 884 module_param(lpfc_##name, int, 0);\
 885 MODULE_PARM_DESC(lpfc_##name, desc);\
 886 lpfc_vport_param_hex_show(name)\
 887 lpfc_vport_param_init(name, defval, minval, maxval)\
 888 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 889
 890 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
 891 static int lpfc_##name = defval;\
 892 module_param(lpfc_##name, int, 0);\
 893 MODULE_PARM_DESC(lpfc_##name, desc);\
 894 lpfc_vport_param_hex_show(name)\
 895 lpfc_vport_param_init(name, defval, minval, maxval)\
 896 lpfc_vport_param_set(name, defval, minval, maxval)\
 897 lpfc_vport_param_store(name)\
 898 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
 899                          lpfc_##name##_show, lpfc_##name##_store)
 900
 901 static CLASS_DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
 902 static CLASS_DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
 903 static CLASS_DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
 904 static CLASS_DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
 905 static CLASS_DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
 906 static CLASS_DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
 907 static CLASS_DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
 908 static CLASS_DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
 909 static CLASS_DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL);
 910 static CLASS_DEVICE_ATTR(option_rom_version, S_IRUGO,
 911                                         lpfc_option_rom_version_show, NULL);
 912 static CLASS_DEVICE_ATTR(num_discovered_ports, S_IRUGO,
 913                                         lpfc_num_discovered_ports_show, NULL);
 914 static CLASS_DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
 915 static CLASS_DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show,
 916                          NULL);
 917 static CLASS_DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
 918                          lpfc_board_mode_show, lpfc_board_mode_store);
 919 static CLASS_DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
 920 static CLASS_DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
 921 static CLASS_DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
 922 static CLASS_DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
 923 static CLASS_DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
 924 static CLASS_DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
 925 static CLASS_DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
 926 static CLASS_DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
 927 static CLASS_DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show,
 928                          NULL);
 929
 930
 931 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
 932
 933 static ssize_t
 934 lpfc_soft_wwn_enable_store(struct class_device *cdev, const char *buf,
 935                                 size_t count)
 936 {
 937         struct Scsi_Host  *shost = class_to_shost(cdev);
 938         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 939         struct lpfc_hba   *phba = vport->phba;
 940         unsigned int cnt = count;
 941
 942         /*
 943          * We're doing a simple sanity check for soft_wwpn setting.
 944          * We require that the user write a specific key to enable
 945          * the soft_wwpn attribute to be settable. Once the attribute
 946          * is written, the enable key resets. If further updates are
 947          * desired, the key must be written again to re-enable the
 948          * attribute.
 949          *
 950          * The "key" is not secret - it is a hardcoded string shown
 951          * here. The intent is to protect against the random user or
 952          * application that is just writing attributes.
 953          */
 954
 955         /* count may include a LF at end of string */
 956         if (buf[cnt-1] == '\n')
 957                 cnt--;
 958
 959         if ((cnt != strlen(lpfc_soft_wwn_key)) ||
 960             (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
 961                 return -EINVAL;
 962
 963         phba->soft_wwn_enable = 1;
 964         return count;
 965 }
 966 static CLASS_DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
 967                                 lpfc_soft_wwn_enable_store);
 968
 969 static ssize_t
 970 lpfc_soft_wwpn_show(struct class_device *cdev, char *buf)
 971 {
 972         struct Scsi_Host  *shost = class_to_shost(cdev);
 973         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 974         struct lpfc_hba   *phba = vport->phba;
 975
 976         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
 977                         (unsigned long long)phba->cfg_soft_wwpn);
 978 }
 979
 980
 981 static ssize_t
 982 lpfc_soft_wwpn_store(struct class_device *cdev, const char *buf, size_t count)
 983 {
 984         struct Scsi_Host  *shost = class_to_shost(cdev);
 985         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
 986         struct lpfc_hba   *phba = vport->phba;
 987         struct completion online_compl;
 988         int stat1=0, stat2=0;
 989         unsigned int i, j, cnt=count;
 990         u8 wwpn[8];
 991
 992         if (!phba->cfg_enable_hba_reset)
 993                 return -EACCES;
 994         spin_lock_irq(&phba->hbalock);
 995         if (phba->over_temp_state == HBA_OVER_TEMP) {
 996                 spin_unlock_irq(&phba->hbalock);
 997                 return -EACCES;
 998         }
 999         spin_unlock_irq(&phba->hbalock);
1000         /* count may include a LF at end of string */
1001         if (buf[cnt-1] == '\n')
1002                 cnt--;
1003
1004         if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
1005             ((cnt == 17) && (*buf++ != 'x')) ||
1006             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
1007                 return -EINVAL;
1008
1009         phba->soft_wwn_enable = 0;
1010
1011         memset(wwpn, 0, sizeof(wwpn));
1012
1013         /* Validate and store the new name */
1014         for (i=0, j=0; i < 16; i++) {
1015                 if ((*buf >= 'a') && (*buf <= 'f'))
1016                         j = ((j << 4) | ((*buf++ -'a') + 10));
1017                 else if ((*buf >= 'A') && (*buf <= 'F'))
1018                         j = ((j << 4) | ((*buf++ -'A') + 10));
1019                 else if ((*buf >= '0') && (*buf <= '9'))
1020                         j = ((j << 4) | (*buf++ -'0'));
1021                 else
1022                         return -EINVAL;
1023                 if (i % 2) {
1024                         wwpn[i/2] = j & 0xff;
1025                         j = 0;
1026                 }
1027         }
1028         phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
1029         fc_host_port_name(shost) = phba->cfg_soft_wwpn;
1030         if (phba->cfg_soft_wwnn)
1031                 fc_host_node_name(shost) = phba->cfg_soft_wwnn;
1032
1033         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
1034                    "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
1035
1036         stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1037         if (stat1)
1038                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1039                                 "0463 lpfc_soft_wwpn attribute set failed to "
1040                                 "reinit adapter - %d\n", stat1);
1041         init_completion(&online_compl);
1042         lpfc_workq_post_event(phba, &stat2, &online_compl, LPFC_EVT_ONLINE);
1043         wait_for_completion(&online_compl);
1044         if (stat2)
1045                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1046                                 "0464 lpfc_soft_wwpn attribute set failed to "
1047                                 "reinit adapter - %d\n", stat2);
1048         return (stat1 || stat2) ? -EIO : count;
1049 }
1050 static CLASS_DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
1051                          lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
1052
1053 static ssize_t
1054 lpfc_soft_wwnn_show(struct class_device *cdev, char *buf)
1055 {
1056         struct Scsi_Host *shost = class_to_shost(cdev);
1057         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
1058         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
1059                         (unsigned long long)phba->cfg_soft_wwnn);
1060 }
1061
1062
1063 static ssize_t
1064 lpfc_soft_wwnn_store(struct class_device *cdev, const char *buf, size_t count)
1065 {
1066         struct Scsi_Host *shost = class_to_shost(cdev);
1067         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
1068         unsigned int i, j, cnt=count;
1069         u8 wwnn[8];
1070
1071         /* count may include a LF at end of string */
1072         if (buf[cnt-1] == '\n')
1073                 cnt--;
1074
1075         if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
1076             ((cnt == 17) && (*buf++ != 'x')) ||
1077             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
1078                 return -EINVAL;
1079
1080         /*
1081          * Allow wwnn to be set many times, as long as the enable is set.
1082          * However, once the wwpn is set, everything locks.
1083          */
1084
1085         memset(wwnn, 0, sizeof(wwnn));
1086
1087         /* Validate and store the new name */
1088         for (i=0, j=0; i < 16; i++) {
1089                 if ((*buf >= 'a') && (*buf <= 'f'))
1090                         j = ((j << 4) | ((*buf++ -'a') + 10));
1091                 else if ((*buf >= 'A') && (*buf <= 'F'))
1092                         j = ((j << 4) | ((*buf++ -'A') + 10));
1093                 else if ((*buf >= '0') && (*buf <= '9'))
1094                         j = ((j << 4) | (*buf++ -'0'));
1095                 else
1096                         return -EINVAL;
1097                 if (i % 2) {
1098                         wwnn[i/2] = j & 0xff;
1099                         j = 0;
1100                 }
1101         }
1102         phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
1103
1104         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
1105                    "lpfc%d: soft_wwnn set. Value will take effect upon "
1106                    "setting of the soft_wwpn\n", phba->brd_no);
1107
1108         return count;
1109 }
1110 static CLASS_DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
1111                          lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
1112
1113
1114 static int lpfc_poll = 0;
1115 module_param(lpfc_poll, int, 0);
1116 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
1117                  " 0 - none,"
1118                  " 1 - poll with interrupts enabled"
1119                  " 3 - poll and disable FCP ring interrupts");
1120
1121 static CLASS_DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
1122                          lpfc_poll_show, lpfc_poll_store);
1123
1124 int  lpfc_sli_mode = 0;
1125 module_param(lpfc_sli_mode, int, 0);
1126 MODULE_PARM_DESC(lpfc_sli_mode, "SLI mode selector:"
1127                  " 0 - auto (SLI-3 if supported),"
1128                  " 2 - select SLI-2 even on SLI-3 capable HBAs,"
1129                  " 3 - select SLI-3");
1130
1131 int lpfc_enable_npiv = 0;
1132 module_param(lpfc_enable_npiv, int, 0);
1133 MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
1134 lpfc_param_show(enable_npiv);
1135 lpfc_param_init(enable_npiv, 0, 0, 1);
1136 static CLASS_DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO,
1137                          lpfc_enable_npiv_show, NULL);
1138
1139 /*
1140 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
1141 # until the timer expires. Value range is [0,255]. Default value is 30.
1142 */
1143 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
1144 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
1145 module_param(lpfc_nodev_tmo, int, 0);
1146 MODULE_PARM_DESC(lpfc_nodev_tmo,
1147                  "Seconds driver will hold I/O waiting "
1148                  "for a device to come back");
1149 static ssize_t
1150 lpfc_nodev_tmo_show(struct class_device *cdev, char *buf)
1151 {
1152         struct Scsi_Host  *shost = class_to_shost(cdev);
1153         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1154         int val = 0;
1155         val = vport->cfg_devloss_tmo;
1156         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
1157 }
1158
1159 static int
1160 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
1161 {
1162         if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
1163                 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
1164                 if (val != LPFC_DEF_DEVLOSS_TMO)
1165                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1166                                          "0402 Ignoring nodev_tmo module "
1167                                          "parameter because devloss_tmo is "
1168                                          "set.\n");
1169                 return 0;
1170         }
1171
1172         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
1173                 vport->cfg_nodev_tmo = val;
1174                 vport->cfg_devloss_tmo = val;
1175                 return 0;
1176         }
1177         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1178                          "0400 lpfc_nodev_tmo attribute cannot be set to"
1179                          " %d, allowed range is [%d, %d]\n",
1180                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
1181         vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
1182         return -EINVAL;
1183 }
1184
1185 static void
1186 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
1187 {
1188         struct Scsi_Host  *shost;
1189         struct lpfc_nodelist  *ndlp;
1190
1191         shost = lpfc_shost_from_vport(vport);
1192         spin_lock_irq(shost->host_lock);
1193         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
1194                 if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
1195                         ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
1196         spin_unlock_irq(shost->host_lock);
1197 }
1198
1199 static int
1200 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
1201 {
1202         if (vport->dev_loss_tmo_changed ||
1203             (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
1204                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1205                                  "0401 Ignoring change to nodev_tmo "
1206                                  "because devloss_tmo is set.\n");
1207                 return 0;
1208         }
1209         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
1210                 vport->cfg_nodev_tmo = val;
1211                 vport->cfg_devloss_tmo = val;
1212                 lpfc_update_rport_devloss_tmo(vport);
1213                 return 0;
1214         }
1215         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1216                          "0403 lpfc_nodev_tmo attribute cannot be set to"
1217                          "%d, allowed range is [%d, %d]\n",
1218                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
1219         return -EINVAL;
1220 }
1221
1222 lpfc_vport_param_store(nodev_tmo)
1223
1224 static CLASS_DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
1225                          lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
1226
1227 /*
1228 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
1229 # disappear until the timer expires. Value range is [0,255]. Default
1230 # value is 30.
1231 */
1232 module_param(lpfc_devloss_tmo, int, 0);
1233 MODULE_PARM_DESC(lpfc_devloss_tmo,
1234                  "Seconds driver will hold I/O waiting "
1235                  "for a device to come back");
1236 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
1237                       LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
1238 lpfc_vport_param_show(devloss_tmo)
1239 static int
1240 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
1241 {
1242         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
1243                 vport->cfg_nodev_tmo = val;
1244                 vport->cfg_devloss_tmo = val;
1245                 vport->dev_loss_tmo_changed = 1;
1246                 lpfc_update_rport_devloss_tmo(vport);
1247                 return 0;
1248         }
1249
1250         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1251                          "0404 lpfc_devloss_tmo attribute cannot be set to"
1252                          " %d, allowed range is [%d, %d]\n",
1253                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
1254         return -EINVAL;
1255 }
1256
1257 lpfc_vport_param_store(devloss_tmo)
1258 static CLASS_DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
1259         lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
1260
1261 /*
1262 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
1263 # deluged with LOTS of information.
1264 # You can set a bit mask to record specific types of verbose messages:
1265 #
1266 # LOG_ELS                       0x1        ELS events
1267 # LOG_DISCOVERY                 0x2        Link discovery events
1268 # LOG_MBOX                      0x4        Mailbox events
1269 # LOG_INIT                      0x8        Initialization events
1270 # LOG_LINK_EVENT                0x10       Link events
1271 # LOG_FCP                       0x40       FCP traffic history
1272 # LOG_NODE                      0x80       Node table events
1273 # LOG_MISC                      0x400      Miscellaneous events
1274 # LOG_SLI                       0x800      SLI events
1275 # LOG_FCP_ERROR                 0x1000     Only log FCP errors
1276 # LOG_LIBDFC                    0x2000     LIBDFC events
1277 # LOG_ALL_MSG                   0xffff     LOG all messages
1278 */
1279 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffff,
1280                        "Verbose logging bit-mask");
1281
1282 /*
1283 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
1284 # objects that have been registered with the nameserver after login.
1285 */
1286 LPFC_VPORT_ATTR_R(enable_da_id, 0, 0, 1,
1287                   "Deregister nameserver objects before LOGO");
1288
1289 /*
1290 # lun_queue_depth:  This parameter is used to limit the number of outstanding
1291 # commands per FCP LUN. Value range is [1,128]. Default value is 30.
1292 */
1293 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128,
1294                   "Max number of FCP commands we can queue to a specific LUN");
1295
1296 /*
1297 # hba_queue_depth:  This parameter is used to limit the number of outstanding
1298 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
1299 # value is greater than the maximum number of exchanges supported by the HBA,
1300 # then maximum number of exchanges supported by the HBA is used to determine
1301 # the hba_queue_depth.
1302 */
1303 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
1304             "Max number of FCP commands we can queue to a lpfc HBA");
1305
1306 /*
1307 # peer_port_login:  This parameter allows/prevents logins
1308 # between peer ports hosted on the same physical port.
1309 # When this parameter is set 0 peer ports of same physical port
1310 # are not allowed to login to each other.
1311 # When this parameter is set 1 peer ports of same physical port
1312 # are allowed to login to each other.
1313 # Default value of this parameter is 0.
1314 */
1315 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
1316                   "Allow peer ports on the same physical port to login to each "
1317                   "other.");
1318
1319 /*
1320 # restrict_login:  This parameter allows/prevents logins
1321 # between Virtual Ports and remote initiators.
1322 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
1323 # other initiators and will attempt to PLOGI all remote ports.
1324 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
1325 # remote ports and will not attempt to PLOGI to other initiators.
1326 # This parameter does not restrict to the physical port.
1327 # This parameter does not restrict logins to Fabric resident remote ports.
1328 # Default value of this parameter is 1.
1329 */
1330 static int lpfc_restrict_login = 1;
1331 module_param(lpfc_restrict_login, int, 0);
1332 MODULE_PARM_DESC(lpfc_restrict_login,
1333                  "Restrict virtual ports login to remote initiators.");
1334 lpfc_vport_param_show(restrict_login);
1335
1336 static int
1337 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
1338 {
1339         if (val < 0 || val > 1) {
1340                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1341                                  "0449 lpfc_restrict_login attribute cannot "
1342                                  "be set to %d, allowed range is [0, 1]\n",
1343                                  val);
1344                 vport->cfg_restrict_login = 1;
1345                 return -EINVAL;
1346         }
1347         if (vport->port_type == LPFC_PHYSICAL_PORT) {
1348                 vport->cfg_restrict_login = 0;
1349                 return 0;
1350         }
1351         vport->cfg_restrict_login = val;
1352         return 0;
1353 }
1354
1355 static int
1356 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
1357 {
1358         if (val < 0 || val > 1) {
1359                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1360                                  "0450 lpfc_restrict_login attribute cannot "
1361                                  "be set to %d, allowed range is [0, 1]\n",
1362                                  val);
1363                 vport->cfg_restrict_login = 1;
1364                 return -EINVAL;
1365         }
1366         if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
1367                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1368                                  "0468 lpfc_restrict_login must be 0 for "
1369                                  "Physical ports.\n");
1370                 vport->cfg_restrict_login = 0;
1371                 return 0;
1372         }
1373         vport->cfg_restrict_login = val;
1374         return 0;
1375 }
1376 lpfc_vport_param_store(restrict_login);
1377 static CLASS_DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
1378                          lpfc_restrict_login_show, lpfc_restrict_login_store);
1379
1380 /*
1381 # Some disk devices have a "select ID" or "select Target" capability.
1382 # From a protocol standpoint "select ID" usually means select the
1383 # Fibre channel "ALPA".  In the FC-AL Profile there is an "informative
1384 # annex" which contains a table that maps a "select ID" (a number
1385 # between 0 and 7F) to an ALPA.  By default, for compatibility with
1386 # older drivers, the lpfc driver scans this table from low ALPA to high
1387 # ALPA.
1388 #
1389 # Turning on the scan-down variable (on  = 1, off = 0) will
1390 # cause the lpfc driver to use an inverted table, effectively
1391 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
1392 #
1393 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
1394 # and will not work across a fabric. Also this parameter will take
1395 # effect only in the case when ALPA map is not available.)
1396 */
1397 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
1398                   "Start scanning for devices from highest ALPA to lowest");
1399
1400 /*
1401 # lpfc_topology:  link topology for init link
1402 #            0x0  = attempt loop mode then point-to-point
1403 #            0x01 = internal loopback mode
1404 #            0x02 = attempt point-to-point mode only
1405 #            0x04 = attempt loop mode only
1406 #            0x06 = attempt point-to-point mode then loop
1407 # Set point-to-point mode if you want to run as an N_Port.
1408 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
1409 # Default value is 0.
1410 */
1411 static int
1412 lpfc_topology_set(struct lpfc_hba *phba, int val)
1413 {
1414         int err;
1415         uint32_t prev_val;
1416         if (val >= 0 && val <= 6) {
1417                 prev_val = phba->cfg_topology;
1418                 phba->cfg_topology = val;
1419                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
1420                 if (err)
1421                         phba->cfg_topology = prev_val;
1422                 return err;
1423         }
1424         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1425                 "%d:0467 lpfc_topology attribute cannot be set to %d, "
1426                 "allowed range is [0, 6]\n",
1427                 phba->brd_no, val);
1428         return -EINVAL;
1429 }
1430 static int lpfc_topology = 0;
1431 module_param(lpfc_topology, int, 0);
1432 MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
1433 lpfc_param_show(topology)
1434 lpfc_param_init(topology, 0, 0, 6)
1435 lpfc_param_store(topology)
1436 static CLASS_DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
1437                 lpfc_topology_show, lpfc_topology_store);
1438
1439 /*
1440 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
1441 # connection.
1442 #       0  = auto select (default)
1443 #       1  = 1 Gigabaud
1444 #       2  = 2 Gigabaud
1445 #       4  = 4 Gigabaud
1446 #       8  = 8 Gigabaud
1447 # Value range is [0,8]. Default value is 0.
1448 */
1449 static int
1450 lpfc_link_speed_set(struct lpfc_hba *phba, int val)
1451 {
1452         int err;
1453         uint32_t prev_val;
1454
1455         if (((val == LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
1456                 ((val == LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
1457                 ((val == LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
1458                 ((val == LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
1459                 ((val == LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)))
1460                 return -EINVAL;
1461
1462         if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED)
1463                 && (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
1464                 prev_val = phba->cfg_link_speed;
1465                 phba->cfg_link_speed = val;
1466                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
1467                 if (err)
1468                         phba->cfg_link_speed = prev_val;
1469                 return err;
1470         }
1471
1472         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1473                 "%d:0469 lpfc_link_speed attribute cannot be set to %d, "
1474                 "allowed range is [0, 8]\n",
1475                 phba->brd_no, val);
1476         return -EINVAL;
1477 }
1478
1479 static int lpfc_link_speed = 0;
1480 module_param(lpfc_link_speed, int, 0);
1481 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
1482 lpfc_param_show(link_speed)
1483 static int
1484 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
1485 {
1486         if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED)
1487                 && (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
1488                 phba->cfg_link_speed = val;
1489                 return 0;
1490         }
1491         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1492                         "0454 lpfc_link_speed attribute cannot "
1493                         "be set to %d, allowed values are "
1494                         "["LPFC_LINK_SPEED_STRING"]\n", val);
1495         phba->cfg_link_speed = 0;
1496         return -EINVAL;
1497 }
1498
1499 lpfc_param_store(link_speed)
1500 static CLASS_DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
1501                 lpfc_link_speed_show, lpfc_link_speed_store);
1502
1503 /*
1504 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
1505 # Value range is [2,3]. Default value is 3.
1506 */
1507 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
1508                   "Select Fibre Channel class of service for FCP sequences");
1509
1510 /*
1511 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
1512 # is [0,1]. Default value is 0.
1513 */
1514 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
1515                    "Use ADISC on rediscovery to authenticate FCP devices");
1516
1517 /*
1518 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
1519 # range is [0,1]. Default value is 0.
1520 */
1521 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
1522
1523 /*
1524 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
1525 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
1526 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
1527 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
1528 # cr_delay is set to 0.
1529 */
1530 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
1531                 "interrupt response is generated");
1532
1533 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
1534                 "interrupt response is generated");
1535
1536 /*
1537 # lpfc_multi_ring_support:  Determines how many rings to spread available
1538 # cmd/rsp IOCB entries across.
1539 # Value range is [1,2]. Default value is 1.
1540 */
1541 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
1542                 "SLI rings to spread IOCB entries across");
1543
1544 /*
1545 # lpfc_multi_ring_rctl:  If lpfc_multi_ring_support is enabled, this
1546 # identifies what rctl value to configure the additional ring for.
1547 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
1548 */
1549 LPFC_ATTR_R(multi_ring_rctl, FC_UNSOL_DATA, 1,
1550              255, "Identifies RCTL for additional ring configuration");
1551
1552 /*
1553 # lpfc_multi_ring_type:  If lpfc_multi_ring_support is enabled, this
1554 # identifies what type value to configure the additional ring for.
1555 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
1556 */
1557 LPFC_ATTR_R(multi_ring_type, FC_LLC_SNAP, 1,
1558              255, "Identifies TYPE for additional ring configuration");
1559
1560 /*
1561 # lpfc_fdmi_on: controls FDMI support.
1562 #       0 = no FDMI support
1563 #       1 = support FDMI without attribute of hostname
1564 #       2 = support FDMI with attribute of hostname
1565 # Value range [0,2]. Default value is 0.
1566 */
1567 LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support");
1568
1569 /*
1570 # Specifies the maximum number of ELS cmds we can have outstanding (for
1571 # discovery). Value range is [1,64]. Default value = 32.
1572 */
1573 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
1574                  "during discovery");
1575
1576 /*
1577 # lpfc_max_luns: maximum allowed LUN.
1578 # Value range is [0,65535]. Default value is 255.
1579 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
1580 */
1581 LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN");
1582
1583 /*
1584 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
1585 # Value range is [1,255], default value is 10.
1586 */
1587 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
1588              "Milliseconds driver will wait between polling FCP ring");
1589
1590 /*
1591 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
1592 #               support this feature
1593 #       0  = MSI disabled (default)
1594 #       1  = MSI enabled
1595 #       2  = MSI-X enabled
1596 # Value range is [0,2]. Default value is 0.
1597 */
1598 LPFC_ATTR_R(use_msi, 0, 0, 2, "Use Message Signaled Interrupts (1) or "
1599             "MSI-X (2), if possible");
1600
1601 /*
1602 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
1603 #       0  = HBA resets disabled
1604 #       1  = HBA resets enabled (default)
1605 # Value range is [0,1]. Default value is 1.
1606 */
1607 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
1608
1609 /*
1610 # lpfc_enable_hba_heartbeat: Enable HBA heartbeat timer..
1611 #       0  = HBA Heartbeat disabled
1612 #       1  = HBA Heartbeat enabled (default)
1613 # Value range is [0,1]. Default value is 1.
1614 */
1615 LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat.");
1616
1617 /*
1618  * lpfc_sg_seg_cnt: Initial Maximum DMA Segment Count
1619  * This value can be set to values between 64 and 256. The default value is
1620  * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
1621  * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
1622  */
1623 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
1624             LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
1625
1626 struct class_device_attribute *lpfc_hba_attrs[] = {
1627         &class_device_attr_info,
1628         &class_device_attr_serialnum,
1629         &class_device_attr_modeldesc,
1630         &class_device_attr_modelname,
1631         &class_device_attr_programtype,
1632         &class_device_attr_portnum,
1633         &class_device_attr_fwrev,
1634         &class_device_attr_hdw,
1635         &class_device_attr_option_rom_version,
1636         &class_device_attr_state,
1637         &class_device_attr_num_discovered_ports,
1638         &class_device_attr_lpfc_drvr_version,
1639         &class_device_attr_lpfc_temp_sensor,
1640         &class_device_attr_lpfc_log_verbose,
1641         &class_device_attr_lpfc_lun_queue_depth,
1642         &class_device_attr_lpfc_hba_queue_depth,
1643         &class_device_attr_lpfc_peer_port_login,
1644         &class_device_attr_lpfc_nodev_tmo,
1645         &class_device_attr_lpfc_devloss_tmo,
1646         &class_device_attr_lpfc_fcp_class,
1647         &class_device_attr_lpfc_use_adisc,
1648         &class_device_attr_lpfc_ack0,
1649         &class_device_attr_lpfc_topology,
1650         &class_device_attr_lpfc_scan_down,
1651         &class_device_attr_lpfc_link_speed,
1652         &class_device_attr_lpfc_cr_delay,
1653         &class_device_attr_lpfc_cr_count,
1654         &class_device_attr_lpfc_multi_ring_support,
1655         &class_device_attr_lpfc_multi_ring_rctl,
1656         &class_device_attr_lpfc_multi_ring_type,
1657         &class_device_attr_lpfc_fdmi_on,
1658         &class_device_attr_lpfc_max_luns,
1659         &class_device_attr_lpfc_enable_npiv,
1660         &class_device_attr_nport_evt_cnt,
1661         &class_device_attr_board_mode,
1662         &class_device_attr_max_vpi,
1663         &class_device_attr_used_vpi,
1664         &class_device_attr_max_rpi,
1665         &class_device_attr_used_rpi,
1666         &class_device_attr_max_xri,
1667         &class_device_attr_used_xri,
1668         &class_device_attr_npiv_info,
1669         &class_device_attr_issue_reset,
1670         &class_device_attr_lpfc_poll,
1671         &class_device_attr_lpfc_poll_tmo,
1672         &class_device_attr_lpfc_use_msi,
1673         &class_device_attr_lpfc_soft_wwnn,
1674         &class_device_attr_lpfc_soft_wwpn,
1675         &class_device_attr_lpfc_soft_wwn_enable,
1676         &class_device_attr_lpfc_enable_hba_reset,
1677         &class_device_attr_lpfc_enable_hba_heartbeat,
1678         &class_device_attr_lpfc_sg_seg_cnt,
1679         NULL,
1680 };
1681
1682 struct class_device_attribute *lpfc_vport_attrs[] = {
1683         &class_device_attr_info,
1684         &class_device_attr_state,
1685         &class_device_attr_num_discovered_ports,
1686         &class_device_attr_lpfc_drvr_version,
1687
1688         &class_device_attr_lpfc_log_verbose,
1689         &class_device_attr_lpfc_lun_queue_depth,
1690         &class_device_attr_lpfc_nodev_tmo,
1691         &class_device_attr_lpfc_devloss_tmo,
1692         &class_device_attr_lpfc_hba_queue_depth,
1693         &class_device_attr_lpfc_peer_port_login,
1694         &class_device_attr_lpfc_restrict_login,
1695         &class_device_attr_lpfc_fcp_class,
1696         &class_device_attr_lpfc_use_adisc,
1697         &class_device_attr_lpfc_fdmi_on,
1698         &class_device_attr_lpfc_max_luns,
1699         &class_device_attr_nport_evt_cnt,
1700         &class_device_attr_npiv_info,
1701         &class_device_attr_lpfc_enable_da_id,
1702         NULL,
1703 };
1704
1705 static ssize_t
1706 sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
1707                    char *buf, loff_t off, size_t count)
1708 {
1709         size_t buf_off;
1710         struct class_device *cdev = container_of(kobj, struct class_device,
1711                                                  kobj);
1712         struct Scsi_Host  *shost = class_to_shost(cdev);
1713         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1714         struct lpfc_hba   *phba = vport->phba;
1715
1716         if ((off + count) > FF_REG_AREA_SIZE)
1717                 return -ERANGE;
1718
1719         if (count == 0) return 0;
1720
1721         if (off % 4 || count % 4 || (unsigned long)buf % 4)
1722                 return -EINVAL;
1723
1724         if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
1725                 return -EPERM;
1726         }
1727
1728         spin_lock_irq(&phba->hbalock);
1729         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t))
1730                 writel(*((uint32_t *)(buf + buf_off)),
1731                        phba->ctrl_regs_memmap_p + off + buf_off);
1732
1733         spin_unlock_irq(&phba->hbalock);
1734
1735         return count;
1736 }
1737
1738 static ssize_t
1739 sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr,
1740                   char *buf, loff_t off, size_t count)
1741 {
1742         size_t buf_off;
1743         uint32_t * tmp_ptr;
1744         struct class_device *cdev = container_of(kobj, struct class_device,
1745                                                  kobj);
1746         struct Scsi_Host  *shost = class_to_shost(cdev);
1747         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1748         struct lpfc_hba   *phba = vport->phba;
1749
1750         if (off > FF_REG_AREA_SIZE)
1751                 return -ERANGE;
1752
1753         if ((off + count) > FF_REG_AREA_SIZE)
1754                 count = FF_REG_AREA_SIZE - off;
1755
1756         if (count == 0) return 0;
1757
1758         if (off % 4 || count % 4 || (unsigned long)buf % 4)
1759                 return -EINVAL;
1760
1761         spin_lock_irq(&phba->hbalock);
1762
1763         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
1764                 tmp_ptr = (uint32_t *)(buf + buf_off);
1765                 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
1766         }
1767
1768         spin_unlock_irq(&phba->hbalock);
1769
1770         return count;
1771 }
1772
1773 static struct bin_attribute sysfs_ctlreg_attr = {
1774         .attr = {
1775                 .name = "ctlreg",
1776                 .mode = S_IRUSR | S_IWUSR,
1777         },
1778         .size = 256,
1779         .read = sysfs_ctlreg_read,
1780         .write = sysfs_ctlreg_write,
1781 };
1782
1783
1784 static void
1785 sysfs_mbox_idle(struct lpfc_hba *phba)
1786 {
1787         phba->sysfs_mbox.state = SMBOX_IDLE;
1788         phba->sysfs_mbox.offset = 0;
1789
1790         if (phba->sysfs_mbox.mbox) {
1791                 mempool_free(phba->sysfs_mbox.mbox,
1792                              phba->mbox_mem_pool);
1793                 phba->sysfs_mbox.mbox = NULL;
1794         }
1795 }
1796
1797 static ssize_t
1798 sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
1799                  char *buf, loff_t off, size_t count)
1800 {
1801         struct class_device *cdev = container_of(kobj, struct class_device,
1802                                                  kobj);
1803         struct Scsi_Host  *shost = class_to_shost(cdev);
1804         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1805         struct lpfc_hba   *phba = vport->phba;
1806         struct lpfcMboxq  *mbox = NULL;
1807
1808         if ((count + off) > MAILBOX_CMD_SIZE)
1809                 return -ERANGE;
1810
1811         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
1812                 return -EINVAL;
1813
1814         if (count == 0)
1815                 return 0;
1816
1817         if (off == 0) {
1818                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1819                 if (!mbox)
1820                         return -ENOMEM;
1821                 memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
1822         }
1823
1824         spin_lock_irq(&phba->hbalock);
1825
1826         if (off == 0) {
1827                 if (phba->sysfs_mbox.mbox)
1828                         mempool_free(mbox, phba->mbox_mem_pool);
1829                 else
1830                         phba->sysfs_mbox.mbox = mbox;
1831                 phba->sysfs_mbox.state = SMBOX_WRITING;
1832         } else {
1833                 if (phba->sysfs_mbox.state  != SMBOX_WRITING ||
1834                     phba->sysfs_mbox.offset != off           ||
1835                     phba->sysfs_mbox.mbox   == NULL) {
1836                         sysfs_mbox_idle(phba);
1837                         spin_unlock_irq(&phba->hbalock);
1838                         return -EAGAIN;
1839                 }
1840         }
1841
1842         memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off,
1843                buf, count);
1844
1845         phba->sysfs_mbox.offset = off + count;
1846
1847         spin_unlock_irq(&phba->hbalock);
1848
1849         return count;
1850 }
1851
1852 static ssize_t
1853 sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr,
1854                 char *buf, loff_t off, size_t count)
1855 {
1856         struct class_device *cdev = container_of(kobj, struct class_device,
1857                                                  kobj);
1858         struct Scsi_Host  *shost = class_to_shost(cdev);
1859         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1860         struct lpfc_hba   *phba = vport->phba;
1861         int rc;
1862
1863         if (off > MAILBOX_CMD_SIZE)
1864                 return -ERANGE;
1865
1866         if ((count + off) > MAILBOX_CMD_SIZE)
1867                 count = MAILBOX_CMD_SIZE - off;
1868
1869         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
1870                 return -EINVAL;
1871
1872         if (off && count == 0)
1873                 return 0;
1874
1875         spin_lock_irq(&phba->hbalock);
1876
1877         if (phba->over_temp_state == HBA_OVER_TEMP) {
1878                 sysfs_mbox_idle(phba);
1879                 spin_unlock_irq(&phba->hbalock);
1880                 return  -EACCES;
1881         }
1882
1883         if (off == 0 &&
1884             phba->sysfs_mbox.state  == SMBOX_WRITING &&
1885             phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
1886
1887                 switch (phba->sysfs_mbox.mbox->mb.mbxCommand) {
1888                         /* Offline only */
1889                 case MBX_INIT_LINK:
1890                 case MBX_DOWN_LINK:
1891                 case MBX_CONFIG_LINK:
1892                 case MBX_CONFIG_RING:
1893                 case MBX_RESET_RING:
1894                 case MBX_UNREG_LOGIN:
1895                 case MBX_CLEAR_LA:
1896                 case MBX_DUMP_CONTEXT:
1897                 case MBX_RUN_DIAGS:
1898                 case MBX_RESTART:
1899                 case MBX_SET_MASK:
1900                 case MBX_SET_DEBUG:
1901                         if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
1902                                 printk(KERN_WARNING "mbox_read:Command 0x%x "
1903                                        "is illegal in on-line state\n",
1904                                        phba->sysfs_mbox.mbox->mb.mbxCommand);
1905                                 sysfs_mbox_idle(phba);
1906                                 spin_unlock_irq(&phba->hbalock);
1907                                 return -EPERM;
1908                         }
1909                 case MBX_WRITE_NV:
1910                 case MBX_WRITE_VPARMS:
1911                 case MBX_LOAD_SM:
1912                 case MBX_READ_NV:
1913                 case MBX_READ_CONFIG:
1914                 case MBX_READ_RCONFIG:
1915                 case MBX_READ_STATUS:
1916                 case MBX_READ_XRI:
1917                 case MBX_READ_REV:
1918                 case MBX_READ_LNK_STAT:
1919                 case MBX_DUMP_MEMORY:
1920                 case MBX_DOWN_LOAD:
1921                 case MBX_UPDATE_CFG:
1922                 case MBX_KILL_BOARD:
1923                 case MBX_LOAD_AREA:
1924                 case MBX_LOAD_EXP_ROM:
1925                 case MBX_BEACON:
1926                 case MBX_DEL_LD_ENTRY:
1927                 case MBX_SET_VARIABLE:
1928                 case MBX_WRITE_WWN:
1929                         break;
1930                 case MBX_READ_SPARM64:
1931                 case MBX_READ_LA:
1932                 case MBX_READ_LA64:
1933                 case MBX_REG_LOGIN:
1934                 case MBX_REG_LOGIN64:
1935                 case MBX_CONFIG_PORT:
1936                 case MBX_RUN_BIU_DIAG:
1937                         printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
1938                                phba->sysfs_mbox.mbox->mb.mbxCommand);
1939                         sysfs_mbox_idle(phba);
1940                         spin_unlock_irq(&phba->hbalock);
1941                         return -EPERM;
1942                 default:
1943                         printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
1944                                phba->sysfs_mbox.mbox->mb.mbxCommand);
1945                         sysfs_mbox_idle(phba);
1946                         spin_unlock_irq(&phba->hbalock);
1947                         return -EPERM;
1948                 }
1949
1950                 /* If HBA encountered an error attention, allow only DUMP
1951                  * or RESTART mailbox commands until the HBA is restarted.
1952                  */
1953                 if ((phba->pport->stopped) &&
1954                         (phba->sysfs_mbox.mbox->mb.mbxCommand !=
1955                                 MBX_DUMP_MEMORY &&
1956                          phba->sysfs_mbox.mbox->mb.mbxCommand !=
1957                                 MBX_RESTART &&
1958                          phba->sysfs_mbox.mbox->mb.mbxCommand !=
1959                                 MBX_WRITE_VPARMS)) {
1960                         sysfs_mbox_idle(phba);
1961                         spin_unlock_irq(&phba->hbalock);
1962                         return -EPERM;
1963                 }
1964
1965                 phba->sysfs_mbox.mbox->vport = vport;
1966
1967                 /* Don't allow mailbox commands to be sent when blocked
1968                  * or when in the middle of discovery
1969                  */
1970                 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO ||
1971                     vport->fc_flag & FC_NDISC_ACTIVE) {
1972                         sysfs_mbox_idle(phba);
1973                         spin_unlock_irq(&phba->hbalock);
1974                         return  -EAGAIN;
1975                 }
1976
1977                 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
1978                     (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){
1979
1980                         spin_unlock_irq(&phba->hbalock);
1981                         rc = lpfc_sli_issue_mbox (phba,
1982                                                   phba->sysfs_mbox.mbox,
1983                                                   MBX_POLL);
1984                         spin_lock_irq(&phba->hbalock);
1985
1986                 } else {
1987                         spin_unlock_irq(&phba->hbalock);
1988                         rc = lpfc_sli_issue_mbox_wait (phba,
1989                                                        phba->sysfs_mbox.mbox,
1990                                 lpfc_mbox_tmo_val(phba,
1991                                     phba->sysfs_mbox.mbox->mb.mbxCommand) * HZ);
1992                         spin_lock_irq(&phba->hbalock);
1993                 }
1994
1995                 if (rc != MBX_SUCCESS) {
1996                         if (rc == MBX_TIMEOUT) {
1997                                 phba->sysfs_mbox.mbox = NULL;
1998                         }
1999                         sysfs_mbox_idle(phba);
2000                         spin_unlock_irq(&phba->hbalock);
2001                         return  (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
2002                 }
2003                 phba->sysfs_mbox.state = SMBOX_READING;
2004         }
2005         else if (phba->sysfs_mbox.offset != off ||
2006                  phba->sysfs_mbox.state  != SMBOX_READING) {
2007                 printk(KERN_WARNING  "mbox_read: Bad State\n");
2008                 sysfs_mbox_idle(phba);
2009                 spin_unlock_irq(&phba->hbalock);
2010                 return -EAGAIN;
2011         }
2012
2013         memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count);
2014
2015         phba->sysfs_mbox.offset = off + count;
2016
2017         if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
2018                 sysfs_mbox_idle(phba);
2019
2020         spin_unlock_irq(&phba->hbalock);
2021
2022         return count;
2023 }
2024
2025 static struct bin_attribute sysfs_mbox_attr = {
2026         .attr = {
2027                 .name = "mbox",
2028                 .mode = S_IRUSR | S_IWUSR,
2029         },
2030         .size = MAILBOX_CMD_SIZE,
2031         .read = sysfs_mbox_read,
2032         .write = sysfs_mbox_write,
2033 };
2034
2035 int
2036 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
2037 {
2038         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2039         int error;
2040
2041         error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
2042                                       &sysfs_ctlreg_attr);
2043         if (error)
2044                 goto out;
2045
2046         error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
2047                                       &sysfs_mbox_attr);
2048         if (error)
2049                 goto out_remove_ctlreg_attr;
2050
2051         return 0;
2052 out_remove_ctlreg_attr:
2053         sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
2054 out:
2055         return error;
2056 }
2057
2058 void
2059 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
2060 {
2061         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2062
2063         sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_mbox_attr);
2064         sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
2065 }
2066
2067
2068 /*
2069  * Dynamic FC Host Attributes Support
2070  */
2071
2072 static void
2073 lpfc_get_host_port_id(struct Scsi_Host *shost)
2074 {
2075         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2076
2077         /* note: fc_myDID already in cpu endianness */
2078         fc_host_port_id(shost) = vport->fc_myDID;
2079 }
2080
2081 static void
2082 lpfc_get_host_port_type(struct Scsi_Host *shost)
2083 {
2084         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2085         struct lpfc_hba   *phba = vport->phba;
2086
2087         spin_lock_irq(shost->host_lock);
2088
2089         if (vport->port_type == LPFC_NPIV_PORT) {
2090                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
2091         } else if (lpfc_is_link_up(phba)) {
2092                 if (phba->fc_topology == TOPOLOGY_LOOP) {
2093                         if (vport->fc_flag & FC_PUBLIC_LOOP)
2094                                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
2095                         else
2096                                 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
2097                 } else {
2098                         if (vport->fc_flag & FC_FABRIC)
2099                                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
2100                         else
2101                                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
2102                 }
2103         } else
2104                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
2105
2106         spin_unlock_irq(shost->host_lock);
2107 }
2108
2109 static void
2110 lpfc_get_host_port_state(struct Scsi_Host *shost)
2111 {
2112         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2113         struct lpfc_hba   *phba = vport->phba;
2114
2115         spin_lock_irq(shost->host_lock);
2116
2117         if (vport->fc_flag & FC_OFFLINE_MODE)
2118                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
2119         else {
2120                 switch (phba->link_state) {
2121                 case LPFC_LINK_UNKNOWN:
2122                 case LPFC_LINK_DOWN:
2123                         fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
2124                         break;
2125                 case LPFC_LINK_UP:
2126                 case LPFC_CLEAR_LA:
2127                 case LPFC_HBA_READY:
2128                         /* Links up, beyond this port_type reports state */
2129                         fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
2130                         break;
2131                 case LPFC_HBA_ERROR:
2132                         fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
2133                         break;
2134                 default:
2135                         fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
2136                         break;
2137                 }
2138         }
2139
2140         spin_unlock_irq(shost->host_lock);
2141 }
2142
2143 static void
2144 lpfc_get_host_speed(struct Scsi_Host *shost)
2145 {
2146         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2147         struct lpfc_hba   *phba = vport->phba;
2148
2149         spin_lock_irq(shost->host_lock);
2150
2151         if (lpfc_is_link_up(phba)) {
2152                 switch(phba->fc_linkspeed) {
2153                         case LA_1GHZ_LINK:
2154                                 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
2155                         break;
2156                         case LA_2GHZ_LINK:
2157                                 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
2158                         break;
2159                         case LA_4GHZ_LINK:
2160                                 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
2161                         break;
2162                         case LA_8GHZ_LINK:
2163                                 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
2164                         break;
2165                         default:
2166                                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
2167                         break;
2168                 }
2169         } else
2170                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
2171
2172         spin_unlock_irq(shost->host_lock);
2173 }
2174
2175 static void
2176 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
2177 {
2178         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2179         struct lpfc_hba   *phba = vport->phba;
2180         u64 node_name;
2181
2182         spin_lock_irq(shost->host_lock);
2183
2184         if ((vport->fc_flag & FC_FABRIC) ||
2185             ((phba->fc_topology == TOPOLOGY_LOOP) &&
2186              (vport->fc_flag & FC_PUBLIC_LOOP)))
2187                 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
2188         else
2189                 /* fabric is local port if there is no F/FL_Port */
2190                 node_name = 0;
2191
2192         spin_unlock_irq(shost->host_lock);
2193
2194         fc_host_fabric_name(shost) = node_name;
2195 }
2196
2197 static struct fc_host_statistics *
2198 lpfc_get_stats(struct Scsi_Host *shost)
2199 {
2200         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2201         struct lpfc_hba   *phba = vport->phba;
2202         struct lpfc_sli   *psli = &phba->sli;
2203         struct fc_host_statistics *hs = &phba->link_stats;
2204         struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
2205         LPFC_MBOXQ_t *pmboxq;
2206         MAILBOX_t *pmb;
2207         unsigned long seconds;
2208         int rc = 0;
2209
2210         /*
2211          * prevent udev from issuing mailbox commands until the port is
2212          * configured.
2213          */
2214         if (phba->link_state < LPFC_LINK_DOWN ||
2215             !phba->mbox_mem_pool ||
2216             (phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0)
2217                 return NULL;
2218
2219         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2220                 return NULL;
2221
2222         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2223         if (!pmboxq)
2224                 return NULL;
2225         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2226
2227         pmb = &pmboxq->mb;
2228         pmb->mbxCommand = MBX_READ_STATUS;
2229         pmb->mbxOwner = OWN_HOST;
2230         pmboxq->context1 = NULL;
2231         pmboxq->vport = vport;
2232
2233         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2234                 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2235                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2236         else
2237                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2238
2239         if (rc != MBX_SUCCESS) {
2240                 if (rc != MBX_TIMEOUT)
2241                         mempool_free(pmboxq, phba->mbox_mem_pool);
2242                 return NULL;
2243         }
2244
2245         memset(hs, 0, sizeof (struct fc_host_statistics));
2246
2247         hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
2248         hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256);
2249         hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
2250         hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256);
2251
2252         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2253         pmb->mbxCommand = MBX_READ_LNK_STAT;
2254         pmb->mbxOwner = OWN_HOST;
2255         pmboxq->context1 = NULL;
2256         pmboxq->vport = vport;
2257
2258         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2259             (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2260                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2261         else
2262                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2263
2264         if (rc != MBX_SUCCESS) {
2265                 if (rc != MBX_TIMEOUT)
2266                         mempool_free(pmboxq, phba->mbox_mem_pool);
2267                 return NULL;
2268         }
2269
2270         hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
2271         hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
2272         hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
2273         hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
2274         hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
2275         hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
2276         hs->error_frames = pmb->un.varRdLnk.crcCnt;
2277
2278         hs->link_failure_count -= lso->link_failure_count;
2279         hs->loss_of_sync_count -= lso->loss_of_sync_count;
2280         hs->loss_of_signal_count -= lso->loss_of_signal_count;
2281         hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
2282         hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
2283         hs->invalid_crc_count -= lso->invalid_crc_count;
2284         hs->error_frames -= lso->error_frames;
2285
2286         if (phba->fc_topology == TOPOLOGY_LOOP) {
2287                 hs->lip_count = (phba->fc_eventTag >> 1);
2288                 hs->lip_count -= lso->link_events;
2289                 hs->nos_count = -1;
2290         } else {
2291                 hs->lip_count = -1;
2292                 hs->nos_count = (phba->fc_eventTag >> 1);
2293                 hs->nos_count -= lso->link_events;
2294         }
2295
2296         hs->dumped_frames = -1;
2297
2298         seconds = get_seconds();
2299         if (seconds < psli->stats_start)
2300                 hs->seconds_since_last_reset = seconds +
2301                                 ((unsigned long)-1 - psli->stats_start);
2302         else
2303                 hs->seconds_since_last_reset = seconds - psli->stats_start;
2304
2305         mempool_free(pmboxq, phba->mbox_mem_pool);
2306
2307         return hs;
2308 }
2309
2310 static void
2311 lpfc_reset_stats(struct Scsi_Host *shost)
2312 {
2313         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2314         struct lpfc_hba   *phba = vport->phba;
2315         struct lpfc_sli   *psli = &phba->sli;
2316         struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
2317         LPFC_MBOXQ_t *pmboxq;
2318         MAILBOX_t *pmb;
2319         int rc = 0;
2320
2321         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2322                 return;
2323
2324         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2325         if (!pmboxq)
2326                 return;
2327         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
2328
2329         pmb = &pmboxq->mb;
2330         pmb->mbxCommand = MBX_READ_STATUS;
2331         pmb->mbxOwner = OWN_HOST;
2332         pmb->un.varWords[0] = 0x1; /* reset request */
2333         pmboxq->context1 = NULL;
2334         pmboxq->vport = vport;
2335
2336         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2337                 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2338                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2339         else
2340                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2341
2342         if (rc != MBX_SUCCESS) {
2343                 if (rc != MBX_TIMEOUT)
2344                         mempool_free(pmboxq, phba->mbox_mem_pool);
2345                 return;
2346         }
2347
2348         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
2349         pmb->mbxCommand = MBX_READ_LNK_STAT;
2350         pmb->mbxOwner = OWN_HOST;
2351         pmboxq->context1 = NULL;
2352         pmboxq->vport = vport;
2353
2354         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2355             (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2356                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2357         else
2358                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2359
2360         if (rc != MBX_SUCCESS) {
2361                 if (rc != MBX_TIMEOUT)
2362                         mempool_free( pmboxq, phba->mbox_mem_pool);
2363                 return;
2364         }
2365
2366         lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
2367         lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
2368         lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
2369         lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
2370         lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
2371         lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
2372         lso->error_frames = pmb->un.varRdLnk.crcCnt;
2373         lso->link_events = (phba->fc_eventTag >> 1);
2374
2375         psli->stats_start = get_seconds();
2376
2377         mempool_free(pmboxq, phba->mbox_mem_pool);
2378
2379         return;
2380 }
2381
2382 /*
2383  * The LPFC driver treats linkdown handling as target loss events so there
2384  * are no sysfs handlers for link_down_tmo.
2385  */
2386
2387 static struct lpfc_nodelist *
2388 lpfc_get_node_by_target(struct scsi_target *starget)
2389 {
2390         struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
2391         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2392         struct lpfc_nodelist *ndlp;
2393
2394         spin_lock_irq(shost->host_lock);
2395         /* Search for this, mapped, target ID */
2396         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2397                 if (NLP_CHK_NODE_ACT(ndlp) &&
2398                     ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
2399                     starget->id == ndlp->nlp_sid) {
2400                         spin_unlock_irq(shost->host_lock);
2401                         return ndlp;
2402                 }
2403         }
2404         spin_unlock_irq(shost->host_lock);
2405         return NULL;
2406 }
2407
2408 static void
2409 lpfc_get_starget_port_id(struct scsi_target *starget)
2410 {
2411         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2412
2413         fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
2414 }
2415
2416 static void
2417 lpfc_get_starget_node_name(struct scsi_target *starget)
2418 {
2419         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2420
2421         fc_starget_node_name(starget) =
2422                 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
2423 }
2424
2425 static void
2426 lpfc_get_starget_port_name(struct scsi_target *starget)
2427 {
2428         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2429
2430         fc_starget_port_name(starget) =
2431                 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
2432 }
2433
2434 static void
2435 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
2436 {
2437         if (timeout)
2438                 rport->dev_loss_tmo = timeout;
2439         else
2440                 rport->dev_loss_tmo = 1;
2441 }
2442
2443
2444 #define lpfc_rport_show_function(field, format_string, sz, cast)        \
2445 static ssize_t                                                          \
2446 lpfc_show_rport_##field (struct class_device *cdev, char *buf)          \
2447 {                                                                       \
2448         struct fc_rport *rport = transport_class_to_rport(cdev);        \
2449         struct lpfc_rport_data *rdata = rport->hostdata;                \
2450         return snprintf(buf, sz, format_string,                         \
2451                 (rdata->target) ? cast rdata->target->field : 0);       \
2452 }
2453
2454 #define lpfc_rport_rd_attr(field, format_string, sz)                    \
2455         lpfc_rport_show_function(field, format_string, sz, )            \
2456 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
2457
2458
2459 struct fc_function_template lpfc_transport_functions = {
2460         /* fixed attributes the driver supports */
2461         .show_host_node_name = 1,
2462         .show_host_port_name = 1,
2463         .show_host_supported_classes = 1,
2464         .show_host_supported_fc4s = 1,
2465         .show_host_supported_speeds = 1,
2466         .show_host_maxframe_size = 1,
2467
2468         /* dynamic attributes the driver supports */
2469         .get_host_port_id = lpfc_get_host_port_id,
2470         .show_host_port_id = 1,
2471
2472         .get_host_port_type = lpfc_get_host_port_type,
2473         .show_host_port_type = 1,
2474
2475         .get_host_port_state = lpfc_get_host_port_state,
2476         .show_host_port_state = 1,
2477
2478         /* active_fc4s is shown but doesn't change (thus no get function) */
2479         .show_host_active_fc4s = 1,
2480
2481         .get_host_speed = lpfc_get_host_speed,
2482         .show_host_speed = 1,
2483
2484         .get_host_fabric_name = lpfc_get_host_fabric_name,
2485         .show_host_fabric_name = 1,
2486
2487         /*
2488          * The LPFC driver treats linkdown handling as target loss events
2489          * so there are no sysfs handlers for link_down_tmo.
2490          */
2491
2492         .get_fc_host_stats = lpfc_get_stats,
2493         .reset_fc_host_stats = lpfc_reset_stats,
2494
2495         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
2496         .show_rport_maxframe_size = 1,
2497         .show_rport_supported_classes = 1,
2498
2499         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
2500         .show_rport_dev_loss_tmo = 1,
2501
2502         .get_starget_port_id  = lpfc_get_starget_port_id,
2503         .show_starget_port_id = 1,
2504
2505         .get_starget_node_name = lpfc_get_starget_node_name,
2506         .show_starget_node_name = 1,
2507
2508         .get_starget_port_name = lpfc_get_starget_port_name,
2509         .show_starget_port_name = 1,
2510
2511         .issue_fc_host_lip = lpfc_issue_lip,
2512         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
2513         .terminate_rport_io = lpfc_terminate_rport_io,
2514
2515         .dd_fcvport_size = sizeof(struct lpfc_vport *),
2516 };
2517
2518 struct fc_function_template lpfc_vport_transport_functions = {
2519         /* fixed attributes the driver supports */
2520         .show_host_node_name = 1,
2521         .show_host_port_name = 1,
2522         .show_host_supported_classes = 1,
2523         .show_host_supported_fc4s = 1,
2524         .show_host_supported_speeds = 1,
2525         .show_host_maxframe_size = 1,
2526
2527         /* dynamic attributes the driver supports */
2528         .get_host_port_id = lpfc_get_host_port_id,
2529         .show_host_port_id = 1,
2530
2531         .get_host_port_type = lpfc_get_host_port_type,
2532         .show_host_port_type = 1,
2533
2534         .get_host_port_state = lpfc_get_host_port_state,
2535         .show_host_port_state = 1,
2536
2537         /* active_fc4s is shown but doesn't change (thus no get function) */
2538         .show_host_active_fc4s = 1,
2539
2540         .get_host_speed = lpfc_get_host_speed,
2541         .show_host_speed = 1,
2542
2543         .get_host_fabric_name = lpfc_get_host_fabric_name,
2544         .show_host_fabric_name = 1,
2545
2546         /*
2547          * The LPFC driver treats linkdown handling as target loss events
2548          * so there are no sysfs handlers for link_down_tmo.
2549          */
2550
2551         .get_fc_host_stats = lpfc_get_stats,
2552         .reset_fc_host_stats = lpfc_reset_stats,
2553
2554         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
2555         .show_rport_maxframe_size = 1,
2556         .show_rport_supported_classes = 1,
2557
2558         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
2559         .show_rport_dev_loss_tmo = 1,
2560
2561         .get_starget_port_id  = lpfc_get_starget_port_id,
2562         .show_starget_port_id = 1,
2563
2564         .get_starget_node_name = lpfc_get_starget_node_name,
2565         .show_starget_node_name = 1,
2566
2567         .get_starget_port_name = lpfc_get_starget_port_name,
2568         .show_starget_port_name = 1,
2569
2570         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
2571         .terminate_rport_io = lpfc_terminate_rport_io,
2572
2573         .vport_disable = lpfc_vport_disable,
2574 };
2575
2576 void
2577 lpfc_get_cfgparam(struct lpfc_hba *phba)
2578 {
2579         lpfc_cr_delay_init(phba, lpfc_cr_delay);
2580         lpfc_cr_count_init(phba, lpfc_cr_count);
2581         lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
2582         lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
2583         lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
2584         lpfc_ack0_init(phba, lpfc_ack0);
2585         lpfc_topology_init(phba, lpfc_topology);
2586         lpfc_link_speed_init(phba, lpfc_link_speed);
2587         lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
2588         lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
2589         lpfc_use_msi_init(phba, lpfc_use_msi);
2590         lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
2591         lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
2592         phba->cfg_poll = lpfc_poll;
2593         phba->cfg_soft_wwnn = 0L;
2594         phba->cfg_soft_wwpn = 0L;
2595         lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
2596         /* Also reinitialize the host templates with new values. */
2597         lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2598         lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2599         /*
2600          * Since the sg_tablesize is module parameter, the sg_dma_buf_size
2601          * used to create the sg_dma_buf_pool must be dynamically calculated.
2602          * 2 segments are added since the IOCB needs a command and response bde.
2603          */
2604         phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
2605                         sizeof(struct fcp_rsp) +
2606                         ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
2607         lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
2608         return;
2609 }
2610
2611 void
2612 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
2613 {
2614         lpfc_log_verbose_init(vport, lpfc_log_verbose);
2615         lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
2616         lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
2617         lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
2618         lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
2619         lpfc_restrict_login_init(vport, lpfc_restrict_login);
2620         lpfc_fcp_class_init(vport, lpfc_fcp_class);
2621         lpfc_use_adisc_init(vport, lpfc_use_adisc);
2622         lpfc_fdmi_on_init(vport, lpfc_fdmi_on);
2623         lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
2624         lpfc_max_luns_init(vport, lpfc_max_luns);
2625         lpfc_scan_down_init(vport, lpfc_scan_down);
2626         lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
2627         return;
2628 }