1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2008 Emulex. All rights reserved. * 5 * EMULEX and SLI are trademarks of Emulex. * 6 * www.emulex.com * 7 * Portions Copyright (C) 2004-2005 Christoph Hellwig * 8 * * 9 * This program is free software; you can redistribute it and/or * 10 * modify it under the terms of version 2 of the GNU General * 11 * Public License as published by the Free Software Foundation. * 12 * This program is distributed in the hope that it will be useful. * 13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 17 * TO BE LEGALLY INVALID. See the GNU General Public License for * 18 * more details, a copy of which can be found in the file COPYING * 19 * included with this package. * 20 *******************************************************************/ 21 22 #include <linux/ctype.h> 23 #include <linux/delay.h> 24 #include <linux/pci.h> 25 #include <linux/interrupt.h> 26 27 #include <scsi/scsi.h> 28 #include <scsi/scsi_device.h> 29 #include <scsi/scsi_host.h> 30 #include <scsi/scsi_tcq.h> 31 #include <scsi/scsi_transport_fc.h> 32 33 #include "lpfc_hw.h" 34 #include "lpfc_sli.h" 35 #include "lpfc_disc.h" 36 #include "lpfc_scsi.h" 37 #include "lpfc.h" 38 #include "lpfc_logmsg.h" 39 #include "lpfc_version.h" 40 #include "lpfc_compat.h" 41 #include "lpfc_crtn.h" 42 #include "lpfc_vport.h" 43 44 #define LPFC_DEF_DEVLOSS_TMO 30 45 #define LPFC_MIN_DEVLOSS_TMO 1 46 #define LPFC_MAX_DEVLOSS_TMO 255 47 48 #define LPFC_MAX_LINK_SPEED 8 49 #define LPFC_LINK_SPEED_BITMAP 0x00000117 50 #define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8" 51 52 static void 53 lpfc_jedec_to_ascii(int incr, char hdw[]) 54 { 55 int i, j; 56 for (i = 0; i < 8; i++) { 57 j = (incr & 0xf); 58 if (j <= 9) 59 hdw[7 - i] = 0x30 + j; 60 else 61 hdw[7 - i] = 0x61 + j - 10; 62 incr = (incr >> 4); 63 } 64 hdw[8] = 0; 65 return; 66 } 67 68 static ssize_t 69 lpfc_drvr_version_show(struct class_device *cdev, char *buf) 70 { 71 return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n"); 72 } 73 74 static ssize_t 75 lpfc_info_show(struct class_device *cdev, char *buf) 76 { 77 struct Scsi_Host *host = class_to_shost(cdev); 78 79 return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host)); 80 } 81 82 static ssize_t 83 lpfc_serialnum_show(struct class_device *cdev, char *buf) 84 { 85 struct Scsi_Host *shost = class_to_shost(cdev); 86 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 87 struct lpfc_hba *phba = vport->phba; 88 89 return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber); 90 } 91 92 static ssize_t 93 lpfc_temp_sensor_show(struct class_device *cdev, char *buf) 94 { 95 struct Scsi_Host *shost = class_to_shost(cdev); 96 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 97 struct lpfc_hba *phba = vport->phba; 98 return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support); 99 } 100 101 static ssize_t 102 lpfc_modeldesc_show(struct class_device *cdev, char *buf) 103 { 104 struct Scsi_Host *shost = class_to_shost(cdev); 105 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 106 struct lpfc_hba *phba = vport->phba; 107 108 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc); 109 } 110 111 static ssize_t 112 lpfc_modelname_show(struct class_device *cdev, char *buf) 113 { 114 struct Scsi_Host *shost = class_to_shost(cdev); 115 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 116 struct lpfc_hba *phba = vport->phba; 117 118 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName); 119 } 120 121 static ssize_t 122 lpfc_programtype_show(struct class_device *cdev, char *buf) 123 { 124 struct Scsi_Host *shost = class_to_shost(cdev); 125 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 126 struct lpfc_hba *phba = vport->phba; 127 128 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType); 129 } 130 131 static ssize_t 132 lpfc_vportnum_show(struct class_device *cdev, char *buf) 133 { 134 struct Scsi_Host *shost = class_to_shost(cdev); 135 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 136 struct lpfc_hba *phba = vport->phba; 137 138 return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port); 139 } 140 141 static ssize_t 142 lpfc_fwrev_show(struct class_device *cdev, char *buf) 143 { 144 struct Scsi_Host *shost = class_to_shost(cdev); 145 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 146 struct lpfc_hba *phba = vport->phba; 147 char fwrev[32]; 148 149 lpfc_decode_firmware_rev(phba, fwrev, 1); 150 return snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", fwrev, phba->sli_rev); 151 } 152 153 static ssize_t 154 lpfc_hdw_show(struct class_device *cdev, char *buf) 155 { 156 char hdw[9]; 157 struct Scsi_Host *shost = class_to_shost(cdev); 158 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 159 struct lpfc_hba *phba = vport->phba; 160 lpfc_vpd_t *vp = &phba->vpd; 161 162 lpfc_jedec_to_ascii(vp->rev.biuRev, hdw); 163 return snprintf(buf, PAGE_SIZE, "%s\n", hdw); 164 } 165 static ssize_t 166 lpfc_option_rom_version_show(struct class_device *cdev, char *buf) 167 { 168 struct Scsi_Host *shost = class_to_shost(cdev); 169 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 170 struct lpfc_hba *phba = vport->phba; 171 172 return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion); 173 } 174 static ssize_t 175 lpfc_state_show(struct class_device *cdev, char *buf) 176 { 177 struct Scsi_Host *shost = class_to_shost(cdev); 178 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 179 struct lpfc_hba *phba = vport->phba; 180 int len = 0; 181 182 switch (phba->link_state) { 183 case LPFC_LINK_UNKNOWN: 184 case LPFC_WARM_START: 185 case LPFC_INIT_START: 186 case LPFC_INIT_MBX_CMDS: 187 case LPFC_LINK_DOWN: 188 case LPFC_HBA_ERROR: 189 len += snprintf(buf + len, PAGE_SIZE-len, "Link Down\n"); 190 break; 191 case LPFC_LINK_UP: 192 case LPFC_CLEAR_LA: 193 case LPFC_HBA_READY: 194 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - "); 195 196 switch (vport->port_state) { 197 case LPFC_LOCAL_CFG_LINK: 198 len += snprintf(buf + len, PAGE_SIZE-len, 199 "Configuring Link\n"); 200 break; 201 case LPFC_FDISC: 202 case LPFC_FLOGI: 203 case LPFC_FABRIC_CFG_LINK: 204 case LPFC_NS_REG: 205 case LPFC_NS_QRY: 206 case LPFC_BUILD_DISC_LIST: 207 case LPFC_DISC_AUTH: 208 len += snprintf(buf + len, PAGE_SIZE - len, 209 "Discovery\n"); 210 break; 211 case LPFC_VPORT_READY: 212 len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n"); 213 break; 214 215 case LPFC_VPORT_FAILED: 216 len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n"); 217 break; 218 219 case LPFC_VPORT_UNKNOWN: 220 len += snprintf(buf + len, PAGE_SIZE - len, 221 "Unknown\n"); 222 break; 223 } 224 225 if (phba->fc_topology == TOPOLOGY_LOOP) { 226 if (vport->fc_flag & FC_PUBLIC_LOOP) 227 len += snprintf(buf + len, PAGE_SIZE-len, 228 " Public Loop\n"); 229 else 230 len += snprintf(buf + len, PAGE_SIZE-len, 231 " Private Loop\n"); 232 } else { 233 if (vport->fc_flag & FC_FABRIC) 234 len += snprintf(buf + len, PAGE_SIZE-len, 235 " Fabric\n"); 236 else 237 len += snprintf(buf + len, PAGE_SIZE-len, 238 " Point-2-Point\n"); 239 } 240 } 241 242 return len; 243 } 244 245 static ssize_t 246 lpfc_num_discovered_ports_show(struct class_device *cdev, char *buf) 247 { 248 struct Scsi_Host *shost = class_to_shost(cdev); 249 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 250 251 return snprintf(buf, PAGE_SIZE, "%d\n", 252 vport->fc_map_cnt + vport->fc_unmap_cnt); 253 } 254 255 256 static int 257 lpfc_issue_lip(struct Scsi_Host *shost) 258 { 259 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 260 struct lpfc_hba *phba = vport->phba; 261 LPFC_MBOXQ_t *pmboxq; 262 int mbxstatus = MBXERR_ERROR; 263 264 if ((vport->fc_flag & FC_OFFLINE_MODE) || 265 (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)) 266 return -EPERM; 267 268 pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL); 269 270 if (!pmboxq) 271 return -ENOMEM; 272 273 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 274 pmboxq->mb.mbxCommand = MBX_DOWN_LINK; 275 pmboxq->mb.mbxOwner = OWN_HOST; 276 277 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2); 278 279 if ((mbxstatus == MBX_SUCCESS) && (pmboxq->mb.mbxStatus == 0)) { 280 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 281 lpfc_init_link(phba, pmboxq, phba->cfg_topology, 282 phba->cfg_link_speed); 283 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, 284 phba->fc_ratov * 2); 285 } 286 287 lpfc_set_loopback_flag(phba); 288 if (mbxstatus != MBX_TIMEOUT) 289 mempool_free(pmboxq, phba->mbox_mem_pool); 290 291 if (mbxstatus == MBXERR_ERROR) 292 return -EIO; 293 294 return 0; 295 } 296 297 static int 298 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type) 299 { 300 struct completion online_compl; 301 struct lpfc_sli_ring *pring; 302 struct lpfc_sli *psli; 303 int status = 0; 304 int cnt = 0; 305 int i; 306 307 init_completion(&online_compl); 308 lpfc_workq_post_event(phba, &status, &online_compl, 309 LPFC_EVT_OFFLINE_PREP); 310 wait_for_completion(&online_compl); 311 312 if (status != 0) 313 return -EIO; 314 315 psli = &phba->sli; 316 317 /* Wait a little for things to settle down, but not 318 * long enough for dev loss timeout to expire. 319 */ 320 for (i = 0; i < psli->num_rings; i++) { 321 pring = &psli->ring[i]; 322 while (pring->txcmplq_cnt) { 323 msleep(10); 324 if (cnt++ > 500) { /* 5 secs */ 325 lpfc_printf_log(phba, 326 KERN_WARNING, LOG_INIT, 327 "0466 Outstanding IO when " 328 "bringing Adapter offline\n"); 329 break; 330 } 331 } 332 } 333 334 init_completion(&online_compl); 335 lpfc_workq_post_event(phba, &status, &online_compl, type); 336 wait_for_completion(&online_compl); 337 338 if (status != 0) 339 return -EIO; 340 341 return 0; 342 } 343 344 static int 345 lpfc_selective_reset(struct lpfc_hba *phba) 346 { 347 struct completion online_compl; 348 int status = 0; 349 350 if (!phba->cfg_enable_hba_reset) 351 return -EIO; 352 353 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); 354 355 if (status != 0) 356 return status; 357 358 init_completion(&online_compl); 359 lpfc_workq_post_event(phba, &status, &online_compl, 360 LPFC_EVT_ONLINE); 361 wait_for_completion(&online_compl); 362 363 if (status != 0) 364 return -EIO; 365 366 return 0; 367 } 368 369 static ssize_t 370 lpfc_issue_reset(struct class_device *cdev, const char *buf, size_t count) 371 { 372 struct Scsi_Host *shost = class_to_shost(cdev); 373 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 374 struct lpfc_hba *phba = vport->phba; 375 376 int status = -EINVAL; 377 378 if (strncmp(buf, "selective", sizeof("selective") - 1) == 0) 379 status = lpfc_selective_reset(phba); 380 381 if (status == 0) 382 return strlen(buf); 383 else 384 return status; 385 } 386 387 static ssize_t 388 lpfc_nport_evt_cnt_show(struct class_device *cdev, char *buf) 389 { 390 struct Scsi_Host *shost = class_to_shost(cdev); 391 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 392 struct lpfc_hba *phba = vport->phba; 393 394 return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt); 395 } 396 397 static ssize_t 398 lpfc_board_mode_show(struct class_device *cdev, char *buf) 399 { 400 struct Scsi_Host *shost = class_to_shost(cdev); 401 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 402 struct lpfc_hba *phba = vport->phba; 403 char * state; 404 405 if (phba->link_state == LPFC_HBA_ERROR) 406 state = "error"; 407 else if (phba->link_state == LPFC_WARM_START) 408 state = "warm start"; 409 else if (phba->link_state == LPFC_INIT_START) 410 state = "offline"; 411 else 412 state = "online"; 413 414 return snprintf(buf, PAGE_SIZE, "%s\n", state); 415 } 416 417 static ssize_t 418 lpfc_board_mode_store(struct class_device *cdev, const char *buf, size_t count) 419 { 420 struct Scsi_Host *shost = class_to_shost(cdev); 421 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 422 struct lpfc_hba *phba = vport->phba; 423 struct completion online_compl; 424 int status=0; 425 426 if (!phba->cfg_enable_hba_reset) 427 return -EACCES; 428 init_completion(&online_compl); 429 430 if(strncmp(buf, "online", sizeof("online") - 1) == 0) { 431 lpfc_workq_post_event(phba, &status, &online_compl, 432 LPFC_EVT_ONLINE); 433 wait_for_completion(&online_compl); 434 } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0) 435 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); 436 else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0) 437 status = lpfc_do_offline(phba, LPFC_EVT_WARM_START); 438 else if (strncmp(buf, "error", sizeof("error") - 1) == 0) 439 status = lpfc_do_offline(phba, LPFC_EVT_KILL); 440 else 441 return -EINVAL; 442 443 if (!status) 444 return strlen(buf); 445 else 446 return -EIO; 447 } 448 449 static int 450 lpfc_get_hba_info(struct lpfc_hba *phba, 451 uint32_t *mxri, uint32_t *axri, 452 uint32_t *mrpi, uint32_t *arpi, 453 uint32_t *mvpi, uint32_t *avpi) 454 { 455 struct lpfc_sli *psli = &phba->sli; 456 LPFC_MBOXQ_t *pmboxq; 457 MAILBOX_t *pmb; 458 int rc = 0; 459 460 /* 461 * prevent udev from issuing mailbox commands until the port is 462 * configured. 463 */ 464 if (phba->link_state < LPFC_LINK_DOWN || 465 !phba->mbox_mem_pool || 466 (phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0) 467 return 0; 468 469 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 470 return 0; 471 472 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 473 if (!pmboxq) 474 return 0; 475 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 476 477 pmb = &pmboxq->mb; 478 pmb->mbxCommand = MBX_READ_CONFIG; 479 pmb->mbxOwner = OWN_HOST; 480 pmboxq->context1 = NULL; 481 482 if ((phba->pport->fc_flag & FC_OFFLINE_MODE) || 483 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 484 rc = MBX_NOT_FINISHED; 485 else 486 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 487 488 if (rc != MBX_SUCCESS) { 489 if (rc != MBX_TIMEOUT) 490 mempool_free(pmboxq, phba->mbox_mem_pool); 491 return 0; 492 } 493 494 if (mrpi) 495 *mrpi = pmb->un.varRdConfig.max_rpi; 496 if (arpi) 497 *arpi = pmb->un.varRdConfig.avail_rpi; 498 if (mxri) 499 *mxri = pmb->un.varRdConfig.max_xri; 500 if (axri) 501 *axri = pmb->un.varRdConfig.avail_xri; 502 if (mvpi) 503 *mvpi = pmb->un.varRdConfig.max_vpi; 504 if (avpi) 505 *avpi = pmb->un.varRdConfig.avail_vpi; 506 507 mempool_free(pmboxq, phba->mbox_mem_pool); 508 return 1; 509 } 510 511 static ssize_t 512 lpfc_max_rpi_show(struct class_device *cdev, char *buf) 513 { 514 struct Scsi_Host *shost = class_to_shost(cdev); 515 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 516 struct lpfc_hba *phba = vport->phba; 517 uint32_t cnt; 518 519 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL)) 520 return snprintf(buf, PAGE_SIZE, "%d\n", cnt); 521 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 522 } 523 524 static ssize_t 525 lpfc_used_rpi_show(struct class_device *cdev, char *buf) 526 { 527 struct Scsi_Host *shost = class_to_shost(cdev); 528 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 529 struct lpfc_hba *phba = vport->phba; 530 uint32_t cnt, acnt; 531 532 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL)) 533 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt)); 534 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 535 } 536 537 static ssize_t 538 lpfc_max_xri_show(struct class_device *cdev, char *buf) 539 { 540 struct Scsi_Host *shost = class_to_shost(cdev); 541 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 542 struct lpfc_hba *phba = vport->phba; 543 uint32_t cnt; 544 545 if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL)) 546 return snprintf(buf, PAGE_SIZE, "%d\n", cnt); 547 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 548 } 549 550 static ssize_t 551 lpfc_used_xri_show(struct class_device *cdev, char *buf) 552 { 553 struct Scsi_Host *shost = class_to_shost(cdev); 554 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 555 struct lpfc_hba *phba = vport->phba; 556 uint32_t cnt, acnt; 557 558 if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL)) 559 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt)); 560 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 561 } 562 563 static ssize_t 564 lpfc_max_vpi_show(struct class_device *cdev, char *buf) 565 { 566 struct Scsi_Host *shost = class_to_shost(cdev); 567 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 568 struct lpfc_hba *phba = vport->phba; 569 uint32_t cnt; 570 571 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL)) 572 return snprintf(buf, PAGE_SIZE, "%d\n", cnt); 573 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 574 } 575 576 static ssize_t 577 lpfc_used_vpi_show(struct class_device *cdev, char *buf) 578 { 579 struct Scsi_Host *shost = class_to_shost(cdev); 580 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 581 struct lpfc_hba *phba = vport->phba; 582 uint32_t cnt, acnt; 583 584 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt)) 585 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt)); 586 return snprintf(buf, PAGE_SIZE, "Unknown\n"); 587 } 588 589 static ssize_t 590 lpfc_npiv_info_show(struct class_device *cdev, char *buf) 591 { 592 struct Scsi_Host *shost = class_to_shost(cdev); 593 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 594 struct lpfc_hba *phba = vport->phba; 595 596 if (!(phba->max_vpi)) 597 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n"); 598 if (vport->port_type == LPFC_PHYSICAL_PORT) 599 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n"); 600 return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi); 601 } 602 603 static ssize_t 604 lpfc_poll_show(struct class_device *cdev, char *buf) 605 { 606 struct Scsi_Host *shost = class_to_shost(cdev); 607 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 608 struct lpfc_hba *phba = vport->phba; 609 610 return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll); 611 } 612 613 static ssize_t 614 lpfc_poll_store(struct class_device *cdev, const char *buf, 615 size_t count) 616 { 617 struct Scsi_Host *shost = class_to_shost(cdev); 618 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 619 struct lpfc_hba *phba = vport->phba; 620 uint32_t creg_val; 621 uint32_t old_val; 622 int val=0; 623 624 if (!isdigit(buf[0])) 625 return -EINVAL; 626 627 if (sscanf(buf, "%i", &val) != 1) 628 return -EINVAL; 629 630 if ((val & 0x3) != val) 631 return -EINVAL; 632 633 spin_lock_irq(&phba->hbalock); 634 635 old_val = phba->cfg_poll; 636 637 if (val & ENABLE_FCP_RING_POLLING) { 638 if ((val & DISABLE_FCP_RING_INT) && 639 !(old_val & DISABLE_FCP_RING_INT)) { 640 creg_val = readl(phba->HCregaddr); 641 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING); 642 writel(creg_val, phba->HCregaddr); 643 readl(phba->HCregaddr); /* flush */ 644 645 lpfc_poll_start_timer(phba); 646 } 647 } else if (val != 0x0) { 648 spin_unlock_irq(&phba->hbalock); 649 return -EINVAL; 650 } 651 652 if (!(val & DISABLE_FCP_RING_INT) && 653 (old_val & DISABLE_FCP_RING_INT)) 654 { 655 spin_unlock_irq(&phba->hbalock); 656 del_timer(&phba->fcp_poll_timer); 657 spin_lock_irq(&phba->hbalock); 658 creg_val = readl(phba->HCregaddr); 659 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING); 660 writel(creg_val, phba->HCregaddr); 661 readl(phba->HCregaddr); /* flush */ 662 } 663 664 phba->cfg_poll = val; 665 666 spin_unlock_irq(&phba->hbalock); 667 668 return strlen(buf); 669 } 670 671 #define lpfc_param_show(attr) \ 672 static ssize_t \ 673 lpfc_##attr##_show(struct class_device *cdev, char *buf) \ 674 { \ 675 struct Scsi_Host *shost = class_to_shost(cdev);\ 676 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 677 struct lpfc_hba *phba = vport->phba;\ 678 int val = 0;\ 679 val = phba->cfg_##attr;\ 680 return snprintf(buf, PAGE_SIZE, "%d\n",\ 681 phba->cfg_##attr);\ 682 } 683 684 #define lpfc_param_hex_show(attr) \ 685 static ssize_t \ 686 lpfc_##attr##_show(struct class_device *cdev, char *buf) \ 687 { \ 688 struct Scsi_Host *shost = class_to_shost(cdev);\ 689 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 690 struct lpfc_hba *phba = vport->phba;\ 691 int val = 0;\ 692 val = phba->cfg_##attr;\ 693 return snprintf(buf, PAGE_SIZE, "%#x\n",\ 694 phba->cfg_##attr);\ 695 } 696 697 #define lpfc_param_init(attr, default, minval, maxval) \ 698 static int \ 699 lpfc_##attr##_init(struct lpfc_hba *phba, int val) \ 700 { \ 701 if (val >= minval && val <= maxval) {\ 702 phba->cfg_##attr = val;\ 703 return 0;\ 704 }\ 705 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \ 706 "0449 lpfc_"#attr" attribute cannot be set to %d, "\ 707 "allowed range is ["#minval", "#maxval"]\n", val); \ 708 phba->cfg_##attr = default;\ 709 return -EINVAL;\ 710 } 711 712 #define lpfc_param_set(attr, default, minval, maxval) \ 713 static int \ 714 lpfc_##attr##_set(struct lpfc_hba *phba, int val) \ 715 { \ 716 if (val >= minval && val <= maxval) {\ 717 phba->cfg_##attr = val;\ 718 return 0;\ 719 }\ 720 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \ 721 "0450 lpfc_"#attr" attribute cannot be set to %d, "\ 722 "allowed range is ["#minval", "#maxval"]\n", val); \ 723 return -EINVAL;\ 724 } 725 726 #define lpfc_param_store(attr) \ 727 static ssize_t \ 728 lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \ 729 { \ 730 struct Scsi_Host *shost = class_to_shost(cdev);\ 731 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 732 struct lpfc_hba *phba = vport->phba;\ 733 int val=0;\ 734 if (!isdigit(buf[0]))\ 735 return -EINVAL;\ 736 if (sscanf(buf, "%i", &val) != 1)\ 737 return -EINVAL;\ 738 if (lpfc_##attr##_set(phba, val) == 0) \ 739 return strlen(buf);\ 740 else \ 741 return -EINVAL;\ 742 } 743 744 #define lpfc_vport_param_show(attr) \ 745 static ssize_t \ 746 lpfc_##attr##_show(struct class_device *cdev, char *buf) \ 747 { \ 748 struct Scsi_Host *shost = class_to_shost(cdev);\ 749 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 750 int val = 0;\ 751 val = vport->cfg_##attr;\ 752 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\ 753 } 754 755 #define lpfc_vport_param_hex_show(attr) \ 756 static ssize_t \ 757 lpfc_##attr##_show(struct class_device *cdev, char *buf) \ 758 { \ 759 struct Scsi_Host *shost = class_to_shost(cdev);\ 760 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 761 int val = 0;\ 762 val = vport->cfg_##attr;\ 763 return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\ 764 } 765 766 #define lpfc_vport_param_init(attr, default, minval, maxval) \ 767 static int \ 768 lpfc_##attr##_init(struct lpfc_vport *vport, int val) \ 769 { \ 770 if (val >= minval && val <= maxval) {\ 771 vport->cfg_##attr = val;\ 772 return 0;\ 773 }\ 774 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \ 775 "0449 lpfc_"#attr" attribute cannot be set to %d, "\ 776 "allowed range is ["#minval", "#maxval"]\n", val); \ 777 vport->cfg_##attr = default;\ 778 return -EINVAL;\ 779 } 780 781 #define lpfc_vport_param_set(attr, default, minval, maxval) \ 782 static int \ 783 lpfc_##attr##_set(struct lpfc_vport *vport, int val) \ 784 { \ 785 if (val >= minval && val <= maxval) {\ 786 vport->cfg_##attr = val;\ 787 return 0;\ 788 }\ 789 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \ 790 "0450 lpfc_"#attr" attribute cannot be set to %d, "\ 791 "allowed range is ["#minval", "#maxval"]\n", val); \ 792 return -EINVAL;\ 793 } 794 795 #define lpfc_vport_param_store(attr) \ 796 static ssize_t \ 797 lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \ 798 { \ 799 struct Scsi_Host *shost = class_to_shost(cdev);\ 800 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\ 801 int val=0;\ 802 if (!isdigit(buf[0]))\ 803 return -EINVAL;\ 804 if (sscanf(buf, "%i", &val) != 1)\ 805 return -EINVAL;\ 806 if (lpfc_##attr##_set(vport, val) == 0) \ 807 return strlen(buf);\ 808 else \ 809 return -EINVAL;\ 810 } 811 812 813 #define LPFC_ATTR(name, defval, minval, maxval, desc) \ 814 static int lpfc_##name = defval;\ 815 module_param(lpfc_##name, int, 0);\ 816 MODULE_PARM_DESC(lpfc_##name, desc);\ 817 lpfc_param_init(name, defval, minval, maxval) 818 819 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \ 820 static int lpfc_##name = defval;\ 821 module_param(lpfc_##name, int, 0);\ 822 MODULE_PARM_DESC(lpfc_##name, desc);\ 823 lpfc_param_show(name)\ 824 lpfc_param_init(name, defval, minval, maxval)\ 825 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 826 827 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \ 828 static int lpfc_##name = defval;\ 829 module_param(lpfc_##name, int, 0);\ 830 MODULE_PARM_DESC(lpfc_##name, desc);\ 831 lpfc_param_show(name)\ 832 lpfc_param_init(name, defval, minval, maxval)\ 833 lpfc_param_set(name, defval, minval, maxval)\ 834 lpfc_param_store(name)\ 835 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 836 lpfc_##name##_show, lpfc_##name##_store) 837 838 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \ 839 static int lpfc_##name = defval;\ 840 module_param(lpfc_##name, int, 0);\ 841 MODULE_PARM_DESC(lpfc_##name, desc);\ 842 lpfc_param_hex_show(name)\ 843 lpfc_param_init(name, defval, minval, maxval)\ 844 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 845 846 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \ 847 static int lpfc_##name = defval;\ 848 module_param(lpfc_##name, int, 0);\ 849 MODULE_PARM_DESC(lpfc_##name, desc);\ 850 lpfc_param_hex_show(name)\ 851 lpfc_param_init(name, defval, minval, maxval)\ 852 lpfc_param_set(name, defval, minval, maxval)\ 853 lpfc_param_store(name)\ 854 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 855 lpfc_##name##_show, lpfc_##name##_store) 856 857 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \ 858 static int lpfc_##name = defval;\ 859 module_param(lpfc_##name, int, 0);\ 860 MODULE_PARM_DESC(lpfc_##name, desc);\ 861 lpfc_vport_param_init(name, defval, minval, maxval) 862 863 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \ 864 static int lpfc_##name = defval;\ 865 module_param(lpfc_##name, int, 0);\ 866 MODULE_PARM_DESC(lpfc_##name, desc);\ 867 lpfc_vport_param_show(name)\ 868 lpfc_vport_param_init(name, defval, minval, maxval)\ 869 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 870 871 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \ 872 static int lpfc_##name = defval;\ 873 module_param(lpfc_##name, int, 0);\ 874 MODULE_PARM_DESC(lpfc_##name, desc);\ 875 lpfc_vport_param_show(name)\ 876 lpfc_vport_param_init(name, defval, minval, maxval)\ 877 lpfc_vport_param_set(name, defval, minval, maxval)\ 878 lpfc_vport_param_store(name)\ 879 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 880 lpfc_##name##_show, lpfc_##name##_store) 881 882 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \ 883 static int lpfc_##name = defval;\ 884 module_param(lpfc_##name, int, 0);\ 885 MODULE_PARM_DESC(lpfc_##name, desc);\ 886 lpfc_vport_param_hex_show(name)\ 887 lpfc_vport_param_init(name, defval, minval, maxval)\ 888 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL) 889 890 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \ 891 static int lpfc_##name = defval;\ 892 module_param(lpfc_##name, int, 0);\ 893 MODULE_PARM_DESC(lpfc_##name, desc);\ 894 lpfc_vport_param_hex_show(name)\ 895 lpfc_vport_param_init(name, defval, minval, maxval)\ 896 lpfc_vport_param_set(name, defval, minval, maxval)\ 897 lpfc_vport_param_store(name)\ 898 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\ 899 lpfc_##name##_show, lpfc_##name##_store) 900 901 static CLASS_DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL); 902 static CLASS_DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL); 903 static CLASS_DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL); 904 static CLASS_DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL); 905 static CLASS_DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL); 906 static CLASS_DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL); 907 static CLASS_DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL); 908 static CLASS_DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL); 909 static CLASS_DEVICE_ATTR(state, S_IRUGO, lpfc_state_show, NULL); 910 static CLASS_DEVICE_ATTR(option_rom_version, S_IRUGO, 911 lpfc_option_rom_version_show, NULL); 912 static CLASS_DEVICE_ATTR(num_discovered_ports, S_IRUGO, 913 lpfc_num_discovered_ports_show, NULL); 914 static CLASS_DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL); 915 static CLASS_DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, 916 NULL); 917 static CLASS_DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR, 918 lpfc_board_mode_show, lpfc_board_mode_store); 919 static CLASS_DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset); 920 static CLASS_DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL); 921 static CLASS_DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL); 922 static CLASS_DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL); 923 static CLASS_DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL); 924 static CLASS_DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL); 925 static CLASS_DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL); 926 static CLASS_DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL); 927 static CLASS_DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, 928 NULL); 929 930 931 static char *lpfc_soft_wwn_key = "C99G71SL8032A"; 932 933 static ssize_t 934 lpfc_soft_wwn_enable_store(struct class_device *cdev, const char *buf, 935 size_t count) 936 { 937 struct Scsi_Host *shost = class_to_shost(cdev); 938 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 939 struct lpfc_hba *phba = vport->phba; 940 unsigned int cnt = count; 941 942 /* 943 * We're doing a simple sanity check for soft_wwpn setting. 944 * We require that the user write a specific key to enable 945 * the soft_wwpn attribute to be settable. Once the attribute 946 * is written, the enable key resets. If further updates are 947 * desired, the key must be written again to re-enable the 948 * attribute. 949 * 950 * The "key" is not secret - it is a hardcoded string shown 951 * here. The intent is to protect against the random user or 952 * application that is just writing attributes. 953 */ 954 955 /* count may include a LF at end of string */ 956 if (buf[cnt-1] == '\n') 957 cnt--; 958 959 if ((cnt != strlen(lpfc_soft_wwn_key)) || 960 (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0)) 961 return -EINVAL; 962 963 phba->soft_wwn_enable = 1; 964 return count; 965 } 966 static CLASS_DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL, 967 lpfc_soft_wwn_enable_store); 968 969 static ssize_t 970 lpfc_soft_wwpn_show(struct class_device *cdev, char *buf) 971 { 972 struct Scsi_Host *shost = class_to_shost(cdev); 973 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 974 struct lpfc_hba *phba = vport->phba; 975 976 return snprintf(buf, PAGE_SIZE, "0x%llx\n", 977 (unsigned long long)phba->cfg_soft_wwpn); 978 } 979 980 981 static ssize_t 982 lpfc_soft_wwpn_store(struct class_device *cdev, const char *buf, size_t count) 983 { 984 struct Scsi_Host *shost = class_to_shost(cdev); 985 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 986 struct lpfc_hba *phba = vport->phba; 987 struct completion online_compl; 988 int stat1=0, stat2=0; 989 unsigned int i, j, cnt=count; 990 u8 wwpn[8]; 991 992 if (!phba->cfg_enable_hba_reset) 993 return -EACCES; 994 spin_lock_irq(&phba->hbalock); 995 if (phba->over_temp_state == HBA_OVER_TEMP) { 996 spin_unlock_irq(&phba->hbalock); 997 return -EACCES; 998 } 999 spin_unlock_irq(&phba->hbalock); 1000 /* count may include a LF at end of string */ 1001 if (buf[cnt-1] == '\n') 1002 cnt--; 1003 1004 if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) || 1005 ((cnt == 17) && (*buf++ != 'x')) || 1006 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x')))) 1007 return -EINVAL; 1008 1009 phba->soft_wwn_enable = 0; 1010 1011 memset(wwpn, 0, sizeof(wwpn)); 1012 1013 /* Validate and store the new name */ 1014 for (i=0, j=0; i < 16; i++) { 1015 if ((*buf >= 'a') && (*buf <= 'f')) 1016 j = ((j << 4) | ((*buf++ -'a') + 10)); 1017 else if ((*buf >= 'A') && (*buf <= 'F')) 1018 j = ((j << 4) | ((*buf++ -'A') + 10)); 1019 else if ((*buf >= '0') && (*buf <= '9')) 1020 j = ((j << 4) | (*buf++ -'0')); 1021 else 1022 return -EINVAL; 1023 if (i % 2) { 1024 wwpn[i/2] = j & 0xff; 1025 j = 0; 1026 } 1027 } 1028 phba->cfg_soft_wwpn = wwn_to_u64(wwpn); 1029 fc_host_port_name(shost) = phba->cfg_soft_wwpn; 1030 if (phba->cfg_soft_wwnn) 1031 fc_host_node_name(shost) = phba->cfg_soft_wwnn; 1032 1033 dev_printk(KERN_NOTICE, &phba->pcidev->dev, 1034 "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no); 1035 1036 stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); 1037 if (stat1) 1038 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1039 "0463 lpfc_soft_wwpn attribute set failed to " 1040 "reinit adapter - %d\n", stat1); 1041 init_completion(&online_compl); 1042 lpfc_workq_post_event(phba, &stat2, &online_compl, LPFC_EVT_ONLINE); 1043 wait_for_completion(&online_compl); 1044 if (stat2) 1045 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1046 "0464 lpfc_soft_wwpn attribute set failed to " 1047 "reinit adapter - %d\n", stat2); 1048 return (stat1 || stat2) ? -EIO : count; 1049 } 1050 static CLASS_DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\ 1051 lpfc_soft_wwpn_show, lpfc_soft_wwpn_store); 1052 1053 static ssize_t 1054 lpfc_soft_wwnn_show(struct class_device *cdev, char *buf) 1055 { 1056 struct Scsi_Host *shost = class_to_shost(cdev); 1057 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 1058 return snprintf(buf, PAGE_SIZE, "0x%llx\n", 1059 (unsigned long long)phba->cfg_soft_wwnn); 1060 } 1061 1062 1063 static ssize_t 1064 lpfc_soft_wwnn_store(struct class_device *cdev, const char *buf, size_t count) 1065 { 1066 struct Scsi_Host *shost = class_to_shost(cdev); 1067 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 1068 unsigned int i, j, cnt=count; 1069 u8 wwnn[8]; 1070 1071 /* count may include a LF at end of string */ 1072 if (buf[cnt-1] == '\n') 1073 cnt--; 1074 1075 if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) || 1076 ((cnt == 17) && (*buf++ != 'x')) || 1077 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x')))) 1078 return -EINVAL; 1079 1080 /* 1081 * Allow wwnn to be set many times, as long as the enable is set. 1082 * However, once the wwpn is set, everything locks. 1083 */ 1084 1085 memset(wwnn, 0, sizeof(wwnn)); 1086 1087 /* Validate and store the new name */ 1088 for (i=0, j=0; i < 16; i++) { 1089 if ((*buf >= 'a') && (*buf <= 'f')) 1090 j = ((j << 4) | ((*buf++ -'a') + 10)); 1091 else if ((*buf >= 'A') && (*buf <= 'F')) 1092 j = ((j << 4) | ((*buf++ -'A') + 10)); 1093 else if ((*buf >= '0') && (*buf <= '9')) 1094 j = ((j << 4) | (*buf++ -'0')); 1095 else 1096 return -EINVAL; 1097 if (i % 2) { 1098 wwnn[i/2] = j & 0xff; 1099 j = 0; 1100 } 1101 } 1102 phba->cfg_soft_wwnn = wwn_to_u64(wwnn); 1103 1104 dev_printk(KERN_NOTICE, &phba->pcidev->dev, 1105 "lpfc%d: soft_wwnn set. Value will take effect upon " 1106 "setting of the soft_wwpn\n", phba->brd_no); 1107 1108 return count; 1109 } 1110 static CLASS_DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\ 1111 lpfc_soft_wwnn_show, lpfc_soft_wwnn_store); 1112 1113 1114 static int lpfc_poll = 0; 1115 module_param(lpfc_poll, int, 0); 1116 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:" 1117 " 0 - none," 1118 " 1 - poll with interrupts enabled" 1119 " 3 - poll and disable FCP ring interrupts"); 1120 1121 static CLASS_DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR, 1122 lpfc_poll_show, lpfc_poll_store); 1123 1124 int lpfc_sli_mode = 0; 1125 module_param(lpfc_sli_mode, int, 0); 1126 MODULE_PARM_DESC(lpfc_sli_mode, "SLI mode selector:" 1127 " 0 - auto (SLI-3 if supported)," 1128 " 2 - select SLI-2 even on SLI-3 capable HBAs," 1129 " 3 - select SLI-3"); 1130 1131 int lpfc_enable_npiv = 0; 1132 module_param(lpfc_enable_npiv, int, 0); 1133 MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality"); 1134 lpfc_param_show(enable_npiv); 1135 lpfc_param_init(enable_npiv, 0, 0, 1); 1136 static CLASS_DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, 1137 lpfc_enable_npiv_show, NULL); 1138 1139 /* 1140 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear 1141 # until the timer expires. Value range is [0,255]. Default value is 30. 1142 */ 1143 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO; 1144 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO; 1145 module_param(lpfc_nodev_tmo, int, 0); 1146 MODULE_PARM_DESC(lpfc_nodev_tmo, 1147 "Seconds driver will hold I/O waiting " 1148 "for a device to come back"); 1149 static ssize_t 1150 lpfc_nodev_tmo_show(struct class_device *cdev, char *buf) 1151 { 1152 struct Scsi_Host *shost = class_to_shost(cdev); 1153 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1154 int val = 0; 1155 val = vport->cfg_devloss_tmo; 1156 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo); 1157 } 1158 1159 static int 1160 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val) 1161 { 1162 if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) { 1163 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo; 1164 if (val != LPFC_DEF_DEVLOSS_TMO) 1165 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1166 "0402 Ignoring nodev_tmo module " 1167 "parameter because devloss_tmo is " 1168 "set.\n"); 1169 return 0; 1170 } 1171 1172 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 1173 vport->cfg_nodev_tmo = val; 1174 vport->cfg_devloss_tmo = val; 1175 return 0; 1176 } 1177 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1178 "0400 lpfc_nodev_tmo attribute cannot be set to" 1179 " %d, allowed range is [%d, %d]\n", 1180 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 1181 vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO; 1182 return -EINVAL; 1183 } 1184 1185 static void 1186 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport) 1187 { 1188 struct Scsi_Host *shost; 1189 struct lpfc_nodelist *ndlp; 1190 1191 shost = lpfc_shost_from_vport(vport); 1192 spin_lock_irq(shost->host_lock); 1193 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) 1194 if (ndlp->rport) 1195 ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo; 1196 spin_unlock_irq(shost->host_lock); 1197 } 1198 1199 static int 1200 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val) 1201 { 1202 if (vport->dev_loss_tmo_changed || 1203 (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) { 1204 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1205 "0401 Ignoring change to nodev_tmo " 1206 "because devloss_tmo is set.\n"); 1207 return 0; 1208 } 1209 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 1210 vport->cfg_nodev_tmo = val; 1211 vport->cfg_devloss_tmo = val; 1212 lpfc_update_rport_devloss_tmo(vport); 1213 return 0; 1214 } 1215 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1216 "0403 lpfc_nodev_tmo attribute cannot be set to" 1217 "%d, allowed range is [%d, %d]\n", 1218 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 1219 return -EINVAL; 1220 } 1221 1222 lpfc_vport_param_store(nodev_tmo) 1223 1224 static CLASS_DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR, 1225 lpfc_nodev_tmo_show, lpfc_nodev_tmo_store); 1226 1227 /* 1228 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that 1229 # disappear until the timer expires. Value range is [0,255]. Default 1230 # value is 30. 1231 */ 1232 module_param(lpfc_devloss_tmo, int, 0); 1233 MODULE_PARM_DESC(lpfc_devloss_tmo, 1234 "Seconds driver will hold I/O waiting " 1235 "for a device to come back"); 1236 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO, 1237 LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO) 1238 lpfc_vport_param_show(devloss_tmo) 1239 static int 1240 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val) 1241 { 1242 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) { 1243 vport->cfg_nodev_tmo = val; 1244 vport->cfg_devloss_tmo = val; 1245 vport->dev_loss_tmo_changed = 1; 1246 lpfc_update_rport_devloss_tmo(vport); 1247 return 0; 1248 } 1249 1250 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1251 "0404 lpfc_devloss_tmo attribute cannot be set to" 1252 " %d, allowed range is [%d, %d]\n", 1253 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO); 1254 return -EINVAL; 1255 } 1256 1257 lpfc_vport_param_store(devloss_tmo) 1258 static CLASS_DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR, 1259 lpfc_devloss_tmo_show, lpfc_devloss_tmo_store); 1260 1261 /* 1262 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being 1263 # deluged with LOTS of information. 1264 # You can set a bit mask to record specific types of verbose messages: 1265 # 1266 # LOG_ELS 0x1 ELS events 1267 # LOG_DISCOVERY 0x2 Link discovery events 1268 # LOG_MBOX 0x4 Mailbox events 1269 # LOG_INIT 0x8 Initialization events 1270 # LOG_LINK_EVENT 0x10 Link events 1271 # LOG_FCP 0x40 FCP traffic history 1272 # LOG_NODE 0x80 Node table events 1273 # LOG_MISC 0x400 Miscellaneous events 1274 # LOG_SLI 0x800 SLI events 1275 # LOG_FCP_ERROR 0x1000 Only log FCP errors 1276 # LOG_LIBDFC 0x2000 LIBDFC events 1277 # LOG_ALL_MSG 0xffff LOG all messages 1278 */ 1279 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffff, 1280 "Verbose logging bit-mask"); 1281 1282 /* 1283 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters 1284 # objects that have been registered with the nameserver after login. 1285 */ 1286 LPFC_VPORT_ATTR_R(enable_da_id, 0, 0, 1, 1287 "Deregister nameserver objects before LOGO"); 1288 1289 /* 1290 # lun_queue_depth: This parameter is used to limit the number of outstanding 1291 # commands per FCP LUN. Value range is [1,128]. Default value is 30. 1292 */ 1293 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128, 1294 "Max number of FCP commands we can queue to a specific LUN"); 1295 1296 /* 1297 # hba_queue_depth: This parameter is used to limit the number of outstanding 1298 # commands per lpfc HBA. Value range is [32,8192]. If this parameter 1299 # value is greater than the maximum number of exchanges supported by the HBA, 1300 # then maximum number of exchanges supported by the HBA is used to determine 1301 # the hba_queue_depth. 1302 */ 1303 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192, 1304 "Max number of FCP commands we can queue to a lpfc HBA"); 1305 1306 /* 1307 # peer_port_login: This parameter allows/prevents logins 1308 # between peer ports hosted on the same physical port. 1309 # When this parameter is set 0 peer ports of same physical port 1310 # are not allowed to login to each other. 1311 # When this parameter is set 1 peer ports of same physical port 1312 # are allowed to login to each other. 1313 # Default value of this parameter is 0. 1314 */ 1315 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1, 1316 "Allow peer ports on the same physical port to login to each " 1317 "other."); 1318 1319 /* 1320 # restrict_login: This parameter allows/prevents logins 1321 # between Virtual Ports and remote initiators. 1322 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from 1323 # other initiators and will attempt to PLOGI all remote ports. 1324 # When this parameter is set (1) Virtual Ports will reject PLOGIs from 1325 # remote ports and will not attempt to PLOGI to other initiators. 1326 # This parameter does not restrict to the physical port. 1327 # This parameter does not restrict logins to Fabric resident remote ports. 1328 # Default value of this parameter is 1. 1329 */ 1330 static int lpfc_restrict_login = 1; 1331 module_param(lpfc_restrict_login, int, 0); 1332 MODULE_PARM_DESC(lpfc_restrict_login, 1333 "Restrict virtual ports login to remote initiators."); 1334 lpfc_vport_param_show(restrict_login); 1335 1336 static int 1337 lpfc_restrict_login_init(struct lpfc_vport *vport, int val) 1338 { 1339 if (val < 0 || val > 1) { 1340 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1341 "0449 lpfc_restrict_login attribute cannot " 1342 "be set to %d, allowed range is [0, 1]\n", 1343 val); 1344 vport->cfg_restrict_login = 1; 1345 return -EINVAL; 1346 } 1347 if (vport->port_type == LPFC_PHYSICAL_PORT) { 1348 vport->cfg_restrict_login = 0; 1349 return 0; 1350 } 1351 vport->cfg_restrict_login = val; 1352 return 0; 1353 } 1354 1355 static int 1356 lpfc_restrict_login_set(struct lpfc_vport *vport, int val) 1357 { 1358 if (val < 0 || val > 1) { 1359 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1360 "0450 lpfc_restrict_login attribute cannot " 1361 "be set to %d, allowed range is [0, 1]\n", 1362 val); 1363 vport->cfg_restrict_login = 1; 1364 return -EINVAL; 1365 } 1366 if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) { 1367 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 1368 "0468 lpfc_restrict_login must be 0 for " 1369 "Physical ports.\n"); 1370 vport->cfg_restrict_login = 0; 1371 return 0; 1372 } 1373 vport->cfg_restrict_login = val; 1374 return 0; 1375 } 1376 lpfc_vport_param_store(restrict_login); 1377 static CLASS_DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR, 1378 lpfc_restrict_login_show, lpfc_restrict_login_store); 1379 1380 /* 1381 # Some disk devices have a "select ID" or "select Target" capability. 1382 # From a protocol standpoint "select ID" usually means select the 1383 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative 1384 # annex" which contains a table that maps a "select ID" (a number 1385 # between 0 and 7F) to an ALPA. By default, for compatibility with 1386 # older drivers, the lpfc driver scans this table from low ALPA to high 1387 # ALPA. 1388 # 1389 # Turning on the scan-down variable (on = 1, off = 0) will 1390 # cause the lpfc driver to use an inverted table, effectively 1391 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1. 1392 # 1393 # (Note: This "select ID" functionality is a LOOP ONLY characteristic 1394 # and will not work across a fabric. Also this parameter will take 1395 # effect only in the case when ALPA map is not available.) 1396 */ 1397 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1, 1398 "Start scanning for devices from highest ALPA to lowest"); 1399 1400 /* 1401 # lpfc_topology: link topology for init link 1402 # 0x0 = attempt loop mode then point-to-point 1403 # 0x01 = internal loopback mode 1404 # 0x02 = attempt point-to-point mode only 1405 # 0x04 = attempt loop mode only 1406 # 0x06 = attempt point-to-point mode then loop 1407 # Set point-to-point mode if you want to run as an N_Port. 1408 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6]. 1409 # Default value is 0. 1410 */ 1411 static int 1412 lpfc_topology_set(struct lpfc_hba *phba, int val) 1413 { 1414 int err; 1415 uint32_t prev_val; 1416 if (val >= 0 && val <= 6) { 1417 prev_val = phba->cfg_topology; 1418 phba->cfg_topology = val; 1419 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport)); 1420 if (err) 1421 phba->cfg_topology = prev_val; 1422 return err; 1423 } 1424 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1425 "%d:0467 lpfc_topology attribute cannot be set to %d, " 1426 "allowed range is [0, 6]\n", 1427 phba->brd_no, val); 1428 return -EINVAL; 1429 } 1430 static int lpfc_topology = 0; 1431 module_param(lpfc_topology, int, 0); 1432 MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology"); 1433 lpfc_param_show(topology) 1434 lpfc_param_init(topology, 0, 0, 6) 1435 lpfc_param_store(topology) 1436 static CLASS_DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR, 1437 lpfc_topology_show, lpfc_topology_store); 1438 1439 /* 1440 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel 1441 # connection. 1442 # 0 = auto select (default) 1443 # 1 = 1 Gigabaud 1444 # 2 = 2 Gigabaud 1445 # 4 = 4 Gigabaud 1446 # 8 = 8 Gigabaud 1447 # Value range is [0,8]. Default value is 0. 1448 */ 1449 static int 1450 lpfc_link_speed_set(struct lpfc_hba *phba, int val) 1451 { 1452 int err; 1453 uint32_t prev_val; 1454 1455 if (((val == LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) || 1456 ((val == LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) || 1457 ((val == LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) || 1458 ((val == LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) || 1459 ((val == LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb))) 1460 return -EINVAL; 1461 1462 if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED) 1463 && (LPFC_LINK_SPEED_BITMAP & (1 << val))) { 1464 prev_val = phba->cfg_link_speed; 1465 phba->cfg_link_speed = val; 1466 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport)); 1467 if (err) 1468 phba->cfg_link_speed = prev_val; 1469 return err; 1470 } 1471 1472 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1473 "%d:0469 lpfc_link_speed attribute cannot be set to %d, " 1474 "allowed range is [0, 8]\n", 1475 phba->brd_no, val); 1476 return -EINVAL; 1477 } 1478 1479 static int lpfc_link_speed = 0; 1480 module_param(lpfc_link_speed, int, 0); 1481 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed"); 1482 lpfc_param_show(link_speed) 1483 static int 1484 lpfc_link_speed_init(struct lpfc_hba *phba, int val) 1485 { 1486 if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED) 1487 && (LPFC_LINK_SPEED_BITMAP & (1 << val))) { 1488 phba->cfg_link_speed = val; 1489 return 0; 1490 } 1491 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1492 "0454 lpfc_link_speed attribute cannot " 1493 "be set to %d, allowed values are " 1494 "["LPFC_LINK_SPEED_STRING"]\n", val); 1495 phba->cfg_link_speed = 0; 1496 return -EINVAL; 1497 } 1498 1499 lpfc_param_store(link_speed) 1500 static CLASS_DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR, 1501 lpfc_link_speed_show, lpfc_link_speed_store); 1502 1503 /* 1504 # lpfc_fcp_class: Determines FC class to use for the FCP protocol. 1505 # Value range is [2,3]. Default value is 3. 1506 */ 1507 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3, 1508 "Select Fibre Channel class of service for FCP sequences"); 1509 1510 /* 1511 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range 1512 # is [0,1]. Default value is 0. 1513 */ 1514 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1, 1515 "Use ADISC on rediscovery to authenticate FCP devices"); 1516 1517 /* 1518 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value 1519 # range is [0,1]. Default value is 0. 1520 */ 1521 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support"); 1522 1523 /* 1524 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing 1525 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take 1526 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay 1527 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if 1528 # cr_delay is set to 0. 1529 */ 1530 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an " 1531 "interrupt response is generated"); 1532 1533 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an " 1534 "interrupt response is generated"); 1535 1536 /* 1537 # lpfc_multi_ring_support: Determines how many rings to spread available 1538 # cmd/rsp IOCB entries across. 1539 # Value range is [1,2]. Default value is 1. 1540 */ 1541 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary " 1542 "SLI rings to spread IOCB entries across"); 1543 1544 /* 1545 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this 1546 # identifies what rctl value to configure the additional ring for. 1547 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data). 1548 */ 1549 LPFC_ATTR_R(multi_ring_rctl, FC_UNSOL_DATA, 1, 1550 255, "Identifies RCTL for additional ring configuration"); 1551 1552 /* 1553 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this 1554 # identifies what type value to configure the additional ring for. 1555 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP). 1556 */ 1557 LPFC_ATTR_R(multi_ring_type, FC_LLC_SNAP, 1, 1558 255, "Identifies TYPE for additional ring configuration"); 1559 1560 /* 1561 # lpfc_fdmi_on: controls FDMI support. 1562 # 0 = no FDMI support 1563 # 1 = support FDMI without attribute of hostname 1564 # 2 = support FDMI with attribute of hostname 1565 # Value range [0,2]. Default value is 0. 1566 */ 1567 LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support"); 1568 1569 /* 1570 # Specifies the maximum number of ELS cmds we can have outstanding (for 1571 # discovery). Value range is [1,64]. Default value = 32. 1572 */ 1573 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands " 1574 "during discovery"); 1575 1576 /* 1577 # lpfc_max_luns: maximum allowed LUN. 1578 # Value range is [0,65535]. Default value is 255. 1579 # NOTE: The SCSI layer might probe all allowed LUN on some old targets. 1580 */ 1581 LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN"); 1582 1583 /* 1584 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring. 1585 # Value range is [1,255], default value is 10. 1586 */ 1587 LPFC_ATTR_RW(poll_tmo, 10, 1, 255, 1588 "Milliseconds driver will wait between polling FCP ring"); 1589 1590 /* 1591 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that 1592 # support this feature 1593 # 0 = MSI disabled (default) 1594 # 1 = MSI enabled 1595 # Value range is [0,1]. Default value is 0. 1596 */ 1597 LPFC_ATTR_R(use_msi, 0, 0, 1, "Use Message Signaled Interrupts, if possible"); 1598 1599 /* 1600 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware. 1601 # 0 = HBA resets disabled 1602 # 1 = HBA resets enabled (default) 1603 # Value range is [0,1]. Default value is 1. 1604 */ 1605 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver."); 1606 1607 /* 1608 # lpfc_enable_hba_heartbeat: Enable HBA heartbeat timer.. 1609 # 0 = HBA Heartbeat disabled 1610 # 1 = HBA Heartbeat enabled (default) 1611 # Value range is [0,1]. Default value is 1. 1612 */ 1613 LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat."); 1614 1615 /* 1616 * lpfc_sg_seg_cnt: Initial Maximum DMA Segment Count 1617 * This value can be set to values between 64 and 256. The default value is 1618 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer 1619 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE). 1620 */ 1621 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT, 1622 LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count"); 1623 1624 struct class_device_attribute *lpfc_hba_attrs[] = { 1625 &class_device_attr_info, 1626 &class_device_attr_serialnum, 1627 &class_device_attr_modeldesc, 1628 &class_device_attr_modelname, 1629 &class_device_attr_programtype, 1630 &class_device_attr_portnum, 1631 &class_device_attr_fwrev, 1632 &class_device_attr_hdw, 1633 &class_device_attr_option_rom_version, 1634 &class_device_attr_state, 1635 &class_device_attr_num_discovered_ports, 1636 &class_device_attr_lpfc_drvr_version, 1637 &class_device_attr_lpfc_temp_sensor, 1638 &class_device_attr_lpfc_log_verbose, 1639 &class_device_attr_lpfc_lun_queue_depth, 1640 &class_device_attr_lpfc_hba_queue_depth, 1641 &class_device_attr_lpfc_peer_port_login, 1642 &class_device_attr_lpfc_nodev_tmo, 1643 &class_device_attr_lpfc_devloss_tmo, 1644 &class_device_attr_lpfc_fcp_class, 1645 &class_device_attr_lpfc_use_adisc, 1646 &class_device_attr_lpfc_ack0, 1647 &class_device_attr_lpfc_topology, 1648 &class_device_attr_lpfc_scan_down, 1649 &class_device_attr_lpfc_link_speed, 1650 &class_device_attr_lpfc_cr_delay, 1651 &class_device_attr_lpfc_cr_count, 1652 &class_device_attr_lpfc_multi_ring_support, 1653 &class_device_attr_lpfc_multi_ring_rctl, 1654 &class_device_attr_lpfc_multi_ring_type, 1655 &class_device_attr_lpfc_fdmi_on, 1656 &class_device_attr_lpfc_max_luns, 1657 &class_device_attr_lpfc_enable_npiv, 1658 &class_device_attr_nport_evt_cnt, 1659 &class_device_attr_board_mode, 1660 &class_device_attr_max_vpi, 1661 &class_device_attr_used_vpi, 1662 &class_device_attr_max_rpi, 1663 &class_device_attr_used_rpi, 1664 &class_device_attr_max_xri, 1665 &class_device_attr_used_xri, 1666 &class_device_attr_npiv_info, 1667 &class_device_attr_issue_reset, 1668 &class_device_attr_lpfc_poll, 1669 &class_device_attr_lpfc_poll_tmo, 1670 &class_device_attr_lpfc_use_msi, 1671 &class_device_attr_lpfc_soft_wwnn, 1672 &class_device_attr_lpfc_soft_wwpn, 1673 &class_device_attr_lpfc_soft_wwn_enable, 1674 &class_device_attr_lpfc_enable_hba_reset, 1675 &class_device_attr_lpfc_enable_hba_heartbeat, 1676 &class_device_attr_lpfc_sg_seg_cnt, 1677 NULL, 1678 }; 1679 1680 struct class_device_attribute *lpfc_vport_attrs[] = { 1681 &class_device_attr_info, 1682 &class_device_attr_state, 1683 &class_device_attr_num_discovered_ports, 1684 &class_device_attr_lpfc_drvr_version, 1685 1686 &class_device_attr_lpfc_log_verbose, 1687 &class_device_attr_lpfc_lun_queue_depth, 1688 &class_device_attr_lpfc_nodev_tmo, 1689 &class_device_attr_lpfc_devloss_tmo, 1690 &class_device_attr_lpfc_hba_queue_depth, 1691 &class_device_attr_lpfc_peer_port_login, 1692 &class_device_attr_lpfc_restrict_login, 1693 &class_device_attr_lpfc_fcp_class, 1694 &class_device_attr_lpfc_use_adisc, 1695 &class_device_attr_lpfc_fdmi_on, 1696 &class_device_attr_lpfc_max_luns, 1697 &class_device_attr_nport_evt_cnt, 1698 &class_device_attr_npiv_info, 1699 &class_device_attr_lpfc_enable_da_id, 1700 NULL, 1701 }; 1702 1703 static ssize_t 1704 sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr, 1705 char *buf, loff_t off, size_t count) 1706 { 1707 size_t buf_off; 1708 struct class_device *cdev = container_of(kobj, struct class_device, 1709 kobj); 1710 struct Scsi_Host *shost = class_to_shost(cdev); 1711 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1712 struct lpfc_hba *phba = vport->phba; 1713 1714 if ((off + count) > FF_REG_AREA_SIZE) 1715 return -ERANGE; 1716 1717 if (count == 0) return 0; 1718 1719 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1720 return -EINVAL; 1721 1722 if (!(vport->fc_flag & FC_OFFLINE_MODE)) { 1723 return -EPERM; 1724 } 1725 1726 spin_lock_irq(&phba->hbalock); 1727 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) 1728 writel(*((uint32_t *)(buf + buf_off)), 1729 phba->ctrl_regs_memmap_p + off + buf_off); 1730 1731 spin_unlock_irq(&phba->hbalock); 1732 1733 return count; 1734 } 1735 1736 static ssize_t 1737 sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr, 1738 char *buf, loff_t off, size_t count) 1739 { 1740 size_t buf_off; 1741 uint32_t * tmp_ptr; 1742 struct class_device *cdev = container_of(kobj, struct class_device, 1743 kobj); 1744 struct Scsi_Host *shost = class_to_shost(cdev); 1745 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1746 struct lpfc_hba *phba = vport->phba; 1747 1748 if (off > FF_REG_AREA_SIZE) 1749 return -ERANGE; 1750 1751 if ((off + count) > FF_REG_AREA_SIZE) 1752 count = FF_REG_AREA_SIZE - off; 1753 1754 if (count == 0) return 0; 1755 1756 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1757 return -EINVAL; 1758 1759 spin_lock_irq(&phba->hbalock); 1760 1761 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) { 1762 tmp_ptr = (uint32_t *)(buf + buf_off); 1763 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off); 1764 } 1765 1766 spin_unlock_irq(&phba->hbalock); 1767 1768 return count; 1769 } 1770 1771 static struct bin_attribute sysfs_ctlreg_attr = { 1772 .attr = { 1773 .name = "ctlreg", 1774 .mode = S_IRUSR | S_IWUSR, 1775 }, 1776 .size = 256, 1777 .read = sysfs_ctlreg_read, 1778 .write = sysfs_ctlreg_write, 1779 }; 1780 1781 1782 static void 1783 sysfs_mbox_idle(struct lpfc_hba *phba) 1784 { 1785 phba->sysfs_mbox.state = SMBOX_IDLE; 1786 phba->sysfs_mbox.offset = 0; 1787 1788 if (phba->sysfs_mbox.mbox) { 1789 mempool_free(phba->sysfs_mbox.mbox, 1790 phba->mbox_mem_pool); 1791 phba->sysfs_mbox.mbox = NULL; 1792 } 1793 } 1794 1795 static ssize_t 1796 sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr, 1797 char *buf, loff_t off, size_t count) 1798 { 1799 struct class_device *cdev = container_of(kobj, struct class_device, 1800 kobj); 1801 struct Scsi_Host *shost = class_to_shost(cdev); 1802 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1803 struct lpfc_hba *phba = vport->phba; 1804 struct lpfcMboxq *mbox = NULL; 1805 1806 if ((count + off) > MAILBOX_CMD_SIZE) 1807 return -ERANGE; 1808 1809 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1810 return -EINVAL; 1811 1812 if (count == 0) 1813 return 0; 1814 1815 if (off == 0) { 1816 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1817 if (!mbox) 1818 return -ENOMEM; 1819 memset(mbox, 0, sizeof (LPFC_MBOXQ_t)); 1820 } 1821 1822 spin_lock_irq(&phba->hbalock); 1823 1824 if (off == 0) { 1825 if (phba->sysfs_mbox.mbox) 1826 mempool_free(mbox, phba->mbox_mem_pool); 1827 else 1828 phba->sysfs_mbox.mbox = mbox; 1829 phba->sysfs_mbox.state = SMBOX_WRITING; 1830 } else { 1831 if (phba->sysfs_mbox.state != SMBOX_WRITING || 1832 phba->sysfs_mbox.offset != off || 1833 phba->sysfs_mbox.mbox == NULL) { 1834 sysfs_mbox_idle(phba); 1835 spin_unlock_irq(&phba->hbalock); 1836 return -EAGAIN; 1837 } 1838 } 1839 1840 memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off, 1841 buf, count); 1842 1843 phba->sysfs_mbox.offset = off + count; 1844 1845 spin_unlock_irq(&phba->hbalock); 1846 1847 return count; 1848 } 1849 1850 static ssize_t 1851 sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr, 1852 char *buf, loff_t off, size_t count) 1853 { 1854 struct class_device *cdev = container_of(kobj, struct class_device, 1855 kobj); 1856 struct Scsi_Host *shost = class_to_shost(cdev); 1857 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1858 struct lpfc_hba *phba = vport->phba; 1859 int rc; 1860 1861 if (off > MAILBOX_CMD_SIZE) 1862 return -ERANGE; 1863 1864 if ((count + off) > MAILBOX_CMD_SIZE) 1865 count = MAILBOX_CMD_SIZE - off; 1866 1867 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1868 return -EINVAL; 1869 1870 if (off && count == 0) 1871 return 0; 1872 1873 spin_lock_irq(&phba->hbalock); 1874 1875 if (phba->over_temp_state == HBA_OVER_TEMP) { 1876 sysfs_mbox_idle(phba); 1877 spin_unlock_irq(&phba->hbalock); 1878 return -EACCES; 1879 } 1880 1881 if (off == 0 && 1882 phba->sysfs_mbox.state == SMBOX_WRITING && 1883 phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) { 1884 1885 switch (phba->sysfs_mbox.mbox->mb.mbxCommand) { 1886 /* Offline only */ 1887 case MBX_INIT_LINK: 1888 case MBX_DOWN_LINK: 1889 case MBX_CONFIG_LINK: 1890 case MBX_CONFIG_RING: 1891 case MBX_RESET_RING: 1892 case MBX_UNREG_LOGIN: 1893 case MBX_CLEAR_LA: 1894 case MBX_DUMP_CONTEXT: 1895 case MBX_RUN_DIAGS: 1896 case MBX_RESTART: 1897 case MBX_SET_MASK: 1898 case MBX_SET_DEBUG: 1899 if (!(vport->fc_flag & FC_OFFLINE_MODE)) { 1900 printk(KERN_WARNING "mbox_read:Command 0x%x " 1901 "is illegal in on-line state\n", 1902 phba->sysfs_mbox.mbox->mb.mbxCommand); 1903 sysfs_mbox_idle(phba); 1904 spin_unlock_irq(&phba->hbalock); 1905 return -EPERM; 1906 } 1907 case MBX_WRITE_NV: 1908 case MBX_WRITE_VPARMS: 1909 case MBX_LOAD_SM: 1910 case MBX_READ_NV: 1911 case MBX_READ_CONFIG: 1912 case MBX_READ_RCONFIG: 1913 case MBX_READ_STATUS: 1914 case MBX_READ_XRI: 1915 case MBX_READ_REV: 1916 case MBX_READ_LNK_STAT: 1917 case MBX_DUMP_MEMORY: 1918 case MBX_DOWN_LOAD: 1919 case MBX_UPDATE_CFG: 1920 case MBX_KILL_BOARD: 1921 case MBX_LOAD_AREA: 1922 case MBX_LOAD_EXP_ROM: 1923 case MBX_BEACON: 1924 case MBX_DEL_LD_ENTRY: 1925 case MBX_SET_VARIABLE: 1926 case MBX_WRITE_WWN: 1927 break; 1928 case MBX_READ_SPARM64: 1929 case MBX_READ_LA: 1930 case MBX_READ_LA64: 1931 case MBX_REG_LOGIN: 1932 case MBX_REG_LOGIN64: 1933 case MBX_CONFIG_PORT: 1934 case MBX_RUN_BIU_DIAG: 1935 printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n", 1936 phba->sysfs_mbox.mbox->mb.mbxCommand); 1937 sysfs_mbox_idle(phba); 1938 spin_unlock_irq(&phba->hbalock); 1939 return -EPERM; 1940 default: 1941 printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n", 1942 phba->sysfs_mbox.mbox->mb.mbxCommand); 1943 sysfs_mbox_idle(phba); 1944 spin_unlock_irq(&phba->hbalock); 1945 return -EPERM; 1946 } 1947 1948 /* If HBA encountered an error attention, allow only DUMP 1949 * mailbox command until the HBA is restarted. 1950 */ 1951 if ((phba->pport->stopped) && 1952 (phba->sysfs_mbox.mbox->mb.mbxCommand 1953 != MBX_DUMP_MEMORY)) { 1954 sysfs_mbox_idle(phba); 1955 spin_unlock_irq(&phba->hbalock); 1956 return -EPERM; 1957 } 1958 1959 phba->sysfs_mbox.mbox->vport = vport; 1960 1961 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) { 1962 sysfs_mbox_idle(phba); 1963 spin_unlock_irq(&phba->hbalock); 1964 return -EAGAIN; 1965 } 1966 1967 if ((vport->fc_flag & FC_OFFLINE_MODE) || 1968 (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){ 1969 1970 spin_unlock_irq(&phba->hbalock); 1971 rc = lpfc_sli_issue_mbox (phba, 1972 phba->sysfs_mbox.mbox, 1973 MBX_POLL); 1974 spin_lock_irq(&phba->hbalock); 1975 1976 } else { 1977 spin_unlock_irq(&phba->hbalock); 1978 rc = lpfc_sli_issue_mbox_wait (phba, 1979 phba->sysfs_mbox.mbox, 1980 lpfc_mbox_tmo_val(phba, 1981 phba->sysfs_mbox.mbox->mb.mbxCommand) * HZ); 1982 spin_lock_irq(&phba->hbalock); 1983 } 1984 1985 if (rc != MBX_SUCCESS) { 1986 if (rc == MBX_TIMEOUT) { 1987 phba->sysfs_mbox.mbox = NULL; 1988 } 1989 sysfs_mbox_idle(phba); 1990 spin_unlock_irq(&phba->hbalock); 1991 return (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV; 1992 } 1993 phba->sysfs_mbox.state = SMBOX_READING; 1994 } 1995 else if (phba->sysfs_mbox.offset != off || 1996 phba->sysfs_mbox.state != SMBOX_READING) { 1997 printk(KERN_WARNING "mbox_read: Bad State\n"); 1998 sysfs_mbox_idle(phba); 1999 spin_unlock_irq(&phba->hbalock); 2000 return -EAGAIN; 2001 } 2002 2003 memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count); 2004 2005 phba->sysfs_mbox.offset = off + count; 2006 2007 if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE) 2008 sysfs_mbox_idle(phba); 2009 2010 spin_unlock_irq(&phba->hbalock); 2011 2012 return count; 2013 } 2014 2015 static struct bin_attribute sysfs_mbox_attr = { 2016 .attr = { 2017 .name = "mbox", 2018 .mode = S_IRUSR | S_IWUSR, 2019 }, 2020 .size = MAILBOX_CMD_SIZE, 2021 .read = sysfs_mbox_read, 2022 .write = sysfs_mbox_write, 2023 }; 2024 2025 int 2026 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport) 2027 { 2028 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2029 int error; 2030 2031 error = sysfs_create_bin_file(&shost->shost_classdev.kobj, 2032 &sysfs_ctlreg_attr); 2033 if (error) 2034 goto out; 2035 2036 error = sysfs_create_bin_file(&shost->shost_classdev.kobj, 2037 &sysfs_mbox_attr); 2038 if (error) 2039 goto out_remove_ctlreg_attr; 2040 2041 return 0; 2042 out_remove_ctlreg_attr: 2043 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr); 2044 out: 2045 return error; 2046 } 2047 2048 void 2049 lpfc_free_sysfs_attr(struct lpfc_vport *vport) 2050 { 2051 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2052 2053 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_mbox_attr); 2054 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr); 2055 } 2056 2057 2058 /* 2059 * Dynamic FC Host Attributes Support 2060 */ 2061 2062 static void 2063 lpfc_get_host_port_id(struct Scsi_Host *shost) 2064 { 2065 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2066 2067 /* note: fc_myDID already in cpu endianness */ 2068 fc_host_port_id(shost) = vport->fc_myDID; 2069 } 2070 2071 static void 2072 lpfc_get_host_port_type(struct Scsi_Host *shost) 2073 { 2074 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2075 struct lpfc_hba *phba = vport->phba; 2076 2077 spin_lock_irq(shost->host_lock); 2078 2079 if (vport->port_type == LPFC_NPIV_PORT) { 2080 fc_host_port_type(shost) = FC_PORTTYPE_NPIV; 2081 } else if (lpfc_is_link_up(phba)) { 2082 if (phba->fc_topology == TOPOLOGY_LOOP) { 2083 if (vport->fc_flag & FC_PUBLIC_LOOP) 2084 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT; 2085 else 2086 fc_host_port_type(shost) = FC_PORTTYPE_LPORT; 2087 } else { 2088 if (vport->fc_flag & FC_FABRIC) 2089 fc_host_port_type(shost) = FC_PORTTYPE_NPORT; 2090 else 2091 fc_host_port_type(shost) = FC_PORTTYPE_PTP; 2092 } 2093 } else 2094 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN; 2095 2096 spin_unlock_irq(shost->host_lock); 2097 } 2098 2099 static void 2100 lpfc_get_host_port_state(struct Scsi_Host *shost) 2101 { 2102 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2103 struct lpfc_hba *phba = vport->phba; 2104 2105 spin_lock_irq(shost->host_lock); 2106 2107 if (vport->fc_flag & FC_OFFLINE_MODE) 2108 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 2109 else { 2110 switch (phba->link_state) { 2111 case LPFC_LINK_UNKNOWN: 2112 case LPFC_LINK_DOWN: 2113 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 2114 break; 2115 case LPFC_LINK_UP: 2116 case LPFC_CLEAR_LA: 2117 case LPFC_HBA_READY: 2118 /* Links up, beyond this port_type reports state */ 2119 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 2120 break; 2121 case LPFC_HBA_ERROR: 2122 fc_host_port_state(shost) = FC_PORTSTATE_ERROR; 2123 break; 2124 default: 2125 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 2126 break; 2127 } 2128 } 2129 2130 spin_unlock_irq(shost->host_lock); 2131 } 2132 2133 static void 2134 lpfc_get_host_speed(struct Scsi_Host *shost) 2135 { 2136 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2137 struct lpfc_hba *phba = vport->phba; 2138 2139 spin_lock_irq(shost->host_lock); 2140 2141 if (lpfc_is_link_up(phba)) { 2142 switch(phba->fc_linkspeed) { 2143 case LA_1GHZ_LINK: 2144 fc_host_speed(shost) = FC_PORTSPEED_1GBIT; 2145 break; 2146 case LA_2GHZ_LINK: 2147 fc_host_speed(shost) = FC_PORTSPEED_2GBIT; 2148 break; 2149 case LA_4GHZ_LINK: 2150 fc_host_speed(shost) = FC_PORTSPEED_4GBIT; 2151 break; 2152 case LA_8GHZ_LINK: 2153 fc_host_speed(shost) = FC_PORTSPEED_8GBIT; 2154 break; 2155 default: 2156 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 2157 break; 2158 } 2159 } else 2160 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 2161 2162 spin_unlock_irq(shost->host_lock); 2163 } 2164 2165 static void 2166 lpfc_get_host_fabric_name (struct Scsi_Host *shost) 2167 { 2168 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2169 struct lpfc_hba *phba = vport->phba; 2170 u64 node_name; 2171 2172 spin_lock_irq(shost->host_lock); 2173 2174 if ((vport->fc_flag & FC_FABRIC) || 2175 ((phba->fc_topology == TOPOLOGY_LOOP) && 2176 (vport->fc_flag & FC_PUBLIC_LOOP))) 2177 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn); 2178 else 2179 /* fabric is local port if there is no F/FL_Port */ 2180 node_name = 0; 2181 2182 spin_unlock_irq(shost->host_lock); 2183 2184 fc_host_fabric_name(shost) = node_name; 2185 } 2186 2187 static struct fc_host_statistics * 2188 lpfc_get_stats(struct Scsi_Host *shost) 2189 { 2190 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2191 struct lpfc_hba *phba = vport->phba; 2192 struct lpfc_sli *psli = &phba->sli; 2193 struct fc_host_statistics *hs = &phba->link_stats; 2194 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets; 2195 LPFC_MBOXQ_t *pmboxq; 2196 MAILBOX_t *pmb; 2197 unsigned long seconds; 2198 int rc = 0; 2199 2200 /* 2201 * prevent udev from issuing mailbox commands until the port is 2202 * configured. 2203 */ 2204 if (phba->link_state < LPFC_LINK_DOWN || 2205 !phba->mbox_mem_pool || 2206 (phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0) 2207 return NULL; 2208 2209 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 2210 return NULL; 2211 2212 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2213 if (!pmboxq) 2214 return NULL; 2215 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 2216 2217 pmb = &pmboxq->mb; 2218 pmb->mbxCommand = MBX_READ_STATUS; 2219 pmb->mbxOwner = OWN_HOST; 2220 pmboxq->context1 = NULL; 2221 pmboxq->vport = vport; 2222 2223 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2224 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2225 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2226 else 2227 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2228 2229 if (rc != MBX_SUCCESS) { 2230 if (rc != MBX_TIMEOUT) 2231 mempool_free(pmboxq, phba->mbox_mem_pool); 2232 return NULL; 2233 } 2234 2235 memset(hs, 0, sizeof (struct fc_host_statistics)); 2236 2237 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt; 2238 hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256); 2239 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt; 2240 hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256); 2241 2242 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 2243 pmb->mbxCommand = MBX_READ_LNK_STAT; 2244 pmb->mbxOwner = OWN_HOST; 2245 pmboxq->context1 = NULL; 2246 pmboxq->vport = vport; 2247 2248 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2249 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2250 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2251 else 2252 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2253 2254 if (rc != MBX_SUCCESS) { 2255 if (rc != MBX_TIMEOUT) 2256 mempool_free(pmboxq, phba->mbox_mem_pool); 2257 return NULL; 2258 } 2259 2260 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 2261 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 2262 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 2263 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 2264 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 2265 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 2266 hs->error_frames = pmb->un.varRdLnk.crcCnt; 2267 2268 hs->link_failure_count -= lso->link_failure_count; 2269 hs->loss_of_sync_count -= lso->loss_of_sync_count; 2270 hs->loss_of_signal_count -= lso->loss_of_signal_count; 2271 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count; 2272 hs->invalid_tx_word_count -= lso->invalid_tx_word_count; 2273 hs->invalid_crc_count -= lso->invalid_crc_count; 2274 hs->error_frames -= lso->error_frames; 2275 2276 if (phba->fc_topology == TOPOLOGY_LOOP) { 2277 hs->lip_count = (phba->fc_eventTag >> 1); 2278 hs->lip_count -= lso->link_events; 2279 hs->nos_count = -1; 2280 } else { 2281 hs->lip_count = -1; 2282 hs->nos_count = (phba->fc_eventTag >> 1); 2283 hs->nos_count -= lso->link_events; 2284 } 2285 2286 hs->dumped_frames = -1; 2287 2288 seconds = get_seconds(); 2289 if (seconds < psli->stats_start) 2290 hs->seconds_since_last_reset = seconds + 2291 ((unsigned long)-1 - psli->stats_start); 2292 else 2293 hs->seconds_since_last_reset = seconds - psli->stats_start; 2294 2295 mempool_free(pmboxq, phba->mbox_mem_pool); 2296 2297 return hs; 2298 } 2299 2300 static void 2301 lpfc_reset_stats(struct Scsi_Host *shost) 2302 { 2303 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2304 struct lpfc_hba *phba = vport->phba; 2305 struct lpfc_sli *psli = &phba->sli; 2306 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets; 2307 LPFC_MBOXQ_t *pmboxq; 2308 MAILBOX_t *pmb; 2309 int rc = 0; 2310 2311 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 2312 return; 2313 2314 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2315 if (!pmboxq) 2316 return; 2317 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 2318 2319 pmb = &pmboxq->mb; 2320 pmb->mbxCommand = MBX_READ_STATUS; 2321 pmb->mbxOwner = OWN_HOST; 2322 pmb->un.varWords[0] = 0x1; /* reset request */ 2323 pmboxq->context1 = NULL; 2324 pmboxq->vport = vport; 2325 2326 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2327 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2328 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2329 else 2330 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2331 2332 if (rc != MBX_SUCCESS) { 2333 if (rc != MBX_TIMEOUT) 2334 mempool_free(pmboxq, phba->mbox_mem_pool); 2335 return; 2336 } 2337 2338 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 2339 pmb->mbxCommand = MBX_READ_LNK_STAT; 2340 pmb->mbxOwner = OWN_HOST; 2341 pmboxq->context1 = NULL; 2342 pmboxq->vport = vport; 2343 2344 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2345 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2346 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2347 else 2348 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2349 2350 if (rc != MBX_SUCCESS) { 2351 if (rc != MBX_TIMEOUT) 2352 mempool_free( pmboxq, phba->mbox_mem_pool); 2353 return; 2354 } 2355 2356 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 2357 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 2358 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 2359 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 2360 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 2361 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 2362 lso->error_frames = pmb->un.varRdLnk.crcCnt; 2363 lso->link_events = (phba->fc_eventTag >> 1); 2364 2365 psli->stats_start = get_seconds(); 2366 2367 mempool_free(pmboxq, phba->mbox_mem_pool); 2368 2369 return; 2370 } 2371 2372 /* 2373 * The LPFC driver treats linkdown handling as target loss events so there 2374 * are no sysfs handlers for link_down_tmo. 2375 */ 2376 2377 static struct lpfc_nodelist * 2378 lpfc_get_node_by_target(struct scsi_target *starget) 2379 { 2380 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2381 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2382 struct lpfc_nodelist *ndlp; 2383 2384 spin_lock_irq(shost->host_lock); 2385 /* Search for this, mapped, target ID */ 2386 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 2387 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE && 2388 starget->id == ndlp->nlp_sid) { 2389 spin_unlock_irq(shost->host_lock); 2390 return ndlp; 2391 } 2392 } 2393 spin_unlock_irq(shost->host_lock); 2394 return NULL; 2395 } 2396 2397 static void 2398 lpfc_get_starget_port_id(struct scsi_target *starget) 2399 { 2400 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 2401 2402 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1; 2403 } 2404 2405 static void 2406 lpfc_get_starget_node_name(struct scsi_target *starget) 2407 { 2408 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 2409 2410 fc_starget_node_name(starget) = 2411 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0; 2412 } 2413 2414 static void 2415 lpfc_get_starget_port_name(struct scsi_target *starget) 2416 { 2417 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 2418 2419 fc_starget_port_name(starget) = 2420 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0; 2421 } 2422 2423 static void 2424 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 2425 { 2426 if (timeout) 2427 rport->dev_loss_tmo = timeout; 2428 else 2429 rport->dev_loss_tmo = 1; 2430 } 2431 2432 2433 #define lpfc_rport_show_function(field, format_string, sz, cast) \ 2434 static ssize_t \ 2435 lpfc_show_rport_##field (struct class_device *cdev, char *buf) \ 2436 { \ 2437 struct fc_rport *rport = transport_class_to_rport(cdev); \ 2438 struct lpfc_rport_data *rdata = rport->hostdata; \ 2439 return snprintf(buf, sz, format_string, \ 2440 (rdata->target) ? cast rdata->target->field : 0); \ 2441 } 2442 2443 #define lpfc_rport_rd_attr(field, format_string, sz) \ 2444 lpfc_rport_show_function(field, format_string, sz, ) \ 2445 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL) 2446 2447 2448 struct fc_function_template lpfc_transport_functions = { 2449 /* fixed attributes the driver supports */ 2450 .show_host_node_name = 1, 2451 .show_host_port_name = 1, 2452 .show_host_supported_classes = 1, 2453 .show_host_supported_fc4s = 1, 2454 .show_host_supported_speeds = 1, 2455 .show_host_maxframe_size = 1, 2456 2457 /* dynamic attributes the driver supports */ 2458 .get_host_port_id = lpfc_get_host_port_id, 2459 .show_host_port_id = 1, 2460 2461 .get_host_port_type = lpfc_get_host_port_type, 2462 .show_host_port_type = 1, 2463 2464 .get_host_port_state = lpfc_get_host_port_state, 2465 .show_host_port_state = 1, 2466 2467 /* active_fc4s is shown but doesn't change (thus no get function) */ 2468 .show_host_active_fc4s = 1, 2469 2470 .get_host_speed = lpfc_get_host_speed, 2471 .show_host_speed = 1, 2472 2473 .get_host_fabric_name = lpfc_get_host_fabric_name, 2474 .show_host_fabric_name = 1, 2475 2476 /* 2477 * The LPFC driver treats linkdown handling as target loss events 2478 * so there are no sysfs handlers for link_down_tmo. 2479 */ 2480 2481 .get_fc_host_stats = lpfc_get_stats, 2482 .reset_fc_host_stats = lpfc_reset_stats, 2483 2484 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 2485 .show_rport_maxframe_size = 1, 2486 .show_rport_supported_classes = 1, 2487 2488 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 2489 .show_rport_dev_loss_tmo = 1, 2490 2491 .get_starget_port_id = lpfc_get_starget_port_id, 2492 .show_starget_port_id = 1, 2493 2494 .get_starget_node_name = lpfc_get_starget_node_name, 2495 .show_starget_node_name = 1, 2496 2497 .get_starget_port_name = lpfc_get_starget_port_name, 2498 .show_starget_port_name = 1, 2499 2500 .issue_fc_host_lip = lpfc_issue_lip, 2501 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 2502 .terminate_rport_io = lpfc_terminate_rport_io, 2503 2504 .dd_fcvport_size = sizeof(struct lpfc_vport *), 2505 }; 2506 2507 struct fc_function_template lpfc_vport_transport_functions = { 2508 /* fixed attributes the driver supports */ 2509 .show_host_node_name = 1, 2510 .show_host_port_name = 1, 2511 .show_host_supported_classes = 1, 2512 .show_host_supported_fc4s = 1, 2513 .show_host_supported_speeds = 1, 2514 .show_host_maxframe_size = 1, 2515 2516 /* dynamic attributes the driver supports */ 2517 .get_host_port_id = lpfc_get_host_port_id, 2518 .show_host_port_id = 1, 2519 2520 .get_host_port_type = lpfc_get_host_port_type, 2521 .show_host_port_type = 1, 2522 2523 .get_host_port_state = lpfc_get_host_port_state, 2524 .show_host_port_state = 1, 2525 2526 /* active_fc4s is shown but doesn't change (thus no get function) */ 2527 .show_host_active_fc4s = 1, 2528 2529 .get_host_speed = lpfc_get_host_speed, 2530 .show_host_speed = 1, 2531 2532 .get_host_fabric_name = lpfc_get_host_fabric_name, 2533 .show_host_fabric_name = 1, 2534 2535 /* 2536 * The LPFC driver treats linkdown handling as target loss events 2537 * so there are no sysfs handlers for link_down_tmo. 2538 */ 2539 2540 .get_fc_host_stats = lpfc_get_stats, 2541 .reset_fc_host_stats = lpfc_reset_stats, 2542 2543 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 2544 .show_rport_maxframe_size = 1, 2545 .show_rport_supported_classes = 1, 2546 2547 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 2548 .show_rport_dev_loss_tmo = 1, 2549 2550 .get_starget_port_id = lpfc_get_starget_port_id, 2551 .show_starget_port_id = 1, 2552 2553 .get_starget_node_name = lpfc_get_starget_node_name, 2554 .show_starget_node_name = 1, 2555 2556 .get_starget_port_name = lpfc_get_starget_port_name, 2557 .show_starget_port_name = 1, 2558 2559 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 2560 .terminate_rport_io = lpfc_terminate_rport_io, 2561 2562 .vport_disable = lpfc_vport_disable, 2563 }; 2564 2565 void 2566 lpfc_get_cfgparam(struct lpfc_hba *phba) 2567 { 2568 lpfc_cr_delay_init(phba, lpfc_cr_delay); 2569 lpfc_cr_count_init(phba, lpfc_cr_count); 2570 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support); 2571 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl); 2572 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type); 2573 lpfc_ack0_init(phba, lpfc_ack0); 2574 lpfc_topology_init(phba, lpfc_topology); 2575 lpfc_link_speed_init(phba, lpfc_link_speed); 2576 lpfc_poll_tmo_init(phba, lpfc_poll_tmo); 2577 lpfc_enable_npiv_init(phba, lpfc_enable_npiv); 2578 lpfc_use_msi_init(phba, lpfc_use_msi); 2579 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset); 2580 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat); 2581 phba->cfg_poll = lpfc_poll; 2582 phba->cfg_soft_wwnn = 0L; 2583 phba->cfg_soft_wwpn = 0L; 2584 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt); 2585 /* Also reinitialize the host templates with new values. */ 2586 lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt; 2587 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt; 2588 /* 2589 * Since the sg_tablesize is module parameter, the sg_dma_buf_size 2590 * used to create the sg_dma_buf_pool must be dynamically calculated. 2591 * 2 segments are added since the IOCB needs a command and response bde. 2592 */ 2593 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) + 2594 sizeof(struct fcp_rsp) + 2595 ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64)); 2596 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth); 2597 return; 2598 } 2599 2600 void 2601 lpfc_get_vport_cfgparam(struct lpfc_vport *vport) 2602 { 2603 lpfc_log_verbose_init(vport, lpfc_log_verbose); 2604 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth); 2605 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo); 2606 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo); 2607 lpfc_peer_port_login_init(vport, lpfc_peer_port_login); 2608 lpfc_restrict_login_init(vport, lpfc_restrict_login); 2609 lpfc_fcp_class_init(vport, lpfc_fcp_class); 2610 lpfc_use_adisc_init(vport, lpfc_use_adisc); 2611 lpfc_fdmi_on_init(vport, lpfc_fdmi_on); 2612 lpfc_discovery_threads_init(vport, lpfc_discovery_threads); 2613 lpfc_max_luns_init(vport, lpfc_max_luns); 2614 lpfc_scan_down_init(vport, lpfc_scan_down); 2615 lpfc_enable_da_id_init(vport, lpfc_enable_da_id); 2616 return; 2617 } 2618