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