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