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