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