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