Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
[sfrench/cifs-2.6.git] / drivers / scsi / lpfc / lpfc_attr.c
1 /*******************************************************************
2  * This file is part of the Emulex Linux Device Driver for         *
3  * Fibre Channel Host Bus Adapters.                                *
4  * Copyright (C) 2004-2009 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 #include <linux/aer.h>
27 #include <linux/gfp.h>
28 #include <linux/kernel.h>
29
30 #include <scsi/scsi.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_host.h>
33 #include <scsi/scsi_tcq.h>
34 #include <scsi/scsi_transport_fc.h>
35 #include <scsi/fc/fc_fs.h>
36
37 #include "lpfc_hw4.h"
38 #include "lpfc_hw.h"
39 #include "lpfc_sli.h"
40 #include "lpfc_sli4.h"
41 #include "lpfc_nl.h"
42 #include "lpfc_disc.h"
43 #include "lpfc_scsi.h"
44 #include "lpfc.h"
45 #include "lpfc_logmsg.h"
46 #include "lpfc_version.h"
47 #include "lpfc_compat.h"
48 #include "lpfc_crtn.h"
49 #include "lpfc_vport.h"
50
51 #define LPFC_DEF_DEVLOSS_TMO 30
52 #define LPFC_MIN_DEVLOSS_TMO 1
53 #define LPFC_MAX_DEVLOSS_TMO 255
54
55 #define LPFC_MAX_LINK_SPEED 8
56 #define LPFC_LINK_SPEED_BITMAP 0x00000117
57 #define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8"
58
59 /**
60  * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
61  * @incr: integer to convert.
62  * @hdw: ascii string holding converted integer plus a string terminator.
63  *
64  * Description:
65  * JEDEC Joint Electron Device Engineering Council.
66  * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
67  * character string. The string is then terminated with a NULL in byte 9.
68  * Hex 0-9 becomes ascii '0' to '9'.
69  * Hex a-f becomes ascii '=' to 'B' capital B.
70  *
71  * Notes:
72  * Coded for 32 bit integers only.
73  **/
74 static void
75 lpfc_jedec_to_ascii(int incr, char hdw[])
76 {
77         int i, j;
78         for (i = 0; i < 8; i++) {
79                 j = (incr & 0xf);
80                 if (j <= 9)
81                         hdw[7 - i] = 0x30 +  j;
82                  else
83                         hdw[7 - i] = 0x61 + j - 10;
84                 incr = (incr >> 4);
85         }
86         hdw[8] = 0;
87         return;
88 }
89
90 /**
91  * lpfc_drvr_version_show - Return the Emulex driver string with version number
92  * @dev: class unused variable.
93  * @attr: device attribute, not used.
94  * @buf: on return contains the module description text.
95  *
96  * Returns: size of formatted string.
97  **/
98 static ssize_t
99 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
100                        char *buf)
101 {
102         return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
103 }
104
105 /**
106  * lpfc_enable_fip_show - Return the fip mode of the HBA
107  * @dev: class unused variable.
108  * @attr: device attribute, not used.
109  * @buf: on return contains the module description text.
110  *
111  * Returns: size of formatted string.
112  **/
113 static ssize_t
114 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
115                        char *buf)
116 {
117         struct Scsi_Host *shost = class_to_shost(dev);
118         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
119         struct lpfc_hba   *phba = vport->phba;
120
121         if (phba->hba_flag & HBA_FIP_SUPPORT)
122                 return snprintf(buf, PAGE_SIZE, "1\n");
123         else
124                 return snprintf(buf, PAGE_SIZE, "0\n");
125 }
126
127 static ssize_t
128 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
129                   char *buf)
130 {
131         struct Scsi_Host *shost = class_to_shost(dev);
132         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
133         struct lpfc_hba   *phba = vport->phba;
134
135         if (phba->cfg_enable_bg)
136                 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
137                         return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n");
138                 else
139                         return snprintf(buf, PAGE_SIZE,
140                                         "BlockGuard Not Supported\n");
141         else
142                         return snprintf(buf, PAGE_SIZE,
143                                         "BlockGuard Disabled\n");
144 }
145
146 static ssize_t
147 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
148                        char *buf)
149 {
150         struct Scsi_Host *shost = class_to_shost(dev);
151         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
152         struct lpfc_hba   *phba = vport->phba;
153
154         return snprintf(buf, PAGE_SIZE, "%llu\n",
155                         (unsigned long long)phba->bg_guard_err_cnt);
156 }
157
158 static ssize_t
159 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
160                         char *buf)
161 {
162         struct Scsi_Host *shost = class_to_shost(dev);
163         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
164         struct lpfc_hba   *phba = vport->phba;
165
166         return snprintf(buf, PAGE_SIZE, "%llu\n",
167                         (unsigned long long)phba->bg_apptag_err_cnt);
168 }
169
170 static ssize_t
171 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
172                         char *buf)
173 {
174         struct Scsi_Host *shost = class_to_shost(dev);
175         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
176         struct lpfc_hba   *phba = vport->phba;
177
178         return snprintf(buf, PAGE_SIZE, "%llu\n",
179                         (unsigned long long)phba->bg_reftag_err_cnt);
180 }
181
182 /**
183  * lpfc_info_show - Return some pci info about the host in ascii
184  * @dev: class converted to a Scsi_host structure.
185  * @attr: device attribute, not used.
186  * @buf: on return contains the formatted text from lpfc_info().
187  *
188  * Returns: size of formatted string.
189  **/
190 static ssize_t
191 lpfc_info_show(struct device *dev, struct device_attribute *attr,
192                char *buf)
193 {
194         struct Scsi_Host *host = class_to_shost(dev);
195
196         return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
197 }
198
199 /**
200  * lpfc_serialnum_show - Return the hba serial number in ascii
201  * @dev: class converted to a Scsi_host structure.
202  * @attr: device attribute, not used.
203  * @buf: on return contains the formatted text serial number.
204  *
205  * Returns: size of formatted string.
206  **/
207 static ssize_t
208 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
209                     char *buf)
210 {
211         struct Scsi_Host  *shost = class_to_shost(dev);
212         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
213         struct lpfc_hba   *phba = vport->phba;
214
215         return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
216 }
217
218 /**
219  * lpfc_temp_sensor_show - Return the temperature sensor level
220  * @dev: class converted to a Scsi_host structure.
221  * @attr: device attribute, not used.
222  * @buf: on return contains the formatted support level.
223  *
224  * Description:
225  * Returns a number indicating the temperature sensor level currently
226  * supported, zero or one in ascii.
227  *
228  * Returns: size of formatted string.
229  **/
230 static ssize_t
231 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
232                       char *buf)
233 {
234         struct Scsi_Host *shost = class_to_shost(dev);
235         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
236         struct lpfc_hba   *phba = vport->phba;
237         return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
238 }
239
240 /**
241  * lpfc_modeldesc_show - Return the model description of the hba
242  * @dev: class converted to a Scsi_host structure.
243  * @attr: device attribute, not used.
244  * @buf: on return contains the scsi vpd model description.
245  *
246  * Returns: size of formatted string.
247  **/
248 static ssize_t
249 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
250                     char *buf)
251 {
252         struct Scsi_Host  *shost = class_to_shost(dev);
253         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
254         struct lpfc_hba   *phba = vport->phba;
255
256         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
257 }
258
259 /**
260  * lpfc_modelname_show - Return the model name of the hba
261  * @dev: class converted to a Scsi_host structure.
262  * @attr: device attribute, not used.
263  * @buf: on return contains the scsi vpd model name.
264  *
265  * Returns: size of formatted string.
266  **/
267 static ssize_t
268 lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
269                     char *buf)
270 {
271         struct Scsi_Host  *shost = class_to_shost(dev);
272         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
273         struct lpfc_hba   *phba = vport->phba;
274
275         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
276 }
277
278 /**
279  * lpfc_programtype_show - Return the program type of the hba
280  * @dev: class converted to a Scsi_host structure.
281  * @attr: device attribute, not used.
282  * @buf: on return contains the scsi vpd program type.
283  *
284  * Returns: size of formatted string.
285  **/
286 static ssize_t
287 lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
288                       char *buf)
289 {
290         struct Scsi_Host  *shost = class_to_shost(dev);
291         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
292         struct lpfc_hba   *phba = vport->phba;
293
294         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
295 }
296
297 /**
298  * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
299  * @dev: class converted to a Scsi_host structure.
300  * @attr: device attribute, not used.
301  * @buf: on return contains the Menlo Maintenance sli flag.
302  *
303  * Returns: size of formatted string.
304  **/
305 static ssize_t
306 lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
307 {
308         struct Scsi_Host  *shost = class_to_shost(dev);
309         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
310         struct lpfc_hba   *phba = vport->phba;
311
312         return snprintf(buf, PAGE_SIZE, "%d\n",
313                 (phba->sli.sli_flag & LPFC_MENLO_MAINT));
314 }
315
316 /**
317  * lpfc_vportnum_show - Return the port number in ascii of the hba
318  * @dev: class converted to a Scsi_host structure.
319  * @attr: device attribute, not used.
320  * @buf: on return contains scsi vpd program type.
321  *
322  * Returns: size of formatted string.
323  **/
324 static ssize_t
325 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
326                    char *buf)
327 {
328         struct Scsi_Host  *shost = class_to_shost(dev);
329         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
330         struct lpfc_hba   *phba = vport->phba;
331
332         return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
333 }
334
335 /**
336  * lpfc_fwrev_show - Return the firmware rev running in the hba
337  * @dev: class converted to a Scsi_host structure.
338  * @attr: device attribute, not used.
339  * @buf: on return contains the scsi vpd program type.
340  *
341  * Returns: size of formatted string.
342  **/
343 static ssize_t
344 lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
345                 char *buf)
346 {
347         struct Scsi_Host  *shost = class_to_shost(dev);
348         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
349         struct lpfc_hba   *phba = vport->phba;
350         char fwrev[32];
351
352         lpfc_decode_firmware_rev(phba, fwrev, 1);
353         return snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", fwrev, phba->sli_rev);
354 }
355
356 /**
357  * lpfc_hdw_show - Return the jedec information about the hba
358  * @dev: class converted to a Scsi_host structure.
359  * @attr: device attribute, not used.
360  * @buf: on return contains the scsi vpd program type.
361  *
362  * Returns: size of formatted string.
363  **/
364 static ssize_t
365 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
366 {
367         char hdw[9];
368         struct Scsi_Host  *shost = class_to_shost(dev);
369         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
370         struct lpfc_hba   *phba = vport->phba;
371         lpfc_vpd_t *vp = &phba->vpd;
372
373         lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
374         return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
375 }
376
377 /**
378  * lpfc_option_rom_version_show - Return the adapter ROM FCode version
379  * @dev: class converted to a Scsi_host structure.
380  * @attr: device attribute, not used.
381  * @buf: on return contains the ROM and FCode ascii strings.
382  *
383  * Returns: size of formatted string.
384  **/
385 static ssize_t
386 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
387                              char *buf)
388 {
389         struct Scsi_Host  *shost = class_to_shost(dev);
390         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
391         struct lpfc_hba   *phba = vport->phba;
392
393         return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
394 }
395
396 /**
397  * lpfc_state_show - Return the link state of the port
398  * @dev: class converted to a Scsi_host structure.
399  * @attr: device attribute, not used.
400  * @buf: on return contains text describing the state of the link.
401  *
402  * Notes:
403  * The switch statement has no default so zero will be returned.
404  *
405  * Returns: size of formatted string.
406  **/
407 static ssize_t
408 lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
409                      char *buf)
410 {
411         struct Scsi_Host  *shost = class_to_shost(dev);
412         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
413         struct lpfc_hba   *phba = vport->phba;
414         int  len = 0;
415
416         switch (phba->link_state) {
417         case LPFC_LINK_UNKNOWN:
418         case LPFC_WARM_START:
419         case LPFC_INIT_START:
420         case LPFC_INIT_MBX_CMDS:
421         case LPFC_LINK_DOWN:
422         case LPFC_HBA_ERROR:
423                 if (phba->hba_flag & LINK_DISABLED)
424                         len += snprintf(buf + len, PAGE_SIZE-len,
425                                 "Link Down - User disabled\n");
426                 else
427                         len += snprintf(buf + len, PAGE_SIZE-len,
428                                 "Link Down\n");
429                 break;
430         case LPFC_LINK_UP:
431         case LPFC_CLEAR_LA:
432         case LPFC_HBA_READY:
433                 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
434
435                 switch (vport->port_state) {
436                 case LPFC_LOCAL_CFG_LINK:
437                         len += snprintf(buf + len, PAGE_SIZE-len,
438                                         "Configuring Link\n");
439                         break;
440                 case LPFC_FDISC:
441                 case LPFC_FLOGI:
442                 case LPFC_FABRIC_CFG_LINK:
443                 case LPFC_NS_REG:
444                 case LPFC_NS_QRY:
445                 case LPFC_BUILD_DISC_LIST:
446                 case LPFC_DISC_AUTH:
447                         len += snprintf(buf + len, PAGE_SIZE - len,
448                                         "Discovery\n");
449                         break;
450                 case LPFC_VPORT_READY:
451                         len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
452                         break;
453
454                 case LPFC_VPORT_FAILED:
455                         len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
456                         break;
457
458                 case LPFC_VPORT_UNKNOWN:
459                         len += snprintf(buf + len, PAGE_SIZE - len,
460                                         "Unknown\n");
461                         break;
462                 }
463                 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
464                         len += snprintf(buf + len, PAGE_SIZE-len,
465                                         "   Menlo Maint Mode\n");
466                 else if (phba->fc_topology == TOPOLOGY_LOOP) {
467                         if (vport->fc_flag & FC_PUBLIC_LOOP)
468                                 len += snprintf(buf + len, PAGE_SIZE-len,
469                                                 "   Public Loop\n");
470                         else
471                                 len += snprintf(buf + len, PAGE_SIZE-len,
472                                                 "   Private Loop\n");
473                 } else {
474                         if (vport->fc_flag & FC_FABRIC)
475                                 len += snprintf(buf + len, PAGE_SIZE-len,
476                                                 "   Fabric\n");
477                         else
478                                 len += snprintf(buf + len, PAGE_SIZE-len,
479                                                 "   Point-2-Point\n");
480                 }
481         }
482
483         return len;
484 }
485
486 /**
487  * lpfc_link_state_store - Transition the link_state on an HBA port
488  * @dev: class device that is converted into a Scsi_host.
489  * @attr: device attribute, not used.
490  * @buf: one or more lpfc_polling_flags values.
491  * @count: not used.
492  *
493  * Returns:
494  * -EINVAL if the buffer is not "up" or "down"
495  * return from link state change function if non-zero
496  * length of the buf on success
497  **/
498 static ssize_t
499 lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
500                 const char *buf, size_t count)
501 {
502         struct Scsi_Host  *shost = class_to_shost(dev);
503         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
504         struct lpfc_hba   *phba = vport->phba;
505
506         int status = -EINVAL;
507
508         if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
509                         (phba->link_state == LPFC_LINK_DOWN))
510                 status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
511         else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
512                         (phba->link_state >= LPFC_LINK_UP))
513                 status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
514
515         if (status == 0)
516                 return strlen(buf);
517         else
518                 return status;
519 }
520
521 /**
522  * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
523  * @dev: class device that is converted into a Scsi_host.
524  * @attr: device attribute, not used.
525  * @buf: on return contains the sum of fc mapped and unmapped.
526  *
527  * Description:
528  * Returns the ascii text number of the sum of the fc mapped and unmapped
529  * vport counts.
530  *
531  * Returns: size of formatted string.
532  **/
533 static ssize_t
534 lpfc_num_discovered_ports_show(struct device *dev,
535                                struct device_attribute *attr, char *buf)
536 {
537         struct Scsi_Host  *shost = class_to_shost(dev);
538         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
539
540         return snprintf(buf, PAGE_SIZE, "%d\n",
541                         vport->fc_map_cnt + vport->fc_unmap_cnt);
542 }
543
544 /**
545  * lpfc_issue_lip - Misnomer, name carried over from long ago
546  * @shost: Scsi_Host pointer.
547  *
548  * Description:
549  * Bring the link down gracefully then re-init the link. The firmware will
550  * re-init the fiber channel interface as required. Does not issue a LIP.
551  *
552  * Returns:
553  * -EPERM port offline or management commands are being blocked
554  * -ENOMEM cannot allocate memory for the mailbox command
555  * -EIO error sending the mailbox command
556  * zero for success
557  **/
558 static int
559 lpfc_issue_lip(struct Scsi_Host *shost)
560 {
561         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
562         struct lpfc_hba   *phba = vport->phba;
563         LPFC_MBOXQ_t *pmboxq;
564         int mbxstatus = MBXERR_ERROR;
565
566         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
567             (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
568                 return -EPERM;
569
570         pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
571
572         if (!pmboxq)
573                 return -ENOMEM;
574
575         memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
576         pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
577         pmboxq->u.mb.mbxOwner = OWN_HOST;
578
579         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
580
581         if ((mbxstatus == MBX_SUCCESS) &&
582             (pmboxq->u.mb.mbxStatus == 0 ||
583              pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
584                 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
585                 lpfc_init_link(phba, pmboxq, phba->cfg_topology,
586                                phba->cfg_link_speed);
587                 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
588                                                      phba->fc_ratov * 2);
589         }
590
591         lpfc_set_loopback_flag(phba);
592         if (mbxstatus != MBX_TIMEOUT)
593                 mempool_free(pmboxq, phba->mbox_mem_pool);
594
595         if (mbxstatus == MBXERR_ERROR)
596                 return -EIO;
597
598         return 0;
599 }
600
601 /**
602  * lpfc_do_offline - Issues a mailbox command to bring the link down
603  * @phba: lpfc_hba pointer.
604  * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
605  *
606  * Notes:
607  * Assumes any error from lpfc_do_offline() will be negative.
608  * Can wait up to 5 seconds for the port ring buffers count
609  * to reach zero, prints a warning if it is not zero and continues.
610  * lpfc_workq_post_event() returns a non-zero return code if call fails.
611  *
612  * Returns:
613  * -EIO error posting the event
614  * zero for success
615  **/
616 static int
617 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
618 {
619         struct completion online_compl;
620         struct lpfc_sli_ring *pring;
621         struct lpfc_sli *psli;
622         int status = 0;
623         int cnt = 0;
624         int i;
625
626         init_completion(&online_compl);
627         lpfc_workq_post_event(phba, &status, &online_compl,
628                               LPFC_EVT_OFFLINE_PREP);
629         wait_for_completion(&online_compl);
630
631         if (status != 0)
632                 return -EIO;
633
634         psli = &phba->sli;
635
636         /* Wait a little for things to settle down, but not
637          * long enough for dev loss timeout to expire.
638          */
639         for (i = 0; i < psli->num_rings; i++) {
640                 pring = &psli->ring[i];
641                 while (pring->txcmplq_cnt) {
642                         msleep(10);
643                         if (cnt++ > 500) {  /* 5 secs */
644                                 lpfc_printf_log(phba,
645                                         KERN_WARNING, LOG_INIT,
646                                         "0466 Outstanding IO when "
647                                         "bringing Adapter offline\n");
648                                 break;
649                         }
650                 }
651         }
652
653         init_completion(&online_compl);
654         lpfc_workq_post_event(phba, &status, &online_compl, type);
655         wait_for_completion(&online_compl);
656
657         if (status != 0)
658                 return -EIO;
659
660         return 0;
661 }
662
663 /**
664  * lpfc_selective_reset - Offline then onlines the port
665  * @phba: lpfc_hba pointer.
666  *
667  * Description:
668  * If the port is configured to allow a reset then the hba is brought
669  * offline then online.
670  *
671  * Notes:
672  * Assumes any error from lpfc_do_offline() will be negative.
673  *
674  * Returns:
675  * lpfc_do_offline() return code if not zero
676  * -EIO reset not configured or error posting the event
677  * zero for success
678  **/
679 static int
680 lpfc_selective_reset(struct lpfc_hba *phba)
681 {
682         struct completion online_compl;
683         int status = 0;
684
685         if (!phba->cfg_enable_hba_reset)
686                 return -EIO;
687
688         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
689
690         if (status != 0)
691                 return status;
692
693         init_completion(&online_compl);
694         lpfc_workq_post_event(phba, &status, &online_compl,
695                               LPFC_EVT_ONLINE);
696         wait_for_completion(&online_compl);
697
698         if (status != 0)
699                 return -EIO;
700
701         return 0;
702 }
703
704 /**
705  * lpfc_issue_reset - Selectively resets an adapter
706  * @dev: class device that is converted into a Scsi_host.
707  * @attr: device attribute, not used.
708  * @buf: containing the string "selective".
709  * @count: unused variable.
710  *
711  * Description:
712  * If the buf contains the string "selective" then lpfc_selective_reset()
713  * is called to perform the reset.
714  *
715  * Notes:
716  * Assumes any error from lpfc_selective_reset() will be negative.
717  * If lpfc_selective_reset() returns zero then the length of the buffer
718  * is returned which indicates success
719  *
720  * Returns:
721  * -EINVAL if the buffer does not contain the string "selective"
722  * length of buf if lpfc-selective_reset() if the call succeeds
723  * return value of lpfc_selective_reset() if the call fails
724 **/
725 static ssize_t
726 lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
727                  const char *buf, size_t count)
728 {
729         struct Scsi_Host  *shost = class_to_shost(dev);
730         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
731         struct lpfc_hba   *phba = vport->phba;
732
733         int status = -EINVAL;
734
735         if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
736                 status = lpfc_selective_reset(phba);
737
738         if (status == 0)
739                 return strlen(buf);
740         else
741                 return status;
742 }
743
744 /**
745  * lpfc_nport_evt_cnt_show - Return the number of nport events
746  * @dev: class device that is converted into a Scsi_host.
747  * @attr: device attribute, not used.
748  * @buf: on return contains the ascii number of nport events.
749  *
750  * Returns: size of formatted string.
751  **/
752 static ssize_t
753 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
754                         char *buf)
755 {
756         struct Scsi_Host  *shost = class_to_shost(dev);
757         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
758         struct lpfc_hba   *phba = vport->phba;
759
760         return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
761 }
762
763 /**
764  * lpfc_board_mode_show - Return the state of the board
765  * @dev: class device that is converted into a Scsi_host.
766  * @attr: device attribute, not used.
767  * @buf: on return contains the state of the adapter.
768  *
769  * Returns: size of formatted string.
770  **/
771 static ssize_t
772 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
773                      char *buf)
774 {
775         struct Scsi_Host  *shost = class_to_shost(dev);
776         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
777         struct lpfc_hba   *phba = vport->phba;
778         char  * state;
779
780         if (phba->link_state == LPFC_HBA_ERROR)
781                 state = "error";
782         else if (phba->link_state == LPFC_WARM_START)
783                 state = "warm start";
784         else if (phba->link_state == LPFC_INIT_START)
785                 state = "offline";
786         else
787                 state = "online";
788
789         return snprintf(buf, PAGE_SIZE, "%s\n", state);
790 }
791
792 /**
793  * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
794  * @dev: class device that is converted into a Scsi_host.
795  * @attr: device attribute, not used.
796  * @buf: containing one of the strings "online", "offline", "warm" or "error".
797  * @count: unused variable.
798  *
799  * Returns:
800  * -EACCES if enable hba reset not enabled
801  * -EINVAL if the buffer does not contain a valid string (see above)
802  * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
803  * buf length greater than zero indicates success
804  **/
805 static ssize_t
806 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
807                       const char *buf, size_t count)
808 {
809         struct Scsi_Host  *shost = class_to_shost(dev);
810         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
811         struct lpfc_hba   *phba = vport->phba;
812         struct completion online_compl;
813         int status=0;
814
815         if (!phba->cfg_enable_hba_reset)
816                 return -EACCES;
817         init_completion(&online_compl);
818
819         if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
820                 lpfc_workq_post_event(phba, &status, &online_compl,
821                                       LPFC_EVT_ONLINE);
822                 wait_for_completion(&online_compl);
823         } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
824                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
825         else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
826                 if (phba->sli_rev == LPFC_SLI_REV4)
827                         return -EINVAL;
828                 else
829                         status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
830         else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
831                 if (phba->sli_rev == LPFC_SLI_REV4)
832                         return -EINVAL;
833                 else
834                         status = lpfc_do_offline(phba, LPFC_EVT_KILL);
835         else
836                 return -EINVAL;
837
838         if (!status)
839                 return strlen(buf);
840         else
841                 return -EIO;
842 }
843
844 /**
845  * lpfc_get_hba_info - Return various bits of informaton about the adapter
846  * @phba: pointer to the adapter structure.
847  * @mxri: max xri count.
848  * @axri: available xri count.
849  * @mrpi: max rpi count.
850  * @arpi: available rpi count.
851  * @mvpi: max vpi count.
852  * @avpi: available vpi count.
853  *
854  * Description:
855  * If an integer pointer for an count is not null then the value for the
856  * count is returned.
857  *
858  * Returns:
859  * zero on error
860  * one for success
861  **/
862 static int
863 lpfc_get_hba_info(struct lpfc_hba *phba,
864                   uint32_t *mxri, uint32_t *axri,
865                   uint32_t *mrpi, uint32_t *arpi,
866                   uint32_t *mvpi, uint32_t *avpi)
867 {
868         struct lpfc_mbx_read_config *rd_config;
869         LPFC_MBOXQ_t *pmboxq;
870         MAILBOX_t *pmb;
871         int rc = 0;
872         uint32_t max_vpi;
873
874         /*
875          * prevent udev from issuing mailbox commands until the port is
876          * configured.
877          */
878         if (phba->link_state < LPFC_LINK_DOWN ||
879             !phba->mbox_mem_pool ||
880             (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
881                 return 0;
882
883         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
884                 return 0;
885
886         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
887         if (!pmboxq)
888                 return 0;
889         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
890
891         pmb = &pmboxq->u.mb;
892         pmb->mbxCommand = MBX_READ_CONFIG;
893         pmb->mbxOwner = OWN_HOST;
894         pmboxq->context1 = NULL;
895
896         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
897                 rc = MBX_NOT_FINISHED;
898         else
899                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
900
901         if (rc != MBX_SUCCESS) {
902                 if (rc != MBX_TIMEOUT)
903                         mempool_free(pmboxq, phba->mbox_mem_pool);
904                 return 0;
905         }
906
907         if (phba->sli_rev == LPFC_SLI_REV4) {
908                 rd_config = &pmboxq->u.mqe.un.rd_config;
909                 if (mrpi)
910                         *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
911                 if (arpi)
912                         *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
913                                         phba->sli4_hba.max_cfg_param.rpi_used;
914                 if (mxri)
915                         *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
916                 if (axri)
917                         *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
918                                         phba->sli4_hba.max_cfg_param.xri_used;
919
920                 /* Account for differences with SLI-3.  Get vpi count from
921                  * mailbox data and subtract one for max vpi value.
922                  */
923                 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
924                         (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
925
926                 if (mvpi)
927                         *mvpi = max_vpi;
928                 if (avpi)
929                         *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
930         } else {
931                 if (mrpi)
932                         *mrpi = pmb->un.varRdConfig.max_rpi;
933                 if (arpi)
934                         *arpi = pmb->un.varRdConfig.avail_rpi;
935                 if (mxri)
936                         *mxri = pmb->un.varRdConfig.max_xri;
937                 if (axri)
938                         *axri = pmb->un.varRdConfig.avail_xri;
939                 if (mvpi)
940                         *mvpi = pmb->un.varRdConfig.max_vpi;
941                 if (avpi)
942                         *avpi = pmb->un.varRdConfig.avail_vpi;
943         }
944
945         mempool_free(pmboxq, phba->mbox_mem_pool);
946         return 1;
947 }
948
949 /**
950  * lpfc_max_rpi_show - Return maximum rpi
951  * @dev: class device that is converted into a Scsi_host.
952  * @attr: device attribute, not used.
953  * @buf: on return contains the maximum rpi count in decimal or "Unknown".
954  *
955  * Description:
956  * Calls lpfc_get_hba_info() asking for just the mrpi count.
957  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
958  * to "Unknown" and the buffer length is returned, therefore the caller
959  * must check for "Unknown" in the buffer to detect a failure.
960  *
961  * Returns: size of formatted string.
962  **/
963 static ssize_t
964 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
965                   char *buf)
966 {
967         struct Scsi_Host  *shost = class_to_shost(dev);
968         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
969         struct lpfc_hba   *phba = vport->phba;
970         uint32_t cnt;
971
972         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
973                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
974         return snprintf(buf, PAGE_SIZE, "Unknown\n");
975 }
976
977 /**
978  * lpfc_used_rpi_show - Return maximum rpi minus available rpi
979  * @dev: class device that is converted into a Scsi_host.
980  * @attr: device attribute, not used.
981  * @buf: containing the used rpi count in decimal or "Unknown".
982  *
983  * Description:
984  * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
985  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
986  * to "Unknown" and the buffer length is returned, therefore the caller
987  * must check for "Unknown" in the buffer to detect a failure.
988  *
989  * Returns: size of formatted string.
990  **/
991 static ssize_t
992 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
993                    char *buf)
994 {
995         struct Scsi_Host  *shost = class_to_shost(dev);
996         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
997         struct lpfc_hba   *phba = vport->phba;
998         uint32_t cnt, acnt;
999
1000         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
1001                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1002         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1003 }
1004
1005 /**
1006  * lpfc_max_xri_show - Return maximum xri
1007  * @dev: class device that is converted into a Scsi_host.
1008  * @attr: device attribute, not used.
1009  * @buf: on return contains the maximum xri count in decimal or "Unknown".
1010  *
1011  * Description:
1012  * Calls lpfc_get_hba_info() asking for just the mrpi count.
1013  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1014  * to "Unknown" and the buffer length is returned, therefore the caller
1015  * must check for "Unknown" in the buffer to detect a failure.
1016  *
1017  * Returns: size of formatted string.
1018  **/
1019 static ssize_t
1020 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
1021                   char *buf)
1022 {
1023         struct Scsi_Host  *shost = class_to_shost(dev);
1024         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1025         struct lpfc_hba   *phba = vport->phba;
1026         uint32_t cnt;
1027
1028         if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
1029                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1030         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1031 }
1032
1033 /**
1034  * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1035  * @dev: class device that is converted into a Scsi_host.
1036  * @attr: device attribute, not used.
1037  * @buf: on return contains the used xri count in decimal or "Unknown".
1038  *
1039  * Description:
1040  * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
1041  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1042  * to "Unknown" and the buffer length is returned, therefore the caller
1043  * must check for "Unknown" in the buffer to detect a failure.
1044  *
1045  * Returns: size of formatted string.
1046  **/
1047 static ssize_t
1048 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
1049                    char *buf)
1050 {
1051         struct Scsi_Host  *shost = class_to_shost(dev);
1052         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1053         struct lpfc_hba   *phba = vport->phba;
1054         uint32_t cnt, acnt;
1055
1056         if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
1057                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1058         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1059 }
1060
1061 /**
1062  * lpfc_max_vpi_show - Return maximum vpi
1063  * @dev: class device that is converted into a Scsi_host.
1064  * @attr: device attribute, not used.
1065  * @buf: on return contains the maximum vpi count in decimal or "Unknown".
1066  *
1067  * Description:
1068  * Calls lpfc_get_hba_info() asking for just the mvpi count.
1069  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1070  * to "Unknown" and the buffer length is returned, therefore the caller
1071  * must check for "Unknown" in the buffer to detect a failure.
1072  *
1073  * Returns: size of formatted string.
1074  **/
1075 static ssize_t
1076 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
1077                   char *buf)
1078 {
1079         struct Scsi_Host  *shost = class_to_shost(dev);
1080         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1081         struct lpfc_hba   *phba = vport->phba;
1082         uint32_t cnt;
1083
1084         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
1085                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1086         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1087 }
1088
1089 /**
1090  * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1091  * @dev: class device that is converted into a Scsi_host.
1092  * @attr: device attribute, not used.
1093  * @buf: on return contains the used vpi count in decimal or "Unknown".
1094  *
1095  * Description:
1096  * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
1097  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1098  * to "Unknown" and the buffer length is returned, therefore the caller
1099  * must check for "Unknown" in the buffer to detect a failure.
1100  *
1101  * Returns: size of formatted string.
1102  **/
1103 static ssize_t
1104 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
1105                    char *buf)
1106 {
1107         struct Scsi_Host  *shost = class_to_shost(dev);
1108         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1109         struct lpfc_hba   *phba = vport->phba;
1110         uint32_t cnt, acnt;
1111
1112         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
1113                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1114         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1115 }
1116
1117 /**
1118  * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1119  * @dev: class device that is converted into a Scsi_host.
1120  * @attr: device attribute, not used.
1121  * @buf: text that must be interpreted to determine if npiv is supported.
1122  *
1123  * Description:
1124  * Buffer will contain text indicating npiv is not suppoerted on the port,
1125  * the port is an NPIV physical port, or it is an npiv virtual port with
1126  * the id of the vport.
1127  *
1128  * Returns: size of formatted string.
1129  **/
1130 static ssize_t
1131 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
1132                     char *buf)
1133 {
1134         struct Scsi_Host  *shost = class_to_shost(dev);
1135         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1136         struct lpfc_hba   *phba = vport->phba;
1137
1138         if (!(phba->max_vpi))
1139                 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
1140         if (vport->port_type == LPFC_PHYSICAL_PORT)
1141                 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
1142         return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
1143 }
1144
1145 /**
1146  * lpfc_poll_show - Return text about poll support for the adapter
1147  * @dev: class device that is converted into a Scsi_host.
1148  * @attr: device attribute, not used.
1149  * @buf: on return contains the cfg_poll in hex.
1150  *
1151  * Notes:
1152  * cfg_poll should be a lpfc_polling_flags type.
1153  *
1154  * Returns: size of formatted string.
1155  **/
1156 static ssize_t
1157 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
1158                char *buf)
1159 {
1160         struct Scsi_Host  *shost = class_to_shost(dev);
1161         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1162         struct lpfc_hba   *phba = vport->phba;
1163
1164         return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
1165 }
1166
1167 /**
1168  * lpfc_poll_store - Set the value of cfg_poll for the adapter
1169  * @dev: class device that is converted into a Scsi_host.
1170  * @attr: device attribute, not used.
1171  * @buf: one or more lpfc_polling_flags values.
1172  * @count: not used.
1173  *
1174  * Notes:
1175  * buf contents converted to integer and checked for a valid value.
1176  *
1177  * Returns:
1178  * -EINVAL if the buffer connot be converted or is out of range
1179  * length of the buf on success
1180  **/
1181 static ssize_t
1182 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
1183                 const char *buf, size_t count)
1184 {
1185         struct Scsi_Host  *shost = class_to_shost(dev);
1186         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1187         struct lpfc_hba   *phba = vport->phba;
1188         uint32_t creg_val;
1189         uint32_t old_val;
1190         int val=0;
1191
1192         if (!isdigit(buf[0]))
1193                 return -EINVAL;
1194
1195         if (sscanf(buf, "%i", &val) != 1)
1196                 return -EINVAL;
1197
1198         if ((val & 0x3) != val)
1199                 return -EINVAL;
1200
1201         if (phba->sli_rev == LPFC_SLI_REV4)
1202                 val = 0;
1203
1204         spin_lock_irq(&phba->hbalock);
1205
1206         old_val = phba->cfg_poll;
1207
1208         if (val & ENABLE_FCP_RING_POLLING) {
1209                 if ((val & DISABLE_FCP_RING_INT) &&
1210                     !(old_val & DISABLE_FCP_RING_INT)) {
1211                         creg_val = readl(phba->HCregaddr);
1212                         creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
1213                         writel(creg_val, phba->HCregaddr);
1214                         readl(phba->HCregaddr); /* flush */
1215
1216                         lpfc_poll_start_timer(phba);
1217                 }
1218         } else if (val != 0x0) {
1219                 spin_unlock_irq(&phba->hbalock);
1220                 return -EINVAL;
1221         }
1222
1223         if (!(val & DISABLE_FCP_RING_INT) &&
1224             (old_val & DISABLE_FCP_RING_INT))
1225         {
1226                 spin_unlock_irq(&phba->hbalock);
1227                 del_timer(&phba->fcp_poll_timer);
1228                 spin_lock_irq(&phba->hbalock);
1229                 creg_val = readl(phba->HCregaddr);
1230                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
1231                 writel(creg_val, phba->HCregaddr);
1232                 readl(phba->HCregaddr); /* flush */
1233         }
1234
1235         phba->cfg_poll = val;
1236
1237         spin_unlock_irq(&phba->hbalock);
1238
1239         return strlen(buf);
1240 }
1241
1242 /**
1243  * lpfc_fips_level_show - Return the current FIPS level for the HBA
1244  * @dev: class unused variable.
1245  * @attr: device attribute, not used.
1246  * @buf: on return contains the module description text.
1247  *
1248  * Returns: size of formatted string.
1249  **/
1250 static ssize_t
1251 lpfc_fips_level_show(struct device *dev,  struct device_attribute *attr,
1252                      char *buf)
1253 {
1254         struct Scsi_Host  *shost = class_to_shost(dev);
1255         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1256         struct lpfc_hba   *phba = vport->phba;
1257
1258         return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
1259 }
1260
1261 /**
1262  * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
1263  * @dev: class unused variable.
1264  * @attr: device attribute, not used.
1265  * @buf: on return contains the module description text.
1266  *
1267  * Returns: size of formatted string.
1268  **/
1269 static ssize_t
1270 lpfc_fips_rev_show(struct device *dev,  struct device_attribute *attr,
1271                    char *buf)
1272 {
1273         struct Scsi_Host  *shost = class_to_shost(dev);
1274         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1275         struct lpfc_hba   *phba = vport->phba;
1276
1277         return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
1278 }
1279
1280 /**
1281  * lpfc_param_show - Return a cfg attribute value in decimal
1282  *
1283  * Description:
1284  * Macro that given an attr e.g. hba_queue_depth expands
1285  * into a function with the name lpfc_hba_queue_depth_show.
1286  *
1287  * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
1288  * @dev: class device that is converted into a Scsi_host.
1289  * @attr: device attribute, not used.
1290  * @buf: on return contains the attribute value in decimal.
1291  *
1292  * Returns: size of formatted string.
1293  **/
1294 #define lpfc_param_show(attr)   \
1295 static ssize_t \
1296 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1297                    char *buf) \
1298 { \
1299         struct Scsi_Host  *shost = class_to_shost(dev);\
1300         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1301         struct lpfc_hba   *phba = vport->phba;\
1302         uint val = 0;\
1303         val = phba->cfg_##attr;\
1304         return snprintf(buf, PAGE_SIZE, "%d\n",\
1305                         phba->cfg_##attr);\
1306 }
1307
1308 /**
1309  * lpfc_param_hex_show - Return a cfg attribute value in hex
1310  *
1311  * Description:
1312  * Macro that given an attr e.g. hba_queue_depth expands
1313  * into a function with the name lpfc_hba_queue_depth_show
1314  *
1315  * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
1316  * @dev: class device that is converted into a Scsi_host.
1317  * @attr: device attribute, not used.
1318  * @buf: on return contains the attribute value in hexadecimal.
1319  *
1320  * Returns: size of formatted string.
1321  **/
1322 #define lpfc_param_hex_show(attr)       \
1323 static ssize_t \
1324 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1325                    char *buf) \
1326 { \
1327         struct Scsi_Host  *shost = class_to_shost(dev);\
1328         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1329         struct lpfc_hba   *phba = vport->phba;\
1330         uint val = 0;\
1331         val = phba->cfg_##attr;\
1332         return snprintf(buf, PAGE_SIZE, "%#x\n",\
1333                         phba->cfg_##attr);\
1334 }
1335
1336 /**
1337  * lpfc_param_init - Intializes a cfg attribute
1338  *
1339  * Description:
1340  * Macro that given an attr e.g. hba_queue_depth expands
1341  * into a function with the name lpfc_hba_queue_depth_init. The macro also
1342  * takes a default argument, a minimum and maximum argument.
1343  *
1344  * lpfc_##attr##_init: Initializes an attribute.
1345  * @phba: pointer the the adapter structure.
1346  * @val: integer attribute value.
1347  *
1348  * Validates the min and max values then sets the adapter config field
1349  * accordingly, or uses the default if out of range and prints an error message.
1350  *
1351  * Returns:
1352  * zero on success
1353  * -EINVAL if default used
1354  **/
1355 #define lpfc_param_init(attr, default, minval, maxval)  \
1356 static int \
1357 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
1358 { \
1359         if (val >= minval && val <= maxval) {\
1360                 phba->cfg_##attr = val;\
1361                 return 0;\
1362         }\
1363         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1364                         "0449 lpfc_"#attr" attribute cannot be set to %d, "\
1365                         "allowed range is ["#minval", "#maxval"]\n", val); \
1366         phba->cfg_##attr = default;\
1367         return -EINVAL;\
1368 }
1369
1370 /**
1371  * lpfc_param_set - Set a cfg attribute value
1372  *
1373  * Description:
1374  * Macro that given an attr e.g. hba_queue_depth expands
1375  * into a function with the name lpfc_hba_queue_depth_set
1376  *
1377  * lpfc_##attr##_set: Sets an attribute value.
1378  * @phba: pointer the the adapter structure.
1379  * @val: integer attribute value.
1380  *
1381  * Description:
1382  * Validates the min and max values then sets the
1383  * adapter config field if in the valid range. prints error message
1384  * and does not set the parameter if invalid.
1385  *
1386  * Returns:
1387  * zero on success
1388  * -EINVAL if val is invalid
1389  **/
1390 #define lpfc_param_set(attr, default, minval, maxval)   \
1391 static int \
1392 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
1393 { \
1394         if (val >= minval && val <= maxval) {\
1395                 phba->cfg_##attr = val;\
1396                 return 0;\
1397         }\
1398         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1399                         "0450 lpfc_"#attr" attribute cannot be set to %d, "\
1400                         "allowed range is ["#minval", "#maxval"]\n", val); \
1401         return -EINVAL;\
1402 }
1403
1404 /**
1405  * lpfc_param_store - Set a vport attribute value
1406  *
1407  * Description:
1408  * Macro that given an attr e.g. hba_queue_depth expands
1409  * into a function with the name lpfc_hba_queue_depth_store.
1410  *
1411  * lpfc_##attr##_store: Set an sttribute value.
1412  * @dev: class device that is converted into a Scsi_host.
1413  * @attr: device attribute, not used.
1414  * @buf: contains the attribute value in ascii.
1415  * @count: not used.
1416  *
1417  * Description:
1418  * Convert the ascii text number to an integer, then
1419  * use the lpfc_##attr##_set function to set the value.
1420  *
1421  * Returns:
1422  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1423  * length of buffer upon success.
1424  **/
1425 #define lpfc_param_store(attr)  \
1426 static ssize_t \
1427 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1428                     const char *buf, size_t count) \
1429 { \
1430         struct Scsi_Host  *shost = class_to_shost(dev);\
1431         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1432         struct lpfc_hba   *phba = vport->phba;\
1433         uint val = 0;\
1434         if (!isdigit(buf[0]))\
1435                 return -EINVAL;\
1436         if (sscanf(buf, "%i", &val) != 1)\
1437                 return -EINVAL;\
1438         if (lpfc_##attr##_set(phba, val) == 0) \
1439                 return strlen(buf);\
1440         else \
1441                 return -EINVAL;\
1442 }
1443
1444 /**
1445  * lpfc_vport_param_show - Return decimal formatted cfg attribute value
1446  *
1447  * Description:
1448  * Macro that given an attr e.g. hba_queue_depth expands
1449  * into a function with the name lpfc_hba_queue_depth_show
1450  *
1451  * lpfc_##attr##_show: prints the attribute value in decimal.
1452  * @dev: class device that is converted into a Scsi_host.
1453  * @attr: device attribute, not used.
1454  * @buf: on return contains the attribute value in decimal.
1455  *
1456  * Returns: length of formatted string.
1457  **/
1458 #define lpfc_vport_param_show(attr)     \
1459 static ssize_t \
1460 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1461                    char *buf) \
1462 { \
1463         struct Scsi_Host  *shost = class_to_shost(dev);\
1464         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1465         uint val = 0;\
1466         val = vport->cfg_##attr;\
1467         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
1468 }
1469
1470 /**
1471  * lpfc_vport_param_hex_show - Return hex formatted attribute value
1472  *
1473  * Description:
1474  * Macro that given an attr e.g.
1475  * hba_queue_depth expands into a function with the name
1476  * lpfc_hba_queue_depth_show
1477  *
1478  * lpfc_##attr##_show: prints the attribute value in hexadecimal.
1479  * @dev: class device that is converted into a Scsi_host.
1480  * @attr: device attribute, not used.
1481  * @buf: on return contains the attribute value in hexadecimal.
1482  *
1483  * Returns: length of formatted string.
1484  **/
1485 #define lpfc_vport_param_hex_show(attr) \
1486 static ssize_t \
1487 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1488                    char *buf) \
1489 { \
1490         struct Scsi_Host  *shost = class_to_shost(dev);\
1491         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1492         uint val = 0;\
1493         val = vport->cfg_##attr;\
1494         return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
1495 }
1496
1497 /**
1498  * lpfc_vport_param_init - Initialize a vport cfg attribute
1499  *
1500  * Description:
1501  * Macro that given an attr e.g. hba_queue_depth expands
1502  * into a function with the name lpfc_hba_queue_depth_init. The macro also
1503  * takes a default argument, a minimum and maximum argument.
1504  *
1505  * lpfc_##attr##_init: validates the min and max values then sets the
1506  * adapter config field accordingly, or uses the default if out of range
1507  * and prints an error message.
1508  * @phba: pointer the the adapter structure.
1509  * @val: integer attribute value.
1510  *
1511  * Returns:
1512  * zero on success
1513  * -EINVAL if default used
1514  **/
1515 #define lpfc_vport_param_init(attr, default, minval, maxval)    \
1516 static int \
1517 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
1518 { \
1519         if (val >= minval && val <= maxval) {\
1520                 vport->cfg_##attr = val;\
1521                 return 0;\
1522         }\
1523         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1524                          "0423 lpfc_"#attr" attribute cannot be set to %d, "\
1525                          "allowed range is ["#minval", "#maxval"]\n", val); \
1526         vport->cfg_##attr = default;\
1527         return -EINVAL;\
1528 }
1529
1530 /**
1531  * lpfc_vport_param_set - Set a vport cfg attribute
1532  *
1533  * Description:
1534  * Macro that given an attr e.g. hba_queue_depth expands
1535  * into a function with the name lpfc_hba_queue_depth_set
1536  *
1537  * lpfc_##attr##_set: validates the min and max values then sets the
1538  * adapter config field if in the valid range. prints error message
1539  * and does not set the parameter if invalid.
1540  * @phba: pointer the the adapter structure.
1541  * @val:        integer attribute value.
1542  *
1543  * Returns:
1544  * zero on success
1545  * -EINVAL if val is invalid
1546  **/
1547 #define lpfc_vport_param_set(attr, default, minval, maxval)     \
1548 static int \
1549 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
1550 { \
1551         if (val >= minval && val <= maxval) {\
1552                 vport->cfg_##attr = val;\
1553                 return 0;\
1554         }\
1555         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1556                          "0424 lpfc_"#attr" attribute cannot be set to %d, "\
1557                          "allowed range is ["#minval", "#maxval"]\n", val); \
1558         return -EINVAL;\
1559 }
1560
1561 /**
1562  * lpfc_vport_param_store - Set a vport attribute
1563  *
1564  * Description:
1565  * Macro that given an attr e.g. hba_queue_depth
1566  * expands into a function with the name lpfc_hba_queue_depth_store
1567  *
1568  * lpfc_##attr##_store: convert the ascii text number to an integer, then
1569  * use the lpfc_##attr##_set function to set the value.
1570  * @cdev: class device that is converted into a Scsi_host.
1571  * @buf:        contains the attribute value in decimal.
1572  * @count: not used.
1573  *
1574  * Returns:
1575  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1576  * length of buffer upon success.
1577  **/
1578 #define lpfc_vport_param_store(attr)    \
1579 static ssize_t \
1580 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1581                     const char *buf, size_t count) \
1582 { \
1583         struct Scsi_Host  *shost = class_to_shost(dev);\
1584         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1585         uint val = 0;\
1586         if (!isdigit(buf[0]))\
1587                 return -EINVAL;\
1588         if (sscanf(buf, "%i", &val) != 1)\
1589                 return -EINVAL;\
1590         if (lpfc_##attr##_set(vport, val) == 0) \
1591                 return strlen(buf);\
1592         else \
1593                 return -EINVAL;\
1594 }
1595
1596
1597 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
1598 static uint lpfc_##name = defval;\
1599 module_param(lpfc_##name, uint, 0);\
1600 MODULE_PARM_DESC(lpfc_##name, desc);\
1601 lpfc_param_init(name, defval, minval, maxval)
1602
1603 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
1604 static uint lpfc_##name = defval;\
1605 module_param(lpfc_##name, uint, 0);\
1606 MODULE_PARM_DESC(lpfc_##name, desc);\
1607 lpfc_param_show(name)\
1608 lpfc_param_init(name, defval, minval, maxval)\
1609 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1610
1611 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
1612 static uint lpfc_##name = defval;\
1613 module_param(lpfc_##name, uint, 0);\
1614 MODULE_PARM_DESC(lpfc_##name, desc);\
1615 lpfc_param_show(name)\
1616 lpfc_param_init(name, defval, minval, maxval)\
1617 lpfc_param_set(name, defval, minval, maxval)\
1618 lpfc_param_store(name)\
1619 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1620                    lpfc_##name##_show, lpfc_##name##_store)
1621
1622 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1623 static uint lpfc_##name = defval;\
1624 module_param(lpfc_##name, uint, 0);\
1625 MODULE_PARM_DESC(lpfc_##name, desc);\
1626 lpfc_param_hex_show(name)\
1627 lpfc_param_init(name, defval, minval, maxval)\
1628 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1629
1630 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1631 static uint lpfc_##name = defval;\
1632 module_param(lpfc_##name, uint, 0);\
1633 MODULE_PARM_DESC(lpfc_##name, desc);\
1634 lpfc_param_hex_show(name)\
1635 lpfc_param_init(name, defval, minval, maxval)\
1636 lpfc_param_set(name, defval, minval, maxval)\
1637 lpfc_param_store(name)\
1638 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1639                    lpfc_##name##_show, lpfc_##name##_store)
1640
1641 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
1642 static uint lpfc_##name = defval;\
1643 module_param(lpfc_##name, uint, 0);\
1644 MODULE_PARM_DESC(lpfc_##name, desc);\
1645 lpfc_vport_param_init(name, defval, minval, maxval)
1646
1647 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
1648 static uint lpfc_##name = defval;\
1649 module_param(lpfc_##name, uint, 0);\
1650 MODULE_PARM_DESC(lpfc_##name, desc);\
1651 lpfc_vport_param_show(name)\
1652 lpfc_vport_param_init(name, defval, minval, maxval)\
1653 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1654
1655 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
1656 static uint lpfc_##name = defval;\
1657 module_param(lpfc_##name, uint, 0);\
1658 MODULE_PARM_DESC(lpfc_##name, desc);\
1659 lpfc_vport_param_show(name)\
1660 lpfc_vport_param_init(name, defval, minval, maxval)\
1661 lpfc_vport_param_set(name, defval, minval, maxval)\
1662 lpfc_vport_param_store(name)\
1663 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1664                    lpfc_##name##_show, lpfc_##name##_store)
1665
1666 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1667 static uint lpfc_##name = defval;\
1668 module_param(lpfc_##name, uint, 0);\
1669 MODULE_PARM_DESC(lpfc_##name, desc);\
1670 lpfc_vport_param_hex_show(name)\
1671 lpfc_vport_param_init(name, defval, minval, maxval)\
1672 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1673
1674 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1675 static uint lpfc_##name = defval;\
1676 module_param(lpfc_##name, uint, 0);\
1677 MODULE_PARM_DESC(lpfc_##name, desc);\
1678 lpfc_vport_param_hex_show(name)\
1679 lpfc_vport_param_init(name, defval, minval, maxval)\
1680 lpfc_vport_param_set(name, defval, minval, maxval)\
1681 lpfc_vport_param_store(name)\
1682 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1683                    lpfc_##name##_show, lpfc_##name##_store)
1684
1685 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
1686 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
1687 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
1688 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
1689 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
1690 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
1691 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
1692 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
1693 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
1694 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
1695 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
1696 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
1697 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
1698                 lpfc_link_state_store);
1699 static DEVICE_ATTR(option_rom_version, S_IRUGO,
1700                    lpfc_option_rom_version_show, NULL);
1701 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
1702                    lpfc_num_discovered_ports_show, NULL);
1703 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
1704 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
1705 static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
1706 static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL);
1707 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
1708                    lpfc_board_mode_show, lpfc_board_mode_store);
1709 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
1710 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
1711 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
1712 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
1713 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
1714 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
1715 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
1716 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
1717 static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
1718 static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL);
1719 static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
1720
1721
1722 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
1723
1724 /**
1725  * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
1726  * @dev: class device that is converted into a Scsi_host.
1727  * @attr: device attribute, not used.
1728  * @buf: containing the string lpfc_soft_wwn_key.
1729  * @count: must be size of lpfc_soft_wwn_key.
1730  *
1731  * Returns:
1732  * -EINVAL if the buffer does not contain lpfc_soft_wwn_key
1733  * length of buf indicates success
1734  **/
1735 static ssize_t
1736 lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
1737                            const char *buf, size_t count)
1738 {
1739         struct Scsi_Host  *shost = class_to_shost(dev);
1740         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1741         struct lpfc_hba   *phba = vport->phba;
1742         unsigned int cnt = count;
1743
1744         /*
1745          * We're doing a simple sanity check for soft_wwpn setting.
1746          * We require that the user write a specific key to enable
1747          * the soft_wwpn attribute to be settable. Once the attribute
1748          * is written, the enable key resets. If further updates are
1749          * desired, the key must be written again to re-enable the
1750          * attribute.
1751          *
1752          * The "key" is not secret - it is a hardcoded string shown
1753          * here. The intent is to protect against the random user or
1754          * application that is just writing attributes.
1755          */
1756
1757         /* count may include a LF at end of string */
1758         if (buf[cnt-1] == '\n')
1759                 cnt--;
1760
1761         if ((cnt != strlen(lpfc_soft_wwn_key)) ||
1762             (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
1763                 return -EINVAL;
1764
1765         phba->soft_wwn_enable = 1;
1766         return count;
1767 }
1768 static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
1769                    lpfc_soft_wwn_enable_store);
1770
1771 /**
1772  * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
1773  * @dev: class device that is converted into a Scsi_host.
1774  * @attr: device attribute, not used.
1775  * @buf: on return contains the wwpn in hexadecimal.
1776  *
1777  * Returns: size of formatted string.
1778  **/
1779 static ssize_t
1780 lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
1781                     char *buf)
1782 {
1783         struct Scsi_Host  *shost = class_to_shost(dev);
1784         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1785         struct lpfc_hba   *phba = vport->phba;
1786
1787         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
1788                         (unsigned long long)phba->cfg_soft_wwpn);
1789 }
1790
1791 /**
1792  * lpfc_soft_wwpn_store - Set the ww port name of the adapter
1793  * @dev class device that is converted into a Scsi_host.
1794  * @attr: device attribute, not used.
1795  * @buf: contains the wwpn in hexadecimal.
1796  * @count: number of wwpn bytes in buf
1797  *
1798  * Returns:
1799  * -EACCES hba reset not enabled, adapter over temp
1800  * -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
1801  * -EIO error taking adapter offline or online
1802  * value of count on success
1803  **/
1804 static ssize_t
1805 lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
1806                      const char *buf, size_t count)
1807 {
1808         struct Scsi_Host  *shost = class_to_shost(dev);
1809         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1810         struct lpfc_hba   *phba = vport->phba;
1811         struct completion online_compl;
1812         int stat1=0, stat2=0;
1813         unsigned int i, j, cnt=count;
1814         u8 wwpn[8];
1815
1816         if (!phba->cfg_enable_hba_reset)
1817                 return -EACCES;
1818         spin_lock_irq(&phba->hbalock);
1819         if (phba->over_temp_state == HBA_OVER_TEMP) {
1820                 spin_unlock_irq(&phba->hbalock);
1821                 return -EACCES;
1822         }
1823         spin_unlock_irq(&phba->hbalock);
1824         /* count may include a LF at end of string */
1825         if (buf[cnt-1] == '\n')
1826                 cnt--;
1827
1828         if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
1829             ((cnt == 17) && (*buf++ != 'x')) ||
1830             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
1831                 return -EINVAL;
1832
1833         phba->soft_wwn_enable = 0;
1834
1835         memset(wwpn, 0, sizeof(wwpn));
1836
1837         /* Validate and store the new name */
1838         for (i=0, j=0; i < 16; i++) {
1839                 int value;
1840
1841                 value = hex_to_bin(*buf++);
1842                 if (value >= 0)
1843                         j = (j << 4) | value;
1844                 else
1845                         return -EINVAL;
1846                 if (i % 2) {
1847                         wwpn[i/2] = j & 0xff;
1848                         j = 0;
1849                 }
1850         }
1851         phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
1852         fc_host_port_name(shost) = phba->cfg_soft_wwpn;
1853         if (phba->cfg_soft_wwnn)
1854                 fc_host_node_name(shost) = phba->cfg_soft_wwnn;
1855
1856         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
1857                    "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
1858
1859         stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1860         if (stat1)
1861                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1862                                 "0463 lpfc_soft_wwpn attribute set failed to "
1863                                 "reinit adapter - %d\n", stat1);
1864         init_completion(&online_compl);
1865         lpfc_workq_post_event(phba, &stat2, &online_compl, LPFC_EVT_ONLINE);
1866         wait_for_completion(&online_compl);
1867         if (stat2)
1868                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1869                                 "0464 lpfc_soft_wwpn attribute set failed to "
1870                                 "reinit adapter - %d\n", stat2);
1871         return (stat1 || stat2) ? -EIO : count;
1872 }
1873 static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
1874                    lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
1875
1876 /**
1877  * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
1878  * @dev: class device that is converted into a Scsi_host.
1879  * @attr: device attribute, not used.
1880  * @buf: on return contains the wwnn in hexadecimal.
1881  *
1882  * Returns: size of formatted string.
1883  **/
1884 static ssize_t
1885 lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
1886                     char *buf)
1887 {
1888         struct Scsi_Host *shost = class_to_shost(dev);
1889         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
1890         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
1891                         (unsigned long long)phba->cfg_soft_wwnn);
1892 }
1893
1894 /**
1895  * lpfc_soft_wwnn_store - sets the ww node name of the adapter
1896  * @cdev: class device that is converted into a Scsi_host.
1897  * @buf: contains the ww node name in hexadecimal.
1898  * @count: number of wwnn bytes in buf.
1899  *
1900  * Returns:
1901  * -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
1902  * value of count on success
1903  **/
1904 static ssize_t
1905 lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
1906                      const char *buf, size_t count)
1907 {
1908         struct Scsi_Host *shost = class_to_shost(dev);
1909         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
1910         unsigned int i, j, cnt=count;
1911         u8 wwnn[8];
1912
1913         /* count may include a LF at end of string */
1914         if (buf[cnt-1] == '\n')
1915                 cnt--;
1916
1917         if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
1918             ((cnt == 17) && (*buf++ != 'x')) ||
1919             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
1920                 return -EINVAL;
1921
1922         /*
1923          * Allow wwnn to be set many times, as long as the enable is set.
1924          * However, once the wwpn is set, everything locks.
1925          */
1926
1927         memset(wwnn, 0, sizeof(wwnn));
1928
1929         /* Validate and store the new name */
1930         for (i=0, j=0; i < 16; i++) {
1931                 int value;
1932
1933                 value = hex_to_bin(*buf++);
1934                 if (value >= 0)
1935                         j = (j << 4) | value;
1936                 else
1937                         return -EINVAL;
1938                 if (i % 2) {
1939                         wwnn[i/2] = j & 0xff;
1940                         j = 0;
1941                 }
1942         }
1943         phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
1944
1945         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
1946                    "lpfc%d: soft_wwnn set. Value will take effect upon "
1947                    "setting of the soft_wwpn\n", phba->brd_no);
1948
1949         return count;
1950 }
1951 static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
1952                    lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
1953
1954
1955 static int lpfc_poll = 0;
1956 module_param(lpfc_poll, int, 0);
1957 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
1958                  " 0 - none,"
1959                  " 1 - poll with interrupts enabled"
1960                  " 3 - poll and disable FCP ring interrupts");
1961
1962 static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
1963                    lpfc_poll_show, lpfc_poll_store);
1964
1965 int  lpfc_sli_mode = 0;
1966 module_param(lpfc_sli_mode, int, 0);
1967 MODULE_PARM_DESC(lpfc_sli_mode, "SLI mode selector:"
1968                  " 0 - auto (SLI-3 if supported),"
1969                  " 2 - select SLI-2 even on SLI-3 capable HBAs,"
1970                  " 3 - select SLI-3");
1971
1972 int lpfc_enable_npiv = 1;
1973 module_param(lpfc_enable_npiv, int, 0);
1974 MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
1975 lpfc_param_show(enable_npiv);
1976 lpfc_param_init(enable_npiv, 1, 0, 1);
1977 static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL);
1978
1979 /*
1980 # lpfc_suppress_link_up:  Bring link up at initialization
1981 #            0x0  = bring link up (issue MBX_INIT_LINK)
1982 #            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
1983 #            0x2  = never bring up link
1984 # Default value is 0.
1985 */
1986 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
1987                 LPFC_DELAY_INIT_LINK_INDEFINITELY,
1988                 "Suppress Link Up at initialization");
1989 /*
1990 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
1991 #       1 - (1024)
1992 #       2 - (2048)
1993 #       3 - (3072)
1994 #       4 - (4096)
1995 #       5 - (5120)
1996 */
1997 static ssize_t
1998 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
1999 {
2000         struct Scsi_Host  *shost = class_to_shost(dev);
2001         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2002
2003         return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
2004 }
2005
2006 static DEVICE_ATTR(iocb_hw, S_IRUGO,
2007                          lpfc_iocb_hw_show, NULL);
2008 static ssize_t
2009 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
2010 {
2011         struct Scsi_Host  *shost = class_to_shost(dev);
2012         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2013
2014         return snprintf(buf, PAGE_SIZE, "%d\n",
2015                 phba->sli.ring[LPFC_ELS_RING].txq_max);
2016 }
2017
2018 static DEVICE_ATTR(txq_hw, S_IRUGO,
2019                          lpfc_txq_hw_show, NULL);
2020 static ssize_t
2021 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
2022  char *buf)
2023 {
2024         struct Scsi_Host  *shost = class_to_shost(dev);
2025         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2026
2027         return snprintf(buf, PAGE_SIZE, "%d\n",
2028                 phba->sli.ring[LPFC_ELS_RING].txcmplq_max);
2029 }
2030
2031 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
2032                          lpfc_txcmplq_hw_show, NULL);
2033
2034 int lpfc_iocb_cnt = 2;
2035 module_param(lpfc_iocb_cnt, int, 1);
2036 MODULE_PARM_DESC(lpfc_iocb_cnt,
2037         "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
2038 lpfc_param_show(iocb_cnt);
2039 lpfc_param_init(iocb_cnt, 2, 1, 5);
2040 static DEVICE_ATTR(lpfc_iocb_cnt, S_IRUGO,
2041                          lpfc_iocb_cnt_show, NULL);
2042
2043 /*
2044 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
2045 # until the timer expires. Value range is [0,255]. Default value is 30.
2046 */
2047 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2048 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
2049 module_param(lpfc_nodev_tmo, int, 0);
2050 MODULE_PARM_DESC(lpfc_nodev_tmo,
2051                  "Seconds driver will hold I/O waiting "
2052                  "for a device to come back");
2053
2054 /**
2055  * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
2056  * @dev: class converted to a Scsi_host structure.
2057  * @attr: device attribute, not used.
2058  * @buf: on return contains the dev loss timeout in decimal.
2059  *
2060  * Returns: size of formatted string.
2061  **/
2062 static ssize_t
2063 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
2064                     char *buf)
2065 {
2066         struct Scsi_Host  *shost = class_to_shost(dev);
2067         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2068
2069         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
2070 }
2071
2072 /**
2073  * lpfc_nodev_tmo_init - Set the hba nodev timeout value
2074  * @vport: lpfc vport structure pointer.
2075  * @val: contains the nodev timeout value.
2076  *
2077  * Description:
2078  * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
2079  * a kernel error message is printed and zero is returned.
2080  * Else if val is in range then nodev tmo and devloss tmo are set to val.
2081  * Otherwise nodev tmo is set to the default value.
2082  *
2083  * Returns:
2084  * zero if already set or if val is in range
2085  * -EINVAL val out of range
2086  **/
2087 static int
2088 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
2089 {
2090         if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
2091                 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
2092                 if (val != LPFC_DEF_DEVLOSS_TMO)
2093                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2094                                          "0407 Ignoring nodev_tmo module "
2095                                          "parameter because devloss_tmo is "
2096                                          "set.\n");
2097                 return 0;
2098         }
2099
2100         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2101                 vport->cfg_nodev_tmo = val;
2102                 vport->cfg_devloss_tmo = val;
2103                 return 0;
2104         }
2105         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2106                          "0400 lpfc_nodev_tmo attribute cannot be set to"
2107                          " %d, allowed range is [%d, %d]\n",
2108                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2109         vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2110         return -EINVAL;
2111 }
2112
2113 /**
2114  * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
2115  * @vport: lpfc vport structure pointer.
2116  *
2117  * Description:
2118  * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
2119  **/
2120 static void
2121 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
2122 {
2123         struct Scsi_Host  *shost;
2124         struct lpfc_nodelist  *ndlp;
2125
2126         shost = lpfc_shost_from_vport(vport);
2127         spin_lock_irq(shost->host_lock);
2128         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
2129                 if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
2130                         ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
2131         spin_unlock_irq(shost->host_lock);
2132 }
2133
2134 /**
2135  * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
2136  * @vport: lpfc vport structure pointer.
2137  * @val: contains the tmo value.
2138  *
2139  * Description:
2140  * If the devloss tmo is already set or the vport dev loss tmo has changed
2141  * then a kernel error message is printed and zero is returned.
2142  * Else if val is in range then nodev tmo and devloss tmo are set to val.
2143  * Otherwise nodev tmo is set to the default value.
2144  *
2145  * Returns:
2146  * zero if already set or if val is in range
2147  * -EINVAL val out of range
2148  **/
2149 static int
2150 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
2151 {
2152         if (vport->dev_loss_tmo_changed ||
2153             (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
2154                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2155                                  "0401 Ignoring change to nodev_tmo "
2156                                  "because devloss_tmo is set.\n");
2157                 return 0;
2158         }
2159         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2160                 vport->cfg_nodev_tmo = val;
2161                 vport->cfg_devloss_tmo = val;
2162                 lpfc_update_rport_devloss_tmo(vport);
2163                 return 0;
2164         }
2165         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2166                          "0403 lpfc_nodev_tmo attribute cannot be set to"
2167                          "%d, allowed range is [%d, %d]\n",
2168                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2169         return -EINVAL;
2170 }
2171
2172 lpfc_vport_param_store(nodev_tmo)
2173
2174 static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
2175                    lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
2176
2177 /*
2178 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
2179 # disappear until the timer expires. Value range is [0,255]. Default
2180 # value is 30.
2181 */
2182 module_param(lpfc_devloss_tmo, int, 0);
2183 MODULE_PARM_DESC(lpfc_devloss_tmo,
2184                  "Seconds driver will hold I/O waiting "
2185                  "for a device to come back");
2186 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
2187                       LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
2188 lpfc_vport_param_show(devloss_tmo)
2189
2190 /**
2191  * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
2192  * @vport: lpfc vport structure pointer.
2193  * @val: contains the tmo value.
2194  *
2195  * Description:
2196  * If val is in a valid range then set the vport nodev tmo,
2197  * devloss tmo, also set the vport dev loss tmo changed flag.
2198  * Else a kernel error message is printed.
2199  *
2200  * Returns:
2201  * zero if val is in range
2202  * -EINVAL val out of range
2203  **/
2204 static int
2205 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
2206 {
2207         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2208                 vport->cfg_nodev_tmo = val;
2209                 vport->cfg_devloss_tmo = val;
2210                 vport->dev_loss_tmo_changed = 1;
2211                 lpfc_update_rport_devloss_tmo(vport);
2212                 return 0;
2213         }
2214
2215         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2216                          "0404 lpfc_devloss_tmo attribute cannot be set to"
2217                          " %d, allowed range is [%d, %d]\n",
2218                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2219         return -EINVAL;
2220 }
2221
2222 lpfc_vport_param_store(devloss_tmo)
2223 static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
2224                    lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
2225
2226 /*
2227 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
2228 # deluged with LOTS of information.
2229 # You can set a bit mask to record specific types of verbose messages:
2230 # See lpfc_logmsh.h for definitions.
2231 */
2232 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
2233                        "Verbose logging bit-mask");
2234
2235 /*
2236 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
2237 # objects that have been registered with the nameserver after login.
2238 */
2239 LPFC_VPORT_ATTR_R(enable_da_id, 0, 0, 1,
2240                   "Deregister nameserver objects before LOGO");
2241
2242 /*
2243 # lun_queue_depth:  This parameter is used to limit the number of outstanding
2244 # commands per FCP LUN. Value range is [1,128]. Default value is 30.
2245 */
2246 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128,
2247                   "Max number of FCP commands we can queue to a specific LUN");
2248
2249 /*
2250 # tgt_queue_depth:  This parameter is used to limit the number of outstanding
2251 # commands per target port. Value range is [10,65535]. Default value is 65535.
2252 */
2253 LPFC_VPORT_ATTR_R(tgt_queue_depth, 65535, 10, 65535,
2254         "Max number of FCP commands we can queue to a specific target port");
2255
2256 /*
2257 # hba_queue_depth:  This parameter is used to limit the number of outstanding
2258 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
2259 # value is greater than the maximum number of exchanges supported by the HBA,
2260 # then maximum number of exchanges supported by the HBA is used to determine
2261 # the hba_queue_depth.
2262 */
2263 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
2264             "Max number of FCP commands we can queue to a lpfc HBA");
2265
2266 /*
2267 # peer_port_login:  This parameter allows/prevents logins
2268 # between peer ports hosted on the same physical port.
2269 # When this parameter is set 0 peer ports of same physical port
2270 # are not allowed to login to each other.
2271 # When this parameter is set 1 peer ports of same physical port
2272 # are allowed to login to each other.
2273 # Default value of this parameter is 0.
2274 */
2275 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
2276                   "Allow peer ports on the same physical port to login to each "
2277                   "other.");
2278
2279 /*
2280 # restrict_login:  This parameter allows/prevents logins
2281 # between Virtual Ports and remote initiators.
2282 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
2283 # other initiators and will attempt to PLOGI all remote ports.
2284 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
2285 # remote ports and will not attempt to PLOGI to other initiators.
2286 # This parameter does not restrict to the physical port.
2287 # This parameter does not restrict logins to Fabric resident remote ports.
2288 # Default value of this parameter is 1.
2289 */
2290 static int lpfc_restrict_login = 1;
2291 module_param(lpfc_restrict_login, int, 0);
2292 MODULE_PARM_DESC(lpfc_restrict_login,
2293                  "Restrict virtual ports login to remote initiators.");
2294 lpfc_vport_param_show(restrict_login);
2295
2296 /**
2297  * lpfc_restrict_login_init - Set the vport restrict login flag
2298  * @vport: lpfc vport structure pointer.
2299  * @val: contains the restrict login value.
2300  *
2301  * Description:
2302  * If val is not in a valid range then log a kernel error message and set
2303  * the vport restrict login to one.
2304  * If the port type is physical clear the restrict login flag and return.
2305  * Else set the restrict login flag to val.
2306  *
2307  * Returns:
2308  * zero if val is in range
2309  * -EINVAL val out of range
2310  **/
2311 static int
2312 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
2313 {
2314         if (val < 0 || val > 1) {
2315                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2316                                  "0422 lpfc_restrict_login attribute cannot "
2317                                  "be set to %d, allowed range is [0, 1]\n",
2318                                  val);
2319                 vport->cfg_restrict_login = 1;
2320                 return -EINVAL;
2321         }
2322         if (vport->port_type == LPFC_PHYSICAL_PORT) {
2323                 vport->cfg_restrict_login = 0;
2324                 return 0;
2325         }
2326         vport->cfg_restrict_login = val;
2327         return 0;
2328 }
2329
2330 /**
2331  * lpfc_restrict_login_set - Set the vport restrict login flag
2332  * @vport: lpfc vport structure pointer.
2333  * @val: contains the restrict login value.
2334  *
2335  * Description:
2336  * If val is not in a valid range then log a kernel error message and set
2337  * the vport restrict login to one.
2338  * If the port type is physical and the val is not zero log a kernel
2339  * error message, clear the restrict login flag and return zero.
2340  * Else set the restrict login flag to val.
2341  *
2342  * Returns:
2343  * zero if val is in range
2344  * -EINVAL val out of range
2345  **/
2346 static int
2347 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
2348 {
2349         if (val < 0 || val > 1) {
2350                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2351                                  "0425 lpfc_restrict_login attribute cannot "
2352                                  "be set to %d, allowed range is [0, 1]\n",
2353                                  val);
2354                 vport->cfg_restrict_login = 1;
2355                 return -EINVAL;
2356         }
2357         if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
2358                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2359                                  "0468 lpfc_restrict_login must be 0 for "
2360                                  "Physical ports.\n");
2361                 vport->cfg_restrict_login = 0;
2362                 return 0;
2363         }
2364         vport->cfg_restrict_login = val;
2365         return 0;
2366 }
2367 lpfc_vport_param_store(restrict_login);
2368 static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
2369                    lpfc_restrict_login_show, lpfc_restrict_login_store);
2370
2371 /*
2372 # Some disk devices have a "select ID" or "select Target" capability.
2373 # From a protocol standpoint "select ID" usually means select the
2374 # Fibre channel "ALPA".  In the FC-AL Profile there is an "informative
2375 # annex" which contains a table that maps a "select ID" (a number
2376 # between 0 and 7F) to an ALPA.  By default, for compatibility with
2377 # older drivers, the lpfc driver scans this table from low ALPA to high
2378 # ALPA.
2379 #
2380 # Turning on the scan-down variable (on  = 1, off = 0) will
2381 # cause the lpfc driver to use an inverted table, effectively
2382 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
2383 #
2384 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
2385 # and will not work across a fabric. Also this parameter will take
2386 # effect only in the case when ALPA map is not available.)
2387 */
2388 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
2389                   "Start scanning for devices from highest ALPA to lowest");
2390
2391 /*
2392 # lpfc_topology:  link topology for init link
2393 #            0x0  = attempt loop mode then point-to-point
2394 #            0x01 = internal loopback mode
2395 #            0x02 = attempt point-to-point mode only
2396 #            0x04 = attempt loop mode only
2397 #            0x06 = attempt point-to-point mode then loop
2398 # Set point-to-point mode if you want to run as an N_Port.
2399 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
2400 # Default value is 0.
2401 */
2402
2403 /**
2404  * lpfc_topology_set - Set the adapters topology field
2405  * @phba: lpfc_hba pointer.
2406  * @val: topology value.
2407  *
2408  * Description:
2409  * If val is in a valid range then set the adapter's topology field and
2410  * issue a lip; if the lip fails reset the topology to the old value.
2411  *
2412  * If the value is not in range log a kernel error message and return an error.
2413  *
2414  * Returns:
2415  * zero if val is in range and lip okay
2416  * non-zero return value from lpfc_issue_lip()
2417  * -EINVAL val out of range
2418  **/
2419 static ssize_t
2420 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
2421                         const char *buf, size_t count)
2422 {
2423         struct Scsi_Host  *shost = class_to_shost(dev);
2424         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2425         struct lpfc_hba   *phba = vport->phba;
2426         int val = 0;
2427         int nolip = 0;
2428         const char *val_buf = buf;
2429         int err;
2430         uint32_t prev_val;
2431
2432         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
2433                 nolip = 1;
2434                 val_buf = &buf[strlen("nolip ")];
2435         }
2436
2437         if (!isdigit(val_buf[0]))
2438                 return -EINVAL;
2439         if (sscanf(val_buf, "%i", &val) != 1)
2440                 return -EINVAL;
2441
2442         if (val >= 0 && val <= 6) {
2443                 prev_val = phba->cfg_topology;
2444                 phba->cfg_topology = val;
2445                 if (nolip)
2446                         return strlen(buf);
2447
2448                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
2449                 if (err) {
2450                         phba->cfg_topology = prev_val;
2451                         return -EINVAL;
2452                 } else
2453                         return strlen(buf);
2454         }
2455         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2456                 "%d:0467 lpfc_topology attribute cannot be set to %d, "
2457                 "allowed range is [0, 6]\n",
2458                 phba->brd_no, val);
2459         return -EINVAL;
2460 }
2461 static int lpfc_topology = 0;
2462 module_param(lpfc_topology, int, 0);
2463 MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
2464 lpfc_param_show(topology)
2465 lpfc_param_init(topology, 0, 0, 6)
2466 static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
2467                 lpfc_topology_show, lpfc_topology_store);
2468
2469 /**
2470  * lpfc_static_vport_show: Read callback function for
2471  *   lpfc_static_vport sysfs file.
2472  * @dev: Pointer to class device object.
2473  * @attr: device attribute structure.
2474  * @buf: Data buffer.
2475  *
2476  * This function is the read call back function for
2477  * lpfc_static_vport sysfs file. The lpfc_static_vport
2478  * sysfs file report the mageability of the vport.
2479  **/
2480 static ssize_t
2481 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
2482                          char *buf)
2483 {
2484         struct Scsi_Host  *shost = class_to_shost(dev);
2485         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2486         if (vport->vport_flag & STATIC_VPORT)
2487                 sprintf(buf, "1\n");
2488         else
2489                 sprintf(buf, "0\n");
2490
2491         return strlen(buf);
2492 }
2493
2494 /*
2495  * Sysfs attribute to control the statistical data collection.
2496  */
2497 static DEVICE_ATTR(lpfc_static_vport, S_IRUGO,
2498                    lpfc_static_vport_show, NULL);
2499
2500 /**
2501  * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
2502  * @dev: Pointer to class device.
2503  * @buf: Data buffer.
2504  * @count: Size of the data buffer.
2505  *
2506  * This function get called when an user write to the lpfc_stat_data_ctrl
2507  * sysfs file. This function parse the command written to the sysfs file
2508  * and take appropriate action. These commands are used for controlling
2509  * driver statistical data collection.
2510  * Following are the command this function handles.
2511  *
2512  *    setbucket <bucket_type> <base> <step>
2513  *                             = Set the latency buckets.
2514  *    destroybucket            = destroy all the buckets.
2515  *    start                    = start data collection
2516  *    stop                     = stop data collection
2517  *    reset                    = reset the collected data
2518  **/
2519 static ssize_t
2520 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
2521                           const char *buf, size_t count)
2522 {
2523         struct Scsi_Host  *shost = class_to_shost(dev);
2524         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2525         struct lpfc_hba   *phba = vport->phba;
2526 #define LPFC_MAX_DATA_CTRL_LEN 1024
2527         static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
2528         unsigned long i;
2529         char *str_ptr, *token;
2530         struct lpfc_vport **vports;
2531         struct Scsi_Host *v_shost;
2532         char *bucket_type_str, *base_str, *step_str;
2533         unsigned long base, step, bucket_type;
2534
2535         if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
2536                 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
2537                         return -EINVAL;
2538
2539                 strcpy(bucket_data, buf);
2540                 str_ptr = &bucket_data[0];
2541                 /* Ignore this token - this is command token */
2542                 token = strsep(&str_ptr, "\t ");
2543                 if (!token)
2544                         return -EINVAL;
2545
2546                 bucket_type_str = strsep(&str_ptr, "\t ");
2547                 if (!bucket_type_str)
2548                         return -EINVAL;
2549
2550                 if (!strncmp(bucket_type_str, "linear", strlen("linear")))
2551                         bucket_type = LPFC_LINEAR_BUCKET;
2552                 else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
2553                         bucket_type = LPFC_POWER2_BUCKET;
2554                 else
2555                         return -EINVAL;
2556
2557                 base_str = strsep(&str_ptr, "\t ");
2558                 if (!base_str)
2559                         return -EINVAL;
2560                 base = simple_strtoul(base_str, NULL, 0);
2561
2562                 step_str = strsep(&str_ptr, "\t ");
2563                 if (!step_str)
2564                         return -EINVAL;
2565                 step = simple_strtoul(step_str, NULL, 0);
2566                 if (!step)
2567                         return -EINVAL;
2568
2569                 /* Block the data collection for every vport */
2570                 vports = lpfc_create_vport_work_array(phba);
2571                 if (vports == NULL)
2572                         return -ENOMEM;
2573
2574                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2575                         v_shost = lpfc_shost_from_vport(vports[i]);
2576                         spin_lock_irq(v_shost->host_lock);
2577                         /* Block and reset data collection */
2578                         vports[i]->stat_data_blocked = 1;
2579                         if (vports[i]->stat_data_enabled)
2580                                 lpfc_vport_reset_stat_data(vports[i]);
2581                         spin_unlock_irq(v_shost->host_lock);
2582                 }
2583
2584                 /* Set the bucket attributes */
2585                 phba->bucket_type = bucket_type;
2586                 phba->bucket_base = base;
2587                 phba->bucket_step = step;
2588
2589                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2590                         v_shost = lpfc_shost_from_vport(vports[i]);
2591
2592                         /* Unblock data collection */
2593                         spin_lock_irq(v_shost->host_lock);
2594                         vports[i]->stat_data_blocked = 0;
2595                         spin_unlock_irq(v_shost->host_lock);
2596                 }
2597                 lpfc_destroy_vport_work_array(phba, vports);
2598                 return strlen(buf);
2599         }
2600
2601         if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
2602                 vports = lpfc_create_vport_work_array(phba);
2603                 if (vports == NULL)
2604                         return -ENOMEM;
2605
2606                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2607                         v_shost = lpfc_shost_from_vport(vports[i]);
2608                         spin_lock_irq(shost->host_lock);
2609                         vports[i]->stat_data_blocked = 1;
2610                         lpfc_free_bucket(vport);
2611                         vport->stat_data_enabled = 0;
2612                         vports[i]->stat_data_blocked = 0;
2613                         spin_unlock_irq(shost->host_lock);
2614                 }
2615                 lpfc_destroy_vport_work_array(phba, vports);
2616                 phba->bucket_type = LPFC_NO_BUCKET;
2617                 phba->bucket_base = 0;
2618                 phba->bucket_step = 0;
2619                 return strlen(buf);
2620         }
2621
2622         if (!strncmp(buf, "start", strlen("start"))) {
2623                 /* If no buckets configured return error */
2624                 if (phba->bucket_type == LPFC_NO_BUCKET)
2625                         return -EINVAL;
2626                 spin_lock_irq(shost->host_lock);
2627                 if (vport->stat_data_enabled) {
2628                         spin_unlock_irq(shost->host_lock);
2629                         return strlen(buf);
2630                 }
2631                 lpfc_alloc_bucket(vport);
2632                 vport->stat_data_enabled = 1;
2633                 spin_unlock_irq(shost->host_lock);
2634                 return strlen(buf);
2635         }
2636
2637         if (!strncmp(buf, "stop", strlen("stop"))) {
2638                 spin_lock_irq(shost->host_lock);
2639                 if (vport->stat_data_enabled == 0) {
2640                         spin_unlock_irq(shost->host_lock);
2641                         return strlen(buf);
2642                 }
2643                 lpfc_free_bucket(vport);
2644                 vport->stat_data_enabled = 0;
2645                 spin_unlock_irq(shost->host_lock);
2646                 return strlen(buf);
2647         }
2648
2649         if (!strncmp(buf, "reset", strlen("reset"))) {
2650                 if ((phba->bucket_type == LPFC_NO_BUCKET)
2651                         || !vport->stat_data_enabled)
2652                         return strlen(buf);
2653                 spin_lock_irq(shost->host_lock);
2654                 vport->stat_data_blocked = 1;
2655                 lpfc_vport_reset_stat_data(vport);
2656                 vport->stat_data_blocked = 0;
2657                 spin_unlock_irq(shost->host_lock);
2658                 return strlen(buf);
2659         }
2660         return -EINVAL;
2661 }
2662
2663
2664 /**
2665  * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
2666  * @dev: Pointer to class device object.
2667  * @buf: Data buffer.
2668  *
2669  * This function is the read call back function for
2670  * lpfc_stat_data_ctrl sysfs file. This function report the
2671  * current statistical data collection state.
2672  **/
2673 static ssize_t
2674 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
2675                          char *buf)
2676 {
2677         struct Scsi_Host  *shost = class_to_shost(dev);
2678         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2679         struct lpfc_hba   *phba = vport->phba;
2680         int index = 0;
2681         int i;
2682         char *bucket_type;
2683         unsigned long bucket_value;
2684
2685         switch (phba->bucket_type) {
2686         case LPFC_LINEAR_BUCKET:
2687                 bucket_type = "linear";
2688                 break;
2689         case LPFC_POWER2_BUCKET:
2690                 bucket_type = "power2";
2691                 break;
2692         default:
2693                 bucket_type = "No Bucket";
2694                 break;
2695         }
2696
2697         sprintf(&buf[index], "Statistical Data enabled :%d, "
2698                 "blocked :%d, Bucket type :%s, Bucket base :%d,"
2699                 " Bucket step :%d\nLatency Ranges :",
2700                 vport->stat_data_enabled, vport->stat_data_blocked,
2701                 bucket_type, phba->bucket_base, phba->bucket_step);
2702         index = strlen(buf);
2703         if (phba->bucket_type != LPFC_NO_BUCKET) {
2704                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
2705                         if (phba->bucket_type == LPFC_LINEAR_BUCKET)
2706                                 bucket_value = phba->bucket_base +
2707                                         phba->bucket_step * i;
2708                         else
2709                                 bucket_value = phba->bucket_base +
2710                                 (1 << i) * phba->bucket_step;
2711
2712                         if (index + 10 > PAGE_SIZE)
2713                                 break;
2714                         sprintf(&buf[index], "%08ld ", bucket_value);
2715                         index = strlen(buf);
2716                 }
2717         }
2718         sprintf(&buf[index], "\n");
2719         return strlen(buf);
2720 }
2721
2722 /*
2723  * Sysfs attribute to control the statistical data collection.
2724  */
2725 static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR,
2726                    lpfc_stat_data_ctrl_show, lpfc_stat_data_ctrl_store);
2727
2728 /*
2729  * lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
2730  */
2731
2732 /*
2733  * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
2734  * for each target.
2735  */
2736 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
2737 #define MAX_STAT_DATA_SIZE_PER_TARGET \
2738         STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
2739
2740
2741 /**
2742  * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
2743  * @filp: sysfs file
2744  * @kobj: Pointer to the kernel object
2745  * @bin_attr: Attribute object
2746  * @buff: Buffer pointer
2747  * @off: File offset
2748  * @count: Buffer size
2749  *
2750  * This function is the read call back function for lpfc_drvr_stat_data
2751  * sysfs file. This function export the statistical data to user
2752  * applications.
2753  **/
2754 static ssize_t
2755 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
2756                 struct bin_attribute *bin_attr,
2757                 char *buf, loff_t off, size_t count)
2758 {
2759         struct device *dev = container_of(kobj, struct device,
2760                 kobj);
2761         struct Scsi_Host  *shost = class_to_shost(dev);
2762         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2763         struct lpfc_hba   *phba = vport->phba;
2764         int i = 0, index = 0;
2765         unsigned long nport_index;
2766         struct lpfc_nodelist *ndlp = NULL;
2767         nport_index = (unsigned long)off /
2768                 MAX_STAT_DATA_SIZE_PER_TARGET;
2769
2770         if (!vport->stat_data_enabled || vport->stat_data_blocked
2771                 || (phba->bucket_type == LPFC_NO_BUCKET))
2772                 return 0;
2773
2774         spin_lock_irq(shost->host_lock);
2775         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2776                 if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data)
2777                         continue;
2778
2779                 if (nport_index > 0) {
2780                         nport_index--;
2781                         continue;
2782                 }
2783
2784                 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
2785                         > count)
2786                         break;
2787
2788                 if (!ndlp->lat_data)
2789                         continue;
2790
2791                 /* Print the WWN */
2792                 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
2793                         ndlp->nlp_portname.u.wwn[0],
2794                         ndlp->nlp_portname.u.wwn[1],
2795                         ndlp->nlp_portname.u.wwn[2],
2796                         ndlp->nlp_portname.u.wwn[3],
2797                         ndlp->nlp_portname.u.wwn[4],
2798                         ndlp->nlp_portname.u.wwn[5],
2799                         ndlp->nlp_portname.u.wwn[6],
2800                         ndlp->nlp_portname.u.wwn[7]);
2801
2802                 index = strlen(buf);
2803
2804                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
2805                         sprintf(&buf[index], "%010u,",
2806                                 ndlp->lat_data[i].cmd_count);
2807                         index = strlen(buf);
2808                 }
2809                 sprintf(&buf[index], "\n");
2810                 index = strlen(buf);
2811         }
2812         spin_unlock_irq(shost->host_lock);
2813         return index;
2814 }
2815
2816 static struct bin_attribute sysfs_drvr_stat_data_attr = {
2817         .attr = {
2818                 .name = "lpfc_drvr_stat_data",
2819                 .mode = S_IRUSR,
2820         },
2821         .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
2822         .read = sysfs_drvr_stat_data_read,
2823         .write = NULL,
2824 };
2825
2826 /*
2827 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
2828 # connection.
2829 #       0  = auto select (default)
2830 #       1  = 1 Gigabaud
2831 #       2  = 2 Gigabaud
2832 #       4  = 4 Gigabaud
2833 #       8  = 8 Gigabaud
2834 # Value range is [0,8]. Default value is 0.
2835 */
2836
2837 /**
2838  * lpfc_link_speed_set - Set the adapters link speed
2839  * @phba: lpfc_hba pointer.
2840  * @val: link speed value.
2841  *
2842  * Description:
2843  * If val is in a valid range then set the adapter's link speed field and
2844  * issue a lip; if the lip fails reset the link speed to the old value.
2845  *
2846  * Notes:
2847  * If the value is not in range log a kernel error message and return an error.
2848  *
2849  * Returns:
2850  * zero if val is in range and lip okay.
2851  * non-zero return value from lpfc_issue_lip()
2852  * -EINVAL val out of range
2853  **/
2854 static ssize_t
2855 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
2856                 const char *buf, size_t count)
2857 {
2858         struct Scsi_Host  *shost = class_to_shost(dev);
2859         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2860         struct lpfc_hba   *phba = vport->phba;
2861         int val = 0;
2862         int nolip = 0;
2863         const char *val_buf = buf;
2864         int err;
2865         uint32_t prev_val;
2866
2867         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
2868                 nolip = 1;
2869                 val_buf = &buf[strlen("nolip ")];
2870         }
2871
2872         if (!isdigit(val_buf[0]))
2873                 return -EINVAL;
2874         if (sscanf(val_buf, "%i", &val) != 1)
2875                 return -EINVAL;
2876
2877         if (((val == LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
2878                 ((val == LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
2879                 ((val == LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
2880                 ((val == LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
2881                 ((val == LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)))
2882                 return -EINVAL;
2883
2884         if ((val >= 0 && val <= 8)
2885                 && (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
2886                 prev_val = phba->cfg_link_speed;
2887                 phba->cfg_link_speed = val;
2888                 if (nolip)
2889                         return strlen(buf);
2890
2891                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
2892                 if (err) {
2893                         phba->cfg_link_speed = prev_val;
2894                         return -EINVAL;
2895                 } else
2896                         return strlen(buf);
2897         }
2898
2899         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2900                 "%d:0469 lpfc_link_speed attribute cannot be set to %d, "
2901                 "allowed range is [0, 8]\n",
2902                 phba->brd_no, val);
2903         return -EINVAL;
2904 }
2905
2906 static int lpfc_link_speed = 0;
2907 module_param(lpfc_link_speed, int, 0);
2908 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
2909 lpfc_param_show(link_speed)
2910
2911 /**
2912  * lpfc_link_speed_init - Set the adapters link speed
2913  * @phba: lpfc_hba pointer.
2914  * @val: link speed value.
2915  *
2916  * Description:
2917  * If val is in a valid range then set the adapter's link speed field.
2918  *
2919  * Notes:
2920  * If the value is not in range log a kernel error message, clear the link
2921  * speed and return an error.
2922  *
2923  * Returns:
2924  * zero if val saved.
2925  * -EINVAL val out of range
2926  **/
2927 static int
2928 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
2929 {
2930         if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED)
2931                 && (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
2932                 phba->cfg_link_speed = val;
2933                 return 0;
2934         }
2935         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2936                         "0405 lpfc_link_speed attribute cannot "
2937                         "be set to %d, allowed values are "
2938                         "["LPFC_LINK_SPEED_STRING"]\n", val);
2939         phba->cfg_link_speed = 0;
2940         return -EINVAL;
2941 }
2942
2943 static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
2944                 lpfc_link_speed_show, lpfc_link_speed_store);
2945
2946 /*
2947 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
2948 #       0  = aer disabled or not supported
2949 #       1  = aer supported and enabled (default)
2950 # Value range is [0,1]. Default value is 1.
2951 */
2952
2953 /**
2954  * lpfc_aer_support_store - Set the adapter for aer support
2955  *
2956  * @dev: class device that is converted into a Scsi_host.
2957  * @attr: device attribute, not used.
2958  * @buf: containing the string "selective".
2959  * @count: unused variable.
2960  *
2961  * Description:
2962  * If the val is 1 and currently the device's AER capability was not
2963  * enabled, invoke the kernel's enable AER helper routine, trying to
2964  * enable the device's AER capability. If the helper routine enabling
2965  * AER returns success, update the device's cfg_aer_support flag to
2966  * indicate AER is supported by the device; otherwise, if the device
2967  * AER capability is already enabled to support AER, then do nothing.
2968  *
2969  * If the val is 0 and currently the device's AER support was enabled,
2970  * invoke the kernel's disable AER helper routine. After that, update
2971  * the device's cfg_aer_support flag to indicate AER is not supported
2972  * by the device; otherwise, if the device AER capability is already
2973  * disabled from supporting AER, then do nothing.
2974  *
2975  * Returns:
2976  * length of the buf on success if val is in range the intended mode
2977  * is supported.
2978  * -EINVAL if val out of range or intended mode is not supported.
2979  **/
2980 static ssize_t
2981 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
2982                        const char *buf, size_t count)
2983 {
2984         struct Scsi_Host *shost = class_to_shost(dev);
2985         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
2986         struct lpfc_hba *phba = vport->phba;
2987         int val = 0, rc = -EINVAL;
2988
2989         if (!isdigit(buf[0]))
2990                 return -EINVAL;
2991         if (sscanf(buf, "%i", &val) != 1)
2992                 return -EINVAL;
2993
2994         switch (val) {
2995         case 0:
2996                 if (phba->hba_flag & HBA_AER_ENABLED) {
2997                         rc = pci_disable_pcie_error_reporting(phba->pcidev);
2998                         if (!rc) {
2999                                 spin_lock_irq(&phba->hbalock);
3000                                 phba->hba_flag &= ~HBA_AER_ENABLED;
3001                                 spin_unlock_irq(&phba->hbalock);
3002                                 phba->cfg_aer_support = 0;
3003                                 rc = strlen(buf);
3004                         } else
3005                                 rc = -EPERM;
3006                 } else {
3007                         phba->cfg_aer_support = 0;
3008                         rc = strlen(buf);
3009                 }
3010                 break;
3011         case 1:
3012                 if (!(phba->hba_flag & HBA_AER_ENABLED)) {
3013                         rc = pci_enable_pcie_error_reporting(phba->pcidev);
3014                         if (!rc) {
3015                                 spin_lock_irq(&phba->hbalock);
3016                                 phba->hba_flag |= HBA_AER_ENABLED;
3017                                 spin_unlock_irq(&phba->hbalock);
3018                                 phba->cfg_aer_support = 1;
3019                                 rc = strlen(buf);
3020                         } else
3021                                  rc = -EPERM;
3022                 } else {
3023                         phba->cfg_aer_support = 1;
3024                         rc = strlen(buf);
3025                 }
3026                 break;
3027         default:
3028                 rc = -EINVAL;
3029                 break;
3030         }
3031         return rc;
3032 }
3033
3034 static int lpfc_aer_support = 1;
3035 module_param(lpfc_aer_support, int, 1);
3036 MODULE_PARM_DESC(lpfc_aer_support, "Enable PCIe device AER support");
3037 lpfc_param_show(aer_support)
3038
3039 /**
3040  * lpfc_aer_support_init - Set the initial adapters aer support flag
3041  * @phba: lpfc_hba pointer.
3042  * @val: link speed value.
3043  *
3044  * Description:
3045  * If val is in a valid range [0,1], then set the adapter's initial
3046  * cfg_aer_support field. It will be up to the driver's probe_one
3047  * routine to determine whether the device's AER support can be set
3048  * or not.
3049  *
3050  * Notes:
3051  * If the value is not in range log a kernel error message, and
3052  * choose the default value of setting AER support and return.
3053  *
3054  * Returns:
3055  * zero if val saved.
3056  * -EINVAL val out of range
3057  **/
3058 static int
3059 lpfc_aer_support_init(struct lpfc_hba *phba, int val)
3060 {
3061         if (val == 0 || val == 1) {
3062                 phba->cfg_aer_support = val;
3063                 return 0;
3064         }
3065         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3066                         "2712 lpfc_aer_support attribute value %d out "
3067                         "of range, allowed values are 0|1, setting it "
3068                         "to default value of 1\n", val);
3069         /* By default, try to enable AER on a device */
3070         phba->cfg_aer_support = 1;
3071         return -EINVAL;
3072 }
3073
3074 static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR,
3075                    lpfc_aer_support_show, lpfc_aer_support_store);
3076
3077 /**
3078  * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
3079  * @dev: class device that is converted into a Scsi_host.
3080  * @attr: device attribute, not used.
3081  * @buf: containing the string "selective".
3082  * @count: unused variable.
3083  *
3084  * Description:
3085  * If the @buf contains 1 and the device currently has the AER support
3086  * enabled, then invokes the kernel AER helper routine
3087  * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
3088  * error status register.
3089  *
3090  * Notes:
3091  *
3092  * Returns:
3093  * -EINVAL if the buf does not contain the 1 or the device is not currently
3094  * enabled with the AER support.
3095  **/
3096 static ssize_t
3097 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
3098                        const char *buf, size_t count)
3099 {
3100         struct Scsi_Host  *shost = class_to_shost(dev);
3101         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3102         struct lpfc_hba   *phba = vport->phba;
3103         int val, rc = -1;
3104
3105         if (!isdigit(buf[0]))
3106                 return -EINVAL;
3107         if (sscanf(buf, "%i", &val) != 1)
3108                 return -EINVAL;
3109         if (val != 1)
3110                 return -EINVAL;
3111
3112         if (phba->hba_flag & HBA_AER_ENABLED)
3113                 rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);
3114
3115         if (rc == 0)
3116                 return strlen(buf);
3117         else
3118                 return -EPERM;
3119 }
3120
3121 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
3122                    lpfc_aer_cleanup_state);
3123
3124 /*
3125 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
3126 # Value range is [2,3]. Default value is 3.
3127 */
3128 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
3129                   "Select Fibre Channel class of service for FCP sequences");
3130
3131 /*
3132 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
3133 # is [0,1]. Default value is 0.
3134 */
3135 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
3136                    "Use ADISC on rediscovery to authenticate FCP devices");
3137
3138 /*
3139 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
3140 # depth. Default value is 0. When the value of this parameter is zero the
3141 # SCSI command completion time is not used for controlling I/O queue depth. When
3142 # the parameter is set to a non-zero value, the I/O queue depth is controlled
3143 # to limit the I/O completion time to the parameter value.
3144 # The value is set in milliseconds.
3145 */
3146 static int lpfc_max_scsicmpl_time;
3147 module_param(lpfc_max_scsicmpl_time, int, 0);
3148 MODULE_PARM_DESC(lpfc_max_scsicmpl_time,
3149         "Use command completion time to control queue depth");
3150 lpfc_vport_param_show(max_scsicmpl_time);
3151 lpfc_vport_param_init(max_scsicmpl_time, 0, 0, 60000);
3152 static int
3153 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
3154 {
3155         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3156         struct lpfc_nodelist *ndlp, *next_ndlp;
3157
3158         if (val == vport->cfg_max_scsicmpl_time)
3159                 return 0;
3160         if ((val < 0) || (val > 60000))
3161                 return -EINVAL;
3162         vport->cfg_max_scsicmpl_time = val;
3163
3164         spin_lock_irq(shost->host_lock);
3165         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
3166                 if (!NLP_CHK_NODE_ACT(ndlp))
3167                         continue;
3168                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
3169                         continue;
3170                 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
3171         }
3172         spin_unlock_irq(shost->host_lock);
3173         return 0;
3174 }
3175 lpfc_vport_param_store(max_scsicmpl_time);
3176 static DEVICE_ATTR(lpfc_max_scsicmpl_time, S_IRUGO | S_IWUSR,
3177                    lpfc_max_scsicmpl_time_show,
3178                    lpfc_max_scsicmpl_time_store);
3179
3180 /*
3181 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
3182 # range is [0,1]. Default value is 0.
3183 */
3184 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
3185
3186 /*
3187 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
3188 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
3189 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
3190 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
3191 # cr_delay is set to 0.
3192 */
3193 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
3194                 "interrupt response is generated");
3195
3196 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
3197                 "interrupt response is generated");
3198
3199 /*
3200 # lpfc_multi_ring_support:  Determines how many rings to spread available
3201 # cmd/rsp IOCB entries across.
3202 # Value range is [1,2]. Default value is 1.
3203 */
3204 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
3205                 "SLI rings to spread IOCB entries across");
3206
3207 /*
3208 # lpfc_multi_ring_rctl:  If lpfc_multi_ring_support is enabled, this
3209 # identifies what rctl value to configure the additional ring for.
3210 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
3211 */
3212 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
3213              255, "Identifies RCTL for additional ring configuration");
3214
3215 /*
3216 # lpfc_multi_ring_type:  If lpfc_multi_ring_support is enabled, this
3217 # identifies what type value to configure the additional ring for.
3218 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
3219 */
3220 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
3221              255, "Identifies TYPE for additional ring configuration");
3222
3223 /*
3224 # lpfc_fdmi_on: controls FDMI support.
3225 #       0 = no FDMI support
3226 #       1 = support FDMI without attribute of hostname
3227 #       2 = support FDMI with attribute of hostname
3228 # Value range [0,2]. Default value is 0.
3229 */
3230 LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support");
3231
3232 /*
3233 # Specifies the maximum number of ELS cmds we can have outstanding (for
3234 # discovery). Value range is [1,64]. Default value = 32.
3235 */
3236 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
3237                  "during discovery");
3238
3239 /*
3240 # lpfc_max_luns: maximum allowed LUN.
3241 # Value range is [0,65535]. Default value is 255.
3242 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
3243 */
3244 LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN");
3245
3246 /*
3247 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
3248 # Value range is [1,255], default value is 10.
3249 */
3250 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
3251              "Milliseconds driver will wait between polling FCP ring");
3252
3253 /*
3254 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
3255 #               support this feature
3256 #       0  = MSI disabled
3257 #       1  = MSI enabled
3258 #       2  = MSI-X enabled (default)
3259 # Value range is [0,2]. Default value is 2.
3260 */
3261 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
3262             "MSI-X (2), if possible");
3263
3264 /*
3265 # lpfc_fcp_imax: Set the maximum number of fast-path FCP interrupts per second
3266 #
3267 # Value range is [636,651042]. Default value is 10000.
3268 */
3269 LPFC_ATTR_R(fcp_imax, LPFC_FP_DEF_IMAX, LPFC_MIM_IMAX, LPFC_DMULT_CONST,