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