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