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 LPFC_ATTR(sli_mode, 0, 0, 3, 3014 "SLI mode selector:" 3015 " 0 - auto (SLI-3 if supported)," 3016 " 2 - select SLI-2 even on SLI-3 capable HBAs," 3017 " 3 - select SLI-3"); 3018 3019 LPFC_ATTR_R(enable_npiv, 1, 0, 1, 3020 "Enable NPIV functionality"); 3021 3022 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2, 3023 "FCF Fast failover=1 Priority failover=2"); 3024 3025 /* 3026 # lpfc_enable_rrq: Track XRI/OXID reuse after IO failures 3027 # 0x0 = disabled, XRI/OXID use not tracked. 3028 # 0x1 = XRI/OXID reuse is timed with ratov, RRQ sent. 3029 # 0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent. 3030 */ 3031 LPFC_ATTR_R(enable_rrq, 2, 0, 2, 3032 "Enable RRQ functionality"); 3033 3034 /* 3035 # lpfc_suppress_link_up: Bring link up at initialization 3036 # 0x0 = bring link up (issue MBX_INIT_LINK) 3037 # 0x1 = do NOT bring link up at initialization(MBX_INIT_LINK) 3038 # 0x2 = never bring up link 3039 # Default value is 0. 3040 */ 3041 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK, 3042 LPFC_DELAY_INIT_LINK_INDEFINITELY, 3043 "Suppress Link Up at initialization"); 3044 /* 3045 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS 3046 # 1 - (1024) 3047 # 2 - (2048) 3048 # 3 - (3072) 3049 # 4 - (4096) 3050 # 5 - (5120) 3051 */ 3052 static ssize_t 3053 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf) 3054 { 3055 struct Scsi_Host *shost = class_to_shost(dev); 3056 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; 3057 3058 return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max); 3059 } 3060 3061 static DEVICE_ATTR(iocb_hw, S_IRUGO, 3062 lpfc_iocb_hw_show, NULL); 3063 static ssize_t 3064 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf) 3065 { 3066 struct Scsi_Host *shost = class_to_shost(dev); 3067 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; 3068 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba); 3069 3070 return snprintf(buf, PAGE_SIZE, "%d\n", pring->txq_max); 3071 } 3072 3073 static DEVICE_ATTR(txq_hw, S_IRUGO, 3074 lpfc_txq_hw_show, NULL); 3075 static ssize_t 3076 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr, 3077 char *buf) 3078 { 3079 struct Scsi_Host *shost = class_to_shost(dev); 3080 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba; 3081 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba); 3082 3083 return snprintf(buf, PAGE_SIZE, "%d\n", pring->txcmplq_max); 3084 } 3085 3086 static DEVICE_ATTR(txcmplq_hw, S_IRUGO, 3087 lpfc_txcmplq_hw_show, NULL); 3088 3089 LPFC_ATTR_R(iocb_cnt, 2, 1, 5, 3090 "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs"); 3091 3092 /* 3093 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear 3094 # until the timer expires. Value range is [0,255]. Default value is 30. 3095 */ 3096 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO; 3097 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO; 3098 module_param(lpfc_nodev_tmo, int, 0); 3099 MODULE_PARM_DESC(lpfc_nodev_tmo, 3100 "Seconds driver will hold I/O waiting " 3101 "for a device to come back"); 3102 3103 /** 3104 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value 3105 * @dev: class converted to a Scsi_host structure. 3106 * @attr: device attribute, not used. 3107 * @buf: on return contains the dev loss timeout in decimal. 3108 * 3109 * Returns: size of formatted string. 3110 **/ 3111 static ssize_t 3112 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr, 3113 char *buf) 3114 { 3115 struct Scsi_Host *shost = class_to_shost(dev); 3116 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3117 3118 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo); 3119 } 3120 3121 /** 3122 * lpfc_nodev_tmo_init - Set the hba nodev timeout value 3123 * @vport: lpfc vport structure pointer. 3124 * @val: contains the nodev timeout value. 3125 * 3126 * Description: 3127 * If the devloss tmo is already set then nodev tmo is set to devloss tmo, 3128 * a kernel error message is printed and zero is returned. 3129 * Else if val is in range then nodev tmo and devloss tmo are set to val. 3130 * Otherwise nodev tmo is set to the default value. 3131 * 3132 * Returns: 3133 * zero if already set or if val is in range 3134 * -EINVAL val out of range 3135 **/ 3136 static int 3137 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val) 3138 { 3139 if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) { 3140 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo; 3141 if (val != LPFC_DEF_DEVLOSS_TMO) 3142 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3143 "0407 Ignoring lpfc_nodev_tmo module " 3144 "parameter because lpfc_devloss_tmo " 3145 "is set.\n"); 3146 return 0; 3147 } 3148 3149 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 3150 vport->cfg_nodev_tmo = val; 3151 vport->cfg_devloss_tmo = val; 3152 return 0; 3153 } 3154 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3155 "0400 lpfc_nodev_tmo attribute cannot be set to" 3156 " %d, allowed range is [%d, %d]\n", 3157 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 3158 vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO; 3159 return -EINVAL; 3160 } 3161 3162 /** 3163 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value 3164 * @vport: lpfc vport structure pointer. 3165 * 3166 * Description: 3167 * Update all the ndlp's dev loss tmo with the vport devloss tmo value. 3168 **/ 3169 static void 3170 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport) 3171 { 3172 struct Scsi_Host *shost; 3173 struct lpfc_nodelist *ndlp; 3174 3175 shost = lpfc_shost_from_vport(vport); 3176 spin_lock_irq(shost->host_lock); 3177 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) 3178 if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport) 3179 ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo; 3180 spin_unlock_irq(shost->host_lock); 3181 } 3182 3183 /** 3184 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values 3185 * @vport: lpfc vport structure pointer. 3186 * @val: contains the tmo value. 3187 * 3188 * Description: 3189 * If the devloss tmo is already set or the vport dev loss tmo has changed 3190 * then a kernel error message is printed and zero is returned. 3191 * Else if val is in range then nodev tmo and devloss tmo are set to val. 3192 * Otherwise nodev tmo is set to the default value. 3193 * 3194 * Returns: 3195 * zero if already set or if val is in range 3196 * -EINVAL val out of range 3197 **/ 3198 static int 3199 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val) 3200 { 3201 if (vport->dev_loss_tmo_changed || 3202 (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) { 3203 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3204 "0401 Ignoring change to lpfc_nodev_tmo " 3205 "because lpfc_devloss_tmo is set.\n"); 3206 return 0; 3207 } 3208 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 3209 vport->cfg_nodev_tmo = val; 3210 vport->cfg_devloss_tmo = val; 3211 /* 3212 * For compat: set the fc_host dev loss so new rports 3213 * will get the value. 3214 */ 3215 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val; 3216 lpfc_update_rport_devloss_tmo(vport); 3217 return 0; 3218 } 3219 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3220 "0403 lpfc_nodev_tmo attribute cannot be set to " 3221 "%d, allowed range is [%d, %d]\n", 3222 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 3223 return -EINVAL; 3224 } 3225 3226 lpfc_vport_param_store(nodev_tmo) 3227 3228 static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR, 3229 lpfc_nodev_tmo_show, lpfc_nodev_tmo_store); 3230 3231 /* 3232 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that 3233 # disappear until the timer expires. Value range is [0,255]. Default 3234 # value is 30. 3235 */ 3236 module_param(lpfc_devloss_tmo, int, S_IRUGO); 3237 MODULE_PARM_DESC(lpfc_devloss_tmo, 3238 "Seconds driver will hold I/O waiting " 3239 "for a device to come back"); 3240 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO, 3241 LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO) 3242 lpfc_vport_param_show(devloss_tmo) 3243 3244 /** 3245 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit 3246 * @vport: lpfc vport structure pointer. 3247 * @val: contains the tmo value. 3248 * 3249 * Description: 3250 * If val is in a valid range then set the vport nodev tmo, 3251 * devloss tmo, also set the vport dev loss tmo changed flag. 3252 * Else a kernel error message is printed. 3253 * 3254 * Returns: 3255 * zero if val is in range 3256 * -EINVAL val out of range 3257 **/ 3258 static int 3259 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val) 3260 { 3261 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 3262 vport->cfg_nodev_tmo = val; 3263 vport->cfg_devloss_tmo = val; 3264 vport->dev_loss_tmo_changed = 1; 3265 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val; 3266 lpfc_update_rport_devloss_tmo(vport); 3267 return 0; 3268 } 3269 3270 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3271 "0404 lpfc_devloss_tmo attribute cannot be set to " 3272 "%d, allowed range is [%d, %d]\n", 3273 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 3274 return -EINVAL; 3275 } 3276 3277 lpfc_vport_param_store(devloss_tmo) 3278 static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR, 3279 lpfc_devloss_tmo_show, lpfc_devloss_tmo_store); 3280 3281 /* 3282 * lpfc_suppress_rsp: Enable suppress rsp feature is firmware supports it 3283 * lpfc_suppress_rsp = 0 Disable 3284 * lpfc_suppress_rsp = 1 Enable (default) 3285 * 3286 */ 3287 LPFC_ATTR_R(suppress_rsp, 1, 0, 1, 3288 "Enable suppress rsp feature is firmware supports it"); 3289 3290 /* 3291 * lpfc_nvmet_mrq: Specify number of RQ pairs for processing NVMET cmds 3292 * lpfc_nvmet_mrq = 1 use a single RQ pair 3293 * lpfc_nvmet_mrq >= 2 use specified RQ pairs for MRQ 3294 * 3295 */ 3296 LPFC_ATTR_R(nvmet_mrq, 3297 1, 1, 16, 3298 "Specify number of RQ pairs for processing NVMET cmds"); 3299 3300 /* 3301 * lpfc_nvmet_mrq_post: Specify number buffers to post on every MRQ 3302 * 3303 */ 3304 LPFC_ATTR_R(nvmet_mrq_post, LPFC_DEF_MRQ_POST, 3305 LPFC_MIN_MRQ_POST, LPFC_MAX_MRQ_POST, 3306 "Specify number of buffers to post on every MRQ"); 3307 3308 /* 3309 * lpfc_enable_fc4_type: Defines what FC4 types are supported. 3310 * Supported Values: 1 - register just FCP 3311 * 3 - register both FCP and NVME 3312 * Supported values are [1,3]. Default value is 3 3313 */ 3314 LPFC_ATTR_R(enable_fc4_type, LPFC_ENABLE_BOTH, 3315 LPFC_ENABLE_FCP, LPFC_ENABLE_BOTH, 3316 "Define fc4 type to register with fabric."); 3317 3318 /* 3319 * lpfc_xri_split: Defines the division of XRI resources between SCSI and NVME 3320 * This parameter is only used if: 3321 * lpfc_enable_fc4_type is 3 - register both FCP and NVME and 3322 * port is not configured for NVMET. 3323 * 3324 * ELS/CT always get 10% of XRIs, up to a maximum of 250 3325 * The remaining XRIs get split up based on lpfc_xri_split per port: 3326 * 3327 * Supported Values are in percentages 3328 * the xri_split value is the percentage the SCSI port will get. The remaining 3329 * percentage will go to NVME. 3330 */ 3331 LPFC_ATTR_R(xri_split, 50, 10, 90, 3332 "Division of XRI resources between SCSI and NVME"); 3333 3334 /* 3335 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being 3336 # deluged with LOTS of information. 3337 # You can set a bit mask to record specific types of verbose messages: 3338 # See lpfc_logmsh.h for definitions. 3339 */ 3340 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff, 3341 "Verbose logging bit-mask"); 3342 3343 /* 3344 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters 3345 # objects that have been registered with the nameserver after login. 3346 */ 3347 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1, 3348 "Deregister nameserver objects before LOGO"); 3349 3350 /* 3351 # lun_queue_depth: This parameter is used to limit the number of outstanding 3352 # commands per FCP LUN. Value range is [1,512]. Default value is 30. 3353 # If this parameter value is greater than 1/8th the maximum number of exchanges 3354 # supported by the HBA port, then the lun queue depth will be reduced to 3355 # 1/8th the maximum number of exchanges. 3356 */ 3357 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 512, 3358 "Max number of FCP commands we can queue to a specific LUN"); 3359 3360 /* 3361 # tgt_queue_depth: This parameter is used to limit the number of outstanding 3362 # commands per target port. Value range is [10,65535]. Default value is 65535. 3363 */ 3364 LPFC_VPORT_ATTR_R(tgt_queue_depth, 65535, 10, 65535, 3365 "Max number of FCP commands we can queue to a specific target port"); 3366 3367 /* 3368 # hba_queue_depth: This parameter is used to limit the number of outstanding 3369 # commands per lpfc HBA. Value range is [32,8192]. If this parameter 3370 # value is greater than the maximum number of exchanges supported by the HBA, 3371 # then maximum number of exchanges supported by the HBA is used to determine 3372 # the hba_queue_depth. 3373 */ 3374 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192, 3375 "Max number of FCP commands we can queue to a lpfc HBA"); 3376 3377 /* 3378 # peer_port_login: This parameter allows/prevents logins 3379 # between peer ports hosted on the same physical port. 3380 # When this parameter is set 0 peer ports of same physical port 3381 # are not allowed to login to each other. 3382 # When this parameter is set 1 peer ports of same physical port 3383 # are allowed to login to each other. 3384 # Default value of this parameter is 0. 3385 */ 3386 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1, 3387 "Allow peer ports on the same physical port to login to each " 3388 "other."); 3389 3390 /* 3391 # restrict_login: This parameter allows/prevents logins 3392 # between Virtual Ports and remote initiators. 3393 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from 3394 # other initiators and will attempt to PLOGI all remote ports. 3395 # When this parameter is set (1) Virtual Ports will reject PLOGIs from 3396 # remote ports and will not attempt to PLOGI to other initiators. 3397 # This parameter does not restrict to the physical port. 3398 # This parameter does not restrict logins to Fabric resident remote ports. 3399 # Default value of this parameter is 1. 3400 */ 3401 static int lpfc_restrict_login = 1; 3402 module_param(lpfc_restrict_login, int, S_IRUGO); 3403 MODULE_PARM_DESC(lpfc_restrict_login, 3404 "Restrict virtual ports login to remote initiators."); 3405 lpfc_vport_param_show(restrict_login); 3406 3407 /** 3408 * lpfc_restrict_login_init - Set the vport restrict login flag 3409 * @vport: lpfc vport structure pointer. 3410 * @val: contains the restrict login value. 3411 * 3412 * Description: 3413 * If val is not in a valid range then log a kernel error message and set 3414 * the vport restrict login to one. 3415 * If the port type is physical clear the restrict login flag and return. 3416 * Else set the restrict login flag to val. 3417 * 3418 * Returns: 3419 * zero if val is in range 3420 * -EINVAL val out of range 3421 **/ 3422 static int 3423 lpfc_restrict_login_init(struct lpfc_vport *vport, int val) 3424 { 3425 if (val < 0 || val > 1) { 3426 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3427 "0422 lpfc_restrict_login attribute cannot " 3428 "be set to %d, allowed range is [0, 1]\n", 3429 val); 3430 vport->cfg_restrict_login = 1; 3431 return -EINVAL; 3432 } 3433 if (vport->port_type == LPFC_PHYSICAL_PORT) { 3434 vport->cfg_restrict_login = 0; 3435 return 0; 3436 } 3437 vport->cfg_restrict_login = val; 3438 return 0; 3439 } 3440 3441 /** 3442 * lpfc_restrict_login_set - Set the vport restrict login flag 3443 * @vport: lpfc vport structure pointer. 3444 * @val: contains the restrict login value. 3445 * 3446 * Description: 3447 * If val is not in a valid range then log a kernel error message and set 3448 * the vport restrict login to one. 3449 * If the port type is physical and the val is not zero log a kernel 3450 * error message, clear the restrict login flag and return zero. 3451 * Else set the restrict login flag to val. 3452 * 3453 * Returns: 3454 * zero if val is in range 3455 * -EINVAL val out of range 3456 **/ 3457 static int 3458 lpfc_restrict_login_set(struct lpfc_vport *vport, int val) 3459 { 3460 if (val < 0 || val > 1) { 3461 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3462 "0425 lpfc_restrict_login attribute cannot " 3463 "be set to %d, allowed range is [0, 1]\n", 3464 val); 3465 vport->cfg_restrict_login = 1; 3466 return -EINVAL; 3467 } 3468 if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) { 3469 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3470 "0468 lpfc_restrict_login must be 0 for " 3471 "Physical ports.\n"); 3472 vport->cfg_restrict_login = 0; 3473 return 0; 3474 } 3475 vport->cfg_restrict_login = val; 3476 return 0; 3477 } 3478 lpfc_vport_param_store(restrict_login); 3479 static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR, 3480 lpfc_restrict_login_show, lpfc_restrict_login_store); 3481 3482 /* 3483 # Some disk devices have a "select ID" or "select Target" capability. 3484 # From a protocol standpoint "select ID" usually means select the 3485 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative 3486 # annex" which contains a table that maps a "select ID" (a number 3487 # between 0 and 7F) to an ALPA. By default, for compatibility with 3488 # older drivers, the lpfc driver scans this table from low ALPA to high 3489 # ALPA. 3490 # 3491 # Turning on the scan-down variable (on = 1, off = 0) will 3492 # cause the lpfc driver to use an inverted table, effectively 3493 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1. 3494 # 3495 # (Note: This "select ID" functionality is a LOOP ONLY characteristic 3496 # and will not work across a fabric. Also this parameter will take 3497 # effect only in the case when ALPA map is not available.) 3498 */ 3499 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1, 3500 "Start scanning for devices from highest ALPA to lowest"); 3501 3502 /* 3503 # lpfc_topology: link topology for init link 3504 # 0x0 = attempt loop mode then point-to-point 3505 # 0x01 = internal loopback mode 3506 # 0x02 = attempt point-to-point mode only 3507 # 0x04 = attempt loop mode only 3508 # 0x06 = attempt point-to-point mode then loop 3509 # Set point-to-point mode if you want to run as an N_Port. 3510 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6]. 3511 # Default value is 0. 3512 */ 3513 LPFC_ATTR(topology, 0, 0, 6, 3514 "Select Fibre Channel topology"); 3515 3516 /** 3517 * lpfc_topology_set - Set the adapters topology field 3518 * @phba: lpfc_hba pointer. 3519 * @val: topology value. 3520 * 3521 * Description: 3522 * If val is in a valid range then set the adapter's topology field and 3523 * issue a lip; if the lip fails reset the topology to the old value. 3524 * 3525 * If the value is not in range log a kernel error message and return an error. 3526 * 3527 * Returns: 3528 * zero if val is in range and lip okay 3529 * non-zero return value from lpfc_issue_lip() 3530 * -EINVAL val out of range 3531 **/ 3532 static ssize_t 3533 lpfc_topology_store(struct device *dev, struct device_attribute *attr, 3534 const char *buf, size_t count) 3535 { 3536 struct Scsi_Host *shost = class_to_shost(dev); 3537 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3538 struct lpfc_hba *phba = vport->phba; 3539 int val = 0; 3540 int nolip = 0; 3541 const char *val_buf = buf; 3542 int err; 3543 uint32_t prev_val; 3544 3545 if (!strncmp(buf, "nolip ", strlen("nolip "))) { 3546 nolip = 1; 3547 val_buf = &buf[strlen("nolip ")]; 3548 } 3549 3550 if (!isdigit(val_buf[0])) 3551 return -EINVAL; 3552 if (sscanf(val_buf, "%i", &val) != 1) 3553 return -EINVAL; 3554 3555 if (val >= 0 && val <= 6) { 3556 prev_val = phba->cfg_topology; 3557 if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G && 3558 val == 4) { 3559 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3560 "3113 Loop mode not supported at speed %d\n", 3561 val); 3562 return -EINVAL; 3563 } 3564 if (phba->pcidev->device == PCI_DEVICE_ID_LANCER_G6_FC && 3565 val == 4) { 3566 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3567 "3114 Loop mode not supported\n"); 3568 return -EINVAL; 3569 } 3570 phba->cfg_topology = val; 3571 if (nolip) 3572 return strlen(buf); 3573 3574 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3575 "3054 lpfc_topology changed from %d to %d\n", 3576 prev_val, val); 3577 if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4) 3578 phba->fc_topology_changed = 1; 3579 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport)); 3580 if (err) { 3581 phba->cfg_topology = prev_val; 3582 return -EINVAL; 3583 } else 3584 return strlen(buf); 3585 } 3586 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3587 "%d:0467 lpfc_topology attribute cannot be set to %d, " 3588 "allowed range is [0, 6]\n", 3589 phba->brd_no, val); 3590 return -EINVAL; 3591 } 3592 3593 lpfc_param_show(topology) 3594 static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR, 3595 lpfc_topology_show, lpfc_topology_store); 3596 3597 /** 3598 * lpfc_static_vport_show: Read callback function for 3599 * lpfc_static_vport sysfs file. 3600 * @dev: Pointer to class device object. 3601 * @attr: device attribute structure. 3602 * @buf: Data buffer. 3603 * 3604 * This function is the read call back function for 3605 * lpfc_static_vport sysfs file. The lpfc_static_vport 3606 * sysfs file report the mageability of the vport. 3607 **/ 3608 static ssize_t 3609 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr, 3610 char *buf) 3611 { 3612 struct Scsi_Host *shost = class_to_shost(dev); 3613 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3614 if (vport->vport_flag & STATIC_VPORT) 3615 sprintf(buf, "1\n"); 3616 else 3617 sprintf(buf, "0\n"); 3618 3619 return strlen(buf); 3620 } 3621 3622 /* 3623 * Sysfs attribute to control the statistical data collection. 3624 */ 3625 static DEVICE_ATTR(lpfc_static_vport, S_IRUGO, 3626 lpfc_static_vport_show, NULL); 3627 3628 /** 3629 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file 3630 * @dev: Pointer to class device. 3631 * @buf: Data buffer. 3632 * @count: Size of the data buffer. 3633 * 3634 * This function get called when a user write to the lpfc_stat_data_ctrl 3635 * sysfs file. This function parse the command written to the sysfs file 3636 * and take appropriate action. These commands are used for controlling 3637 * driver statistical data collection. 3638 * Following are the command this function handles. 3639 * 3640 * setbucket <bucket_type> <base> <step> 3641 * = Set the latency buckets. 3642 * destroybucket = destroy all the buckets. 3643 * start = start data collection 3644 * stop = stop data collection 3645 * reset = reset the collected data 3646 **/ 3647 static ssize_t 3648 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr, 3649 const char *buf, size_t count) 3650 { 3651 struct Scsi_Host *shost = class_to_shost(dev); 3652 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3653 struct lpfc_hba *phba = vport->phba; 3654 #define LPFC_MAX_DATA_CTRL_LEN 1024 3655 static char bucket_data[LPFC_MAX_DATA_CTRL_LEN]; 3656 unsigned long i; 3657 char *str_ptr, *token; 3658 struct lpfc_vport **vports; 3659 struct Scsi_Host *v_shost; 3660 char *bucket_type_str, *base_str, *step_str; 3661 unsigned long base, step, bucket_type; 3662 3663 if (!strncmp(buf, "setbucket", strlen("setbucket"))) { 3664 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1)) 3665 return -EINVAL; 3666 3667 strncpy(bucket_data, buf, LPFC_MAX_DATA_CTRL_LEN); 3668 str_ptr = &bucket_data[0]; 3669 /* Ignore this token - this is command token */ 3670 token = strsep(&str_ptr, "\t "); 3671 if (!token) 3672 return -EINVAL; 3673 3674 bucket_type_str = strsep(&str_ptr, "\t "); 3675 if (!bucket_type_str) 3676 return -EINVAL; 3677 3678 if (!strncmp(bucket_type_str, "linear", strlen("linear"))) 3679 bucket_type = LPFC_LINEAR_BUCKET; 3680 else if (!strncmp(bucket_type_str, "power2", strlen("power2"))) 3681 bucket_type = LPFC_POWER2_BUCKET; 3682 else 3683 return -EINVAL; 3684 3685 base_str = strsep(&str_ptr, "\t "); 3686 if (!base_str) 3687 return -EINVAL; 3688 base = simple_strtoul(base_str, NULL, 0); 3689 3690 step_str = strsep(&str_ptr, "\t "); 3691 if (!step_str) 3692 return -EINVAL; 3693 step = simple_strtoul(step_str, NULL, 0); 3694 if (!step) 3695 return -EINVAL; 3696 3697 /* Block the data collection for every vport */ 3698 vports = lpfc_create_vport_work_array(phba); 3699 if (vports == NULL) 3700 return -ENOMEM; 3701 3702 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 3703 v_shost = lpfc_shost_from_vport(vports[i]); 3704 spin_lock_irq(v_shost->host_lock); 3705 /* Block and reset data collection */ 3706 vports[i]->stat_data_blocked = 1; 3707 if (vports[i]->stat_data_enabled) 3708 lpfc_vport_reset_stat_data(vports[i]); 3709 spin_unlock_irq(v_shost->host_lock); 3710 } 3711 3712 /* Set the bucket attributes */ 3713 phba->bucket_type = bucket_type; 3714 phba->bucket_base = base; 3715 phba->bucket_step = step; 3716 3717 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 3718 v_shost = lpfc_shost_from_vport(vports[i]); 3719 3720 /* Unblock data collection */ 3721 spin_lock_irq(v_shost->host_lock); 3722 vports[i]->stat_data_blocked = 0; 3723 spin_unlock_irq(v_shost->host_lock); 3724 } 3725 lpfc_destroy_vport_work_array(phba, vports); 3726 return strlen(buf); 3727 } 3728 3729 if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) { 3730 vports = lpfc_create_vport_work_array(phba); 3731 if (vports == NULL) 3732 return -ENOMEM; 3733 3734 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 3735 v_shost = lpfc_shost_from_vport(vports[i]); 3736 spin_lock_irq(shost->host_lock); 3737 vports[i]->stat_data_blocked = 1; 3738 lpfc_free_bucket(vport); 3739 vport->stat_data_enabled = 0; 3740 vports[i]->stat_data_blocked = 0; 3741 spin_unlock_irq(shost->host_lock); 3742 } 3743 lpfc_destroy_vport_work_array(phba, vports); 3744 phba->bucket_type = LPFC_NO_BUCKET; 3745 phba->bucket_base = 0; 3746 phba->bucket_step = 0; 3747 return strlen(buf); 3748 } 3749 3750 if (!strncmp(buf, "start", strlen("start"))) { 3751 /* If no buckets configured return error */ 3752 if (phba->bucket_type == LPFC_NO_BUCKET) 3753 return -EINVAL; 3754 spin_lock_irq(shost->host_lock); 3755 if (vport->stat_data_enabled) { 3756 spin_unlock_irq(shost->host_lock); 3757 return strlen(buf); 3758 } 3759 lpfc_alloc_bucket(vport); 3760 vport->stat_data_enabled = 1; 3761 spin_unlock_irq(shost->host_lock); 3762 return strlen(buf); 3763 } 3764 3765 if (!strncmp(buf, "stop", strlen("stop"))) { 3766 spin_lock_irq(shost->host_lock); 3767 if (vport->stat_data_enabled == 0) { 3768 spin_unlock_irq(shost->host_lock); 3769 return strlen(buf); 3770 } 3771 lpfc_free_bucket(vport); 3772 vport->stat_data_enabled = 0; 3773 spin_unlock_irq(shost->host_lock); 3774 return strlen(buf); 3775 } 3776 3777 if (!strncmp(buf, "reset", strlen("reset"))) { 3778 if ((phba->bucket_type == LPFC_NO_BUCKET) 3779 || !vport->stat_data_enabled) 3780 return strlen(buf); 3781 spin_lock_irq(shost->host_lock); 3782 vport->stat_data_blocked = 1; 3783 lpfc_vport_reset_stat_data(vport); 3784 vport->stat_data_blocked = 0; 3785 spin_unlock_irq(shost->host_lock); 3786 return strlen(buf); 3787 } 3788 return -EINVAL; 3789 } 3790 3791 3792 /** 3793 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file 3794 * @dev: Pointer to class device object. 3795 * @buf: Data buffer. 3796 * 3797 * This function is the read call back function for 3798 * lpfc_stat_data_ctrl sysfs file. This function report the 3799 * current statistical data collection state. 3800 **/ 3801 static ssize_t 3802 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr, 3803 char *buf) 3804 { 3805 struct Scsi_Host *shost = class_to_shost(dev); 3806 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3807 struct lpfc_hba *phba = vport->phba; 3808 int index = 0; 3809 int i; 3810 char *bucket_type; 3811 unsigned long bucket_value; 3812 3813 switch (phba->bucket_type) { 3814 case LPFC_LINEAR_BUCKET: 3815 bucket_type = "linear"; 3816 break; 3817 case LPFC_POWER2_BUCKET: 3818 bucket_type = "power2"; 3819 break; 3820 default: 3821 bucket_type = "No Bucket"; 3822 break; 3823 } 3824 3825 sprintf(&buf[index], "Statistical Data enabled :%d, " 3826 "blocked :%d, Bucket type :%s, Bucket base :%d," 3827 " Bucket step :%d\nLatency Ranges :", 3828 vport->stat_data_enabled, vport->stat_data_blocked, 3829 bucket_type, phba->bucket_base, phba->bucket_step); 3830 index = strlen(buf); 3831 if (phba->bucket_type != LPFC_NO_BUCKET) { 3832 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) { 3833 if (phba->bucket_type == LPFC_LINEAR_BUCKET) 3834 bucket_value = phba->bucket_base + 3835 phba->bucket_step * i; 3836 else 3837 bucket_value = phba->bucket_base + 3838 (1 << i) * phba->bucket_step; 3839 3840 if (index + 10 > PAGE_SIZE) 3841 break; 3842 sprintf(&buf[index], "%08ld ", bucket_value); 3843 index = strlen(buf); 3844 } 3845 } 3846 sprintf(&buf[index], "\n"); 3847 return strlen(buf); 3848 } 3849 3850 /* 3851 * Sysfs attribute to control the statistical data collection. 3852 */ 3853 static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR, 3854 lpfc_stat_data_ctrl_show, lpfc_stat_data_ctrl_store); 3855 3856 /* 3857 * lpfc_drvr_stat_data: sysfs attr to get driver statistical data. 3858 */ 3859 3860 /* 3861 * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN 3862 * for each target. 3863 */ 3864 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18) 3865 #define MAX_STAT_DATA_SIZE_PER_TARGET \ 3866 STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT) 3867 3868 3869 /** 3870 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute 3871 * @filp: sysfs file 3872 * @kobj: Pointer to the kernel object 3873 * @bin_attr: Attribute object 3874 * @buff: Buffer pointer 3875 * @off: File offset 3876 * @count: Buffer size 3877 * 3878 * This function is the read call back function for lpfc_drvr_stat_data 3879 * sysfs file. This function export the statistical data to user 3880 * applications. 3881 **/ 3882 static ssize_t 3883 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj, 3884 struct bin_attribute *bin_attr, 3885 char *buf, loff_t off, size_t count) 3886 { 3887 struct device *dev = container_of(kobj, struct device, 3888 kobj); 3889 struct Scsi_Host *shost = class_to_shost(dev); 3890 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3891 struct lpfc_hba *phba = vport->phba; 3892 int i = 0, index = 0; 3893 unsigned long nport_index; 3894 struct lpfc_nodelist *ndlp = NULL; 3895 nport_index = (unsigned long)off / 3896 MAX_STAT_DATA_SIZE_PER_TARGET; 3897 3898 if (!vport->stat_data_enabled || vport->stat_data_blocked 3899 || (phba->bucket_type == LPFC_NO_BUCKET)) 3900 return 0; 3901 3902 spin_lock_irq(shost->host_lock); 3903 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 3904 if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data) 3905 continue; 3906 3907 if (nport_index > 0) { 3908 nport_index--; 3909 continue; 3910 } 3911 3912 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET) 3913 > count) 3914 break; 3915 3916 if (!ndlp->lat_data) 3917 continue; 3918 3919 /* Print the WWN */ 3920 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:", 3921 ndlp->nlp_portname.u.wwn[0], 3922 ndlp->nlp_portname.u.wwn[1], 3923 ndlp->nlp_portname.u.wwn[2], 3924 ndlp->nlp_portname.u.wwn[3], 3925 ndlp->nlp_portname.u.wwn[4], 3926 ndlp->nlp_portname.u.wwn[5], 3927 ndlp->nlp_portname.u.wwn[6], 3928 ndlp->nlp_portname.u.wwn[7]); 3929 3930 index = strlen(buf); 3931 3932 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) { 3933 sprintf(&buf[index], "%010u,", 3934 ndlp->lat_data[i].cmd_count); 3935 index = strlen(buf); 3936 } 3937 sprintf(&buf[index], "\n"); 3938 index = strlen(buf); 3939 } 3940 spin_unlock_irq(shost->host_lock); 3941 return index; 3942 } 3943 3944 static struct bin_attribute sysfs_drvr_stat_data_attr = { 3945 .attr = { 3946 .name = "lpfc_drvr_stat_data", 3947 .mode = S_IRUSR, 3948 }, 3949 .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET, 3950 .read = sysfs_drvr_stat_data_read, 3951 .write = NULL, 3952 }; 3953 3954 /* 3955 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel 3956 # connection. 3957 # Value range is [0,16]. Default value is 0. 3958 */ 3959 /** 3960 * lpfc_link_speed_set - Set the adapters link speed 3961 * @phba: lpfc_hba pointer. 3962 * @val: link speed value. 3963 * 3964 * Description: 3965 * If val is in a valid range then set the adapter's link speed field and 3966 * issue a lip; if the lip fails reset the link speed to the old value. 3967 * 3968 * Notes: 3969 * If the value is not in range log a kernel error message and return an error. 3970 * 3971 * Returns: 3972 * zero if val is in range and lip okay. 3973 * non-zero return value from lpfc_issue_lip() 3974 * -EINVAL val out of range 3975 **/ 3976 static ssize_t 3977 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr, 3978 const char *buf, size_t count) 3979 { 3980 struct Scsi_Host *shost = class_to_shost(dev); 3981 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3982 struct lpfc_hba *phba = vport->phba; 3983 int val = LPFC_USER_LINK_SPEED_AUTO; 3984 int nolip = 0; 3985 const char *val_buf = buf; 3986 int err; 3987 uint32_t prev_val, if_type; 3988 3989 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 3990 if (if_type == LPFC_SLI_INTF_IF_TYPE_2 && 3991 phba->hba_flag & HBA_FORCED_LINK_SPEED) 3992 return -EPERM; 3993 3994 if (!strncmp(buf, "nolip ", strlen("nolip "))) { 3995 nolip = 1; 3996 val_buf = &buf[strlen("nolip ")]; 3997 } 3998 3999 if (!isdigit(val_buf[0])) 4000 return -EINVAL; 4001 if (sscanf(val_buf, "%i", &val) != 1) 4002 return -EINVAL; 4003 4004 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4005 "3055 lpfc_link_speed changed from %d to %d %s\n", 4006 phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)"); 4007 4008 if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) || 4009 ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) || 4010 ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) || 4011 ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) || 4012 ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) || 4013 ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) || 4014 ((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb))) { 4015 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4016 "2879 lpfc_link_speed attribute cannot be set " 4017 "to %d. Speed is not supported by this port.\n", 4018 val); 4019 return -EINVAL; 4020 } 4021 if (val == LPFC_USER_LINK_SPEED_16G && 4022 phba->fc_topology == LPFC_TOPOLOGY_LOOP) { 4023 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4024 "3112 lpfc_link_speed attribute cannot be set " 4025 "to %d. Speed is not supported in loop mode.\n", 4026 val); 4027 return -EINVAL; 4028 } 4029 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) && 4030 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) { 4031 prev_val = phba->cfg_link_speed; 4032 phba->cfg_link_speed = val; 4033 if (nolip) 4034 return strlen(buf); 4035 4036 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport)); 4037 if (err) { 4038 phba->cfg_link_speed = prev_val; 4039 return -EINVAL; 4040 } else 4041 return strlen(buf); 4042 } 4043 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4044 "0469 lpfc_link_speed attribute cannot be set to %d, " 4045 "allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val); 4046 return -EINVAL; 4047 } 4048 4049 static int lpfc_link_speed = 0; 4050 module_param(lpfc_link_speed, int, S_IRUGO); 4051 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed"); 4052 lpfc_param_show(link_speed) 4053 4054 /** 4055 * lpfc_link_speed_init - Set the adapters link speed 4056 * @phba: lpfc_hba pointer. 4057 * @val: link speed value. 4058 * 4059 * Description: 4060 * If val is in a valid range then set the adapter's link speed field. 4061 * 4062 * Notes: 4063 * If the value is not in range log a kernel error message, clear the link 4064 * speed and return an error. 4065 * 4066 * Returns: 4067 * zero if val saved. 4068 * -EINVAL val out of range 4069 **/ 4070 static int 4071 lpfc_link_speed_init(struct lpfc_hba *phba, int val) 4072 { 4073 if (val == LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) { 4074 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4075 "3111 lpfc_link_speed of %d cannot " 4076 "support loop mode, setting topology to default.\n", 4077 val); 4078 phba->cfg_topology = 0; 4079 } 4080 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) && 4081 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) { 4082 phba->cfg_link_speed = val; 4083 return 0; 4084 } 4085 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4086 "0405 lpfc_link_speed attribute cannot " 4087 "be set to %d, allowed values are " 4088 "["LPFC_LINK_SPEED_STRING"]\n", val); 4089 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO; 4090 return -EINVAL; 4091 } 4092 4093 static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR, 4094 lpfc_link_speed_show, lpfc_link_speed_store); 4095 4096 /* 4097 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER) 4098 # 0 = aer disabled or not supported 4099 # 1 = aer supported and enabled (default) 4100 # Value range is [0,1]. Default value is 1. 4101 */ 4102 LPFC_ATTR(aer_support, 1, 0, 1, 4103 "Enable PCIe device AER support"); 4104 lpfc_param_show(aer_support) 4105 4106 /** 4107 * lpfc_aer_support_store - Set the adapter for aer support 4108 * 4109 * @dev: class device that is converted into a Scsi_host. 4110 * @attr: device attribute, not used. 4111 * @buf: containing enable or disable aer flag. 4112 * @count: unused variable. 4113 * 4114 * Description: 4115 * If the val is 1 and currently the device's AER capability was not 4116 * enabled, invoke the kernel's enable AER helper routine, trying to 4117 * enable the device's AER capability. If the helper routine enabling 4118 * AER returns success, update the device's cfg_aer_support flag to 4119 * indicate AER is supported by the device; otherwise, if the device 4120 * AER capability is already enabled to support AER, then do nothing. 4121 * 4122 * If the val is 0 and currently the device's AER support was enabled, 4123 * invoke the kernel's disable AER helper routine. After that, update 4124 * the device's cfg_aer_support flag to indicate AER is not supported 4125 * by the device; otherwise, if the device AER capability is already 4126 * disabled from supporting AER, then do nothing. 4127 * 4128 * Returns: 4129 * length of the buf on success if val is in range the intended mode 4130 * is supported. 4131 * -EINVAL if val out of range or intended mode is not supported. 4132 **/ 4133 static ssize_t 4134 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr, 4135 const char *buf, size_t count) 4136 { 4137 struct Scsi_Host *shost = class_to_shost(dev); 4138 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 4139 struct lpfc_hba *phba = vport->phba; 4140 int val = 0, rc = -EINVAL; 4141 4142 if (!isdigit(buf[0])) 4143 return -EINVAL; 4144 if (sscanf(buf, "%i", &val) != 1) 4145 return -EINVAL; 4146 4147 switch (val) { 4148 case 0: 4149 if (phba->hba_flag & HBA_AER_ENABLED) { 4150 rc = pci_disable_pcie_error_reporting(phba->pcidev); 4151 if (!rc) { 4152 spin_lock_irq(&phba->hbalock); 4153 phba->hba_flag &= ~HBA_AER_ENABLED; 4154 spin_unlock_irq(&phba->hbalock); 4155 phba->cfg_aer_support = 0; 4156 rc = strlen(buf); 4157 } else 4158 rc = -EPERM; 4159 } else { 4160 phba->cfg_aer_support = 0; 4161 rc = strlen(buf); 4162 } 4163 break; 4164 case 1: 4165 if (!(phba->hba_flag & HBA_AER_ENABLED)) { 4166 rc = pci_enable_pcie_error_reporting(phba->pcidev); 4167 if (!rc) { 4168 spin_lock_irq(&phba->hbalock); 4169 phba->hba_flag |= HBA_AER_ENABLED; 4170 spin_unlock_irq(&phba->hbalock); 4171 phba->cfg_aer_support = 1; 4172 rc = strlen(buf); 4173 } else 4174 rc = -EPERM; 4175 } else { 4176 phba->cfg_aer_support = 1; 4177 rc = strlen(buf); 4178 } 4179 break; 4180 default: 4181 rc = -EINVAL; 4182 break; 4183 } 4184 return rc; 4185 } 4186 4187 static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR, 4188 lpfc_aer_support_show, lpfc_aer_support_store); 4189 4190 /** 4191 * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device 4192 * @dev: class device that is converted into a Scsi_host. 4193 * @attr: device attribute, not used. 4194 * @buf: containing flag 1 for aer cleanup state. 4195 * @count: unused variable. 4196 * 4197 * Description: 4198 * If the @buf contains 1 and the device currently has the AER support 4199 * enabled, then invokes the kernel AER helper routine 4200 * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable 4201 * error status register. 4202 * 4203 * Notes: 4204 * 4205 * Returns: 4206 * -EINVAL if the buf does not contain the 1 or the device is not currently 4207 * enabled with the AER support. 4208 **/ 4209 static ssize_t 4210 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr, 4211 const char *buf, size_t count) 4212 { 4213 struct Scsi_Host *shost = class_to_shost(dev); 4214 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4215 struct lpfc_hba *phba = vport->phba; 4216 int val, rc = -1; 4217 4218 if (!isdigit(buf[0])) 4219 return -EINVAL; 4220 if (sscanf(buf, "%i", &val) != 1) 4221 return -EINVAL; 4222 if (val != 1) 4223 return -EINVAL; 4224 4225 if (phba->hba_flag & HBA_AER_ENABLED) 4226 rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev); 4227 4228 if (rc == 0) 4229 return strlen(buf); 4230 else 4231 return -EPERM; 4232 } 4233 4234 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL, 4235 lpfc_aer_cleanup_state); 4236 4237 /** 4238 * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions 4239 * 4240 * @dev: class device that is converted into a Scsi_host. 4241 * @attr: device attribute, not used. 4242 * @buf: containing the string the number of vfs to be enabled. 4243 * @count: unused variable. 4244 * 4245 * Description: 4246 * When this api is called either through user sysfs, the driver shall 4247 * try to enable or disable SR-IOV virtual functions according to the 4248 * following: 4249 * 4250 * If zero virtual function has been enabled to the physical function, 4251 * the driver shall invoke the pci enable virtual function api trying 4252 * to enable the virtual functions. If the nr_vfn provided is greater 4253 * than the maximum supported, the maximum virtual function number will 4254 * be used for invoking the api; otherwise, the nr_vfn provided shall 4255 * be used for invoking the api. If the api call returned success, the 4256 * actual number of virtual functions enabled will be set to the driver 4257 * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver 4258 * cfg_sriov_nr_virtfn remains zero. 4259 * 4260 * If none-zero virtual functions have already been enabled to the 4261 * physical function, as reflected by the driver's cfg_sriov_nr_virtfn, 4262 * -EINVAL will be returned and the driver does nothing; 4263 * 4264 * If the nr_vfn provided is zero and none-zero virtual functions have 4265 * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the 4266 * disabling virtual function api shall be invoded to disable all the 4267 * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to 4268 * zero. Otherwise, if zero virtual function has been enabled, do 4269 * nothing. 4270 * 4271 * Returns: 4272 * length of the buf on success if val is in range the intended mode 4273 * is supported. 4274 * -EINVAL if val out of range or intended mode is not supported. 4275 **/ 4276 static ssize_t 4277 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr, 4278 const char *buf, size_t count) 4279 { 4280 struct Scsi_Host *shost = class_to_shost(dev); 4281 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 4282 struct lpfc_hba *phba = vport->phba; 4283 struct pci_dev *pdev = phba->pcidev; 4284 int val = 0, rc = -EINVAL; 4285 4286 /* Sanity check on user data */ 4287 if (!isdigit(buf[0])) 4288 return -EINVAL; 4289 if (sscanf(buf, "%i", &val) != 1) 4290 return -EINVAL; 4291 if (val < 0) 4292 return -EINVAL; 4293 4294 /* Request disabling virtual functions */ 4295 if (val == 0) { 4296 if (phba->cfg_sriov_nr_virtfn > 0) { 4297 pci_disable_sriov(pdev); 4298 phba->cfg_sriov_nr_virtfn = 0; 4299 } 4300 return strlen(buf); 4301 } 4302 4303 /* Request enabling virtual functions */ 4304 if (phba->cfg_sriov_nr_virtfn > 0) { 4305 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4306 "3018 There are %d virtual functions " 4307 "enabled on physical function.\n", 4308 phba->cfg_sriov_nr_virtfn); 4309 return -EEXIST; 4310 } 4311 4312 if (val <= LPFC_MAX_VFN_PER_PFN) 4313 phba->cfg_sriov_nr_virtfn = val; 4314 else { 4315 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4316 "3019 Enabling %d virtual functions is not " 4317 "allowed.\n", val); 4318 return -EINVAL; 4319 } 4320 4321 rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn); 4322 if (rc) { 4323 phba->cfg_sriov_nr_virtfn = 0; 4324 rc = -EPERM; 4325 } else 4326 rc = strlen(buf); 4327 4328 return rc; 4329 } 4330 4331 LPFC_ATTR(sriov_nr_virtfn, LPFC_DEF_VFN_PER_PFN, 0, LPFC_MAX_VFN_PER_PFN, 4332 "Enable PCIe device SR-IOV virtual fn"); 4333 4334 lpfc_param_show(sriov_nr_virtfn) 4335 static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR, 4336 lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store); 4337 4338 /** 4339 * lpfc_request_firmware_store - Request for Linux generic firmware upgrade 4340 * 4341 * @dev: class device that is converted into a Scsi_host. 4342 * @attr: device attribute, not used. 4343 * @buf: containing the string the number of vfs to be enabled. 4344 * @count: unused variable. 4345 * 4346 * Description: 4347 * 4348 * Returns: 4349 * length of the buf on success if val is in range the intended mode 4350 * is supported. 4351 * -EINVAL if val out of range or intended mode is not supported. 4352 **/ 4353 static ssize_t 4354 lpfc_request_firmware_upgrade_store(struct device *dev, 4355 struct device_attribute *attr, 4356 const char *buf, size_t count) 4357 { 4358 struct Scsi_Host *shost = class_to_shost(dev); 4359 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 4360 struct lpfc_hba *phba = vport->phba; 4361 int val = 0, rc = -EINVAL; 4362 4363 /* Sanity check on user data */ 4364 if (!isdigit(buf[0])) 4365 return -EINVAL; 4366 if (sscanf(buf, "%i", &val) != 1) 4367 return -EINVAL; 4368 if (val != 1) 4369 return -EINVAL; 4370 4371 rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE); 4372 if (rc) 4373 rc = -EPERM; 4374 else 4375 rc = strlen(buf); 4376 return rc; 4377 } 4378 4379 static int lpfc_req_fw_upgrade; 4380 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR); 4381 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade"); 4382 lpfc_param_show(request_firmware_upgrade) 4383 4384 /** 4385 * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade 4386 * @phba: lpfc_hba pointer. 4387 * @val: 0 or 1. 4388 * 4389 * Description: 4390 * Set the initial Linux generic firmware upgrade enable or disable flag. 4391 * 4392 * Returns: 4393 * zero if val saved. 4394 * -EINVAL val out of range 4395 **/ 4396 static int 4397 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val) 4398 { 4399 if (val >= 0 && val <= 1) { 4400 phba->cfg_request_firmware_upgrade = val; 4401 return 0; 4402 } 4403 return -EINVAL; 4404 } 4405 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR, 4406 lpfc_request_firmware_upgrade_show, 4407 lpfc_request_firmware_upgrade_store); 4408 4409 /** 4410 * lpfc_fcp_imax_store 4411 * 4412 * @dev: class device that is converted into a Scsi_host. 4413 * @attr: device attribute, not used. 4414 * @buf: string with the number of fast-path FCP interrupts per second. 4415 * @count: unused variable. 4416 * 4417 * Description: 4418 * If val is in a valid range [636,651042], then set the adapter's 4419 * maximum number of fast-path FCP interrupts per second. 4420 * 4421 * Returns: 4422 * length of the buf on success if val is in range the intended mode 4423 * is supported. 4424 * -EINVAL if val out of range or intended mode is not supported. 4425 **/ 4426 static ssize_t 4427 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr, 4428 const char *buf, size_t count) 4429 { 4430 struct Scsi_Host *shost = class_to_shost(dev); 4431 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 4432 struct lpfc_hba *phba = vport->phba; 4433 int val = 0, i; 4434 4435 /* fcp_imax is only valid for SLI4 */ 4436 if (phba->sli_rev != LPFC_SLI_REV4) 4437 return -EINVAL; 4438 4439 /* Sanity check on user data */ 4440 if (!isdigit(buf[0])) 4441 return -EINVAL; 4442 if (sscanf(buf, "%i", &val) != 1) 4443 return -EINVAL; 4444 4445 /* 4446 * Value range for the HBA is [5000,5000000] 4447 * The value for each EQ depends on how many EQs are configured. 4448 * Allow value == 0 4449 */ 4450 if (val && (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX)) 4451 return -EINVAL; 4452 4453 phba->cfg_fcp_imax = (uint32_t)val; 4454 for (i = 0; i < phba->io_channel_irqs; i++) 4455 lpfc_modify_hba_eq_delay(phba, i); 4456 4457 return strlen(buf); 4458 } 4459 4460 /* 4461 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second 4462 # for the HBA. 4463 # 4464 # Value range is [5,000 to 5,000,000]. Default value is 50,000. 4465 */ 4466 static int lpfc_fcp_imax = LPFC_DEF_IMAX; 4467 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR); 4468 MODULE_PARM_DESC(lpfc_fcp_imax, 4469 "Set the maximum number of FCP interrupts per second per HBA"); 4470 lpfc_param_show(fcp_imax) 4471 4472 /** 4473 * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable 4474 * @phba: lpfc_hba pointer. 4475 * @val: link speed value. 4476 * 4477 * Description: 4478 * If val is in a valid range [636,651042], then initialize the adapter's 4479 * maximum number of fast-path FCP interrupts per second. 4480 * 4481 * Returns: 4482 * zero if val saved. 4483 * -EINVAL val out of range 4484 **/ 4485 static int 4486 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val) 4487 { 4488 if (phba->sli_rev != LPFC_SLI_REV4) { 4489 phba->cfg_fcp_imax = 0; 4490 return 0; 4491 } 4492 4493 if ((val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) || 4494 (val == 0)) { 4495 phba->cfg_fcp_imax = val; 4496 return 0; 4497 } 4498 4499 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4500 "3016 lpfc_fcp_imax: %d out of range, using default\n", 4501 val); 4502 phba->cfg_fcp_imax = LPFC_DEF_IMAX; 4503 4504 return 0; 4505 } 4506 4507 static DEVICE_ATTR(lpfc_fcp_imax, S_IRUGO | S_IWUSR, 4508 lpfc_fcp_imax_show, lpfc_fcp_imax_store); 4509 4510 /** 4511 * lpfc_state_show - Display current driver CPU affinity 4512 * @dev: class converted to a Scsi_host structure. 4513 * @attr: device attribute, not used. 4514 * @buf: on return contains text describing the state of the link. 4515 * 4516 * Returns: size of formatted string. 4517 **/ 4518 static ssize_t 4519 lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr, 4520 char *buf) 4521 { 4522 struct Scsi_Host *shost = class_to_shost(dev); 4523 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 4524 struct lpfc_hba *phba = vport->phba; 4525 struct lpfc_vector_map_info *cpup; 4526 int len = 0; 4527 4528 if ((phba->sli_rev != LPFC_SLI_REV4) || 4529 (phba->intr_type != MSIX)) 4530 return len; 4531 4532 switch (phba->cfg_fcp_cpu_map) { 4533 case 0: 4534 len += snprintf(buf + len, PAGE_SIZE-len, 4535 "fcp_cpu_map: No mapping (%d)\n", 4536 phba->cfg_fcp_cpu_map); 4537 return len; 4538 case 1: 4539 len += snprintf(buf + len, PAGE_SIZE-len, 4540 "fcp_cpu_map: HBA centric mapping (%d): " 4541 "%d online CPUs\n", 4542 phba->cfg_fcp_cpu_map, 4543 phba->sli4_hba.num_online_cpu); 4544 break; 4545 case 2: 4546 len += snprintf(buf + len, PAGE_SIZE-len, 4547 "fcp_cpu_map: Driver centric mapping (%d): " 4548 "%d online CPUs\n", 4549 phba->cfg_fcp_cpu_map, 4550 phba->sli4_hba.num_online_cpu); 4551 break; 4552 } 4553 4554 while (phba->sli4_hba.curr_disp_cpu < phba->sli4_hba.num_present_cpu) { 4555 cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu]; 4556 4557 /* margin should fit in this and the truncated message */ 4558 if (cpup->irq == LPFC_VECTOR_MAP_EMPTY) 4559 len += snprintf(buf + len, PAGE_SIZE-len, 4560 "CPU %02d io_chan %02d " 4561 "physid %d coreid %d\n", 4562 phba->sli4_hba.curr_disp_cpu, 4563 cpup->channel_id, cpup->phys_id, 4564 cpup->core_id); 4565 else 4566 len += snprintf(buf + len, PAGE_SIZE-len, 4567 "CPU %02d io_chan %02d " 4568 "physid %d coreid %d IRQ %d\n", 4569 phba->sli4_hba.curr_disp_cpu, 4570 cpup->channel_id, cpup->phys_id, 4571 cpup->core_id, cpup->irq); 4572 4573 phba->sli4_hba.curr_disp_cpu++; 4574 4575 /* display max number of CPUs keeping some margin */ 4576 if (phba->sli4_hba.curr_disp_cpu < 4577 phba->sli4_hba.num_present_cpu && 4578 (len >= (PAGE_SIZE - 64))) { 4579 len += snprintf(buf + len, PAGE_SIZE-len, "more...\n"); 4580 break; 4581 } 4582 } 4583 4584 if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_present_cpu) 4585 phba->sli4_hba.curr_disp_cpu = 0; 4586 4587 return len; 4588 } 4589 4590 /** 4591 * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors 4592 * @dev: class device that is converted into a Scsi_host. 4593 * @attr: device attribute, not used. 4594 * @buf: one or more lpfc_polling_flags values. 4595 * @count: not used. 4596 * 4597 * Returns: 4598 * -EINVAL - Not implemented yet. 4599 **/ 4600 static ssize_t 4601 lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr, 4602 const char *buf, size_t count) 4603 { 4604 int status = -EINVAL; 4605 return status; 4606 } 4607 4608 /* 4609 # lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors 4610 # for the HBA. 4611 # 4612 # Value range is [0 to 2]. Default value is LPFC_DRIVER_CPU_MAP (2). 4613 # 0 - Do not affinitze IRQ vectors 4614 # 1 - Affintize HBA vectors with respect to each HBA 4615 # (start with CPU0 for each HBA) 4616 # 2 - Affintize HBA vectors with respect to the entire driver 4617 # (round robin thru all CPUs across all HBAs) 4618 */ 4619 static int lpfc_fcp_cpu_map = LPFC_DRIVER_CPU_MAP; 4620 module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR); 4621 MODULE_PARM_DESC(lpfc_fcp_cpu_map, 4622 "Defines how to map CPUs to IRQ vectors per HBA"); 4623 4624 /** 4625 * lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable 4626 * @phba: lpfc_hba pointer. 4627 * @val: link speed value. 4628 * 4629 * Description: 4630 * If val is in a valid range [0-2], then affinitze the adapter's 4631 * MSIX vectors. 4632 * 4633 * Returns: 4634 * zero if val saved. 4635 * -EINVAL val out of range 4636 **/ 4637 static int 4638 lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val) 4639 { 4640 if (phba->sli_rev != LPFC_SLI_REV4) { 4641 phba->cfg_fcp_cpu_map = 0; 4642 return 0; 4643 } 4644 4645 if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) { 4646 phba->cfg_fcp_cpu_map = val; 4647 return 0; 4648 } 4649 4650 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4651 "3326 lpfc_fcp_cpu_map: %d out of range, using " 4652 "default\n", val); 4653 phba->cfg_fcp_cpu_map = LPFC_DRIVER_CPU_MAP; 4654 4655 return 0; 4656 } 4657 4658 static DEVICE_ATTR(lpfc_fcp_cpu_map, S_IRUGO | S_IWUSR, 4659 lpfc_fcp_cpu_map_show, lpfc_fcp_cpu_map_store); 4660 4661 /* 4662 # lpfc_fcp_class: Determines FC class to use for the FCP protocol. 4663 # Value range is [2,3]. Default value is 3. 4664 */ 4665 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3, 4666 "Select Fibre Channel class of service for FCP sequences"); 4667 4668 /* 4669 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range 4670 # is [0,1]. Default value is 0. 4671 */ 4672 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1, 4673 "Use ADISC on rediscovery to authenticate FCP devices"); 4674 4675 /* 4676 # lpfc_first_burst_size: First burst size to use on the NPorts 4677 # that support first burst. 4678 # Value range is [0,65536]. Default value is 0. 4679 */ 4680 LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536, 4681 "First burst size for Targets that support first burst"); 4682 4683 /* 4684 * lpfc_nvmet_fb_size: NVME Target mode supported first burst size. 4685 * When the driver is configured as an NVME target, this value is 4686 * communicated to the NVME initiator in the PRLI response. It is 4687 * used only when the lpfc_nvme_enable_fb and lpfc_nvmet_support 4688 * parameters are set and the target is sending the PRLI RSP. 4689 * Parameter supported on physical port only - no NPIV support. 4690 * Value range is [0,65536]. Default value is 0. 4691 */ 4692 LPFC_ATTR_RW(nvmet_fb_size, 0, 0, 65536, 4693 "NVME Target mode first burst size in 512B increments."); 4694 4695 /* 4696 * lpfc_nvme_enable_fb: Enable NVME first burst on I and T functions. 4697 * For the Initiator (I), enabling this parameter means that an NVMET 4698 * PRLI response with FBA enabled and an FB_SIZE set to a nonzero value will be 4699 * processed by the initiator for subsequent NVME FCP IO. For the target 4700 * function (T), enabling this parameter qualifies the lpfc_nvmet_fb_size 4701 * driver parameter as the target function's first burst size returned to the 4702 * initiator in the target's NVME PRLI response. Parameter supported on physical 4703 * port only - no NPIV support. 4704 * Value range is [0,1]. Default value is 0 (disabled). 4705 */ 4706 LPFC_ATTR_RW(nvme_enable_fb, 0, 0, 1, 4707 "Enable First Burst feature on I and T functions."); 4708 4709 /* 4710 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue 4711 # depth. Default value is 0. When the value of this parameter is zero the 4712 # SCSI command completion time is not used for controlling I/O queue depth. When 4713 # the parameter is set to a non-zero value, the I/O queue depth is controlled 4714 # to limit the I/O completion time to the parameter value. 4715 # The value is set in milliseconds. 4716 */ 4717 LPFC_VPORT_ATTR(max_scsicmpl_time, 0, 0, 60000, 4718 "Use command completion time to control queue depth"); 4719 4720 lpfc_vport_param_show(max_scsicmpl_time); 4721 static int 4722 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val) 4723 { 4724 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 4725 struct lpfc_nodelist *ndlp, *next_ndlp; 4726 4727 if (val == vport->cfg_max_scsicmpl_time) 4728 return 0; 4729 if ((val < 0) || (val > 60000)) 4730 return -EINVAL; 4731 vport->cfg_max_scsicmpl_time = val; 4732 4733 spin_lock_irq(shost->host_lock); 4734 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 4735 if (!NLP_CHK_NODE_ACT(ndlp)) 4736 continue; 4737 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 4738 continue; 4739 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth; 4740 } 4741 spin_unlock_irq(shost->host_lock); 4742 return 0; 4743 } 4744 lpfc_vport_param_store(max_scsicmpl_time); 4745 static DEVICE_ATTR(lpfc_max_scsicmpl_time, S_IRUGO | S_IWUSR, 4746 lpfc_max_scsicmpl_time_show, 4747 lpfc_max_scsicmpl_time_store); 4748 4749 /* 4750 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value 4751 # range is [0,1]. Default value is 0. 4752 */ 4753 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support"); 4754 4755 /* 4756 * lpfc_io_sched: Determine scheduling algrithmn for issuing FCP cmds 4757 * range is [0,1]. Default value is 0. 4758 * For [0], FCP commands are issued to Work Queues ina round robin fashion. 4759 * For [1], FCP commands are issued to a Work Queue associated with the 4760 * current CPU. 4761 * 4762 * LPFC_FCP_SCHED_ROUND_ROBIN == 0 4763 * LPFC_FCP_SCHED_BY_CPU == 1 4764 * 4765 * The driver dynamically sets this to 1 (BY_CPU) if it's able to set up cpu 4766 * affinity for FCP/NVME I/Os through Work Queues associated with the current 4767 * CPU. Otherwise, the default 0 (Round Robin) scheduling of FCP/NVME I/Os 4768 * through WQs will be used. 4769 */ 4770 LPFC_ATTR_RW(fcp_io_sched, LPFC_FCP_SCHED_ROUND_ROBIN, 4771 LPFC_FCP_SCHED_ROUND_ROBIN, 4772 LPFC_FCP_SCHED_BY_CPU, 4773 "Determine scheduling algorithm for " 4774 "issuing commands [0] - Round Robin, [1] - Current CPU"); 4775 4776 /* 4777 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior 4778 # range is [0,1]. Default value is 0. 4779 # For [0], bus reset issues target reset to ALL devices 4780 # For [1], bus reset issues target reset to non-FCP2 devices 4781 */ 4782 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for " 4783 "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset"); 4784 4785 4786 /* 4787 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing 4788 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take 4789 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay 4790 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if 4791 # cr_delay is set to 0. 4792 */ 4793 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an " 4794 "interrupt response is generated"); 4795 4796 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an " 4797 "interrupt response is generated"); 4798 4799 /* 4800 # lpfc_multi_ring_support: Determines how many rings to spread available 4801 # cmd/rsp IOCB entries across. 4802 # Value range is [1,2]. Default value is 1. 4803 */ 4804 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary " 4805 "SLI rings to spread IOCB entries across"); 4806 4807 /* 4808 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this 4809 # identifies what rctl value to configure the additional ring for. 4810 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data). 4811 */ 4812 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1, 4813 255, "Identifies RCTL for additional ring configuration"); 4814 4815 /* 4816 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this 4817 # identifies what type value to configure the additional ring for. 4818 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP). 4819 */ 4820 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1, 4821 255, "Identifies TYPE for additional ring configuration"); 4822 4823 /* 4824 # lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN 4825 # 0 = SmartSAN functionality disabled (default) 4826 # 1 = SmartSAN functionality enabled 4827 # This parameter will override the value of lpfc_fdmi_on module parameter. 4828 # Value range is [0,1]. Default value is 0. 4829 */ 4830 LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality"); 4831 4832 /* 4833 # lpfc_fdmi_on: Controls FDMI support. 4834 # 0 No FDMI support (default) 4835 # 1 Traditional FDMI support 4836 # Traditional FDMI support means the driver will assume FDMI-2 support; 4837 # however, if that fails, it will fallback to FDMI-1. 4838 # If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on. 4839 # If lpfc_enable_SmartSAN is set 0, the driver uses the current value of 4840 # lpfc_fdmi_on. 4841 # Value range [0,1]. Default value is 0. 4842 */ 4843 LPFC_ATTR_R(fdmi_on, 0, 0, 1, "Enable FDMI support"); 4844 4845 /* 4846 # Specifies the maximum number of ELS cmds we can have outstanding (for 4847 # discovery). Value range is [1,64]. Default value = 32. 4848 */ 4849 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands " 4850 "during discovery"); 4851 4852 /* 4853 # lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that 4854 # will be scanned by the SCSI midlayer when sequential scanning is 4855 # used; and is also the highest LUN ID allowed when the SCSI midlayer 4856 # parses REPORT_LUN responses. The lpfc driver has no LUN count or 4857 # LUN ID limit, but the SCSI midlayer requires this field for the uses 4858 # above. The lpfc driver limits the default value to 255 for two reasons. 4859 # As it bounds the sequential scan loop, scanning for thousands of luns 4860 # on a target can take minutes of wall clock time. Additionally, 4861 # there are FC targets, such as JBODs, that only recognize 8-bits of 4862 # LUN ID. When they receive a value greater than 8 bits, they chop off 4863 # the high order bits. In other words, they see LUN IDs 0, 256, 512, 4864 # and so on all as LUN ID 0. This causes the linux kernel, which sees 4865 # valid responses at each of the LUN IDs, to believe there are multiple 4866 # devices present, when in fact, there is only 1. 4867 # A customer that is aware of their target behaviors, and the results as 4868 # indicated above, is welcome to increase the lpfc_max_luns value. 4869 # As mentioned, this value is not used by the lpfc driver, only the 4870 # SCSI midlayer. 4871 # Value range is [0,65535]. Default value is 255. 4872 # NOTE: The SCSI layer might probe all allowed LUN on some old targets. 4873 */ 4874 LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID"); 4875 4876 /* 4877 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring. 4878 # Value range is [1,255], default value is 10. 4879 */ 4880 LPFC_ATTR_RW(poll_tmo, 10, 1, 255, 4881 "Milliseconds driver will wait between polling FCP ring"); 4882 4883 /* 4884 # lpfc_task_mgmt_tmo: Maximum time to wait for task management commands 4885 # to complete in seconds. Value range is [5,180], default value is 60. 4886 */ 4887 LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180, 4888 "Maximum time to wait for task management commands to complete"); 4889 /* 4890 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that 4891 # support this feature 4892 # 0 = MSI disabled 4893 # 1 = MSI enabled 4894 # 2 = MSI-X enabled (default) 4895 # Value range is [0,2]. Default value is 2. 4896 */ 4897 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or " 4898 "MSI-X (2), if possible"); 4899 4900 /* 4901 * lpfc_nvme_oas: Use the oas bit when sending NVME/NVMET IOs 4902 * 4903 * 0 = NVME OAS disabled 4904 * 1 = NVME OAS enabled 4905 * 4906 * Value range is [0,1]. Default value is 0. 4907 */ 4908 LPFC_ATTR_RW(nvme_oas, 0, 0, 1, 4909 "Use OAS bit on NVME IOs"); 4910 4911 /* 4912 * lpfc_fcp_io_channel: Set the number of FCP IO channels the driver 4913 * will advertise it supports to the SCSI layer. This also will map to 4914 * the number of WQs the driver will create. 4915 * 4916 * 0 = Configure the number of io channels to the number of active CPUs. 4917 * 1,32 = Manually specify how many io channels to use. 4918 * 4919 * Value range is [0,32]. Default value is 4. 4920 */ 4921 LPFC_ATTR_R(fcp_io_channel, 4922 LPFC_FCP_IO_CHAN_DEF, 4923 LPFC_HBA_IO_CHAN_MIN, LPFC_HBA_IO_CHAN_MAX, 4924 "Set the number of FCP I/O channels"); 4925 4926 /* 4927 * lpfc_nvme_io_channel: Set the number of IO hardware queues the driver 4928 * will advertise it supports to the NVME layer. This also will map to 4929 * the number of WQs the driver will create. 4930 * 4931 * This module parameter is valid when lpfc_enable_fc4_type is set 4932 * to support NVME. 4933 * 4934 * The NVME Layer will try to create this many, plus 1 administrative 4935 * hardware queue. The administrative queue will always map to WQ 0 4936 * A hardware IO queue maps (qidx) to a specific driver WQ. 4937 * 4938 * 0 = Configure the number of io channels to the number of active CPUs. 4939 * 1,32 = Manually specify how many io channels to use. 4940 * 4941 * Value range is [0,32]. Default value is 0. 4942 */ 4943 LPFC_ATTR_R(nvme_io_channel, 4944 LPFC_NVME_IO_CHAN_DEF, 4945 LPFC_HBA_IO_CHAN_MIN, LPFC_HBA_IO_CHAN_MAX, 4946 "Set the number of NVME I/O channels"); 4947 4948 /* 4949 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware. 4950 # 0 = HBA resets disabled 4951 # 1 = HBA resets enabled (default) 4952 # Value range is [0,1]. Default value is 1. 4953 */ 4954 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver."); 4955 4956 /* 4957 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer.. 4958 # 0 = HBA Heartbeat disabled 4959 # 1 = HBA Heartbeat enabled (default) 4960 # Value range is [0,1]. Default value is 1. 4961 */ 4962 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat."); 4963 4964 /* 4965 # lpfc_EnableXLane: Enable Express Lane Feature 4966 # 0x0 Express Lane Feature disabled 4967 # 0x1 Express Lane Feature enabled 4968 # Value range is [0,1]. Default value is 0. 4969 */ 4970 LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature."); 4971 4972 /* 4973 # lpfc_XLanePriority: Define CS_CTL priority for Express Lane Feature 4974 # 0x0 - 0x7f = CS_CTL field in FC header (high 7 bits) 4975 # Value range is [0x0,0x7f]. Default value is 0 4976 */ 4977 LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature."); 4978 4979 /* 4980 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF) 4981 # 0 = BlockGuard disabled (default) 4982 # 1 = BlockGuard enabled 4983 # Value range is [0,1]. Default value is 0. 4984 */ 4985 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support"); 4986 4987 /* 4988 # lpfc_fcp_look_ahead: Look ahead for completions in FCP start routine 4989 # 0 = disabled (default) 4990 # 1 = enabled 4991 # Value range is [0,1]. Default value is 0. 4992 # 4993 # This feature in under investigation and may be supported in the future. 4994 */ 4995 unsigned int lpfc_fcp_look_ahead = LPFC_LOOK_AHEAD_OFF; 4996 4997 /* 4998 # lpfc_prot_mask: i 4999 # - Bit mask of host protection capabilities used to register with the 5000 # SCSI mid-layer 5001 # - Only meaningful if BG is turned on (lpfc_enable_bg=1). 5002 # - Allows you to ultimately specify which profiles to use 5003 # - Default will result in registering capabilities for all profiles. 5004 # - SHOST_DIF_TYPE1_PROTECTION 1 5005 # HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection 5006 # - SHOST_DIX_TYPE0_PROTECTION 8 5007 # HBA supports DIX Type 0: Host to HBA protection only 5008 # - SHOST_DIX_TYPE1_PROTECTION 16 5009 # HBA supports DIX Type 1: Host to HBA Type 1 protection 5010 # 5011 */ 5012 LPFC_ATTR(prot_mask, 5013 (SHOST_DIF_TYPE1_PROTECTION | 5014 SHOST_DIX_TYPE0_PROTECTION | 5015 SHOST_DIX_TYPE1_PROTECTION), 5016 0, 5017 (SHOST_DIF_TYPE1_PROTECTION | 5018 SHOST_DIX_TYPE0_PROTECTION | 5019 SHOST_DIX_TYPE1_PROTECTION), 5020 "T10-DIF host protection capabilities mask"); 5021 5022 /* 5023 # lpfc_prot_guard: i 5024 # - Bit mask of protection guard types to register with the SCSI mid-layer 5025 # - Guard types are currently either 1) T10-DIF CRC 2) IP checksum 5026 # - Allows you to ultimately specify which profiles to use 5027 # - Default will result in registering capabilities for all guard types 5028 # 5029 */ 5030 LPFC_ATTR(prot_guard, 5031 SHOST_DIX_GUARD_IP, SHOST_DIX_GUARD_CRC, SHOST_DIX_GUARD_IP, 5032 "T10-DIF host protection guard type"); 5033 5034 /* 5035 * Delay initial NPort discovery when Clean Address bit is cleared in 5036 * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed. 5037 * This parameter can have value 0 or 1. 5038 * When this parameter is set to 0, no delay is added to the initial 5039 * discovery. 5040 * When this parameter is set to non-zero value, initial Nport discovery is 5041 * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC 5042 * accept and FCID/Fabric name/Fabric portname is changed. 5043 * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion 5044 * when Clean Address bit is cleared in FLOGI/FDISC 5045 * accept and FCID/Fabric name/Fabric portname is changed. 5046 * Default value is 0. 5047 */ 5048 LPFC_ATTR(delay_discovery, 0, 0, 1, 5049 "Delay NPort discovery when Clean Address bit is cleared."); 5050 5051 /* 5052 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count 5053 * This value can be set to values between 64 and 4096. The default value is 5054 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer 5055 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE). 5056 * Because of the additional overhead involved in setting up T10-DIF, 5057 * this parameter will be limited to 128 if BlockGuard is enabled under SLI4 5058 * and will be limited to 512 if BlockGuard is enabled under SLI3. 5059 */ 5060 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT, 5061 LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count"); 5062 5063 /* 5064 * lpfc_enable_mds_diags: Enable MDS Diagnostics 5065 * 0 = MDS Diagnostics disabled (default) 5066 * 1 = MDS Diagnostics enabled 5067 * Value range is [0,1]. Default value is 0. 5068 */ 5069 LPFC_ATTR_R(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics"); 5070 5071 struct device_attribute *lpfc_hba_attrs[] = { 5072 &dev_attr_nvme_info, 5073 &dev_attr_bg_info, 5074 &dev_attr_bg_guard_err, 5075 &dev_attr_bg_apptag_err, 5076 &dev_attr_bg_reftag_err, 5077 &dev_attr_info, 5078 &dev_attr_serialnum, 5079 &dev_attr_modeldesc, 5080 &dev_attr_modelname, 5081 &dev_attr_programtype, 5082 &dev_attr_portnum, 5083 &dev_attr_fwrev, 5084 &dev_attr_hdw, 5085 &dev_attr_option_rom_version, 5086 &dev_attr_link_state, 5087 &dev_attr_num_discovered_ports, 5088 &dev_attr_menlo_mgmt_mode, 5089 &dev_attr_lpfc_drvr_version, 5090 &dev_attr_lpfc_enable_fip, 5091 &dev_attr_lpfc_temp_sensor, 5092 &dev_attr_lpfc_log_verbose, 5093 &dev_attr_lpfc_lun_queue_depth, 5094 &dev_attr_lpfc_tgt_queue_depth, 5095 &dev_attr_lpfc_hba_queue_depth, 5096 &dev_attr_lpfc_peer_port_login, 5097 &dev_attr_lpfc_nodev_tmo, 5098 &dev_attr_lpfc_devloss_tmo, 5099 &dev_attr_lpfc_enable_fc4_type, 5100 &dev_attr_lpfc_xri_split, 5101 &dev_attr_lpfc_fcp_class, 5102 &dev_attr_lpfc_use_adisc, 5103 &dev_attr_lpfc_first_burst_size, 5104 &dev_attr_lpfc_ack0, 5105 &dev_attr_lpfc_topology, 5106 &dev_attr_lpfc_scan_down, 5107 &dev_attr_lpfc_link_speed, 5108 &dev_attr_lpfc_fcp_io_sched, 5109 &dev_attr_lpfc_fcp2_no_tgt_reset, 5110 &dev_attr_lpfc_cr_delay, 5111 &dev_attr_lpfc_cr_count, 5112 &dev_attr_lpfc_multi_ring_support, 5113 &dev_attr_lpfc_multi_ring_rctl, 5114 &dev_attr_lpfc_multi_ring_type, 5115 &dev_attr_lpfc_fdmi_on, 5116 &dev_attr_lpfc_enable_SmartSAN, 5117 &dev_attr_lpfc_max_luns, 5118 &dev_attr_lpfc_enable_npiv, 5119 &dev_attr_lpfc_fcf_failover_policy, 5120 &dev_attr_lpfc_enable_rrq, 5121 &dev_attr_nport_evt_cnt, 5122 &dev_attr_board_mode, 5123 &dev_attr_max_vpi, 5124 &dev_attr_used_vpi, 5125 &dev_attr_max_rpi, 5126 &dev_attr_used_rpi, 5127 &dev_attr_max_xri, 5128 &dev_attr_used_xri, 5129 &dev_attr_npiv_info, 5130 &dev_attr_issue_reset, 5131 &dev_attr_lpfc_poll, 5132 &dev_attr_lpfc_poll_tmo, 5133 &dev_attr_lpfc_task_mgmt_tmo, 5134 &dev_attr_lpfc_use_msi, 5135 &dev_attr_lpfc_nvme_oas, 5136 &dev_attr_lpfc_fcp_imax, 5137 &dev_attr_lpfc_fcp_cpu_map, 5138 &dev_attr_lpfc_fcp_io_channel, 5139 &dev_attr_lpfc_suppress_rsp, 5140 &dev_attr_lpfc_nvme_io_channel, 5141 &dev_attr_lpfc_nvmet_mrq, 5142 &dev_attr_lpfc_nvmet_mrq_post, 5143 &dev_attr_lpfc_nvme_enable_fb, 5144 &dev_attr_lpfc_nvmet_fb_size, 5145 &dev_attr_lpfc_enable_bg, 5146 &dev_attr_lpfc_soft_wwnn, 5147 &dev_attr_lpfc_soft_wwpn, 5148 &dev_attr_lpfc_soft_wwn_enable, 5149 &dev_attr_lpfc_enable_hba_reset, 5150 &dev_attr_lpfc_enable_hba_heartbeat, 5151 &dev_attr_lpfc_EnableXLane, 5152 &dev_attr_lpfc_XLanePriority, 5153 &dev_attr_lpfc_xlane_lun, 5154 &dev_attr_lpfc_xlane_tgt, 5155 &dev_attr_lpfc_xlane_vpt, 5156 &dev_attr_lpfc_xlane_lun_state, 5157 &dev_attr_lpfc_xlane_lun_status, 5158 &dev_attr_lpfc_xlane_priority, 5159 &dev_attr_lpfc_sg_seg_cnt, 5160 &dev_attr_lpfc_max_scsicmpl_time, 5161 &dev_attr_lpfc_stat_data_ctrl, 5162 &dev_attr_lpfc_aer_support, 5163 &dev_attr_lpfc_aer_state_cleanup, 5164 &dev_attr_lpfc_sriov_nr_virtfn, 5165 &dev_attr_lpfc_req_fw_upgrade, 5166 &dev_attr_lpfc_suppress_link_up, 5167 &dev_attr_lpfc_iocb_cnt, 5168 &dev_attr_iocb_hw, 5169 &dev_attr_txq_hw, 5170 &dev_attr_txcmplq_hw, 5171 &dev_attr_lpfc_fips_level, 5172 &dev_attr_lpfc_fips_rev, 5173 &dev_attr_lpfc_dss, 5174 &dev_attr_lpfc_sriov_hw_max_virtfn, 5175 &dev_attr_protocol, 5176 &dev_attr_lpfc_xlane_supported, 5177 &dev_attr_lpfc_enable_mds_diags, 5178 NULL, 5179 }; 5180 5181 struct device_attribute *lpfc_vport_attrs[] = { 5182 &dev_attr_info, 5183 &dev_attr_link_state, 5184 &dev_attr_num_discovered_ports, 5185 &dev_attr_lpfc_drvr_version, 5186 &dev_attr_lpfc_log_verbose, 5187 &dev_attr_lpfc_lun_queue_depth, 5188 &dev_attr_lpfc_tgt_queue_depth, 5189 &dev_attr_lpfc_nodev_tmo, 5190 &dev_attr_lpfc_devloss_tmo, 5191 &dev_attr_lpfc_hba_queue_depth, 5192 &dev_attr_lpfc_peer_port_login, 5193 &dev_attr_lpfc_restrict_login, 5194 &dev_attr_lpfc_fcp_class, 5195 &dev_attr_lpfc_use_adisc, 5196 &dev_attr_lpfc_first_burst_size, 5197 &dev_attr_lpfc_max_luns, 5198 &dev_attr_nport_evt_cnt, 5199 &dev_attr_npiv_info, 5200 &dev_attr_lpfc_enable_da_id, 5201 &dev_attr_lpfc_max_scsicmpl_time, 5202 &dev_attr_lpfc_stat_data_ctrl, 5203 &dev_attr_lpfc_static_vport, 5204 &dev_attr_lpfc_fips_level, 5205 &dev_attr_lpfc_fips_rev, 5206 NULL, 5207 }; 5208 5209 /** 5210 * sysfs_ctlreg_write - Write method for writing to ctlreg 5211 * @filp: open sysfs file 5212 * @kobj: kernel kobject that contains the kernel class device. 5213 * @bin_attr: kernel attributes passed to us. 5214 * @buf: contains the data to be written to the adapter IOREG space. 5215 * @off: offset into buffer to beginning of data. 5216 * @count: bytes to transfer. 5217 * 5218 * Description: 5219 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg. 5220 * Uses the adapter io control registers to send buf contents to the adapter. 5221 * 5222 * Returns: 5223 * -ERANGE off and count combo out of range 5224 * -EINVAL off, count or buff address invalid 5225 * -EPERM adapter is offline 5226 * value of count, buf contents written 5227 **/ 5228 static ssize_t 5229 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj, 5230 struct bin_attribute *bin_attr, 5231 char *buf, loff_t off, size_t count) 5232 { 5233 size_t buf_off; 5234 struct device *dev = container_of(kobj, struct device, kobj); 5235 struct Scsi_Host *shost = class_to_shost(dev); 5236 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5237 struct lpfc_hba *phba = vport->phba; 5238 5239 if (phba->sli_rev >= LPFC_SLI_REV4) 5240 return -EPERM; 5241 5242 if ((off + count) > FF_REG_AREA_SIZE) 5243 return -ERANGE; 5244 5245 if (count <= LPFC_REG_WRITE_KEY_SIZE) 5246 return 0; 5247 5248 if (off % 4 || count % 4 || (unsigned long)buf % 4) 5249 return -EINVAL; 5250 5251 /* This is to protect HBA registers from accidental writes. */ 5252 if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE)) 5253 return -EINVAL; 5254 5255 if (!(vport->fc_flag & FC_OFFLINE_MODE)) 5256 return -EPERM; 5257 5258 spin_lock_irq(&phba->hbalock); 5259 for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE; 5260 buf_off += sizeof(uint32_t)) 5261 writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)), 5262 phba->ctrl_regs_memmap_p + off + buf_off); 5263 5264 spin_unlock_irq(&phba->hbalock); 5265 5266 return count; 5267 } 5268 5269 /** 5270 * sysfs_ctlreg_read - Read method for reading from ctlreg 5271 * @filp: open sysfs file 5272 * @kobj: kernel kobject that contains the kernel class device. 5273 * @bin_attr: kernel attributes passed to us. 5274 * @buf: if successful contains the data from the adapter IOREG space. 5275 * @off: offset into buffer to beginning of data. 5276 * @count: bytes to transfer. 5277 * 5278 * Description: 5279 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg. 5280 * Uses the adapter io control registers to read data into buf. 5281 * 5282 * Returns: 5283 * -ERANGE off and count combo out of range 5284 * -EINVAL off, count or buff address invalid 5285 * value of count, buf contents read 5286 **/ 5287 static ssize_t 5288 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj, 5289 struct bin_attribute *bin_attr, 5290 char *buf, loff_t off, size_t count) 5291 { 5292 size_t buf_off; 5293 uint32_t * tmp_ptr; 5294 struct device *dev = container_of(kobj, struct device, kobj); 5295 struct Scsi_Host *shost = class_to_shost(dev); 5296 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5297 struct lpfc_hba *phba = vport->phba; 5298 5299 if (phba->sli_rev >= LPFC_SLI_REV4) 5300 return -EPERM; 5301 5302 if (off > FF_REG_AREA_SIZE) 5303 return -ERANGE; 5304 5305 if ((off + count) > FF_REG_AREA_SIZE) 5306 count = FF_REG_AREA_SIZE - off; 5307 5308 if (count == 0) return 0; 5309 5310 if (off % 4 || count % 4 || (unsigned long)buf % 4) 5311 return -EINVAL; 5312 5313 spin_lock_irq(&phba->hbalock); 5314 5315 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) { 5316 tmp_ptr = (uint32_t *)(buf + buf_off); 5317 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off); 5318 } 5319 5320 spin_unlock_irq(&phba->hbalock); 5321 5322 return count; 5323 } 5324 5325 static struct bin_attribute sysfs_ctlreg_attr = { 5326 .attr = { 5327 .name = "ctlreg", 5328 .mode = S_IRUSR | S_IWUSR, 5329 }, 5330 .size = 256, 5331 .read = sysfs_ctlreg_read, 5332 .write = sysfs_ctlreg_write, 5333 }; 5334 5335 /** 5336 * sysfs_mbox_write - Write method for writing information via mbox 5337 * @filp: open sysfs file 5338 * @kobj: kernel kobject that contains the kernel class device. 5339 * @bin_attr: kernel attributes passed to us. 5340 * @buf: contains the data to be written to sysfs mbox. 5341 * @off: offset into buffer to beginning of data. 5342 * @count: bytes to transfer. 5343 * 5344 * Description: 5345 * Deprecated function. All mailbox access from user space is performed via the 5346 * bsg interface. 5347 * 5348 * Returns: 5349 * -EPERM operation not permitted 5350 **/ 5351 static ssize_t 5352 sysfs_mbox_write(struct file *filp, struct kobject *kobj, 5353 struct bin_attribute *bin_attr, 5354 char *buf, loff_t off, size_t count) 5355 { 5356 return -EPERM; 5357 } 5358 5359 /** 5360 * sysfs_mbox_read - Read method for reading information via mbox 5361 * @filp: open sysfs file 5362 * @kobj: kernel kobject that contains the kernel class device. 5363 * @bin_attr: kernel attributes passed to us. 5364 * @buf: contains the data to be read from sysfs mbox. 5365 * @off: offset into buffer to beginning of data. 5366 * @count: bytes to transfer. 5367 * 5368 * Description: 5369 * Deprecated function. All mailbox access from user space is performed via the 5370 * bsg interface. 5371 * 5372 * Returns: 5373 * -EPERM operation not permitted 5374 **/ 5375 static ssize_t 5376 sysfs_mbox_read(struct file *filp, struct kobject *kobj, 5377 struct bin_attribute *bin_attr, 5378 char *buf, loff_t off, size_t count) 5379 { 5380 return -EPERM; 5381 } 5382 5383 static struct bin_attribute sysfs_mbox_attr = { 5384 .attr = { 5385 .name = "mbox", 5386 .mode = S_IRUSR | S_IWUSR, 5387 }, 5388 .size = MAILBOX_SYSFS_MAX, 5389 .read = sysfs_mbox_read, 5390 .write = sysfs_mbox_write, 5391 }; 5392 5393 /** 5394 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries 5395 * @vport: address of lpfc vport structure. 5396 * 5397 * Return codes: 5398 * zero on success 5399 * error return code from sysfs_create_bin_file() 5400 **/ 5401 int 5402 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport) 5403 { 5404 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 5405 int error; 5406 5407 error = sysfs_create_bin_file(&shost->shost_dev.kobj, 5408 &sysfs_drvr_stat_data_attr); 5409 5410 /* Virtual ports do not need ctrl_reg and mbox */ 5411 if (error || vport->port_type == LPFC_NPIV_PORT) 5412 goto out; 5413 5414 error = sysfs_create_bin_file(&shost->shost_dev.kobj, 5415 &sysfs_ctlreg_attr); 5416 if (error) 5417 goto out_remove_stat_attr; 5418 5419 error = sysfs_create_bin_file(&shost->shost_dev.kobj, 5420 &sysfs_mbox_attr); 5421 if (error) 5422 goto out_remove_ctlreg_attr; 5423 5424 return 0; 5425 out_remove_ctlreg_attr: 5426 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr); 5427 out_remove_stat_attr: 5428 sysfs_remove_bin_file(&shost->shost_dev.kobj, 5429 &sysfs_drvr_stat_data_attr); 5430 out: 5431 return error; 5432 } 5433 5434 /** 5435 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries 5436 * @vport: address of lpfc vport structure. 5437 **/ 5438 void 5439 lpfc_free_sysfs_attr(struct lpfc_vport *vport) 5440 { 5441 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 5442 sysfs_remove_bin_file(&shost->shost_dev.kobj, 5443 &sysfs_drvr_stat_data_attr); 5444 /* Virtual ports do not need ctrl_reg and mbox */ 5445 if (vport->port_type == LPFC_NPIV_PORT) 5446 return; 5447 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr); 5448 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr); 5449 } 5450 5451 /* 5452 * Dynamic FC Host Attributes Support 5453 */ 5454 5455 /** 5456 * lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host 5457 * @shost: kernel scsi host pointer. 5458 **/ 5459 static void 5460 lpfc_get_host_symbolic_name(struct Scsi_Host *shost) 5461 { 5462 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; 5463 5464 lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost), 5465 sizeof fc_host_symbolic_name(shost)); 5466 } 5467 5468 /** 5469 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id 5470 * @shost: kernel scsi host pointer. 5471 **/ 5472 static void 5473 lpfc_get_host_port_id(struct Scsi_Host *shost) 5474 { 5475 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5476 5477 /* note: fc_myDID already in cpu endianness */ 5478 fc_host_port_id(shost) = vport->fc_myDID; 5479 } 5480 5481 /** 5482 * lpfc_get_host_port_type - Set the value of the scsi host port type 5483 * @shost: kernel scsi host pointer. 5484 **/ 5485 static void 5486 lpfc_get_host_port_type(struct Scsi_Host *shost) 5487 { 5488 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5489 struct lpfc_hba *phba = vport->phba; 5490 5491 spin_lock_irq(shost->host_lock); 5492 5493 if (vport->port_type == LPFC_NPIV_PORT) { 5494 fc_host_port_type(shost) = FC_PORTTYPE_NPIV; 5495 } else if (lpfc_is_link_up(phba)) { 5496 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) { 5497 if (vport->fc_flag & FC_PUBLIC_LOOP) 5498 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT; 5499 else 5500 fc_host_port_type(shost) = FC_PORTTYPE_LPORT; 5501 } else { 5502 if (vport->fc_flag & FC_FABRIC) 5503 fc_host_port_type(shost) = FC_PORTTYPE_NPORT; 5504 else 5505 fc_host_port_type(shost) = FC_PORTTYPE_PTP; 5506 } 5507 } else 5508 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN; 5509 5510 spin_unlock_irq(shost->host_lock); 5511 } 5512 5513 /** 5514 * lpfc_get_host_port_state - Set the value of the scsi host port state 5515 * @shost: kernel scsi host pointer. 5516 **/ 5517 static void 5518 lpfc_get_host_port_state(struct Scsi_Host *shost) 5519 { 5520 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5521 struct lpfc_hba *phba = vport->phba; 5522 5523 spin_lock_irq(shost->host_lock); 5524 5525 if (vport->fc_flag & FC_OFFLINE_MODE) 5526 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 5527 else { 5528 switch (phba->link_state) { 5529 case LPFC_LINK_UNKNOWN: 5530 case LPFC_LINK_DOWN: 5531 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 5532 break; 5533 case LPFC_LINK_UP: 5534 case LPFC_CLEAR_LA: 5535 case LPFC_HBA_READY: 5536 /* Links up, reports port state accordingly */ 5537 if (vport->port_state < LPFC_VPORT_READY) 5538 fc_host_port_state(shost) = 5539 FC_PORTSTATE_BYPASSED; 5540 else 5541 fc_host_port_state(shost) = 5542 FC_PORTSTATE_ONLINE; 5543 break; 5544 case LPFC_HBA_ERROR: 5545 fc_host_port_state(shost) = FC_PORTSTATE_ERROR; 5546 break; 5547 default: 5548 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 5549 break; 5550 } 5551 } 5552 5553 spin_unlock_irq(shost->host_lock); 5554 } 5555 5556 /** 5557 * lpfc_get_host_speed - Set the value of the scsi host speed 5558 * @shost: kernel scsi host pointer. 5559 **/ 5560 static void 5561 lpfc_get_host_speed(struct Scsi_Host *shost) 5562 { 5563 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5564 struct lpfc_hba *phba = vport->phba; 5565 5566 spin_lock_irq(shost->host_lock); 5567 5568 if ((lpfc_is_link_up(phba)) && (!(phba->hba_flag & HBA_FCOE_MODE))) { 5569 switch(phba->fc_linkspeed) { 5570 case LPFC_LINK_SPEED_1GHZ: 5571 fc_host_speed(shost) = FC_PORTSPEED_1GBIT; 5572 break; 5573 case LPFC_LINK_SPEED_2GHZ: 5574 fc_host_speed(shost) = FC_PORTSPEED_2GBIT; 5575 break; 5576 case LPFC_LINK_SPEED_4GHZ: 5577 fc_host_speed(shost) = FC_PORTSPEED_4GBIT; 5578 break; 5579 case LPFC_LINK_SPEED_8GHZ: 5580 fc_host_speed(shost) = FC_PORTSPEED_8GBIT; 5581 break; 5582 case LPFC_LINK_SPEED_10GHZ: 5583 fc_host_speed(shost) = FC_PORTSPEED_10GBIT; 5584 break; 5585 case LPFC_LINK_SPEED_16GHZ: 5586 fc_host_speed(shost) = FC_PORTSPEED_16GBIT; 5587 break; 5588 case LPFC_LINK_SPEED_32GHZ: 5589 fc_host_speed(shost) = FC_PORTSPEED_32GBIT; 5590 break; 5591 default: 5592 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 5593 break; 5594 } 5595 } else 5596 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 5597 5598 spin_unlock_irq(shost->host_lock); 5599 } 5600 5601 /** 5602 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name 5603 * @shost: kernel scsi host pointer. 5604 **/ 5605 static void 5606 lpfc_get_host_fabric_name (struct Scsi_Host *shost) 5607 { 5608 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5609 struct lpfc_hba *phba = vport->phba; 5610 u64 node_name; 5611 5612 spin_lock_irq(shost->host_lock); 5613 5614 if ((vport->port_state > LPFC_FLOGI) && 5615 ((vport->fc_flag & FC_FABRIC) || 5616 ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) && 5617 (vport->fc_flag & FC_PUBLIC_LOOP)))) 5618 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn); 5619 else 5620 /* fabric is local port if there is no F/FL_Port */ 5621 node_name = 0; 5622 5623 spin_unlock_irq(shost->host_lock); 5624 5625 fc_host_fabric_name(shost) = node_name; 5626 } 5627 5628 /** 5629 * lpfc_get_stats - Return statistical information about the adapter 5630 * @shost: kernel scsi host pointer. 5631 * 5632 * Notes: 5633 * NULL on error for link down, no mbox pool, sli2 active, 5634 * management not allowed, memory allocation error, or mbox error. 5635 * 5636 * Returns: 5637 * NULL for error 5638 * address of the adapter host statistics 5639 **/ 5640 static struct fc_host_statistics * 5641 lpfc_get_stats(struct Scsi_Host *shost) 5642 { 5643 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5644 struct lpfc_hba *phba = vport->phba; 5645 struct lpfc_sli *psli = &phba->sli; 5646 struct fc_host_statistics *hs = &phba->link_stats; 5647 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets; 5648 LPFC_MBOXQ_t *pmboxq; 5649 MAILBOX_t *pmb; 5650 unsigned long seconds; 5651 int rc = 0; 5652 5653 /* 5654 * prevent udev from issuing mailbox commands until the port is 5655 * configured. 5656 */ 5657 if (phba->link_state < LPFC_LINK_DOWN || 5658 !phba->mbox_mem_pool || 5659 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0) 5660 return NULL; 5661 5662 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 5663 return NULL; 5664 5665 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 5666 if (!pmboxq) 5667 return NULL; 5668 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 5669 5670 pmb = &pmboxq->u.mb; 5671 pmb->mbxCommand = MBX_READ_STATUS; 5672 pmb->mbxOwner = OWN_HOST; 5673 pmboxq->context1 = NULL; 5674 pmboxq->vport = vport; 5675 5676 if (vport->fc_flag & FC_OFFLINE_MODE) 5677 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 5678 else 5679 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 5680 5681 if (rc != MBX_SUCCESS) { 5682 if (rc != MBX_TIMEOUT) 5683 mempool_free(pmboxq, phba->mbox_mem_pool); 5684 return NULL; 5685 } 5686 5687 memset(hs, 0, sizeof (struct fc_host_statistics)); 5688 5689 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt; 5690 /* 5691 * The MBX_READ_STATUS returns tx_k_bytes which has to 5692 * converted to words 5693 */ 5694 hs->tx_words = (uint64_t) 5695 ((uint64_t)pmb->un.varRdStatus.xmitByteCnt 5696 * (uint64_t)256); 5697 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt; 5698 hs->rx_words = (uint64_t) 5699 ((uint64_t)pmb->un.varRdStatus.rcvByteCnt 5700 * (uint64_t)256); 5701 5702 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 5703 pmb->mbxCommand = MBX_READ_LNK_STAT; 5704 pmb->mbxOwner = OWN_HOST; 5705 pmboxq->context1 = NULL; 5706 pmboxq->vport = vport; 5707 5708 if (vport->fc_flag & FC_OFFLINE_MODE) 5709 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 5710 else 5711 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 5712 5713 if (rc != MBX_SUCCESS) { 5714 if (rc != MBX_TIMEOUT) 5715 mempool_free(pmboxq, phba->mbox_mem_pool); 5716 return NULL; 5717 } 5718 5719 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 5720 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 5721 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 5722 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 5723 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 5724 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 5725 hs->error_frames = pmb->un.varRdLnk.crcCnt; 5726 5727 hs->link_failure_count -= lso->link_failure_count; 5728 hs->loss_of_sync_count -= lso->loss_of_sync_count; 5729 hs->loss_of_signal_count -= lso->loss_of_signal_count; 5730 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count; 5731 hs->invalid_tx_word_count -= lso->invalid_tx_word_count; 5732 hs->invalid_crc_count -= lso->invalid_crc_count; 5733 hs->error_frames -= lso->error_frames; 5734 5735 if (phba->hba_flag & HBA_FCOE_MODE) { 5736 hs->lip_count = -1; 5737 hs->nos_count = (phba->link_events >> 1); 5738 hs->nos_count -= lso->link_events; 5739 } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) { 5740 hs->lip_count = (phba->fc_eventTag >> 1); 5741 hs->lip_count -= lso->link_events; 5742 hs->nos_count = -1; 5743 } else { 5744 hs->lip_count = -1; 5745 hs->nos_count = (phba->fc_eventTag >> 1); 5746 hs->nos_count -= lso->link_events; 5747 } 5748 5749 hs->dumped_frames = -1; 5750 5751 seconds = get_seconds(); 5752 if (seconds < psli->stats_start) 5753 hs->seconds_since_last_reset = seconds + 5754 ((unsigned long)-1 - psli->stats_start); 5755 else 5756 hs->seconds_since_last_reset = seconds - psli->stats_start; 5757 5758 mempool_free(pmboxq, phba->mbox_mem_pool); 5759 5760 return hs; 5761 } 5762 5763 /** 5764 * lpfc_reset_stats - Copy the adapter link stats information 5765 * @shost: kernel scsi host pointer. 5766 **/ 5767 static void 5768 lpfc_reset_stats(struct Scsi_Host *shost) 5769 { 5770 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5771 struct lpfc_hba *phba = vport->phba; 5772 struct lpfc_sli *psli = &phba->sli; 5773 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets; 5774 LPFC_MBOXQ_t *pmboxq; 5775 MAILBOX_t *pmb; 5776 int rc = 0; 5777 5778 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 5779 return; 5780 5781 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 5782 if (!pmboxq) 5783 return; 5784 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 5785 5786 pmb = &pmboxq->u.mb; 5787 pmb->mbxCommand = MBX_READ_STATUS; 5788 pmb->mbxOwner = OWN_HOST; 5789 pmb->un.varWords[0] = 0x1; /* reset request */ 5790 pmboxq->context1 = NULL; 5791 pmboxq->vport = vport; 5792 5793 if ((vport->fc_flag & FC_OFFLINE_MODE) || 5794 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) 5795 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 5796 else 5797 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 5798 5799 if (rc != MBX_SUCCESS) { 5800 if (rc != MBX_TIMEOUT) 5801 mempool_free(pmboxq, phba->mbox_mem_pool); 5802 return; 5803 } 5804 5805 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 5806 pmb->mbxCommand = MBX_READ_LNK_STAT; 5807 pmb->mbxOwner = OWN_HOST; 5808 pmboxq->context1 = NULL; 5809 pmboxq->vport = vport; 5810 5811 if ((vport->fc_flag & FC_OFFLINE_MODE) || 5812 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) 5813 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 5814 else 5815 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 5816 5817 if (rc != MBX_SUCCESS) { 5818 if (rc != MBX_TIMEOUT) 5819 mempool_free( pmboxq, phba->mbox_mem_pool); 5820 return; 5821 } 5822 5823 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 5824 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 5825 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 5826 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 5827 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 5828 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 5829 lso->error_frames = pmb->un.varRdLnk.crcCnt; 5830 if (phba->hba_flag & HBA_FCOE_MODE) 5831 lso->link_events = (phba->link_events >> 1); 5832 else 5833 lso->link_events = (phba->fc_eventTag >> 1); 5834 5835 psli->stats_start = get_seconds(); 5836 5837 mempool_free(pmboxq, phba->mbox_mem_pool); 5838 5839 return; 5840 } 5841 5842 /* 5843 * The LPFC driver treats linkdown handling as target loss events so there 5844 * are no sysfs handlers for link_down_tmo. 5845 */ 5846 5847 /** 5848 * lpfc_get_node_by_target - Return the nodelist for a target 5849 * @starget: kernel scsi target pointer. 5850 * 5851 * Returns: 5852 * address of the node list if found 5853 * NULL target not found 5854 **/ 5855 static struct lpfc_nodelist * 5856 lpfc_get_node_by_target(struct scsi_target *starget) 5857 { 5858 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 5859 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5860 struct lpfc_nodelist *ndlp; 5861 5862 spin_lock_irq(shost->host_lock); 5863 /* Search for this, mapped, target ID */ 5864 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 5865 if (NLP_CHK_NODE_ACT(ndlp) && 5866 ndlp->nlp_state == NLP_STE_MAPPED_NODE && 5867 starget->id == ndlp->nlp_sid) { 5868 spin_unlock_irq(shost->host_lock); 5869 return ndlp; 5870 } 5871 } 5872 spin_unlock_irq(shost->host_lock); 5873 return NULL; 5874 } 5875 5876 /** 5877 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1 5878 * @starget: kernel scsi target pointer. 5879 **/ 5880 static void 5881 lpfc_get_starget_port_id(struct scsi_target *starget) 5882 { 5883 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 5884 5885 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1; 5886 } 5887 5888 /** 5889 * lpfc_get_starget_node_name - Set the target node name 5890 * @starget: kernel scsi target pointer. 5891 * 5892 * Description: Set the target node name to the ndlp node name wwn or zero. 5893 **/ 5894 static void 5895 lpfc_get_starget_node_name(struct scsi_target *starget) 5896 { 5897 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 5898 5899 fc_starget_node_name(starget) = 5900 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0; 5901 } 5902 5903 /** 5904 * lpfc_get_starget_port_name - Set the target port name 5905 * @starget: kernel scsi target pointer. 5906 * 5907 * Description: set the target port name to the ndlp port name wwn or zero. 5908 **/ 5909 static void 5910 lpfc_get_starget_port_name(struct scsi_target *starget) 5911 { 5912 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 5913 5914 fc_starget_port_name(starget) = 5915 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0; 5916 } 5917 5918 /** 5919 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo 5920 * @rport: fc rport address. 5921 * @timeout: new value for dev loss tmo. 5922 * 5923 * Description: 5924 * If timeout is non zero set the dev_loss_tmo to timeout, else set 5925 * dev_loss_tmo to one. 5926 **/ 5927 static void 5928 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 5929 { 5930 if (timeout) 5931 rport->dev_loss_tmo = timeout; 5932 else 5933 rport->dev_loss_tmo = 1; 5934 } 5935 5936 /** 5937 * lpfc_rport_show_function - Return rport target information 5938 * 5939 * Description: 5940 * Macro that uses field to generate a function with the name lpfc_show_rport_ 5941 * 5942 * lpfc_show_rport_##field: returns the bytes formatted in buf 5943 * @cdev: class converted to an fc_rport. 5944 * @buf: on return contains the target_field or zero. 5945 * 5946 * Returns: size of formatted string. 5947 **/ 5948 #define lpfc_rport_show_function(field, format_string, sz, cast) \ 5949 static ssize_t \ 5950 lpfc_show_rport_##field (struct device *dev, \ 5951 struct device_attribute *attr, \ 5952 char *buf) \ 5953 { \ 5954 struct fc_rport *rport = transport_class_to_rport(dev); \ 5955 struct lpfc_rport_data *rdata = rport->hostdata; \ 5956 return snprintf(buf, sz, format_string, \ 5957 (rdata->target) ? cast rdata->target->field : 0); \ 5958 } 5959 5960 #define lpfc_rport_rd_attr(field, format_string, sz) \ 5961 lpfc_rport_show_function(field, format_string, sz, ) \ 5962 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL) 5963 5964 /** 5965 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name 5966 * @fc_vport: The fc_vport who's symbolic name has been changed. 5967 * 5968 * Description: 5969 * This function is called by the transport after the @fc_vport's symbolic name 5970 * has been changed. This function re-registers the symbolic name with the 5971 * switch to propagate the change into the fabric if the vport is active. 5972 **/ 5973 static void 5974 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport) 5975 { 5976 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 5977 5978 if (vport->port_state == LPFC_VPORT_READY) 5979 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0); 5980 } 5981 5982 /** 5983 * lpfc_hba_log_verbose_init - Set hba's log verbose level 5984 * @phba: Pointer to lpfc_hba struct. 5985 * 5986 * This function is called by the lpfc_get_cfgparam() routine to set the 5987 * module lpfc_log_verbose into the @phba cfg_log_verbose for use with 5988 * log message according to the module's lpfc_log_verbose parameter setting 5989 * before hba port or vport created. 5990 **/ 5991 static void 5992 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose) 5993 { 5994 phba->cfg_log_verbose = verbose; 5995 } 5996 5997 struct fc_function_template lpfc_transport_functions = { 5998 /* fixed attributes the driver supports */ 5999 .show_host_node_name = 1, 6000 .show_host_port_name = 1, 6001 .show_host_supported_classes = 1, 6002 .show_host_supported_fc4s = 1, 6003 .show_host_supported_speeds = 1, 6004 .show_host_maxframe_size = 1, 6005 6006 .get_host_symbolic_name = lpfc_get_host_symbolic_name, 6007 .show_host_symbolic_name = 1, 6008 6009 /* dynamic attributes the driver supports */ 6010 .get_host_port_id = lpfc_get_host_port_id, 6011 .show_host_port_id = 1, 6012 6013 .get_host_port_type = lpfc_get_host_port_type, 6014 .show_host_port_type = 1, 6015 6016 .get_host_port_state = lpfc_get_host_port_state, 6017 .show_host_port_state = 1, 6018 6019 /* active_fc4s is shown but doesn't change (thus no get function) */ 6020 .show_host_active_fc4s = 1, 6021 6022 .get_host_speed = lpfc_get_host_speed, 6023 .show_host_speed = 1, 6024 6025 .get_host_fabric_name = lpfc_get_host_fabric_name, 6026 .show_host_fabric_name = 1, 6027 6028 /* 6029 * The LPFC driver treats linkdown handling as target loss events 6030 * so there are no sysfs handlers for link_down_tmo. 6031 */ 6032 6033 .get_fc_host_stats = lpfc_get_stats, 6034 .reset_fc_host_stats = lpfc_reset_stats, 6035 6036 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 6037 .show_rport_maxframe_size = 1, 6038 .show_rport_supported_classes = 1, 6039 6040 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 6041 .show_rport_dev_loss_tmo = 1, 6042 6043 .get_starget_port_id = lpfc_get_starget_port_id, 6044 .show_starget_port_id = 1, 6045 6046 .get_starget_node_name = lpfc_get_starget_node_name, 6047 .show_starget_node_name = 1, 6048 6049 .get_starget_port_name = lpfc_get_starget_port_name, 6050 .show_starget_port_name = 1, 6051 6052 .issue_fc_host_lip = lpfc_issue_lip, 6053 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 6054 .terminate_rport_io = lpfc_terminate_rport_io, 6055 6056 .dd_fcvport_size = sizeof(struct lpfc_vport *), 6057 6058 .vport_disable = lpfc_vport_disable, 6059 6060 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name, 6061 6062 .bsg_request = lpfc_bsg_request, 6063 .bsg_timeout = lpfc_bsg_timeout, 6064 }; 6065 6066 struct fc_function_template lpfc_vport_transport_functions = { 6067 /* fixed attributes the driver supports */ 6068 .show_host_node_name = 1, 6069 .show_host_port_name = 1, 6070 .show_host_supported_classes = 1, 6071 .show_host_supported_fc4s = 1, 6072 .show_host_supported_speeds = 1, 6073 .show_host_maxframe_size = 1, 6074 6075 .get_host_symbolic_name = lpfc_get_host_symbolic_name, 6076 .show_host_symbolic_name = 1, 6077 6078 /* dynamic attributes the driver supports */ 6079 .get_host_port_id = lpfc_get_host_port_id, 6080 .show_host_port_id = 1, 6081 6082 .get_host_port_type = lpfc_get_host_port_type, 6083 .show_host_port_type = 1, 6084 6085 .get_host_port_state = lpfc_get_host_port_state, 6086 .show_host_port_state = 1, 6087 6088 /* active_fc4s is shown but doesn't change (thus no get function) */ 6089 .show_host_active_fc4s = 1, 6090 6091 .get_host_speed = lpfc_get_host_speed, 6092 .show_host_speed = 1, 6093 6094 .get_host_fabric_name = lpfc_get_host_fabric_name, 6095 .show_host_fabric_name = 1, 6096 6097 /* 6098 * The LPFC driver treats linkdown handling as target loss events 6099 * so there are no sysfs handlers for link_down_tmo. 6100 */ 6101 6102 .get_fc_host_stats = lpfc_get_stats, 6103 .reset_fc_host_stats = lpfc_reset_stats, 6104 6105 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 6106 .show_rport_maxframe_size = 1, 6107 .show_rport_supported_classes = 1, 6108 6109 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 6110 .show_rport_dev_loss_tmo = 1, 6111 6112 .get_starget_port_id = lpfc_get_starget_port_id, 6113 .show_starget_port_id = 1, 6114 6115 .get_starget_node_name = lpfc_get_starget_node_name, 6116 .show_starget_node_name = 1, 6117 6118 .get_starget_port_name = lpfc_get_starget_port_name, 6119 .show_starget_port_name = 1, 6120 6121 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 6122 .terminate_rport_io = lpfc_terminate_rport_io, 6123 6124 .vport_disable = lpfc_vport_disable, 6125 6126 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name, 6127 }; 6128 6129 /** 6130 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure 6131 * @phba: lpfc_hba pointer. 6132 **/ 6133 void 6134 lpfc_get_cfgparam(struct lpfc_hba *phba) 6135 { 6136 lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched); 6137 lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset); 6138 lpfc_cr_delay_init(phba, lpfc_cr_delay); 6139 lpfc_cr_count_init(phba, lpfc_cr_count); 6140 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support); 6141 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl); 6142 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type); 6143 lpfc_ack0_init(phba, lpfc_ack0); 6144 lpfc_topology_init(phba, lpfc_topology); 6145 lpfc_link_speed_init(phba, lpfc_link_speed); 6146 lpfc_poll_tmo_init(phba, lpfc_poll_tmo); 6147 lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo); 6148 lpfc_enable_npiv_init(phba, lpfc_enable_npiv); 6149 lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy); 6150 lpfc_enable_rrq_init(phba, lpfc_enable_rrq); 6151 lpfc_fdmi_on_init(phba, lpfc_fdmi_on); 6152 lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN); 6153 lpfc_use_msi_init(phba, lpfc_use_msi); 6154 lpfc_nvme_oas_init(phba, lpfc_nvme_oas); 6155 lpfc_fcp_imax_init(phba, lpfc_fcp_imax); 6156 lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map); 6157 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset); 6158 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat); 6159 6160 lpfc_EnableXLane_init(phba, lpfc_EnableXLane); 6161 if (phba->sli_rev != LPFC_SLI_REV4) 6162 phba->cfg_EnableXLane = 0; 6163 lpfc_XLanePriority_init(phba, lpfc_XLanePriority); 6164 6165 memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t))); 6166 memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t))); 6167 phba->cfg_oas_lun_state = 0; 6168 phba->cfg_oas_lun_status = 0; 6169 phba->cfg_oas_flags = 0; 6170 phba->cfg_oas_priority = 0; 6171 lpfc_enable_bg_init(phba, lpfc_enable_bg); 6172 lpfc_prot_mask_init(phba, lpfc_prot_mask); 6173 lpfc_prot_guard_init(phba, lpfc_prot_guard); 6174 if (phba->sli_rev == LPFC_SLI_REV4) 6175 phba->cfg_poll = 0; 6176 else 6177 phba->cfg_poll = lpfc_poll; 6178 lpfc_suppress_rsp_init(phba, lpfc_suppress_rsp); 6179 6180 lpfc_enable_fc4_type_init(phba, lpfc_enable_fc4_type); 6181 lpfc_nvmet_mrq_init(phba, lpfc_nvmet_mrq); 6182 lpfc_nvmet_mrq_post_init(phba, lpfc_nvmet_mrq_post); 6183 6184 /* Initialize first burst. Target vs Initiator are different. */ 6185 lpfc_nvme_enable_fb_init(phba, lpfc_nvme_enable_fb); 6186 lpfc_nvmet_fb_size_init(phba, lpfc_nvmet_fb_size); 6187 lpfc_fcp_io_channel_init(phba, lpfc_fcp_io_channel); 6188 lpfc_nvme_io_channel_init(phba, lpfc_nvme_io_channel); 6189 6190 if (phba->sli_rev != LPFC_SLI_REV4) { 6191 /* NVME only supported on SLI4 */ 6192 phba->nvmet_support = 0; 6193 phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP; 6194 } else { 6195 /* We MUST have FCP support */ 6196 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP)) 6197 phba->cfg_enable_fc4_type |= LPFC_ENABLE_FCP; 6198 } 6199 6200 /* A value of 0 means use the number of CPUs found in the system */ 6201 if (phba->cfg_fcp_io_channel == 0) 6202 phba->cfg_fcp_io_channel = phba->sli4_hba.num_present_cpu; 6203 if (phba->cfg_nvme_io_channel == 0) 6204 phba->cfg_nvme_io_channel = phba->sli4_hba.num_present_cpu; 6205 6206 if (phba->cfg_enable_fc4_type == LPFC_ENABLE_NVME) 6207 phba->cfg_fcp_io_channel = 0; 6208 6209 if (phba->cfg_enable_fc4_type == LPFC_ENABLE_FCP) 6210 phba->cfg_nvme_io_channel = 0; 6211 6212 if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel) 6213 phba->io_channel_irqs = phba->cfg_fcp_io_channel; 6214 else 6215 phba->io_channel_irqs = phba->cfg_nvme_io_channel; 6216 6217 phba->cfg_soft_wwnn = 0L; 6218 phba->cfg_soft_wwpn = 0L; 6219 lpfc_xri_split_init(phba, lpfc_xri_split); 6220 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt); 6221 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth); 6222 lpfc_hba_log_verbose_init(phba, lpfc_log_verbose); 6223 lpfc_aer_support_init(phba, lpfc_aer_support); 6224 lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn); 6225 lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade); 6226 lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up); 6227 lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt); 6228 lpfc_delay_discovery_init(phba, lpfc_delay_discovery); 6229 lpfc_sli_mode_init(phba, lpfc_sli_mode); 6230 phba->cfg_enable_dss = 1; 6231 lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags); 6232 return; 6233 } 6234 6235 /** 6236 * lpfc_nvme_mod_param_dep - Adjust module parameter value based on 6237 * dependencies between protocols and roles. 6238 * @phba: lpfc_hba pointer. 6239 **/ 6240 void 6241 lpfc_nvme_mod_param_dep(struct lpfc_hba *phba) 6242 { 6243 if (phba->cfg_nvme_io_channel > phba->sli4_hba.num_present_cpu) 6244 phba->cfg_nvme_io_channel = phba->sli4_hba.num_present_cpu; 6245 6246 if (phba->cfg_fcp_io_channel > phba->sli4_hba.num_present_cpu) 6247 phba->cfg_fcp_io_channel = phba->sli4_hba.num_present_cpu; 6248 6249 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME && 6250 phba->nvmet_support) { 6251 phba->cfg_enable_fc4_type &= ~LPFC_ENABLE_FCP; 6252 phba->cfg_fcp_io_channel = 0; 6253 6254 lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, 6255 "6013 %s x%x fb_size x%x, fb_max x%x\n", 6256 "NVME Target PRLI ACC enable_fb ", 6257 phba->cfg_nvme_enable_fb, 6258 phba->cfg_nvmet_fb_size, 6259 LPFC_NVMET_FB_SZ_MAX); 6260 6261 if (phba->cfg_nvme_enable_fb == 0) 6262 phba->cfg_nvmet_fb_size = 0; 6263 else { 6264 if (phba->cfg_nvmet_fb_size > LPFC_NVMET_FB_SZ_MAX) 6265 phba->cfg_nvmet_fb_size = LPFC_NVMET_FB_SZ_MAX; 6266 } 6267 6268 /* Adjust lpfc_nvmet_mrq to avoid running out of WQE slots */ 6269 if (phba->cfg_nvmet_mrq > phba->cfg_nvme_io_channel) { 6270 phba->cfg_nvmet_mrq = phba->cfg_nvme_io_channel; 6271 lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, 6272 "6018 Adjust lpfc_nvmet_mrq to %d\n", 6273 phba->cfg_nvmet_mrq); 6274 } 6275 } else { 6276 /* Not NVME Target mode. Turn off Target parameters. */ 6277 phba->nvmet_support = 0; 6278 phba->cfg_nvmet_mrq = 0; 6279 phba->cfg_nvmet_mrq_post = 0; 6280 phba->cfg_nvmet_fb_size = 0; 6281 } 6282 6283 if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel) 6284 phba->io_channel_irqs = phba->cfg_fcp_io_channel; 6285 else 6286 phba->io_channel_irqs = phba->cfg_nvme_io_channel; 6287 } 6288 6289 /** 6290 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure 6291 * @vport: lpfc_vport pointer. 6292 **/ 6293 void 6294 lpfc_get_vport_cfgparam(struct lpfc_vport *vport) 6295 { 6296 lpfc_log_verbose_init(vport, lpfc_log_verbose); 6297 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth); 6298 lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth); 6299 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo); 6300 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo); 6301 lpfc_peer_port_login_init(vport, lpfc_peer_port_login); 6302 lpfc_restrict_login_init(vport, lpfc_restrict_login); 6303 lpfc_fcp_class_init(vport, lpfc_fcp_class); 6304 lpfc_use_adisc_init(vport, lpfc_use_adisc); 6305 lpfc_first_burst_size_init(vport, lpfc_first_burst_size); 6306 lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time); 6307 lpfc_discovery_threads_init(vport, lpfc_discovery_threads); 6308 lpfc_max_luns_init(vport, lpfc_max_luns); 6309 lpfc_scan_down_init(vport, lpfc_scan_down); 6310 lpfc_enable_da_id_init(vport, lpfc_enable_da_id); 6311 return; 6312 } 6313