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