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 (NLP_CHK_NODE_ACT(ndlp) && 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 # 2 = MSI-X enabled 1596 # Value range is [0,2]. Default value is 0. 1597 */ 1598 LPFC_ATTR_R(use_msi, 0, 0, 2, "Use Message Signaled Interrupts (1) or " 1599 "MSI-X (2), if possible"); 1600 1601 /* 1602 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware. 1603 # 0 = HBA resets disabled 1604 # 1 = HBA resets enabled (default) 1605 # Value range is [0,1]. Default value is 1. 1606 */ 1607 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver."); 1608 1609 /* 1610 # lpfc_enable_hba_heartbeat: Enable HBA heartbeat timer.. 1611 # 0 = HBA Heartbeat disabled 1612 # 1 = HBA Heartbeat enabled (default) 1613 # Value range is [0,1]. Default value is 1. 1614 */ 1615 LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat."); 1616 1617 /* 1618 * lpfc_sg_seg_cnt: Initial Maximum DMA Segment Count 1619 * This value can be set to values between 64 and 256. The default value is 1620 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer 1621 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE). 1622 */ 1623 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT, 1624 LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count"); 1625 1626 struct class_device_attribute *lpfc_hba_attrs[] = { 1627 &class_device_attr_info, 1628 &class_device_attr_serialnum, 1629 &class_device_attr_modeldesc, 1630 &class_device_attr_modelname, 1631 &class_device_attr_programtype, 1632 &class_device_attr_portnum, 1633 &class_device_attr_fwrev, 1634 &class_device_attr_hdw, 1635 &class_device_attr_option_rom_version, 1636 &class_device_attr_state, 1637 &class_device_attr_num_discovered_ports, 1638 &class_device_attr_lpfc_drvr_version, 1639 &class_device_attr_lpfc_temp_sensor, 1640 &class_device_attr_lpfc_log_verbose, 1641 &class_device_attr_lpfc_lun_queue_depth, 1642 &class_device_attr_lpfc_hba_queue_depth, 1643 &class_device_attr_lpfc_peer_port_login, 1644 &class_device_attr_lpfc_nodev_tmo, 1645 &class_device_attr_lpfc_devloss_tmo, 1646 &class_device_attr_lpfc_fcp_class, 1647 &class_device_attr_lpfc_use_adisc, 1648 &class_device_attr_lpfc_ack0, 1649 &class_device_attr_lpfc_topology, 1650 &class_device_attr_lpfc_scan_down, 1651 &class_device_attr_lpfc_link_speed, 1652 &class_device_attr_lpfc_cr_delay, 1653 &class_device_attr_lpfc_cr_count, 1654 &class_device_attr_lpfc_multi_ring_support, 1655 &class_device_attr_lpfc_multi_ring_rctl, 1656 &class_device_attr_lpfc_multi_ring_type, 1657 &class_device_attr_lpfc_fdmi_on, 1658 &class_device_attr_lpfc_max_luns, 1659 &class_device_attr_lpfc_enable_npiv, 1660 &class_device_attr_nport_evt_cnt, 1661 &class_device_attr_board_mode, 1662 &class_device_attr_max_vpi, 1663 &class_device_attr_used_vpi, 1664 &class_device_attr_max_rpi, 1665 &class_device_attr_used_rpi, 1666 &class_device_attr_max_xri, 1667 &class_device_attr_used_xri, 1668 &class_device_attr_npiv_info, 1669 &class_device_attr_issue_reset, 1670 &class_device_attr_lpfc_poll, 1671 &class_device_attr_lpfc_poll_tmo, 1672 &class_device_attr_lpfc_use_msi, 1673 &class_device_attr_lpfc_soft_wwnn, 1674 &class_device_attr_lpfc_soft_wwpn, 1675 &class_device_attr_lpfc_soft_wwn_enable, 1676 &class_device_attr_lpfc_enable_hba_reset, 1677 &class_device_attr_lpfc_enable_hba_heartbeat, 1678 &class_device_attr_lpfc_sg_seg_cnt, 1679 NULL, 1680 }; 1681 1682 struct class_device_attribute *lpfc_vport_attrs[] = { 1683 &class_device_attr_info, 1684 &class_device_attr_state, 1685 &class_device_attr_num_discovered_ports, 1686 &class_device_attr_lpfc_drvr_version, 1687 1688 &class_device_attr_lpfc_log_verbose, 1689 &class_device_attr_lpfc_lun_queue_depth, 1690 &class_device_attr_lpfc_nodev_tmo, 1691 &class_device_attr_lpfc_devloss_tmo, 1692 &class_device_attr_lpfc_hba_queue_depth, 1693 &class_device_attr_lpfc_peer_port_login, 1694 &class_device_attr_lpfc_restrict_login, 1695 &class_device_attr_lpfc_fcp_class, 1696 &class_device_attr_lpfc_use_adisc, 1697 &class_device_attr_lpfc_fdmi_on, 1698 &class_device_attr_lpfc_max_luns, 1699 &class_device_attr_nport_evt_cnt, 1700 &class_device_attr_npiv_info, 1701 &class_device_attr_lpfc_enable_da_id, 1702 NULL, 1703 }; 1704 1705 static ssize_t 1706 sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr, 1707 char *buf, loff_t off, size_t count) 1708 { 1709 size_t buf_off; 1710 struct class_device *cdev = container_of(kobj, struct class_device, 1711 kobj); 1712 struct Scsi_Host *shost = class_to_shost(cdev); 1713 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1714 struct lpfc_hba *phba = vport->phba; 1715 1716 if ((off + count) > FF_REG_AREA_SIZE) 1717 return -ERANGE; 1718 1719 if (count == 0) return 0; 1720 1721 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1722 return -EINVAL; 1723 1724 if (!(vport->fc_flag & FC_OFFLINE_MODE)) { 1725 return -EPERM; 1726 } 1727 1728 spin_lock_irq(&phba->hbalock); 1729 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) 1730 writel(*((uint32_t *)(buf + buf_off)), 1731 phba->ctrl_regs_memmap_p + off + buf_off); 1732 1733 spin_unlock_irq(&phba->hbalock); 1734 1735 return count; 1736 } 1737 1738 static ssize_t 1739 sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr, 1740 char *buf, loff_t off, size_t count) 1741 { 1742 size_t buf_off; 1743 uint32_t * tmp_ptr; 1744 struct class_device *cdev = container_of(kobj, struct class_device, 1745 kobj); 1746 struct Scsi_Host *shost = class_to_shost(cdev); 1747 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1748 struct lpfc_hba *phba = vport->phba; 1749 1750 if (off > FF_REG_AREA_SIZE) 1751 return -ERANGE; 1752 1753 if ((off + count) > FF_REG_AREA_SIZE) 1754 count = FF_REG_AREA_SIZE - off; 1755 1756 if (count == 0) return 0; 1757 1758 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1759 return -EINVAL; 1760 1761 spin_lock_irq(&phba->hbalock); 1762 1763 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) { 1764 tmp_ptr = (uint32_t *)(buf + buf_off); 1765 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off); 1766 } 1767 1768 spin_unlock_irq(&phba->hbalock); 1769 1770 return count; 1771 } 1772 1773 static struct bin_attribute sysfs_ctlreg_attr = { 1774 .attr = { 1775 .name = "ctlreg", 1776 .mode = S_IRUSR | S_IWUSR, 1777 }, 1778 .size = 256, 1779 .read = sysfs_ctlreg_read, 1780 .write = sysfs_ctlreg_write, 1781 }; 1782 1783 1784 static void 1785 sysfs_mbox_idle(struct lpfc_hba *phba) 1786 { 1787 phba->sysfs_mbox.state = SMBOX_IDLE; 1788 phba->sysfs_mbox.offset = 0; 1789 1790 if (phba->sysfs_mbox.mbox) { 1791 mempool_free(phba->sysfs_mbox.mbox, 1792 phba->mbox_mem_pool); 1793 phba->sysfs_mbox.mbox = NULL; 1794 } 1795 } 1796 1797 static ssize_t 1798 sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr, 1799 char *buf, loff_t off, size_t count) 1800 { 1801 struct class_device *cdev = container_of(kobj, struct class_device, 1802 kobj); 1803 struct Scsi_Host *shost = class_to_shost(cdev); 1804 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1805 struct lpfc_hba *phba = vport->phba; 1806 struct lpfcMboxq *mbox = NULL; 1807 1808 if ((count + off) > MAILBOX_CMD_SIZE) 1809 return -ERANGE; 1810 1811 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1812 return -EINVAL; 1813 1814 if (count == 0) 1815 return 0; 1816 1817 if (off == 0) { 1818 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1819 if (!mbox) 1820 return -ENOMEM; 1821 memset(mbox, 0, sizeof (LPFC_MBOXQ_t)); 1822 } 1823 1824 spin_lock_irq(&phba->hbalock); 1825 1826 if (off == 0) { 1827 if (phba->sysfs_mbox.mbox) 1828 mempool_free(mbox, phba->mbox_mem_pool); 1829 else 1830 phba->sysfs_mbox.mbox = mbox; 1831 phba->sysfs_mbox.state = SMBOX_WRITING; 1832 } else { 1833 if (phba->sysfs_mbox.state != SMBOX_WRITING || 1834 phba->sysfs_mbox.offset != off || 1835 phba->sysfs_mbox.mbox == NULL) { 1836 sysfs_mbox_idle(phba); 1837 spin_unlock_irq(&phba->hbalock); 1838 return -EAGAIN; 1839 } 1840 } 1841 1842 memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off, 1843 buf, count); 1844 1845 phba->sysfs_mbox.offset = off + count; 1846 1847 spin_unlock_irq(&phba->hbalock); 1848 1849 return count; 1850 } 1851 1852 static ssize_t 1853 sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr, 1854 char *buf, loff_t off, size_t count) 1855 { 1856 struct class_device *cdev = container_of(kobj, struct class_device, 1857 kobj); 1858 struct Scsi_Host *shost = class_to_shost(cdev); 1859 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 1860 struct lpfc_hba *phba = vport->phba; 1861 int rc; 1862 1863 if (off > MAILBOX_CMD_SIZE) 1864 return -ERANGE; 1865 1866 if ((count + off) > MAILBOX_CMD_SIZE) 1867 count = MAILBOX_CMD_SIZE - off; 1868 1869 if (off % 4 || count % 4 || (unsigned long)buf % 4) 1870 return -EINVAL; 1871 1872 if (off && count == 0) 1873 return 0; 1874 1875 spin_lock_irq(&phba->hbalock); 1876 1877 if (phba->over_temp_state == HBA_OVER_TEMP) { 1878 sysfs_mbox_idle(phba); 1879 spin_unlock_irq(&phba->hbalock); 1880 return -EACCES; 1881 } 1882 1883 if (off == 0 && 1884 phba->sysfs_mbox.state == SMBOX_WRITING && 1885 phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) { 1886 1887 switch (phba->sysfs_mbox.mbox->mb.mbxCommand) { 1888 /* Offline only */ 1889 case MBX_INIT_LINK: 1890 case MBX_DOWN_LINK: 1891 case MBX_CONFIG_LINK: 1892 case MBX_CONFIG_RING: 1893 case MBX_RESET_RING: 1894 case MBX_UNREG_LOGIN: 1895 case MBX_CLEAR_LA: 1896 case MBX_DUMP_CONTEXT: 1897 case MBX_RUN_DIAGS: 1898 case MBX_RESTART: 1899 case MBX_SET_MASK: 1900 case MBX_SET_DEBUG: 1901 if (!(vport->fc_flag & FC_OFFLINE_MODE)) { 1902 printk(KERN_WARNING "mbox_read:Command 0x%x " 1903 "is illegal in on-line state\n", 1904 phba->sysfs_mbox.mbox->mb.mbxCommand); 1905 sysfs_mbox_idle(phba); 1906 spin_unlock_irq(&phba->hbalock); 1907 return -EPERM; 1908 } 1909 case MBX_WRITE_NV: 1910 case MBX_WRITE_VPARMS: 1911 case MBX_LOAD_SM: 1912 case MBX_READ_NV: 1913 case MBX_READ_CONFIG: 1914 case MBX_READ_RCONFIG: 1915 case MBX_READ_STATUS: 1916 case MBX_READ_XRI: 1917 case MBX_READ_REV: 1918 case MBX_READ_LNK_STAT: 1919 case MBX_DUMP_MEMORY: 1920 case MBX_DOWN_LOAD: 1921 case MBX_UPDATE_CFG: 1922 case MBX_KILL_BOARD: 1923 case MBX_LOAD_AREA: 1924 case MBX_LOAD_EXP_ROM: 1925 case MBX_BEACON: 1926 case MBX_DEL_LD_ENTRY: 1927 case MBX_SET_VARIABLE: 1928 case MBX_WRITE_WWN: 1929 break; 1930 case MBX_READ_SPARM64: 1931 case MBX_READ_LA: 1932 case MBX_READ_LA64: 1933 case MBX_REG_LOGIN: 1934 case MBX_REG_LOGIN64: 1935 case MBX_CONFIG_PORT: 1936 case MBX_RUN_BIU_DIAG: 1937 printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n", 1938 phba->sysfs_mbox.mbox->mb.mbxCommand); 1939 sysfs_mbox_idle(phba); 1940 spin_unlock_irq(&phba->hbalock); 1941 return -EPERM; 1942 default: 1943 printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n", 1944 phba->sysfs_mbox.mbox->mb.mbxCommand); 1945 sysfs_mbox_idle(phba); 1946 spin_unlock_irq(&phba->hbalock); 1947 return -EPERM; 1948 } 1949 1950 /* If HBA encountered an error attention, allow only DUMP 1951 * or RESTART mailbox commands until the HBA is restarted. 1952 */ 1953 if ((phba->pport->stopped) && 1954 (phba->sysfs_mbox.mbox->mb.mbxCommand != 1955 MBX_DUMP_MEMORY && 1956 phba->sysfs_mbox.mbox->mb.mbxCommand != 1957 MBX_RESTART && 1958 phba->sysfs_mbox.mbox->mb.mbxCommand != 1959 MBX_WRITE_VPARMS)) { 1960 sysfs_mbox_idle(phba); 1961 spin_unlock_irq(&phba->hbalock); 1962 return -EPERM; 1963 } 1964 1965 phba->sysfs_mbox.mbox->vport = vport; 1966 1967 /* Don't allow mailbox commands to be sent when blocked 1968 * or when in the middle of discovery 1969 */ 1970 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO || 1971 vport->fc_flag & FC_NDISC_ACTIVE) { 1972 sysfs_mbox_idle(phba); 1973 spin_unlock_irq(&phba->hbalock); 1974 return -EAGAIN; 1975 } 1976 1977 if ((vport->fc_flag & FC_OFFLINE_MODE) || 1978 (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){ 1979 1980 spin_unlock_irq(&phba->hbalock); 1981 rc = lpfc_sli_issue_mbox (phba, 1982 phba->sysfs_mbox.mbox, 1983 MBX_POLL); 1984 spin_lock_irq(&phba->hbalock); 1985 1986 } else { 1987 spin_unlock_irq(&phba->hbalock); 1988 rc = lpfc_sli_issue_mbox_wait (phba, 1989 phba->sysfs_mbox.mbox, 1990 lpfc_mbox_tmo_val(phba, 1991 phba->sysfs_mbox.mbox->mb.mbxCommand) * HZ); 1992 spin_lock_irq(&phba->hbalock); 1993 } 1994 1995 if (rc != MBX_SUCCESS) { 1996 if (rc == MBX_TIMEOUT) { 1997 phba->sysfs_mbox.mbox = NULL; 1998 } 1999 sysfs_mbox_idle(phba); 2000 spin_unlock_irq(&phba->hbalock); 2001 return (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV; 2002 } 2003 phba->sysfs_mbox.state = SMBOX_READING; 2004 } 2005 else if (phba->sysfs_mbox.offset != off || 2006 phba->sysfs_mbox.state != SMBOX_READING) { 2007 printk(KERN_WARNING "mbox_read: Bad State\n"); 2008 sysfs_mbox_idle(phba); 2009 spin_unlock_irq(&phba->hbalock); 2010 return -EAGAIN; 2011 } 2012 2013 memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count); 2014 2015 phba->sysfs_mbox.offset = off + count; 2016 2017 if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE) 2018 sysfs_mbox_idle(phba); 2019 2020 spin_unlock_irq(&phba->hbalock); 2021 2022 return count; 2023 } 2024 2025 static struct bin_attribute sysfs_mbox_attr = { 2026 .attr = { 2027 .name = "mbox", 2028 .mode = S_IRUSR | S_IWUSR, 2029 }, 2030 .size = MAILBOX_CMD_SIZE, 2031 .read = sysfs_mbox_read, 2032 .write = sysfs_mbox_write, 2033 }; 2034 2035 int 2036 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport) 2037 { 2038 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2039 int error; 2040 2041 error = sysfs_create_bin_file(&shost->shost_classdev.kobj, 2042 &sysfs_ctlreg_attr); 2043 if (error) 2044 goto out; 2045 2046 error = sysfs_create_bin_file(&shost->shost_classdev.kobj, 2047 &sysfs_mbox_attr); 2048 if (error) 2049 goto out_remove_ctlreg_attr; 2050 2051 return 0; 2052 out_remove_ctlreg_attr: 2053 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr); 2054 out: 2055 return error; 2056 } 2057 2058 void 2059 lpfc_free_sysfs_attr(struct lpfc_vport *vport) 2060 { 2061 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2062 2063 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_mbox_attr); 2064 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr); 2065 } 2066 2067 2068 /* 2069 * Dynamic FC Host Attributes Support 2070 */ 2071 2072 static void 2073 lpfc_get_host_port_id(struct Scsi_Host *shost) 2074 { 2075 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2076 2077 /* note: fc_myDID already in cpu endianness */ 2078 fc_host_port_id(shost) = vport->fc_myDID; 2079 } 2080 2081 static void 2082 lpfc_get_host_port_type(struct Scsi_Host *shost) 2083 { 2084 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2085 struct lpfc_hba *phba = vport->phba; 2086 2087 spin_lock_irq(shost->host_lock); 2088 2089 if (vport->port_type == LPFC_NPIV_PORT) { 2090 fc_host_port_type(shost) = FC_PORTTYPE_NPIV; 2091 } else if (lpfc_is_link_up(phba)) { 2092 if (phba->fc_topology == TOPOLOGY_LOOP) { 2093 if (vport->fc_flag & FC_PUBLIC_LOOP) 2094 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT; 2095 else 2096 fc_host_port_type(shost) = FC_PORTTYPE_LPORT; 2097 } else { 2098 if (vport->fc_flag & FC_FABRIC) 2099 fc_host_port_type(shost) = FC_PORTTYPE_NPORT; 2100 else 2101 fc_host_port_type(shost) = FC_PORTTYPE_PTP; 2102 } 2103 } else 2104 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN; 2105 2106 spin_unlock_irq(shost->host_lock); 2107 } 2108 2109 static void 2110 lpfc_get_host_port_state(struct Scsi_Host *shost) 2111 { 2112 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2113 struct lpfc_hba *phba = vport->phba; 2114 2115 spin_lock_irq(shost->host_lock); 2116 2117 if (vport->fc_flag & FC_OFFLINE_MODE) 2118 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 2119 else { 2120 switch (phba->link_state) { 2121 case LPFC_LINK_UNKNOWN: 2122 case LPFC_LINK_DOWN: 2123 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 2124 break; 2125 case LPFC_LINK_UP: 2126 case LPFC_CLEAR_LA: 2127 case LPFC_HBA_READY: 2128 /* Links up, beyond this port_type reports state */ 2129 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 2130 break; 2131 case LPFC_HBA_ERROR: 2132 fc_host_port_state(shost) = FC_PORTSTATE_ERROR; 2133 break; 2134 default: 2135 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 2136 break; 2137 } 2138 } 2139 2140 spin_unlock_irq(shost->host_lock); 2141 } 2142 2143 static void 2144 lpfc_get_host_speed(struct Scsi_Host *shost) 2145 { 2146 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2147 struct lpfc_hba *phba = vport->phba; 2148 2149 spin_lock_irq(shost->host_lock); 2150 2151 if (lpfc_is_link_up(phba)) { 2152 switch(phba->fc_linkspeed) { 2153 case LA_1GHZ_LINK: 2154 fc_host_speed(shost) = FC_PORTSPEED_1GBIT; 2155 break; 2156 case LA_2GHZ_LINK: 2157 fc_host_speed(shost) = FC_PORTSPEED_2GBIT; 2158 break; 2159 case LA_4GHZ_LINK: 2160 fc_host_speed(shost) = FC_PORTSPEED_4GBIT; 2161 break; 2162 case LA_8GHZ_LINK: 2163 fc_host_speed(shost) = FC_PORTSPEED_8GBIT; 2164 break; 2165 default: 2166 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 2167 break; 2168 } 2169 } else 2170 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 2171 2172 spin_unlock_irq(shost->host_lock); 2173 } 2174 2175 static void 2176 lpfc_get_host_fabric_name (struct Scsi_Host *shost) 2177 { 2178 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2179 struct lpfc_hba *phba = vport->phba; 2180 u64 node_name; 2181 2182 spin_lock_irq(shost->host_lock); 2183 2184 if ((vport->fc_flag & FC_FABRIC) || 2185 ((phba->fc_topology == TOPOLOGY_LOOP) && 2186 (vport->fc_flag & FC_PUBLIC_LOOP))) 2187 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn); 2188 else 2189 /* fabric is local port if there is no F/FL_Port */ 2190 node_name = 0; 2191 2192 spin_unlock_irq(shost->host_lock); 2193 2194 fc_host_fabric_name(shost) = node_name; 2195 } 2196 2197 static struct fc_host_statistics * 2198 lpfc_get_stats(struct Scsi_Host *shost) 2199 { 2200 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2201 struct lpfc_hba *phba = vport->phba; 2202 struct lpfc_sli *psli = &phba->sli; 2203 struct fc_host_statistics *hs = &phba->link_stats; 2204 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets; 2205 LPFC_MBOXQ_t *pmboxq; 2206 MAILBOX_t *pmb; 2207 unsigned long seconds; 2208 int rc = 0; 2209 2210 /* 2211 * prevent udev from issuing mailbox commands until the port is 2212 * configured. 2213 */ 2214 if (phba->link_state < LPFC_LINK_DOWN || 2215 !phba->mbox_mem_pool || 2216 (phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0) 2217 return NULL; 2218 2219 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 2220 return NULL; 2221 2222 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2223 if (!pmboxq) 2224 return NULL; 2225 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 2226 2227 pmb = &pmboxq->mb; 2228 pmb->mbxCommand = MBX_READ_STATUS; 2229 pmb->mbxOwner = OWN_HOST; 2230 pmboxq->context1 = NULL; 2231 pmboxq->vport = vport; 2232 2233 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2234 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2235 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2236 else 2237 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2238 2239 if (rc != MBX_SUCCESS) { 2240 if (rc != MBX_TIMEOUT) 2241 mempool_free(pmboxq, phba->mbox_mem_pool); 2242 return NULL; 2243 } 2244 2245 memset(hs, 0, sizeof (struct fc_host_statistics)); 2246 2247 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt; 2248 hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256); 2249 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt; 2250 hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256); 2251 2252 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t)); 2253 pmb->mbxCommand = MBX_READ_LNK_STAT; 2254 pmb->mbxOwner = OWN_HOST; 2255 pmboxq->context1 = NULL; 2256 pmboxq->vport = vport; 2257 2258 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2259 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2260 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2261 else 2262 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2263 2264 if (rc != MBX_SUCCESS) { 2265 if (rc != MBX_TIMEOUT) 2266 mempool_free(pmboxq, phba->mbox_mem_pool); 2267 return NULL; 2268 } 2269 2270 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 2271 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 2272 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 2273 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 2274 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 2275 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 2276 hs->error_frames = pmb->un.varRdLnk.crcCnt; 2277 2278 hs->link_failure_count -= lso->link_failure_count; 2279 hs->loss_of_sync_count -= lso->loss_of_sync_count; 2280 hs->loss_of_signal_count -= lso->loss_of_signal_count; 2281 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count; 2282 hs->invalid_tx_word_count -= lso->invalid_tx_word_count; 2283 hs->invalid_crc_count -= lso->invalid_crc_count; 2284 hs->error_frames -= lso->error_frames; 2285 2286 if (phba->fc_topology == TOPOLOGY_LOOP) { 2287 hs->lip_count = (phba->fc_eventTag >> 1); 2288 hs->lip_count -= lso->link_events; 2289 hs->nos_count = -1; 2290 } else { 2291 hs->lip_count = -1; 2292 hs->nos_count = (phba->fc_eventTag >> 1); 2293 hs->nos_count -= lso->link_events; 2294 } 2295 2296 hs->dumped_frames = -1; 2297 2298 seconds = get_seconds(); 2299 if (seconds < psli->stats_start) 2300 hs->seconds_since_last_reset = seconds + 2301 ((unsigned long)-1 - psli->stats_start); 2302 else 2303 hs->seconds_since_last_reset = seconds - psli->stats_start; 2304 2305 mempool_free(pmboxq, phba->mbox_mem_pool); 2306 2307 return hs; 2308 } 2309 2310 static void 2311 lpfc_reset_stats(struct Scsi_Host *shost) 2312 { 2313 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2314 struct lpfc_hba *phba = vport->phba; 2315 struct lpfc_sli *psli = &phba->sli; 2316 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets; 2317 LPFC_MBOXQ_t *pmboxq; 2318 MAILBOX_t *pmb; 2319 int rc = 0; 2320 2321 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) 2322 return; 2323 2324 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2325 if (!pmboxq) 2326 return; 2327 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 2328 2329 pmb = &pmboxq->mb; 2330 pmb->mbxCommand = MBX_READ_STATUS; 2331 pmb->mbxOwner = OWN_HOST; 2332 pmb->un.varWords[0] = 0x1; /* reset request */ 2333 pmboxq->context1 = NULL; 2334 pmboxq->vport = vport; 2335 2336 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2337 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2338 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2339 else 2340 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2341 2342 if (rc != MBX_SUCCESS) { 2343 if (rc != MBX_TIMEOUT) 2344 mempool_free(pmboxq, phba->mbox_mem_pool); 2345 return; 2346 } 2347 2348 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); 2349 pmb->mbxCommand = MBX_READ_LNK_STAT; 2350 pmb->mbxOwner = OWN_HOST; 2351 pmboxq->context1 = NULL; 2352 pmboxq->vport = vport; 2353 2354 if ((vport->fc_flag & FC_OFFLINE_MODE) || 2355 (!(psli->sli_flag & LPFC_SLI2_ACTIVE))) 2356 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); 2357 else 2358 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); 2359 2360 if (rc != MBX_SUCCESS) { 2361 if (rc != MBX_TIMEOUT) 2362 mempool_free( pmboxq, phba->mbox_mem_pool); 2363 return; 2364 } 2365 2366 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; 2367 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt; 2368 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt; 2369 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt; 2370 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord; 2371 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt; 2372 lso->error_frames = pmb->un.varRdLnk.crcCnt; 2373 lso->link_events = (phba->fc_eventTag >> 1); 2374 2375 psli->stats_start = get_seconds(); 2376 2377 mempool_free(pmboxq, phba->mbox_mem_pool); 2378 2379 return; 2380 } 2381 2382 /* 2383 * The LPFC driver treats linkdown handling as target loss events so there 2384 * are no sysfs handlers for link_down_tmo. 2385 */ 2386 2387 static struct lpfc_nodelist * 2388 lpfc_get_node_by_target(struct scsi_target *starget) 2389 { 2390 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2391 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2392 struct lpfc_nodelist *ndlp; 2393 2394 spin_lock_irq(shost->host_lock); 2395 /* Search for this, mapped, target ID */ 2396 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 2397 if (NLP_CHK_NODE_ACT(ndlp) && 2398 ndlp->nlp_state == NLP_STE_MAPPED_NODE && 2399 starget->id == ndlp->nlp_sid) { 2400 spin_unlock_irq(shost->host_lock); 2401 return ndlp; 2402 } 2403 } 2404 spin_unlock_irq(shost->host_lock); 2405 return NULL; 2406 } 2407 2408 static void 2409 lpfc_get_starget_port_id(struct scsi_target *starget) 2410 { 2411 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 2412 2413 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1; 2414 } 2415 2416 static void 2417 lpfc_get_starget_node_name(struct scsi_target *starget) 2418 { 2419 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 2420 2421 fc_starget_node_name(starget) = 2422 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0; 2423 } 2424 2425 static void 2426 lpfc_get_starget_port_name(struct scsi_target *starget) 2427 { 2428 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget); 2429 2430 fc_starget_port_name(starget) = 2431 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0; 2432 } 2433 2434 static void 2435 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 2436 { 2437 if (timeout) 2438 rport->dev_loss_tmo = timeout; 2439 else 2440 rport->dev_loss_tmo = 1; 2441 } 2442 2443 2444 #define lpfc_rport_show_function(field, format_string, sz, cast) \ 2445 static ssize_t \ 2446 lpfc_show_rport_##field (struct class_device *cdev, char *buf) \ 2447 { \ 2448 struct fc_rport *rport = transport_class_to_rport(cdev); \ 2449 struct lpfc_rport_data *rdata = rport->hostdata; \ 2450 return snprintf(buf, sz, format_string, \ 2451 (rdata->target) ? cast rdata->target->field : 0); \ 2452 } 2453 2454 #define lpfc_rport_rd_attr(field, format_string, sz) \ 2455 lpfc_rport_show_function(field, format_string, sz, ) \ 2456 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL) 2457 2458 2459 struct fc_function_template lpfc_transport_functions = { 2460 /* fixed attributes the driver supports */ 2461 .show_host_node_name = 1, 2462 .show_host_port_name = 1, 2463 .show_host_supported_classes = 1, 2464 .show_host_supported_fc4s = 1, 2465 .show_host_supported_speeds = 1, 2466 .show_host_maxframe_size = 1, 2467 2468 /* dynamic attributes the driver supports */ 2469 .get_host_port_id = lpfc_get_host_port_id, 2470 .show_host_port_id = 1, 2471 2472 .get_host_port_type = lpfc_get_host_port_type, 2473 .show_host_port_type = 1, 2474 2475 .get_host_port_state = lpfc_get_host_port_state, 2476 .show_host_port_state = 1, 2477 2478 /* active_fc4s is shown but doesn't change (thus no get function) */ 2479 .show_host_active_fc4s = 1, 2480 2481 .get_host_speed = lpfc_get_host_speed, 2482 .show_host_speed = 1, 2483 2484 .get_host_fabric_name = lpfc_get_host_fabric_name, 2485 .show_host_fabric_name = 1, 2486 2487 /* 2488 * The LPFC driver treats linkdown handling as target loss events 2489 * so there are no sysfs handlers for link_down_tmo. 2490 */ 2491 2492 .get_fc_host_stats = lpfc_get_stats, 2493 .reset_fc_host_stats = lpfc_reset_stats, 2494 2495 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 2496 .show_rport_maxframe_size = 1, 2497 .show_rport_supported_classes = 1, 2498 2499 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 2500 .show_rport_dev_loss_tmo = 1, 2501 2502 .get_starget_port_id = lpfc_get_starget_port_id, 2503 .show_starget_port_id = 1, 2504 2505 .get_starget_node_name = lpfc_get_starget_node_name, 2506 .show_starget_node_name = 1, 2507 2508 .get_starget_port_name = lpfc_get_starget_port_name, 2509 .show_starget_port_name = 1, 2510 2511 .issue_fc_host_lip = lpfc_issue_lip, 2512 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 2513 .terminate_rport_io = lpfc_terminate_rport_io, 2514 2515 .dd_fcvport_size = sizeof(struct lpfc_vport *), 2516 }; 2517 2518 struct fc_function_template lpfc_vport_transport_functions = { 2519 /* fixed attributes the driver supports */ 2520 .show_host_node_name = 1, 2521 .show_host_port_name = 1, 2522 .show_host_supported_classes = 1, 2523 .show_host_supported_fc4s = 1, 2524 .show_host_supported_speeds = 1, 2525 .show_host_maxframe_size = 1, 2526 2527 /* dynamic attributes the driver supports */ 2528 .get_host_port_id = lpfc_get_host_port_id, 2529 .show_host_port_id = 1, 2530 2531 .get_host_port_type = lpfc_get_host_port_type, 2532 .show_host_port_type = 1, 2533 2534 .get_host_port_state = lpfc_get_host_port_state, 2535 .show_host_port_state = 1, 2536 2537 /* active_fc4s is shown but doesn't change (thus no get function) */ 2538 .show_host_active_fc4s = 1, 2539 2540 .get_host_speed = lpfc_get_host_speed, 2541 .show_host_speed = 1, 2542 2543 .get_host_fabric_name = lpfc_get_host_fabric_name, 2544 .show_host_fabric_name = 1, 2545 2546 /* 2547 * The LPFC driver treats linkdown handling as target loss events 2548 * so there are no sysfs handlers for link_down_tmo. 2549 */ 2550 2551 .get_fc_host_stats = lpfc_get_stats, 2552 .reset_fc_host_stats = lpfc_reset_stats, 2553 2554 .dd_fcrport_size = sizeof(struct lpfc_rport_data), 2555 .show_rport_maxframe_size = 1, 2556 .show_rport_supported_classes = 1, 2557 2558 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo, 2559 .show_rport_dev_loss_tmo = 1, 2560 2561 .get_starget_port_id = lpfc_get_starget_port_id, 2562 .show_starget_port_id = 1, 2563 2564 .get_starget_node_name = lpfc_get_starget_node_name, 2565 .show_starget_node_name = 1, 2566 2567 .get_starget_port_name = lpfc_get_starget_port_name, 2568 .show_starget_port_name = 1, 2569 2570 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk, 2571 .terminate_rport_io = lpfc_terminate_rport_io, 2572 2573 .vport_disable = lpfc_vport_disable, 2574 }; 2575 2576 void 2577 lpfc_get_cfgparam(struct lpfc_hba *phba) 2578 { 2579 lpfc_cr_delay_init(phba, lpfc_cr_delay); 2580 lpfc_cr_count_init(phba, lpfc_cr_count); 2581 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support); 2582 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl); 2583 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type); 2584 lpfc_ack0_init(phba, lpfc_ack0); 2585 lpfc_topology_init(phba, lpfc_topology); 2586 lpfc_link_speed_init(phba, lpfc_link_speed); 2587 lpfc_poll_tmo_init(phba, lpfc_poll_tmo); 2588 lpfc_enable_npiv_init(phba, lpfc_enable_npiv); 2589 lpfc_use_msi_init(phba, lpfc_use_msi); 2590 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset); 2591 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat); 2592 phba->cfg_poll = lpfc_poll; 2593 phba->cfg_soft_wwnn = 0L; 2594 phba->cfg_soft_wwpn = 0L; 2595 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt); 2596 /* Also reinitialize the host templates with new values. */ 2597 lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt; 2598 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt; 2599 /* 2600 * Since the sg_tablesize is module parameter, the sg_dma_buf_size 2601 * used to create the sg_dma_buf_pool must be dynamically calculated. 2602 * 2 segments are added since the IOCB needs a command and response bde. 2603 */ 2604 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) + 2605 sizeof(struct fcp_rsp) + 2606 ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64)); 2607 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth); 2608 return; 2609 } 2610 2611 void 2612 lpfc_get_vport_cfgparam(struct lpfc_vport *vport) 2613 { 2614 lpfc_log_verbose_init(vport, lpfc_log_verbose); 2615 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth); 2616 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo); 2617 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo); 2618 lpfc_peer_port_login_init(vport, lpfc_peer_port_login); 2619 lpfc_restrict_login_init(vport, lpfc_restrict_login); 2620 lpfc_fcp_class_init(vport, lpfc_fcp_class); 2621 lpfc_use_adisc_init(vport, lpfc_use_adisc); 2622 lpfc_fdmi_on_init(vport, lpfc_fdmi_on); 2623 lpfc_discovery_threads_init(vport, lpfc_discovery_threads); 2624 lpfc_max_luns_init(vport, lpfc_max_luns); 2625 lpfc_scan_down_init(vport, lpfc_scan_down); 2626 lpfc_enable_da_id_init(vport, lpfc_enable_da_id); 2627 return; 2628 } 2629