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 (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 # Value range is [0,1]. Default value is 0.
1596 */
1597 LPFC_ATTR_R(use_msi, 0, 0, 1, "Use Message Signaled Interrupts, if possible");
1598
1599 /*
1600 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
1601 #       0  = HBA resets disabled
1602 #       1  = HBA resets enabled (default)
1603 # Value range is [0,1]. Default value is 1.
1604 */
1605 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
1606
1607 /*
1608 # lpfc_enable_hba_heartbeat: Enable HBA heartbeat timer..
1609 #       0  = HBA Heartbeat disabled
1610 #       1  = HBA Heartbeat enabled (default)
1611 # Value range is [0,1]. Default value is 1.
1612 */
1613 LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat.");
1614
1615 /*
1616  * lpfc_sg_seg_cnt: Initial Maximum DMA Segment Count
1617  * This value can be set to values between 64 and 256. The default value is
1618  * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
1619  * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
1620  */
1621 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
1622             LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
1623
1624 struct class_device_attribute *lpfc_hba_attrs[] = {
1625         &class_device_attr_info,
1626         &class_device_attr_serialnum,
1627         &class_device_attr_modeldesc,
1628         &class_device_attr_modelname,
1629         &class_device_attr_programtype,
1630         &class_device_attr_portnum,
1631         &class_device_attr_fwrev,
1632         &class_device_attr_hdw,
1633         &class_device_attr_option_rom_version,
1634         &class_device_attr_state,
1635         &class_device_attr_num_discovered_ports,
1636         &class_device_attr_lpfc_drvr_version,
1637         &class_device_attr_lpfc_temp_sensor,
1638         &class_device_attr_lpfc_log_verbose,
1639         &class_device_attr_lpfc_lun_queue_depth,
1640         &class_device_attr_lpfc_hba_queue_depth,
1641         &class_device_attr_lpfc_peer_port_login,
1642         &class_device_attr_lpfc_nodev_tmo,
1643         &class_device_attr_lpfc_devloss_tmo,
1644         &class_device_attr_lpfc_fcp_class,
1645         &class_device_attr_lpfc_use_adisc,
1646         &class_device_attr_lpfc_ack0,
1647         &class_device_attr_lpfc_topology,
1648         &class_device_attr_lpfc_scan_down,
1649         &class_device_attr_lpfc_link_speed,
1650         &class_device_attr_lpfc_cr_delay,
1651         &class_device_attr_lpfc_cr_count,
1652         &class_device_attr_lpfc_multi_ring_support,
1653         &class_device_attr_lpfc_multi_ring_rctl,
1654         &class_device_attr_lpfc_multi_ring_type,
1655         &class_device_attr_lpfc_fdmi_on,
1656         &class_device_attr_lpfc_max_luns,
1657         &class_device_attr_lpfc_enable_npiv,
1658         &class_device_attr_nport_evt_cnt,
1659         &class_device_attr_board_mode,
1660         &class_device_attr_max_vpi,
1661         &class_device_attr_used_vpi,
1662         &class_device_attr_max_rpi,
1663         &class_device_attr_used_rpi,
1664         &class_device_attr_max_xri,
1665         &class_device_attr_used_xri,
1666         &class_device_attr_npiv_info,
1667         &class_device_attr_issue_reset,
1668         &class_device_attr_lpfc_poll,
1669         &class_device_attr_lpfc_poll_tmo,
1670         &class_device_attr_lpfc_use_msi,
1671         &class_device_attr_lpfc_soft_wwnn,
1672         &class_device_attr_lpfc_soft_wwpn,
1673         &class_device_attr_lpfc_soft_wwn_enable,
1674         &class_device_attr_lpfc_enable_hba_reset,
1675         &class_device_attr_lpfc_enable_hba_heartbeat,
1676         &class_device_attr_lpfc_sg_seg_cnt,
1677         NULL,
1678 };
1679
1680 struct class_device_attribute *lpfc_vport_attrs[] = {
1681         &class_device_attr_info,
1682         &class_device_attr_state,
1683         &class_device_attr_num_discovered_ports,
1684         &class_device_attr_lpfc_drvr_version,
1685
1686         &class_device_attr_lpfc_log_verbose,
1687         &class_device_attr_lpfc_lun_queue_depth,
1688         &class_device_attr_lpfc_nodev_tmo,
1689         &class_device_attr_lpfc_devloss_tmo,
1690         &class_device_attr_lpfc_hba_queue_depth,
1691         &class_device_attr_lpfc_peer_port_login,
1692         &class_device_attr_lpfc_restrict_login,
1693         &class_device_attr_lpfc_fcp_class,
1694         &class_device_attr_lpfc_use_adisc,
1695         &class_device_attr_lpfc_fdmi_on,
1696         &class_device_attr_lpfc_max_luns,
1697         &class_device_attr_nport_evt_cnt,
1698         &class_device_attr_npiv_info,
1699         &class_device_attr_lpfc_enable_da_id,
1700         NULL,
1701 };
1702
1703 static ssize_t
1704 sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
1705                    char *buf, loff_t off, size_t count)
1706 {
1707         size_t buf_off;
1708         struct class_device *cdev = container_of(kobj, struct class_device,
1709                                                  kobj);
1710         struct Scsi_Host  *shost = class_to_shost(cdev);
1711         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1712         struct lpfc_hba   *phba = vport->phba;
1713
1714         if ((off + count) > FF_REG_AREA_SIZE)
1715                 return -ERANGE;
1716
1717         if (count == 0) return 0;
1718
1719         if (off % 4 || count % 4 || (unsigned long)buf % 4)
1720                 return -EINVAL;
1721
1722         if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
1723                 return -EPERM;
1724         }
1725
1726         spin_lock_irq(&phba->hbalock);
1727         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t))
1728                 writel(*((uint32_t *)(buf + buf_off)),
1729                        phba->ctrl_regs_memmap_p + off + buf_off);
1730
1731         spin_unlock_irq(&phba->hbalock);
1732
1733         return count;
1734 }
1735
1736 static ssize_t
1737 sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr,
1738                   char *buf, loff_t off, size_t count)
1739 {
1740         size_t buf_off;
1741         uint32_t * tmp_ptr;
1742         struct class_device *cdev = container_of(kobj, struct class_device,
1743                                                  kobj);
1744         struct Scsi_Host  *shost = class_to_shost(cdev);
1745         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1746         struct lpfc_hba   *phba = vport->phba;
1747
1748         if (off > FF_REG_AREA_SIZE)
1749                 return -ERANGE;
1750
1751         if ((off + count) > FF_REG_AREA_SIZE)
1752                 count = FF_REG_AREA_SIZE - off;
1753
1754         if (count == 0) return 0;
1755
1756         if (off % 4 || count % 4 || (unsigned long)buf % 4)
1757                 return -EINVAL;
1758
1759         spin_lock_irq(&phba->hbalock);
1760
1761         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
1762                 tmp_ptr = (uint32_t *)(buf + buf_off);
1763                 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
1764         }
1765
1766         spin_unlock_irq(&phba->hbalock);
1767
1768         return count;
1769 }
1770
1771 static struct bin_attribute sysfs_ctlreg_attr = {
1772         .attr = {
1773                 .name = "ctlreg",
1774                 .mode = S_IRUSR | S_IWUSR,
1775         },
1776         .size = 256,
1777         .read = sysfs_ctlreg_read,
1778         .write = sysfs_ctlreg_write,
1779 };
1780
1781
1782 static void
1783 sysfs_mbox_idle(struct lpfc_hba *phba)
1784 {
1785         phba->sysfs_mbox.state = SMBOX_IDLE;
1786         phba->sysfs_mbox.offset = 0;
1787
1788         if (phba->sysfs_mbox.mbox) {
1789                 mempool_free(phba->sysfs_mbox.mbox,
1790                              phba->mbox_mem_pool);
1791                 phba->sysfs_mbox.mbox = NULL;
1792         }
1793 }
1794
1795 static ssize_t
1796 sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
1797                  char *buf, loff_t off, size_t count)
1798 {
1799         struct class_device *cdev = container_of(kobj, struct class_device,
1800                                                  kobj);
1801         struct Scsi_Host  *shost = class_to_shost(cdev);
1802         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1803         struct lpfc_hba   *phba = vport->phba;
1804         struct lpfcMboxq  *mbox = NULL;
1805
1806         if ((count + off) > MAILBOX_CMD_SIZE)
1807                 return -ERANGE;
1808
1809         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
1810                 return -EINVAL;
1811
1812         if (count == 0)
1813                 return 0;
1814
1815         if (off == 0) {
1816                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1817                 if (!mbox)
1818                         return -ENOMEM;
1819                 memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
1820         }
1821
1822         spin_lock_irq(&phba->hbalock);
1823
1824         if (off == 0) {
1825                 if (phba->sysfs_mbox.mbox)
1826                         mempool_free(mbox, phba->mbox_mem_pool);
1827                 else
1828                         phba->sysfs_mbox.mbox = mbox;
1829                 phba->sysfs_mbox.state = SMBOX_WRITING;
1830         } else {
1831                 if (phba->sysfs_mbox.state  != SMBOX_WRITING ||
1832                     phba->sysfs_mbox.offset != off           ||
1833                     phba->sysfs_mbox.mbox   == NULL) {
1834                         sysfs_mbox_idle(phba);
1835                         spin_unlock_irq(&phba->hbalock);
1836                         return -EAGAIN;
1837                 }
1838         }
1839
1840         memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off,
1841                buf, count);
1842
1843         phba->sysfs_mbox.offset = off + count;
1844
1845         spin_unlock_irq(&phba->hbalock);
1846
1847         return count;
1848 }
1849
1850 static ssize_t
1851 sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr,
1852                 char *buf, loff_t off, size_t count)
1853 {
1854         struct class_device *cdev = container_of(kobj, struct class_device,
1855                                                  kobj);
1856         struct Scsi_Host  *shost = class_to_shost(cdev);
1857         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1858         struct lpfc_hba   *phba = vport->phba;
1859         int rc;
1860
1861         if (off > MAILBOX_CMD_SIZE)
1862                 return -ERANGE;
1863
1864         if ((count + off) > MAILBOX_CMD_SIZE)
1865                 count = MAILBOX_CMD_SIZE - off;
1866
1867         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
1868                 return -EINVAL;
1869
1870         if (off && count == 0)
1871                 return 0;
1872
1873         spin_lock_irq(&phba->hbalock);
1874
1875         if (phba->over_temp_state == HBA_OVER_TEMP) {
1876                 sysfs_mbox_idle(phba);
1877                 spin_unlock_irq(&phba->hbalock);
1878                 return  -EACCES;
1879         }
1880
1881         if (off == 0 &&
1882             phba->sysfs_mbox.state  == SMBOX_WRITING &&
1883             phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
1884
1885                 switch (phba->sysfs_mbox.mbox->mb.mbxCommand) {
1886                         /* Offline only */
1887                 case MBX_INIT_LINK:
1888                 case MBX_DOWN_LINK:
1889                 case MBX_CONFIG_LINK:
1890                 case MBX_CONFIG_RING:
1891                 case MBX_RESET_RING:
1892                 case MBX_UNREG_LOGIN:
1893                 case MBX_CLEAR_LA:
1894                 case MBX_DUMP_CONTEXT:
1895                 case MBX_RUN_DIAGS:
1896                 case MBX_RESTART:
1897                 case MBX_SET_MASK:
1898                 case MBX_SET_DEBUG:
1899                         if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
1900                                 printk(KERN_WARNING "mbox_read:Command 0x%x "
1901                                        "is illegal in on-line state\n",
1902                                        phba->sysfs_mbox.mbox->mb.mbxCommand);
1903                                 sysfs_mbox_idle(phba);
1904                                 spin_unlock_irq(&phba->hbalock);
1905                                 return -EPERM;
1906                         }
1907                 case MBX_WRITE_NV:
1908                 case MBX_WRITE_VPARMS:
1909                 case MBX_LOAD_SM:
1910                 case MBX_READ_NV:
1911                 case MBX_READ_CONFIG:
1912                 case MBX_READ_RCONFIG:
1913                 case MBX_READ_STATUS:
1914                 case MBX_READ_XRI:
1915                 case MBX_READ_REV:
1916                 case MBX_READ_LNK_STAT:
1917                 case MBX_DUMP_MEMORY:
1918                 case MBX_DOWN_LOAD:
1919                 case MBX_UPDATE_CFG:
1920                 case MBX_KILL_BOARD:
1921                 case MBX_LOAD_AREA:
1922                 case MBX_LOAD_EXP_ROM:
1923                 case MBX_BEACON:
1924                 case MBX_DEL_LD_ENTRY:
1925                 case MBX_SET_VARIABLE:
1926                 case MBX_WRITE_WWN:
1927                         break;
1928                 case MBX_READ_SPARM64:
1929                 case MBX_READ_LA:
1930                 case MBX_READ_LA64:
1931                 case MBX_REG_LOGIN:
1932                 case MBX_REG_LOGIN64:
1933                 case MBX_CONFIG_PORT:
1934                 case MBX_RUN_BIU_DIAG:
1935                         printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
1936                                phba->sysfs_mbox.mbox->mb.mbxCommand);
1937                         sysfs_mbox_idle(phba);
1938                         spin_unlock_irq(&phba->hbalock);
1939                         return -EPERM;
1940                 default:
1941                         printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
1942                                phba->sysfs_mbox.mbox->mb.mbxCommand);
1943                         sysfs_mbox_idle(phba);
1944                         spin_unlock_irq(&phba->hbalock);
1945                         return -EPERM;
1946                 }
1947
1948                 /* If HBA encountered an error attention, allow only DUMP
1949                  * mailbox command until the HBA is restarted.
1950                  */
1951                 if ((phba->pport->stopped) &&
1952                         (phba->sysfs_mbox.mbox->mb.mbxCommand
1953                                 != MBX_DUMP_MEMORY)) {
1954                         sysfs_mbox_idle(phba);
1955                         spin_unlock_irq(&phba->hbalock);
1956                         return -EPERM;
1957                 }
1958
1959                 phba->sysfs_mbox.mbox->vport = vport;
1960
1961                 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
1962                         sysfs_mbox_idle(phba);
1963                         spin_unlock_irq(&phba->hbalock);
1964                         return  -EAGAIN;
1965                 }
1966
1967                 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
1968                     (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){
1969
1970                         spin_unlock_irq(&phba->hbalock);
1971                         rc = lpfc_sli_issue_mbox (phba,
1972                                                   phba->sysfs_mbox.mbox,
1973                                                   MBX_POLL);
1974                         spin_lock_irq(&phba->hbalock);
1975
1976                 } else {
1977                         spin_unlock_irq(&phba->hbalock);
1978                         rc = lpfc_sli_issue_mbox_wait (phba,
1979                                                        phba->sysfs_mbox.mbox,
1980                                 lpfc_mbox_tmo_val(phba,
1981                                     phba->sysfs_mbox.mbox->mb.mbxCommand) * HZ);
1982                         spin_lock_irq(&phba->hbalock);
1983                 }
1984
1985                 if (rc != MBX_SUCCESS) {
1986                         if (rc == MBX_TIMEOUT) {
1987                                 phba->sysfs_mbox.mbox = NULL;
1988                         }
1989                         sysfs_mbox_idle(phba);
1990                         spin_unlock_irq(&phba->hbalock);
1991                         return  (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
1992                 }
1993                 phba->sysfs_mbox.state = SMBOX_READING;
1994         }
1995         else if (phba->sysfs_mbox.offset != off ||
1996                  phba->sysfs_mbox.state  != SMBOX_READING) {
1997                 printk(KERN_WARNING  "mbox_read: Bad State\n");
1998                 sysfs_mbox_idle(phba);
1999                 spin_unlock_irq(&phba->hbalock);
2000                 return -EAGAIN;
2001         }
2002
2003         memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count);
2004
2005         phba->sysfs_mbox.offset = off + count;
2006
2007         if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
2008                 sysfs_mbox_idle(phba);
2009
2010         spin_unlock_irq(&phba->hbalock);
2011
2012         return count;
2013 }
2014
2015 static struct bin_attribute sysfs_mbox_attr = {
2016         .attr = {
2017                 .name = "mbox",
2018                 .mode = S_IRUSR | S_IWUSR,
2019         },
2020         .size = MAILBOX_CMD_SIZE,
2021         .read = sysfs_mbox_read,
2022         .write = sysfs_mbox_write,
2023 };
2024
2025 int
2026 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
2027 {
2028         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2029         int error;
2030
2031         error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
2032                                       &sysfs_ctlreg_attr);
2033         if (error)
2034                 goto out;
2035
2036         error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
2037                                       &sysfs_mbox_attr);
2038         if (error)
2039                 goto out_remove_ctlreg_attr;
2040
2041         return 0;
2042 out_remove_ctlreg_attr:
2043         sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
2044 out:
2045         return error;
2046 }
2047
2048 void
2049 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
2050 {
2051         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2052
2053         sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_mbox_attr);
2054         sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
2055 }
2056
2057
2058 /*
2059  * Dynamic FC Host Attributes Support
2060  */
2061
2062 static void
2063 lpfc_get_host_port_id(struct Scsi_Host *shost)
2064 {
2065         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2066
2067         /* note: fc_myDID already in cpu endianness */
2068         fc_host_port_id(shost) = vport->fc_myDID;
2069 }
2070
2071 static void
2072 lpfc_get_host_port_type(struct Scsi_Host *shost)
2073 {
2074         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2075         struct lpfc_hba   *phba = vport->phba;
2076
2077         spin_lock_irq(shost->host_lock);
2078
2079         if (vport->port_type == LPFC_NPIV_PORT) {
2080                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
2081         } else if (lpfc_is_link_up(phba)) {
2082                 if (phba->fc_topology == TOPOLOGY_LOOP) {
2083                         if (vport->fc_flag & FC_PUBLIC_LOOP)
2084                                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
2085                         else
2086                                 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
2087                 } else {
2088                         if (vport->fc_flag & FC_FABRIC)
2089                                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
2090                         else
2091                                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
2092                 }
2093         } else
2094                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
2095
2096         spin_unlock_irq(shost->host_lock);
2097 }
2098
2099 static void
2100 lpfc_get_host_port_state(struct Scsi_Host *shost)
2101 {
2102         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2103         struct lpfc_hba   *phba = vport->phba;
2104
2105         spin_lock_irq(shost->host_lock);
2106
2107         if (vport->fc_flag & FC_OFFLINE_MODE)
2108                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
2109         else {
2110                 switch (phba->link_state) {
2111                 case LPFC_LINK_UNKNOWN:
2112                 case LPFC_LINK_DOWN:
2113                         fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
2114                         break;
2115                 case LPFC_LINK_UP:
2116                 case LPFC_CLEAR_LA:
2117                 case LPFC_HBA_READY:
2118                         /* Links up, beyond this port_type reports state */
2119                         fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
2120                         break;
2121                 case LPFC_HBA_ERROR:
2122                         fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
2123                         break;
2124                 default:
2125                         fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
2126                         break;
2127                 }
2128         }
2129
2130         spin_unlock_irq(shost->host_lock);
2131 }
2132
2133 static void
2134 lpfc_get_host_speed(struct Scsi_Host *shost)
2135 {
2136         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2137         struct lpfc_hba   *phba = vport->phba;
2138
2139         spin_lock_irq(shost->host_lock);
2140
2141         if (lpfc_is_link_up(phba)) {
2142                 switch(phba->fc_linkspeed) {
2143                         case LA_1GHZ_LINK:
2144                                 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
2145                         break;
2146                         case LA_2GHZ_LINK:
2147                                 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
2148                         break;
2149                         case LA_4GHZ_LINK:
2150                                 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
2151                         break;
2152                         case LA_8GHZ_LINK:
2153                                 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
2154                         break;
2155                         default:
2156                                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
2157                         break;
2158                 }
2159         } else
2160                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
2161
2162         spin_unlock_irq(shost->host_lock);
2163 }
2164
2165 static void
2166 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
2167 {
2168         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2169         struct lpfc_hba   *phba = vport->phba;
2170         u64 node_name;
2171
2172         spin_lock_irq(shost->host_lock);
2173
2174         if ((vport->fc_flag & FC_FABRIC) ||
2175             ((phba->fc_topology == TOPOLOGY_LOOP) &&
2176              (vport->fc_flag & FC_PUBLIC_LOOP)))
2177                 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
2178         else
2179                 /* fabric is local port if there is no F/FL_Port */
2180                 node_name = 0;
2181
2182         spin_unlock_irq(shost->host_lock);
2183
2184         fc_host_fabric_name(shost) = node_name;
2185 }
2186
2187 static struct fc_host_statistics *
2188 lpfc_get_stats(struct Scsi_Host *shost)
2189 {
2190         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2191         struct lpfc_hba   *phba = vport->phba;
2192         struct lpfc_sli   *psli = &phba->sli;
2193         struct fc_host_statistics *hs = &phba->link_stats;
2194         struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
2195         LPFC_MBOXQ_t *pmboxq;
2196         MAILBOX_t *pmb;
2197         unsigned long seconds;
2198         int rc = 0;
2199
2200         /*
2201          * prevent udev from issuing mailbox commands until the port is
2202          * configured.
2203          */
2204         if (phba->link_state < LPFC_LINK_DOWN ||
2205             !phba->mbox_mem_pool ||
2206             (phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0)
2207                 return NULL;
2208
2209         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2210                 return NULL;
2211
2212         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2213         if (!pmboxq)
2214                 return NULL;
2215         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2216
2217         pmb = &pmboxq->mb;
2218         pmb->mbxCommand = MBX_READ_STATUS;
2219         pmb->mbxOwner = OWN_HOST;
2220         pmboxq->context1 = NULL;
2221         pmboxq->vport = vport;
2222
2223         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2224                 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2225                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2226         else
2227                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2228
2229         if (rc != MBX_SUCCESS) {
2230                 if (rc != MBX_TIMEOUT)
2231                         mempool_free(pmboxq, phba->mbox_mem_pool);
2232                 return NULL;
2233         }
2234
2235         memset(hs, 0, sizeof (struct fc_host_statistics));
2236
2237         hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
2238         hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256);
2239         hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
2240         hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256);
2241
2242         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2243         pmb->mbxCommand = MBX_READ_LNK_STAT;
2244         pmb->mbxOwner = OWN_HOST;
2245         pmboxq->context1 = NULL;
2246         pmboxq->vport = vport;
2247
2248         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2249             (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2250                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2251         else
2252                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2253
2254         if (rc != MBX_SUCCESS) {
2255                 if (rc != MBX_TIMEOUT)
2256                         mempool_free(pmboxq, phba->mbox_mem_pool);
2257                 return NULL;
2258         }
2259
2260         hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
2261         hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
2262         hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
2263         hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
2264         hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
2265         hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
2266         hs->error_frames = pmb->un.varRdLnk.crcCnt;
2267
2268         hs->link_failure_count -= lso->link_failure_count;
2269         hs->loss_of_sync_count -= lso->loss_of_sync_count;
2270         hs->loss_of_signal_count -= lso->loss_of_signal_count;
2271         hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
2272         hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
2273         hs->invalid_crc_count -= lso->invalid_crc_count;
2274         hs->error_frames -= lso->error_frames;
2275
2276         if (phba->fc_topology == TOPOLOGY_LOOP) {
2277                 hs->lip_count = (phba->fc_eventTag >> 1);
2278                 hs->lip_count -= lso->link_events;
2279                 hs->nos_count = -1;
2280         } else {
2281                 hs->lip_count = -1;
2282                 hs->nos_count = (phba->fc_eventTag >> 1);
2283                 hs->nos_count -= lso->link_events;
2284         }
2285
2286         hs->dumped_frames = -1;
2287
2288         seconds = get_seconds();
2289         if (seconds < psli->stats_start)
2290                 hs->seconds_since_last_reset = seconds +
2291                                 ((unsigned long)-1 - psli->stats_start);
2292         else
2293                 hs->seconds_since_last_reset = seconds - psli->stats_start;
2294
2295         mempool_free(pmboxq, phba->mbox_mem_pool);
2296
2297         return hs;
2298 }
2299
2300 static void
2301 lpfc_reset_stats(struct Scsi_Host *shost)
2302 {
2303         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2304         struct lpfc_hba   *phba = vport->phba;
2305         struct lpfc_sli   *psli = &phba->sli;
2306         struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
2307         LPFC_MBOXQ_t *pmboxq;
2308         MAILBOX_t *pmb;
2309         int rc = 0;
2310
2311         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2312                 return;
2313
2314         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2315         if (!pmboxq)
2316                 return;
2317         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
2318
2319         pmb = &pmboxq->mb;
2320         pmb->mbxCommand = MBX_READ_STATUS;
2321         pmb->mbxOwner = OWN_HOST;
2322         pmb->un.varWords[0] = 0x1; /* reset request */
2323         pmboxq->context1 = NULL;
2324         pmboxq->vport = vport;
2325
2326         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2327                 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2328                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2329         else
2330                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2331
2332         if (rc != MBX_SUCCESS) {
2333                 if (rc != MBX_TIMEOUT)
2334                         mempool_free(pmboxq, phba->mbox_mem_pool);
2335                 return;
2336         }
2337
2338         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
2339         pmb->mbxCommand = MBX_READ_LNK_STAT;
2340         pmb->mbxOwner = OWN_HOST;
2341         pmboxq->context1 = NULL;
2342         pmboxq->vport = vport;
2343
2344         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2345             (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2346                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2347         else
2348                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2349
2350         if (rc != MBX_SUCCESS) {
2351                 if (rc != MBX_TIMEOUT)
2352                         mempool_free( pmboxq, phba->mbox_mem_pool);
2353                 return;
2354         }
2355
2356         lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
2357         lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
2358         lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
2359         lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
2360         lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
2361         lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
2362         lso->error_frames = pmb->un.varRdLnk.crcCnt;
2363         lso->link_events = (phba->fc_eventTag >> 1);
2364
2365         psli->stats_start = get_seconds();
2366
2367         mempool_free(pmboxq, phba->mbox_mem_pool);
2368
2369         return;
2370 }
2371
2372 /*
2373  * The LPFC driver treats linkdown handling as target loss events so there
2374  * are no sysfs handlers for link_down_tmo.
2375  */
2376
2377 static struct lpfc_nodelist *
2378 lpfc_get_node_by_target(struct scsi_target *starget)
2379 {
2380         struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
2381         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2382         struct lpfc_nodelist *ndlp;
2383
2384         spin_lock_irq(shost->host_lock);
2385         /* Search for this, mapped, target ID */
2386         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2387                 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
2388                     starget->id == ndlp->nlp_sid) {
2389                         spin_unlock_irq(shost->host_lock);
2390                         return ndlp;
2391                 }
2392         }
2393         spin_unlock_irq(shost->host_lock);
2394         return NULL;
2395 }
2396
2397 static void
2398 lpfc_get_starget_port_id(struct scsi_target *starget)
2399 {
2400         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2401
2402         fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
2403 }
2404
2405 static void
2406 lpfc_get_starget_node_name(struct scsi_target *starget)
2407 {
2408         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2409
2410         fc_starget_node_name(starget) =
2411                 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
2412 }
2413
2414 static void
2415 lpfc_get_starget_port_name(struct scsi_target *starget)
2416 {
2417         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2418
2419         fc_starget_port_name(starget) =
2420                 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
2421 }
2422
2423 static void
2424 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
2425 {
2426         if (timeout)
2427                 rport->dev_loss_tmo = timeout;
2428         else
2429                 rport->dev_loss_tmo = 1;
2430 }
2431
2432
2433 #define lpfc_rport_show_function(field, format_string, sz, cast)        \
2434 static ssize_t                                                          \
2435 lpfc_show_rport_##field (struct class_device *cdev, char *buf)          \
2436 {                                                                       \
2437         struct fc_rport *rport = transport_class_to_rport(cdev);        \
2438         struct lpfc_rport_data *rdata = rport->hostdata;                \
2439         return snprintf(buf, sz, format_string,                         \
2440                 (rdata->target) ? cast rdata->target->field : 0);       \
2441 }
2442
2443 #define lpfc_rport_rd_attr(field, format_string, sz)                    \
2444         lpfc_rport_show_function(field, format_string, sz, )            \
2445 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
2446
2447
2448 struct fc_function_template lpfc_transport_functions = {
2449         /* fixed attributes the driver supports */
2450         .show_host_node_name = 1,
2451         .show_host_port_name = 1,
2452         .show_host_supported_classes = 1,
2453         .show_host_supported_fc4s = 1,
2454         .show_host_supported_speeds = 1,
2455         .show_host_maxframe_size = 1,
2456
2457         /* dynamic attributes the driver supports */
2458         .get_host_port_id = lpfc_get_host_port_id,
2459         .show_host_port_id = 1,
2460
2461         .get_host_port_type = lpfc_get_host_port_type,
2462         .show_host_port_type = 1,
2463
2464         .get_host_port_state = lpfc_get_host_port_state,
2465         .show_host_port_state = 1,
2466
2467         /* active_fc4s is shown but doesn't change (thus no get function) */
2468         .show_host_active_fc4s = 1,
2469
2470         .get_host_speed = lpfc_get_host_speed,
2471         .show_host_speed = 1,
2472
2473         .get_host_fabric_name = lpfc_get_host_fabric_name,
2474         .show_host_fabric_name = 1,
2475
2476         /*
2477          * The LPFC driver treats linkdown handling as target loss events
2478          * so there are no sysfs handlers for link_down_tmo.
2479          */
2480
2481         .get_fc_host_stats = lpfc_get_stats,
2482         .reset_fc_host_stats = lpfc_reset_stats,
2483
2484         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
2485         .show_rport_maxframe_size = 1,
2486         .show_rport_supported_classes = 1,
2487
2488         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
2489         .show_rport_dev_loss_tmo = 1,
2490
2491         .get_starget_port_id  = lpfc_get_starget_port_id,
2492         .show_starget_port_id = 1,
2493
2494         .get_starget_node_name = lpfc_get_starget_node_name,
2495         .show_starget_node_name = 1,
2496
2497         .get_starget_port_name = lpfc_get_starget_port_name,
2498         .show_starget_port_name = 1,
2499
2500         .issue_fc_host_lip = lpfc_issue_lip,
2501         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
2502         .terminate_rport_io = lpfc_terminate_rport_io,
2503
2504         .dd_fcvport_size = sizeof(struct lpfc_vport *),
2505 };
2506
2507 struct fc_function_template lpfc_vport_transport_functions = {
2508         /* fixed attributes the driver supports */
2509         .show_host_node_name = 1,
2510         .show_host_port_name = 1,
2511         .show_host_supported_classes = 1,
2512         .show_host_supported_fc4s = 1,
2513         .show_host_supported_speeds = 1,
2514         .show_host_maxframe_size = 1,
2515
2516         /* dynamic attributes the driver supports */
2517         .get_host_port_id = lpfc_get_host_port_id,
2518         .show_host_port_id = 1,
2519
2520         .get_host_port_type = lpfc_get_host_port_type,
2521         .show_host_port_type = 1,
2522
2523         .get_host_port_state = lpfc_get_host_port_state,
2524         .show_host_port_state = 1,
2525
2526         /* active_fc4s is shown but doesn't change (thus no get function) */
2527         .show_host_active_fc4s = 1,
2528
2529         .get_host_speed = lpfc_get_host_speed,
2530         .show_host_speed = 1,
2531
2532         .get_host_fabric_name = lpfc_get_host_fabric_name,
2533         .show_host_fabric_name = 1,
2534
2535         /*
2536          * The LPFC driver treats linkdown handling as target loss events
2537          * so there are no sysfs handlers for link_down_tmo.
2538          */
2539
2540         .get_fc_host_stats = lpfc_get_stats,
2541         .reset_fc_host_stats = lpfc_reset_stats,
2542
2543         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
2544         .show_rport_maxframe_size = 1,
2545         .show_rport_supported_classes = 1,
2546
2547         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
2548         .show_rport_dev_loss_tmo = 1,
2549
2550         .get_starget_port_id  = lpfc_get_starget_port_id,
2551         .show_starget_port_id = 1,
2552
2553         .get_starget_node_name = lpfc_get_starget_node_name,
2554         .show_starget_node_name = 1,
2555
2556         .get_starget_port_name = lpfc_get_starget_port_name,
2557         .show_starget_port_name = 1,
2558
2559         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
2560         .terminate_rport_io = lpfc_terminate_rport_io,
2561
2562         .vport_disable = lpfc_vport_disable,
2563 };
2564
2565 void
2566 lpfc_get_cfgparam(struct lpfc_hba *phba)
2567 {
2568         lpfc_cr_delay_init(phba, lpfc_cr_delay);
2569         lpfc_cr_count_init(phba, lpfc_cr_count);
2570         lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
2571         lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
2572         lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
2573         lpfc_ack0_init(phba, lpfc_ack0);
2574         lpfc_topology_init(phba, lpfc_topology);
2575         lpfc_link_speed_init(phba, lpfc_link_speed);
2576         lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
2577         lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
2578         lpfc_use_msi_init(phba, lpfc_use_msi);
2579         lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
2580         lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
2581         phba->cfg_poll = lpfc_poll;
2582         phba->cfg_soft_wwnn = 0L;
2583         phba->cfg_soft_wwpn = 0L;
2584         lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
2585         /* Also reinitialize the host templates with new values. */
2586         lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2587         lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2588         /*
2589          * Since the sg_tablesize is module parameter, the sg_dma_buf_size
2590          * used to create the sg_dma_buf_pool must be dynamically calculated.
2591          * 2 segments are added since the IOCB needs a command and response bde.
2592          */
2593         phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
2594                         sizeof(struct fcp_rsp) +
2595                         ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
2596         lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
2597         return;
2598 }
2599
2600 void
2601 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
2602 {
2603         lpfc_log_verbose_init(vport, lpfc_log_verbose);
2604         lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
2605         lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
2606         lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
2607         lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
2608         lpfc_restrict_login_init(vport, lpfc_restrict_login);
2609         lpfc_fcp_class_init(vport, lpfc_fcp_class);
2610         lpfc_use_adisc_init(vport, lpfc_use_adisc);
2611         lpfc_fdmi_on_init(vport, lpfc_fdmi_on);
2612         lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
2613         lpfc_max_luns_init(vport, lpfc_max_luns);
2614         lpfc_scan_down_init(vport, lpfc_scan_down);
2615         lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
2616         return;
2617 }