1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2012 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 #include <linux/module.h> 27 #include <linux/aer.h> 28 #include <linux/gfp.h> 29 #include <linux/kernel.h> 30 31 #include <scsi/scsi.h> 32 #include <scsi/scsi_device.h> 33 #include <scsi/scsi_host.h> 34 #include <scsi/scsi_tcq.h> 35 #include <scsi/scsi_transport_fc.h> 36 #include <scsi/fc/fc_fs.h> 37 38 #include "lpfc_hw4.h" 39 #include "lpfc_hw.h" 40 #include "lpfc_sli.h" 41 #include "lpfc_sli4.h" 42 #include "lpfc_nl.h" 43 #include "lpfc_disc.h" 44 #include "lpfc_scsi.h" 45 #include "lpfc.h" 46 #include "lpfc_logmsg.h" 47 #include "lpfc_version.h" 48 #include "lpfc_compat.h" 49 #include "lpfc_crtn.h" 50 #include "lpfc_vport.h" 51 52 #define LPFC_DEF_DEVLOSS_TMO 30 53 #define LPFC_MIN_DEVLOSS_TMO 1 54 #define LPFC_MAX_DEVLOSS_TMO 255 55 56 /* 57 * Write key size should be multiple of 4. If write key is changed 58 * make sure that library write key is also changed. 59 */ 60 #define LPFC_REG_WRITE_KEY_SIZE 4 61 #define LPFC_REG_WRITE_KEY "EMLX" 62 63 /** 64 * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules 65 * @incr: integer to convert. 66 * @hdw: ascii string holding converted integer plus a string terminator. 67 * 68 * Description: 69 * JEDEC Joint Electron Device Engineering Council. 70 * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii 71 * character string. The string is then terminated with a NULL in byte 9. 72 * Hex 0-9 becomes ascii '0' to '9'. 73 * Hex a-f becomes ascii '=' to 'B' capital B. 74 * 75 * Notes: 76 * Coded for 32 bit integers only. 77 **/ 78 static void 79 lpfc_jedec_to_ascii(int incr, char hdw[]) 80 { 81 int i, j; 82 for (i = 0; i < 8; i++) { 83 j = (incr & 0xf); 84 if (j <= 9) 85 hdw[7 - i] = 0x30 + j; 86 else 87 hdw[7 - i] = 0x61 + j - 10; 88 incr = (incr >> 4); 89 } 90 hdw[8] = 0; 91 return; 92 } 93 94 /** 95 * lpfc_drvr_version_show - Return the Emulex driver string with version number 96 * @dev: class unused variable. 97 * @attr: device attribute, not used. 98 * @buf: on return contains the module description text. 99 * 100 * Returns: size of formatted string. 101 **/ 102 static ssize_t 103 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr, 104 char *buf) 105 { 106 return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n"); 107 } 108 109 /** 110 * lpfc_enable_fip_show - Return the fip mode of the HBA 111 * @dev: class unused variable. 112 * @attr: device attribute, not used. 113 * @buf: on return contains the module description text. 114 * 115 * Returns: size of formatted string. 116 **/ 117 static ssize_t 118 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr, 119 char *buf) 120 { 121 struct Scsi_Host *shost = class_to_shost(dev); 122 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 123 struct lpfc_hba *phba = vport->phba; 124 125 if (phba->hba_flag & HBA_FIP_SUPPORT) 126 return snprintf(buf, PAGE_SIZE, "1\n"); 127 else 128 return snprintf(buf, PAGE_SIZE, "0\n"); 129 } 130 131 static ssize_t 132 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr, 133 char *buf) 134 { 135 struct Scsi_Host *shost = class_to_shost(dev); 136 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 137 struct lpfc_hba *phba = vport->phba; 138 139 if (phba->cfg_enable_bg) 140 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED) 141 return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n"); 142 else 143 return snprintf(buf, PAGE_SIZE, 144 "BlockGuard Not Supported\n"); 145 else 146 return snprintf(buf, PAGE_SIZE, 147 "BlockGuard Disabled\n"); 148 } 149 150 static ssize_t 151 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr, 152 char *buf) 153 { 154 struct Scsi_Host *shost = class_to_shost(dev); 155 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 156 struct lpfc_hba *phba = vport->phba; 157 158 return snprintf(buf, PAGE_SIZE, "%llu\n", 159 (unsigned long long)phba->bg_guard_err_cnt); 160 } 161 162 static ssize_t 163 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr, 164 char *buf) 165 { 166 struct Scsi_Host *shost = class_to_shost(dev); 167 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 168 struct lpfc_hba *phba = vport->phba; 169 170 return snprintf(buf, PAGE_SIZE, "%llu\n", 171 (unsigned long long)phba->bg_apptag_err_cnt); 172 } 173 174 static ssize_t 175 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr, 176 char *buf) 177 { 178 struct Scsi_Host *shost = class_to_shost(dev); 179 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 180 struct lpfc_hba *phba = vport->phba; 181 182 return snprintf(buf, PAGE_SIZE, "%llu\n", 183 (unsigned long long)phba->bg_reftag_err_cnt); 184 } 185 186 /** 187 * lpfc_info_show - Return some pci info about the host in ascii 188 * @dev: class converted to a Scsi_host structure. 189 * @attr: device attribute, not used. 190 * @buf: on return contains the formatted text from lpfc_info(). 191 * 192 * Returns: size of formatted string. 193 **/ 194 static ssize_t 195 lpfc_info_show(struct device *dev, struct device_attribute *attr, 196 char *buf) 197 { 198 struct Scsi_Host *host = class_to_shost(dev); 199 200 return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host)); 201 } 202 203 /** 204 * lpfc_serialnum_show - Return the hba serial number in ascii 205 * @dev: class converted to a Scsi_host structure. 206 * @attr: device attribute, not used. 207 * @buf: on return contains the formatted text serial number. 208 * 209 * Returns: size of formatted string. 210 **/ 211 static ssize_t 212 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr, 213 char *buf) 214 { 215 struct Scsi_Host *shost = class_to_shost(dev); 216 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 217 struct lpfc_hba *phba = vport->phba; 218 219 return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber); 220 } 221 222 /** 223 * lpfc_temp_sensor_show - Return the temperature sensor level 224 * @dev: class converted to a Scsi_host structure. 225 * @attr: device attribute, not used. 226 * @buf: on return contains the formatted support level. 227 * 228 * Description: 229 * Returns a number indicating the temperature sensor level currently 230 * supported, zero or one in ascii. 231 * 232 * Returns: size of formatted string. 233 **/ 234 static ssize_t 235 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr, 236 char *buf) 237 { 238 struct Scsi_Host *shost = class_to_shost(dev); 239 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 240 struct lpfc_hba *phba = vport->phba; 241 return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support); 242 } 243 244 /** 245 * lpfc_modeldesc_show - Return the model description of the hba 246 * @dev: class converted to a Scsi_host structure. 247 * @attr: device attribute, not used. 248 * @buf: on return contains the scsi vpd model description. 249 * 250 * Returns: size of formatted string. 251 **/ 252 static ssize_t 253 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr, 254 char *buf) 255 { 256 struct Scsi_Host *shost = class_to_shost(dev); 257 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 258 struct lpfc_hba *phba = vport->phba; 259 260 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc); 261 } 262 263 /** 264 * lpfc_modelname_show - Return the model name of the hba 265 * @dev: class converted to a Scsi_host structure. 266 * @attr: device attribute, not used. 267 * @buf: on return contains the scsi vpd model name. 268 * 269 * Returns: size of formatted string. 270 **/ 271 static ssize_t 272 lpfc_modelname_show(struct device *dev, struct device_attribute *attr, 273 char *buf) 274 { 275 struct Scsi_Host *shost = class_to_shost(dev); 276 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 277 struct lpfc_hba *phba = vport->phba; 278 279 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName); 280 } 281 282 /** 283 * lpfc_programtype_show - Return the program type of the hba 284 * @dev: class converted to a Scsi_host structure. 285 * @attr: device attribute, not used. 286 * @buf: on return contains the scsi vpd program type. 287 * 288 * Returns: size of formatted string. 289 **/ 290 static ssize_t 291 lpfc_programtype_show(struct device *dev, struct device_attribute *attr, 292 char *buf) 293 { 294 struct Scsi_Host *shost = class_to_shost(dev); 295 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 296 struct lpfc_hba *phba = vport->phba; 297 298 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType); 299 } 300 301 /** 302 * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag 303 * @dev: class converted to a Scsi_host structure. 304 * @attr: device attribute, not used. 305 * @buf: on return contains the Menlo Maintenance sli flag. 306 * 307 * Returns: size of formatted string. 308 **/ 309 static ssize_t 310 lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf) 311 { 312 struct Scsi_Host *shost = class_to_shost(dev); 313 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 314 struct lpfc_hba *phba = vport->phba; 315 316 return snprintf(buf, PAGE_SIZE, "%d\n", 317 (phba->sli.sli_flag & LPFC_MENLO_MAINT)); 318 } 319 320 /** 321 * lpfc_vportnum_show - Return the port number in ascii of the hba 322 * @dev: class converted to a Scsi_host structure. 323 * @attr: device attribute, not used. 324 * @buf: on return contains scsi vpd program type. 325 * 326 * Returns: size of formatted string. 327 **/ 328 static ssize_t 329 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr, 330 char *buf) 331 { 332 struct Scsi_Host *shost = class_to_shost(dev); 333 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 334 struct lpfc_hba *phba = vport->phba; 335 336 return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port); 337 } 338 339 /** 340 * lpfc_fwrev_show - Return the firmware rev running in the hba 341 * @dev: class converted to a Scsi_host structure. 342 * @attr: device attribute, not used. 343 * @buf: on return contains the scsi vpd program type. 344 * 345 * Returns: size of formatted string. 346 **/ 347 static ssize_t 348 lpfc_fwrev_show(struct device *dev, struct device_attribute *attr, 349 char *buf) 350 { 351 struct Scsi_Host *shost = class_to_shost(dev); 352 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 353 struct lpfc_hba *phba = vport->phba; 354 uint32_t if_type; 355 uint8_t sli_family; 356 char fwrev[FW_REV_STR_SIZE]; 357 int len; 358 359 lpfc_decode_firmware_rev(phba, fwrev, 1); 360 if_type = phba->sli4_hba.pc_sli4_params.if_type; 361 sli_family = phba->sli4_hba.pc_sli4_params.sli_family; 362 363 if (phba->sli_rev < LPFC_SLI_REV4) 364 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", 365 fwrev, phba->sli_rev); 366 else 367 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n", 368 fwrev, phba->sli_rev, if_type, sli_family); 369 370 return len; 371 } 372 373 /** 374 * lpfc_hdw_show - Return the jedec information about the hba 375 * @dev: class converted to a Scsi_host structure. 376 * @attr: device attribute, not used. 377 * @buf: on return contains the scsi vpd program type. 378 * 379 * Returns: size of formatted string. 380 **/ 381 static ssize_t 382 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf) 383 { 384 char hdw[9]; 385 struct Scsi_Host *shost = class_to_shost(dev); 386 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 387 struct lpfc_hba *phba = vport->phba; 388 lpfc_vpd_t *vp = &phba->vpd; 389 390 lpfc_jedec_to_ascii(vp->rev.biuRev, hdw); 391 return snprintf(buf, PAGE_SIZE, "%s\n", hdw); 392 } 393 394 /** 395 * lpfc_option_rom_version_show - Return the adapter ROM FCode version 396 * @dev: class converted to a Scsi_host structure. 397 * @attr: device attribute, not used. 398 * @buf: on return contains the ROM and FCode ascii strings. 399 * 400 * Returns: size of formatted string. 401 **/ 402 static ssize_t 403 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr, 404 char *buf) 405 { 406 struct Scsi_Host *shost = class_to_shost(dev); 407 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 408 struct lpfc_hba *phba = vport->phba; 409 410 return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion); 411 } 412 413 /** 414 * lpfc_state_show - Return the link state of the port 415 * @dev: class converted to a Scsi_host structure. 416 * @attr: device attribute, not used. 417 * @buf: on return contains text describing the state of the link. 418 * 419 * Notes: 420 * The switch statement has no default so zero will be returned. 421 * 422 * Returns: size of formatted string. 423 **/ 424 static ssize_t 425 lpfc_link_state_show(struct device *dev, struct device_attribute *attr, 426 char *buf) 427 { 428 struct Scsi_Host *shost = class_to_shost(dev); 429 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 430 struct lpfc_hba *phba = vport->phba; 431 int len = 0; 432 433 switch (phba->link_state) { 434 case LPFC_LINK_UNKNOWN: 435 case LPFC_WARM_START: 436 case LPFC_INIT_START: 437 case LPFC_INIT_MBX_CMDS: 438 case LPFC_LINK_DOWN: 439 case LPFC_HBA_ERROR: 440 if (phba->hba_flag & LINK_DISABLED) 441 len += snprintf(buf + len, PAGE_SIZE-len, 442 "Link Down - User disabled\n"); 443 else 444 len += snprintf(buf + len, PAGE_SIZE-len, 445 "Link Down\n"); 446 break; 447 case LPFC_LINK_UP: 448 case LPFC_CLEAR_LA: 449 case LPFC_HBA_READY: 450 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - "); 451 452 switch (vport->port_state) { 453 case LPFC_LOCAL_CFG_LINK: 454 len += snprintf(buf + len, PAGE_SIZE-len, 455 "Configuring Link\n"); 456 break; 457 case LPFC_FDISC: 458 case LPFC_FLOGI: 459 case LPFC_FABRIC_CFG_LINK: 460 case LPFC_NS_REG: 461 case LPFC_NS_QRY: 462 case LPFC_BUILD_DISC_LIST: 463 case LPFC_DISC_AUTH: 464 len += snprintf(buf + len, PAGE_SIZE - len, 465 "Discovery\n"); 466 break; 467 case LPFC_VPORT_READY: 468 len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n"); 469 break; 470 471 case LPFC_VPORT_FAILED: 472 len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n"); 473 break; 474 475 case LPFC_VPORT_UNKNOWN: 476 len += snprintf(buf + len, PAGE_SIZE - len, 477 "Unknown\n"); 478 break; 479 } 480 if (phba->sli.sli_flag & LPFC_MENLO_MAINT) 481 len += snprintf(buf + len, PAGE_SIZE-len, 482 " Menlo Maint Mode\n"); 483 else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) { 484 if (vport->fc_flag & FC_PUBLIC_LOOP) 485 len += snprintf(buf + len, PAGE_SIZE-len, 486 " Public Loop\n"); 487 else 488 len += snprintf(buf + len, PAGE_SIZE-len, 489 " Private Loop\n"); 490 } else { 491 if (vport->fc_flag & FC_FABRIC) 492 len += snprintf(buf + len, PAGE_SIZE-len, 493 " Fabric\n"); 494 else 495 len += snprintf(buf + len, PAGE_SIZE-len, 496 " Point-2-Point\n"); 497 } 498 } 499 500 return len; 501 } 502 503 /** 504 * lpfc_sli4_protocol_show - Return the fip mode of the HBA 505 * @dev: class unused variable. 506 * @attr: device attribute, not used. 507 * @buf: on return contains the module description text. 508 * 509 * Returns: size of formatted string. 510 **/ 511 static ssize_t 512 lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr, 513 char *buf) 514 { 515 struct Scsi_Host *shost = class_to_shost(dev); 516 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 517 struct lpfc_hba *phba = vport->phba; 518 519 if (phba->sli_rev < LPFC_SLI_REV4) 520 return snprintf(buf, PAGE_SIZE, "fc\n"); 521 522 if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) { 523 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE) 524 return snprintf(buf, PAGE_SIZE, "fcoe\n"); 525 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC) 526 return snprintf(buf, PAGE_SIZE, "fc\n"); 527 } 528 return snprintf(buf, PAGE_SIZE, "unknown\n"); 529 } 530 531 /** 532 * lpfc_link_state_store - Transition the link_state on an HBA port 533 * @dev: class device that is converted into a Scsi_host. 534 * @attr: device attribute, not used. 535 * @buf: one or more lpfc_polling_flags values. 536 * @count: not used. 537 * 538 * Returns: 539 * -EINVAL if the buffer is not "up" or "down" 540 * return from link state change function if non-zero 541 * length of the buf on success 542 **/ 543 static ssize_t 544 lpfc_link_state_store(struct device *dev, struct device_attribute *attr, 545 const char *buf, size_t count) 546 { 547 struct Scsi_Host *shost = class_to_shost(dev); 548 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 549 struct lpfc_hba *phba = vport->phba; 550 551 int status = -EINVAL; 552 553 if ((strncmp(buf, "up", sizeof("up") - 1) == 0) && 554 (phba->link_state == LPFC_LINK_DOWN)) 555 status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT); 556 else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) && 557 (phba->link_state >= LPFC_LINK_UP)) 558 status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT); 559 560 if (status == 0) 561 return strlen(buf); 562 else 563 return status; 564 } 565 566 /** 567 * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports 568 * @dev: class device that is converted into a Scsi_host. 569 * @attr: device attribute, not used. 570 * @buf: on return contains the sum of fc mapped and unmapped. 571 * 572 * Description: 573 * Returns the ascii text number of the sum of the fc mapped and unmapped 574 * vport counts. 575 * 576 * Returns: size of formatted string. 577 **/ 578 static ssize_t 579 lpfc_num_discovered_ports_show(struct device *dev, 580 struct device_attribute *attr, char *buf) 581 { 582 struct Scsi_Host *shost = class_to_shost(dev); 583 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 584 585 return snprintf(buf, PAGE_SIZE, "%d\n", 586 vport->fc_map_cnt + vport->fc_unmap_cnt); 587 } 588 589 /** 590 * lpfc_issue_lip - Misnomer, name carried over from long ago 591 * @shost: Scsi_Host pointer. 592 * 593 * Description: 594 * Bring the link down gracefully then re-init the link. The firmware will 595 * re-init the fiber channel interface as required. Does not issue a LIP. 596 * 597 * Returns: 598 * -EPERM port offline or management commands are being blocked 599 * -ENOMEM cannot allocate memory for the mailbox command 600 * -EIO error sending the mailbox command 601 * zero for success 602 **/ 603 static int 604 lpfc_issue_lip(struct Scsi_Host *shost) 605 { 606 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 607 struct lpfc_hba *phba = vport->phba; 608 LPFC_MBOXQ_t *pmboxq; 609 int mbxstatus = MBXERR_ERROR; 610 611 if ((vport->fc_flag & FC_OFFLINE_MODE) || 612 (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)) 613 return -EPERM; 614 615 pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL); 616 617 if (!pmboxq) 618 return -ENOMEM; 619 620 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 621 pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK; 622 pmboxq->u.mb.mbxOwner = OWN_HOST; 623 624 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2); 625 626 if ((mbxstatus == MBX_SUCCESS) && 627 (pmboxq->u.mb.mbxStatus == 0 || 628 pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) { 629 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 630 lpfc_init_link(phba, pmboxq, phba->cfg_topology, 631 phba->cfg_link_speed); 632 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, 633 phba->fc_ratov * 2); 634 if ((mbxstatus == MBX_SUCCESS) && 635 (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION)) 636 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI, 637 "2859 SLI authentication is required " 638 "for INIT_LINK but has not done yet\n"); 639 } 640 641 lpfc_set_loopback_flag(phba); 642 if (mbxstatus != MBX_TIMEOUT) 643 mempool_free(pmboxq, phba->mbox_mem_pool); 644 645 if (mbxstatus == MBXERR_ERROR) 646 return -EIO; 647 648 return 0; 649 } 650 651 /** 652 * lpfc_do_offline - Issues a mailbox command to bring the link down 653 * @phba: lpfc_hba pointer. 654 * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL. 655 * 656 * Notes: 657 * Assumes any error from lpfc_do_offline() will be negative. 658 * Can wait up to 5 seconds for the port ring buffers count 659 * to reach zero, prints a warning if it is not zero and continues. 660 * lpfc_workq_post_event() returns a non-zero return code if call fails. 661 * 662 * Returns: 663 * -EIO error posting the event 664 * zero for success 665 **/ 666 static int 667 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type) 668 { 669 struct completion online_compl; 670 struct lpfc_sli_ring *pring; 671 struct lpfc_sli *psli; 672 int status = 0; 673 int cnt = 0; 674 int i; 675 int rc; 676 677 init_completion(&online_compl); 678 rc = lpfc_workq_post_event(phba, &status, &online_compl, 679 LPFC_EVT_OFFLINE_PREP); 680 if (rc == 0) 681 return -ENOMEM; 682 683 wait_for_completion(&online_compl); 684 685 if (status != 0) 686 return -EIO; 687 688 psli = &phba->sli; 689 690 /* Wait a little for things to settle down, but not 691 * long enough for dev loss timeout to expire. 692 */ 693 for (i = 0; i < psli->num_rings; i++) { 694 pring = &psli->ring[i]; 695 while (pring->txcmplq_cnt) { 696 msleep(10); 697 if (cnt++ > 500) { /* 5 secs */ 698 lpfc_printf_log(phba, 699 KERN_WARNING, LOG_INIT, 700 "0466 Outstanding IO when " 701 "bringing Adapter offline\n"); 702 break; 703 } 704 } 705 } 706 707 init_completion(&online_compl); 708 rc = lpfc_workq_post_event(phba, &status, &online_compl, type); 709 if (rc == 0) 710 return -ENOMEM; 711 712 wait_for_completion(&online_compl); 713 714 if (status != 0) 715 return -EIO; 716 717 return 0; 718 } 719 720 /** 721 * lpfc_selective_reset - Offline then onlines the port 722 * @phba: lpfc_hba pointer. 723 * 724 * Description: 725 * If the port is configured to allow a reset then the hba is brought 726 * offline then online. 727 * 728 * Notes: 729 * Assumes any error from lpfc_do_offline() will be negative. 730 * Do not make this function static. 731 * 732 * Returns: 733 * lpfc_do_offline() return code if not zero 734 * -EIO reset not configured or error posting the event 735 * zero for success 736 **/ 737 int 738 lpfc_selective_reset(struct lpfc_hba *phba) 739 { 740 struct completion online_compl; 741 int status = 0; 742 int rc; 743 744 if (!phba->cfg_enable_hba_reset) 745 return -EACCES; 746 747 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); 748 749 if (status != 0) 750 return status; 751 752 init_completion(&online_compl); 753 rc = lpfc_workq_post_event(phba, &status, &online_compl, 754 LPFC_EVT_ONLINE); 755 if (rc == 0) 756 return -ENOMEM; 757 758 wait_for_completion(&online_compl); 759 760 if (status != 0) 761 return -EIO; 762 763 return 0; 764 } 765 766 /** 767 * lpfc_issue_reset - Selectively resets an adapter 768 * @dev: class device that is converted into a Scsi_host. 769 * @attr: device attribute, not used. 770 * @buf: containing the string "selective". 771 * @count: unused variable. 772 * 773 * Description: 774 * If the buf contains the string "selective" then lpfc_selective_reset() 775 * is called to perform the reset. 776 * 777 * Notes: 778 * Assumes any error from lpfc_selective_reset() will be negative. 779 * If lpfc_selective_reset() returns zero then the length of the buffer 780 * is returned which indicates success 781 * 782 * Returns: 783 * -EINVAL if the buffer does not contain the string "selective" 784 * length of buf if lpfc-selective_reset() if the call succeeds 785 * return value of lpfc_selective_reset() if the call fails 786 **/ 787 static ssize_t 788 lpfc_issue_reset(struct device *dev, struct device_attribute *attr, 789 const char *buf, size_t count) 790 { 791 struct Scsi_Host *shost = class_to_shost(dev); 792 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 793 struct lpfc_hba *phba = vport->phba; 794 int status = -EINVAL; 795 796 if (!phba->cfg_enable_hba_reset) 797 return -EACCES; 798 799 if (strncmp(buf, "selective", sizeof("selective") - 1) == 0) 800 status = phba->lpfc_selective_reset(phba); 801 802 if (status == 0) 803 return strlen(buf); 804 else 805 return status; 806 } 807 808 /** 809 * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness 810 * @phba: lpfc_hba pointer. 811 * 812 * Description: 813 * SLI4 interface type-2 device to wait on the sliport status register for 814 * the readyness after performing a firmware reset. 815 * 816 * Returns: 817 * zero for success, -EPERM when port does not have privilage to perform the 818 * reset, -EIO when port timeout from recovering from the reset. 819 * 820 * Note: 821 * As the caller will interpret the return code by value, be careful in making 822 * change or addition to return codes. 823 **/ 824 int 825 lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba) 826 { 827 struct lpfc_register portstat_reg = {0}; 828 int i; 829 830 msleep(100); 831 lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr, 832 &portstat_reg.word0); 833 834 /* verify if privilaged for the request operation */ 835 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) && 836 !bf_get(lpfc_sliport_status_err, &portstat_reg)) 837 return -EPERM; 838 839 /* wait for the SLI port firmware ready after firmware reset */ 840 for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) { 841 msleep(10); 842 lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr, 843 &portstat_reg.word0); 844 if (!bf_get(lpfc_sliport_status_err, &portstat_reg)) 845 continue; 846 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg)) 847 continue; 848 if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg)) 849 continue; 850 break; 851 } 852 853 if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT) 854 return 0; 855 else 856 return -EIO; 857 } 858 859 /** 860 * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc 861 * @phba: lpfc_hba pointer. 862 * 863 * Description: 864 * Request SLI4 interface type-2 device to perform a physical register set 865 * access. 866 * 867 * Returns: 868 * zero for success 869 **/ 870 static ssize_t 871 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode) 872 { 873 struct completion online_compl; 874 struct pci_dev *pdev = phba->pcidev; 875 uint32_t before_fc_flag; 876 uint32_t sriov_nr_virtfn; 877 uint32_t reg_val; 878 int status = 0, rc = 0; 879 int job_posted = 1, sriov_err; 880 881 if (!phba->cfg_enable_hba_reset) 882 return -EACCES; 883 884 if ((phba->sli_rev < LPFC_SLI_REV4) || 885 (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) != 886 LPFC_SLI_INTF_IF_TYPE_2)) 887 return -EPERM; 888 889 /* Keep state if we need to restore back */ 890 before_fc_flag = phba->pport->fc_flag; 891 sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn; 892 893 /* Disable SR-IOV virtual functions if enabled */ 894 if (phba->cfg_sriov_nr_virtfn) { 895 pci_disable_sriov(pdev); 896 phba->cfg_sriov_nr_virtfn = 0; 897 } 898 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); 899 900 if (status != 0) 901 return status; 902 903 /* wait for the device to be quiesced before firmware reset */ 904 msleep(100); 905 906 reg_val = readl(phba->sli4_hba.conf_regs_memmap_p + 907 LPFC_CTL_PDEV_CTL_OFFSET); 908 909 if (opcode == LPFC_FW_DUMP) 910 reg_val |= LPFC_FW_DUMP_REQUEST; 911 else if (opcode == LPFC_FW_RESET) 912 reg_val |= LPFC_CTL_PDEV_CTL_FRST; 913 else if (opcode == LPFC_DV_RESET) 914 reg_val |= LPFC_CTL_PDEV_CTL_DRST; 915 916 writel(reg_val, phba->sli4_hba.conf_regs_memmap_p + 917 LPFC_CTL_PDEV_CTL_OFFSET); 918 /* flush */ 919 readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET); 920 921 /* delay driver action following IF_TYPE_2 reset */ 922 rc = lpfc_sli4_pdev_status_reg_wait(phba); 923 924 if (rc == -EPERM) { 925 /* no privilage for reset */ 926 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 927 "3150 No privilage to perform the requested " 928 "access: x%x\n", reg_val); 929 } else if (rc == -EIO) { 930 /* reset failed, there is nothing more we can do */ 931 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 932 "3153 Fail to perform the requested " 933 "access: x%x\n", reg_val); 934 return rc; 935 } 936 937 /* keep the original port state */ 938 if (before_fc_flag & FC_OFFLINE_MODE) 939 goto out; 940 941 init_completion(&online_compl); 942 job_posted = lpfc_workq_post_event(phba, &status, &online_compl, 943 LPFC_EVT_ONLINE); 944 if (!job_posted) 945 goto out; 946 947 wait_for_completion(&online_compl); 948 949 out: 950 /* in any case, restore the virtual functions enabled as before */ 951 if (sriov_nr_virtfn) { 952 sriov_err = 953 lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn); 954 if (!sriov_err) 955 phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn; 956 } 957 958 /* return proper error code */ 959 if (!rc) { 960 if (!job_posted) 961 rc = -ENOMEM; 962 else if (status) 963 rc = -EIO; 964 } 965 return rc; 966 } 967 968 /** 969 * lpfc_nport_evt_cnt_show - Return the number of nport events 970 * @dev: class device that is converted into a Scsi_host. 971 * @attr: device attribute, not used. 972 * @buf: on return contains the ascii number of nport events. 973 * 974 * Returns: size of formatted string. 975 **/ 976 static ssize_t 977 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr, 978 char *buf) 979 { 980 struct Scsi_Host *shost = class_to_shost(dev); 981 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 982 struct lpfc_hba *phba = vport->phba; 983 984 return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt); 985 } 986 987 /** 988 * lpfc_board_mode_show - Return the state of the board 989 * @dev: class device that is converted into a Scsi_host. 990 * @attr: device attribute, not used. 991 * @buf: on return contains the state of the adapter. 992 * 993 * Returns: size of formatted string. 994 **/ 995 static ssize_t 996 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr, 997 char *buf) 998 { 999 struct Scsi_Host *shost = class_to_shost(dev); 1000 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1001 struct lpfc_hba *phba = vport->phba; 1002 char * state; 1003 1004 if (phba->link_state == LPFC_HBA_ERROR) 1005 state = "error"; 1006 else if (phba->link_state == LPFC_WARM_START) 1007 state = "warm start"; 1008 else if (phba->link_state == LPFC_INIT_START) 1009 state = "offline"; 1010 else 1011 state = "online"; 1012 1013 return snprintf(buf, PAGE_SIZE, "%s\n", state); 1014 } 1015 1016 /** 1017 * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state 1018 * @dev: class device that is converted into a Scsi_host. 1019 * @attr: device attribute, not used. 1020 * @buf: containing one of the strings "online", "offline", "warm" or "error". 1021 * @count: unused variable. 1022 * 1023 * Returns: 1024 * -EACCES if enable hba reset not enabled 1025 * -EINVAL if the buffer does not contain a valid string (see above) 1026 * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails 1027 * buf length greater than zero indicates success 1028 **/ 1029 static ssize_t 1030 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr, 1031 const char *buf, size_t count) 1032 { 1033 struct Scsi_Host *shost = class_to_shost(dev); 1034 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1035 struct lpfc_hba *phba = vport->phba; 1036 struct completion online_compl; 1037 char *board_mode_str = NULL; 1038 int status = 0; 1039 int rc; 1040 1041 if (!phba->cfg_enable_hba_reset) { 1042 status = -EACCES; 1043 goto board_mode_out; 1044 } 1045 1046 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1047 "3050 lpfc_board_mode set to %s\n", buf); 1048 1049 init_completion(&online_compl); 1050 1051 if(strncmp(buf, "online", sizeof("online") - 1) == 0) { 1052 rc = lpfc_workq_post_event(phba, &status, &online_compl, 1053 LPFC_EVT_ONLINE); 1054 if (rc == 0) { 1055 status = -ENOMEM; 1056 goto board_mode_out; 1057 } 1058 wait_for_completion(&online_compl); 1059 } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0) 1060 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); 1061 else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0) 1062 if (phba->sli_rev == LPFC_SLI_REV4) 1063 status = -EINVAL; 1064 else 1065 status = lpfc_do_offline(phba, LPFC_EVT_WARM_START); 1066 else if (strncmp(buf, "error", sizeof("error") - 1) == 0) 1067 if (phba->sli_rev == LPFC_SLI_REV4) 1068 status = -EINVAL; 1069 else 1070 status = lpfc_do_offline(phba, LPFC_EVT_KILL); 1071 else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0) 1072 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP); 1073 else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0) 1074 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET); 1075 else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0) 1076 status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET); 1077 else 1078 status = -EINVAL; 1079 1080 board_mode_out: 1081 if (!status) 1082 return strlen(buf); 1083 else { 1084 board_mode_str = strchr(buf, '\n'); 1085 if (board_mode_str) 1086 *board_mode_str = '\0'; 1087 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1088 "3097 Failed \"%s\", status(%d), " 1089 "fc_flag(x%x)\n", 1090 buf, status, phba->pport->fc_flag); 1091 return status; 1092 } 1093 } 1094 1095 /** 1096 * lpfc_get_hba_info - Return various bits of informaton about the adapter 1097 * @phba: pointer to the adapter structure. 1098 * @mxri: max xri count. 1099 * @axri: available xri count. 1100 * @mrpi: max rpi count. 1101 * @arpi: available rpi count. 1102 * @mvpi: max vpi count. 1103 * @avpi: available vpi count. 1104 * 1105 * Description: 1106 * If an integer pointer for an count is not null then the value for the 1107 * count is returned. 1108 * 1109 * Returns: 1110 * zero on error 1111 * one for success 1112 **/ 1113 static int 1114 lpfc_get_hba_info(struct lpfc_hba *phba, 1115 uint32_t *mxri, uint32_t *axri, 1116 uint32_t *mrpi, uint32_t *arpi, 1117 uint32_t *mvpi, uint32_t *avpi) 1118 { 1119 struct lpfc_mbx_read_config *rd_config; 1120 LPFC_MBOXQ_t *pmboxq; 1121 MAILBOX_t *pmb; 1122 int rc = 0; 1123 uint32_t max_vpi; 1124 1125 /* 1126 * prevent udev from issuing mailbox commands until the port is 1127 * configured. 1128 */ 1129 if (phba->link_state < LPFC_LINK_DOWN || 1130 !phba->mbox_mem_pool || 1131 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0) 1132 return 0; 1133 1134 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 1135 return 0; 1136 1137 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1138 if (!pmboxq) 1139 return 0; 1140 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 1141 1142 pmb = &pmboxq->u.mb; 1143 pmb->mbxCommand = MBX_READ_CONFIG; 1144 pmb->mbxOwner = OWN_HOST; 1145 pmboxq->context1 = NULL; 1146 1147 if (phba->pport->fc_flag & FC_OFFLINE_MODE) 1148 rc = MBX_NOT_FINISHED; 1149 else 1150 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 1151 1152 if (rc != MBX_SUCCESS) { 1153 if (rc != MBX_TIMEOUT) 1154 mempool_free(pmboxq, phba->mbox_mem_pool); 1155 return 0; 1156 } 1157 1158 if (phba->sli_rev == LPFC_SLI_REV4) { 1159 rd_config = &pmboxq->u.mqe.un.rd_config; 1160 if (mrpi) 1161 *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config); 1162 if (arpi) 1163 *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) - 1164 phba->sli4_hba.max_cfg_param.rpi_used; 1165 if (mxri) 1166 *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config); 1167 if (axri) 1168 *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) - 1169 phba->sli4_hba.max_cfg_param.xri_used; 1170 1171 /* Account for differences with SLI-3. Get vpi count from 1172 * mailbox data and subtract one for max vpi value. 1173 */ 1174 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ? 1175 (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0; 1176 1177 if (mvpi) 1178 *mvpi = max_vpi; 1179 if (avpi) 1180 *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used; 1181 } else { 1182 if (mrpi) 1183 *mrpi = pmb->un.varRdConfig.max_rpi; 1184 if (arpi) 1185 *arpi = pmb->un.varRdConfig.avail_rpi; 1186 if (mxri) 1187 *mxri = pmb->un.varRdConfig.max_xri; 1188 if (axri) 1189 *axri = pmb->un.varRdConfig.avail_xri; 1190 if (mvpi) 1191 *mvpi = pmb->un.varRdConfig.max_vpi; 1192 if (avpi) 1193 *avpi = pmb->un.varRdConfig.avail_vpi; 1194 } 1195 1196 mempool_free(pmboxq, phba->mbox_mem_pool); 1197 return 1; 1198 } 1199 1200 /** 1201 * lpfc_max_rpi_show - Return maximum rpi 1202 * @dev: class device that is converted into a Scsi_host. 1203 * @attr: device attribute, not used. 1204 * @buf: on return contains the maximum rpi count in decimal or "Unknown". 1205 * 1206 * Description: 1207 * Calls lpfc_get_hba_info() asking for just the mrpi count. 1208 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set 1209 * to "Unknown" and the buffer length is returned, therefore the caller 1210 * must check for "Unknown" in the buffer to detect a failure. 1211 * 1212 * Returns: size of formatted string. 1213 **/ 1214 static ssize_t 1215 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr, 1216 char *buf) 1217 { 1218 struct Scsi_Host *shost = class_to_shost(dev); 1219 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1220 struct lpfc_hba *phba = vport->phba; 1221 uint32_t cnt; 1222 1223 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL)) 1224 return snprintf(buf, PAGE_SIZE, "%d\n", cnt); 1225 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 1226 } 1227 1228 /** 1229 * lpfc_used_rpi_show - Return maximum rpi minus available rpi 1230 * @dev: class device that is converted into a Scsi_host. 1231 * @attr: device attribute, not used. 1232 * @buf: containing the used rpi count in decimal or "Unknown". 1233 * 1234 * Description: 1235 * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts. 1236 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set 1237 * to "Unknown" and the buffer length is returned, therefore the caller 1238 * must check for "Unknown" in the buffer to detect a failure. 1239 * 1240 * Returns: size of formatted string. 1241 **/ 1242 static ssize_t 1243 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr, 1244 char *buf) 1245 { 1246 struct Scsi_Host *shost = class_to_shost(dev); 1247 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1248 struct lpfc_hba *phba = vport->phba; 1249 uint32_t cnt, acnt; 1250 1251 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL)) 1252 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt)); 1253 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 1254 } 1255 1256 /** 1257 * lpfc_max_xri_show - Return maximum xri 1258 * @dev: class device that is converted into a Scsi_host. 1259 * @attr: device attribute, not used. 1260 * @buf: on return contains the maximum xri count in decimal or "Unknown". 1261 * 1262 * Description: 1263 * Calls lpfc_get_hba_info() asking for just the mrpi count. 1264 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set 1265 * to "Unknown" and the buffer length is returned, therefore the caller 1266 * must check for "Unknown" in the buffer to detect a failure. 1267 * 1268 * Returns: size of formatted string. 1269 **/ 1270 static ssize_t 1271 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr, 1272 char *buf) 1273 { 1274 struct Scsi_Host *shost = class_to_shost(dev); 1275 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1276 struct lpfc_hba *phba = vport->phba; 1277 uint32_t cnt; 1278 1279 if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL)) 1280 return snprintf(buf, PAGE_SIZE, "%d\n", cnt); 1281 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 1282 } 1283 1284 /** 1285 * lpfc_used_xri_show - Return maximum xpi minus the available xpi 1286 * @dev: class device that is converted into a Scsi_host. 1287 * @attr: device attribute, not used. 1288 * @buf: on return contains the used xri count in decimal or "Unknown". 1289 * 1290 * Description: 1291 * Calls lpfc_get_hba_info() asking for just the mxri and axri counts. 1292 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set 1293 * to "Unknown" and the buffer length is returned, therefore the caller 1294 * must check for "Unknown" in the buffer to detect a failure. 1295 * 1296 * Returns: size of formatted string. 1297 **/ 1298 static ssize_t 1299 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr, 1300 char *buf) 1301 { 1302 struct Scsi_Host *shost = class_to_shost(dev); 1303 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1304 struct lpfc_hba *phba = vport->phba; 1305 uint32_t cnt, acnt; 1306 1307 if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL)) 1308 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt)); 1309 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 1310 } 1311 1312 /** 1313 * lpfc_max_vpi_show - Return maximum vpi 1314 * @dev: class device that is converted into a Scsi_host. 1315 * @attr: device attribute, not used. 1316 * @buf: on return contains the maximum vpi count in decimal or "Unknown". 1317 * 1318 * Description: 1319 * Calls lpfc_get_hba_info() asking for just the mvpi count. 1320 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set 1321 * to "Unknown" and the buffer length is returned, therefore the caller 1322 * must check for "Unknown" in the buffer to detect a failure. 1323 * 1324 * Returns: size of formatted string. 1325 **/ 1326 static ssize_t 1327 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr, 1328 char *buf) 1329 { 1330 struct Scsi_Host *shost = class_to_shost(dev); 1331 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1332 struct lpfc_hba *phba = vport->phba; 1333 uint32_t cnt; 1334 1335 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL)) 1336 return snprintf(buf, PAGE_SIZE, "%d\n", cnt); 1337 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 1338 } 1339 1340 /** 1341 * lpfc_used_vpi_show - Return maximum vpi minus the available vpi 1342 * @dev: class device that is converted into a Scsi_host. 1343 * @attr: device attribute, not used. 1344 * @buf: on return contains the used vpi count in decimal or "Unknown". 1345 * 1346 * Description: 1347 * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts. 1348 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set 1349 * to "Unknown" and the buffer length is returned, therefore the caller 1350 * must check for "Unknown" in the buffer to detect a failure. 1351 * 1352 * Returns: size of formatted string. 1353 **/ 1354 static ssize_t 1355 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr, 1356 char *buf) 1357 { 1358 struct Scsi_Host *shost = class_to_shost(dev); 1359 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1360 struct lpfc_hba *phba = vport->phba; 1361 uint32_t cnt, acnt; 1362 1363 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt)) 1364 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt)); 1365 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 1366 } 1367 1368 /** 1369 * lpfc_npiv_info_show - Return text about NPIV support for the adapter 1370 * @dev: class device that is converted into a Scsi_host. 1371 * @attr: device attribute, not used. 1372 * @buf: text that must be interpreted to determine if npiv is supported. 1373 * 1374 * Description: 1375 * Buffer will contain text indicating npiv is not suppoerted on the port, 1376 * the port is an NPIV physical port, or it is an npiv virtual port with 1377 * the id of the vport. 1378 * 1379 * Returns: size of formatted string. 1380 **/ 1381 static ssize_t 1382 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr, 1383 char *buf) 1384 { 1385 struct Scsi_Host *shost = class_to_shost(dev); 1386 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1387 struct lpfc_hba *phba = vport->phba; 1388 1389 if (!(phba->max_vpi)) 1390 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n"); 1391 if (vport->port_type == LPFC_PHYSICAL_PORT) 1392 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n"); 1393 return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi); 1394 } 1395 1396 /** 1397 * lpfc_poll_show - Return text about poll support for the adapter 1398 * @dev: class device that is converted into a Scsi_host. 1399 * @attr: device attribute, not used. 1400 * @buf: on return contains the cfg_poll in hex. 1401 * 1402 * Notes: 1403 * cfg_poll should be a lpfc_polling_flags type. 1404 * 1405 * Returns: size of formatted string. 1406 **/ 1407 static ssize_t 1408 lpfc_poll_show(struct device *dev, struct device_attribute *attr, 1409 char *buf) 1410 { 1411 struct Scsi_Host *shost = class_to_shost(dev); 1412 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1413 struct lpfc_hba *phba = vport->phba; 1414 1415 return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll); 1416 } 1417 1418 /** 1419 * lpfc_poll_store - Set the value of cfg_poll for the adapter 1420 * @dev: class device that is converted into a Scsi_host. 1421 * @attr: device attribute, not used. 1422 * @buf: one or more lpfc_polling_flags values. 1423 * @count: not used. 1424 * 1425 * Notes: 1426 * buf contents converted to integer and checked for a valid value. 1427 * 1428 * Returns: 1429 * -EINVAL if the buffer connot be converted or is out of range 1430 * length of the buf on success 1431 **/ 1432 static ssize_t 1433 lpfc_poll_store(struct device *dev, struct device_attribute *attr, 1434 const char *buf, size_t count) 1435 { 1436 struct Scsi_Host *shost = class_to_shost(dev); 1437 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1438 struct lpfc_hba *phba = vport->phba; 1439 uint32_t creg_val; 1440 uint32_t old_val; 1441 int val=0; 1442 1443 if (!isdigit(buf[0])) 1444 return -EINVAL; 1445 1446 if (sscanf(buf, "%i", &val) != 1) 1447 return -EINVAL; 1448 1449 if ((val & 0x3) != val) 1450 return -EINVAL; 1451 1452 if (phba->sli_rev == LPFC_SLI_REV4) 1453 val = 0; 1454 1455 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1456 "3051 lpfc_poll changed from %d to %d\n", 1457 phba->cfg_poll, val); 1458 1459 spin_lock_irq(&phba->hbalock); 1460 1461 old_val = phba->cfg_poll; 1462 1463 if (val & ENABLE_FCP_RING_POLLING) { 1464 if ((val & DISABLE_FCP_RING_INT) && 1465 !(old_val & DISABLE_FCP_RING_INT)) { 1466 if (lpfc_readl(phba->HCregaddr, &creg_val)) { 1467 spin_unlock_irq(&phba->hbalock); 1468 return -EINVAL; 1469 } 1470 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING); 1471 writel(creg_val, phba->HCregaddr); 1472 readl(phba->HCregaddr); /* flush */ 1473 1474 lpfc_poll_start_timer(phba); 1475 } 1476 } else if (val != 0x0) { 1477 spin_unlock_irq(&phba->hbalock); 1478 return -EINVAL; 1479 } 1480 1481 if (!(val & DISABLE_FCP_RING_INT) && 1482 (old_val & DISABLE_FCP_RING_INT)) 1483 { 1484 spin_unlock_irq(&phba->hbalock); 1485 del_timer(&phba->fcp_poll_timer); 1486 spin_lock_irq(&phba->hbalock); 1487 if (lpfc_readl(phba->HCregaddr, &creg_val)) { 1488 spin_unlock_irq(&phba->hbalock); 1489 return -EINVAL; 1490 } 1491 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING); 1492 writel(creg_val, phba->HCregaddr); 1493 readl(phba->HCregaddr); /* flush */ 1494 } 1495 1496 phba->cfg_poll = val; 1497 1498 spin_unlock_irq(&phba->hbalock); 1499 1500 return strlen(buf); 1501 } 1502 1503 /** 1504 * lpfc_fips_level_show - Return the current FIPS level for the HBA 1505 * @dev: class unused variable. 1506 * @attr: device attribute, not used. 1507 * @buf: on return contains the module description text. 1508 * 1509 * Returns: size of formatted string. 1510 **/ 1511 static ssize_t 1512 lpfc_fips_level_show(struct device *dev, struct device_attribute *attr, 1513 char *buf) 1514 { 1515 struct Scsi_Host *shost = class_to_shost(dev); 1516 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1517 struct lpfc_hba *phba = vport->phba; 1518 1519 return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level); 1520 } 1521 1522 /** 1523 * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA 1524 * @dev: class unused variable. 1525 * @attr: device attribute, not used. 1526 * @buf: on return contains the module description text. 1527 * 1528 * Returns: size of formatted string. 1529 **/ 1530 static ssize_t 1531 lpfc_fips_rev_show(struct device *dev, struct device_attribute *attr, 1532 char *buf) 1533 { 1534 struct Scsi_Host *shost = class_to_shost(dev); 1535 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1536 struct lpfc_hba *phba = vport->phba; 1537 1538 return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev); 1539 } 1540 1541 /** 1542 * lpfc_dss_show - Return the current state of dss and the configured state 1543 * @dev: class converted to a Scsi_host structure. 1544 * @attr: device attribute, not used. 1545 * @buf: on return contains the formatted text. 1546 * 1547 * Returns: size of formatted string. 1548 **/ 1549 static ssize_t 1550 lpfc_dss_show(struct device *dev, struct device_attribute *attr, 1551 char *buf) 1552 { 1553 struct Scsi_Host *shost = class_to_shost(dev); 1554 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1555 struct lpfc_hba *phba = vport->phba; 1556 1557 return snprintf(buf, PAGE_SIZE, "%s - %sOperational\n", 1558 (phba->cfg_enable_dss) ? "Enabled" : "Disabled", 1559 (phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ? 1560 "" : "Not "); 1561 } 1562 1563 /** 1564 * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions 1565 * @dev: class converted to a Scsi_host structure. 1566 * @attr: device attribute, not used. 1567 * @buf: on return contains the formatted support level. 1568 * 1569 * Description: 1570 * Returns the maximum number of virtual functions a physical function can 1571 * support, 0 will be returned if called on virtual function. 1572 * 1573 * Returns: size of formatted string. 1574 **/ 1575 static ssize_t 1576 lpfc_sriov_hw_max_virtfn_show(struct device *dev, 1577 struct device_attribute *attr, 1578 char *buf) 1579 { 1580 struct Scsi_Host *shost = class_to_shost(dev); 1581 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1582 struct lpfc_hba *phba = vport->phba; 1583 uint16_t max_nr_virtfn; 1584 1585 max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba); 1586 return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn); 1587 } 1588 1589 /** 1590 * lpfc_param_show - Return a cfg attribute value in decimal 1591 * 1592 * Description: 1593 * Macro that given an attr e.g. hba_queue_depth expands 1594 * into a function with the name lpfc_hba_queue_depth_show. 1595 * 1596 * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field. 1597 * @dev: class device that is converted into a Scsi_host. 1598 * @attr: device attribute, not used. 1599 * @buf: on return contains the attribute value in decimal. 1600 * 1601 * Returns: size of formatted string. 1602 **/ 1603 #define lpfc_param_show(attr) \ 1604 static ssize_t \ 1605 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ 1606 char *buf) \ 1607 { \ 1608 struct Scsi_Host *shost = class_to_shost(dev);\ 1609 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 1610 struct lpfc_hba *phba = vport->phba;\ 1611 uint val = 0;\ 1612 val = phba->cfg_##attr;\ 1613 return snprintf(buf, PAGE_SIZE, "%d\n",\ 1614 phba->cfg_##attr);\ 1615 } 1616 1617 /** 1618 * lpfc_param_hex_show - Return a cfg attribute value in hex 1619 * 1620 * Description: 1621 * Macro that given an attr e.g. hba_queue_depth expands 1622 * into a function with the name lpfc_hba_queue_depth_show 1623 * 1624 * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field. 1625 * @dev: class device that is converted into a Scsi_host. 1626 * @attr: device attribute, not used. 1627 * @buf: on return contains the attribute value in hexadecimal. 1628 * 1629 * Returns: size of formatted string. 1630 **/ 1631 #define lpfc_param_hex_show(attr) \ 1632 static ssize_t \ 1633 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ 1634 char *buf) \ 1635 { \ 1636 struct Scsi_Host *shost = class_to_shost(dev);\ 1637 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 1638 struct lpfc_hba *phba = vport->phba;\ 1639 uint val = 0;\ 1640 val = phba->cfg_##attr;\ 1641 return snprintf(buf, PAGE_SIZE, "%#x\n",\ 1642 phba->cfg_##attr);\ 1643 } 1644 1645 /** 1646 * lpfc_param_init - Initializes a cfg attribute 1647 * 1648 * Description: 1649 * Macro that given an attr e.g. hba_queue_depth expands 1650 * into a function with the name lpfc_hba_queue_depth_init. The macro also 1651 * takes a default argument, a minimum and maximum argument. 1652 * 1653 * lpfc_##attr##_init: Initializes an attribute. 1654 * @phba: pointer the the adapter structure. 1655 * @val: integer attribute value. 1656 * 1657 * Validates the min and max values then sets the adapter config field 1658 * accordingly, or uses the default if out of range and prints an error message. 1659 * 1660 * Returns: 1661 * zero on success 1662 * -EINVAL if default used 1663 **/ 1664 #define lpfc_param_init(attr, default, minval, maxval) \ 1665 static int \ 1666 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \ 1667 { \ 1668 if (val >= minval && val <= maxval) {\ 1669 phba->cfg_##attr = val;\ 1670 return 0;\ 1671 }\ 1672 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \ 1673 "0449 lpfc_"#attr" attribute cannot be set to %d, "\ 1674 "allowed range is ["#minval", "#maxval"]\n", val); \ 1675 phba->cfg_##attr = default;\ 1676 return -EINVAL;\ 1677 } 1678 1679 /** 1680 * lpfc_param_set - Set a cfg attribute value 1681 * 1682 * Description: 1683 * Macro that given an attr e.g. hba_queue_depth expands 1684 * into a function with the name lpfc_hba_queue_depth_set 1685 * 1686 * lpfc_##attr##_set: Sets an attribute value. 1687 * @phba: pointer the the adapter structure. 1688 * @val: integer attribute value. 1689 * 1690 * Description: 1691 * Validates the min and max values then sets the 1692 * adapter config field if in the valid range. prints error message 1693 * and does not set the parameter if invalid. 1694 * 1695 * Returns: 1696 * zero on success 1697 * -EINVAL if val is invalid 1698 **/ 1699 #define lpfc_param_set(attr, default, minval, maxval) \ 1700 static int \ 1701 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \ 1702 { \ 1703 if (val >= minval && val <= maxval) {\ 1704 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \ 1705 "3052 lpfc_" #attr " changed from %d to %d\n", \ 1706 phba->cfg_##attr, val); \ 1707 phba->cfg_##attr = val;\ 1708 return 0;\ 1709 }\ 1710 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \ 1711 "0450 lpfc_"#attr" attribute cannot be set to %d, "\ 1712 "allowed range is ["#minval", "#maxval"]\n", val); \ 1713 return -EINVAL;\ 1714 } 1715 1716 /** 1717 * lpfc_param_store - Set a vport attribute value 1718 * 1719 * Description: 1720 * Macro that given an attr e.g. hba_queue_depth expands 1721 * into a function with the name lpfc_hba_queue_depth_store. 1722 * 1723 * lpfc_##attr##_store: Set an sttribute value. 1724 * @dev: class device that is converted into a Scsi_host. 1725 * @attr: device attribute, not used. 1726 * @buf: contains the attribute value in ascii. 1727 * @count: not used. 1728 * 1729 * Description: 1730 * Convert the ascii text number to an integer, then 1731 * use the lpfc_##attr##_set function to set the value. 1732 * 1733 * Returns: 1734 * -EINVAL if val is invalid or lpfc_##attr##_set() fails 1735 * length of buffer upon success. 1736 **/ 1737 #define lpfc_param_store(attr) \ 1738 static ssize_t \ 1739 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \ 1740 const char *buf, size_t count) \ 1741 { \ 1742 struct Scsi_Host *shost = class_to_shost(dev);\ 1743 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 1744 struct lpfc_hba *phba = vport->phba;\ 1745 uint val = 0;\ 1746 if (!isdigit(buf[0]))\ 1747 return -EINVAL;\ 1748 if (sscanf(buf, "%i", &val) != 1)\ 1749 return -EINVAL;\ 1750 if (lpfc_##attr##_set(phba, val) == 0) \ 1751 return strlen(buf);\ 1752 else \ 1753 return -EINVAL;\ 1754 } 1755 1756 /** 1757 * lpfc_vport_param_show - Return decimal formatted cfg attribute value 1758 * 1759 * Description: 1760 * Macro that given an attr e.g. hba_queue_depth expands 1761 * into a function with the name lpfc_hba_queue_depth_show 1762 * 1763 * lpfc_##attr##_show: prints the attribute value in decimal. 1764 * @dev: class device that is converted into a Scsi_host. 1765 * @attr: device attribute, not used. 1766 * @buf: on return contains the attribute value in decimal. 1767 * 1768 * Returns: length of formatted string. 1769 **/ 1770 #define lpfc_vport_param_show(attr) \ 1771 static ssize_t \ 1772 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ 1773 char *buf) \ 1774 { \ 1775 struct Scsi_Host *shost = class_to_shost(dev);\ 1776 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 1777 uint val = 0;\ 1778 val = vport->cfg_##attr;\ 1779 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\ 1780 } 1781 1782 /** 1783 * lpfc_vport_param_hex_show - Return hex formatted attribute value 1784 * 1785 * Description: 1786 * Macro that given an attr e.g. 1787 * hba_queue_depth expands into a function with the name 1788 * lpfc_hba_queue_depth_show 1789 * 1790 * lpfc_##attr##_show: prints the attribute value in hexadecimal. 1791 * @dev: class device that is converted into a Scsi_host. 1792 * @attr: device attribute, not used. 1793 * @buf: on return contains the attribute value in hexadecimal. 1794 * 1795 * Returns: length of formatted string. 1796 **/ 1797 #define lpfc_vport_param_hex_show(attr) \ 1798 static ssize_t \ 1799 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \ 1800 char *buf) \ 1801 { \ 1802 struct Scsi_Host *shost = class_to_shost(dev);\ 1803 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 1804 uint val = 0;\ 1805 val = vport->cfg_##attr;\ 1806 return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\ 1807 } 1808 1809 /** 1810 * lpfc_vport_param_init - Initialize a vport cfg attribute 1811 * 1812 * Description: 1813 * Macro that given an attr e.g. hba_queue_depth expands 1814 * into a function with the name lpfc_hba_queue_depth_init. The macro also 1815 * takes a default argument, a minimum and maximum argument. 1816 * 1817 * lpfc_##attr##_init: validates the min and max values then sets the 1818 * adapter config field accordingly, or uses the default if out of range 1819 * and prints an error message. 1820 * @phba: pointer the the adapter structure. 1821 * @val: integer attribute value. 1822 * 1823 * Returns: 1824 * zero on success 1825 * -EINVAL if default used 1826 **/ 1827 #define lpfc_vport_param_init(attr, default, minval, maxval) \ 1828 static int \ 1829 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \ 1830 { \ 1831 if (val >= minval && val <= maxval) {\ 1832 vport->cfg_##attr = val;\ 1833 return 0;\ 1834 }\ 1835 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \ 1836 "0423 lpfc_"#attr" attribute cannot be set to %d, "\ 1837 "allowed range is ["#minval", "#maxval"]\n", val); \ 1838 vport->cfg_##attr = default;\ 1839 return -EINVAL;\ 1840 } 1841 1842 /** 1843 * lpfc_vport_param_set - Set a vport cfg attribute 1844 * 1845 * Description: 1846 * Macro that given an attr e.g. hba_queue_depth expands 1847 * into a function with the name lpfc_hba_queue_depth_set 1848 * 1849 * lpfc_##attr##_set: validates the min and max values then sets the 1850 * adapter config field if in the valid range. prints error message 1851 * and does not set the parameter if invalid. 1852 * @phba: pointer the the adapter structure. 1853 * @val: integer attribute value. 1854 * 1855 * Returns: 1856 * zero on success 1857 * -EINVAL if val is invalid 1858 **/ 1859 #define lpfc_vport_param_set(attr, default, minval, maxval) \ 1860 static int \ 1861 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \ 1862 { \ 1863 if (val >= minval && val <= maxval) {\ 1864 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \ 1865 "3053 lpfc_" #attr " changed from %d to %d\n", \ 1866 vport->cfg_##attr, val); \ 1867 vport->cfg_##attr = val;\ 1868 return 0;\ 1869 }\ 1870 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \ 1871 "0424 lpfc_"#attr" attribute cannot be set to %d, "\ 1872 "allowed range is ["#minval", "#maxval"]\n", val); \ 1873 return -EINVAL;\ 1874 } 1875 1876 /** 1877 * lpfc_vport_param_store - Set a vport attribute 1878 * 1879 * Description: 1880 * Macro that given an attr e.g. hba_queue_depth 1881 * expands into a function with the name lpfc_hba_queue_depth_store 1882 * 1883 * lpfc_##attr##_store: convert the ascii text number to an integer, then 1884 * use the lpfc_##attr##_set function to set the value. 1885 * @cdev: class device that is converted into a Scsi_host. 1886 * @buf: contains the attribute value in decimal. 1887 * @count: not used. 1888 * 1889 * Returns: 1890 * -EINVAL if val is invalid or lpfc_##attr##_set() fails 1891 * length of buffer upon success. 1892 **/ 1893 #define lpfc_vport_param_store(attr) \ 1894 static ssize_t \ 1895 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \ 1896 const char *buf, size_t count) \ 1897 { \ 1898 struct Scsi_Host *shost = class_to_shost(dev);\ 1899 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 1900 uint val = 0;\ 1901 if (!isdigit(buf[0]))\ 1902 return -EINVAL;\ 1903 if (sscanf(buf, "%i", &val) != 1)\ 1904 return -EINVAL;\ 1905 if (lpfc_##attr##_set(vport, val) == 0) \ 1906 return strlen(buf);\ 1907 else \ 1908 return -EINVAL;\ 1909 } 1910 1911 1912 #define LPFC_ATTR(name, defval, minval, maxval, desc) \ 1913 static uint lpfc_##name = defval;\ 1914 module_param(lpfc_##name, uint, S_IRUGO);\ 1915 MODULE_PARM_DESC(lpfc_##name, desc);\ 1916 lpfc_param_init(name, defval, minval, maxval) 1917 1918 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \ 1919 static uint lpfc_##name = defval;\ 1920 module_param(lpfc_##name, uint, S_IRUGO);\ 1921 MODULE_PARM_DESC(lpfc_##name, desc);\ 1922 lpfc_param_show(name)\ 1923 lpfc_param_init(name, defval, minval, maxval)\ 1924 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 1925 1926 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \ 1927 static uint lpfc_##name = defval;\ 1928 module_param(lpfc_##name, uint, S_IRUGO);\ 1929 MODULE_PARM_DESC(lpfc_##name, desc);\ 1930 lpfc_param_show(name)\ 1931 lpfc_param_init(name, defval, minval, maxval)\ 1932 lpfc_param_set(name, defval, minval, maxval)\ 1933 lpfc_param_store(name)\ 1934 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 1935 lpfc_##name##_show, lpfc_##name##_store) 1936 1937 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \ 1938 static uint lpfc_##name = defval;\ 1939 module_param(lpfc_##name, uint, S_IRUGO);\ 1940 MODULE_PARM_DESC(lpfc_##name, desc);\ 1941 lpfc_param_hex_show(name)\ 1942 lpfc_param_init(name, defval, minval, maxval)\ 1943 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 1944 1945 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \ 1946 static uint lpfc_##name = defval;\ 1947 module_param(lpfc_##name, uint, S_IRUGO);\ 1948 MODULE_PARM_DESC(lpfc_##name, desc);\ 1949 lpfc_param_hex_show(name)\ 1950 lpfc_param_init(name, defval, minval, maxval)\ 1951 lpfc_param_set(name, defval, minval, maxval)\ 1952 lpfc_param_store(name)\ 1953 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 1954 lpfc_##name##_show, lpfc_##name##_store) 1955 1956 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \ 1957 static uint lpfc_##name = defval;\ 1958 module_param(lpfc_##name, uint, S_IRUGO);\ 1959 MODULE_PARM_DESC(lpfc_##name, desc);\ 1960 lpfc_vport_param_init(name, defval, minval, maxval) 1961 1962 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \ 1963 static uint lpfc_##name = defval;\ 1964 module_param(lpfc_##name, uint, S_IRUGO);\ 1965 MODULE_PARM_DESC(lpfc_##name, desc);\ 1966 lpfc_vport_param_show(name)\ 1967 lpfc_vport_param_init(name, defval, minval, maxval)\ 1968 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 1969 1970 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \ 1971 static uint lpfc_##name = defval;\ 1972 module_param(lpfc_##name, uint, S_IRUGO);\ 1973 MODULE_PARM_DESC(lpfc_##name, desc);\ 1974 lpfc_vport_param_show(name)\ 1975 lpfc_vport_param_init(name, defval, minval, maxval)\ 1976 lpfc_vport_param_set(name, defval, minval, maxval)\ 1977 lpfc_vport_param_store(name)\ 1978 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 1979 lpfc_##name##_show, lpfc_##name##_store) 1980 1981 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \ 1982 static uint lpfc_##name = defval;\ 1983 module_param(lpfc_##name, uint, S_IRUGO);\ 1984 MODULE_PARM_DESC(lpfc_##name, desc);\ 1985 lpfc_vport_param_hex_show(name)\ 1986 lpfc_vport_param_init(name, defval, minval, maxval)\ 1987 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 1988 1989 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \ 1990 static uint lpfc_##name = defval;\ 1991 module_param(lpfc_##name, uint, S_IRUGO);\ 1992 MODULE_PARM_DESC(lpfc_##name, desc);\ 1993 lpfc_vport_param_hex_show(name)\ 1994 lpfc_vport_param_init(name, defval, minval, maxval)\ 1995 lpfc_vport_param_set(name, defval, minval, maxval)\ 1996 lpfc_vport_param_store(name)\ 1997 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 1998 lpfc_##name##_show, lpfc_##name##_store) 1999 2000 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL); 2001 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL); 2002 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL); 2003 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL); 2004 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL); 2005 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL); 2006 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL); 2007 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL); 2008 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL); 2009 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL); 2010 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL); 2011 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL); 2012 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show, 2013 lpfc_link_state_store); 2014 static DEVICE_ATTR(option_rom_version, S_IRUGO, 2015 lpfc_option_rom_version_show, NULL); 2016 static DEVICE_ATTR(num_discovered_ports, S_IRUGO, 2017 lpfc_num_discovered_ports_show, NULL); 2018 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL); 2019 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL); 2020 static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL); 2021 static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL); 2022 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR, 2023 lpfc_board_mode_show, lpfc_board_mode_store); 2024 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset); 2025 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL); 2026 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL); 2027 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL); 2028 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL); 2029 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL); 2030 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL); 2031 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL); 2032 static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL); 2033 static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL); 2034 static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL); 2035 static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL); 2036 static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO, 2037 lpfc_sriov_hw_max_virtfn_show, NULL); 2038 static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL); 2039 2040 static char *lpfc_soft_wwn_key = "C99G71SL8032A"; 2041 2042 /** 2043 * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid 2044 * @dev: class device that is converted into a Scsi_host. 2045 * @attr: device attribute, not used. 2046 * @buf: containing the string lpfc_soft_wwn_key. 2047 * @count: must be size of lpfc_soft_wwn_key. 2048 * 2049 * Returns: 2050 * -EINVAL if the buffer does not contain lpfc_soft_wwn_key 2051 * length of buf indicates success 2052 **/ 2053 static ssize_t 2054 lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr, 2055 const char *buf, size_t count) 2056 { 2057 struct Scsi_Host *shost = class_to_shost(dev); 2058 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2059 struct lpfc_hba *phba = vport->phba; 2060 unsigned int cnt = count; 2061 2062 /* 2063 * We're doing a simple sanity check for soft_wwpn setting. 2064 * We require that the user write a specific key to enable 2065 * the soft_wwpn attribute to be settable. Once the attribute 2066 * is written, the enable key resets. If further updates are 2067 * desired, the key must be written again to re-enable the 2068 * attribute. 2069 * 2070 * The "key" is not secret - it is a hardcoded string shown 2071 * here. The intent is to protect against the random user or 2072 * application that is just writing attributes. 2073 */ 2074 2075 /* count may include a LF at end of string */ 2076 if (buf[cnt-1] == '\n') 2077 cnt--; 2078 2079 if ((cnt != strlen(lpfc_soft_wwn_key)) || 2080 (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0)) 2081 return -EINVAL; 2082 2083 phba->soft_wwn_enable = 1; 2084 return count; 2085 } 2086 static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL, 2087 lpfc_soft_wwn_enable_store); 2088 2089 /** 2090 * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter 2091 * @dev: class device that is converted into a Scsi_host. 2092 * @attr: device attribute, not used. 2093 * @buf: on return contains the wwpn in hexadecimal. 2094 * 2095 * Returns: size of formatted string. 2096 **/ 2097 static ssize_t 2098 lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr, 2099 char *buf) 2100 { 2101 struct Scsi_Host *shost = class_to_shost(dev); 2102 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2103 struct lpfc_hba *phba = vport->phba; 2104 2105 return snprintf(buf, PAGE_SIZE, "0x%llx\n", 2106 (unsigned long long)phba->cfg_soft_wwpn); 2107 } 2108 2109 /** 2110 * lpfc_soft_wwpn_store - Set the ww port name of the adapter 2111 * @dev class device that is converted into a Scsi_host. 2112 * @attr: device attribute, not used. 2113 * @buf: contains the wwpn in hexadecimal. 2114 * @count: number of wwpn bytes in buf 2115 * 2116 * Returns: 2117 * -EACCES hba reset not enabled, adapter over temp 2118 * -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid 2119 * -EIO error taking adapter offline or online 2120 * value of count on success 2121 **/ 2122 static ssize_t 2123 lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr, 2124 const char *buf, size_t count) 2125 { 2126 struct Scsi_Host *shost = class_to_shost(dev); 2127 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2128 struct lpfc_hba *phba = vport->phba; 2129 struct completion online_compl; 2130 int stat1=0, stat2=0; 2131 unsigned int i, j, cnt=count; 2132 u8 wwpn[8]; 2133 int rc; 2134 2135 if (!phba->cfg_enable_hba_reset) 2136 return -EACCES; 2137 spin_lock_irq(&phba->hbalock); 2138 if (phba->over_temp_state == HBA_OVER_TEMP) { 2139 spin_unlock_irq(&phba->hbalock); 2140 return -EACCES; 2141 } 2142 spin_unlock_irq(&phba->hbalock); 2143 /* count may include a LF at end of string */ 2144 if (buf[cnt-1] == '\n') 2145 cnt--; 2146 2147 if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) || 2148 ((cnt == 17) && (*buf++ != 'x')) || 2149 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x')))) 2150 return -EINVAL; 2151 2152 phba->soft_wwn_enable = 0; 2153 2154 memset(wwpn, 0, sizeof(wwpn)); 2155 2156 /* Validate and store the new name */ 2157 for (i=0, j=0; i < 16; i++) { 2158 int value; 2159 2160 value = hex_to_bin(*buf++); 2161 if (value >= 0) 2162 j = (j << 4) | value; 2163 else 2164 return -EINVAL; 2165 if (i % 2) { 2166 wwpn[i/2] = j & 0xff; 2167 j = 0; 2168 } 2169 } 2170 phba->cfg_soft_wwpn = wwn_to_u64(wwpn); 2171 fc_host_port_name(shost) = phba->cfg_soft_wwpn; 2172 if (phba->cfg_soft_wwnn) 2173 fc_host_node_name(shost) = phba->cfg_soft_wwnn; 2174 2175 dev_printk(KERN_NOTICE, &phba->pcidev->dev, 2176 "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no); 2177 2178 stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); 2179 if (stat1) 2180 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 2181 "0463 lpfc_soft_wwpn attribute set failed to " 2182 "reinit adapter - %d\n", stat1); 2183 init_completion(&online_compl); 2184 rc = lpfc_workq_post_event(phba, &stat2, &online_compl, 2185 LPFC_EVT_ONLINE); 2186 if (rc == 0) 2187 return -ENOMEM; 2188 2189 wait_for_completion(&online_compl); 2190 if (stat2) 2191 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 2192 "0464 lpfc_soft_wwpn attribute set failed to " 2193 "reinit adapter - %d\n", stat2); 2194 return (stat1 || stat2) ? -EIO : count; 2195 } 2196 static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\ 2197 lpfc_soft_wwpn_show, lpfc_soft_wwpn_store); 2198 2199 /** 2200 * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter 2201 * @dev: class device that is converted into a Scsi_host. 2202 * @attr: device attribute, not used. 2203 * @buf: on return contains the wwnn in hexadecimal. 2204 * 2205 * Returns: size of formatted string. 2206 **/ 2207 static ssize_t 2208 lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr, 2209 char *buf) 2210 { 2211 struct Scsi_Host *shost = class_to_shost(dev); 2212 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 2213 return snprintf(buf, PAGE_SIZE, "0x%llx\n", 2214 (unsigned long long)phba->cfg_soft_wwnn); 2215 } 2216 2217 /** 2218 * lpfc_soft_wwnn_store - sets the ww node name of the adapter 2219 * @cdev: class device that is converted into a Scsi_host. 2220 * @buf: contains the ww node name in hexadecimal. 2221 * @count: number of wwnn bytes in buf. 2222 * 2223 * Returns: 2224 * -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid 2225 * value of count on success 2226 **/ 2227 static ssize_t 2228 lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr, 2229 const char *buf, size_t count) 2230 { 2231 struct Scsi_Host *shost = class_to_shost(dev); 2232 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 2233 unsigned int i, j, cnt=count; 2234 u8 wwnn[8]; 2235 2236 /* count may include a LF at end of string */ 2237 if (buf[cnt-1] == '\n') 2238 cnt--; 2239 2240 if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) || 2241 ((cnt == 17) && (*buf++ != 'x')) || 2242 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x')))) 2243 return -EINVAL; 2244 2245 /* 2246 * Allow wwnn to be set many times, as long as the enable is set. 2247 * However, once the wwpn is set, everything locks. 2248 */ 2249 2250 memset(wwnn, 0, sizeof(wwnn)); 2251 2252 /* Validate and store the new name */ 2253 for (i=0, j=0; i < 16; i++) { 2254 int value; 2255 2256 value = hex_to_bin(*buf++); 2257 if (value >= 0) 2258 j = (j << 4) | value; 2259 else 2260 return -EINVAL; 2261 if (i % 2) { 2262 wwnn[i/2] = j & 0xff; 2263 j = 0; 2264 } 2265 } 2266 phba->cfg_soft_wwnn = wwn_to_u64(wwnn); 2267 2268 dev_printk(KERN_NOTICE, &phba->pcidev->dev, 2269 "lpfc%d: soft_wwnn set. Value will take effect upon " 2270 "setting of the soft_wwpn\n", phba->brd_no); 2271 2272 return count; 2273 } 2274 static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\ 2275 lpfc_soft_wwnn_show, lpfc_soft_wwnn_store); 2276 2277 2278 static int lpfc_poll = 0; 2279 module_param(lpfc_poll, int, S_IRUGO); 2280 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:" 2281 " 0 - none," 2282 " 1 - poll with interrupts enabled" 2283 " 3 - poll and disable FCP ring interrupts"); 2284 2285 static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR, 2286 lpfc_poll_show, lpfc_poll_store); 2287 2288 int lpfc_sli_mode = 0; 2289 module_param(lpfc_sli_mode, int, S_IRUGO); 2290 MODULE_PARM_DESC(lpfc_sli_mode, "SLI mode selector:" 2291 " 0 - auto (SLI-3 if supported)," 2292 " 2 - select SLI-2 even on SLI-3 capable HBAs," 2293 " 3 - select SLI-3"); 2294 2295 int lpfc_enable_npiv = 1; 2296 module_param(lpfc_enable_npiv, int, S_IRUGO); 2297 MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality"); 2298 lpfc_param_show(enable_npiv); 2299 lpfc_param_init(enable_npiv, 1, 0, 1); 2300 static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL); 2301 2302 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2, 2303 "FCF Fast failover=1 Priority failover=2"); 2304 2305 int lpfc_enable_rrq; 2306 module_param(lpfc_enable_rrq, int, S_IRUGO); 2307 MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality"); 2308 lpfc_param_show(enable_rrq); 2309 lpfc_param_init(enable_rrq, 0, 0, 1); 2310 static DEVICE_ATTR(lpfc_enable_rrq, S_IRUGO, lpfc_enable_rrq_show, NULL); 2311 2312 /* 2313 # lpfc_suppress_link_up: Bring link up at initialization 2314 # 0x0 = bring link up (issue MBX_INIT_LINK) 2315 # 0x1 = do NOT bring link up at initialization(MBX_INIT_LINK) 2316 # 0x2 = never bring up link 2317 # Default value is 0. 2318 */ 2319 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK, 2320 LPFC_DELAY_INIT_LINK_INDEFINITELY, 2321 "Suppress Link Up at initialization"); 2322 /* 2323 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS 2324 # 1 - (1024) 2325 # 2 - (2048) 2326 # 3 - (3072) 2327 # 4 - (4096) 2328 # 5 - (5120) 2329 */ 2330 static ssize_t 2331 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf) 2332 { 2333 struct Scsi_Host *shost = class_to_shost(dev); 2334 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; 2335 2336 return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max); 2337 } 2338 2339 static DEVICE_ATTR(iocb_hw, S_IRUGO, 2340 lpfc_iocb_hw_show, NULL); 2341 static ssize_t 2342 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf) 2343 { 2344 struct Scsi_Host *shost = class_to_shost(dev); 2345 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; 2346 2347 return snprintf(buf, PAGE_SIZE, "%d\n", 2348 phba->sli.ring[LPFC_ELS_RING].txq_max); 2349 } 2350 2351 static DEVICE_ATTR(txq_hw, S_IRUGO, 2352 lpfc_txq_hw_show, NULL); 2353 static ssize_t 2354 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr, 2355 char *buf) 2356 { 2357 struct Scsi_Host *shost = class_to_shost(dev); 2358 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; 2359 2360 return snprintf(buf, PAGE_SIZE, "%d\n", 2361 phba->sli.ring[LPFC_ELS_RING].txcmplq_max); 2362 } 2363 2364 static DEVICE_ATTR(txcmplq_hw, S_IRUGO, 2365 lpfc_txcmplq_hw_show, NULL); 2366 2367 int lpfc_iocb_cnt = 2; 2368 module_param(lpfc_iocb_cnt, int, S_IRUGO); 2369 MODULE_PARM_DESC(lpfc_iocb_cnt, 2370 "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs"); 2371 lpfc_param_show(iocb_cnt); 2372 lpfc_param_init(iocb_cnt, 2, 1, 5); 2373 static DEVICE_ATTR(lpfc_iocb_cnt, S_IRUGO, 2374 lpfc_iocb_cnt_show, NULL); 2375 2376 /* 2377 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear 2378 # until the timer expires. Value range is [0,255]. Default value is 30. 2379 */ 2380 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO; 2381 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO; 2382 module_param(lpfc_nodev_tmo, int, 0); 2383 MODULE_PARM_DESC(lpfc_nodev_tmo, 2384 "Seconds driver will hold I/O waiting " 2385 "for a device to come back"); 2386 2387 /** 2388 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value 2389 * @dev: class converted to a Scsi_host structure. 2390 * @attr: device attribute, not used. 2391 * @buf: on return contains the dev loss timeout in decimal. 2392 * 2393 * Returns: size of formatted string. 2394 **/ 2395 static ssize_t 2396 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr, 2397 char *buf) 2398 { 2399 struct Scsi_Host *shost = class_to_shost(dev); 2400 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2401 2402 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo); 2403 } 2404 2405 /** 2406 * lpfc_nodev_tmo_init - Set the hba nodev timeout value 2407 * @vport: lpfc vport structure pointer. 2408 * @val: contains the nodev timeout value. 2409 * 2410 * Description: 2411 * If the devloss tmo is already set then nodev tmo is set to devloss tmo, 2412 * a kernel error message is printed and zero is returned. 2413 * Else if val is in range then nodev tmo and devloss tmo are set to val. 2414 * Otherwise nodev tmo is set to the default value. 2415 * 2416 * Returns: 2417 * zero if already set or if val is in range 2418 * -EINVAL val out of range 2419 **/ 2420 static int 2421 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val) 2422 { 2423 if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) { 2424 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo; 2425 if (val != LPFC_DEF_DEVLOSS_TMO) 2426 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2427 "0407 Ignoring nodev_tmo module " 2428 "parameter because devloss_tmo is " 2429 "set.\n"); 2430 return 0; 2431 } 2432 2433 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 2434 vport->cfg_nodev_tmo = val; 2435 vport->cfg_devloss_tmo = val; 2436 return 0; 2437 } 2438 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2439 "0400 lpfc_nodev_tmo attribute cannot be set to" 2440 " %d, allowed range is [%d, %d]\n", 2441 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 2442 vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO; 2443 return -EINVAL; 2444 } 2445 2446 /** 2447 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value 2448 * @vport: lpfc vport structure pointer. 2449 * 2450 * Description: 2451 * Update all the ndlp's dev loss tmo with the vport devloss tmo value. 2452 **/ 2453 static void 2454 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport) 2455 { 2456 struct Scsi_Host *shost; 2457 struct lpfc_nodelist *ndlp; 2458 2459 shost = lpfc_shost_from_vport(vport); 2460 spin_lock_irq(shost->host_lock); 2461 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) 2462 if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport) 2463 ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo; 2464 spin_unlock_irq(shost->host_lock); 2465 } 2466 2467 /** 2468 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values 2469 * @vport: lpfc vport structure pointer. 2470 * @val: contains the tmo value. 2471 * 2472 * Description: 2473 * If the devloss tmo is already set or the vport dev loss tmo has changed 2474 * then a kernel error message is printed and zero is returned. 2475 * Else if val is in range then nodev tmo and devloss tmo are set to val. 2476 * Otherwise nodev tmo is set to the default value. 2477 * 2478 * Returns: 2479 * zero if already set or if val is in range 2480 * -EINVAL val out of range 2481 **/ 2482 static int 2483 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val) 2484 { 2485 if (vport->dev_loss_tmo_changed || 2486 (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) { 2487 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2488 "0401 Ignoring change to nodev_tmo " 2489 "because devloss_tmo is set.\n"); 2490 return 0; 2491 } 2492 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 2493 vport->cfg_nodev_tmo = val; 2494 vport->cfg_devloss_tmo = val; 2495 /* 2496 * For compat: set the fc_host dev loss so new rports 2497 * will get the value. 2498 */ 2499 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val; 2500 lpfc_update_rport_devloss_tmo(vport); 2501 return 0; 2502 } 2503 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2504 "0403 lpfc_nodev_tmo attribute cannot be set to" 2505 "%d, allowed range is [%d, %d]\n", 2506 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 2507 return -EINVAL; 2508 } 2509 2510 lpfc_vport_param_store(nodev_tmo) 2511 2512 static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR, 2513 lpfc_nodev_tmo_show, lpfc_nodev_tmo_store); 2514 2515 /* 2516 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that 2517 # disappear until the timer expires. Value range is [0,255]. Default 2518 # value is 30. 2519 */ 2520 module_param(lpfc_devloss_tmo, int, S_IRUGO); 2521 MODULE_PARM_DESC(lpfc_devloss_tmo, 2522 "Seconds driver will hold I/O waiting " 2523 "for a device to come back"); 2524 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO, 2525 LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO) 2526 lpfc_vport_param_show(devloss_tmo) 2527 2528 /** 2529 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit 2530 * @vport: lpfc vport structure pointer. 2531 * @val: contains the tmo value. 2532 * 2533 * Description: 2534 * If val is in a valid range then set the vport nodev tmo, 2535 * devloss tmo, also set the vport dev loss tmo changed flag. 2536 * Else a kernel error message is printed. 2537 * 2538 * Returns: 2539 * zero if val is in range 2540 * -EINVAL val out of range 2541 **/ 2542 static int 2543 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val) 2544 { 2545 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 2546 vport->cfg_nodev_tmo = val; 2547 vport->cfg_devloss_tmo = val; 2548 vport->dev_loss_tmo_changed = 1; 2549 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val; 2550 lpfc_update_rport_devloss_tmo(vport); 2551 return 0; 2552 } 2553 2554 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2555 "0404 lpfc_devloss_tmo attribute cannot be set to" 2556 " %d, allowed range is [%d, %d]\n", 2557 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 2558 return -EINVAL; 2559 } 2560 2561 lpfc_vport_param_store(devloss_tmo) 2562 static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR, 2563 lpfc_devloss_tmo_show, lpfc_devloss_tmo_store); 2564 2565 /* 2566 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being 2567 # deluged with LOTS of information. 2568 # You can set a bit mask to record specific types of verbose messages: 2569 # See lpfc_logmsh.h for definitions. 2570 */ 2571 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff, 2572 "Verbose logging bit-mask"); 2573 2574 /* 2575 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters 2576 # objects that have been registered with the nameserver after login. 2577 */ 2578 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1, 2579 "Deregister nameserver objects before LOGO"); 2580 2581 /* 2582 # lun_queue_depth: This parameter is used to limit the number of outstanding 2583 # commands per FCP LUN. Value range is [1,128]. Default value is 30. 2584 */ 2585 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128, 2586 "Max number of FCP commands we can queue to a specific LUN"); 2587 2588 /* 2589 # tgt_queue_depth: This parameter is used to limit the number of outstanding 2590 # commands per target port. Value range is [10,65535]. Default value is 65535. 2591 */ 2592 LPFC_VPORT_ATTR_R(tgt_queue_depth, 65535, 10, 65535, 2593 "Max number of FCP commands we can queue to a specific target port"); 2594 2595 /* 2596 # hba_queue_depth: This parameter is used to limit the number of outstanding 2597 # commands per lpfc HBA. Value range is [32,8192]. If this parameter 2598 # value is greater than the maximum number of exchanges supported by the HBA, 2599 # then maximum number of exchanges supported by the HBA is used to determine 2600 # the hba_queue_depth. 2601 */ 2602 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192, 2603 "Max number of FCP commands we can queue to a lpfc HBA"); 2604 2605 /* 2606 # peer_port_login: This parameter allows/prevents logins 2607 # between peer ports hosted on the same physical port. 2608 # When this parameter is set 0 peer ports of same physical port 2609 # are not allowed to login to each other. 2610 # When this parameter is set 1 peer ports of same physical port 2611 # are allowed to login to each other. 2612 # Default value of this parameter is 0. 2613 */ 2614 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1, 2615 "Allow peer ports on the same physical port to login to each " 2616 "other."); 2617 2618 /* 2619 # restrict_login: This parameter allows/prevents logins 2620 # between Virtual Ports and remote initiators. 2621 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from 2622 # other initiators and will attempt to PLOGI all remote ports. 2623 # When this parameter is set (1) Virtual Ports will reject PLOGIs from 2624 # remote ports and will not attempt to PLOGI to other initiators. 2625 # This parameter does not restrict to the physical port. 2626 # This parameter does not restrict logins to Fabric resident remote ports. 2627 # Default value of this parameter is 1. 2628 */ 2629 static int lpfc_restrict_login = 1; 2630 module_param(lpfc_restrict_login, int, S_IRUGO); 2631 MODULE_PARM_DESC(lpfc_restrict_login, 2632 "Restrict virtual ports login to remote initiators."); 2633 lpfc_vport_param_show(restrict_login); 2634 2635 /** 2636 * lpfc_restrict_login_init - Set the vport restrict login flag 2637 * @vport: lpfc vport structure pointer. 2638 * @val: contains the restrict login value. 2639 * 2640 * Description: 2641 * If val is not in a valid range then log a kernel error message and set 2642 * the vport restrict login to one. 2643 * If the port type is physical clear the restrict login flag and return. 2644 * Else set the restrict login flag to val. 2645 * 2646 * Returns: 2647 * zero if val is in range 2648 * -EINVAL val out of range 2649 **/ 2650 static int 2651 lpfc_restrict_login_init(struct lpfc_vport *vport, int val) 2652 { 2653 if (val < 0 || val > 1) { 2654 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2655 "0422 lpfc_restrict_login attribute cannot " 2656 "be set to %d, allowed range is [0, 1]\n", 2657 val); 2658 vport->cfg_restrict_login = 1; 2659 return -EINVAL; 2660 } 2661 if (vport->port_type == LPFC_PHYSICAL_PORT) { 2662 vport->cfg_restrict_login = 0; 2663 return 0; 2664 } 2665 vport->cfg_restrict_login = val; 2666 return 0; 2667 } 2668 2669 /** 2670 * lpfc_restrict_login_set - Set the vport restrict login flag 2671 * @vport: lpfc vport structure pointer. 2672 * @val: contains the restrict login value. 2673 * 2674 * Description: 2675 * If val is not in a valid range then log a kernel error message and set 2676 * the vport restrict login to one. 2677 * If the port type is physical and the val is not zero log a kernel 2678 * error message, clear the restrict login flag and return zero. 2679 * Else set the restrict login flag to val. 2680 * 2681 * Returns: 2682 * zero if val is in range 2683 * -EINVAL val out of range 2684 **/ 2685 static int 2686 lpfc_restrict_login_set(struct lpfc_vport *vport, int val) 2687 { 2688 if (val < 0 || val > 1) { 2689 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2690 "0425 lpfc_restrict_login attribute cannot " 2691 "be set to %d, allowed range is [0, 1]\n", 2692 val); 2693 vport->cfg_restrict_login = 1; 2694 return -EINVAL; 2695 } 2696 if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) { 2697 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2698 "0468 lpfc_restrict_login must be 0 for " 2699 "Physical ports.\n"); 2700 vport->cfg_restrict_login = 0; 2701 return 0; 2702 } 2703 vport->cfg_restrict_login = val; 2704 return 0; 2705 } 2706 lpfc_vport_param_store(restrict_login); 2707 static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR, 2708 lpfc_restrict_login_show, lpfc_restrict_login_store); 2709 2710 /* 2711 # Some disk devices have a "select ID" or "select Target" capability. 2712 # From a protocol standpoint "select ID" usually means select the 2713 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative 2714 # annex" which contains a table that maps a "select ID" (a number 2715 # between 0 and 7F) to an ALPA. By default, for compatibility with 2716 # older drivers, the lpfc driver scans this table from low ALPA to high 2717 # ALPA. 2718 # 2719 # Turning on the scan-down variable (on = 1, off = 0) will 2720 # cause the lpfc driver to use an inverted table, effectively 2721 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1. 2722 # 2723 # (Note: This "select ID" functionality is a LOOP ONLY characteristic 2724 # and will not work across a fabric. Also this parameter will take 2725 # effect only in the case when ALPA map is not available.) 2726 */ 2727 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1, 2728 "Start scanning for devices from highest ALPA to lowest"); 2729 2730 /* 2731 # lpfc_topology: link topology for init link 2732 # 0x0 = attempt loop mode then point-to-point 2733 # 0x01 = internal loopback mode 2734 # 0x02 = attempt point-to-point mode only 2735 # 0x04 = attempt loop mode only 2736 # 0x06 = attempt point-to-point mode then loop 2737 # Set point-to-point mode if you want to run as an N_Port. 2738 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6]. 2739 # Default value is 0. 2740 */ 2741 2742 /** 2743 * lpfc_topology_set - Set the adapters topology field 2744 * @phba: lpfc_hba pointer. 2745 * @val: topology value. 2746 * 2747 * Description: 2748 * If val is in a valid range then set the adapter's topology field and 2749 * issue a lip; if the lip fails reset the topology to the old value. 2750 * 2751 * If the value is not in range log a kernel error message and return an error. 2752 * 2753 * Returns: 2754 * zero if val is in range and lip okay 2755 * non-zero return value from lpfc_issue_lip() 2756 * -EINVAL val out of range 2757 **/ 2758 static ssize_t 2759 lpfc_topology_store(struct device *dev, struct device_attribute *attr, 2760 const char *buf, size_t count) 2761 { 2762 struct Scsi_Host *shost = class_to_shost(dev); 2763 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2764 struct lpfc_hba *phba = vport->phba; 2765 int val = 0; 2766 int nolip = 0; 2767 const char *val_buf = buf; 2768 int err; 2769 uint32_t prev_val; 2770 2771 if (!strncmp(buf, "nolip ", strlen("nolip "))) { 2772 nolip = 1; 2773 val_buf = &buf[strlen("nolip ")]; 2774 } 2775 2776 if (!isdigit(val_buf[0])) 2777 return -EINVAL; 2778 if (sscanf(val_buf, "%i", &val) != 1) 2779 return -EINVAL; 2780 2781 if (val >= 0 && val <= 6) { 2782 prev_val = phba->cfg_topology; 2783 phba->cfg_topology = val; 2784 if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G && 2785 val == 4) { 2786 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2787 "3113 Loop mode not supported at speed %d\n", 2788 phba->cfg_link_speed); 2789 phba->cfg_topology = prev_val; 2790 return -EINVAL; 2791 } 2792 if (nolip) 2793 return strlen(buf); 2794 2795 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 2796 "3054 lpfc_topology changed from %d to %d\n", 2797 prev_val, val); 2798 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport)); 2799 if (err) { 2800 phba->cfg_topology = prev_val; 2801 return -EINVAL; 2802 } else 2803 return strlen(buf); 2804 } 2805 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 2806 "%d:0467 lpfc_topology attribute cannot be set to %d, " 2807 "allowed range is [0, 6]\n", 2808 phba->brd_no, val); 2809 return -EINVAL; 2810 } 2811 static int lpfc_topology = 0; 2812 module_param(lpfc_topology, int, S_IRUGO); 2813 MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology"); 2814 lpfc_param_show(topology) 2815 lpfc_param_init(topology, 0, 0, 6) 2816 static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR, 2817 lpfc_topology_show, lpfc_topology_store); 2818 2819 /** 2820 * lpfc_static_vport_show: Read callback function for 2821 * lpfc_static_vport sysfs file. 2822 * @dev: Pointer to class device object. 2823 * @attr: device attribute structure. 2824 * @buf: Data buffer. 2825 * 2826 * This function is the read call back function for 2827 * lpfc_static_vport sysfs file. The lpfc_static_vport 2828 * sysfs file report the mageability of the vport. 2829 **/ 2830 static ssize_t 2831 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr, 2832 char *buf) 2833 { 2834 struct Scsi_Host *shost = class_to_shost(dev); 2835 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2836 if (vport->vport_flag & STATIC_VPORT) 2837 sprintf(buf, "1\n"); 2838 else 2839 sprintf(buf, "0\n"); 2840 2841 return strlen(buf); 2842 } 2843 2844 /* 2845 * Sysfs attribute to control the statistical data collection. 2846 */ 2847 static DEVICE_ATTR(lpfc_static_vport, S_IRUGO, 2848 lpfc_static_vport_show, NULL); 2849 2850 /** 2851 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file 2852 * @dev: Pointer to class device. 2853 * @buf: Data buffer. 2854 * @count: Size of the data buffer. 2855 * 2856 * This function get called when an user write to the lpfc_stat_data_ctrl 2857 * sysfs file. This function parse the command written to the sysfs file 2858 * and take appropriate action. These commands are used for controlling 2859 * driver statistical data collection. 2860 * Following are the command this function handles. 2861 * 2862 * setbucket <bucket_type> <base> <step> 2863 * = Set the latency buckets. 2864 * destroybucket = destroy all the buckets. 2865 * start = start data collection 2866 * stop = stop data collection 2867 * reset = reset the collected data 2868 **/ 2869 static ssize_t 2870 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr, 2871 const char *buf, size_t count) 2872 { 2873 struct Scsi_Host *shost = class_to_shost(dev); 2874 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2875 struct lpfc_hba *phba = vport->phba; 2876 #define LPFC_MAX_DATA_CTRL_LEN 1024 2877 static char bucket_data[LPFC_MAX_DATA_CTRL_LEN]; 2878 unsigned long i; 2879 char *str_ptr, *token; 2880 struct lpfc_vport **vports; 2881 struct Scsi_Host *v_shost; 2882 char *bucket_type_str, *base_str, *step_str; 2883 unsigned long base, step, bucket_type; 2884 2885 if (!strncmp(buf, "setbucket", strlen("setbucket"))) { 2886 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1)) 2887 return -EINVAL; 2888 2889 strcpy(bucket_data, buf); 2890 str_ptr = &bucket_data[0]; 2891 /* Ignore this token - this is command token */ 2892 token = strsep(&str_ptr, "\t "); 2893 if (!token) 2894 return -EINVAL; 2895 2896 bucket_type_str = strsep(&str_ptr, "\t "); 2897 if (!bucket_type_str) 2898 return -EINVAL; 2899 2900 if (!strncmp(bucket_type_str, "linear", strlen("linear"))) 2901 bucket_type = LPFC_LINEAR_BUCKET; 2902 else if (!strncmp(bucket_type_str, "power2", strlen("power2"))) 2903 bucket_type = LPFC_POWER2_BUCKET; 2904 else 2905 return -EINVAL; 2906 2907 base_str = strsep(&str_ptr, "\t "); 2908 if (!base_str) 2909 return -EINVAL; 2910 base = simple_strtoul(base_str, NULL, 0); 2911 2912 step_str = strsep(&str_ptr, "\t "); 2913 if (!step_str) 2914 return -EINVAL; 2915 step = simple_strtoul(step_str, NULL, 0); 2916 if (!step) 2917 return -EINVAL; 2918 2919 /* Block the data collection for every vport */ 2920 vports = lpfc_create_vport_work_array(phba); 2921 if (vports == NULL) 2922 return -ENOMEM; 2923 2924 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 2925 v_shost = lpfc_shost_from_vport(vports[i]); 2926 spin_lock_irq(v_shost->host_lock); 2927 /* Block and reset data collection */ 2928 vports[i]->stat_data_blocked = 1; 2929 if (vports[i]->stat_data_enabled) 2930 lpfc_vport_reset_stat_data(vports[i]); 2931 spin_unlock_irq(v_shost->host_lock); 2932 } 2933 2934 /* Set the bucket attributes */ 2935 phba->bucket_type = bucket_type; 2936 phba->bucket_base = base; 2937 phba->bucket_step = step; 2938 2939 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 2940 v_shost = lpfc_shost_from_vport(vports[i]); 2941 2942 /* Unblock data collection */ 2943 spin_lock_irq(v_shost->host_lock); 2944 vports[i]->stat_data_blocked = 0; 2945 spin_unlock_irq(v_shost->host_lock); 2946 } 2947 lpfc_destroy_vport_work_array(phba, vports); 2948 return strlen(buf); 2949 } 2950 2951 if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) { 2952 vports = lpfc_create_vport_work_array(phba); 2953 if (vports == NULL) 2954 return -ENOMEM; 2955 2956 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 2957 v_shost = lpfc_shost_from_vport(vports[i]); 2958 spin_lock_irq(shost->host_lock); 2959 vports[i]->stat_data_blocked = 1; 2960 lpfc_free_bucket(vport); 2961 vport->stat_data_enabled = 0; 2962 vports[i]->stat_data_blocked = 0; 2963 spin_unlock_irq(shost->host_lock); 2964 } 2965 lpfc_destroy_vport_work_array(phba, vports); 2966 phba->bucket_type = LPFC_NO_BUCKET; 2967 phba->bucket_base = 0; 2968 phba->bucket_step = 0; 2969 return strlen(buf); 2970 } 2971 2972 if (!strncmp(buf, "start", strlen("start"))) { 2973 /* If no buckets configured return error */ 2974 if (phba->bucket_type == LPFC_NO_BUCKET) 2975 return -EINVAL; 2976 spin_lock_irq(shost->host_lock); 2977 if (vport->stat_data_enabled) { 2978 spin_unlock_irq(shost->host_lock); 2979 return strlen(buf); 2980 } 2981 lpfc_alloc_bucket(vport); 2982 vport->stat_data_enabled = 1; 2983 spin_unlock_irq(shost->host_lock); 2984 return strlen(buf); 2985 } 2986 2987 if (!strncmp(buf, "stop", strlen("stop"))) { 2988 spin_lock_irq(shost->host_lock); 2989 if (vport->stat_data_enabled == 0) { 2990 spin_unlock_irq(shost->host_lock); 2991 return strlen(buf); 2992 } 2993 lpfc_free_bucket(vport); 2994 vport->stat_data_enabled = 0; 2995 spin_unlock_irq(shost->host_lock); 2996 return strlen(buf); 2997 } 2998 2999 if (!strncmp(buf, "reset", strlen("reset"))) { 3000 if ((phba->bucket_type == LPFC_NO_BUCKET) 3001 || !vport->stat_data_enabled) 3002 return strlen(buf); 3003 spin_lock_irq(shost->host_lock); 3004 vport->stat_data_blocked = 1; 3005 lpfc_vport_reset_stat_data(vport); 3006 vport->stat_data_blocked = 0; 3007 spin_unlock_irq(shost->host_lock); 3008 return strlen(buf); 3009 } 3010 return -EINVAL; 3011 } 3012 3013 3014 /** 3015 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file 3016 * @dev: Pointer to class device object. 3017 * @buf: Data buffer. 3018 * 3019 * This function is the read call back function for 3020 * lpfc_stat_data_ctrl sysfs file. This function report the 3021 * current statistical data collection state. 3022 **/ 3023 static ssize_t 3024 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr, 3025 char *buf) 3026 { 3027 struct Scsi_Host *shost = class_to_shost(dev); 3028 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3029 struct lpfc_hba *phba = vport->phba; 3030 int index = 0; 3031 int i; 3032 char *bucket_type; 3033 unsigned long bucket_value; 3034 3035 switch (phba->bucket_type) { 3036 case LPFC_LINEAR_BUCKET: 3037 bucket_type = "linear"; 3038 break; 3039 case LPFC_POWER2_BUCKET: 3040 bucket_type = "power2"; 3041 break; 3042 default: 3043 bucket_type = "No Bucket"; 3044 break; 3045 } 3046 3047 sprintf(&buf[index], "Statistical Data enabled :%d, " 3048 "blocked :%d, Bucket type :%s, Bucket base :%d," 3049 " Bucket step :%d\nLatency Ranges :", 3050 vport->stat_data_enabled, vport->stat_data_blocked, 3051 bucket_type, phba->bucket_base, phba->bucket_step); 3052 index = strlen(buf); 3053 if (phba->bucket_type != LPFC_NO_BUCKET) { 3054 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) { 3055 if (phba->bucket_type == LPFC_LINEAR_BUCKET) 3056 bucket_value = phba->bucket_base + 3057 phba->bucket_step * i; 3058 else 3059 bucket_value = phba->bucket_base + 3060 (1 << i) * phba->bucket_step; 3061 3062 if (index + 10 > PAGE_SIZE) 3063 break; 3064 sprintf(&buf[index], "%08ld ", bucket_value); 3065 index = strlen(buf); 3066 } 3067 } 3068 sprintf(&buf[index], "\n"); 3069 return strlen(buf); 3070 } 3071 3072 /* 3073 * Sysfs attribute to control the statistical data collection. 3074 */ 3075 static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR, 3076 lpfc_stat_data_ctrl_show, lpfc_stat_data_ctrl_store); 3077 3078 /* 3079 * lpfc_drvr_stat_data: sysfs attr to get driver statistical data. 3080 */ 3081 3082 /* 3083 * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN 3084 * for each target. 3085 */ 3086 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18) 3087 #define MAX_STAT_DATA_SIZE_PER_TARGET \ 3088 STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT) 3089 3090 3091 /** 3092 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute 3093 * @filp: sysfs file 3094 * @kobj: Pointer to the kernel object 3095 * @bin_attr: Attribute object 3096 * @buff: Buffer pointer 3097 * @off: File offset 3098 * @count: Buffer size 3099 * 3100 * This function is the read call back function for lpfc_drvr_stat_data 3101 * sysfs file. This function export the statistical data to user 3102 * applications. 3103 **/ 3104 static ssize_t 3105 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj, 3106 struct bin_attribute *bin_attr, 3107 char *buf, loff_t off, size_t count) 3108 { 3109 struct device *dev = container_of(kobj, struct device, 3110 kobj); 3111 struct Scsi_Host *shost = class_to_shost(dev); 3112 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3113 struct lpfc_hba *phba = vport->phba; 3114 int i = 0, index = 0; 3115 unsigned long nport_index; 3116 struct lpfc_nodelist *ndlp = NULL; 3117 nport_index = (unsigned long)off / 3118 MAX_STAT_DATA_SIZE_PER_TARGET; 3119 3120 if (!vport->stat_data_enabled || vport->stat_data_blocked 3121 || (phba->bucket_type == LPFC_NO_BUCKET)) 3122 return 0; 3123 3124 spin_lock_irq(shost->host_lock); 3125 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 3126 if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data) 3127 continue; 3128 3129 if (nport_index > 0) { 3130 nport_index--; 3131 continue; 3132 } 3133 3134 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET) 3135 > count) 3136 break; 3137 3138 if (!ndlp->lat_data) 3139 continue; 3140 3141 /* Print the WWN */ 3142 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:", 3143 ndlp->nlp_portname.u.wwn[0], 3144 ndlp->nlp_portname.u.wwn[1], 3145 ndlp->nlp_portname.u.wwn[2], 3146 ndlp->nlp_portname.u.wwn[3], 3147 ndlp->nlp_portname.u.wwn[4], 3148 ndlp->nlp_portname.u.wwn[5], 3149 ndlp->nlp_portname.u.wwn[6], 3150 ndlp->nlp_portname.u.wwn[7]); 3151 3152 index = strlen(buf); 3153 3154 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) { 3155 sprintf(&buf[index], "%010u,", 3156 ndlp->lat_data[i].cmd_count); 3157 index = strlen(buf); 3158 } 3159 sprintf(&buf[index], "\n"); 3160 index = strlen(buf); 3161 } 3162 spin_unlock_irq(shost->host_lock); 3163 return index; 3164 } 3165 3166 static struct bin_attribute sysfs_drvr_stat_data_attr = { 3167 .attr = { 3168 .name = "lpfc_drvr_stat_data", 3169 .mode = S_IRUSR, 3170 }, 3171 .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET, 3172 .read = sysfs_drvr_stat_data_read, 3173 .write = NULL, 3174 }; 3175 3176 /* 3177 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel 3178 # connection. 3179 # Value range is [0,16]. Default value is 0. 3180 */ 3181 /** 3182 * lpfc_link_speed_set - Set the adapters link speed 3183 * @phba: lpfc_hba pointer. 3184 * @val: link speed value. 3185 * 3186 * Description: 3187 * If val is in a valid range then set the adapter's link speed field and 3188 * issue a lip; if the lip fails reset the link speed to the old value. 3189 * 3190 * Notes: 3191 * If the value is not in range log a kernel error message and return an error. 3192 * 3193 * Returns: 3194 * zero if val is in range and lip okay. 3195 * non-zero return value from lpfc_issue_lip() 3196 * -EINVAL val out of range 3197 **/ 3198 static ssize_t 3199 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr, 3200 const char *buf, size_t count) 3201 { 3202 struct Scsi_Host *shost = class_to_shost(dev); 3203 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3204 struct lpfc_hba *phba = vport->phba; 3205 int val = LPFC_USER_LINK_SPEED_AUTO; 3206 int nolip = 0; 3207 const char *val_buf = buf; 3208 int err; 3209 uint32_t prev_val; 3210 3211 if (!strncmp(buf, "nolip ", strlen("nolip "))) { 3212 nolip = 1; 3213 val_buf = &buf[strlen("nolip ")]; 3214 } 3215 3216 if (!isdigit(val_buf[0])) 3217 return -EINVAL; 3218 if (sscanf(val_buf, "%i", &val) != 1) 3219 return -EINVAL; 3220 3221 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3222 "3055 lpfc_link_speed changed from %d to %d %s\n", 3223 phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)"); 3224 3225 if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) || 3226 ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) || 3227 ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) || 3228 ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) || 3229 ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) || 3230 ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb))) { 3231 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3232 "2879 lpfc_link_speed attribute cannot be set " 3233 "to %d. Speed is not supported by this port.\n", 3234 val); 3235 return -EINVAL; 3236 } 3237 if (val == LPFC_USER_LINK_SPEED_16G && 3238 phba->fc_topology == LPFC_TOPOLOGY_LOOP) { 3239 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3240 "3112 lpfc_link_speed attribute cannot be set " 3241 "to %d. Speed is not supported in loop mode.\n", 3242 val); 3243 return -EINVAL; 3244 } 3245 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) && 3246 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) { 3247 prev_val = phba->cfg_link_speed; 3248 phba->cfg_link_speed = val; 3249 if (nolip) 3250 return strlen(buf); 3251 3252 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport)); 3253 if (err) { 3254 phba->cfg_link_speed = prev_val; 3255 return -EINVAL; 3256 } else 3257 return strlen(buf); 3258 } 3259 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3260 "0469 lpfc_link_speed attribute cannot be set to %d, " 3261 "allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val); 3262 return -EINVAL; 3263 } 3264 3265 static int lpfc_link_speed = 0; 3266 module_param(lpfc_link_speed, int, S_IRUGO); 3267 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed"); 3268 lpfc_param_show(link_speed) 3269 3270 /** 3271 * lpfc_link_speed_init - Set the adapters link speed 3272 * @phba: lpfc_hba pointer. 3273 * @val: link speed value. 3274 * 3275 * Description: 3276 * If val is in a valid range then set the adapter's link speed field. 3277 * 3278 * Notes: 3279 * If the value is not in range log a kernel error message, clear the link 3280 * speed and return an error. 3281 * 3282 * Returns: 3283 * zero if val saved. 3284 * -EINVAL val out of range 3285 **/ 3286 static int 3287 lpfc_link_speed_init(struct lpfc_hba *phba, int val) 3288 { 3289 if (val == LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) { 3290 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3291 "3111 lpfc_link_speed of %d cannot " 3292 "support loop mode, setting topology to default.\n", 3293 val); 3294 phba->cfg_topology = 0; 3295 } 3296 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) && 3297 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) { 3298 phba->cfg_link_speed = val; 3299 return 0; 3300 } 3301 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3302 "0405 lpfc_link_speed attribute cannot " 3303 "be set to %d, allowed values are " 3304 "["LPFC_LINK_SPEED_STRING"]\n", val); 3305 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO; 3306 return -EINVAL; 3307 } 3308 3309 static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR, 3310 lpfc_link_speed_show, lpfc_link_speed_store); 3311 3312 /* 3313 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER) 3314 # 0 = aer disabled or not supported 3315 # 1 = aer supported and enabled (default) 3316 # Value range is [0,1]. Default value is 1. 3317 */ 3318 3319 /** 3320 * lpfc_aer_support_store - Set the adapter for aer support 3321 * 3322 * @dev: class device that is converted into a Scsi_host. 3323 * @attr: device attribute, not used. 3324 * @buf: containing enable or disable aer flag. 3325 * @count: unused variable. 3326 * 3327 * Description: 3328 * If the val is 1 and currently the device's AER capability was not 3329 * enabled, invoke the kernel's enable AER helper routine, trying to 3330 * enable the device's AER capability. If the helper routine enabling 3331 * AER returns success, update the device's cfg_aer_support flag to 3332 * indicate AER is supported by the device; otherwise, if the device 3333 * AER capability is already enabled to support AER, then do nothing. 3334 * 3335 * If the val is 0 and currently the device's AER support was enabled, 3336 * invoke the kernel's disable AER helper routine. After that, update 3337 * the device's cfg_aer_support flag to indicate AER is not supported 3338 * by the device; otherwise, if the device AER capability is already 3339 * disabled from supporting AER, then do nothing. 3340 * 3341 * Returns: 3342 * length of the buf on success if val is in range the intended mode 3343 * is supported. 3344 * -EINVAL if val out of range or intended mode is not supported. 3345 **/ 3346 static ssize_t 3347 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr, 3348 const char *buf, size_t count) 3349 { 3350 struct Scsi_Host *shost = class_to_shost(dev); 3351 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 3352 struct lpfc_hba *phba = vport->phba; 3353 int val = 0, rc = -EINVAL; 3354 3355 if (!isdigit(buf[0])) 3356 return -EINVAL; 3357 if (sscanf(buf, "%i", &val) != 1) 3358 return -EINVAL; 3359 3360 switch (val) { 3361 case 0: 3362 if (phba->hba_flag & HBA_AER_ENABLED) { 3363 rc = pci_disable_pcie_error_reporting(phba->pcidev); 3364 if (!rc) { 3365 spin_lock_irq(&phba->hbalock); 3366 phba->hba_flag &= ~HBA_AER_ENABLED; 3367 spin_unlock_irq(&phba->hbalock); 3368 phba->cfg_aer_support = 0; 3369 rc = strlen(buf); 3370 } else 3371 rc = -EPERM; 3372 } else { 3373 phba->cfg_aer_support = 0; 3374 rc = strlen(buf); 3375 } 3376 break; 3377 case 1: 3378 if (!(phba->hba_flag & HBA_AER_ENABLED)) { 3379 rc = pci_enable_pcie_error_reporting(phba->pcidev); 3380 if (!rc) { 3381 spin_lock_irq(&phba->hbalock); 3382 phba->hba_flag |= HBA_AER_ENABLED; 3383 spin_unlock_irq(&phba->hbalock); 3384 phba->cfg_aer_support = 1; 3385 rc = strlen(buf); 3386 } else 3387 rc = -EPERM; 3388 } else { 3389 phba->cfg_aer_support = 1; 3390 rc = strlen(buf); 3391 } 3392 break; 3393 default: 3394 rc = -EINVAL; 3395 break; 3396 } 3397 return rc; 3398 } 3399 3400 static int lpfc_aer_support = 1; 3401 module_param(lpfc_aer_support, int, S_IRUGO); 3402 MODULE_PARM_DESC(lpfc_aer_support, "Enable PCIe device AER support"); 3403 lpfc_param_show(aer_support) 3404 3405 /** 3406 * lpfc_aer_support_init - Set the initial adapters aer support flag 3407 * @phba: lpfc_hba pointer. 3408 * @val: enable aer or disable aer flag. 3409 * 3410 * Description: 3411 * If val is in a valid range [0,1], then set the adapter's initial 3412 * cfg_aer_support field. It will be up to the driver's probe_one 3413 * routine to determine whether the device's AER support can be set 3414 * or not. 3415 * 3416 * Notes: 3417 * If the value is not in range log a kernel error message, and 3418 * choose the default value of setting AER support and return. 3419 * 3420 * Returns: 3421 * zero if val saved. 3422 * -EINVAL val out of range 3423 **/ 3424 static int 3425 lpfc_aer_support_init(struct lpfc_hba *phba, int val) 3426 { 3427 if (val == 0 || val == 1) { 3428 phba->cfg_aer_support = val; 3429 return 0; 3430 } 3431 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3432 "2712 lpfc_aer_support attribute value %d out " 3433 "of range, allowed values are 0|1, setting it " 3434 "to default value of 1\n", val); 3435 /* By default, try to enable AER on a device */ 3436 phba->cfg_aer_support = 1; 3437 return -EINVAL; 3438 } 3439 3440 static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR, 3441 lpfc_aer_support_show, lpfc_aer_support_store); 3442 3443 /** 3444 * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device 3445 * @dev: class device that is converted into a Scsi_host. 3446 * @attr: device attribute, not used. 3447 * @buf: containing flag 1 for aer cleanup state. 3448 * @count: unused variable. 3449 * 3450 * Description: 3451 * If the @buf contains 1 and the device currently has the AER support 3452 * enabled, then invokes the kernel AER helper routine 3453 * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable 3454 * error status register. 3455 * 3456 * Notes: 3457 * 3458 * Returns: 3459 * -EINVAL if the buf does not contain the 1 or the device is not currently 3460 * enabled with the AER support. 3461 **/ 3462 static ssize_t 3463 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr, 3464 const char *buf, size_t count) 3465 { 3466 struct Scsi_Host *shost = class_to_shost(dev); 3467 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3468 struct lpfc_hba *phba = vport->phba; 3469 int val, rc = -1; 3470 3471 if (!isdigit(buf[0])) 3472 return -EINVAL; 3473 if (sscanf(buf, "%i", &val) != 1) 3474 return -EINVAL; 3475 if (val != 1) 3476 return -EINVAL; 3477 3478 if (phba->hba_flag & HBA_AER_ENABLED) 3479 rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev); 3480 3481 if (rc == 0) 3482 return strlen(buf); 3483 else 3484 return -EPERM; 3485 } 3486 3487 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL, 3488 lpfc_aer_cleanup_state); 3489 3490 /** 3491 * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions 3492 * 3493 * @dev: class device that is converted into a Scsi_host. 3494 * @attr: device attribute, not used. 3495 * @buf: containing the string the number of vfs to be enabled. 3496 * @count: unused variable. 3497 * 3498 * Description: 3499 * When this api is called either through user sysfs, the driver shall 3500 * try to enable or disable SR-IOV virtual functions according to the 3501 * following: 3502 * 3503 * If zero virtual function has been enabled to the physical function, 3504 * the driver shall invoke the pci enable virtual function api trying 3505 * to enable the virtual functions. If the nr_vfn provided is greater 3506 * than the maximum supported, the maximum virtual function number will 3507 * be used for invoking the api; otherwise, the nr_vfn provided shall 3508 * be used for invoking the api. If the api call returned success, the 3509 * actual number of virtual functions enabled will be set to the driver 3510 * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver 3511 * cfg_sriov_nr_virtfn remains zero. 3512 * 3513 * If none-zero virtual functions have already been enabled to the 3514 * physical function, as reflected by the driver's cfg_sriov_nr_virtfn, 3515 * -EINVAL will be returned and the driver does nothing; 3516 * 3517 * If the nr_vfn provided is zero and none-zero virtual functions have 3518 * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the 3519 * disabling virtual function api shall be invoded to disable all the 3520 * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to 3521 * zero. Otherwise, if zero virtual function has been enabled, do 3522 * nothing. 3523 * 3524 * Returns: 3525 * length of the buf on success if val is in range the intended mode 3526 * is supported. 3527 * -EINVAL if val out of range or intended mode is not supported. 3528 **/ 3529 static ssize_t 3530 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr, 3531 const char *buf, size_t count) 3532 { 3533 struct Scsi_Host *shost = class_to_shost(dev); 3534 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 3535 struct lpfc_hba *phba = vport->phba; 3536 struct pci_dev *pdev = phba->pcidev; 3537 int val = 0, rc = -EINVAL; 3538 3539 /* Sanity check on user data */ 3540 if (!isdigit(buf[0])) 3541 return -EINVAL; 3542 if (sscanf(buf, "%i", &val) != 1) 3543 return -EINVAL; 3544 if (val < 0) 3545 return -EINVAL; 3546 3547 /* Request disabling virtual functions */ 3548 if (val == 0) { 3549 if (phba->cfg_sriov_nr_virtfn > 0) { 3550 pci_disable_sriov(pdev); 3551 phba->cfg_sriov_nr_virtfn = 0; 3552 } 3553 return strlen(buf); 3554 } 3555 3556 /* Request enabling virtual functions */ 3557 if (phba->cfg_sriov_nr_virtfn > 0) { 3558 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3559 "3018 There are %d virtual functions " 3560 "enabled on physical function.\n", 3561 phba->cfg_sriov_nr_virtfn); 3562 return -EEXIST; 3563 } 3564 3565 if (val <= LPFC_MAX_VFN_PER_PFN) 3566 phba->cfg_sriov_nr_virtfn = val; 3567 else { 3568 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3569 "3019 Enabling %d virtual functions is not " 3570 "allowed.\n", val); 3571 return -EINVAL; 3572 } 3573 3574 rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn); 3575 if (rc) { 3576 phba->cfg_sriov_nr_virtfn = 0; 3577 rc = -EPERM; 3578 } else 3579 rc = strlen(buf); 3580 3581 return rc; 3582 } 3583 3584 static int lpfc_sriov_nr_virtfn = LPFC_DEF_VFN_PER_PFN; 3585 module_param(lpfc_sriov_nr_virtfn, int, S_IRUGO|S_IWUSR); 3586 MODULE_PARM_DESC(lpfc_sriov_nr_virtfn, "Enable PCIe device SR-IOV virtual fn"); 3587 lpfc_param_show(sriov_nr_virtfn) 3588 3589 /** 3590 * lpfc_sriov_nr_virtfn_init - Set the initial sr-iov virtual function enable 3591 * @phba: lpfc_hba pointer. 3592 * @val: link speed value. 3593 * 3594 * Description: 3595 * If val is in a valid range [0,255], then set the adapter's initial 3596 * cfg_sriov_nr_virtfn field. If it's greater than the maximum, the maximum 3597 * number shall be used instead. It will be up to the driver's probe_one 3598 * routine to determine whether the device's SR-IOV is supported or not. 3599 * 3600 * Returns: 3601 * zero if val saved. 3602 * -EINVAL val out of range 3603 **/ 3604 static int 3605 lpfc_sriov_nr_virtfn_init(struct lpfc_hba *phba, int val) 3606 { 3607 if (val >= 0 && val <= LPFC_MAX_VFN_PER_PFN) { 3608 phba->cfg_sriov_nr_virtfn = val; 3609 return 0; 3610 } 3611 3612 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3613 "3017 Enabling %d virtual functions is not " 3614 "allowed.\n", val); 3615 return -EINVAL; 3616 } 3617 static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR, 3618 lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store); 3619 3620 /** 3621 * lpfc_request_firmware_store - Request for Linux generic firmware upgrade 3622 * 3623 * @dev: class device that is converted into a Scsi_host. 3624 * @attr: device attribute, not used. 3625 * @buf: containing the string the number of vfs to be enabled. 3626 * @count: unused variable. 3627 * 3628 * Description: 3629 * 3630 * Returns: 3631 * length of the buf on success if val is in range the intended mode 3632 * is supported. 3633 * -EINVAL if val out of range or intended mode is not supported. 3634 **/ 3635 static ssize_t 3636 lpfc_request_firmware_upgrade_store(struct device *dev, 3637 struct device_attribute *attr, 3638 const char *buf, size_t count) 3639 { 3640 struct Scsi_Host *shost = class_to_shost(dev); 3641 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 3642 struct lpfc_hba *phba = vport->phba; 3643 int val = 0, rc = -EINVAL; 3644 3645 /* Sanity check on user data */ 3646 if (!isdigit(buf[0])) 3647 return -EINVAL; 3648 if (sscanf(buf, "%i", &val) != 1) 3649 return -EINVAL; 3650 if (val != 1) 3651 return -EINVAL; 3652 3653 rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE); 3654 if (rc) 3655 rc = -EPERM; 3656 else 3657 rc = strlen(buf); 3658 return rc; 3659 } 3660 3661 static int lpfc_req_fw_upgrade; 3662 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR); 3663 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade"); 3664 lpfc_param_show(request_firmware_upgrade) 3665 3666 /** 3667 * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade 3668 * @phba: lpfc_hba pointer. 3669 * @val: 0 or 1. 3670 * 3671 * Description: 3672 * Set the initial Linux generic firmware upgrade enable or disable flag. 3673 * 3674 * Returns: 3675 * zero if val saved. 3676 * -EINVAL val out of range 3677 **/ 3678 static int 3679 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val) 3680 { 3681 if (val >= 0 && val <= 1) { 3682 phba->cfg_request_firmware_upgrade = val; 3683 return 0; 3684 } 3685 return -EINVAL; 3686 } 3687 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR, 3688 lpfc_request_firmware_upgrade_show, 3689 lpfc_request_firmware_upgrade_store); 3690 3691 /** 3692 * lpfc_fcp_imax_store 3693 * 3694 * @dev: class device that is converted into a Scsi_host. 3695 * @attr: device attribute, not used. 3696 * @buf: string with the number of fast-path FCP interrupts per second. 3697 * @count: unused variable. 3698 * 3699 * Description: 3700 * If val is in a valid range [636,651042], then set the adapter's 3701 * maximum number of fast-path FCP interrupts per second. 3702 * 3703 * Returns: 3704 * length of the buf on success if val is in range the intended mode 3705 * is supported. 3706 * -EINVAL if val out of range or intended mode is not supported. 3707 **/ 3708 static ssize_t 3709 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr, 3710 const char *buf, size_t count) 3711 { 3712 struct Scsi_Host *shost = class_to_shost(dev); 3713 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 3714 struct lpfc_hba *phba = vport->phba; 3715 int val = 0, i; 3716 3717 /* fcp_imax is only valid for SLI4 */ 3718 if (phba->sli_rev != LPFC_SLI_REV4) 3719 return -EINVAL; 3720 3721 /* Sanity check on user data */ 3722 if (!isdigit(buf[0])) 3723 return -EINVAL; 3724 if (sscanf(buf, "%i", &val) != 1) 3725 return -EINVAL; 3726 3727 /* 3728 * Value range for the HBA is [5000,5000000] 3729 * The value for each EQ depends on how many EQs are configured. 3730 */ 3731 if (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX) 3732 return -EINVAL; 3733 3734 phba->cfg_fcp_imax = (uint32_t)val; 3735 for (i = 0; i < phba->cfg_fcp_io_channel; i += LPFC_MAX_EQ_DELAY) 3736 lpfc_modify_fcp_eq_delay(phba, i); 3737 3738 return strlen(buf); 3739 } 3740 3741 /* 3742 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second 3743 # for the HBA. 3744 # 3745 # Value range is [5,000 to 5,000,000]. Default value is 50,000. 3746 */ 3747 static int lpfc_fcp_imax = LPFC_DEF_IMAX; 3748 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR); 3749 MODULE_PARM_DESC(lpfc_fcp_imax, 3750 "Set the maximum number of FCP interrupts per second per HBA"); 3751 lpfc_param_show(fcp_imax) 3752 3753 /** 3754 * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable 3755 * @phba: lpfc_hba pointer. 3756 * @val: link speed value. 3757 * 3758 * Description: 3759 * If val is in a valid range [636,651042], then initialize the adapter's 3760 * maximum number of fast-path FCP interrupts per second. 3761 * 3762 * Returns: 3763 * zero if val saved. 3764 * -EINVAL val out of range 3765 **/ 3766 static int 3767 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val) 3768 { 3769 if (phba->sli_rev != LPFC_SLI_REV4) { 3770 phba->cfg_fcp_imax = 0; 3771 return 0; 3772 } 3773 3774 if (val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) { 3775 phba->cfg_fcp_imax = val; 3776 return 0; 3777 } 3778 3779 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3780 "3016 fcp_imax: %d out of range, using default\n", val); 3781 phba->cfg_fcp_imax = LPFC_DEF_IMAX; 3782 3783 return 0; 3784 } 3785 3786 static DEVICE_ATTR(lpfc_fcp_imax, S_IRUGO | S_IWUSR, 3787 lpfc_fcp_imax_show, lpfc_fcp_imax_store); 3788 3789 /* 3790 # lpfc_fcp_class: Determines FC class to use for the FCP protocol. 3791 # Value range is [2,3]. Default value is 3. 3792 */ 3793 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3, 3794 "Select Fibre Channel class of service for FCP sequences"); 3795 3796 /* 3797 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range 3798 # is [0,1]. Default value is 0. 3799 */ 3800 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1, 3801 "Use ADISC on rediscovery to authenticate FCP devices"); 3802 3803 /* 3804 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue 3805 # depth. Default value is 0. When the value of this parameter is zero the 3806 # SCSI command completion time is not used for controlling I/O queue depth. When 3807 # the parameter is set to a non-zero value, the I/O queue depth is controlled 3808 # to limit the I/O completion time to the parameter value. 3809 # The value is set in milliseconds. 3810 */ 3811 static int lpfc_max_scsicmpl_time; 3812 module_param(lpfc_max_scsicmpl_time, int, S_IRUGO); 3813 MODULE_PARM_DESC(lpfc_max_scsicmpl_time, 3814 "Use command completion time to control queue depth"); 3815 lpfc_vport_param_show(max_scsicmpl_time); 3816 lpfc_vport_param_init(max_scsicmpl_time, 0, 0, 60000); 3817 static int 3818 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val) 3819 { 3820 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 3821 struct lpfc_nodelist *ndlp, *next_ndlp; 3822 3823 if (val == vport->cfg_max_scsicmpl_time) 3824 return 0; 3825 if ((val < 0) || (val > 60000)) 3826 return -EINVAL; 3827 vport->cfg_max_scsicmpl_time = val; 3828 3829 spin_lock_irq(shost->host_lock); 3830 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 3831 if (!NLP_CHK_NODE_ACT(ndlp)) 3832 continue; 3833 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 3834 continue; 3835 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth; 3836 } 3837 spin_unlock_irq(shost->host_lock); 3838 return 0; 3839 } 3840 lpfc_vport_param_store(max_scsicmpl_time); 3841 static DEVICE_ATTR(lpfc_max_scsicmpl_time, S_IRUGO | S_IWUSR, 3842 lpfc_max_scsicmpl_time_show, 3843 lpfc_max_scsicmpl_time_store); 3844 3845 /* 3846 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value 3847 # range is [0,1]. Default value is 0. 3848 */ 3849 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support"); 3850 3851 /* 3852 # lpfc_fcp_io_sched: Determine scheduling algrithmn for issuing FCP cmds 3853 # range is [0,1]. Default value is 0. 3854 # For [0], FCP commands are issued to Work Queues ina round robin fashion. 3855 # For [1], FCP commands are issued to a Work Queue associated with the 3856 # current CPU. 3857 */ 3858 LPFC_ATTR_RW(fcp_io_sched, 0, 0, 1, "Determine scheduling algrithmn for " 3859 "issuing commands [0] - Round Robin, [1] - Current CPU"); 3860 3861 /* 3862 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior 3863 # range is [0,1]. Default value is 0. 3864 # For [0], bus reset issues target reset to ALL devices 3865 # For [1], bus reset issues target reset to non-FCP2 devices 3866 */ 3867 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for " 3868 "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset"); 3869 3870 3871 /* 3872 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing 3873 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take 3874 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay 3875 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if 3876 # cr_delay is set to 0. 3877 */ 3878 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an " 3879 "interrupt response is generated"); 3880 3881 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an " 3882 "interrupt response is generated"); 3883 3884 /* 3885 # lpfc_multi_ring_support: Determines how many rings to spread available 3886 # cmd/rsp IOCB entries across. 3887 # Value range is [1,2]. Default value is 1. 3888 */ 3889 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary " 3890 "SLI rings to spread IOCB entries across"); 3891 3892 /* 3893 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this 3894 # identifies what rctl value to configure the additional ring for. 3895 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data). 3896 */ 3897 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1, 3898 255, "Identifies RCTL for additional ring configuration"); 3899 3900 /* 3901 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this 3902 # identifies what type value to configure the additional ring for. 3903 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP). 3904 */ 3905 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1, 3906 255, "Identifies TYPE for additional ring configuration"); 3907 3908 /* 3909 # lpfc_fdmi_on: controls FDMI support. 3910 # 0 = no FDMI support 3911 # 1 = support FDMI without attribute of hostname 3912 # 2 = support FDMI with attribute of hostname 3913 # Value range [0,2]. Default value is 0. 3914 */ 3915 LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support"); 3916 3917 /* 3918 # Specifies the maximum number of ELS cmds we can have outstanding (for 3919 # discovery). Value range is [1,64]. Default value = 32. 3920 */ 3921 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands " 3922 "during discovery"); 3923 3924 /* 3925 # lpfc_max_luns: maximum allowed LUN. 3926 # Value range is [0,65535]. Default value is 255. 3927 # NOTE: The SCSI layer might probe all allowed LUN on some old targets. 3928 */ 3929 LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN"); 3930 3931 /* 3932 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring. 3933 # Value range is [1,255], default value is 10. 3934 */ 3935 LPFC_ATTR_RW(poll_tmo, 10, 1, 255, 3936 "Milliseconds driver will wait between polling FCP ring"); 3937 3938 /* 3939 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that 3940 # support this feature 3941 # 0 = MSI disabled 3942 # 1 = MSI enabled 3943 # 2 = MSI-X enabled (default) 3944 # Value range is [0,2]. Default value is 2. 3945 */ 3946 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or " 3947 "MSI-X (2), if possible"); 3948 3949 /* 3950 # lpfc_fcp_wq_count: Set the number of fast-path FCP work queues 3951 # This parameter is ignored and will eventually be depricated 3952 # 3953 # Value range is [1,7]. Default value is 4. 3954 */ 3955 LPFC_ATTR_R(fcp_wq_count, LPFC_FCP_IO_CHAN_DEF, LPFC_FCP_IO_CHAN_MIN, 3956 LPFC_FCP_IO_CHAN_MAX, 3957 "Set the number of fast-path FCP work queues, if possible"); 3958 3959 /* 3960 # lpfc_fcp_eq_count: Set the number of FCP EQ/CQ/WQ IO channels 3961 # 3962 # Value range is [1,7]. Default value is 4. 3963 */ 3964 LPFC_ATTR_R(fcp_eq_count, LPFC_FCP_IO_CHAN_DEF, LPFC_FCP_IO_CHAN_MIN, 3965 LPFC_FCP_IO_CHAN_MAX, 3966 "Set the number of fast-path FCP event queues, if possible"); 3967 3968 /* 3969 # lpfc_fcp_io_channel: Set the number of FCP EQ/CQ/WQ IO channels 3970 # 3971 # Value range is [1,7]. Default value is 4. 3972 */ 3973 LPFC_ATTR_R(fcp_io_channel, LPFC_FCP_IO_CHAN_DEF, LPFC_FCP_IO_CHAN_MIN, 3974 LPFC_FCP_IO_CHAN_MAX, 3975 "Set the number of FCP I/O channels"); 3976 3977 /* 3978 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware. 3979 # 0 = HBA resets disabled 3980 # 1 = HBA resets enabled (default) 3981 # Value range is [0,1]. Default value is 1. 3982 */ 3983 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver."); 3984 3985 /* 3986 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer.. 3987 # 0 = HBA Heartbeat disabled 3988 # 1 = HBA Heartbeat enabled (default) 3989 # Value range is [0,1]. Default value is 1. 3990 */ 3991 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat."); 3992 3993 /* 3994 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF) 3995 # 0 = BlockGuard disabled (default) 3996 # 1 = BlockGuard enabled 3997 # Value range is [0,1]. Default value is 0. 3998 */ 3999 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support"); 4000 4001 /* 4002 # lpfc_fcp_look_ahead: Look ahead for completions in FCP start routine 4003 # 0 = disabled (default) 4004 # 1 = enabled 4005 # Value range is [0,1]. Default value is 0. 4006 */ 4007 unsigned int lpfc_fcp_look_ahead = LPFC_LOOK_AHEAD_OFF; 4008 4009 module_param(lpfc_fcp_look_ahead, uint, S_IRUGO); 4010 MODULE_PARM_DESC(lpfc_fcp_look_ahead, "Look ahead for completions"); 4011 4012 /* 4013 # lpfc_prot_mask: i 4014 # - Bit mask of host protection capabilities used to register with the 4015 # SCSI mid-layer 4016 # - Only meaningful if BG is turned on (lpfc_enable_bg=1). 4017 # - Allows you to ultimately specify which profiles to use 4018 # - Default will result in registering capabilities for all profiles. 4019 # - SHOST_DIF_TYPE1_PROTECTION 1 4020 # HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection 4021 # - SHOST_DIX_TYPE0_PROTECTION 8 4022 # HBA supports DIX Type 0: Host to HBA protection only 4023 # - SHOST_DIX_TYPE1_PROTECTION 16 4024 # HBA supports DIX Type 1: Host to HBA Type 1 protection 4025 # 4026 */ 4027 unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION | 4028 SHOST_DIX_TYPE0_PROTECTION | 4029 SHOST_DIX_TYPE1_PROTECTION; 4030 4031 module_param(lpfc_prot_mask, uint, S_IRUGO); 4032 MODULE_PARM_DESC(lpfc_prot_mask, "host protection mask"); 4033 4034 /* 4035 # lpfc_prot_guard: i 4036 # - Bit mask of protection guard types to register with the SCSI mid-layer 4037 # - Guard types are currently either 1) T10-DIF CRC 2) IP checksum 4038 # - Allows you to ultimately specify which profiles to use 4039 # - Default will result in registering capabilities for all guard types 4040 # 4041 */ 4042 unsigned char lpfc_prot_guard = SHOST_DIX_GUARD_IP; 4043 module_param(lpfc_prot_guard, byte, S_IRUGO); 4044 MODULE_PARM_DESC(lpfc_prot_guard, "host protection guard type"); 4045 4046 /* 4047 * Delay initial NPort discovery when Clean Address bit is cleared in 4048 * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed. 4049 * This parameter can have value 0 or 1. 4050 * When this parameter is set to 0, no delay is added to the initial 4051 * discovery. 4052 * When this parameter is set to non-zero value, initial Nport discovery is 4053 * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC 4054 * accept and FCID/Fabric name/Fabric portname is changed. 4055 * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion 4056 * when Clean Address bit is cleared in FLOGI/FDISC 4057 * accept and FCID/Fabric name/Fabric portname is changed. 4058 * Default value is 0. 4059 */ 4060 int lpfc_delay_discovery; 4061 module_param(lpfc_delay_discovery, int, S_IRUGO); 4062 MODULE_PARM_DESC(lpfc_delay_discovery, 4063 "Delay NPort discovery when Clean Address bit is cleared. " 4064 "Allowed values: 0,1."); 4065 4066 /* 4067 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count 4068 * This value can be set to values between 64 and 256. The default value is 4069 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer 4070 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE). 4071 */ 4072 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT, 4073 LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count"); 4074 4075 LPFC_ATTR_R(prot_sg_seg_cnt, LPFC_DEFAULT_PROT_SG_SEG_CNT, 4076 LPFC_DEFAULT_PROT_SG_SEG_CNT, LPFC_MAX_PROT_SG_SEG_CNT, 4077 "Max Protection Scatter Gather Segment Count"); 4078 4079 struct device_attribute *lpfc_hba_attrs[] = { 4080 &dev_attr_bg_info, 4081 &dev_attr_bg_guard_err, 4082 &dev_attr_bg_apptag_err, 4083 &dev_attr_bg_reftag_err, 4084 &dev_attr_info, 4085 &dev_attr_serialnum, 4086 &dev_attr_modeldesc, 4087 &dev_attr_modelname, 4088 &dev_attr_programtype, 4089 &dev_attr_portnum, 4090 &dev_attr_fwrev, 4091 &dev_attr_hdw, 4092 &dev_attr_option_rom_version, 4093 &dev_attr_link_state, 4094 &dev_attr_num_discovered_ports, 4095 &dev_attr_menlo_mgmt_mode, 4096 &dev_attr_lpfc_drvr_version, 4097 &dev_attr_lpfc_enable_fip, 4098 &dev_attr_lpfc_temp_sensor, 4099 &dev_attr_lpfc_log_verbose, 4100 &dev_attr_lpfc_lun_queue_depth, 4101 &dev_attr_lpfc_tgt_queue_depth, 4102 &dev_attr_lpfc_hba_queue_depth, 4103 &dev_attr_lpfc_peer_port_login, 4104 &dev_attr_lpfc_nodev_tmo, 4105 &dev_attr_lpfc_devloss_tmo, 4106 &dev_attr_lpfc_fcp_class, 4107 &dev_attr_lpfc_use_adisc, 4108 &dev_attr_lpfc_ack0, 4109 &dev_attr_lpfc_topology, 4110 &dev_attr_lpfc_scan_down, 4111 &dev_attr_lpfc_link_speed, 4112 &dev_attr_lpfc_fcp_io_sched, 4113 &dev_attr_lpfc_fcp2_no_tgt_reset, 4114 &dev_attr_lpfc_cr_delay, 4115 &dev_attr_lpfc_cr_count, 4116 &dev_attr_lpfc_multi_ring_support, 4117 &dev_attr_lpfc_multi_ring_rctl, 4118 &dev_attr_lpfc_multi_ring_type, 4119 &dev_attr_lpfc_fdmi_on, 4120 &dev_attr_lpfc_max_luns, 4121 &dev_attr_lpfc_enable_npiv, 4122 &dev_attr_lpfc_fcf_failover_policy, 4123 &dev_attr_lpfc_enable_rrq, 4124 &dev_attr_nport_evt_cnt, 4125 &dev_attr_board_mode, 4126 &dev_attr_max_vpi, 4127 &dev_attr_used_vpi, 4128 &dev_attr_max_rpi, 4129 &dev_attr_used_rpi, 4130 &dev_attr_max_xri, 4131 &dev_attr_used_xri, 4132 &dev_attr_npiv_info, 4133 &dev_attr_issue_reset, 4134 &dev_attr_lpfc_poll, 4135 &dev_attr_lpfc_poll_tmo, 4136 &dev_attr_lpfc_use_msi, 4137 &dev_attr_lpfc_fcp_imax, 4138 &dev_attr_lpfc_fcp_wq_count, 4139 &dev_attr_lpfc_fcp_eq_count, 4140 &dev_attr_lpfc_fcp_io_channel, 4141 &dev_attr_lpfc_enable_bg, 4142 &dev_attr_lpfc_soft_wwnn, 4143 &dev_attr_lpfc_soft_wwpn, 4144 &dev_attr_lpfc_soft_wwn_enable, 4145 &dev_attr_lpfc_enable_hba_reset, 4146 &dev_attr_lpfc_enable_hba_heartbeat, 4147 &dev_attr_lpfc_sg_seg_cnt, 4148 &dev_attr_lpfc_max_scsicmpl_time, 4149 &dev_attr_lpfc_stat_data_ctrl, 4150 &dev_attr_lpfc_prot_sg_seg_cnt, 4151 &dev_attr_lpfc_aer_support, 4152 &dev_attr_lpfc_aer_state_cleanup, 4153 &dev_attr_lpfc_sriov_nr_virtfn, 4154 &dev_attr_lpfc_req_fw_upgrade, 4155 &dev_attr_lpfc_suppress_link_up, 4156 &dev_attr_lpfc_iocb_cnt, 4157 &dev_attr_iocb_hw, 4158 &dev_attr_txq_hw, 4159 &dev_attr_txcmplq_hw, 4160 &dev_attr_lpfc_fips_level, 4161 &dev_attr_lpfc_fips_rev, 4162 &dev_attr_lpfc_dss, 4163 &dev_attr_lpfc_sriov_hw_max_virtfn, 4164 &dev_attr_protocol, 4165 NULL, 4166 }; 4167 4168 struct device_attribute *lpfc_vport_attrs[] = { 4169 &dev_attr_info, 4170 &dev_attr_link_state, 4171 &dev_attr_num_discovered_ports, 4172 &dev_attr_lpfc_drvr_version, 4173 &dev_attr_lpfc_log_verbose, 4174 &dev_attr_lpfc_lun_queue_depth, 4175 &dev_attr_lpfc_tgt_queue_depth, 4176 &dev_attr_lpfc_nodev_tmo, 4177 &dev_attr_lpfc_devloss_tmo, 4178 &dev_attr_lpfc_hba_queue_depth, 4179 &dev_attr_lpfc_peer_port_login, 4180 &dev_attr_lpfc_restrict_login, 4181 &dev_attr_lpfc_fcp_class, 4182 &dev_attr_lpfc_use_adisc, 4183 &dev_attr_lpfc_fdmi_on, 4184 &dev_attr_lpfc_max_luns, 4185 &dev_attr_nport_evt_cnt, 4186 &dev_attr_npiv_info, 4187 &dev_attr_lpfc_enable_da_id, 4188 &dev_attr_lpfc_max_scsicmpl_time, 4189 &dev_attr_lpfc_stat_data_ctrl, 4190 &dev_attr_lpfc_static_vport, 4191 &dev_attr_lpfc_fips_level, 4192 &dev_attr_lpfc_fips_rev, 4193 NULL, 4194 }; 4195 4196 /** 4197 * sysfs_ctlreg_write - Write method for writing to ctlreg 4198 * @filp: open sysfs file 4199 * @kobj: kernel kobject that contains the kernel class device. 4200 * @bin_attr: kernel attributes passed to us. 4201 * @buf: contains the data to be written to the adapter IOREG space. 4202 * @off: offset into buffer to beginning of data. 4203 * @count: bytes to transfer. 4204 * 4205 * Description: 4206 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg. 4207 * Uses the adapter io control registers to send buf contents to the adapter. 4208 * 4209 * Returns: 4210 * -ERANGE off and count combo out of range 4211 * -EINVAL off, count or buff address invalid 4212 * -EPERM adapter is offline 4213 * value of count, buf contents written 4214 **/ 4215 static ssize_t 4216 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj, 4217 struct bin_attribute *bin_attr, 4218 char *buf, loff_t off, size_t count) 4219 { 4220 size_t buf_off; 4221 struct device *dev = container_of(kobj, struct device, kobj); 4222 struct Scsi_Host *shost = class_to_shost(dev); 4223 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4224 struct lpfc_hba *phba = vport->phba; 4225 4226 if (phba->sli_rev >= LPFC_SLI_REV4) 4227 return -EPERM; 4228 4229 if ((off + count) > FF_REG_AREA_SIZE) 4230 return -ERANGE; 4231 4232 if (count <= LPFC_REG_WRITE_KEY_SIZE) 4233 return 0; 4234 4235 if (off % 4 || count % 4 || (unsigned long)buf % 4) 4236 return -EINVAL; 4237 4238 /* This is to protect HBA registers from accidental writes. */ 4239 if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE)) 4240 return -EINVAL; 4241 4242 if (!(vport->fc_flag & FC_OFFLINE_MODE)) 4243 return -EPERM; 4244 4245 spin_lock_irq(&phba->hbalock); 4246 for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE; 4247 buf_off += sizeof(uint32_t)) 4248 writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)), 4249 phba->ctrl_regs_memmap_p + off + buf_off); 4250 4251 spin_unlock_irq(&phba->hbalock); 4252 4253 return count; 4254 } 4255 4256 /** 4257 * sysfs_ctlreg_read - Read method for reading from ctlreg 4258 * @filp: open sysfs file 4259 * @kobj: kernel kobject that contains the kernel class device. 4260 * @bin_attr: kernel attributes passed to us. 4261 * @buf: if successful contains the data from the adapter IOREG space. 4262 * @off: offset into buffer to beginning of data. 4263 * @count: bytes to transfer. 4264 * 4265 * Description: 4266 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg. 4267 * Uses the adapter io control registers to read data into buf. 4268 * 4269 * Returns: 4270 * -ERANGE off and count combo out of range 4271 * -EINVAL off, count or buff address invalid 4272 * value of count, buf contents read 4273 **/ 4274 static ssize_t 4275 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj, 4276 struct bin_attribute *bin_attr, 4277 char *buf, loff_t off, size_t count) 4278 { 4279 size_t buf_off; 4280 uint32_t * tmp_ptr; 4281 struct device *dev = container_of(kobj, struct device, kobj); 4282 struct Scsi_Host *shost = class_to_shost(dev); 4283 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4284 struct lpfc_hba *phba = vport->phba; 4285 4286 if (phba->sli_rev >= LPFC_SLI_REV4) 4287 return -EPERM; 4288 4289 if (off > FF_REG_AREA_SIZE) 4290 return -ERANGE; 4291 4292 if ((off + count) > FF_REG_AREA_SIZE) 4293 count = FF_REG_AREA_SIZE - off; 4294 4295 if (count == 0) return 0; 4296 4297 if (off % 4 || count % 4 || (unsigned long)buf % 4) 4298 return -EINVAL; 4299 4300 spin_lock_irq(&phba->hbalock); 4301 4302 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) { 4303 tmp_ptr = (uint32_t *)(buf + buf_off); 4304 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off); 4305 } 4306 4307 spin_unlock_irq(&phba->hbalock); 4308 4309 return count; 4310 } 4311 4312 static struct bin_attribute sysfs_ctlreg_attr = { 4313 .attr = { 4314 .name = "ctlreg", 4315 .mode = S_IRUSR | S_IWUSR, 4316 }, 4317 .size = 256, 4318 .read = sysfs_ctlreg_read, 4319 .write = sysfs_ctlreg_write, 4320 }; 4321 4322 /** 4323 * sysfs_mbox_write - Write method for writing information via mbox 4324 * @filp: open sysfs file 4325 * @kobj: kernel kobject that contains the kernel class device. 4326 * @bin_attr: kernel attributes passed to us. 4327 * @buf: contains the data to be written to sysfs mbox. 4328 * @off: offset into buffer to beginning of data. 4329 * @count: bytes to transfer. 4330 * 4331 * Description: 4332 * Deprecated function. All mailbox access from user space is performed via the 4333 * bsg interface. 4334 * 4335 * Returns: 4336 * -EPERM operation not permitted 4337 **/ 4338 static ssize_t 4339 sysfs_mbox_write(struct file *filp, struct kobject *kobj, 4340 struct bin_attribute *bin_attr, 4341 char *buf, loff_t off, size_t count) 4342 { 4343 return -EPERM; 4344 } 4345 4346 /** 4347 * sysfs_mbox_read - Read method for reading information via mbox 4348 * @filp: open sysfs file 4349 * @kobj: kernel kobject that contains the kernel class device. 4350 * @bin_attr: kernel attributes passed to us. 4351 * @buf: contains the data to be read from sysfs mbox. 4352 * @off: offset into buffer to beginning of data. 4353 * @count: bytes to transfer. 4354 * 4355 * Description: 4356 * Deprecated function. All mailbox access from user space is performed via the 4357 * bsg interface. 4358 * 4359 * Returns: 4360 * -EPERM operation not permitted 4361 **/ 4362 static ssize_t 4363 sysfs_mbox_read(struct file *filp, struct kobject *kobj, 4364 struct bin_attribute *bin_attr, 4365 char *buf, loff_t off, size_t count) 4366 { 4367 return -EPERM; 4368 } 4369 4370 static struct bin_attribute sysfs_mbox_attr = { 4371 .attr = { 4372 .name = "mbox", 4373 .mode = S_IRUSR | S_IWUSR, 4374 }, 4375 .size = MAILBOX_SYSFS_MAX, 4376 .read = sysfs_mbox_read, 4377 .write = sysfs_mbox_write, 4378 }; 4379 4380 /** 4381 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries 4382 * @vport: address of lpfc vport structure. 4383 * 4384 * Return codes: 4385 * zero on success 4386 * error return code from sysfs_create_bin_file() 4387 **/ 4388 int 4389 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport) 4390 { 4391 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 4392 int error; 4393 4394 error = sysfs_create_bin_file(&shost->shost_dev.kobj, 4395 &sysfs_drvr_stat_data_attr); 4396 4397 /* Virtual ports do not need ctrl_reg and mbox */ 4398 if (error || vport->port_type == LPFC_NPIV_PORT) 4399 goto out; 4400 4401 error = sysfs_create_bin_file(&shost->shost_dev.kobj, 4402 &sysfs_ctlreg_attr); 4403 if (error) 4404 goto out_remove_stat_attr; 4405 4406 error = sysfs_create_bin_file(&shost->shost_dev.kobj, 4407 &sysfs_mbox_attr); 4408 if (error) 4409 goto out_remove_ctlreg_attr; 4410 4411 return 0; 4412 out_remove_ctlreg_attr: 4413 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr); 4414 out_remove_stat_attr: 4415 sysfs_remove_bin_file(&shost->shost_dev.kobj, 4416 &sysfs_drvr_stat_data_attr); 4417 out: 4418 return error; 4419 } 4420 4421 /** 4422 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries 4423 * @vport: address of lpfc vport structure. 4424 **/ 4425 void 4426 lpfc_free_sysfs_attr(struct lpfc_vport *vport) 4427 { 4428 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 4429 sysfs_remove_bin_file(&shost->shost_dev.kobj, 4430 &sysfs_drvr_stat_data_attr); 4431 /* Virtual ports do not need ctrl_reg and mbox */ 4432 if (vport->port_type == LPFC_NPIV_PORT) 4433 return; 4434 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr); 4435 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr); 4436 } 4437 4438 4439 /* 4440 * Dynamic FC Host Attributes Support 4441 */ 4442 4443 /** 4444 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id 4445 * @shost: kernel scsi host pointer. 4446 **/ 4447 static void 4448 lpfc_get_host_port_id(struct Scsi_Host *shost) 4449 { 4450 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4451 4452 /* note: fc_myDID already in cpu endianness */ 4453 fc_host_port_id(shost) = vport->fc_myDID; 4454 } 4455 4456 /** 4457 * lpfc_get_host_port_type - Set the value of the scsi host port type 4458 * @shost: kernel scsi host pointer. 4459 **/ 4460 static void 4461 lpfc_get_host_port_type(struct Scsi_Host *shost) 4462 { 4463 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4464 struct lpfc_hba *phba = vport->phba; 4465 4466 spin_lock_irq(shost->host_lock); 4467 4468 if (vport->port_type == LPFC_NPIV_PORT) { 4469 fc_host_port_type(shost) = FC_PORTTYPE_NPIV; 4470 } else if (lpfc_is_link_up(phba)) { 4471 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) { 4472 if (vport->fc_flag & FC_PUBLIC_LOOP) 4473 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT; 4474 else 4475 fc_host_port_type(shost) = FC_PORTTYPE_LPORT; 4476 } else { 4477 if (vport->fc_flag & FC_FABRIC) 4478 fc_host_port_type(shost) = FC_PORTTYPE_NPORT; 4479 else 4480 fc_host_port_type(shost) = FC_PORTTYPE_PTP; 4481 } 4482 } else 4483 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN; 4484 4485 spin_unlock_irq(shost->host_lock); 4486 } 4487 4488 /** 4489 * lpfc_get_host_port_state - Set the value of the scsi host port state 4490 * @shost: kernel scsi host pointer. 4491 **/ 4492 static void 4493 lpfc_get_host_port_state(struct Scsi_Host *shost) 4494 { 4495 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4496 struct lpfc_hba *phba = vport->phba; 4497 4498 spin_lock_irq(shost->host_lock); 4499 4500 if (vport->fc_flag & FC_OFFLINE_MODE) 4501 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 4502 else { 4503 switch (phba->link_state) { 4504 case LPFC_LINK_UNKNOWN: 4505 case LPFC_LINK_DOWN: 4506 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 4507 break; 4508 case LPFC_LINK_UP: 4509 case LPFC_CLEAR_LA: 4510 case LPFC_HBA_READY: 4511 /* Links up, reports port state accordingly */ 4512 if (vport->port_state < LPFC_VPORT_READY) 4513 fc_host_port_state(shost) = 4514 FC_PORTSTATE_BYPASSED; 4515 else 4516 fc_host_port_state(shost) = 4517 FC_PORTSTATE_ONLINE; 4518 break; 4519 case LPFC_HBA_ERROR: 4520 fc_host_port_state(shost) = FC_PORTSTATE_ERROR; 4521 break; 4522 default: 4523 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 4524 break; 4525 } 4526 } 4527 4528 spin_unlock_irq(shost->host_lock); 4529 } 4530 4531 /** 4532 * lpfc_get_host_speed - Set the value of the scsi host speed 4533 * @shost: kernel scsi host pointer. 4534 **/ 4535 static void 4536 lpfc_get_host_speed(struct Scsi_Host *shost) 4537 { 4538 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4539 struct lpfc_hba *phba = vport->phba; 4540 4541 spin_lock_irq(shost->host_lock); 4542 4543 if (lpfc_is_link_up(phba)) { 4544 switch(phba->fc_linkspeed) { 4545 case LPFC_LINK_SPEED_1GHZ: 4546 fc_host_speed(shost) = FC_PORTSPEED_1GBIT; 4547 break; 4548 case LPFC_LINK_SPEED_2GHZ: 4549 fc_host_speed(shost) = FC_PORTSPEED_2GBIT; 4550 break; 4551 case LPFC_LINK_SPEED_4GHZ: 4552 fc_host_speed(shost) = FC_PORTSPEED_4GBIT; 4553 break; 4554 case LPFC_LINK_SPEED_8GHZ: 4555 fc_host_speed(shost) = FC_PORTSPEED_8GBIT; 4556 break; 4557 case LPFC_LINK_SPEED_10GHZ: 4558 fc_host_speed(shost) = FC_PORTSPEED_10GBIT; 4559 break; 4560 case LPFC_LINK_SPEED_16GHZ: 4561 fc_host_speed(shost) = FC_PORTSPEED_16GBIT; 4562 break; 4563 default: 4564 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 4565 break; 4566 } 4567 } else 4568 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 4569 4570 spin_unlock_irq(shost->host_lock); 4571 } 4572 4573 /** 4574 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name 4575 * @shost: kernel scsi host pointer. 4576 **/ 4577 static void 4578 lpfc_get_host_fabric_name (struct Scsi_Host *shost) 4579 { 4580 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4581 struct lpfc_hba *phba = vport->phba; 4582 u64 node_name; 4583 4584 spin_lock_irq(shost->host_lock); 4585 4586 if ((vport->port_state > LPFC_FLOGI) && 4587 ((vport->fc_flag & FC_FABRIC) || 4588 ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) && 4589 (vport->fc_flag & FC_PUBLIC_LOOP)))) 4590 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn); 4591 else 4592 /* fabric is local port if there is no F/FL_Port */ 4593 node_name = 0; 4594 4595 spin_unlock_irq(shost->host_lock); 4596 4597 fc_host_fabric_name(shost) = node_name; 4598 } 4599 4600 /** 4601 * lpfc_get_stats - Return statistical information about the adapter 4602 * @shost: kernel scsi host pointer. 4603 * 4604 * Notes: 4605 * NULL on error for link down, no mbox pool, sli2 active, 4606 * management not allowed, memory allocation error, or mbox error. 4607 * 4608 * Returns: 4609 * NULL for error 4610 * address of the adapter host statistics 4611 **/ 4612 static struct fc_host_statistics * 4613 lpfc_get_stats(struct Scsi_Host *shost) 4614 { 4615 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4616 struct lpfc_hba *phba = vport->phba; 4617 struct lpfc_sli *psli = &phba->sli; 4618 struct fc_host_statistics *hs = &phba->link_stats; 4619 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets; 4620 LPFC_MBOXQ_t *pmboxq; 4621 MAILBOX_t *pmb; 4622 unsigned long seconds; 4623 int rc = 0; 4624 4625 /* 4626 * prevent udev from issuing mailbox commands until the port is 4627 * configured. 4628 */ 4629 if (phba->link_state < LPFC_LINK_DOWN || 4630 !phba->mbox_mem_pool || 4631 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0) 4632 return NULL; 4633 4634 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 4635 return NULL; 4636 4637 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 4638 if (!pmboxq) 4639 return NULL; 4640 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 4641 4642 pmb = &pmboxq->u.mb; 4643 pmb->mbxCommand = MBX_READ_STATUS; 4644 pmb->mbxOwner = OWN_HOST; 4645 pmboxq->context1 = NULL; 4646 pmboxq->vport = vport; 4647 4648 if (vport->fc_flag & FC_OFFLINE_MODE) 4649 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 4650 else 4651 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 4652 4653 if (rc != MBX_SUCCESS) { 4654 if (rc != MBX_TIMEOUT) 4655 mempool_free(pmboxq, phba->mbox_mem_pool); 4656 return NULL; 4657 } 4658 4659 memset(hs, 0, sizeof (struct fc_host_statistics)); 4660 4661 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt; 4662 /* 4663 * The MBX_READ_STATUS returns tx_k_bytes which has to 4664 * converted to words 4665 */ 4666 hs->tx_words = (uint64_t) 4667 ((uint64_t)pmb->un.varRdStatus.xmitByteCnt 4668 * (uint64_t)256); 4669 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt; 4670 hs->rx_words = (uint64_t) 4671 ((uint64_t)pmb->un.varRdStatus.rcvByteCnt 4672 * (uint64_t)256); 4673 4674 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 4675 pmb->mbxCommand = MBX_READ_LNK_STAT; 4676 pmb->mbxOwner = OWN_HOST; 4677 pmboxq->context1 = NULL; 4678 pmboxq->vport = vport; 4679 4680 if (vport->fc_flag & FC_OFFLINE_MODE) 4681 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 4682 else 4683 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 4684 4685 if (rc != MBX_SUCCESS) { 4686 if (rc != MBX_TIMEOUT) 4687 mempool_free(pmboxq, phba->mbox_mem_pool); 4688 return NULL; 4689 } 4690 4691 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 4692 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 4693 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 4694 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 4695 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 4696 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 4697 hs->error_frames = pmb->un.varRdLnk.crcCnt; 4698 4699 hs->link_failure_count -= lso->link_failure_count; 4700 hs->loss_of_sync_count -= lso->loss_of_sync_count; 4701 hs->loss_of_signal_count -= lso->loss_of_signal_count; 4702 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count; 4703 hs->invalid_tx_word_count -= lso->invalid_tx_word_count; 4704 hs->invalid_crc_count -= lso->invalid_crc_count; 4705 hs->error_frames -= lso->error_frames; 4706 4707 if (phba->hba_flag & HBA_FCOE_MODE) { 4708 hs->lip_count = -1; 4709 hs->nos_count = (phba->link_events >> 1); 4710 hs->nos_count -= lso->link_events; 4711 } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) { 4712 hs->lip_count = (phba->fc_eventTag >> 1); 4713 hs->lip_count -= lso->link_events; 4714 hs->nos_count = -1; 4715 } else { 4716 hs->lip_count = -1; 4717 hs->nos_count = (phba->fc_eventTag >> 1); 4718 hs->nos_count -= lso->link_events; 4719 } 4720 4721 hs->dumped_frames = -1; 4722 4723 seconds = get_seconds(); 4724 if (seconds < psli->stats_start) 4725 hs->seconds_since_last_reset = seconds + 4726 ((unsigned long)-1 - psli->stats_start); 4727 else 4728 hs->seconds_since_last_reset = seconds - psli->stats_start; 4729 4730 mempool_free(pmboxq, phba->mbox_mem_pool); 4731 4732 return hs; 4733 } 4734 4735 /** 4736 * lpfc_reset_stats - Copy the adapter link stats information 4737 * @shost: kernel scsi host pointer. 4738 **/ 4739 static void 4740 lpfc_reset_stats(struct Scsi_Host *shost) 4741 { 4742 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4743 struct lpfc_hba *phba = vport->phba; 4744 struct lpfc_sli *psli = &phba->sli; 4745 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets; 4746 LPFC_MBOXQ_t *pmboxq; 4747 MAILBOX_t *pmb; 4748 int rc = 0; 4749 4750 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 4751 return; 4752 4753 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 4754 if (!pmboxq) 4755 return; 4756 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 4757 4758 pmb = &pmboxq->u.mb; 4759 pmb->mbxCommand = MBX_READ_STATUS; 4760 pmb->mbxOwner = OWN_HOST; 4761 pmb->un.varWords[0] = 0x1; /* reset request */ 4762 pmboxq->context1 = NULL; 4763 pmboxq->vport = vport; 4764 4765 if ((vport->fc_flag & FC_OFFLINE_MODE) || 4766 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) 4767 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 4768 else 4769 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 4770 4771 if (rc != MBX_SUCCESS) { 4772 if (rc != MBX_TIMEOUT) 4773 mempool_free(pmboxq, phba->mbox_mem_pool); 4774 return; 4775 } 4776 4777 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 4778 pmb->mbxCommand = MBX_READ_LNK_STAT; 4779 pmb->mbxOwner = OWN_HOST; 4780 pmboxq->context1 = NULL; 4781 pmboxq->vport = vport; 4782 4783 if ((vport->fc_flag & FC_OFFLINE_MODE) || 4784 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) 4785 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 4786 else 4787 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 4788 4789 if (rc != MBX_SUCCESS) { 4790 if (rc != MBX_TIMEOUT) 4791 mempool_free( pmboxq, phba->mbox_mem_pool); 4792 return; 4793 } 4794 4795 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 4796 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 4797 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 4798 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 4799 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 4800 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 4801 lso->error_frames = pmb->un.varRdLnk.crcCnt; 4802 if (phba->hba_flag & HBA_FCOE_MODE) 4803 lso->link_events = (phba->link_events >> 1); 4804 else 4805 lso->link_events = (phba->fc_eventTag >> 1); 4806 4807 psli->stats_start = get_seconds(); 4808 4809 mempool_free(pmboxq, phba->mbox_mem_pool); 4810 4811 return; 4812 } 4813 4814 /* 4815 * The LPFC driver treats linkdown handling as target loss events so there 4816 * are no sysfs handlers for link_down_tmo. 4817 */ 4818 4819 /** 4820 * lpfc_get_node_by_target - Return the nodelist for a target 4821 * @starget: kernel scsi target pointer. 4822 * 4823 * Returns: 4824 * address of the node list if found 4825 * NULL target not found 4826 **/ 4827 static struct lpfc_nodelist * 4828 lpfc_get_node_by_target(struct scsi_target *starget) 4829 { 4830 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 4831 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4832 struct lpfc_nodelist *ndlp; 4833 4834 spin_lock_irq(shost->host_lock); 4835 /* Search for this, mapped, target ID */ 4836 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 4837 if (NLP_CHK_NODE_ACT(ndlp) && 4838 ndlp->nlp_state == NLP_STE_MAPPED_NODE && 4839 starget->id == ndlp->nlp_sid) { 4840 spin_unlock_irq(shost->host_lock); 4841 return ndlp; 4842 } 4843 } 4844 spin_unlock_irq(shost->host_lock); 4845 return NULL; 4846 } 4847 4848 /** 4849 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1 4850 * @starget: kernel scsi target pointer. 4851 **/ 4852 static void 4853 lpfc_get_starget_port_id(struct scsi_target *starget) 4854 { 4855 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 4856 4857 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1; 4858 } 4859 4860 /** 4861 * lpfc_get_starget_node_name - Set the target node name 4862 * @starget: kernel scsi target pointer. 4863 * 4864 * Description: Set the target node name to the ndlp node name wwn or zero. 4865 **/ 4866 static void 4867 lpfc_get_starget_node_name(struct scsi_target *starget) 4868 { 4869 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 4870 4871 fc_starget_node_name(starget) = 4872 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0; 4873 } 4874 4875 /** 4876 * lpfc_get_starget_port_name - Set the target port name 4877 * @starget: kernel scsi target pointer. 4878 * 4879 * Description: set the target port name to the ndlp port name wwn or zero. 4880 **/ 4881 static void 4882 lpfc_get_starget_port_name(struct scsi_target *starget) 4883 { 4884 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 4885 4886 fc_starget_port_name(starget) = 4887 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0; 4888 } 4889 4890 /** 4891 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo 4892 * @rport: fc rport address. 4893 * @timeout: new value for dev loss tmo. 4894 * 4895 * Description: 4896 * If timeout is non zero set the dev_loss_tmo to timeout, else set 4897 * dev_loss_tmo to one. 4898 **/ 4899 static void 4900 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 4901 { 4902 if (timeout) 4903 rport->dev_loss_tmo = timeout; 4904 else 4905 rport->dev_loss_tmo = 1; 4906 } 4907 4908 /** 4909 * lpfc_rport_show_function - Return rport target information 4910 * 4911 * Description: 4912 * Macro that uses field to generate a function with the name lpfc_show_rport_ 4913 * 4914 * lpfc_show_rport_##field: returns the bytes formatted in buf 4915 * @cdev: class converted to an fc_rport. 4916 * @buf: on return contains the target_field or zero. 4917 * 4918 * Returns: size of formatted string. 4919 **/ 4920 #define lpfc_rport_show_function(field, format_string, sz, cast) \ 4921 static ssize_t \ 4922 lpfc_show_rport_##field (struct device *dev, \ 4923 struct device_attribute *attr, \ 4924 char *buf) \ 4925 { \ 4926 struct fc_rport *rport = transport_class_to_rport(dev); \ 4927 struct lpfc_rport_data *rdata = rport->hostdata; \ 4928 return snprintf(buf, sz, format_string, \ 4929 (rdata->target) ? cast rdata->target->field : 0); \ 4930 } 4931 4932 #define lpfc_rport_rd_attr(field, format_string, sz) \ 4933 lpfc_rport_show_function(field, format_string, sz, ) \ 4934 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL) 4935 4936 /** 4937 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name 4938 * @fc_vport: The fc_vport who's symbolic name has been changed. 4939 * 4940 * Description: 4941 * This function is called by the transport after the @fc_vport's symbolic name 4942 * has been changed. This function re-registers the symbolic name with the 4943 * switch to propagate the change into the fabric if the vport is active. 4944 **/ 4945 static void 4946 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport) 4947 { 4948 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 4949 4950 if (vport->port_state == LPFC_VPORT_READY) 4951 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0); 4952 } 4953 4954 /** 4955 * lpfc_hba_log_verbose_init - Set hba's log verbose level 4956 * @phba: Pointer to lpfc_hba struct. 4957 * 4958 * This function is called by the lpfc_get_cfgparam() routine to set the 4959 * module lpfc_log_verbose into the @phba cfg_log_verbose for use with 4960 * log message according to the module's lpfc_log_verbose parameter setting 4961 * before hba port or vport created. 4962 **/ 4963 static void 4964 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose) 4965 { 4966 phba->cfg_log_verbose = verbose; 4967 } 4968 4969 struct fc_function_template lpfc_transport_functions = { 4970 /* fixed attributes the driver supports */ 4971 .show_host_node_name = 1, 4972 .show_host_port_name = 1, 4973 .show_host_supported_classes = 1, 4974 .show_host_supported_fc4s = 1, 4975 .show_host_supported_speeds = 1, 4976 .show_host_maxframe_size = 1, 4977 .show_host_symbolic_name = 1, 4978 4979 /* dynamic attributes the driver supports */ 4980 .get_host_port_id = lpfc_get_host_port_id, 4981 .show_host_port_id = 1, 4982 4983 .get_host_port_type = lpfc_get_host_port_type, 4984 .show_host_port_type = 1, 4985 4986 .get_host_port_state = lpfc_get_host_port_state, 4987 .show_host_port_state = 1, 4988 4989 /* active_fc4s is shown but doesn't change (thus no get function) */ 4990 .show_host_active_fc4s = 1, 4991 4992 .get_host_speed = lpfc_get_host_speed, 4993 .show_host_speed = 1, 4994 4995 .get_host_fabric_name = lpfc_get_host_fabric_name, 4996 .show_host_fabric_name = 1, 4997 4998 /* 4999 * The LPFC driver treats linkdown handling as target loss events 5000 * so there are no sysfs handlers for link_down_tmo. 5001 */ 5002 5003 .get_fc_host_stats = lpfc_get_stats, 5004 .reset_fc_host_stats = lpfc_reset_stats, 5005 5006 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 5007 .show_rport_maxframe_size = 1, 5008 .show_rport_supported_classes = 1, 5009 5010 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 5011 .show_rport_dev_loss_tmo = 1, 5012 5013 .get_starget_port_id = lpfc_get_starget_port_id, 5014 .show_starget_port_id = 1, 5015 5016 .get_starget_node_name = lpfc_get_starget_node_name, 5017 .show_starget_node_name = 1, 5018 5019 .get_starget_port_name = lpfc_get_starget_port_name, 5020 .show_starget_port_name = 1, 5021 5022 .issue_fc_host_lip = lpfc_issue_lip, 5023 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 5024 .terminate_rport_io = lpfc_terminate_rport_io, 5025 5026 .dd_fcvport_size = sizeof(struct lpfc_vport *), 5027 5028 .vport_disable = lpfc_vport_disable, 5029 5030 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name, 5031 5032 .bsg_request = lpfc_bsg_request, 5033 .bsg_timeout = lpfc_bsg_timeout, 5034 }; 5035 5036 struct fc_function_template lpfc_vport_transport_functions = { 5037 /* fixed attributes the driver supports */ 5038 .show_host_node_name = 1, 5039 .show_host_port_name = 1, 5040 .show_host_supported_classes = 1, 5041 .show_host_supported_fc4s = 1, 5042 .show_host_supported_speeds = 1, 5043 .show_host_maxframe_size = 1, 5044 .show_host_symbolic_name = 1, 5045 5046 /* dynamic attributes the driver supports */ 5047 .get_host_port_id = lpfc_get_host_port_id, 5048 .show_host_port_id = 1, 5049 5050 .get_host_port_type = lpfc_get_host_port_type, 5051 .show_host_port_type = 1, 5052 5053 .get_host_port_state = lpfc_get_host_port_state, 5054 .show_host_port_state = 1, 5055 5056 /* active_fc4s is shown but doesn't change (thus no get function) */ 5057 .show_host_active_fc4s = 1, 5058 5059 .get_host_speed = lpfc_get_host_speed, 5060 .show_host_speed = 1, 5061 5062 .get_host_fabric_name = lpfc_get_host_fabric_name, 5063 .show_host_fabric_name = 1, 5064 5065 /* 5066 * The LPFC driver treats linkdown handling as target loss events 5067 * so there are no sysfs handlers for link_down_tmo. 5068 */ 5069 5070 .get_fc_host_stats = lpfc_get_stats, 5071 .reset_fc_host_stats = lpfc_reset_stats, 5072 5073 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 5074 .show_rport_maxframe_size = 1, 5075 .show_rport_supported_classes = 1, 5076 5077 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 5078 .show_rport_dev_loss_tmo = 1, 5079 5080 .get_starget_port_id = lpfc_get_starget_port_id, 5081 .show_starget_port_id = 1, 5082 5083 .get_starget_node_name = lpfc_get_starget_node_name, 5084 .show_starget_node_name = 1, 5085 5086 .get_starget_port_name = lpfc_get_starget_port_name, 5087 .show_starget_port_name = 1, 5088 5089 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 5090 .terminate_rport_io = lpfc_terminate_rport_io, 5091 5092 .vport_disable = lpfc_vport_disable, 5093 5094 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name, 5095 }; 5096 5097 /** 5098 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure 5099 * @phba: lpfc_hba pointer. 5100 **/ 5101 void 5102 lpfc_get_cfgparam(struct lpfc_hba *phba) 5103 { 5104 lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched); 5105 lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset); 5106 lpfc_cr_delay_init(phba, lpfc_cr_delay); 5107 lpfc_cr_count_init(phba, lpfc_cr_count); 5108 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support); 5109 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl); 5110 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type); 5111 lpfc_ack0_init(phba, lpfc_ack0); 5112 lpfc_topology_init(phba, lpfc_topology); 5113 lpfc_link_speed_init(phba, lpfc_link_speed); 5114 lpfc_poll_tmo_init(phba, lpfc_poll_tmo); 5115 lpfc_enable_npiv_init(phba, lpfc_enable_npiv); 5116 lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy); 5117 lpfc_enable_rrq_init(phba, lpfc_enable_rrq); 5118 lpfc_use_msi_init(phba, lpfc_use_msi); 5119 lpfc_fcp_imax_init(phba, lpfc_fcp_imax); 5120 lpfc_fcp_wq_count_init(phba, lpfc_fcp_wq_count); 5121 lpfc_fcp_eq_count_init(phba, lpfc_fcp_eq_count); 5122 lpfc_fcp_io_channel_init(phba, lpfc_fcp_io_channel); 5123 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset); 5124 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat); 5125 lpfc_enable_bg_init(phba, lpfc_enable_bg); 5126 if (phba->sli_rev == LPFC_SLI_REV4) 5127 phba->cfg_poll = 0; 5128 else 5129 phba->cfg_poll = lpfc_poll; 5130 phba->cfg_soft_wwnn = 0L; 5131 phba->cfg_soft_wwpn = 0L; 5132 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt); 5133 lpfc_prot_sg_seg_cnt_init(phba, lpfc_prot_sg_seg_cnt); 5134 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth); 5135 lpfc_hba_log_verbose_init(phba, lpfc_log_verbose); 5136 lpfc_aer_support_init(phba, lpfc_aer_support); 5137 lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn); 5138 lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade); 5139 lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up); 5140 lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt); 5141 phba->cfg_enable_dss = 1; 5142 return; 5143 } 5144 5145 /** 5146 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure 5147 * @vport: lpfc_vport pointer. 5148 **/ 5149 void 5150 lpfc_get_vport_cfgparam(struct lpfc_vport *vport) 5151 { 5152 lpfc_log_verbose_init(vport, lpfc_log_verbose); 5153 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth); 5154 lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth); 5155 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo); 5156 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo); 5157 lpfc_peer_port_login_init(vport, lpfc_peer_port_login); 5158 lpfc_restrict_login_init(vport, lpfc_restrict_login); 5159 lpfc_fcp_class_init(vport, lpfc_fcp_class); 5160 lpfc_use_adisc_init(vport, lpfc_use_adisc); 5161 lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time); 5162 lpfc_fdmi_on_init(vport, lpfc_fdmi_on); 5163 lpfc_discovery_threads_init(vport, lpfc_discovery_threads); 5164 lpfc_max_luns_init(vport, lpfc_max_luns); 5165 lpfc_scan_down_init(vport, lpfc_scan_down); 5166 lpfc_enable_da_id_init(vport, lpfc_enable_da_id); 5167 return; 5168 } 5169