?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: add PAGE_KERNEL_EXEC_NOCACHE
[wrt350n-kernel.git] / drivers / scsi / lpfc / lpfc_attr.c
blob4bae4a2ed2f1e9218b627f279d513a847b5ce931
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 (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 # Value range is [0,1]. Default value is 0.
1596 */
1597 LPFC_ATTR_R(use_msi, 0, 0, 1, "Use Message Signaled Interrupts, if possible");
1598
1599 /*
1600 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
1601 # 0 = HBA resets disabled
1602 # 1 = HBA resets enabled (default)
1603 # Value range is [0,1]. Default value is 1.
1604 */
1605 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
1606
1607 /*
1608 # lpfc_enable_hba_heartbeat: Enable HBA heartbeat timer..
1609 # 0 = HBA Heartbeat disabled
1610 # 1 = HBA Heartbeat enabled (default)
1611 # Value range is [0,1]. Default value is 1.
1612 */
1613 LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat.");
1614
1615 /*
1616 * lpfc_sg_seg_cnt: Initial Maximum DMA Segment Count
1617 * This value can be set to values between 64 and 256. The default value is
1618 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
1619 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
1620 */
1621 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
1622 LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
1623
1624 struct class_device_attribute *lpfc_hba_attrs[] = {
1625 &class_device_attr_info,
1626 &class_device_attr_serialnum,
1627 &class_device_attr_modeldesc,
1628 &class_device_attr_modelname,
1629 &class_device_attr_programtype,
1630 &class_device_attr_portnum,
1631 &class_device_attr_fwrev,
1632 &class_device_attr_hdw,
1633 &class_device_attr_option_rom_version,
1634 &class_device_attr_state,
1635 &class_device_attr_num_discovered_ports,
1636 &class_device_attr_lpfc_drvr_version,
1637 &class_device_attr_lpfc_temp_sensor,
1638 &class_device_attr_lpfc_log_verbose,
1639 &class_device_attr_lpfc_lun_queue_depth,
1640 &class_device_attr_lpfc_hba_queue_depth,
1641 &class_device_attr_lpfc_peer_port_login,
1642 &class_device_attr_lpfc_nodev_tmo,
1643 &class_device_attr_lpfc_devloss_tmo,
1644 &class_device_attr_lpfc_fcp_class,
1645 &class_device_attr_lpfc_use_adisc,
1646 &class_device_attr_lpfc_ack0,
1647 &class_device_attr_lpfc_topology,
1648 &class_device_attr_lpfc_scan_down,
1649 &class_device_attr_lpfc_link_speed,
1650 &class_device_attr_lpfc_cr_delay,
1651 &class_device_attr_lpfc_cr_count,
1652 &class_device_attr_lpfc_multi_ring_support,
1653 &class_device_attr_lpfc_multi_ring_rctl,
1654 &class_device_attr_lpfc_multi_ring_type,
1655 &class_device_attr_lpfc_fdmi_on,
1656 &class_device_attr_lpfc_max_luns,
1657 &class_device_attr_lpfc_enable_npiv,
1658 &class_device_attr_nport_evt_cnt,
1659 &class_device_attr_board_mode,
1660 &class_device_attr_max_vpi,
1661 &class_device_attr_used_vpi,
1662 &class_device_attr_max_rpi,
1663 &class_device_attr_used_rpi,
1664 &class_device_attr_max_xri,
1665 &class_device_attr_used_xri,
1666 &class_device_attr_npiv_info,
1667 &class_device_attr_issue_reset,
1668 &class_device_attr_lpfc_poll,
1669 &class_device_attr_lpfc_poll_tmo,
1670 &class_device_attr_lpfc_use_msi,
1671 &class_device_attr_lpfc_soft_wwnn,
1672 &class_device_attr_lpfc_soft_wwpn,
1673 &class_device_attr_lpfc_soft_wwn_enable,
1674 &class_device_attr_lpfc_enable_hba_reset,
1675 &class_device_attr_lpfc_enable_hba_heartbeat,
1676 &class_device_attr_lpfc_sg_seg_cnt,
1677 NULL,
1678 };
1679
1680 struct class_device_attribute *lpfc_vport_attrs[] = {
1681 &class_device_attr_info,
1682 &class_device_attr_state,
1683 &class_device_attr_num_discovered_ports,
1684 &class_device_attr_lpfc_drvr_version,
1685
1686 &class_device_attr_lpfc_log_verbose,
1687 &class_device_attr_lpfc_lun_queue_depth,
1688 &class_device_attr_lpfc_nodev_tmo,
1689 &class_device_attr_lpfc_devloss_tmo,
1690 &class_device_attr_lpfc_hba_queue_depth,
1691 &class_device_attr_lpfc_peer_port_login,
1692 &class_device_attr_lpfc_restrict_login,
1693 &class_device_attr_lpfc_fcp_class,
1694 &class_device_attr_lpfc_use_adisc,
1695 &class_device_attr_lpfc_fdmi_on,
1696 &class_device_attr_lpfc_max_luns,
1697 &class_device_attr_nport_evt_cnt,
1698 &class_device_attr_npiv_info,
1699 &class_device_attr_lpfc_enable_da_id,
1700 NULL,
1701 };
1702
1703 static ssize_t
1704 sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
1705 char *buf, loff_t off, size_t count)
1706 {
1707 size_t buf_off;
1708 struct class_device *cdev = container_of(kobj, struct class_device,
1709 kobj);
1710 struct Scsi_Host *shost = class_to_shost(cdev);
1711 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1712 struct lpfc_hba *phba = vport->phba;
1713
1714 if ((off + count) > FF_REG_AREA_SIZE)
1715 return -ERANGE;
1716
1717 if (count == 0) return 0;
1718
1719 if (off % 4 || count % 4 || (unsigned long)buf % 4)
1720 return -EINVAL;
1721
1722 if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
1723 return -EPERM;
1724 }
1725
1726 spin_lock_irq(&phba->hbalock);
1727 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t))
1728 writel(*((uint32_t *)(buf + buf_off)),
1729 phba->ctrl_regs_memmap_p + off + buf_off);
1730
1731 spin_unlock_irq(&phba->hbalock);
1732
1733 return count;
1734 }
1735
1736 static ssize_t
1737 sysfs_ctlreg_read(struct kobject *kobj, struct bin_attribute *bin_attr,
1738 char *buf, loff_t off, size_t count)
1739 {
1740 size_t buf_off;
1741 uint32_t * tmp_ptr;
1742 struct class_device *cdev = container_of(kobj, struct class_device,
1743 kobj);
1744 struct Scsi_Host *shost = class_to_shost(cdev);
1745 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1746 struct lpfc_hba *phba = vport->phba;
1747
1748 if (off > FF_REG_AREA_SIZE)
1749 return -ERANGE;
1750
1751 if ((off + count) > FF_REG_AREA_SIZE)
1752 count = FF_REG_AREA_SIZE - off;
1753
1754 if (count == 0) return 0;
1755
1756 if (off % 4 || count % 4 || (unsigned long)buf % 4)
1757 return -EINVAL;
1758
1759 spin_lock_irq(&phba->hbalock);
1760
1761 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
1762 tmp_ptr = (uint32_t *)(buf + buf_off);
1763 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
1764 }
1765
1766 spin_unlock_irq(&phba->hbalock);
1767
1768 return count;
1769 }
1770
1771 static struct bin_attribute sysfs_ctlreg_attr = {
1772 .attr = {
1773 .name = "ctlreg",
1774 .mode = S_IRUSR | S_IWUSR,
1775 },
1776 .size = 256,
1777 .read = sysfs_ctlreg_read,
1778 .write = sysfs_ctlreg_write,
1779 };
1780
1781
1782 static void
1783 sysfs_mbox_idle(struct lpfc_hba *phba)
1784 {
1785 phba->sysfs_mbox.state = SMBOX_IDLE;
1786 phba->sysfs_mbox.offset = 0;
1787
1788 if (phba->sysfs_mbox.mbox) {
1789 mempool_free(phba->sysfs_mbox.mbox,
1790 phba->mbox_mem_pool);
1791 phba->sysfs_mbox.mbox = NULL;
1792 }
1793 }
1794
1795 static ssize_t
1796 sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
1797 char *buf, loff_t off, size_t count)
1798 {
1799 struct class_device *cdev = container_of(kobj, struct class_device,
1800 kobj);
1801 struct Scsi_Host *shost = class_to_shost(cdev);
1802 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1803 struct lpfc_hba *phba = vport->phba;
1804 struct lpfcMboxq *mbox = NULL;
1805
1806 if ((count + off) > MAILBOX_CMD_SIZE)
1807 return -ERANGE;
1808
1809 if (off % 4 || count % 4 || (unsigned long)buf % 4)
1810 return -EINVAL;
1811
1812 if (count == 0)
1813 return 0;
1814
1815 if (off == 0) {
1816 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1817 if (!mbox)
1818 return -ENOMEM;
1819 memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
1820 }
1821
1822 spin_lock_irq(&phba->hbalock);
1823
1824 if (off == 0) {
1825 if (phba->sysfs_mbox.mbox)
1826 mempool_free(mbox, phba->mbox_mem_pool);
1827 else
1828 phba->sysfs_mbox.mbox = mbox;
1829 phba->sysfs_mbox.state = SMBOX_WRITING;
1830 } else {
1831 if (phba->sysfs_mbox.state != SMBOX_WRITING ||
1832 phba->sysfs_mbox.offset != off ||
1833 phba->sysfs_mbox.mbox == NULL) {
1834 sysfs_mbox_idle(phba);
1835 spin_unlock_irq(&phba->hbalock);
1836 return -EAGAIN;
1837 }
1838 }
1839
1840 memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off,
1841 buf, count);
1842
1843 phba->sysfs_mbox.offset = off + count;
1844
1845 spin_unlock_irq(&phba->hbalock);
1846
1847 return count;
1848 }
1849
1850 static ssize_t
1851 sysfs_mbox_read(struct kobject *kobj, struct bin_attribute *bin_attr,
1852 char *buf, loff_t off, size_t count)
1853 {
1854 struct class_device *cdev = container_of(kobj, struct class_device,
1855 kobj);
1856 struct Scsi_Host *shost = class_to_shost(cdev);
1857 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1858 struct lpfc_hba *phba = vport->phba;
1859 int rc;
1860
1861 if (off > MAILBOX_CMD_SIZE)
1862 return -ERANGE;
1863
1864 if ((count + off) > MAILBOX_CMD_SIZE)
1865 count = MAILBOX_CMD_SIZE - off;
1866
1867 if (off % 4 || count % 4 || (unsigned long)buf % 4)
1868 return -EINVAL;
1869
1870 if (off && count == 0)
1871 return 0;
1872
1873 spin_lock_irq(&phba->hbalock);
1874
1875 if (phba->over_temp_state == HBA_OVER_TEMP) {
1876 sysfs_mbox_idle(phba);
1877 spin_unlock_irq(&phba->hbalock);
1878 return -EACCES;
1879 }
1880
1881 if (off == 0 &&
1882 phba->sysfs_mbox.state == SMBOX_WRITING &&
1883 phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
1884
1885 switch (phba->sysfs_mbox.mbox->mb.mbxCommand) {
1886 /* Offline only */
1887 case MBX_INIT_LINK:
1888 case MBX_DOWN_LINK:
1889 case MBX_CONFIG_LINK:
1890 case MBX_CONFIG_RING:
1891 case MBX_RESET_RING:
1892 case MBX_UNREG_LOGIN:
1893 case MBX_CLEAR_LA:
1894 case MBX_DUMP_CONTEXT:
1895 case MBX_RUN_DIAGS:
1896 case MBX_RESTART:
1897 case MBX_SET_MASK:
1898 case MBX_SET_DEBUG:
1899 if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
1900 printk(KERN_WARNING "mbox_read:Command 0x%x "
1901 "is illegal in on-line state\n",
1902 phba->sysfs_mbox.mbox->mb.mbxCommand);
1903 sysfs_mbox_idle(phba);
1904 spin_unlock_irq(&phba->hbalock);
1905 return -EPERM;
1906 }
1907 case MBX_WRITE_NV:
1908 case MBX_WRITE_VPARMS:
1909 case MBX_LOAD_SM:
1910 case MBX_READ_NV:
1911 case MBX_READ_CONFIG:
1912 case MBX_READ_RCONFIG:
1913 case MBX_READ_STATUS:
1914 case MBX_READ_XRI:
1915 case MBX_READ_REV:
1916 case MBX_READ_LNK_STAT:
1917 case MBX_DUMP_MEMORY:
1918 case MBX_DOWN_LOAD:
1919 case MBX_UPDATE_CFG:
1920 case MBX_KILL_BOARD:
1921 case MBX_LOAD_AREA:
1922 case MBX_LOAD_EXP_ROM:
1923 case MBX_BEACON:
1924 case MBX_DEL_LD_ENTRY:
1925 case MBX_SET_VARIABLE:
1926 case MBX_WRITE_WWN:
1927 break;
1928 case MBX_READ_SPARM64:
1929 case MBX_READ_LA:
1930 case MBX_READ_LA64:
1931 case MBX_REG_LOGIN:
1932 case MBX_REG_LOGIN64:
1933 case MBX_CONFIG_PORT:
1934 case MBX_RUN_BIU_DIAG:
1935 printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
1936 phba->sysfs_mbox.mbox->mb.mbxCommand);
1937 sysfs_mbox_idle(phba);
1938 spin_unlock_irq(&phba->hbalock);
1939 return -EPERM;
1940 default:
1941 printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
1942 phba->sysfs_mbox.mbox->mb.mbxCommand);
1943 sysfs_mbox_idle(phba);
1944 spin_unlock_irq(&phba->hbalock);
1945 return -EPERM;
1946 }
1947
1948 /* If HBA encountered an error attention, allow only DUMP
1949 * mailbox command until the HBA is restarted.
1950 */
1951 if ((phba->pport->stopped) &&
1952 (phba->sysfs_mbox.mbox->mb.mbxCommand
1953 != MBX_DUMP_MEMORY)) {
1954 sysfs_mbox_idle(phba);
1955 spin_unlock_irq(&phba->hbalock);
1956 return -EPERM;
1957 }
1958
1959 phba->sysfs_mbox.mbox->vport = vport;
1960
1961 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
1962 sysfs_mbox_idle(phba);
1963 spin_unlock_irq(&phba->hbalock);
1964 return -EAGAIN;
1965 }
1966
1967 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
1968 (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE))){
1969
1970 spin_unlock_irq(&phba->hbalock);
1971 rc = lpfc_sli_issue_mbox (phba,
1972 phba->sysfs_mbox.mbox,
1973 MBX_POLL);
1974 spin_lock_irq(&phba->hbalock);
1975
1976 } else {
1977 spin_unlock_irq(&phba->hbalock);
1978 rc = lpfc_sli_issue_mbox_wait (phba,
1979 phba->sysfs_mbox.mbox,
1980 lpfc_mbox_tmo_val(phba,
1981 phba->sysfs_mbox.mbox->mb.mbxCommand) * HZ);
1982 spin_lock_irq(&phba->hbalock);
1983 }
1984
1985 if (rc != MBX_SUCCESS) {
1986 if (rc == MBX_TIMEOUT) {
1987 phba->sysfs_mbox.mbox = NULL;
1988 }
1989 sysfs_mbox_idle(phba);
1990 spin_unlock_irq(&phba->hbalock);
1991 return (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
1992 }
1993 phba->sysfs_mbox.state = SMBOX_READING;
1994 }
1995 else if (phba->sysfs_mbox.offset != off ||
1996 phba->sysfs_mbox.state != SMBOX_READING) {
1997 printk(KERN_WARNING "mbox_read: Bad State\n");
1998 sysfs_mbox_idle(phba);
1999 spin_unlock_irq(&phba->hbalock);
2000 return -EAGAIN;
2001 }
2002
2003 memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count);
2004
2005 phba->sysfs_mbox.offset = off + count;
2006
2007 if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
2008 sysfs_mbox_idle(phba);
2009
2010 spin_unlock_irq(&phba->hbalock);
2011
2012 return count;
2013 }
2014
2015 static struct bin_attribute sysfs_mbox_attr = {
2016 .attr = {
2017 .name = "mbox",
2018 .mode = S_IRUSR | S_IWUSR,
2019 },
2020 .size = MAILBOX_CMD_SIZE,
2021 .read = sysfs_mbox_read,
2022 .write = sysfs_mbox_write,
2023 };
2024
2025 int
2026 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
2027 {
2028 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2029 int error;
2030
2031 error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
2032 &sysfs_ctlreg_attr);
2033 if (error)
2034 goto out;
2035
2036 error = sysfs_create_bin_file(&shost->shost_classdev.kobj,
2037 &sysfs_mbox_attr);
2038 if (error)
2039 goto out_remove_ctlreg_attr;
2040
2041 return 0;
2042 out_remove_ctlreg_attr:
2043 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
2044 out:
2045 return error;
2046 }
2047
2048 void
2049 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
2050 {
2051 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2052
2053 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_mbox_attr);
2054 sysfs_remove_bin_file(&shost->shost_classdev.kobj, &sysfs_ctlreg_attr);
2055 }
2056
2057
2058 /*
2059 * Dynamic FC Host Attributes Support
2060 */
2061
2062 static void
2063 lpfc_get_host_port_id(struct Scsi_Host *shost)
2064 {
2065 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2066
2067 /* note: fc_myDID already in cpu endianness */
2068 fc_host_port_id(shost) = vport->fc_myDID;
2069 }
2070
2071 static void
2072 lpfc_get_host_port_type(struct Scsi_Host *shost)
2073 {
2074 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2075 struct lpfc_hba *phba = vport->phba;
2076
2077 spin_lock_irq(shost->host_lock);
2078
2079 if (vport->port_type == LPFC_NPIV_PORT) {
2080 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
2081 } else if (lpfc_is_link_up(phba)) {
2082 if (phba->fc_topology == TOPOLOGY_LOOP) {
2083 if (vport->fc_flag & FC_PUBLIC_LOOP)
2084 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
2085 else
2086 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
2087 } else {
2088 if (vport->fc_flag & FC_FABRIC)
2089 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
2090 else
2091 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
2092 }
2093 } else
2094 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
2095
2096 spin_unlock_irq(shost->host_lock);
2097 }
2098
2099 static void
2100 lpfc_get_host_port_state(struct Scsi_Host *shost)
2101 {
2102 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2103 struct lpfc_hba *phba = vport->phba;
2104
2105 spin_lock_irq(shost->host_lock);
2106
2107 if (vport->fc_flag & FC_OFFLINE_MODE)
2108 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
2109 else {
2110 switch (phba->link_state) {
2111 case LPFC_LINK_UNKNOWN:
2112 case LPFC_LINK_DOWN:
2113 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
2114 break;
2115 case LPFC_LINK_UP:
2116 case LPFC_CLEAR_LA:
2117 case LPFC_HBA_READY:
2118 /* Links up, beyond this port_type reports state */
2119 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
2120 break;
2121 case LPFC_HBA_ERROR:
2122 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
2123 break;
2124 default:
2125 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
2126 break;
2127 }
2128 }
2129
2130 spin_unlock_irq(shost->host_lock);
2131 }
2132
2133 static void
2134 lpfc_get_host_speed(struct Scsi_Host *shost)
2135 {
2136 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2137 struct lpfc_hba *phba = vport->phba;
2138
2139 spin_lock_irq(shost->host_lock);
2140
2141 if (lpfc_is_link_up(phba)) {
2142 switch(phba->fc_linkspeed) {
2143 case LA_1GHZ_LINK:
2144 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
2145 break;
2146 case LA_2GHZ_LINK:
2147 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
2148 break;
2149 case LA_4GHZ_LINK:
2150 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
2151 break;
2152 case LA_8GHZ_LINK:
2153 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
2154 break;
2155 default:
2156 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
2157 break;
2158 }
2159 } else
2160 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
2161
2162 spin_unlock_irq(shost->host_lock);
2163 }
2164
2165 static void
2166 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
2167 {
2168 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2169 struct lpfc_hba *phba = vport->phba;
2170 u64 node_name;
2171
2172 spin_lock_irq(shost->host_lock);
2173
2174 if ((vport->fc_flag & FC_FABRIC) ||
2175 ((phba->fc_topology == TOPOLOGY_LOOP) &&
2176 (vport->fc_flag & FC_PUBLIC_LOOP)))
2177 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
2178 else
2179 /* fabric is local port if there is no F/FL_Port */
2180 node_name = 0;
2181
2182 spin_unlock_irq(shost->host_lock);
2183
2184 fc_host_fabric_name(shost) = node_name;
2185 }
2186
2187 static struct fc_host_statistics *
2188 lpfc_get_stats(struct Scsi_Host *shost)
2189 {
2190 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2191 struct lpfc_hba *phba = vport->phba;
2192 struct lpfc_sli *psli = &phba->sli;
2193 struct fc_host_statistics *hs = &phba->link_stats;
2194 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
2195 LPFC_MBOXQ_t *pmboxq;
2196 MAILBOX_t *pmb;
2197 unsigned long seconds;
2198 int rc = 0;
2199
2200 /*
2201 * prevent udev from issuing mailbox commands until the port is
2202 * configured.
2203 */
2204 if (phba->link_state < LPFC_LINK_DOWN ||
2205 !phba->mbox_mem_pool ||
2206 (phba->sli.sli_flag & LPFC_SLI2_ACTIVE) == 0)
2207 return NULL;
2208
2209 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2210 return NULL;
2211
2212 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2213 if (!pmboxq)
2214 return NULL;
2215 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2216
2217 pmb = &pmboxq->mb;
2218 pmb->mbxCommand = MBX_READ_STATUS;
2219 pmb->mbxOwner = OWN_HOST;
2220 pmboxq->context1 = NULL;
2221 pmboxq->vport = vport;
2222
2223 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2224 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2225 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2226 else
2227 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2228
2229 if (rc != MBX_SUCCESS) {
2230 if (rc != MBX_TIMEOUT)
2231 mempool_free(pmboxq, phba->mbox_mem_pool);
2232 return NULL;
2233 }
2234
2235 memset(hs, 0, sizeof (struct fc_host_statistics));
2236
2237 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
2238 hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256);
2239 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
2240 hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256);
2241
2242 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2243 pmb->mbxCommand = MBX_READ_LNK_STAT;
2244 pmb->mbxOwner = OWN_HOST;
2245 pmboxq->context1 = NULL;
2246 pmboxq->vport = vport;
2247
2248 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2249 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2250 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2251 else
2252 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2253
2254 if (rc != MBX_SUCCESS) {
2255 if (rc != MBX_TIMEOUT)
2256 mempool_free(pmboxq, phba->mbox_mem_pool);
2257 return NULL;
2258 }
2259
2260 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
2261 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
2262 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
2263 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
2264 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
2265 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
2266 hs->error_frames = pmb->un.varRdLnk.crcCnt;
2267
2268 hs->link_failure_count -= lso->link_failure_count;
2269 hs->loss_of_sync_count -= lso->loss_of_sync_count;
2270 hs->loss_of_signal_count -= lso->loss_of_signal_count;
2271 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
2272 hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
2273 hs->invalid_crc_count -= lso->invalid_crc_count;
2274 hs->error_frames -= lso->error_frames;
2275
2276 if (phba->fc_topology == TOPOLOGY_LOOP) {
2277 hs->lip_count = (phba->fc_eventTag >> 1);
2278 hs->lip_count -= lso->link_events;
2279 hs->nos_count = -1;
2280 } else {
2281 hs->lip_count = -1;
2282 hs->nos_count = (phba->fc_eventTag >> 1);
2283 hs->nos_count -= lso->link_events;
2284 }
2285
2286 hs->dumped_frames = -1;
2287
2288 seconds = get_seconds();
2289 if (seconds < psli->stats_start)
2290 hs->seconds_since_last_reset = seconds +
2291 ((unsigned long)-1 - psli->stats_start);
2292 else
2293 hs->seconds_since_last_reset = seconds - psli->stats_start;
2294
2295 mempool_free(pmboxq, phba->mbox_mem_pool);
2296
2297 return hs;
2298 }
2299
2300 static void
2301 lpfc_reset_stats(struct Scsi_Host *shost)
2302 {
2303 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2304 struct lpfc_hba *phba = vport->phba;
2305 struct lpfc_sli *psli = &phba->sli;
2306 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
2307 LPFC_MBOXQ_t *pmboxq;
2308 MAILBOX_t *pmb;
2309 int rc = 0;
2310
2311 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2312 return;
2313
2314 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2315 if (!pmboxq)
2316 return;
2317 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
2318
2319 pmb = &pmboxq->mb;
2320 pmb->mbxCommand = MBX_READ_STATUS;
2321 pmb->mbxOwner = OWN_HOST;
2322 pmb->un.varWords[0] = 0x1; /* reset request */
2323 pmboxq->context1 = NULL;
2324 pmboxq->vport = vport;
2325
2326 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2327 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2328 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2329 else
2330 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2331
2332 if (rc != MBX_SUCCESS) {
2333 if (rc != MBX_TIMEOUT)
2334 mempool_free(pmboxq, phba->mbox_mem_pool);
2335 return;
2336 }
2337
2338 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
2339 pmb->mbxCommand = MBX_READ_LNK_STAT;
2340 pmb->mbxOwner = OWN_HOST;
2341 pmboxq->context1 = NULL;
2342 pmboxq->vport = vport;
2343
2344 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
2345 (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
2346 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2347 else
2348 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2349
2350 if (rc != MBX_SUCCESS) {
2351 if (rc != MBX_TIMEOUT)
2352 mempool_free( pmboxq, phba->mbox_mem_pool);
2353 return;
2354 }
2355
2356 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
2357 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
2358 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
2359 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
2360 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
2361 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
2362 lso->error_frames = pmb->un.varRdLnk.crcCnt;
2363 lso->link_events = (phba->fc_eventTag >> 1);
2364
2365 psli->stats_start = get_seconds();
2366
2367 mempool_free(pmboxq, phba->mbox_mem_pool);
2368
2369 return;
2370 }
2371
2372 /*
2373 * The LPFC driver treats linkdown handling as target loss events so there
2374 * are no sysfs handlers for link_down_tmo.
2375 */
2376
2377 static struct lpfc_nodelist *
2378 lpfc_get_node_by_target(struct scsi_target *starget)
2379 {
2380 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2381 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2382 struct lpfc_nodelist *ndlp;
2383
2384 spin_lock_irq(shost->host_lock);
2385 /* Search for this, mapped, target ID */
2386 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2387 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
2388 starget->id == ndlp->nlp_sid) {
2389 spin_unlock_irq(shost->host_lock);
2390 return ndlp;
2391 }
2392 }
2393 spin_unlock_irq(shost->host_lock);
2394 return NULL;
2395 }
2396
2397 static void
2398 lpfc_get_starget_port_id(struct scsi_target *starget)
2399 {
2400 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2401
2402 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
2403 }
2404
2405 static void
2406 lpfc_get_starget_node_name(struct scsi_target *starget)
2407 {
2408 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2409
2410 fc_starget_node_name(starget) =
2411 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
2412 }
2413
2414 static void
2415 lpfc_get_starget_port_name(struct scsi_target *starget)
2416 {
2417 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
2418
2419 fc_starget_port_name(starget) =
2420 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
2421 }
2422
2423 static void
2424 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
2425 {
2426 if (timeout)
2427 rport->dev_loss_tmo = timeout;
2428 else
2429 rport->dev_loss_tmo = 1;
2430 }
2431
2432
2433 #define lpfc_rport_show_function(field, format_string, sz, cast) \
2434 static ssize_t \
2435 lpfc_show_rport_##field (struct class_device *cdev, char *buf) \
2436 { \
2437 struct fc_rport *rport = transport_class_to_rport(cdev); \
2438 struct lpfc_rport_data *rdata = rport->hostdata; \
2439 return snprintf(buf, sz, format_string, \
2440 (rdata->target) ? cast rdata->target->field : 0); \
2441 }
2442
2443 #define lpfc_rport_rd_attr(field, format_string, sz) \
2444 lpfc_rport_show_function(field, format_string, sz, ) \
2445 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
2446
2447
2448 struct fc_function_template lpfc_transport_functions = {
2449 /* fixed attributes the driver supports */
2450 .show_host_node_name = 1,
2451 .show_host_port_name = 1,
2452 .show_host_supported_classes = 1,
2453 .show_host_supported_fc4s = 1,
2454 .show_host_supported_speeds = 1,
2455 .show_host_maxframe_size = 1,
2456
2457 /* dynamic attributes the driver supports */
2458 .get_host_port_id = lpfc_get_host_port_id,
2459 .show_host_port_id = 1,
2460
2461 .get_host_port_type = lpfc_get_host_port_type,
2462 .show_host_port_type = 1,
2463
2464 .get_host_port_state = lpfc_get_host_port_state,
2465 .show_host_port_state = 1,
2466
2467 /* active_fc4s is shown but doesn't change (thus no get function) */
2468 .show_host_active_fc4s = 1,
2469
2470 .get_host_speed = lpfc_get_host_speed,
2471 .show_host_speed = 1,
2472
2473 .get_host_fabric_name = lpfc_get_host_fabric_name,
2474 .show_host_fabric_name = 1,
2475
2476 /*
2477 * The LPFC driver treats linkdown handling as target loss events
2478 * so there are no sysfs handlers for link_down_tmo.
2479 */
2480
2481 .get_fc_host_stats = lpfc_get_stats,
2482 .reset_fc_host_stats = lpfc_reset_stats,
2483
2484 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
2485 .show_rport_maxframe_size = 1,
2486 .show_rport_supported_classes = 1,
2487
2488 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
2489 .show_rport_dev_loss_tmo = 1,
2490
2491 .get_starget_port_id = lpfc_get_starget_port_id,
2492 .show_starget_port_id = 1,
2493
2494 .get_starget_node_name = lpfc_get_starget_node_name,
2495 .show_starget_node_name = 1,
2496
2497 .get_starget_port_name = lpfc_get_starget_port_name,
2498 .show_starget_port_name = 1,
2499
2500 .issue_fc_host_lip = lpfc_issue_lip,
2501 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
2502 .terminate_rport_io = lpfc_terminate_rport_io,
2503
2504 .dd_fcvport_size = sizeof(struct lpfc_vport *),
2505 };
2506
2507 struct fc_function_template lpfc_vport_transport_functions = {
2508 /* fixed attributes the driver supports */
2509 .show_host_node_name = 1,
2510 .show_host_port_name = 1,
2511 .show_host_supported_classes = 1,
2512 .show_host_supported_fc4s = 1,
2513 .show_host_supported_speeds = 1,
2514 .show_host_maxframe_size = 1,
2515
2516 /* dynamic attributes the driver supports */
2517 .get_host_port_id = lpfc_get_host_port_id,
2518 .show_host_port_id = 1,
2519
2520 .get_host_port_type = lpfc_get_host_port_type,
2521 .show_host_port_type = 1,
2522
2523 .get_host_port_state = lpfc_get_host_port_state,
2524 .show_host_port_state = 1,
2525
2526 /* active_fc4s is shown but doesn't change (thus no get function) */
2527 .show_host_active_fc4s = 1,
2528
2529 .get_host_speed = lpfc_get_host_speed,
2530 .show_host_speed = 1,
2531
2532 .get_host_fabric_name = lpfc_get_host_fabric_name,
2533 .show_host_fabric_name = 1,
2534
2535 /*
2536 * The LPFC driver treats linkdown handling as target loss events
2537 * so there are no sysfs handlers for link_down_tmo.
2538 */
2539
2540 .get_fc_host_stats = lpfc_get_stats,
2541 .reset_fc_host_stats = lpfc_reset_stats,
2542
2543 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
2544 .show_rport_maxframe_size = 1,
2545 .show_rport_supported_classes = 1,
2546
2547 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
2548 .show_rport_dev_loss_tmo = 1,
2549
2550 .get_starget_port_id = lpfc_get_starget_port_id,
2551 .show_starget_port_id = 1,
2552
2553 .get_starget_node_name = lpfc_get_starget_node_name,
2554 .show_starget_node_name = 1,
2555
2556 .get_starget_port_name = lpfc_get_starget_port_name,
2557 .show_starget_port_name = 1,
2558
2559 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
2560 .terminate_rport_io = lpfc_terminate_rport_io,
2561
2562 .vport_disable = lpfc_vport_disable,
2563 };
2564
2565 void
2566 lpfc_get_cfgparam(struct lpfc_hba *phba)
2567 {
2568 lpfc_cr_delay_init(phba, lpfc_cr_delay);
2569 lpfc_cr_count_init(phba, lpfc_cr_count);
2570 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
2571 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
2572 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
2573 lpfc_ack0_init(phba, lpfc_ack0);
2574 lpfc_topology_init(phba, lpfc_topology);
2575 lpfc_link_speed_init(phba, lpfc_link_speed);
2576 lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
2577 lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
2578 lpfc_use_msi_init(phba, lpfc_use_msi);
2579 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
2580 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
2581 phba->cfg_poll = lpfc_poll;
2582 phba->cfg_soft_wwnn = 0L;
2583 phba->cfg_soft_wwpn = 0L;
2584 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
2585 /* Also reinitialize the host templates with new values. */
2586 lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2587 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2588 /*
2589 * Since the sg_tablesize is module parameter, the sg_dma_buf_size
2590 * used to create the sg_dma_buf_pool must be dynamically calculated.
2591 * 2 segments are added since the IOCB needs a command and response bde.
2592 */
2593 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
2594 sizeof(struct fcp_rsp) +
2595 ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
2596 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
2597 return;
2598 }
2599
2600 void
2601 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
2602 {
2603 lpfc_log_verbose_init(vport, lpfc_log_verbose);
2604 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
2605 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
2606 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
2607 lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
2608 lpfc_restrict_login_init(vport, lpfc_restrict_login);
2609 lpfc_fcp_class_init(vport, lpfc_fcp_class);
2610 lpfc_use_adisc_init(vport, lpfc_use_adisc);
2611 lpfc_fdmi_on_init(vport, lpfc_fdmi_on);
2612 lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
2613 lpfc_max_luns_init(vport, lpfc_max_luns);
2614 lpfc_scan_down_init(vport, lpfc_scan_down);
2615 lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
2616 return;
2617 }
WRT350N Kernel Patches