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