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