[SCSI] lpfc 8.3.24: Extend BSG infrastructure and add link diagnostics
[linux-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-2011 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 /**
56  * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
57  * @incr: integer to convert.
58  * @hdw: ascii string holding converted integer plus a string terminator.
59  *
60  * Description:
61  * JEDEC Joint Electron Device Engineering Council.
62  * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
63  * character string. The string is then terminated with a NULL in byte 9.
64  * Hex 0-9 becomes ascii '0' to '9'.
65  * Hex a-f becomes ascii '=' to 'B' capital B.
66  *
67  * Notes:
68  * Coded for 32 bit integers only.
69  **/
70 static void
71 lpfc_jedec_to_ascii(int incr, char hdw[])
72 {
73         int i, j;
74         for (i = 0; i < 8; i++) {
75                 j = (incr & 0xf);
76                 if (j <= 9)
77                         hdw[7 - i] = 0x30 +  j;
78                  else
79                         hdw[7 - i] = 0x61 + j - 10;
80                 incr = (incr >> 4);
81         }
82         hdw[8] = 0;
83         return;
84 }
85
86 /**
87  * lpfc_drvr_version_show - Return the Emulex driver string with version number
88  * @dev: class unused variable.
89  * @attr: device attribute, not used.
90  * @buf: on return contains the module description text.
91  *
92  * Returns: size of formatted string.
93  **/
94 static ssize_t
95 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
96                        char *buf)
97 {
98         return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
99 }
100
101 /**
102  * lpfc_enable_fip_show - Return the fip mode of the HBA
103  * @dev: class unused variable.
104  * @attr: device attribute, not used.
105  * @buf: on return contains the module description text.
106  *
107  * Returns: size of formatted string.
108  **/
109 static ssize_t
110 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
111                        char *buf)
112 {
113         struct Scsi_Host *shost = class_to_shost(dev);
114         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
115         struct lpfc_hba   *phba = vport->phba;
116
117         if (phba->hba_flag & HBA_FIP_SUPPORT)
118                 return snprintf(buf, PAGE_SIZE, "1\n");
119         else
120                 return snprintf(buf, PAGE_SIZE, "0\n");
121 }
122
123 static ssize_t
124 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
125                   char *buf)
126 {
127         struct Scsi_Host *shost = class_to_shost(dev);
128         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
129         struct lpfc_hba   *phba = vport->phba;
130
131         if (phba->cfg_enable_bg)
132                 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
133                         return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n");
134                 else
135                         return snprintf(buf, PAGE_SIZE,
136                                         "BlockGuard Not Supported\n");
137         else
138                         return snprintf(buf, PAGE_SIZE,
139                                         "BlockGuard Disabled\n");
140 }
141
142 static ssize_t
143 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
144                        char *buf)
145 {
146         struct Scsi_Host *shost = class_to_shost(dev);
147         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
148         struct lpfc_hba   *phba = vport->phba;
149
150         return snprintf(buf, PAGE_SIZE, "%llu\n",
151                         (unsigned long long)phba->bg_guard_err_cnt);
152 }
153
154 static ssize_t
155 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
156                         char *buf)
157 {
158         struct Scsi_Host *shost = class_to_shost(dev);
159         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
160         struct lpfc_hba   *phba = vport->phba;
161
162         return snprintf(buf, PAGE_SIZE, "%llu\n",
163                         (unsigned long long)phba->bg_apptag_err_cnt);
164 }
165
166 static ssize_t
167 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
168                         char *buf)
169 {
170         struct Scsi_Host *shost = class_to_shost(dev);
171         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
172         struct lpfc_hba   *phba = vport->phba;
173
174         return snprintf(buf, PAGE_SIZE, "%llu\n",
175                         (unsigned long long)phba->bg_reftag_err_cnt);
176 }
177
178 /**
179  * lpfc_info_show - Return some pci info about the host in ascii
180  * @dev: class converted to a Scsi_host structure.
181  * @attr: device attribute, not used.
182  * @buf: on return contains the formatted text from lpfc_info().
183  *
184  * Returns: size of formatted string.
185  **/
186 static ssize_t
187 lpfc_info_show(struct device *dev, struct device_attribute *attr,
188                char *buf)
189 {
190         struct Scsi_Host *host = class_to_shost(dev);
191
192         return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
193 }
194
195 /**
196  * lpfc_serialnum_show - Return the hba serial number in ascii
197  * @dev: class converted to a Scsi_host structure.
198  * @attr: device attribute, not used.
199  * @buf: on return contains the formatted text serial number.
200  *
201  * Returns: size of formatted string.
202  **/
203 static ssize_t
204 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
205                     char *buf)
206 {
207         struct Scsi_Host  *shost = class_to_shost(dev);
208         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
209         struct lpfc_hba   *phba = vport->phba;
210
211         return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
212 }
213
214 /**
215  * lpfc_temp_sensor_show - Return the temperature sensor level
216  * @dev: class converted to a Scsi_host structure.
217  * @attr: device attribute, not used.
218  * @buf: on return contains the formatted support level.
219  *
220  * Description:
221  * Returns a number indicating the temperature sensor level currently
222  * supported, zero or one in ascii.
223  *
224  * Returns: size of formatted string.
225  **/
226 static ssize_t
227 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
228                       char *buf)
229 {
230         struct Scsi_Host *shost = class_to_shost(dev);
231         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
232         struct lpfc_hba   *phba = vport->phba;
233         return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
234 }
235
236 /**
237  * lpfc_modeldesc_show - Return the model description of the hba
238  * @dev: class converted to a Scsi_host structure.
239  * @attr: device attribute, not used.
240  * @buf: on return contains the scsi vpd model description.
241  *
242  * Returns: size of formatted string.
243  **/
244 static ssize_t
245 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
246                     char *buf)
247 {
248         struct Scsi_Host  *shost = class_to_shost(dev);
249         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
250         struct lpfc_hba   *phba = vport->phba;
251
252         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
253 }
254
255 /**
256  * lpfc_modelname_show - Return the model name of the hba
257  * @dev: class converted to a Scsi_host structure.
258  * @attr: device attribute, not used.
259  * @buf: on return contains the scsi vpd model name.
260  *
261  * Returns: size of formatted string.
262  **/
263 static ssize_t
264 lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
265                     char *buf)
266 {
267         struct Scsi_Host  *shost = class_to_shost(dev);
268         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
269         struct lpfc_hba   *phba = vport->phba;
270
271         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
272 }
273
274 /**
275  * lpfc_programtype_show - Return the program type of the hba
276  * @dev: class converted to a Scsi_host structure.
277  * @attr: device attribute, not used.
278  * @buf: on return contains the scsi vpd program type.
279  *
280  * Returns: size of formatted string.
281  **/
282 static ssize_t
283 lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
284                       char *buf)
285 {
286         struct Scsi_Host  *shost = class_to_shost(dev);
287         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
288         struct lpfc_hba   *phba = vport->phba;
289
290         return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
291 }
292
293 /**
294  * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
295  * @dev: class converted to a Scsi_host structure.
296  * @attr: device attribute, not used.
297  * @buf: on return contains the Menlo Maintenance sli flag.
298  *
299  * Returns: size of formatted string.
300  **/
301 static ssize_t
302 lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
303 {
304         struct Scsi_Host  *shost = class_to_shost(dev);
305         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
306         struct lpfc_hba   *phba = vport->phba;
307
308         return snprintf(buf, PAGE_SIZE, "%d\n",
309                 (phba->sli.sli_flag & LPFC_MENLO_MAINT));
310 }
311
312 /**
313  * lpfc_vportnum_show - Return the port number in ascii of the hba
314  * @dev: class converted to a Scsi_host structure.
315  * @attr: device attribute, not used.
316  * @buf: on return contains scsi vpd program type.
317  *
318  * Returns: size of formatted string.
319  **/
320 static ssize_t
321 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
322                    char *buf)
323 {
324         struct Scsi_Host  *shost = class_to_shost(dev);
325         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
326         struct lpfc_hba   *phba = vport->phba;
327
328         return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
329 }
330
331 /**
332  * lpfc_fwrev_show - Return the firmware rev running in the hba
333  * @dev: class converted to a Scsi_host structure.
334  * @attr: device attribute, not used.
335  * @buf: on return contains the scsi vpd program type.
336  *
337  * Returns: size of formatted string.
338  **/
339 static ssize_t
340 lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
341                 char *buf)
342 {
343         struct Scsi_Host  *shost = class_to_shost(dev);
344         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
345         struct lpfc_hba   *phba = vport->phba;
346         char fwrev[32];
347
348         lpfc_decode_firmware_rev(phba, fwrev, 1);
349         return snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", fwrev, phba->sli_rev);
350 }
351
352 /**
353  * lpfc_hdw_show - Return the jedec information about the hba
354  * @dev: class converted to a Scsi_host structure.
355  * @attr: device attribute, not used.
356  * @buf: on return contains the scsi vpd program type.
357  *
358  * Returns: size of formatted string.
359  **/
360 static ssize_t
361 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
362 {
363         char hdw[9];
364         struct Scsi_Host  *shost = class_to_shost(dev);
365         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
366         struct lpfc_hba   *phba = vport->phba;
367         lpfc_vpd_t *vp = &phba->vpd;
368
369         lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
370         return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
371 }
372
373 /**
374  * lpfc_option_rom_version_show - Return the adapter ROM FCode version
375  * @dev: class converted to a Scsi_host structure.
376  * @attr: device attribute, not used.
377  * @buf: on return contains the ROM and FCode ascii strings.
378  *
379  * Returns: size of formatted string.
380  **/
381 static ssize_t
382 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
383                              char *buf)
384 {
385         struct Scsi_Host  *shost = class_to_shost(dev);
386         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
387         struct lpfc_hba   *phba = vport->phba;
388
389         return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
390 }
391
392 /**
393  * lpfc_state_show - Return the link state of the port
394  * @dev: class converted to a Scsi_host structure.
395  * @attr: device attribute, not used.
396  * @buf: on return contains text describing the state of the link.
397  *
398  * Notes:
399  * The switch statement has no default so zero will be returned.
400  *
401  * Returns: size of formatted string.
402  **/
403 static ssize_t
404 lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
405                      char *buf)
406 {
407         struct Scsi_Host  *shost = class_to_shost(dev);
408         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
409         struct lpfc_hba   *phba = vport->phba;
410         int  len = 0;
411
412         switch (phba->link_state) {
413         case LPFC_LINK_UNKNOWN:
414         case LPFC_WARM_START:
415         case LPFC_INIT_START:
416         case LPFC_INIT_MBX_CMDS:
417         case LPFC_LINK_DOWN:
418         case LPFC_HBA_ERROR:
419                 if (phba->hba_flag & LINK_DISABLED)
420                         len += snprintf(buf + len, PAGE_SIZE-len,
421                                 "Link Down - User disabled\n");
422                 else
423                         len += snprintf(buf + len, PAGE_SIZE-len,
424                                 "Link Down\n");
425                 break;
426         case LPFC_LINK_UP:
427         case LPFC_CLEAR_LA:
428         case LPFC_HBA_READY:
429                 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
430
431                 switch (vport->port_state) {
432                 case LPFC_LOCAL_CFG_LINK:
433                         len += snprintf(buf + len, PAGE_SIZE-len,
434                                         "Configuring Link\n");
435                         break;
436                 case LPFC_FDISC:
437                 case LPFC_FLOGI:
438                 case LPFC_FABRIC_CFG_LINK:
439                 case LPFC_NS_REG:
440                 case LPFC_NS_QRY:
441                 case LPFC_BUILD_DISC_LIST:
442                 case LPFC_DISC_AUTH:
443                         len += snprintf(buf + len, PAGE_SIZE - len,
444                                         "Discovery\n");
445                         break;
446                 case LPFC_VPORT_READY:
447                         len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
448                         break;
449
450                 case LPFC_VPORT_FAILED:
451                         len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
452                         break;
453
454                 case LPFC_VPORT_UNKNOWN:
455                         len += snprintf(buf + len, PAGE_SIZE - len,
456                                         "Unknown\n");
457                         break;
458                 }
459                 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
460                         len += snprintf(buf + len, PAGE_SIZE-len,
461                                         "   Menlo Maint Mode\n");
462                 else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
463                         if (vport->fc_flag & FC_PUBLIC_LOOP)
464                                 len += snprintf(buf + len, PAGE_SIZE-len,
465                                                 "   Public Loop\n");
466                         else
467                                 len += snprintf(buf + len, PAGE_SIZE-len,
468                                                 "   Private Loop\n");
469                 } else {
470                         if (vport->fc_flag & FC_FABRIC)
471                                 len += snprintf(buf + len, PAGE_SIZE-len,
472                                                 "   Fabric\n");
473                         else
474                                 len += snprintf(buf + len, PAGE_SIZE-len,
475                                                 "   Point-2-Point\n");
476                 }
477         }
478
479         return len;
480 }
481
482 /**
483  * lpfc_link_state_store - Transition the link_state on an HBA port
484  * @dev: class device that is converted into a Scsi_host.
485  * @attr: device attribute, not used.
486  * @buf: one or more lpfc_polling_flags values.
487  * @count: not used.
488  *
489  * Returns:
490  * -EINVAL if the buffer is not "up" or "down"
491  * return from link state change function if non-zero
492  * length of the buf on success
493  **/
494 static ssize_t
495 lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
496                 const char *buf, size_t count)
497 {
498         struct Scsi_Host  *shost = class_to_shost(dev);
499         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
500         struct lpfc_hba   *phba = vport->phba;
501
502         int status = -EINVAL;
503
504         if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
505                         (phba->link_state == LPFC_LINK_DOWN))
506                 status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
507         else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
508                         (phba->link_state >= LPFC_LINK_UP))
509                 status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
510
511         if (status == 0)
512                 return strlen(buf);
513         else
514                 return status;
515 }
516
517 /**
518  * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
519  * @dev: class device that is converted into a Scsi_host.
520  * @attr: device attribute, not used.
521  * @buf: on return contains the sum of fc mapped and unmapped.
522  *
523  * Description:
524  * Returns the ascii text number of the sum of the fc mapped and unmapped
525  * vport counts.
526  *
527  * Returns: size of formatted string.
528  **/
529 static ssize_t
530 lpfc_num_discovered_ports_show(struct device *dev,
531                                struct device_attribute *attr, char *buf)
532 {
533         struct Scsi_Host  *shost = class_to_shost(dev);
534         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
535
536         return snprintf(buf, PAGE_SIZE, "%d\n",
537                         vport->fc_map_cnt + vport->fc_unmap_cnt);
538 }
539
540 /**
541  * lpfc_issue_lip - Misnomer, name carried over from long ago
542  * @shost: Scsi_Host pointer.
543  *
544  * Description:
545  * Bring the link down gracefully then re-init the link. The firmware will
546  * re-init the fiber channel interface as required. Does not issue a LIP.
547  *
548  * Returns:
549  * -EPERM port offline or management commands are being blocked
550  * -ENOMEM cannot allocate memory for the mailbox command
551  * -EIO error sending the mailbox command
552  * zero for success
553  **/
554 static int
555 lpfc_issue_lip(struct Scsi_Host *shost)
556 {
557         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
558         struct lpfc_hba   *phba = vport->phba;
559         LPFC_MBOXQ_t *pmboxq;
560         int mbxstatus = MBXERR_ERROR;
561
562         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
563             (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
564                 return -EPERM;
565
566         pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
567
568         if (!pmboxq)
569                 return -ENOMEM;
570
571         memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
572         pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
573         pmboxq->u.mb.mbxOwner = OWN_HOST;
574
575         mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
576
577         if ((mbxstatus == MBX_SUCCESS) &&
578             (pmboxq->u.mb.mbxStatus == 0 ||
579              pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
580                 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
581                 lpfc_init_link(phba, pmboxq, phba->cfg_topology,
582                                phba->cfg_link_speed);
583                 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
584                                                      phba->fc_ratov * 2);
585                 if ((mbxstatus == MBX_SUCCESS) &&
586                     (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
587                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
588                                         "2859 SLI authentication is required "
589                                         "for INIT_LINK but has not done yet\n");
590         }
591
592         lpfc_set_loopback_flag(phba);
593         if (mbxstatus != MBX_TIMEOUT)
594                 mempool_free(pmboxq, phba->mbox_mem_pool);
595
596         if (mbxstatus == MBXERR_ERROR)
597                 return -EIO;
598
599         return 0;
600 }
601
602 /**
603  * lpfc_do_offline - Issues a mailbox command to bring the link down
604  * @phba: lpfc_hba pointer.
605  * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
606  *
607  * Notes:
608  * Assumes any error from lpfc_do_offline() will be negative.
609  * Can wait up to 5 seconds for the port ring buffers count
610  * to reach zero, prints a warning if it is not zero and continues.
611  * lpfc_workq_post_event() returns a non-zero return code if call fails.
612  *
613  * Returns:
614  * -EIO error posting the event
615  * zero for success
616  **/
617 static int
618 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
619 {
620         struct completion online_compl;
621         struct lpfc_sli_ring *pring;
622         struct lpfc_sli *psli;
623         int status = 0;
624         int cnt = 0;
625         int i;
626         int rc;
627
628         init_completion(&online_compl);
629         rc = lpfc_workq_post_event(phba, &status, &online_compl,
630                               LPFC_EVT_OFFLINE_PREP);
631         if (rc == 0)
632                 return -ENOMEM;
633
634         wait_for_completion(&online_compl);
635
636         if (status != 0)
637                 return -EIO;
638
639         psli = &phba->sli;
640
641         /* Wait a little for things to settle down, but not
642          * long enough for dev loss timeout to expire.
643          */
644         for (i = 0; i < psli->num_rings; i++) {
645                 pring = &psli->ring[i];
646                 while (pring->txcmplq_cnt) {
647                         msleep(10);
648                         if (cnt++ > 500) {  /* 5 secs */
649                                 lpfc_printf_log(phba,
650                                         KERN_WARNING, LOG_INIT,
651                                         "0466 Outstanding IO when "
652                                         "bringing Adapter offline\n");
653                                 break;
654                         }
655                 }
656         }
657
658         init_completion(&online_compl);
659         rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
660         if (rc == 0)
661                 return -ENOMEM;
662
663         wait_for_completion(&online_compl);
664
665         if (status != 0)
666                 return -EIO;
667
668         return 0;
669 }
670
671 /**
672  * lpfc_selective_reset - Offline then onlines the port
673  * @phba: lpfc_hba pointer.
674  *
675  * Description:
676  * If the port is configured to allow a reset then the hba is brought
677  * offline then online.
678  *
679  * Notes:
680  * Assumes any error from lpfc_do_offline() will be negative.
681  * Do not make this function static.
682  *
683  * Returns:
684  * lpfc_do_offline() return code if not zero
685  * -EIO reset not configured or error posting the event
686  * zero for success
687  **/
688 int
689 lpfc_selective_reset(struct lpfc_hba *phba)
690 {
691         struct completion online_compl;
692         int status = 0;
693         int rc;
694
695         if (!phba->cfg_enable_hba_reset)
696                 return -EIO;
697
698         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
699
700         if (status != 0)
701                 return status;
702
703         init_completion(&online_compl);
704         rc = lpfc_workq_post_event(phba, &status, &online_compl,
705                               LPFC_EVT_ONLINE);
706         if (rc == 0)
707                 return -ENOMEM;
708
709         wait_for_completion(&online_compl);
710
711         if (status != 0)
712                 return -EIO;
713
714         return 0;
715 }
716
717 /**
718  * lpfc_issue_reset - Selectively resets an adapter
719  * @dev: class device that is converted into a Scsi_host.
720  * @attr: device attribute, not used.
721  * @buf: containing the string "selective".
722  * @count: unused variable.
723  *
724  * Description:
725  * If the buf contains the string "selective" then lpfc_selective_reset()
726  * is called to perform the reset.
727  *
728  * Notes:
729  * Assumes any error from lpfc_selective_reset() will be negative.
730  * If lpfc_selective_reset() returns zero then the length of the buffer
731  * is returned which indicates success
732  *
733  * Returns:
734  * -EINVAL if the buffer does not contain the string "selective"
735  * length of buf if lpfc-selective_reset() if the call succeeds
736  * return value of lpfc_selective_reset() if the call fails
737 **/
738 static ssize_t
739 lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
740                  const char *buf, size_t count)
741 {
742         struct Scsi_Host  *shost = class_to_shost(dev);
743         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
744         struct lpfc_hba   *phba = vport->phba;
745
746         int status = -EINVAL;
747
748         if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
749                 status = phba->lpfc_selective_reset(phba);
750
751         if (status == 0)
752                 return strlen(buf);
753         else
754                 return status;
755 }
756
757 /**
758  * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
759  * @phba: lpfc_hba pointer.
760  *
761  * Description:
762  * Request SLI4 interface type-2 device to perform a physical register set
763  * access.
764  *
765  * Returns:
766  * zero for success
767  **/
768 static ssize_t
769 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
770 {
771         struct completion online_compl;
772         uint32_t reg_val;
773         int status = 0;
774         int rc;
775
776         if (!phba->cfg_enable_hba_reset)
777                 return -EIO;
778
779         if ((phba->sli_rev < LPFC_SLI_REV4) ||
780             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
781              LPFC_SLI_INTF_IF_TYPE_2))
782                 return -EPERM;
783
784         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
785
786         if (status != 0)
787                 return status;
788
789         /* wait for the device to be quiesced before firmware reset */
790         msleep(100);
791
792         reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
793                         LPFC_CTL_PDEV_CTL_OFFSET);
794
795         if (opcode == LPFC_FW_DUMP)
796                 reg_val |= LPFC_FW_DUMP_REQUEST;
797         else if (opcode == LPFC_FW_RESET)
798                 reg_val |= LPFC_CTL_PDEV_CTL_FRST;
799         else if (opcode == LPFC_DV_RESET)
800                 reg_val |= LPFC_CTL_PDEV_CTL_DRST;
801
802         writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
803                LPFC_CTL_PDEV_CTL_OFFSET);
804         /* flush */
805         readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
806
807         /* delay driver action following IF_TYPE_2 reset */
808         msleep(100);
809
810         init_completion(&online_compl);
811         rc = lpfc_workq_post_event(phba, &status, &online_compl,
812                                    LPFC_EVT_ONLINE);
813         if (rc == 0)
814                 return -ENOMEM;
815
816         wait_for_completion(&online_compl);
817
818         if (status != 0)
819                 return -EIO;
820
821         return 0;
822 }
823
824 /**
825  * lpfc_nport_evt_cnt_show - Return the number of nport events
826  * @dev: class device that is converted into a Scsi_host.
827  * @attr: device attribute, not used.
828  * @buf: on return contains the ascii number of nport events.
829  *
830  * Returns: size of formatted string.
831  **/
832 static ssize_t
833 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
834                         char *buf)
835 {
836         struct Scsi_Host  *shost = class_to_shost(dev);
837         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
838         struct lpfc_hba   *phba = vport->phba;
839
840         return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
841 }
842
843 /**
844  * lpfc_board_mode_show - Return the state of the board
845  * @dev: class device that is converted into a Scsi_host.
846  * @attr: device attribute, not used.
847  * @buf: on return contains the state of the adapter.
848  *
849  * Returns: size of formatted string.
850  **/
851 static ssize_t
852 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
853                      char *buf)
854 {
855         struct Scsi_Host  *shost = class_to_shost(dev);
856         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
857         struct lpfc_hba   *phba = vport->phba;
858         char  * state;
859
860         if (phba->link_state == LPFC_HBA_ERROR)
861                 state = "error";
862         else if (phba->link_state == LPFC_WARM_START)
863                 state = "warm start";
864         else if (phba->link_state == LPFC_INIT_START)
865                 state = "offline";
866         else
867                 state = "online";
868
869         return snprintf(buf, PAGE_SIZE, "%s\n", state);
870 }
871
872 /**
873  * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
874  * @dev: class device that is converted into a Scsi_host.
875  * @attr: device attribute, not used.
876  * @buf: containing one of the strings "online", "offline", "warm" or "error".
877  * @count: unused variable.
878  *
879  * Returns:
880  * -EACCES if enable hba reset not enabled
881  * -EINVAL if the buffer does not contain a valid string (see above)
882  * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
883  * buf length greater than zero indicates success
884  **/
885 static ssize_t
886 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
887                       const char *buf, size_t count)
888 {
889         struct Scsi_Host  *shost = class_to_shost(dev);
890         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
891         struct lpfc_hba   *phba = vport->phba;
892         struct completion online_compl;
893         int status=0;
894         int rc;
895
896         if (!phba->cfg_enable_hba_reset)
897                 return -EACCES;
898         init_completion(&online_compl);
899
900         if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
901                 rc = lpfc_workq_post_event(phba, &status, &online_compl,
902                                       LPFC_EVT_ONLINE);
903                 if (rc == 0)
904                         return -ENOMEM;
905                 wait_for_completion(&online_compl);
906         } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
907                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
908         else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
909                 if (phba->sli_rev == LPFC_SLI_REV4)
910                         return -EINVAL;
911                 else
912                         status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
913         else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
914                 if (phba->sli_rev == LPFC_SLI_REV4)
915                         return -EINVAL;
916                 else
917                         status = lpfc_do_offline(phba, LPFC_EVT_KILL);
918         else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
919                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
920         else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
921                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
922         else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
923                 status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
924         else
925                 return -EINVAL;
926
927         if (!status)
928                 return strlen(buf);
929         else
930                 return -EIO;
931 }
932
933 /**
934  * lpfc_get_hba_info - Return various bits of informaton about the adapter
935  * @phba: pointer to the adapter structure.
936  * @mxri: max xri count.
937  * @axri: available xri count.
938  * @mrpi: max rpi count.
939  * @arpi: available rpi count.
940  * @mvpi: max vpi count.
941  * @avpi: available vpi count.
942  *
943  * Description:
944  * If an integer pointer for an count is not null then the value for the
945  * count is returned.
946  *
947  * Returns:
948  * zero on error
949  * one for success
950  **/
951 static int
952 lpfc_get_hba_info(struct lpfc_hba *phba,
953                   uint32_t *mxri, uint32_t *axri,
954                   uint32_t *mrpi, uint32_t *arpi,
955                   uint32_t *mvpi, uint32_t *avpi)
956 {
957         struct lpfc_mbx_read_config *rd_config;
958         LPFC_MBOXQ_t *pmboxq;
959         MAILBOX_t *pmb;
960         int rc = 0;
961         uint32_t max_vpi;
962
963         /*
964          * prevent udev from issuing mailbox commands until the port is
965          * configured.
966          */
967         if (phba->link_state < LPFC_LINK_DOWN ||
968             !phba->mbox_mem_pool ||
969             (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
970                 return 0;
971
972         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
973                 return 0;
974
975         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
976         if (!pmboxq)
977                 return 0;
978         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
979
980         pmb = &pmboxq->u.mb;
981         pmb->mbxCommand = MBX_READ_CONFIG;
982         pmb->mbxOwner = OWN_HOST;
983         pmboxq->context1 = NULL;
984
985         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
986                 rc = MBX_NOT_FINISHED;
987         else
988                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
989
990         if (rc != MBX_SUCCESS) {
991                 if (rc != MBX_TIMEOUT)
992                         mempool_free(pmboxq, phba->mbox_mem_pool);
993                 return 0;
994         }
995
996         if (phba->sli_rev == LPFC_SLI_REV4) {
997                 rd_config = &pmboxq->u.mqe.un.rd_config;
998                 if (mrpi)
999                         *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
1000                 if (arpi)
1001                         *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
1002                                         phba->sli4_hba.max_cfg_param.rpi_used;
1003                 if (mxri)
1004                         *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
1005                 if (axri)
1006                         *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
1007                                         phba->sli4_hba.max_cfg_param.xri_used;
1008
1009                 /* Account for differences with SLI-3.  Get vpi count from
1010                  * mailbox data and subtract one for max vpi value.
1011                  */
1012                 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
1013                         (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
1014
1015                 if (mvpi)
1016                         *mvpi = max_vpi;
1017                 if (avpi)
1018                         *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
1019         } else {
1020                 if (mrpi)
1021                         *mrpi = pmb->un.varRdConfig.max_rpi;
1022                 if (arpi)
1023                         *arpi = pmb->un.varRdConfig.avail_rpi;
1024                 if (mxri)
1025                         *mxri = pmb->un.varRdConfig.max_xri;
1026                 if (axri)
1027                         *axri = pmb->un.varRdConfig.avail_xri;
1028                 if (mvpi)
1029                         *mvpi = pmb->un.varRdConfig.max_vpi;
1030                 if (avpi)
1031                         *avpi = pmb->un.varRdConfig.avail_vpi;
1032         }
1033
1034         mempool_free(pmboxq, phba->mbox_mem_pool);
1035         return 1;
1036 }
1037
1038 /**
1039  * lpfc_max_rpi_show - Return maximum rpi
1040  * @dev: class device that is converted into a Scsi_host.
1041  * @attr: device attribute, not used.
1042  * @buf: on return contains the maximum rpi count in decimal or "Unknown".
1043  *
1044  * Description:
1045  * Calls lpfc_get_hba_info() asking for just the mrpi count.
1046  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1047  * to "Unknown" and the buffer length is returned, therefore the caller
1048  * must check for "Unknown" in the buffer to detect a failure.
1049  *
1050  * Returns: size of formatted string.
1051  **/
1052 static ssize_t
1053 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
1054                   char *buf)
1055 {
1056         struct Scsi_Host  *shost = class_to_shost(dev);
1057         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1058         struct lpfc_hba   *phba = vport->phba;
1059         uint32_t cnt;
1060
1061         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
1062                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1063         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1064 }
1065
1066 /**
1067  * lpfc_used_rpi_show - Return maximum rpi minus available rpi
1068  * @dev: class device that is converted into a Scsi_host.
1069  * @attr: device attribute, not used.
1070  * @buf: containing the used rpi count in decimal or "Unknown".
1071  *
1072  * Description:
1073  * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
1074  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1075  * to "Unknown" and the buffer length is returned, therefore the caller
1076  * must check for "Unknown" in the buffer to detect a failure.
1077  *
1078  * Returns: size of formatted string.
1079  **/
1080 static ssize_t
1081 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
1082                    char *buf)
1083 {
1084         struct Scsi_Host  *shost = class_to_shost(dev);
1085         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1086         struct lpfc_hba   *phba = vport->phba;
1087         uint32_t cnt, acnt;
1088
1089         if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
1090                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1091         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1092 }
1093
1094 /**
1095  * lpfc_max_xri_show - Return maximum xri
1096  * @dev: class device that is converted into a Scsi_host.
1097  * @attr: device attribute, not used.
1098  * @buf: on return contains the maximum xri count in decimal or "Unknown".
1099  *
1100  * Description:
1101  * Calls lpfc_get_hba_info() asking for just the mrpi count.
1102  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1103  * to "Unknown" and the buffer length is returned, therefore the caller
1104  * must check for "Unknown" in the buffer to detect a failure.
1105  *
1106  * Returns: size of formatted string.
1107  **/
1108 static ssize_t
1109 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
1110                   char *buf)
1111 {
1112         struct Scsi_Host  *shost = class_to_shost(dev);
1113         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1114         struct lpfc_hba   *phba = vport->phba;
1115         uint32_t cnt;
1116
1117         if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
1118                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1119         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1120 }
1121
1122 /**
1123  * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1124  * @dev: class device that is converted into a Scsi_host.
1125  * @attr: device attribute, not used.
1126  * @buf: on return contains the used xri count in decimal or "Unknown".
1127  *
1128  * Description:
1129  * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
1130  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1131  * to "Unknown" and the buffer length is returned, therefore the caller
1132  * must check for "Unknown" in the buffer to detect a failure.
1133  *
1134  * Returns: size of formatted string.
1135  **/
1136 static ssize_t
1137 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
1138                    char *buf)
1139 {
1140         struct Scsi_Host  *shost = class_to_shost(dev);
1141         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1142         struct lpfc_hba   *phba = vport->phba;
1143         uint32_t cnt, acnt;
1144
1145         if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
1146                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1147         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1148 }
1149
1150 /**
1151  * lpfc_max_vpi_show - Return maximum vpi
1152  * @dev: class device that is converted into a Scsi_host.
1153  * @attr: device attribute, not used.
1154  * @buf: on return contains the maximum vpi count in decimal or "Unknown".
1155  *
1156  * Description:
1157  * Calls lpfc_get_hba_info() asking for just the mvpi count.
1158  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1159  * to "Unknown" and the buffer length is returned, therefore the caller
1160  * must check for "Unknown" in the buffer to detect a failure.
1161  *
1162  * Returns: size of formatted string.
1163  **/
1164 static ssize_t
1165 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
1166                   char *buf)
1167 {
1168         struct Scsi_Host  *shost = class_to_shost(dev);
1169         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1170         struct lpfc_hba   *phba = vport->phba;
1171         uint32_t cnt;
1172
1173         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
1174                 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1175         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1176 }
1177
1178 /**
1179  * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1180  * @dev: class device that is converted into a Scsi_host.
1181  * @attr: device attribute, not used.
1182  * @buf: on return contains the used vpi count in decimal or "Unknown".
1183  *
1184  * Description:
1185  * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
1186  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1187  * to "Unknown" and the buffer length is returned, therefore the caller
1188  * must check for "Unknown" in the buffer to detect a failure.
1189  *
1190  * Returns: size of formatted string.
1191  **/
1192 static ssize_t
1193 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
1194                    char *buf)
1195 {
1196         struct Scsi_Host  *shost = class_to_shost(dev);
1197         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1198         struct lpfc_hba   *phba = vport->phba;
1199         uint32_t cnt, acnt;
1200
1201         if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
1202                 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1203         return snprintf(buf, PAGE_SIZE, "Unknown\n");
1204 }
1205
1206 /**
1207  * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1208  * @dev: class device that is converted into a Scsi_host.
1209  * @attr: device attribute, not used.
1210  * @buf: text that must be interpreted to determine if npiv is supported.
1211  *
1212  * Description:
1213  * Buffer will contain text indicating npiv is not suppoerted on the port,
1214  * the port is an NPIV physical port, or it is an npiv virtual port with
1215  * the id of the vport.
1216  *
1217  * Returns: size of formatted string.
1218  **/
1219 static ssize_t
1220 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
1221                     char *buf)
1222 {
1223         struct Scsi_Host  *shost = class_to_shost(dev);
1224         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1225         struct lpfc_hba   *phba = vport->phba;
1226
1227         if (!(phba->max_vpi))
1228                 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
1229         if (vport->port_type == LPFC_PHYSICAL_PORT)
1230                 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
1231         return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
1232 }
1233
1234 /**
1235  * lpfc_poll_show - Return text about poll support for the adapter
1236  * @dev: class device that is converted into a Scsi_host.
1237  * @attr: device attribute, not used.
1238  * @buf: on return contains the cfg_poll in hex.
1239  *
1240  * Notes:
1241  * cfg_poll should be a lpfc_polling_flags type.
1242  *
1243  * Returns: size of formatted string.
1244  **/
1245 static ssize_t
1246 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
1247                char *buf)
1248 {
1249         struct Scsi_Host  *shost = class_to_shost(dev);
1250         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1251         struct lpfc_hba   *phba = vport->phba;
1252
1253         return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
1254 }
1255
1256 /**
1257  * lpfc_poll_store - Set the value of cfg_poll for the adapter
1258  * @dev: class device that is converted into a Scsi_host.
1259  * @attr: device attribute, not used.
1260  * @buf: one or more lpfc_polling_flags values.
1261  * @count: not used.
1262  *
1263  * Notes:
1264  * buf contents converted to integer and checked for a valid value.
1265  *
1266  * Returns:
1267  * -EINVAL if the buffer connot be converted or is out of range
1268  * length of the buf on success
1269  **/
1270 static ssize_t
1271 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
1272                 const char *buf, size_t count)
1273 {
1274         struct Scsi_Host  *shost = class_to_shost(dev);
1275         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1276         struct lpfc_hba   *phba = vport->phba;
1277         uint32_t creg_val;
1278         uint32_t old_val;
1279         int val=0;
1280
1281         if (!isdigit(buf[0]))
1282                 return -EINVAL;
1283
1284         if (sscanf(buf, "%i", &val) != 1)
1285                 return -EINVAL;
1286
1287         if ((val & 0x3) != val)
1288                 return -EINVAL;
1289
1290         if (phba->sli_rev == LPFC_SLI_REV4)
1291                 val = 0;
1292
1293         spin_lock_irq(&phba->hbalock);
1294
1295         old_val = phba->cfg_poll;
1296
1297         if (val & ENABLE_FCP_RING_POLLING) {
1298                 if ((val & DISABLE_FCP_RING_INT) &&
1299                     !(old_val & DISABLE_FCP_RING_INT)) {
1300                         if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1301                                 spin_unlock_irq(&phba->hbalock);
1302                                 return -EINVAL;
1303                         }
1304                         creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
1305                         writel(creg_val, phba->HCregaddr);
1306                         readl(phba->HCregaddr); /* flush */
1307
1308                         lpfc_poll_start_timer(phba);
1309                 }
1310         } else if (val != 0x0) {
1311                 spin_unlock_irq(&phba->hbalock);
1312                 return -EINVAL;
1313         }
1314
1315         if (!(val & DISABLE_FCP_RING_INT) &&
1316             (old_val & DISABLE_FCP_RING_INT))
1317         {
1318                 spin_unlock_irq(&phba->hbalock);
1319                 del_timer(&phba->fcp_poll_timer);
1320                 spin_lock_irq(&phba->hbalock);
1321                 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1322                         spin_unlock_irq(&phba->hbalock);
1323                         return -EINVAL;
1324                 }
1325                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
1326                 writel(creg_val, phba->HCregaddr);
1327                 readl(phba->HCregaddr); /* flush */
1328         }
1329
1330         phba->cfg_poll = val;
1331
1332         spin_unlock_irq(&phba->hbalock);
1333
1334         return strlen(buf);
1335 }
1336
1337 /**
1338  * lpfc_fips_level_show - Return the current FIPS level for the HBA
1339  * @dev: class unused variable.
1340  * @attr: device attribute, not used.
1341  * @buf: on return contains the module description text.
1342  *
1343  * Returns: size of formatted string.
1344  **/
1345 static ssize_t
1346 lpfc_fips_level_show(struct device *dev,  struct device_attribute *attr,
1347                      char *buf)
1348 {
1349         struct Scsi_Host  *shost = class_to_shost(dev);
1350         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1351         struct lpfc_hba   *phba = vport->phba;
1352
1353         return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
1354 }
1355
1356 /**
1357  * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
1358  * @dev: class unused variable.
1359  * @attr: device attribute, not used.
1360  * @buf: on return contains the module description text.
1361  *
1362  * Returns: size of formatted string.
1363  **/
1364 static ssize_t
1365 lpfc_fips_rev_show(struct device *dev,  struct device_attribute *attr,
1366                    char *buf)
1367 {
1368         struct Scsi_Host  *shost = class_to_shost(dev);
1369         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1370         struct lpfc_hba   *phba = vport->phba;
1371
1372         return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
1373 }
1374
1375 /**
1376  * lpfc_dss_show - Return the current state of dss and the configured state
1377  * @dev: class converted to a Scsi_host structure.
1378  * @attr: device attribute, not used.
1379  * @buf: on return contains the formatted text.
1380  *
1381  * Returns: size of formatted string.
1382  **/
1383 static ssize_t
1384 lpfc_dss_show(struct device *dev, struct device_attribute *attr,
1385               char *buf)
1386 {
1387         struct Scsi_Host *shost = class_to_shost(dev);
1388         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1389         struct lpfc_hba   *phba = vport->phba;
1390
1391         return snprintf(buf, PAGE_SIZE, "%s - %sOperational\n",
1392                         (phba->cfg_enable_dss) ? "Enabled" : "Disabled",
1393                         (phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ?
1394                                 "" : "Not ");
1395 }
1396
1397 /**
1398  * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
1399  * @dev: class converted to a Scsi_host structure.
1400  * @attr: device attribute, not used.
1401  * @buf: on return contains the formatted support level.
1402  *
1403  * Description:
1404  * Returns the maximum number of virtual functions a physical function can
1405  * support, 0 will be returned if called on virtual function.
1406  *
1407  * Returns: size of formatted string.
1408  **/
1409 static ssize_t
1410 lpfc_sriov_hw_max_virtfn_show(struct device *dev,
1411                               struct device_attribute *attr,
1412                               char *buf)
1413 {
1414         struct Scsi_Host *shost = class_to_shost(dev);
1415         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1416         struct lpfc_hba *phba = vport->phba;
1417         struct pci_dev *pdev = phba->pcidev;
1418         union  lpfc_sli4_cfg_shdr *shdr;
1419         uint32_t shdr_status, shdr_add_status;
1420         LPFC_MBOXQ_t *mboxq;
1421         struct lpfc_mbx_get_prof_cfg *get_prof_cfg;
1422         struct lpfc_rsrc_desc_pcie *desc;
1423         uint32_t max_nr_virtfn;
1424         uint32_t desc_count;
1425         int length, rc, i;
1426
1427         if ((phba->sli_rev < LPFC_SLI_REV4) ||
1428             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
1429              LPFC_SLI_INTF_IF_TYPE_2))
1430                 return -EPERM;
1431
1432         if (!pdev->is_physfn)
1433                 return snprintf(buf, PAGE_SIZE, "%d\n", 0);
1434
1435         mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1436         if (!mboxq)
1437                 return -ENOMEM;
1438
1439         /* get the maximum number of virtfn support by physfn */
1440         length = (sizeof(struct lpfc_mbx_get_prof_cfg) -
1441                   sizeof(struct lpfc_sli4_cfg_mhdr));
1442         lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
1443                          LPFC_MBOX_OPCODE_GET_PROFILE_CONFIG,
1444                          length, LPFC_SLI4_MBX_EMBED);
1445         shdr = (union lpfc_sli4_cfg_shdr *)
1446                 &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
1447         bf_set(lpfc_mbox_hdr_pf_num, &shdr->request,
1448                phba->sli4_hba.iov.pf_number + 1);
1449
1450         get_prof_cfg = &mboxq->u.mqe.un.get_prof_cfg;
1451         bf_set(lpfc_mbx_get_prof_cfg_prof_tp, &get_prof_cfg->u.request,
1452                LPFC_CFG_TYPE_CURRENT_ACTIVE);
1453
1454         rc = lpfc_sli_issue_mbox_wait(phba, mboxq,
1455                                 lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG));
1456
1457         if (rc != MBX_TIMEOUT) {
1458                 /* check return status */
1459                 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
1460                 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
1461                                          &shdr->response);
1462                 if (shdr_status || shdr_add_status || rc)
1463                         goto error_out;
1464
1465         } else
1466                 goto error_out;
1467
1468         desc_count = get_prof_cfg->u.response.prof_cfg.rsrc_desc_count;
1469
1470         for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) {
1471                 desc = (struct lpfc_rsrc_desc_pcie *)
1472                         &get_prof_cfg->u.response.prof_cfg.desc[i];
1473                 if (LPFC_RSRC_DESC_TYPE_PCIE ==
1474                     bf_get(lpfc_rsrc_desc_pcie_type, desc)) {
1475                         max_nr_virtfn = bf_get(lpfc_rsrc_desc_pcie_nr_virtfn,
1476                                                desc);
1477                         break;
1478                 }
1479         }
1480
1481         if (i < LPFC_RSRC_DESC_MAX_NUM) {
1482                 if (rc != MBX_TIMEOUT)
1483                         mempool_free(mboxq, phba->mbox_mem_pool);
1484                 return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
1485         }
1486
1487 error_out:
1488         if (rc != MBX_TIMEOUT)
1489                 mempool_free(mboxq, phba->mbox_mem_pool);
1490         return -EIO;
1491 }
1492
1493 /**
1494  * lpfc_param_show - Return a cfg attribute value in decimal
1495  *
1496  * Description:
1497  * Macro that given an attr e.g. hba_queue_depth expands
1498  * into a function with the name lpfc_hba_queue_depth_show.
1499  *
1500  * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
1501  * @dev: class device that is converted into a Scsi_host.
1502  * @attr: device attribute, not used.
1503  * @buf: on return contains the attribute value in decimal.
1504  *
1505  * Returns: size of formatted string.
1506  **/
1507 #define lpfc_param_show(attr)   \
1508 static ssize_t \
1509 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1510                    char *buf) \
1511 { \
1512         struct Scsi_Host  *shost = class_to_shost(dev);\
1513         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1514         struct lpfc_hba   *phba = vport->phba;\
1515         uint val = 0;\
1516         val = phba->cfg_##attr;\
1517         return snprintf(buf, PAGE_SIZE, "%d\n",\
1518                         phba->cfg_##attr);\
1519 }
1520
1521 /**
1522  * lpfc_param_hex_show - Return a cfg attribute value in hex
1523  *
1524  * Description:
1525  * Macro that given an attr e.g. hba_queue_depth expands
1526  * into a function with the name lpfc_hba_queue_depth_show
1527  *
1528  * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
1529  * @dev: class device that is converted into a Scsi_host.
1530  * @attr: device attribute, not used.
1531  * @buf: on return contains the attribute value in hexadecimal.
1532  *
1533  * Returns: size of formatted string.
1534  **/
1535 #define lpfc_param_hex_show(attr)       \
1536 static ssize_t \
1537 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1538                    char *buf) \
1539 { \
1540         struct Scsi_Host  *shost = class_to_shost(dev);\
1541         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1542         struct lpfc_hba   *phba = vport->phba;\
1543         uint val = 0;\
1544         val = phba->cfg_##attr;\
1545         return snprintf(buf, PAGE_SIZE, "%#x\n",\
1546                         phba->cfg_##attr);\
1547 }
1548
1549 /**
1550  * lpfc_param_init - Initializes a cfg attribute
1551  *
1552  * Description:
1553  * Macro that given an attr e.g. hba_queue_depth expands
1554  * into a function with the name lpfc_hba_queue_depth_init. The macro also
1555  * takes a default argument, a minimum and maximum argument.
1556  *
1557  * lpfc_##attr##_init: Initializes an attribute.
1558  * @phba: pointer the the adapter structure.
1559  * @val: integer attribute value.
1560  *
1561  * Validates the min and max values then sets the adapter config field
1562  * accordingly, or uses the default if out of range and prints an error message.
1563  *
1564  * Returns:
1565  * zero on success
1566  * -EINVAL if default used
1567  **/
1568 #define lpfc_param_init(attr, default, minval, maxval)  \
1569 static int \
1570 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
1571 { \
1572         if (val >= minval && val <= maxval) {\
1573                 phba->cfg_##attr = val;\
1574                 return 0;\
1575         }\
1576         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1577                         "0449 lpfc_"#attr" attribute cannot be set to %d, "\
1578                         "allowed range is ["#minval", "#maxval"]\n", val); \
1579         phba->cfg_##attr = default;\
1580         return -EINVAL;\
1581 }
1582
1583 /**
1584  * lpfc_param_set - Set a cfg attribute value
1585  *
1586  * Description:
1587  * Macro that given an attr e.g. hba_queue_depth expands
1588  * into a function with the name lpfc_hba_queue_depth_set
1589  *
1590  * lpfc_##attr##_set: Sets an attribute value.
1591  * @phba: pointer the the adapter structure.
1592  * @val: integer attribute value.
1593  *
1594  * Description:
1595  * Validates the min and max values then sets the
1596  * adapter config field if in the valid range. prints error message
1597  * and does not set the parameter if invalid.
1598  *
1599  * Returns:
1600  * zero on success
1601  * -EINVAL if val is invalid
1602  **/
1603 #define lpfc_param_set(attr, default, minval, maxval)   \
1604 static int \
1605 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
1606 { \
1607         if (val >= minval && val <= maxval) {\
1608                 phba->cfg_##attr = val;\
1609                 return 0;\
1610         }\
1611         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1612                         "0450 lpfc_"#attr" attribute cannot be set to %d, "\
1613                         "allowed range is ["#minval", "#maxval"]\n", val); \
1614         return -EINVAL;\
1615 }
1616
1617 /**
1618  * lpfc_param_store - Set a vport attribute value
1619  *
1620  * Description:
1621  * Macro that given an attr e.g. hba_queue_depth expands
1622  * into a function with the name lpfc_hba_queue_depth_store.
1623  *
1624  * lpfc_##attr##_store: Set an sttribute value.
1625  * @dev: class device that is converted into a Scsi_host.
1626  * @attr: device attribute, not used.
1627  * @buf: contains the attribute value in ascii.
1628  * @count: not used.
1629  *
1630  * Description:
1631  * Convert the ascii text number to an integer, then
1632  * use the lpfc_##attr##_set function to set the value.
1633  *
1634  * Returns:
1635  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1636  * length of buffer upon success.
1637  **/
1638 #define lpfc_param_store(attr)  \
1639 static ssize_t \
1640 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1641                     const char *buf, size_t count) \
1642 { \
1643         struct Scsi_Host  *shost = class_to_shost(dev);\
1644         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1645         struct lpfc_hba   *phba = vport->phba;\
1646         uint val = 0;\
1647         if (!isdigit(buf[0]))\
1648                 return -EINVAL;\
1649         if (sscanf(buf, "%i", &val) != 1)\
1650                 return -EINVAL;\
1651         if (lpfc_##attr##_set(phba, val) == 0) \
1652                 return strlen(buf);\
1653         else \
1654                 return -EINVAL;\
1655 }
1656
1657 /**
1658  * lpfc_vport_param_show - Return decimal formatted cfg attribute value
1659  *
1660  * Description:
1661  * Macro that given an attr e.g. hba_queue_depth expands
1662  * into a function with the name lpfc_hba_queue_depth_show
1663  *
1664  * lpfc_##attr##_show: prints the attribute value in decimal.
1665  * @dev: class device that is converted into a Scsi_host.
1666  * @attr: device attribute, not used.
1667  * @buf: on return contains the attribute value in decimal.
1668  *
1669  * Returns: length of formatted string.
1670  **/
1671 #define lpfc_vport_param_show(attr)     \
1672 static ssize_t \
1673 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1674                    char *buf) \
1675 { \
1676         struct Scsi_Host  *shost = class_to_shost(dev);\
1677         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1678         uint val = 0;\
1679         val = vport->cfg_##attr;\
1680         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
1681 }
1682
1683 /**
1684  * lpfc_vport_param_hex_show - Return hex formatted attribute value
1685  *
1686  * Description:
1687  * Macro that given an attr e.g.
1688  * hba_queue_depth expands into a function with the name
1689  * lpfc_hba_queue_depth_show
1690  *
1691  * lpfc_##attr##_show: prints the attribute value in hexadecimal.
1692  * @dev: class device that is converted into a Scsi_host.
1693  * @attr: device attribute, not used.
1694  * @buf: on return contains the attribute value in hexadecimal.
1695  *
1696  * Returns: length of formatted string.
1697  **/
1698 #define lpfc_vport_param_hex_show(attr) \
1699 static ssize_t \
1700 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1701                    char *buf) \
1702 { \
1703         struct Scsi_Host  *shost = class_to_shost(dev);\
1704         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1705         uint val = 0;\
1706         val = vport->cfg_##attr;\
1707         return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
1708 }
1709
1710 /**
1711  * lpfc_vport_param_init - Initialize a vport cfg attribute
1712  *
1713  * Description:
1714  * Macro that given an attr e.g. hba_queue_depth expands
1715  * into a function with the name lpfc_hba_queue_depth_init. The macro also
1716  * takes a default argument, a minimum and maximum argument.
1717  *
1718  * lpfc_##attr##_init: validates the min and max values then sets the
1719  * adapter config field accordingly, or uses the default if out of range
1720  * and prints an error message.
1721  * @phba: pointer the the adapter structure.
1722  * @val: integer attribute value.
1723  *
1724  * Returns:
1725  * zero on success
1726  * -EINVAL if default used
1727  **/
1728 #define lpfc_vport_param_init(attr, default, minval, maxval)    \
1729 static int \
1730 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
1731 { \
1732         if (val >= minval && val <= maxval) {\
1733                 vport->cfg_##attr = val;\
1734                 return 0;\
1735         }\
1736         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1737                          "0423 lpfc_"#attr" attribute cannot be set to %d, "\
1738                          "allowed range is ["#minval", "#maxval"]\n", val); \
1739         vport->cfg_##attr = default;\
1740         return -EINVAL;\
1741 }
1742
1743 /**
1744  * lpfc_vport_param_set - Set a vport cfg attribute
1745  *
1746  * Description:
1747  * Macro that given an attr e.g. hba_queue_depth expands
1748  * into a function with the name lpfc_hba_queue_depth_set
1749  *
1750  * lpfc_##attr##_set: validates the min and max values then sets the
1751  * adapter config field if in the valid range. prints error message
1752  * and does not set the parameter if invalid.
1753  * @phba: pointer the the adapter structure.
1754  * @val:        integer attribute value.
1755  *
1756  * Returns:
1757  * zero on success
1758  * -EINVAL if val is invalid
1759  **/
1760 #define lpfc_vport_param_set(attr, default, minval, maxval)     \
1761 static int \
1762 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
1763 { \
1764         if (val >= minval && val <= maxval) {\
1765                 vport->cfg_##attr = val;\
1766                 return 0;\
1767         }\
1768         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1769                          "0424 lpfc_"#attr" attribute cannot be set to %d, "\
1770                          "allowed range is ["#minval", "#maxval"]\n", val); \
1771         return -EINVAL;\
1772 }
1773
1774 /**
1775  * lpfc_vport_param_store - Set a vport attribute
1776  *
1777  * Description:
1778  * Macro that given an attr e.g. hba_queue_depth
1779  * expands into a function with the name lpfc_hba_queue_depth_store
1780  *
1781  * lpfc_##attr##_store: convert the ascii text number to an integer, then
1782  * use the lpfc_##attr##_set function to set the value.
1783  * @cdev: class device that is converted into a Scsi_host.
1784  * @buf:        contains the attribute value in decimal.
1785  * @count: not used.
1786  *
1787  * Returns:
1788  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1789  * length of buffer upon success.
1790  **/
1791 #define lpfc_vport_param_store(attr)    \
1792 static ssize_t \
1793 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1794                     const char *buf, size_t count) \
1795 { \
1796         struct Scsi_Host  *shost = class_to_shost(dev);\
1797         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1798         uint val = 0;\
1799         if (!isdigit(buf[0]))\
1800                 return -EINVAL;\
1801         if (sscanf(buf, "%i", &val) != 1)\
1802                 return -EINVAL;\
1803         if (lpfc_##attr##_set(vport, val) == 0) \
1804                 return strlen(buf);\
1805         else \
1806                 return -EINVAL;\
1807 }
1808
1809
1810 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
1811 static uint lpfc_##name = defval;\
1812 module_param(lpfc_##name, uint, S_IRUGO);\
1813 MODULE_PARM_DESC(lpfc_##name, desc);\
1814 lpfc_param_init(name, defval, minval, maxval)
1815
1816 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
1817 static uint lpfc_##name = defval;\
1818 module_param(lpfc_##name, uint, S_IRUGO);\
1819 MODULE_PARM_DESC(lpfc_##name, desc);\
1820 lpfc_param_show(name)\
1821 lpfc_param_init(name, defval, minval, maxval)\
1822 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1823
1824 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
1825 static uint lpfc_##name = defval;\
1826 module_param(lpfc_##name, uint, S_IRUGO);\
1827 MODULE_PARM_DESC(lpfc_##name, desc);\
1828 lpfc_param_show(name)\
1829 lpfc_param_init(name, defval, minval, maxval)\
1830 lpfc_param_set(name, defval, minval, maxval)\
1831 lpfc_param_store(name)\
1832 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1833                    lpfc_##name##_show, lpfc_##name##_store)
1834
1835 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1836 static uint lpfc_##name = defval;\
1837 module_param(lpfc_##name, uint, S_IRUGO);\
1838 MODULE_PARM_DESC(lpfc_##name, desc);\
1839 lpfc_param_hex_show(name)\
1840 lpfc_param_init(name, defval, minval, maxval)\
1841 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1842
1843 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1844 static uint lpfc_##name = defval;\
1845 module_param(lpfc_##name, uint, S_IRUGO);\
1846 MODULE_PARM_DESC(lpfc_##name, desc);\
1847 lpfc_param_hex_show(name)\
1848 lpfc_param_init(name, defval, minval, maxval)\
1849 lpfc_param_set(name, defval, minval, maxval)\
1850 lpfc_param_store(name)\
1851 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1852                    lpfc_##name##_show, lpfc_##name##_store)
1853
1854 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
1855 static uint lpfc_##name = defval;\
1856 module_param(lpfc_##name, uint, S_IRUGO);\
1857 MODULE_PARM_DESC(lpfc_##name, desc);\
1858 lpfc_vport_param_init(name, defval, minval, maxval)
1859
1860 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
1861 static uint lpfc_##name = defval;\
1862 module_param(lpfc_##name, uint, S_IRUGO);\
1863 MODULE_PARM_DESC(lpfc_##name, desc);\
1864 lpfc_vport_param_show(name)\
1865 lpfc_vport_param_init(name, defval, minval, maxval)\
1866 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1867
1868 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
1869 static uint lpfc_##name = defval;\
1870 module_param(lpfc_##name, uint, S_IRUGO);\
1871 MODULE_PARM_DESC(lpfc_##name, desc);\
1872 lpfc_vport_param_show(name)\
1873 lpfc_vport_param_init(name, defval, minval, maxval)\
1874 lpfc_vport_param_set(name, defval, minval, maxval)\
1875 lpfc_vport_param_store(name)\
1876 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1877                    lpfc_##name##_show, lpfc_##name##_store)
1878
1879 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1880 static uint lpfc_##name = defval;\
1881 module_param(lpfc_##name, uint, S_IRUGO);\
1882 MODULE_PARM_DESC(lpfc_##name, desc);\
1883 lpfc_vport_param_hex_show(name)\
1884 lpfc_vport_param_init(name, defval, minval, maxval)\
1885 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1886
1887 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1888 static uint lpfc_##name = defval;\
1889 module_param(lpfc_##name, uint, S_IRUGO);\
1890 MODULE_PARM_DESC(lpfc_##name, desc);\
1891 lpfc_vport_param_hex_show(name)\
1892 lpfc_vport_param_init(name, defval, minval, maxval)\
1893 lpfc_vport_param_set(name, defval, minval, maxval)\
1894 lpfc_vport_param_store(name)\
1895 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1896                    lpfc_##name##_show, lpfc_##name##_store)
1897
1898 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
1899 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
1900 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
1901 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
1902 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
1903 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
1904 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
1905 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
1906 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
1907 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
1908 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
1909 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
1910 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
1911                 lpfc_link_state_store);
1912 static DEVICE_ATTR(option_rom_version, S_IRUGO,
1913                    lpfc_option_rom_version_show, NULL);
1914 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
1915                    lpfc_num_discovered_ports_show, NULL);
1916 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
1917 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
1918 static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
1919 static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL);
1920 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
1921                    lpfc_board_mode_show, lpfc_board_mode_store);
1922 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
1923 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
1924 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
1925 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
1926 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
1927 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
1928 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
1929 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
1930 static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
1931 static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL);
1932 static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
1933 static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL);
1934 static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO,
1935                    lpfc_sriov_hw_max_virtfn_show, NULL);
1936
1937 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
1938
1939 /**
1940  * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
1941  * @dev: class device that is converted into a Scsi_host.
1942  * @attr: device attribute, not used.
1943  * @buf: containing the string lpfc_soft_wwn_key.
1944  * @count: must be size of lpfc_soft_wwn_key.
1945  *
1946  * Returns:
1947  * -EINVAL if the buffer does not contain lpfc_soft_wwn_key
1948  * length of buf indicates success
1949  **/
1950 static ssize_t
1951 lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
1952                            const char *buf, size_t count)
1953 {
1954         struct Scsi_Host  *shost = class_to_shost(dev);
1955         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1956         struct lpfc_hba   *phba = vport->phba;
1957         unsigned int cnt = count;
1958
1959         /*
1960          * We're doing a simple sanity check for soft_wwpn setting.
1961          * We require that the user write a specific key to enable
1962          * the soft_wwpn attribute to be settable. Once the attribute
1963          * is written, the enable key resets. If further updates are
1964          * desired, the key must be written again to re-enable the
1965          * attribute.
1966          *
1967          * The "key" is not secret - it is a hardcoded string shown
1968          * here. The intent is to protect against the random user or
1969          * application that is just writing attributes.
1970          */
1971
1972         /* count may include a LF at end of string */
1973         if (buf[cnt-1] == '\n')
1974                 cnt--;
1975
1976         if ((cnt != strlen(lpfc_soft_wwn_key)) ||
1977             (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
1978                 return -EINVAL;
1979
1980         phba->soft_wwn_enable = 1;
1981         return count;
1982 }
1983 static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
1984                    lpfc_soft_wwn_enable_store);
1985
1986 /**
1987  * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
1988  * @dev: class device that is converted into a Scsi_host.
1989  * @attr: device attribute, not used.
1990  * @buf: on return contains the wwpn in hexadecimal.
1991  *
1992  * Returns: size of formatted string.
1993  **/
1994 static ssize_t
1995 lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
1996                     char *buf)
1997 {
1998         struct Scsi_Host  *shost = class_to_shost(dev);
1999         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2000         struct lpfc_hba   *phba = vport->phba;
2001
2002         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2003                         (unsigned long long)phba->cfg_soft_wwpn);
2004 }
2005
2006 /**
2007  * lpfc_soft_wwpn_store - Set the ww port name of the adapter
2008  * @dev class device that is converted into a Scsi_host.
2009  * @attr: device attribute, not used.
2010  * @buf: contains the wwpn in hexadecimal.
2011  * @count: number of wwpn bytes in buf
2012  *
2013  * Returns:
2014  * -EACCES hba reset not enabled, adapter over temp
2015  * -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
2016  * -EIO error taking adapter offline or online
2017  * value of count on success
2018  **/
2019 static ssize_t
2020 lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
2021                      const char *buf, size_t count)
2022 {
2023         struct Scsi_Host  *shost = class_to_shost(dev);
2024         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2025         struct lpfc_hba   *phba = vport->phba;
2026         struct completion online_compl;
2027         int stat1=0, stat2=0;
2028         unsigned int i, j, cnt=count;
2029         u8 wwpn[8];
2030         int rc;
2031
2032         if (!phba->cfg_enable_hba_reset)
2033                 return -EACCES;
2034         spin_lock_irq(&phba->hbalock);
2035         if (phba->over_temp_state == HBA_OVER_TEMP) {
2036                 spin_unlock_irq(&phba->hbalock);
2037                 return -EACCES;
2038         }
2039         spin_unlock_irq(&phba->hbalock);
2040         /* count may include a LF at end of string */
2041         if (buf[cnt-1] == '\n')
2042                 cnt--;
2043
2044         if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
2045             ((cnt == 17) && (*buf++ != 'x')) ||
2046             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2047                 return -EINVAL;
2048
2049         phba->soft_wwn_enable = 0;
2050
2051         memset(wwpn, 0, sizeof(wwpn));
2052
2053         /* Validate and store the new name */
2054         for (i=0, j=0; i < 16; i++) {
2055                 int value;
2056
2057                 value = hex_to_bin(*buf++);
2058                 if (value >= 0)
2059                         j = (j << 4) | value;
2060                 else
2061                         return -EINVAL;
2062                 if (i % 2) {
2063                         wwpn[i/2] = j & 0xff;
2064                         j = 0;
2065                 }
2066         }
2067         phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
2068         fc_host_port_name(shost) = phba->cfg_soft_wwpn;
2069         if (phba->cfg_soft_wwnn)
2070                 fc_host_node_name(shost) = phba->cfg_soft_wwnn;
2071
2072         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2073                    "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
2074
2075         stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2076         if (stat1)
2077                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2078                                 "0463 lpfc_soft_wwpn attribute set failed to "
2079                                 "reinit adapter - %d\n", stat1);
2080         init_completion(&online_compl);
2081         rc = lpfc_workq_post_event(phba, &stat2, &online_compl,
2082                                    LPFC_EVT_ONLINE);
2083         if (rc == 0)
2084                 return -ENOMEM;
2085
2086         wait_for_completion(&online_compl);
2087         if (stat2)
2088                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2089                                 "0464 lpfc_soft_wwpn attribute set failed to "
2090                                 "reinit adapter - %d\n", stat2);
2091         return (stat1 || stat2) ? -EIO : count;
2092 }
2093 static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
2094                    lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
2095
2096 /**
2097  * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
2098  * @dev: class device that is converted into a Scsi_host.
2099  * @attr: device attribute, not used.
2100  * @buf: on return contains the wwnn in hexadecimal.
2101  *
2102  * Returns: size of formatted string.
2103  **/
2104 static ssize_t
2105 lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
2106                     char *buf)
2107 {
2108         struct Scsi_Host *shost = class_to_shost(dev);
2109         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2110         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2111                         (unsigned long long)phba->cfg_soft_wwnn);
2112 }
2113
2114 /**
2115  * lpfc_soft_wwnn_store - sets the ww node name of the adapter
2116  * @cdev: class device that is converted into a Scsi_host.
2117  * @buf: contains the ww node name in hexadecimal.
2118  * @count: number of wwnn bytes in buf.
2119  *
2120  * Returns:
2121  * -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
2122  * value of count on success
2123  **/
2124 static ssize_t
2125 lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
2126                      const char *buf, size_t count)
2127 {
2128         struct Scsi_Host *shost = class_to_shost(dev);
2129         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2130         unsigned int i, j, cnt=count;
2131         u8 wwnn[8];
2132
2133         /* count may include a LF at end of string */
2134         if (buf[cnt-1] == '\n')
2135                 cnt--;
2136
2137         if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
2138             ((cnt == 17) && (*buf++ != 'x')) ||
2139             ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2140                 return -EINVAL;
2141
2142         /*
2143          * Allow wwnn to be set many times, as long as the enable is set.
2144          * However, once the wwpn is set, everything locks.
2145          */
2146
2147         memset(wwnn, 0, sizeof(wwnn));
2148
2149         /* Validate and store the new name */
2150         for (i=0, j=0; i < 16; i++) {
2151                 int value;
2152
2153                 value = hex_to_bin(*buf++);
2154                 if (value >= 0)
2155                         j = (j << 4) | value;
2156                 else
2157                         return -EINVAL;
2158                 if (i % 2) {
2159                         wwnn[i/2] = j & 0xff;
2160                         j = 0;
2161                 }
2162         }
2163         phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
2164
2165         dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2166                    "lpfc%d: soft_wwnn set. Value will take effect upon "
2167                    "setting of the soft_wwpn\n", phba->brd_no);
2168
2169         return count;
2170 }
2171 static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
2172                    lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
2173
2174
2175 static int lpfc_poll = 0;
2176 module_param(lpfc_poll, int, S_IRUGO);
2177 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
2178                  " 0 - none,"
2179                  " 1 - poll with interrupts enabled"
2180                  " 3 - poll and disable FCP ring interrupts");
2181
2182 static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
2183                    lpfc_poll_show, lpfc_poll_store);
2184
2185 int  lpfc_sli_mode = 0;
2186 module_param(lpfc_sli_mode, int, S_IRUGO);
2187 MODULE_PARM_DESC(lpfc_sli_mode, "SLI mode selector:"
2188                  " 0 - auto (SLI-3 if supported),"
2189                  " 2 - select SLI-2 even on SLI-3 capable HBAs,"
2190                  " 3 - select SLI-3");
2191
2192 int lpfc_enable_npiv = 1;
2193 module_param(lpfc_enable_npiv, int, S_IRUGO);
2194 MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
2195 lpfc_param_show(enable_npiv);
2196 lpfc_param_init(enable_npiv, 1, 0, 1);
2197 static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL);
2198
2199 int lpfc_enable_rrq;
2200 module_param(lpfc_enable_rrq, int, S_IRUGO);
2201 MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
2202 lpfc_param_show(enable_rrq);
2203 lpfc_param_init(enable_rrq, 0, 0, 1);
2204 static DEVICE_ATTR(lpfc_enable_rrq, S_IRUGO, lpfc_enable_rrq_show, NULL);
2205
2206 /*
2207 # lpfc_suppress_link_up:  Bring link up at initialization
2208 #            0x0  = bring link up (issue MBX_INIT_LINK)
2209 #            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
2210 #            0x2  = never bring up link
2211 # Default value is 0.
2212 */
2213 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
2214                 LPFC_DELAY_INIT_LINK_INDEFINITELY,
2215                 "Suppress Link Up at initialization");
2216 /*
2217 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
2218 #       1 - (1024)
2219 #       2 - (2048)
2220 #       3 - (3072)
2221 #       4 - (4096)
2222 #       5 - (5120)
2223 */
2224 static ssize_t
2225 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
2226 {
2227         struct Scsi_Host  *shost = class_to_shost(dev);
2228         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2229
2230         return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
2231 }
2232
2233 static DEVICE_ATTR(iocb_hw, S_IRUGO,
2234                          lpfc_iocb_hw_show, NULL);
2235 static ssize_t
2236 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
2237 {
2238         struct Scsi_Host  *shost = class_to_shost(dev);
2239         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2240
2241         return snprintf(buf, PAGE_SIZE, "%d\n",
2242                 phba->sli.ring[LPFC_ELS_RING].txq_max);
2243 }
2244
2245 static DEVICE_ATTR(txq_hw, S_IRUGO,
2246                          lpfc_txq_hw_show, NULL);
2247 static ssize_t
2248 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
2249  char *buf)
2250 {
2251         struct Scsi_Host  *shost = class_to_shost(dev);
2252         struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2253
2254         return snprintf(buf, PAGE_SIZE, "%d\n",
2255                 phba->sli.ring[LPFC_ELS_RING].txcmplq_max);
2256 }
2257
2258 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
2259                          lpfc_txcmplq_hw_show, NULL);
2260
2261 int lpfc_iocb_cnt = 2;
2262 module_param(lpfc_iocb_cnt, int, S_IRUGO);
2263 MODULE_PARM_DESC(lpfc_iocb_cnt,
2264         "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
2265 lpfc_param_show(iocb_cnt);
2266 lpfc_param_init(iocb_cnt, 2, 1, 5);
2267 static DEVICE_ATTR(lpfc_iocb_cnt, S_IRUGO,
2268                          lpfc_iocb_cnt_show, NULL);
2269
2270 /*
2271 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
2272 # until the timer expires. Value range is [0,255]. Default value is 30.
2273 */
2274 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2275 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
2276 module_param(lpfc_nodev_tmo, int, 0);
2277 MODULE_PARM_DESC(lpfc_nodev_tmo,
2278                  "Seconds driver will hold I/O waiting "
2279                  "for a device to come back");
2280
2281 /**
2282  * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
2283  * @dev: class converted to a Scsi_host structure.
2284  * @attr: device attribute, not used.
2285  * @buf: on return contains the dev loss timeout in decimal.
2286  *
2287  * Returns: size of formatted string.
2288  **/
2289 static ssize_t
2290 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
2291                     char *buf)
2292 {
2293         struct Scsi_Host  *shost = class_to_shost(dev);
2294         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2295
2296         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
2297 }
2298
2299 /**
2300  * lpfc_nodev_tmo_init - Set the hba nodev timeout value
2301  * @vport: lpfc vport structure pointer.
2302  * @val: contains the nodev timeout value.
2303  *
2304  * Description:
2305  * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
2306  * a kernel error message is printed and zero is returned.
2307  * Else if val is in range then nodev tmo and devloss tmo are set to val.
2308  * Otherwise nodev tmo is set to the default value.
2309  *
2310  * Returns:
2311  * zero if already set or if val is in range
2312  * -EINVAL val out of range
2313  **/
2314 static int
2315 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
2316 {
2317         if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
2318                 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
2319                 if (val != LPFC_DEF_DEVLOSS_TMO)
2320                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2321                                          "0407 Ignoring nodev_tmo module "
2322                                          "parameter because devloss_tmo is "
2323                                          "set.\n");
2324                 return 0;
2325         }
2326
2327         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2328                 vport->cfg_nodev_tmo = val;
2329                 vport->cfg_devloss_tmo = val;
2330                 return 0;
2331         }
2332         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2333                          "0400 lpfc_nodev_tmo attribute cannot be set to"
2334                          " %d, allowed range is [%d, %d]\n",
2335                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2336         vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2337         return -EINVAL;
2338 }
2339
2340 /**
2341  * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
2342  * @vport: lpfc vport structure pointer.
2343  *
2344  * Description:
2345  * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
2346  **/
2347 static void
2348 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
2349 {
2350         struct Scsi_Host  *shost;
2351         struct lpfc_nodelist  *ndlp;
2352
2353         shost = lpfc_shost_from_vport(vport);
2354         spin_lock_irq(shost->host_lock);
2355         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
2356                 if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
2357                         ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
2358         spin_unlock_irq(shost->host_lock);
2359 }
2360
2361 /**
2362  * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
2363  * @vport: lpfc vport structure pointer.
2364  * @val: contains the tmo value.
2365  *
2366  * Description:
2367  * If the devloss tmo is already set or the vport dev loss tmo has changed
2368  * then a kernel error message is printed and zero is returned.
2369  * Else if val is in range then nodev tmo and devloss tmo are set to val.
2370  * Otherwise nodev tmo is set to the default value.
2371  *
2372  * Returns:
2373  * zero if already set or if val is in range
2374  * -EINVAL val out of range
2375  **/
2376 static int
2377 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
2378 {
2379         if (vport->dev_loss_tmo_changed ||
2380             (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
2381                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2382                                  "0401 Ignoring change to nodev_tmo "
2383                                  "because devloss_tmo is set.\n");
2384                 return 0;
2385         }
2386         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2387                 vport->cfg_nodev_tmo = val;
2388                 vport->cfg_devloss_tmo = val;
2389                 /*
2390                  * For compat: set the fc_host dev loss so new rports
2391                  * will get the value.
2392                  */
2393                 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
2394                 lpfc_update_rport_devloss_tmo(vport);
2395                 return 0;
2396         }
2397         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2398                          "0403 lpfc_nodev_tmo attribute cannot be set to"
2399                          "%d, allowed range is [%d, %d]\n",
2400                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2401         return -EINVAL;
2402 }
2403
2404 lpfc_vport_param_store(nodev_tmo)
2405
2406 static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
2407                    lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
2408
2409 /*
2410 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
2411 # disappear until the timer expires. Value range is [0,255]. Default
2412 # value is 30.
2413 */
2414 module_param(lpfc_devloss_tmo, int, S_IRUGO);
2415 MODULE_PARM_DESC(lpfc_devloss_tmo,
2416                  "Seconds driver will hold I/O waiting "
2417                  "for a device to come back");
2418 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
2419                       LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
2420 lpfc_vport_param_show(devloss_tmo)
2421
2422 /**
2423  * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
2424  * @vport: lpfc vport structure pointer.
2425  * @val: contains the tmo value.
2426  *
2427  * Description:
2428  * If val is in a valid range then set the vport nodev tmo,
2429  * devloss tmo, also set the vport dev loss tmo changed flag.
2430  * Else a kernel error message is printed.
2431  *
2432  * Returns:
2433  * zero if val is in range
2434  * -EINVAL val out of range
2435  **/
2436 static int
2437 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
2438 {
2439         if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2440                 vport->cfg_nodev_tmo = val;
2441                 vport->cfg_devloss_tmo = val;
2442                 vport->dev_loss_tmo_changed = 1;
2443                 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
2444                 lpfc_update_rport_devloss_tmo(vport);
2445                 return 0;
2446         }
2447
2448         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2449                          "0404 lpfc_devloss_tmo attribute cannot be set to"
2450                          " %d, allowed range is [%d, %d]\n",
2451                          val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2452         return -EINVAL;
2453 }
2454
2455 lpfc_vport_param_store(devloss_tmo)
2456 static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
2457                    lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
2458
2459 /*
2460 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
2461 # deluged with LOTS of information.
2462 # You can set a bit mask to record specific types of verbose messages:
2463 # See lpfc_logmsh.h for definitions.
2464 */
2465 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
2466                        "Verbose logging bit-mask");
2467
2468 /*
2469 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
2470 # objects that have been registered with the nameserver after login.
2471 */
2472 LPFC_VPORT_ATTR_R(enable_da_id, 0, 0, 1,
2473                   "Deregister nameserver objects before LOGO");
2474
2475 /*
2476 # lun_queue_depth:  This parameter is used to limit the number of outstanding
2477 # commands per FCP LUN. Value range is [1,128]. Default value is 30.
2478 */
2479 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128,
2480                   "Max number of FCP commands we can queue to a specific LUN");
2481
2482 /*
2483 # tgt_queue_depth:  This parameter is used to limit the number of outstanding
2484 # commands per target port. Value range is [10,65535]. Default value is 65535.
2485 */
2486 LPFC_VPORT_ATTR_R(tgt_queue_depth, 65535, 10, 65535,
2487         "Max number of FCP commands we can queue to a specific target port");
2488
2489 /*
2490 # hba_queue_depth:  This parameter is used to limit the number of outstanding
2491 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
2492 # value is greater than the maximum number of exchanges supported by the HBA,
2493 # then maximum number of exchanges supported by the HBA is used to determine
2494 # the hba_queue_depth.
2495 */
2496 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
2497             "Max number of FCP commands we can queue to a lpfc HBA");
2498
2499 /*
2500 # peer_port_login:  This parameter allows/prevents logins
2501 # between peer ports hosted on the same physical port.
2502 # When this parameter is set 0 peer ports of same physical port
2503 # are not allowed to login to each other.
2504 # When this parameter is set 1 peer ports of same physical port
2505 # are allowed to login to each other.
2506 # Default value of this parameter is 0.
2507 */
2508 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
2509                   "Allow peer ports on the same physical port to login to each "
2510                   "other.");
2511
2512 /*
2513 # restrict_login:  This parameter allows/prevents logins
2514 # between Virtual Ports and remote initiators.
2515 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
2516 # other initiators and will attempt to PLOGI all remote ports.
2517 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
2518 # remote ports and will not attempt to PLOGI to other initiators.
2519 # This parameter does not restrict to the physical port.
2520 # This parameter does not restrict logins to Fabric resident remote ports.
2521 # Default value of this parameter is 1.
2522 */
2523 static int lpfc_restrict_login = 1;
2524 module_param(lpfc_restrict_login, int, S_IRUGO);
2525 MODULE_PARM_DESC(lpfc_restrict_login,
2526                  "Restrict virtual ports login to remote initiators.");
2527 lpfc_vport_param_show(restrict_login);
2528
2529 /**
2530  * lpfc_restrict_login_init - Set the vport restrict login flag
2531  * @vport: lpfc vport structure pointer.
2532  * @val: contains the restrict login value.
2533  *
2534  * Description:
2535  * If val is not in a valid range then log a kernel error message and set
2536  * the vport restrict login to one.
2537  * If the port type is physical clear the restrict login flag and return.
2538  * Else set the restrict login flag to val.
2539  *
2540  * Returns:
2541  * zero if val is in range
2542  * -EINVAL val out of range
2543  **/
2544 static int
2545 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
2546 {
2547         if (val < 0 || val > 1) {
2548                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2549                                  "0422 lpfc_restrict_login attribute cannot "
2550                                  "be set to %d, allowed range is [0, 1]\n",
2551                                  val);
2552                 vport->cfg_restrict_login = 1;
2553                 return -EINVAL;
2554         }
2555         if (vport->port_type == LPFC_PHYSICAL_PORT) {
2556                 vport->cfg_restrict_login = 0;
2557                 return 0;
2558         }
2559         vport->cfg_restrict_login = val;
2560         return 0;
2561 }
2562
2563 /**
2564  * lpfc_restrict_login_set - Set the vport restrict login flag
2565  * @vport: lpfc vport structure pointer.
2566  * @val: contains the restrict login value.
2567  *
2568  * Description:
2569  * If val is not in a valid range then log a kernel error message and set
2570  * the vport restrict login to one.
2571  * If the port type is physical and the val is not zero log a kernel
2572  * error message, clear the restrict login flag and return zero.
2573  * Else set the restrict login flag to val.
2574  *
2575  * Returns:
2576  * zero if val is in range
2577  * -EINVAL val out of range
2578  **/
2579 static int
2580 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
2581 {
2582         if (val < 0 || val > 1) {
2583                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2584                                  "0425 lpfc_restrict_login attribute cannot "
2585                                  "be set to %d, allowed range is [0, 1]\n",
2586                                  val);
2587                 vport->cfg_restrict_login = 1;
2588                 return -EINVAL;
2589         }
2590         if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
2591                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2592                                  "0468 lpfc_restrict_login must be 0 for "
2593                                  "Physical ports.\n");
2594                 vport->cfg_restrict_login = 0;
2595                 return 0;
2596         }
2597         vport->cfg_restrict_login = val;
2598         return 0;
2599 }
2600 lpfc_vport_param_store(restrict_login);
2601 static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
2602                    lpfc_restrict_login_show, lpfc_restrict_login_store);
2603
2604 /*
2605 # Some disk devices have a "select ID" or "select Target" capability.
2606 # From a protocol standpoint "select ID" usually means select the
2607 # Fibre channel "ALPA".  In the FC-AL Profile there is an "informative
2608 # annex" which contains a table that maps a "select ID" (a number
2609 # between 0 and 7F) to an ALPA.  By default, for compatibility with
2610 # older drivers, the lpfc driver scans this table from low ALPA to high
2611 # ALPA.
2612 #
2613 # Turning on the scan-down variable (on  = 1, off = 0) will
2614 # cause the lpfc driver to use an inverted table, effectively
2615 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
2616 #
2617 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
2618 # and will not work across a fabric. Also this parameter will take
2619 # effect only in the case when ALPA map is not available.)
2620 */
2621 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
2622                   "Start scanning for devices from highest ALPA to lowest");
2623
2624 /*
2625 # lpfc_topology:  link topology for init link
2626 #            0x0  = attempt loop mode then point-to-point
2627 #            0x01 = internal loopback mode
2628 #            0x02 = attempt point-to-point mode only
2629 #            0x04 = attempt loop mode only
2630 #            0x06 = attempt point-to-point mode then loop
2631 # Set point-to-point mode if you want to run as an N_Port.
2632 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
2633 # Default value is 0.
2634 */
2635
2636 /**
2637  * lpfc_topology_set - Set the adapters topology field
2638  * @phba: lpfc_hba pointer.
2639  * @val: topology value.
2640  *
2641  * Description:
2642  * If val is in a valid range then set the adapter's topology field and
2643  * issue a lip; if the lip fails reset the topology to the old value.
2644  *
2645  * If the value is not in range log a kernel error message and return an error.
2646  *
2647  * Returns:
2648  * zero if val is in range and lip okay
2649  * non-zero return value from lpfc_issue_lip()
2650  * -EINVAL val out of range
2651  **/
2652 static ssize_t
2653 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
2654                         const char *buf, size_t count)
2655 {
2656         struct Scsi_Host  *shost = class_to_shost(dev);
2657         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2658         struct lpfc_hba   *phba = vport->phba;
2659         int val = 0;
2660         int nolip = 0;
2661         const char *val_buf = buf;
2662         int err;
2663         uint32_t prev_val;
2664
2665         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
2666                 nolip = 1;
2667                 val_buf = &buf[strlen("nolip ")];
2668         }
2669
2670         if (!isdigit(val_buf[0]))
2671                 return -EINVAL;
2672         if (sscanf(val_buf, "%i", &val) != 1)
2673                 return -EINVAL;
2674
2675         if (val >= 0 && val <= 6) {
2676                 prev_val = phba->cfg_topology;
2677                 phba->cfg_topology = val;
2678                 if (nolip)
2679                         return strlen(buf);
2680
2681                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
2682                 if (err) {
2683                         phba->cfg_topology = prev_val;
2684                         return -EINVAL;
2685                 } else
2686                         return strlen(buf);
2687         }
2688         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2689                 "%d:0467 lpfc_topology attribute cannot be set to %d, "
2690                 "allowed range is [0, 6]\n",
2691                 phba->brd_no, val);
2692         return -EINVAL;
2693 }
2694 static int lpfc_topology = 0;
2695 module_param(lpfc_topology, int, S_IRUGO);
2696 MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
2697 lpfc_param_show(topology)
2698 lpfc_param_init(topology, 0, 0, 6)
2699 static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
2700                 lpfc_topology_show, lpfc_topology_store);
2701
2702 /**
2703  * lpfc_static_vport_show: Read callback function for
2704  *   lpfc_static_vport sysfs file.
2705  * @dev: Pointer to class device object.
2706  * @attr: device attribute structure.
2707  * @buf: Data buffer.
2708  *
2709  * This function is the read call back function for
2710  * lpfc_static_vport sysfs file. The lpfc_static_vport
2711  * sysfs file report the mageability of the vport.
2712  **/
2713 static ssize_t
2714 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
2715                          char *buf)
2716 {
2717         struct Scsi_Host  *shost = class_to_shost(dev);
2718         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2719         if (vport->vport_flag & STATIC_VPORT)
2720                 sprintf(buf, "1\n");
2721         else
2722                 sprintf(buf, "0\n");
2723
2724         return strlen(buf);
2725 }
2726
2727 /*
2728  * Sysfs attribute to control the statistical data collection.
2729  */
2730 static DEVICE_ATTR(lpfc_static_vport, S_IRUGO,
2731                    lpfc_static_vport_show, NULL);
2732
2733 /**
2734  * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
2735  * @dev: Pointer to class device.
2736  * @buf: Data buffer.
2737  * @count: Size of the data buffer.
2738  *
2739  * This function get called when an user write to the lpfc_stat_data_ctrl
2740  * sysfs file. This function parse the command written to the sysfs file
2741  * and take appropriate action. These commands are used for controlling
2742  * driver statistical data collection.
2743  * Following are the command this function handles.
2744  *
2745  *    setbucket <bucket_type> <base> <step>
2746  *                             = Set the latency buckets.
2747  *    destroybucket            = destroy all the buckets.
2748  *    start                    = start data collection
2749  *    stop                     = stop data collection
2750  *    reset                    = reset the collected data
2751  **/
2752 static ssize_t
2753 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
2754                           const char *buf, size_t count)
2755 {
2756         struct Scsi_Host  *shost = class_to_shost(dev);
2757         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2758         struct lpfc_hba   *phba = vport->phba;
2759 #define LPFC_MAX_DATA_CTRL_LEN 1024
2760         static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
2761         unsigned long i;
2762         char *str_ptr, *token;
2763         struct lpfc_vport **vports;
2764         struct Scsi_Host *v_shost;
2765         char *bucket_type_str, *base_str, *step_str;
2766         unsigned long base, step, bucket_type;
2767
2768         if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
2769                 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
2770                         return -EINVAL;
2771
2772                 strcpy(bucket_data, buf);
2773                 str_ptr = &bucket_data[0];
2774                 /* Ignore this token - this is command token */
2775                 token = strsep(&str_ptr, "\t ");
2776                 if (!token)
2777                         return -EINVAL;
2778
2779                 bucket_type_str = strsep(&str_ptr, "\t ");
2780                 if (!bucket_type_str)
2781                         return -EINVAL;
2782
2783                 if (!strncmp(bucket_type_str, "linear", strlen("linear")))
2784                         bucket_type = LPFC_LINEAR_BUCKET;
2785                 else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
2786                         bucket_type = LPFC_POWER2_BUCKET;
2787                 else
2788                         return -EINVAL;
2789
2790                 base_str = strsep(&str_ptr, "\t ");
2791                 if (!base_str)
2792                         return -EINVAL;
2793                 base = simple_strtoul(base_str, NULL, 0);
2794
2795                 step_str = strsep(&str_ptr, "\t ");
2796                 if (!step_str)
2797                         return -EINVAL;
2798                 step = simple_strtoul(step_str, NULL, 0);
2799                 if (!step)
2800                         return -EINVAL;
2801
2802                 /* Block the data collection for every vport */
2803                 vports = lpfc_create_vport_work_array(phba);
2804                 if (vports == NULL)
2805                         return -ENOMEM;
2806
2807                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2808                         v_shost = lpfc_shost_from_vport(vports[i]);
2809                         spin_lock_irq(v_shost->host_lock);
2810                         /* Block and reset data collection */
2811                         vports[i]->stat_data_blocked = 1;
2812                         if (vports[i]->stat_data_enabled)
2813                                 lpfc_vport_reset_stat_data(vports[i]);
2814                         spin_unlock_irq(v_shost->host_lock);
2815                 }
2816
2817                 /* Set the bucket attributes */
2818                 phba->bucket_type = bucket_type;
2819                 phba->bucket_base = base;
2820                 phba->bucket_step = step;
2821
2822                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2823                         v_shost = lpfc_shost_from_vport(vports[i]);
2824
2825                         /* Unblock data collection */
2826                         spin_lock_irq(v_shost->host_lock);
2827                         vports[i]->stat_data_blocked = 0;
2828                         spin_unlock_irq(v_shost->host_lock);
2829                 }
2830                 lpfc_destroy_vport_work_array(phba, vports);
2831                 return strlen(buf);
2832         }
2833
2834         if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
2835                 vports = lpfc_create_vport_work_array(phba);
2836                 if (vports == NULL)
2837                         return -ENOMEM;
2838
2839                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2840                         v_shost = lpfc_shost_from_vport(vports[i]);
2841                         spin_lock_irq(shost->host_lock);
2842                         vports[i]->stat_data_blocked = 1;
2843                         lpfc_free_bucket(vport);
2844                         vport->stat_data_enabled = 0;
2845                         vports[i]->stat_data_blocked = 0;
2846                         spin_unlock_irq(shost->host_lock);
2847                 }
2848                 lpfc_destroy_vport_work_array(phba, vports);
2849                 phba->bucket_type = LPFC_NO_BUCKET;
2850                 phba->bucket_base = 0;
2851                 phba->bucket_step = 0;
2852                 return strlen(buf);
2853         }
2854
2855         if (!strncmp(buf, "start", strlen("start"))) {
2856                 /* If no buckets configured return error */
2857                 if (phba->bucket_type == LPFC_NO_BUCKET)
2858                         return -EINVAL;
2859                 spin_lock_irq(shost->host_lock);
2860                 if (vport->stat_data_enabled) {
2861                         spin_unlock_irq(shost->host_lock);
2862                         return strlen(buf);
2863                 }
2864                 lpfc_alloc_bucket(vport);
2865                 vport->stat_data_enabled = 1;
2866                 spin_unlock_irq(shost->host_lock);
2867                 return strlen(buf);
2868         }
2869
2870         if (!strncmp(buf, "stop", strlen("stop"))) {
2871                 spin_lock_irq(shost->host_lock);
2872                 if (vport->stat_data_enabled == 0) {
2873                         spin_unlock_irq(shost->host_lock);
2874                         return strlen(buf);
2875                 }
2876                 lpfc_free_bucket(vport);
2877                 vport->stat_data_enabled = 0;
2878                 spin_unlock_irq(shost->host_lock);
2879                 return strlen(buf);
2880         }
2881
2882         if (!strncmp(buf, "reset", strlen("reset"))) {
2883                 if ((phba->bucket_type == LPFC_NO_BUCKET)
2884                         || !vport->stat_data_enabled)
2885                         return strlen(buf);
2886                 spin_lock_irq(shost->host_lock);
2887                 vport->stat_data_blocked = 1;
2888                 lpfc_vport_reset_stat_data(vport);
2889                 vport->stat_data_blocked = 0;
2890                 spin_unlock_irq(shost->host_lock);
2891                 return strlen(buf);
2892         }
2893         return -EINVAL;
2894 }
2895
2896
2897 /**
2898  * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
2899  * @dev: Pointer to class device object.
2900  * @buf: Data buffer.
2901  *
2902  * This function is the read call back function for
2903  * lpfc_stat_data_ctrl sysfs file. This function report the
2904  * current statistical data collection state.
2905  **/
2906 static ssize_t
2907 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
2908                          char *buf)
2909 {
2910         struct Scsi_Host  *shost = class_to_shost(dev);
2911         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2912         struct lpfc_hba   *phba = vport->phba;
2913         int index = 0;
2914         int i;
2915         char *bucket_type;
2916         unsigned long bucket_value;
2917
2918         switch (phba->bucket_type) {
2919         case LPFC_LINEAR_BUCKET:
2920                 bucket_type = "linear";
2921                 break;
2922         case LPFC_POWER2_BUCKET:
2923                 bucket_type = "power2";
2924                 break;
2925         default:
2926                 bucket_type = "No Bucket";
2927                 break;
2928         }
2929
2930         sprintf(&buf[index], "Statistical Data enabled :%d, "
2931                 "blocked :%d, Bucket type :%s, Bucket base :%d,"
2932                 " Bucket step :%d\nLatency Ranges :",
2933                 vport->stat_data_enabled, vport->stat_data_blocked,
2934                 bucket_type, phba->bucket_base, phba->bucket_step);
2935         index = strlen(buf);
2936         if (phba->bucket_type != LPFC_NO_BUCKET) {
2937                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
2938                         if (phba->bucket_type == LPFC_LINEAR_BUCKET)
2939                                 bucket_value = phba->bucket_base +
2940                                         phba->bucket_step * i;
2941                         else
2942                                 bucket_value = phba->bucket_base +
2943                                 (1 << i) * phba->bucket_step;
2944
2945                         if (index + 10 > PAGE_SIZE)
2946                                 break;
2947                         sprintf(&buf[index], "%08ld ", bucket_value);
2948                         index = strlen(buf);
2949                 }
2950         }
2951         sprintf(&buf[index], "\n");
2952         return strlen(buf);
2953 }
2954
2955 /*
2956  * Sysfs attribute to control the statistical data collection.
2957  */
2958 static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR,
2959                    lpfc_stat_data_ctrl_show, lpfc_stat_data_ctrl_store);
2960
2961 /*
2962  * lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
2963  */
2964
2965 /*
2966  * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
2967  * for each target.
2968  */
2969 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
2970 #define MAX_STAT_DATA_SIZE_PER_TARGET \
2971         STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
2972
2973
2974 /**
2975  * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
2976  * @filp: sysfs file
2977  * @kobj: Pointer to the kernel object
2978  * @bin_attr: Attribute object
2979  * @buff: Buffer pointer
2980  * @off: File offset
2981  * @count: Buffer size
2982  *
2983  * This function is the read call back function for lpfc_drvr_stat_data
2984  * sysfs file. This function export the statistical data to user
2985  * applications.
2986  **/
2987 static ssize_t
2988 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
2989                 struct bin_attribute *bin_attr,
2990                 char *buf, loff_t off, size_t count)
2991 {
2992         struct device *dev = container_of(kobj, struct device,
2993                 kobj);
2994         struct Scsi_Host  *shost = class_to_shost(dev);
2995         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2996         struct lpfc_hba   *phba = vport->phba;
2997         int i = 0, index = 0;
2998         unsigned long nport_index;
2999         struct lpfc_nodelist *ndlp = NULL;
3000         nport_index = (unsigned long)off /
3001                 MAX_STAT_DATA_SIZE_PER_TARGET;
3002
3003         if (!vport->stat_data_enabled || vport->stat_data_blocked
3004                 || (phba->bucket_type == LPFC_NO_BUCKET))
3005                 return 0;
3006
3007         spin_lock_irq(shost->host_lock);
3008         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3009                 if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data)
3010                         continue;
3011
3012                 if (nport_index > 0) {
3013                         nport_index--;
3014                         continue;
3015                 }
3016
3017                 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
3018                         > count)
3019                         break;
3020
3021                 if (!ndlp->lat_data)
3022                         continue;
3023
3024                 /* Print the WWN */
3025                 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
3026                         ndlp->nlp_portname.u.wwn[0],
3027                         ndlp->nlp_portname.u.wwn[1],
3028                         ndlp->nlp_portname.u.wwn[2],
3029                         ndlp->nlp_portname.u.wwn[3],
3030                         ndlp->nlp_portname.u.wwn[4],
3031                         ndlp->nlp_portname.u.wwn[5],
3032                         ndlp->nlp_portname.u.wwn[6],
3033                         ndlp->nlp_portname.u.wwn[7]);
3034
3035                 index = strlen(buf);
3036
3037                 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
3038                         sprintf(&buf[index], "%010u,",
3039                                 ndlp->lat_data[i].cmd_count);
3040                         index = strlen(buf);
3041                 }
3042                 sprintf(&buf[index], "\n");
3043                 index = strlen(buf);
3044         }
3045         spin_unlock_irq(shost->host_lock);
3046         return index;
3047 }
3048
3049 static struct bin_attribute sysfs_drvr_stat_data_attr = {
3050         .attr = {
3051                 .name = "lpfc_drvr_stat_data",
3052                 .mode = S_IRUSR,
3053         },
3054         .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
3055         .read = sysfs_drvr_stat_data_read,
3056         .write = NULL,
3057 };
3058
3059 /*
3060 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
3061 # connection.
3062 # Value range is [0,16]. Default value is 0.
3063 */
3064 /**
3065  * lpfc_link_speed_set - Set the adapters link speed
3066  * @phba: lpfc_hba pointer.
3067  * @val: link speed value.
3068  *
3069  * Description:
3070  * If val is in a valid range then set the adapter's link speed field and
3071  * issue a lip; if the lip fails reset the link speed to the old value.
3072  *
3073  * Notes:
3074  * If the value is not in range log a kernel error message and return an error.
3075  *
3076  * Returns:
3077  * zero if val is in range and lip okay.
3078  * non-zero return value from lpfc_issue_lip()
3079  * -EINVAL val out of range
3080  **/
3081 static ssize_t
3082 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
3083                 const char *buf, size_t count)
3084 {
3085         struct Scsi_Host  *shost = class_to_shost(dev);
3086         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3087         struct lpfc_hba   *phba = vport->phba;
3088         int val = LPFC_USER_LINK_SPEED_AUTO;
3089         int nolip = 0;
3090         const char *val_buf = buf;
3091         int err;
3092         uint32_t prev_val;
3093
3094         if (!strncmp(buf, "nolip ", strlen("nolip "))) {
3095                 nolip = 1;
3096                 val_buf = &buf[strlen("nolip ")];
3097         }
3098
3099         if (!isdigit(val_buf[0]))
3100                 return -EINVAL;
3101         if (sscanf(val_buf, "%i", &val) != 1)
3102                 return -EINVAL;
3103
3104         if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
3105             ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
3106             ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
3107             ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
3108             ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
3109             ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb))) {
3110                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3111                                 "2879 lpfc_link_speed attribute cannot be set "
3112                                 "to %d. Speed is not supported by this port.\n",
3113                                 val);
3114                 return -EINVAL;
3115         }
3116         if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
3117             (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3118                 prev_val = phba->cfg_link_speed;
3119                 phba->cfg_link_speed = val;
3120                 if (nolip)
3121                         return strlen(buf);
3122
3123                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
3124                 if (err) {
3125                         phba->cfg_link_speed = prev_val;
3126                         return -EINVAL;
3127                 } else
3128                         return strlen(buf);
3129         }
3130         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3131                 "0469 lpfc_link_speed attribute cannot be set to %d, "
3132                 "allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val);
3133         return -EINVAL;
3134 }
3135
3136 static int lpfc_link_speed = 0;
3137 module_param(lpfc_link_speed, int, S_IRUGO);
3138 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
3139 lpfc_param_show(link_speed)
3140
3141 /**
3142  * lpfc_link_speed_init - Set the adapters link speed
3143  * @phba: lpfc_hba pointer.
3144  * @val: link speed value.
3145  *
3146  * Description:
3147  * If val is in a valid range then set the adapter's link speed field.
3148  *
3149  * Notes:
3150  * If the value is not in range log a kernel error message, clear the link
3151  * speed and return an error.
3152  *
3153  * Returns:
3154  * zero if val saved.
3155  * -EINVAL val out of range
3156  **/
3157 static int
3158 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
3159 {
3160         if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
3161             (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3162                 phba->cfg_link_speed = val;
3163                 return 0;
3164         }
3165         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3166                         "0405 lpfc_link_speed attribute cannot "
3167                         "be set to %d, allowed values are "
3168                         "["LPFC_LINK_SPEED_STRING"]\n", val);
3169         phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
3170         return -EINVAL;
3171 }
3172
3173 static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
3174                    lpfc_link_speed_show, lpfc_link_speed_store);
3175
3176 /*
3177 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
3178 #       0  = aer disabled or not supported
3179 #       1  = aer supported and enabled (default)
3180 # Value range is [0,1]. Default value is 1.
3181 */
3182
3183 /**
3184  * lpfc_aer_support_store - Set the adapter for aer support
3185  *
3186  * @dev: class device that is converted into a Scsi_host.
3187  * @attr: device attribute, not used.
3188  * @buf: containing enable or disable aer flag.
3189  * @count: unused variable.
3190  *
3191  * Description:
3192  * If the val is 1 and currently the device's AER capability was not
3193  * enabled, invoke the kernel's enable AER helper routine, trying to
3194  * enable the device's AER capability. If the helper routine enabling
3195  * AER returns success, update the device's cfg_aer_support flag to
3196  * indicate AER is supported by the device; otherwise, if the device
3197  * AER capability is already enabled to support AER, then do nothing.
3198  *
3199  * If the val is 0 and currently the device's AER support was enabled,
3200  * invoke the kernel's disable AER helper routine. After that, update
3201  * the device's cfg_aer_support flag to indicate AER is not supported
3202  * by the device; otherwise, if the device AER capability is already
3203  * disabled from supporting AER, then do nothing.
3204  *
3205  * Returns:
3206  * length of the buf on success if val is in range the intended mode
3207  * is supported.
3208  * -EINVAL if val out of range or intended mode is not supported.
3209  **/
3210 static ssize_t
3211 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
3212                        const char *buf, size_t count)
3213 {
3214         struct Scsi_Host *shost = class_to_shost(dev);
3215         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
3216         struct lpfc_hba *phba = vport->phba;
3217         int val = 0, rc = -EINVAL;
3218
3219         if (!isdigit(buf[0]))
3220                 return -EINVAL;
3221         if (sscanf(buf, "%i", &val) != 1)
3222                 return -EINVAL;
3223
3224         switch (val) {
3225         case 0:
3226                 if (phba->hba_flag & HBA_AER_ENABLED) {
3227                         rc = pci_disable_pcie_error_reporting(phba->pcidev);
3228                         if (!rc) {
3229                                 spin_lock_irq(&phba->hbalock);
3230                                 phba->hba_flag &= ~HBA_AER_ENABLED;
3231                                 spin_unlock_irq(&phba->hbalock);
3232                                 phba->cfg_aer_support = 0;
3233                                 rc = strlen(buf);
3234                         } else
3235                                 rc = -EPERM;
3236                 } else {
3237                         phba->cfg_aer_support = 0;
3238                         rc = strlen(buf);
3239                 }
3240                 break;
3241         case 1:
3242                 if (!(phba->hba_flag & HBA_AER_ENABLED)) {
3243                         rc = pci_enable_pcie_error_reporting(phba->pcidev);
3244                         if (!rc) {
3245                                 spin_lock_irq(&phba->hbalock);
3246                                 phba->hba_flag |= HBA_AER_ENABLED;
3247                                 spin_unlock_irq(&phba->hbalock);
3248                                 phba->cfg_aer_support = 1;
3249                                 rc = strlen(buf);
3250                         } else
3251                                  rc = -EPERM;
3252                 } else {
3253                         phba->cfg_aer_support = 1;
3254                         rc = strlen(buf);
3255                 }
3256                 break;
3257         default:
3258                 rc = -EINVAL;
3259                 break;
3260         }
3261         return rc;
3262 }
3263
3264 static int lpfc_aer_support = 1;
3265 module_param(lpfc_aer_support, int, S_IRUGO);
3266 MODULE_PARM_DESC(lpfc_aer_support, "Enable PCIe device AER support");
3267 lpfc_param_show(aer_support)
3268
3269 /**
3270  * lpfc_aer_support_init - Set the initial adapters aer support flag
3271  * @phba: lpfc_hba pointer.
3272  * @val: enable aer or disable aer flag.
3273  *
3274  * Description:
3275  * If val is in a valid range [0,1], then set the adapter's initial
3276  * cfg_aer_support field. It will be up to the driver's probe_one
3277  * routine to determine whether the device's AER support can be set
3278  * or not.
3279  *
3280  * Notes:
3281  * If the value is not in range log a kernel error message, and
3282  * choose the default value of setting AER support and return.
3283  *
3284  * Returns:
3285  * zero if val saved.
3286  * -EINVAL val out of range
3287  **/
3288 static int
3289 lpfc_aer_support_init(struct lpfc_hba *phba, int val)
3290 {
3291         if (val == 0 || val == 1) {
3292                 phba->cfg_aer_support = val;
3293                 return 0;
3294         }
3295         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3296                         "2712 lpfc_aer_support attribute value %d out "
3297                         "of range, allowed values are 0|1, setting it "
3298                         "to default value of 1\n", val);
3299         /* By default, try to enable AER on a device */
3300         phba->cfg_aer_support = 1;
3301         return -EINVAL;
3302 }
3303
3304 static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR,
3305                    lpfc_aer_support_show, lpfc_aer_support_store);
3306
3307 /**
3308  * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
3309  * @dev: class device that is converted into a Scsi_host.
3310  * @attr: device attribute, not used.
3311  * @buf: containing flag 1 for aer cleanup state.
3312  * @count: unused variable.
3313  *
3314  * Description:
3315  * If the @buf contains 1 and the device currently has the AER support
3316  * enabled, then invokes the kernel AER helper routine
3317  * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
3318  * error status register.
3319  *
3320  * Notes:
3321  *
3322  * Returns:
3323  * -EINVAL if the buf does not contain the 1 or the device is not currently
3324  * enabled with the AER support.
3325  **/
3326 static ssize_t
3327 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
3328                        const char *buf, size_t count)
3329 {
3330         struct Scsi_Host  *shost = class_to_shost(dev);
3331         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3332         struct lpfc_hba   *phba = vport->phba;
3333         int val, rc = -1;
3334
3335         if (!isdigit(buf[0]))
3336                 return -EINVAL;
3337         if (sscanf(buf, "%i", &val) != 1)
3338                 return -EINVAL;
3339         if (val != 1)
3340                 return -EINVAL;
3341
3342         if (phba->hba_flag & HBA_AER_ENABLED)
3343                 rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);
3344
3345         if (rc == 0)
3346                 return strlen(buf);
3347         else
3348                 return -EPERM;
3349 }
3350
3351 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
3352                    lpfc_aer_cleanup_state);
3353
3354 /**
3355  * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
3356  *
3357  * @dev: class device that is converted into a Scsi_host.
3358  * @attr: device attribute, not used.
3359  * @buf: containing the string the number of vfs to be enabled.
3360  * @count: unused variable.
3361  *
3362  * Description:
3363  * When this api is called either through user sysfs, the driver shall
3364  * try to enable or disable SR-IOV virtual functions according to the
3365  * following:
3366  *
3367  * If zero virtual function has been enabled to the physical function,
3368  * the driver shall invoke the pci enable virtual function api trying
3369  * to enable the virtual functions. If the nr_vfn provided is greater
3370  * than the maximum supported, the maximum virtual function number will
3371  * be used for invoking the api; otherwise, the nr_vfn provided shall
3372  * be used for invoking the api. If the api call returned success, the
3373  * actual number of virtual functions enabled will be set to the driver
3374  * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
3375  * cfg_sriov_nr_virtfn remains zero.
3376  *
3377  * If none-zero virtual functions have already been enabled to the
3378  * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
3379  * -EINVAL will be returned and the driver does nothing;
3380  *
3381  * If the nr_vfn provided is zero and none-zero virtual functions have
3382  * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
3383  * disabling virtual function api shall be invoded to disable all the
3384  * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
3385  * zero. Otherwise, if zero virtual function has been enabled, do
3386  * nothing.
3387  *
3388  * Returns:
3389  * length of the buf on success if val is in range the intended mode
3390  * is supported.
3391  * -EINVAL if val out of range or intended mode is not supported.
3392  **/
3393 static ssize_t
3394 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
3395                          const char *buf, size_t count)
3396 {
3397         struct Scsi_Host *shost = class_to_shost(dev);
3398         struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
3399         struct lpfc_hba *phba = vport->phba;
3400         struct pci_dev *pdev = phba->pcidev;
3401         int val = 0, rc = -EINVAL;
3402
3403         /* Sanity check on user data */
3404         if (!isdigit(buf[0]))
3405                 return -EINVAL;
3406         if (sscanf(buf, "%i", &val) != 1)
3407                 return -EINVAL;
3408         if (val < 0)
3409                 return -EINVAL;
3410
3411         /* Request disabling virtual functions */
3412         if (val == 0) {
3413                 if (phba->cfg_sriov_nr_virtfn > 0) {
3414                         pci_disable_sriov(pdev);
3415                         phba->cfg_sriov_nr_virtfn = 0;
3416                 }
3417                 return strlen(buf);
3418         }
3419
3420         /* Request enabling virtual functions */
3421         if (phba->cfg_sriov_nr_virtfn > 0) {
3422                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3423                                 "3018 There are %d virtual functions "
3424                                 "enabled on physical function.\n",
3425                                 phba->cfg_sriov_nr_virtfn);
3426                 return -EEXIST;
3427         }
3428
3429         if (val <= LPFC_MAX_VFN_PER_PFN)
3430                 phba->cfg_sriov_nr_virtfn = val;
3431         else {
3432                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3433                                 "3019 Enabling %d virtual functions is not "
3434                                 "allowed.\n", val);
3435                 return -EINVAL;
3436         }
3437
3438         rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
3439         if (rc) {
3440                 phba->cfg_sriov_nr_virtfn = 0;
3441                 rc = -EPERM;
3442         } else
3443                 rc = strlen(buf);
3444
3445         return rc;
3446 }
3447
3448 static int lpfc_sriov_nr_virtfn = LPFC_DEF_VFN_PER_PFN;
3449 module_param(lpfc_sriov_nr_virtfn, int, S_IRUGO|S_IWUSR);
3450 MODULE_PARM_DESC(lpfc_sriov_nr_virtfn, "Enable PCIe device SR-IOV virtual fn");
3451 lpfc_param_show(sriov_nr_virtfn)
3452
3453 /**
3454  * lpfc_sriov_nr_virtfn_init - Set the initial sr-iov virtual function enable
3455  * @phba: lpfc_hba pointer.
3456  * @val: link speed value.
3457  *
3458  * Description:
3459  * If val is in a valid range [0,255], then set the adapter's initial
3460  * cfg_sriov_nr_virtfn field. If it's greater than the maximum, the maximum
3461  * number shall be used instead. It will be up to the driver's probe_one
3462  * routine to determine whether the device's SR-IOV is supported or not.
3463  *
3464  * Returns:
3465  * zero if val saved.
3466  * -EINVAL val out of range
3467  **/
3468 static int
3469 lpfc_sriov_nr_virtfn_init(struct lpfc_hba *phba, int val)
3470 {
3471         if (val >= 0 && val <= LPFC_MAX_VFN_PER_PFN) {
3472                 phba->cfg_sriov_nr_virtfn = val;
3473                 return 0;
3474         }
3475
3476         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3477                         "3017 Enabling %d virtual functions is not "
3478                         "allowed.\n", val);
3479         return -EINVAL;
3480 }
3481 static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR,
3482                    lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store);
3483
3484 /*
3485 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
3486 # Value range is [2,3]. Default value is 3.
3487 */
3488 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
3489                   "Select Fibre Channel class of service for FCP sequences");
3490
3491 /*
3492 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
3493 # is [0,1]. Default value is 0.
3494 */
3495 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
3496                    "Use ADISC on rediscovery to authenticate FCP devices");
3497
3498 /*
3499 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
3500 # depth. Default value is 0. When the value of this parameter is zero the
3501 # SCSI command completion time is not used for controlling I/O queue depth. When
3502 # the parameter is set to a non-zero value, the I/O queue depth is controlled
3503 # to limit the I/O completion time to the parameter value.
3504 # The value is set in milliseconds.
3505 */
3506 static int lpfc_max_scsicmpl_time;
3507 module_param(lpfc_max_scsicmpl_time, int, S_IRUGO);
3508 MODULE_PARM_DESC(lpfc_max_scsicmpl_time,
3509         "Use command completion time to control queue depth");
3510 lpfc_vport_param_show(max_scsicmpl_time);
3511 lpfc_vport_param_init(max_scsicmpl_time, 0, 0, 60000);
3512 static int
3513 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
3514 {
3515         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3516         struct lpfc_nodelist *ndlp, *next_ndlp;
3517
3518         if (val == vport->cfg_max_scsicmpl_time)
3519                 return 0;
3520         if ((val < 0) || (val > 60000))
3521                 return -EINVAL;
3522         vport->cfg_max_scsicmpl_time = val;
3523
3524         spin_lock_irq(shost->host_lock);
3525         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
3526                 if (!NLP_CHK_NODE_ACT(ndlp))
3527                         continue;
3528                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
3529                         continue;
3530                 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
3531         }
3532         spin_unlock_irq(shost->host_lock);
3533         return 0;
3534 }
3535 lpfc_vport_param_store(max_scsicmpl_time);
3536 static DEVICE_ATTR(lpfc_max_scsicmpl_time, S_IRUGO | S_IWUSR,
3537                    lpfc_max_scsicmpl_time_show,
3538                    lpfc_max_scsicmpl_time_store);
3539
3540 /*
3541 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
3542 # range is [0,1]. Default value is 0.
3543 */
3544 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
3545
3546 /*
3547 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
3548 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
3549 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
3550 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
3551 # cr_delay is set to 0.
3552 */
3553 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
3554                 "interrupt response is generated");
3555
3556 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
3557                 "interrupt response is generated");
3558
3559 /*
3560 # lpfc_multi_ring_support:  Determines how many rings to spread available
3561 # cmd/rsp IOCB entries across.
3562 # Value range is [1,2]. Default value is 1.
3563 */
3564 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
3565                 "SLI rings to spread IOCB entries across");
3566
3567 /*
3568 # lpfc_multi_ring_rctl:  If lpfc_multi_ring_support is enabled, this
3569 # identifies what rctl value to configure the additional ring for.
3570 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
3571 */
3572 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
3573              255, "Identifies RCTL for additional ring configuration");
3574
3575 /*
3576 # lpfc_multi_ring_type:  If lpfc_multi_ring_support is enabled, this
3577 # identifies what type value to configure the additional ring for.
3578 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
3579 */
3580 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
3581              255, "Identifies TYPE for additional ring configuration");
3582
3583 /*
3584 # lpfc_fdmi_on: controls FDMI support.
3585 #       0 = no FDMI support
3586 #       1 = support FDMI without attribute of hostname
3587 #       2 = support FDMI with attribute of hostname
3588 # Value range [0,2]. Default value is 0.
3589 */
3590 LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support");
3591
3592 /*
3593 # Specifies the maximum number of ELS cmds we can have outstanding (for
3594 # discovery). Value range is [1,64]. Default value = 32.
3595 */
3596 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
3597                  "during discovery");
3598
3599 /*
3600 # lpfc_max_luns: maximum allowed LUN.
3601 # Value range is [0,65535]. Default value is 255.
3602 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
3603 */
3604 LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN");
3605
3606 /*
3607 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
3608 # Value range is [1,255], default value is 10.
3609 */
3610 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
3611              "Milliseconds driver will wait between polling FCP ring");
3612
3613 /*
3614 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
3615 #               support this feature
3616 #       0  = MSI disabled
3617 #       1  = MSI enabled
3618 #       2  = MSI-X enabled (default)
3619 # Value range is [0,2]. Default value is 2.
3620 */
3621 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
3622             "MSI-X (2), if possible");
3623
3624 /*
3625 # lpfc_fcp_imax: Set the maximum number of fast-path FCP interrupts per second
3626 #
3627 # Value range is [636,651042]. Default value is 10000.
3628 */
3629 LPFC_ATTR_R(fcp_imax, LPFC_FP_DEF_IMAX, LPFC_MIM_IMAX, LPFC_DMULT_CONST,
3630             "Set the maximum number of fast-path FCP interrupts per second");
3631
3632 /*
3633 # lpfc_fcp_wq_count: Set the number of fast-path FCP work queues
3634 #
3635 # Value range is [1,31]. Default value is 4.
3636 */
3637 LPFC_ATTR_R(fcp_wq_count, LPFC_FP_WQN_DEF, LPFC_FP_WQN_MIN, LPFC_FP_WQN_MAX,
3638             "Set the number of fast-path FCP work queues, if possible");
3639
3640 /*
3641 # lpfc_fcp_eq_count: Set the number of fast-path FCP event queues
3642 #
3643 # Value range is [1,7]. Default value is 1.
3644 */
3645 LPFC_ATTR_R(fcp_eq_count, LPFC_FP_EQN_DEF, LPFC_FP_EQN_MIN, LPFC_FP_EQN_MAX,
3646             "Set the number of fast-path FCP event queues, if possible");
3647
3648 /*
3649 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
3650 #       0  = HBA resets disabled
3651 #       1  = HBA resets enabled (default)
3652 # Value range is [0,1]. Default value is 1.
3653 */
3654 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
3655
3656 /*
3657 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
3658 #       0  = HBA Heartbeat disabled
3659 #       1  = HBA Heartbeat enabled (default)
3660 # Value range is [0,1]. Default value is 1.
3661 */
3662 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
3663
3664 /*
3665 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
3666 #       0  = BlockGuard disabled (default)
3667 #       1  = BlockGuard enabled
3668 # Value range is [0,1]. Default value is 0.
3669 */
3670 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
3671
3672 /*
3673 # lpfc_prot_mask: i
3674 #       - Bit mask of host protection capabilities used to register with the
3675 #         SCSI mid-layer
3676 #       - Only meaningful if BG is turned on (lpfc_enable_bg=1).
3677 #       - Allows you to ultimately specify which profiles to use
3678 #       - Default will result in registering capabilities for all profiles.
3679 #
3680 */
3681 unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION;
3682
3683 module_param(lpfc_prot_mask, uint, S_IRUGO);
3684 MODULE_PARM_DESC(lpfc_prot_mask, "host protection mask");
3685
3686 /*
3687 # lpfc_prot_guard: i
3688 #       - Bit mask of protection guard types to register with the SCSI mid-layer
3689 #       - Guard types are currently either 1) IP checksum 2) T10-DIF CRC
3690 #       - Allows you to ultimately specify which profiles to use
3691 #       - Default will result in registering capabilities for all guard types
3692 #
3693 */
3694 unsigned char lpfc_prot_guard = SHOST_DIX_GUARD_IP;
3695 module_param(lpfc_prot_guard, byte, S_IRUGO);
3696 MODULE_PARM_DESC(lpfc_prot_guard, "host protection guard type");
3697
3698 /*
3699  * Delay initial NPort discovery when Clean Address bit is cleared in
3700  * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
3701  * This parameter can have value 0 or 1.
3702  * When this parameter is set to 0, no delay is added to the initial
3703  * discovery.
3704  * When this parameter is set to non-zero value, initial Nport discovery is
3705  * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
3706  * accept and FCID/Fabric name/Fabric portname is changed.
3707  * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
3708  * when Clean Address bit is cleared in FLOGI/FDISC
3709  * accept and FCID/Fabric name/Fabric portname is changed.
3710  * Default value is 0.
3711  */
3712 int lpfc_delay_discovery;
3713 module_param(lpfc_delay_discovery, int, S_IRUGO);
3714 MODULE_PARM_DESC(lpfc_delay_discovery,
3715         "Delay NPort discovery when Clean Address bit is cleared. "
3716         "Allowed values: 0,1.");
3717
3718 /*
3719  * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
3720  * This value can be set to values between 64 and 256. The default value is
3721  * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
3722  * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
3723  */
3724 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
3725             LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
3726
3727 LPFC_ATTR_R(prot_sg_seg_cnt, LPFC_DEFAULT_PROT_SG_SEG_CNT,
3728                 LPFC_DEFAULT_PROT_SG_SEG_CNT, LPFC_MAX_PROT_SG_SEG_CNT,
3729                 "Max Protection Scatter Gather Segment Count");
3730
3731 struct device_attribute *lpfc_hba_attrs[] = {
3732         &dev_attr_bg_info,
3733         &dev_attr_bg_guard_err,
3734         &dev_attr_bg_apptag_err,
3735         &dev_attr_bg_reftag_err,
3736         &dev_attr_info,
3737         &dev_attr_serialnum,
3738         &dev_attr_modeldesc,
3739         &dev_attr_modelname,
3740         &dev_attr_programtype,
3741         &dev_attr_portnum,
3742         &dev_attr_fwrev,
3743         &dev_attr_hdw,
3744         &dev_attr_option_rom_version,
3745         &dev_attr_link_state,
3746         &dev_attr_num_discovered_ports,
3747         &dev_attr_menlo_mgmt_mode,
3748         &dev_attr_lpfc_drvr_version,
3749         &dev_attr_lpfc_enable_fip,
3750         &dev_attr_lpfc_temp_sensor,
3751         &dev_attr_lpfc_log_verbose,
3752         &dev_attr_lpfc_lun_queue_depth,
3753         &dev_attr_lpfc_tgt_queue_depth,
3754         &dev_attr_lpfc_hba_queue_depth,
3755         &dev_attr_lpfc_peer_port_login,
3756         &dev_attr_lpfc_nodev_tmo,
3757         &dev_attr_lpfc_devloss_tmo,
3758         &dev_attr_lpfc_fcp_class,
3759         &dev_attr_lpfc_use_adisc,
3760         &dev_attr_lpfc_ack0,
3761         &dev_attr_lpfc_topology,
3762         &dev_attr_lpfc_scan_down,
3763         &dev_attr_lpfc_link_speed,
3764         &dev_attr_lpfc_cr_delay,
3765         &dev_attr_lpfc_cr_count,
3766         &dev_attr_lpfc_multi_ring_support,
3767         &dev_attr_lpfc_multi_ring_rctl,
3768         &dev_attr_lpfc_multi_ring_type,
3769         &dev_attr_lpfc_fdmi_on,
3770         &dev_attr_lpfc_max_luns,
3771         &dev_attr_lpfc_enable_npiv,
3772         &dev_attr_lpfc_enable_rrq,
3773         &dev_attr_nport_evt_cnt,
3774         &dev_attr_board_mode,
3775         &dev_attr_max_vpi,
3776         &dev_attr_used_vpi,
3777         &dev_attr_max_rpi,
3778         &dev_attr_used_rpi,
3779         &dev_attr_max_xri,
3780         &dev_attr_used_xri,
3781         &dev_attr_npiv_info,
3782         &dev_attr_issue_reset,
3783         &dev_attr_lpfc_poll,
3784         &dev_attr_lpfc_poll_tmo,
3785         &dev_attr_lpfc_use_msi,
3786         &dev_attr_lpfc_fcp_imax,
3787         &dev_attr_lpfc_fcp_wq_count,
3788         &dev_attr_lpfc_fcp_eq_count,
3789         &dev_attr_lpfc_enable_bg,
3790         &dev_attr_lpfc_soft_wwnn,
3791         &dev_attr_lpfc_soft_wwpn,
3792         &dev_attr_lpfc_soft_wwn_enable,
3793         &dev_attr_lpfc_enable_hba_reset,
3794         &dev_attr_lpfc_enable_hba_heartbeat,
3795         &dev_attr_lpfc_sg_seg_cnt,
3796         &dev_attr_lpfc_max_scsicmpl_time,
3797         &dev_attr_lpfc_stat_data_ctrl,
3798         &dev_attr_lpfc_prot_sg_seg_cnt,
3799         &dev_attr_lpfc_aer_support,
3800         &dev_attr_lpfc_aer_state_cleanup,
3801         &dev_attr_lpfc_sriov_nr_virtfn,
3802         &dev_attr_lpfc_suppress_link_up,
3803         &dev_attr_lpfc_iocb_cnt,
3804         &dev_attr_iocb_hw,
3805         &dev_attr_txq_hw,
3806         &dev_attr_txcmplq_hw,
3807         &dev_attr_lpfc_fips_level,
3808         &dev_attr_lpfc_fips_rev,
3809         &dev_attr_lpfc_dss,
3810         &dev_attr_lpfc_sriov_hw_max_virtfn,
3811         NULL,
3812 };
3813
3814 struct device_attribute *lpfc_vport_attrs[] = {
3815         &dev_attr_info,
3816         &dev_attr_link_state,
3817         &dev_attr_num_discovered_ports,
3818         &dev_attr_lpfc_drvr_version,
3819         &dev_attr_lpfc_log_verbose,
3820         &dev_attr_lpfc_lun_queue_depth,
3821         &dev_attr_lpfc_tgt_queue_depth,
3822         &dev_attr_lpfc_nodev_tmo,
3823         &dev_attr_lpfc_devloss_tmo,
3824         &dev_attr_lpfc_hba_queue_depth,
3825         &dev_attr_lpfc_peer_port_login,
3826         &dev_attr_lpfc_restrict_login,
3827         &dev_attr_lpfc_fcp_class,
3828         &dev_attr_lpfc_use_adisc,
3829         &dev_attr_lpfc_fdmi_on,
3830         &dev_attr_lpfc_max_luns,
3831         &dev_attr_nport_evt_cnt,
3832         &dev_attr_npiv_info,
3833         &dev_attr_lpfc_enable_da_id,
3834         &dev_attr_lpfc_max_scsicmpl_time,
3835         &dev_attr_lpfc_stat_data_ctrl,
3836         &dev_attr_lpfc_static_vport,
3837         &dev_attr_lpfc_fips_level,
3838         &dev_attr_lpfc_fips_rev,
3839         NULL,
3840 };
3841
3842 /**
3843  * sysfs_ctlreg_write - Write method for writing to ctlreg
3844  * @filp: open sysfs file
3845  * @kobj: kernel kobject that contains the kernel class device.
3846  * @bin_attr: kernel attributes passed to us.
3847  * @buf: contains the data to be written to the adapter IOREG space.
3848  * @off: offset into buffer to beginning of data.
3849  * @count: bytes to transfer.
3850  *
3851  * Description:
3852  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
3853  * Uses the adapter io control registers to send buf contents to the adapter.
3854  *
3855  * Returns:
3856  * -ERANGE off and count combo out of range
3857  * -EINVAL off, count or buff address invalid
3858  * -EPERM adapter is offline
3859  * value of count, buf contents written
3860  **/
3861 static ssize_t
3862 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
3863                    struct bin_attribute *bin_attr,
3864                    char *buf, loff_t off, size_t count)
3865 {
3866         size_t buf_off;
3867         struct device *dev = container_of(kobj, struct device, kobj);
3868         struct Scsi_Host  *shost = class_to_shost(dev);
3869         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3870         struct lpfc_hba   *phba = vport->phba;
3871
3872         if (phba->sli_rev >= LPFC_SLI_REV4)
3873                 return -EPERM;
3874
3875         if ((off + count) > FF_REG_AREA_SIZE)
3876                 return -ERANGE;
3877
3878         if (count == 0) return 0;
3879
3880         if (off % 4 || count % 4 || (unsigned long)buf % 4)
3881                 return -EINVAL;
3882
3883         if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
3884                 return -EPERM;
3885         }
3886
3887         spin_lock_irq(&phba->hbalock);
3888         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t))
3889                 writel(*((uint32_t *)(buf + buf_off)),
3890                        phba->ctrl_regs_memmap_p + off + buf_off);
3891
3892         spin_unlock_irq(&phba->hbalock);
3893
3894         return count;
3895 }
3896
3897 /**
3898  * sysfs_ctlreg_read - Read method for reading from ctlreg
3899  * @filp: open sysfs file
3900  * @kobj: kernel kobject that contains the kernel class device.
3901  * @bin_attr: kernel attributes passed to us.
3902  * @buf: if successful contains the data from the adapter IOREG space.
3903  * @off: offset into buffer to beginning of data.
3904  * @count: bytes to transfer.
3905  *
3906  * Description:
3907  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
3908  * Uses the adapter io control registers to read data into buf.
3909  *
3910  * Returns:
3911  * -ERANGE off and count combo out of range
3912  * -EINVAL off, count or buff address invalid
3913  * value of count, buf contents read
3914  **/
3915 static ssize_t
3916 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
3917                   struct bin_attribute *bin_attr,
3918                   char *buf, loff_t off, size_t count)
3919 {
3920         size_t buf_off;
3921         uint32_t * tmp_ptr;
3922         struct device *dev = container_of(kobj, struct device, kobj);
3923         struct Scsi_Host  *shost = class_to_shost(dev);
3924         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3925         struct lpfc_hba   *phba = vport->phba;
3926
3927         if (phba->sli_rev >= LPFC_SLI_REV4)
3928                 return -EPERM;
3929
3930         if (off > FF_REG_AREA_SIZE)
3931                 return -ERANGE;
3932
3933         if ((off + count) > FF_REG_AREA_SIZE)
3934                 count = FF_REG_AREA_SIZE - off;
3935
3936         if (count == 0) return 0;
3937
3938         if (off % 4 || count % 4 || (unsigned long)buf % 4)
3939                 return -EINVAL;
3940
3941         spin_lock_irq(&phba->hbalock);
3942
3943         for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
3944                 tmp_ptr = (uint32_t *)(buf + buf_off);
3945                 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
3946         }
3947
3948         spin_unlock_irq(&phba->hbalock);
3949
3950         return count;
3951 }
3952
3953 static struct bin_attribute sysfs_ctlreg_attr = {
3954         .attr = {
3955                 .name = "ctlreg",
3956                 .mode = S_IRUSR | S_IWUSR,
3957         },
3958         .size = 256,
3959         .read = sysfs_ctlreg_read,
3960         .write = sysfs_ctlreg_write,
3961 };
3962
3963 /**
3964  * sysfs_mbox_idle - frees the sysfs mailbox
3965  * @phba: lpfc_hba pointer
3966  **/
3967 static void
3968 sysfs_mbox_idle(struct lpfc_hba *phba)
3969 {
3970         phba->sysfs_mbox.state = SMBOX_IDLE;
3971         phba->sysfs_mbox.offset = 0;
3972
3973         if (phba->sysfs_mbox.mbox) {
3974                 mempool_free(phba->sysfs_mbox.mbox,
3975                              phba->mbox_mem_pool);
3976                 phba->sysfs_mbox.mbox = NULL;
3977         }
3978 }
3979
3980 /**
3981  * sysfs_mbox_write - Write method for writing information via mbox
3982  * @filp: open sysfs file
3983  * @kobj: kernel kobject that contains the kernel class device.
3984  * @bin_attr: kernel attributes passed to us.
3985  * @buf: contains the data to be written to sysfs mbox.
3986  * @off: offset into buffer to beginning of data.
3987  * @count: bytes to transfer.
3988  *
3989  * Description:
3990  * Accessed via /sys/class/scsi_host/hostxxx/mbox.
3991  * Uses the sysfs mbox to send buf contents to the adapter.
3992  *
3993  * Returns:
3994  * -ERANGE off and count combo out of range
3995  * -EINVAL off, count or buff address invalid
3996  * zero if count is zero
3997  * -EPERM adapter is offline
3998  * -ENOMEM failed to allocate memory for the mail box
3999  * -EAGAIN offset, state or mbox is NULL
4000  * count number of bytes transferred
4001  **/
4002 static ssize_t
4003 sysfs_mbox_write(struct file *filp, struct kobject *kobj,
4004                  struct bin_attribute *bin_attr,
4005                  char *buf, loff_t off, size_t count)
4006 {
4007         struct device *dev = container_of(kobj, struct device, kobj);
4008         struct Scsi_Host  *shost = class_to_shost(dev);
4009         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4010         struct lpfc_hba   *phba = vport->phba;
4011         struct lpfcMboxq  *mbox = NULL;
4012
4013         if ((count + off) > MAILBOX_CMD_SIZE)
4014                 return -ERANGE;
4015
4016         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
4017                 return -EINVAL;
4018
4019         if (count == 0)
4020                 return 0;
4021
4022         if (off == 0) {
4023                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4024                 if (!mbox)
4025                         return -ENOMEM;
4026                 memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
4027         }
4028
4029         spin_lock_irq(&phba->hbalock);
4030
4031         if (off == 0) {
4032                 if (phba->sysfs_mbox.mbox)
4033                         mempool_free(mbox, phba->mbox_mem_pool);
4034                 else
4035                         phba->sysfs_mbox.mbox = mbox;
4036                 phba->sysfs_mbox.state = SMBOX_WRITING;
4037         } else {
4038                 if (phba->sysfs_mbox.state  != SMBOX_WRITING ||
4039                     phba->sysfs_mbox.offset != off           ||
4040                     phba->sysfs_mbox.mbox   == NULL) {
4041                         sysfs_mbox_idle(phba);
4042                         spin_unlock_irq(&phba->hbalock);
4043                         return -EAGAIN;
4044                 }
4045         }
4046
4047         memcpy((uint8_t *) &phba->sysfs_mbox.mbox->u.mb + off,
4048                buf, count);
4049
4050         phba->sysfs_mbox.offset = off + count;
4051
4052         spin_unlock_irq(&phba->hbalock);
4053
4054         return count;
4055 }
4056
4057 /**
4058  * sysfs_mbox_read - Read method for reading information via mbox
4059  * @filp: open sysfs file
4060  * @kobj: kernel kobject that contains the kernel class device.
4061  * @bin_attr: kernel attributes passed to us.
4062  * @buf: contains the data to be read from sysfs mbox.
4063  * @off: offset into buffer to beginning of data.
4064  * @count: bytes to transfer.
4065  *
4066  * Description:
4067  * Accessed via /sys/class/scsi_host/hostxxx/mbox.
4068  * Uses the sysfs mbox to receive data from to the adapter.
4069  *
4070  * Returns:
4071  * -ERANGE off greater than mailbox command size
4072  * -EINVAL off, count or buff address invalid
4073  * zero if off and count are zero
4074  * -EACCES adapter over temp
4075  * -EPERM garbage can value to catch a multitude of errors
4076  * -EAGAIN management IO not permitted, state or off error
4077  * -ETIME mailbox timeout
4078  * -ENODEV mailbox error
4079  * count number of bytes transferred
4080  **/
4081 static ssize_t
4082 sysfs_mbox_read(struct file *filp, struct kobject *kobj,
4083                 struct bin_attribute *bin_attr,
4084                 char *buf, loff_t off, size_t count)
4085 {
4086         struct device *dev = container_of(kobj, struct device, kobj);
4087         struct Scsi_Host  *shost = class_to_shost(dev);
4088         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4089         struct lpfc_hba   *phba = vport->phba;
4090         int rc;
4091         MAILBOX_t *pmb;
4092
4093         if (off > MAILBOX_CMD_SIZE)
4094                 return -ERANGE;
4095
4096         if ((count + off) > MAILBOX_CMD_SIZE)
4097                 count = MAILBOX_CMD_SIZE - off;
4098
4099         if (off % 4 ||  count % 4 || (unsigned long)buf % 4)
4100                 return -EINVAL;
4101
4102         if (off && count == 0)
4103                 return 0;
4104
4105         spin_lock_irq(&phba->hbalock);
4106
4107         if (phba->over_temp_state == HBA_OVER_TEMP) {
4108                 sysfs_mbox_idle(phba);
4109                 spin_unlock_irq(&phba->hbalock);
4110                 return  -EACCES;
4111         }
4112
4113         if (off == 0 &&
4114             phba->sysfs_mbox.state  == SMBOX_WRITING &&
4115             phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
4116                 pmb = &phba->sysfs_mbox.mbox->u.mb;
4117                 switch (pmb->mbxCommand) {
4118                         /* Offline only */
4119                 case MBX_INIT_LINK:
4120                 case MBX_DOWN_LINK:
4121                 case MBX_CONFIG_LINK:
4122                 case MBX_CONFIG_RING:
4123                 case MBX_RESET_RING:
4124                 case MBX_UNREG_LOGIN:
4125                 case MBX_CLEAR_LA:
4126                 case MBX_DUMP_CONTEXT:
4127                 case MBX_RUN_DIAGS:
4128                 case MBX_RESTART:
4129                 case MBX_SET_MASK:
4130                 case MBX_SET_DEBUG:
4131                         if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
4132                                 printk(KERN_WARNING "mbox_read:Command 0x%x "
4133                                        "is illegal in on-line state\n",
4134                                        pmb->mbxCommand);
4135                                 sysfs_mbox_idle(phba);
4136                                 spin_unlock_irq(&phba->hbalock);
4137                                 return -EPERM;
4138                         }
4139                 case MBX_WRITE_NV:
4140                 case MBX_WRITE_VPARMS:
4141                 case MBX_LOAD_SM:
4142                 case MBX_READ_NV:
4143                 case MBX_READ_CONFIG:
4144                 case MBX_READ_RCONFIG:
4145                 case MBX_READ_STATUS:
4146                 case MBX_READ_XRI:
4147                 case MBX_READ_REV:
4148                 case MBX_READ_LNK_STAT:
4149                 case MBX_DUMP_MEMORY:
4150                 case MBX_DOWN_LOAD:
4151                 case MBX_UPDATE_CFG:
4152                 case MBX_KILL_BOARD:
4153                 case MBX_LOAD_AREA:
4154                 case MBX_LOAD_EXP_ROM:
4155                 case MBX_BEACON:
4156                 case MBX_DEL_LD_ENTRY:
4157                 case MBX_SET_VARIABLE:
4158                 case MBX_WRITE_WWN:
4159                 case MBX_PORT_CAPABILITIES:
4160                 case MBX_PORT_IOV_CONTROL:
4161                         break;
4162                 case MBX_SECURITY_MGMT:
4163                 case MBX_AUTH_PORT:
4164                         if (phba->pci_dev_grp == LPFC_PCI_DEV_OC) {
4165                                 printk(KERN_WARNING "mbox_read:Command 0x%x "
4166                                        "is not permitted\n", pmb->mbxCommand);
4167                                 sysfs_mbox_idle(phba);
4168                                 spin_unlock_irq(&phba->hbalock);
4169                                 return -EPERM;
4170                         }
4171                         break;
4172                 case MBX_READ_SPARM64:
4173                 case MBX_READ_TOPOLOGY:
4174                 case MBX_REG_LOGIN:
4175                 case MBX_REG_LOGIN64:
4176                 case MBX_CONFIG_PORT:
4177                 case MBX_RUN_BIU_DIAG:
4178                         printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
4179                                pmb->mbxCommand);
4180                         sysfs_mbox_idle(phba);
4181                         spin_unlock_irq(&phba->hbalock);
4182                         return -EPERM;
4183                 default:
4184                         printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
4185                                pmb->mbxCommand);
4186                         sysfs_mbox_idle(phba);
4187                         spin_unlock_irq(&phba->hbalock);
4188                         return -EPERM;
4189                 }
4190
4191                 /* If HBA encountered an error attention, allow only DUMP
4192                  * or RESTART mailbox commands until the HBA is restarted.
4193                  */
4194                 if (phba->pport->stopped &&
4195                     pmb->mbxCommand != MBX_DUMP_MEMORY &&
4196                     pmb->mbxCommand != MBX_RESTART &&
4197                     pmb->mbxCommand != MBX_WRITE_VPARMS &&
4198                     pmb->mbxCommand != MBX_WRITE_WWN)
4199                         lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
4200                                         "1259 mbox: Issued mailbox cmd "
4201                                         "0x%x while in stopped state.\n",
4202                                         pmb->mbxCommand);
4203
4204                 phba->sysfs_mbox.mbox->vport = vport;
4205
4206                 /* Don't allow mailbox commands to be sent when blocked
4207                  * or when in the middle of discovery
4208                  */
4209                 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
4210                         sysfs_mbox_idle(phba);
4211                         spin_unlock_irq(&phba->hbalock);
4212                         return  -EAGAIN;
4213                 }
4214
4215                 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4216                     (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE))) {
4217
4218                         spin_unlock_irq(&phba->hbalock);
4219                         rc = lpfc_sli_issue_mbox (phba,
4220                                                   phba->sysfs_mbox.mbox,
4221                                                   MBX_POLL);
4222                         spin_lock_irq(&phba->hbalock);
4223
4224                 } else {
4225                         spin_unlock_irq(&phba->hbalock);
4226                         rc = lpfc_sli_issue_mbox_wait (phba,
4227                                                        phba->sysfs_mbox.mbox,
4228                                 lpfc_mbox_tmo_val(phba, pmb->mbxCommand) * HZ);
4229                         spin_lock_irq(&phba->hbalock);
4230                 }
4231
4232                 if (rc != MBX_SUCCESS) {
4233                         if (rc == MBX_TIMEOUT) {
4234                                 phba->sysfs_mbox.mbox = NULL;
4235                         }
4236                         sysfs_mbox_idle(phba);
4237                         spin_unlock_irq(&phba->hbalock);
4238                         return  (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
4239                 }
4240                 phba->sysfs_mbox.state = SMBOX_READING;
4241         }
4242         else if (phba->sysfs_mbox.offset != off ||
4243                  phba->sysfs_mbox.state  != SMBOX_READING) {
4244                 printk(KERN_WARNING  "mbox_read: Bad State\n");
4245                 sysfs_mbox_idle(phba);
4246                 spin_unlock_irq(&phba->hbalock);
4247                 return -EAGAIN;
4248         }
4249
4250         memcpy(buf, (uint8_t *) &pmb + off, count);
4251
4252         phba->sysfs_mbox.offset = off + count;
4253
4254         if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
4255                 sysfs_mbox_idle(phba);
4256
4257         spin_unlock_irq(&phba->hbalock);
4258
4259         return count;
4260 }
4261
4262 static struct bin_attribute sysfs_mbox_attr = {
4263         .attr = {
4264                 .name = "mbox",
4265                 .mode = S_IRUSR | S_IWUSR,
4266         },
4267         .size = MAILBOX_SYSFS_MAX,
4268         .read = sysfs_mbox_read,
4269         .write = sysfs_mbox_write,
4270 };
4271
4272 /**
4273  * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
4274  * @vport: address of lpfc vport structure.
4275  *
4276  * Return codes:
4277  * zero on success
4278  * error return code from sysfs_create_bin_file()
4279  **/
4280 int
4281 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
4282 {
4283         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4284         int error;
4285
4286         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4287                                       &sysfs_drvr_stat_data_attr);
4288
4289         /* Virtual ports do not need ctrl_reg and mbox */
4290         if (error || vport->port_type == LPFC_NPIV_PORT)
4291                 goto out;
4292
4293         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4294                                       &sysfs_ctlreg_attr);
4295         if (error)
4296                 goto out_remove_stat_attr;
4297
4298         error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4299                                       &sysfs_mbox_attr);
4300         if (error)
4301                 goto out_remove_ctlreg_attr;
4302
4303         return 0;
4304 out_remove_ctlreg_attr:
4305         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
4306 out_remove_stat_attr:
4307         sysfs_remove_bin_file(&shost->shost_dev.kobj,
4308                         &sysfs_drvr_stat_data_attr);
4309 out:
4310         return error;
4311 }
4312
4313 /**
4314  * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
4315  * @vport: address of lpfc vport structure.
4316  **/
4317 void
4318 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
4319 {
4320         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4321         sysfs_remove_bin_file(&shost->shost_dev.kobj,
4322                 &sysfs_drvr_stat_data_attr);
4323         /* Virtual ports do not need ctrl_reg and mbox */
4324         if (vport->port_type == LPFC_NPIV_PORT)
4325                 return;
4326         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
4327         sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
4328 }
4329
4330
4331 /*
4332  * Dynamic FC Host Attributes Support
4333  */
4334
4335 /**
4336  * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
4337  * @shost: kernel scsi host pointer.
4338  **/
4339 static void
4340 lpfc_get_host_port_id(struct Scsi_Host *shost)
4341 {
4342         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4343
4344         /* note: fc_myDID already in cpu endianness */
4345         fc_host_port_id(shost) = vport->fc_myDID;
4346 }
4347
4348 /**
4349  * lpfc_get_host_port_type - Set the value of the scsi host port type
4350  * @shost: kernel scsi host pointer.
4351  **/
4352 static void
4353 lpfc_get_host_port_type(struct Scsi_Host *shost)
4354 {
4355         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4356         struct lpfc_hba   *phba = vport->phba;
4357
4358         spin_lock_irq(shost->host_lock);
4359
4360         if (vport->port_type == LPFC_NPIV_PORT) {
4361                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
4362         } else if (lpfc_is_link_up(phba)) {
4363                 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4364                         if (vport->fc_flag & FC_PUBLIC_LOOP)
4365                                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
4366                         else
4367                                 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
4368                 } else {
4369                         if (vport->fc_flag & FC_FABRIC)
4370                                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
4371                         else
4372                                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
4373                 }
4374         } else
4375                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
4376
4377         spin_unlock_irq(shost->host_lock);
4378 }
4379
4380 /**
4381  * lpfc_get_host_port_state - Set the value of the scsi host port state
4382  * @shost: kernel scsi host pointer.
4383  **/
4384 static void
4385 lpfc_get_host_port_state(struct Scsi_Host *shost)
4386 {
4387         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4388         struct lpfc_hba   *phba = vport->phba;
4389
4390         spin_lock_irq(shost->host_lock);
4391
4392         if (vport->fc_flag & FC_OFFLINE_MODE)
4393                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
4394         else {
4395                 switch (phba->link_state) {
4396                 case LPFC_LINK_UNKNOWN:
4397                 case LPFC_LINK_DOWN:
4398                         fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
4399                         break;
4400                 case LPFC_LINK_UP:
4401                 case LPFC_CLEAR_LA:
4402                 case LPFC_HBA_READY:
4403                         /* Links up, beyond this port_type reports state */
4404                         fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
4405                         break;
4406                 case LPFC_HBA_ERROR:
4407                         fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
4408                         break;
4409                 default:
4410                         fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
4411                         break;
4412                 }
4413         }
4414
4415         spin_unlock_irq(shost->host_lock);
4416 }
4417
4418 /**
4419  * lpfc_get_host_speed - Set the value of the scsi host speed
4420  * @shost: kernel scsi host pointer.
4421  **/
4422 static void
4423 lpfc_get_host_speed(struct Scsi_Host *shost)
4424 {
4425         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4426         struct lpfc_hba   *phba = vport->phba;
4427
4428         spin_lock_irq(shost->host_lock);
4429
4430         if (lpfc_is_link_up(phba)) {
4431                 switch(phba->fc_linkspeed) {
4432                 case LPFC_LINK_SPEED_1GHZ:
4433                         fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
4434                         break;
4435                 case LPFC_LINK_SPEED_2GHZ:
4436                         fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
4437                         break;
4438                 case LPFC_LINK_SPEED_4GHZ:
4439                         fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
4440                         break;
4441                 case LPFC_LINK_SPEED_8GHZ:
4442                         fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
4443                         break;
4444                 case LPFC_LINK_SPEED_10GHZ:
4445                         fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
4446                         break;
4447                 case LPFC_LINK_SPEED_16GHZ:
4448                         fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
4449                         break;
4450                 default:
4451                         fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
4452                         break;
4453                 }
4454         } else
4455                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
4456
4457         spin_unlock_irq(shost->host_lock);
4458 }
4459
4460 /**
4461  * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
4462  * @shost: kernel scsi host pointer.
4463  **/
4464 static void
4465 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
4466 {
4467         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4468         struct lpfc_hba   *phba = vport->phba;
4469         u64 node_name;
4470
4471         spin_lock_irq(shost->host_lock);
4472
4473         if ((vport->fc_flag & FC_FABRIC) ||
4474             ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
4475              (vport->fc_flag & FC_PUBLIC_LOOP)))
4476                 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
4477         else
4478                 /* fabric is local port if there is no F/FL_Port */
4479                 node_name = 0;
4480
4481         spin_unlock_irq(shost->host_lock);
4482
4483         fc_host_fabric_name(shost) = node_name;
4484 }
4485
4486 /**
4487  * lpfc_get_stats - Return statistical information about the adapter
4488  * @shost: kernel scsi host pointer.
4489  *
4490  * Notes:
4491  * NULL on error for link down, no mbox pool, sli2 active,
4492  * management not allowed, memory allocation error, or mbox error.
4493  *
4494  * Returns:
4495  * NULL for error
4496  * address of the adapter host statistics
4497  **/
4498 static struct fc_host_statistics *
4499 lpfc_get_stats(struct Scsi_Host *shost)
4500 {
4501         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4502         struct lpfc_hba   *phba = vport->phba;
4503         struct lpfc_sli   *psli = &phba->sli;
4504         struct fc_host_statistics *hs = &phba->link_stats;
4505         struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
4506         LPFC_MBOXQ_t *pmboxq;
4507         MAILBOX_t *pmb;
4508         unsigned long seconds;
4509         int rc = 0;
4510
4511         /*
4512          * prevent udev from issuing mailbox commands until the port is
4513          * configured.
4514          */
4515         if (phba->link_state < LPFC_LINK_DOWN ||
4516             !phba->mbox_mem_pool ||
4517             (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
4518                 return NULL;
4519
4520         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
4521                 return NULL;
4522
4523         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4524         if (!pmboxq)
4525                 return NULL;
4526         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
4527
4528         pmb = &pmboxq->u.mb;
4529         pmb->mbxCommand = MBX_READ_STATUS;
4530         pmb->mbxOwner = OWN_HOST;
4531         pmboxq->context1 = NULL;
4532         pmboxq->vport = vport;
4533
4534         if (vport->fc_flag & FC_OFFLINE_MODE)
4535                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4536         else
4537                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4538
4539         if (rc != MBX_SUCCESS) {
4540                 if (rc != MBX_TIMEOUT)
4541                         mempool_free(pmboxq, phba->mbox_mem_pool);
4542                 return NULL;
4543         }
4544
4545         memset(hs, 0, sizeof (struct fc_host_statistics));
4546
4547         hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
4548         hs->tx_words = (pmb->un.varRdStatus.xmitByteCnt * 256);
4549         hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
4550         hs->rx_words = (pmb->un.varRdStatus.rcvByteCnt * 256);
4551
4552         memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
4553         pmb->mbxCommand = MBX_READ_LNK_STAT;
4554         pmb->mbxOwner = OWN_HOST;
4555         pmboxq->context1 = NULL;
4556         pmboxq->vport = vport;
4557
4558         if (vport->fc_flag & FC_OFFLINE_MODE)
4559                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4560         else
4561                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4562
4563         if (rc != MBX_SUCCESS) {
4564                 if (rc != MBX_TIMEOUT)
4565                         mempool_free(pmboxq, phba->mbox_mem_pool);
4566                 return NULL;
4567         }
4568
4569         hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
4570         hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
4571         hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
4572         hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
4573         hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
4574         hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
4575         hs->error_frames = pmb->un.varRdLnk.crcCnt;
4576
4577         hs->link_failure_count -= lso->link_failure_count;
4578         hs->loss_of_sync_count -= lso->loss_of_sync_count;
4579         hs->loss_of_signal_count -= lso->loss_of_signal_count;
4580         hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
4581         hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
4582         hs->invalid_crc_count -= lso->invalid_crc_count;
4583         hs->error_frames -= lso->error_frames;
4584
4585         if (phba->hba_flag & HBA_FCOE_MODE) {
4586                 hs->lip_count = -1;
4587                 hs->nos_count = (phba->link_events >> 1);
4588                 hs->nos_count -= lso->link_events;
4589         } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4590                 hs->lip_count = (phba->fc_eventTag >> 1);
4591                 hs->lip_count -= lso->link_events;
4592                 hs->nos_count = -1;
4593         } else {
4594                 hs->lip_count = -1;
4595                 hs->nos_count = (phba->fc_eventTag >> 1);
4596                 hs->nos_count -= lso->link_events;
4597         }
4598
4599         hs->dumped_frames = -1;
4600
4601         seconds = get_seconds();
4602         if (seconds < psli->stats_start)
4603                 hs->seconds_since_last_reset = seconds +
4604                                 ((unsigned long)-1 - psli->stats_start);
4605         else
4606                 hs->seconds_since_last_reset = seconds - psli->stats_start;
4607
4608         mempool_free(pmboxq, phba->mbox_mem_pool);
4609
4610         return hs;
4611 }
4612
4613 /**
4614  * lpfc_reset_stats - Copy the adapter link stats information
4615  * @shost: kernel scsi host pointer.
4616  **/
4617 static void
4618 lpfc_reset_stats(struct Scsi_Host *shost)
4619 {
4620         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4621         struct lpfc_hba   *phba = vport->phba;
4622         struct lpfc_sli   *psli = &phba->sli;
4623         struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
4624         LPFC_MBOXQ_t *pmboxq;
4625         MAILBOX_t *pmb;
4626         int rc = 0;
4627
4628         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
4629                 return;
4630
4631         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4632         if (!pmboxq)
4633                 return;
4634         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4635
4636         pmb = &pmboxq->u.mb;
4637         pmb->mbxCommand = MBX_READ_STATUS;
4638         pmb->mbxOwner = OWN_HOST;
4639         pmb->un.varWords[0] = 0x1; /* reset request */
4640         pmboxq->context1 = NULL;
4641         pmboxq->vport = vport;
4642
4643         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4644                 (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
4645                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4646         else
4647                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4648
4649         if (rc != MBX_SUCCESS) {
4650                 if (rc != MBX_TIMEOUT)
4651                         mempool_free(pmboxq, phba->mbox_mem_pool);
4652                 return;
4653         }
4654
4655         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4656         pmb->mbxCommand = MBX_READ_LNK_STAT;
4657         pmb->mbxOwner = OWN_HOST;
4658         pmboxq->context1 = NULL;
4659         pmboxq->vport = vport;
4660
4661         if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4662             (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
4663                 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4664         else
4665                 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4666
4667         if (rc != MBX_SUCCESS) {
4668                 if (rc != MBX_TIMEOUT)
4669                         mempool_free( pmboxq, phba->mbox_mem_pool);
4670                 return;
4671         }
4672
4673         lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
4674         lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
4675         lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
4676         lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
4677         lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
4678         lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
4679         lso->error_frames = pmb->un.varRdLnk.crcCnt;
4680         if (phba->hba_flag & HBA_FCOE_MODE)
4681                 lso->link_events = (phba->link_events >> 1);
4682         else
4683                 lso->link_events = (phba->fc_eventTag >> 1);
4684
4685         psli->stats_start = get_seconds();
4686
4687         mempool_free(pmboxq, phba->mbox_mem_pool);
4688
4689         return;
4690 }
4691
4692 /*
4693  * The LPFC driver treats linkdown handling as target loss events so there
4694  * are no sysfs handlers for link_down_tmo.
4695  */
4696
4697 /**
4698  * lpfc_get_node_by_target - Return the nodelist for a target
4699  * @starget: kernel scsi target pointer.
4700  *
4701  * Returns:
4702  * address of the node list if found
4703  * NULL target not found
4704  **/
4705 static struct lpfc_nodelist *
4706 lpfc_get_node_by_target(struct scsi_target *starget)
4707 {
4708         struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
4709         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4710         struct lpfc_nodelist *ndlp;
4711
4712         spin_lock_irq(shost->host_lock);
4713         /* Search for this, mapped, target ID */
4714         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
4715                 if (NLP_CHK_NODE_ACT(ndlp) &&
4716                     ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
4717                     starget->id == ndlp->nlp_sid) {
4718                         spin_unlock_irq(shost->host_lock);
4719                         return ndlp;
4720                 }
4721         }
4722         spin_unlock_irq(shost->host_lock);
4723         return NULL;
4724 }
4725
4726 /**
4727  * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
4728  * @starget: kernel scsi target pointer.
4729  **/
4730 static void
4731 lpfc_get_starget_port_id(struct scsi_target *starget)
4732 {
4733         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
4734
4735         fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
4736 }
4737
4738 /**
4739  * lpfc_get_starget_node_name - Set the target node name
4740  * @starget: kernel scsi target pointer.
4741  *
4742  * Description: Set the target node name to the ndlp node name wwn or zero.
4743  **/
4744 static void
4745 lpfc_get_starget_node_name(struct scsi_target *starget)
4746 {
4747         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
4748
4749         fc_starget_node_name(starget) =
4750                 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
4751 }
4752
4753 /**
4754  * lpfc_get_starget_port_name - Set the target port name
4755  * @starget: kernel scsi target pointer.
4756  *
4757  * Description:  set the target port name to the ndlp port name wwn or zero.
4758  **/
4759 static void
4760 lpfc_get_starget_port_name(struct scsi_target *starget)
4761 {
4762         struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
4763
4764         fc_starget_port_name(starget) =
4765                 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
4766 }
4767
4768 /**
4769  * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
4770  * @rport: fc rport address.
4771  * @timeout: new value for dev loss tmo.
4772  *
4773  * Description:
4774  * If timeout is non zero set the dev_loss_tmo to timeout, else set
4775  * dev_loss_tmo to one.
4776  **/
4777 static void
4778 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
4779 {
4780         if (timeout)
4781                 rport->dev_loss_tmo = timeout;
4782         else
4783                 rport->dev_loss_tmo = 1;
4784 }
4785
4786 /**
4787  * lpfc_rport_show_function - Return rport target information
4788  *
4789  * Description:
4790  * Macro that uses field to generate a function with the name lpfc_show_rport_
4791  *
4792  * lpfc_show_rport_##field: returns the bytes formatted in buf
4793  * @cdev: class converted to an fc_rport.
4794  * @buf: on return contains the target_field or zero.
4795  *
4796  * Returns: size of formatted string.
4797  **/
4798 #define lpfc_rport_show_function(field, format_string, sz, cast)        \
4799 static ssize_t                                                          \
4800 lpfc_show_rport_##field (struct device *dev,                            \
4801                          struct device_attribute *attr,                 \
4802                          char *buf)                                     \
4803 {                                                                       \
4804         struct fc_rport *rport = transport_class_to_rport(dev);         \
4805         struct lpfc_rport_data *rdata = rport->hostdata;                \
4806         return snprintf(buf, sz, format_string,                         \
4807                 (rdata->target) ? cast rdata->target->field : 0);       \
4808 }
4809
4810 #define lpfc_rport_rd_attr(field, format_string, sz)                    \
4811         lpfc_rport_show_function(field, format_string, sz, )            \
4812 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
4813
4814 /**
4815  * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
4816  * @fc_vport: The fc_vport who's symbolic name has been changed.
4817  *
4818  * Description:
4819  * This function is called by the transport after the @fc_vport's symbolic name
4820  * has been changed. This function re-registers the symbolic name with the
4821  * switch to propagate the change into the fabric if the vport is active.
4822  **/
4823 static void
4824 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
4825 {
4826         struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
4827
4828         if (vport->port_state == LPFC_VPORT_READY)
4829                 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
4830 }
4831
4832 /**
4833  * lpfc_hba_log_verbose_init - Set hba's log verbose level
4834  * @phba: Pointer to lpfc_hba struct.
4835  *
4836  * This function is called by the lpfc_get_cfgparam() routine to set the
4837  * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
4838  * log message according to the module's lpfc_log_verbose parameter setting
4839  * before hba port or vport created.
4840  **/
4841 static void
4842 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
4843 {
4844         phba->cfg_log_verbose = verbose;
4845 }
4846
4847 struct fc_function_template lpfc_transport_functions = {
4848         /* fixed attributes the driver supports */
4849         .show_host_node_name = 1,
4850         .show_host_port_name = 1,
4851         .show_host_supported_classes = 1,
4852         .show_host_supported_fc4s = 1,
4853         .show_host_supported_speeds = 1,
4854         .show_host_maxframe_size = 1,
4855         .show_host_symbolic_name = 1,
4856
4857         /* dynamic attributes the driver supports */
4858         .get_host_port_id = lpfc_get_host_port_id,
4859         .show_host_port_id = 1,
4860
4861         .get_host_port_type = lpfc_get_host_port_type,
4862         .show_host_port_type = 1,
4863
4864         .get_host_port_state = lpfc_get_host_port_state,
4865         .show_host_port_state = 1,
4866
4867         /* active_fc4s is shown but doesn't change (thus no get function) */
4868         .show_host_active_fc4s = 1,
4869
4870         .get_host_speed = lpfc_get_host_speed,
4871         .show_host_speed = 1,
4872
4873         .get_host_fabric_name = lpfc_get_host_fabric_name,
4874         .show_host_fabric_name = 1,
4875
4876         /*
4877          * The LPFC driver treats linkdown handling as target loss events
4878          * so there are no sysfs handlers for link_down_tmo.
4879          */
4880
4881         .get_fc_host_stats = lpfc_get_stats,
4882         .reset_fc_host_stats = lpfc_reset_stats,
4883
4884         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
4885         .show_rport_maxframe_size = 1,
4886         .show_rport_supported_classes = 1,
4887
4888         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
4889         .show_rport_dev_loss_tmo = 1,
4890
4891         .get_starget_port_id  = lpfc_get_starget_port_id,
4892         .show_starget_port_id = 1,
4893
4894         .get_starget_node_name = lpfc_get_starget_node_name,
4895         .show_starget_node_name = 1,
4896
4897         .get_starget_port_name = lpfc_get_starget_port_name,
4898         .show_starget_port_name = 1,
4899
4900         .issue_fc_host_lip = lpfc_issue_lip,
4901         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
4902         .terminate_rport_io = lpfc_terminate_rport_io,
4903
4904         .dd_fcvport_size = sizeof(struct lpfc_vport *),
4905
4906         .vport_disable = lpfc_vport_disable,
4907
4908         .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
4909
4910         .bsg_request = lpfc_bsg_request,
4911         .bsg_timeout = lpfc_bsg_timeout,
4912 };
4913
4914 struct fc_function_template lpfc_vport_transport_functions = {
4915         /* fixed attributes the driver supports */
4916         .show_host_node_name = 1,
4917         .show_host_port_name = 1,
4918         .show_host_supported_classes = 1,
4919         .show_host_supported_fc4s = 1,
4920         .show_host_supported_speeds = 1,
4921         .show_host_maxframe_size = 1,
4922         .show_host_symbolic_name = 1,
4923
4924         /* dynamic attributes the driver supports */
4925         .get_host_port_id = lpfc_get_host_port_id,
4926         .show_host_port_id = 1,
4927
4928         .get_host_port_type = lpfc_get_host_port_type,
4929         .show_host_port_type = 1,
4930
4931         .get_host_port_state = lpfc_get_host_port_state,
4932         .show_host_port_state = 1,
4933
4934         /* active_fc4s is shown but doesn't change (thus no get function) */
4935         .show_host_active_fc4s = 1,
4936
4937         .get_host_speed = lpfc_get_host_speed,
4938         .show_host_speed = 1,
4939
4940         .get_host_fabric_name = lpfc_get_host_fabric_name,
4941         .show_host_fabric_name = 1,
4942
4943         /*
4944          * The LPFC driver treats linkdown handling as target loss events
4945          * so there are no sysfs handlers for link_down_tmo.
4946          */
4947
4948         .get_fc_host_stats = lpfc_get_stats,
4949         .reset_fc_host_stats = lpfc_reset_stats,
4950
4951         .dd_fcrport_size = sizeof(struct lpfc_rport_data),
4952         .show_rport_maxframe_size = 1,
4953         .show_rport_supported_classes = 1,
4954
4955         .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
4956         .show_rport_dev_loss_tmo = 1,
4957
4958         .get_starget_port_id  = lpfc_get_starget_port_id,
4959         .show_starget_port_id = 1,
4960
4961         .get_starget_node_name = lpfc_get_starget_node_name,
4962         .show_starget_node_name = 1,
4963
4964         .get_starget_port_name = lpfc_get_starget_port_name,
4965         .show_starget_port_name = 1,
4966
4967         .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
4968         .terminate_rport_io = lpfc_terminate_rport_io,
4969
4970         .vport_disable = lpfc_vport_disable,
4971
4972         .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
4973 };
4974
4975 /**
4976  * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
4977  * @phba: lpfc_hba pointer.
4978  **/
4979 void
4980 lpfc_get_cfgparam(struct lpfc_hba *phba)
4981 {
4982         lpfc_cr_delay_init(phba, lpfc_cr_delay);
4983         lpfc_cr_count_init(phba, lpfc_cr_count);
4984         lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
4985         lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
4986         lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
4987         lpfc_ack0_init(phba, lpfc_ack0);
4988         lpfc_topology_init(phba, lpfc_topology);
4989         lpfc_link_speed_init(phba, lpfc_link_speed);
4990         lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
4991         lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
4992         lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
4993         lpfc_use_msi_init(phba, lpfc_use_msi);
4994         lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
4995         lpfc_fcp_wq_count_init(phba, lpfc_fcp_wq_count);
4996         lpfc_fcp_eq_count_init(phba, lpfc_fcp_eq_count);
4997         lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
4998         lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
4999         lpfc_enable_bg_init(phba, lpfc_enable_bg);
5000         if (phba->sli_rev == LPFC_SLI_REV4)
5001                 phba->cfg_poll = 0;
5002         else
5003         phba->cfg_poll = lpfc_poll;
5004         phba->cfg_soft_wwnn = 0L;
5005         phba->cfg_soft_wwpn = 0L;
5006         lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
5007         lpfc_prot_sg_seg_cnt_init(phba, lpfc_prot_sg_seg_cnt);
5008         lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
5009         lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
5010         lpfc_aer_support_init(phba, lpfc_aer_support);
5011         lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
5012         lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
5013         lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
5014         phba->cfg_enable_dss = 1;
5015         return;
5016 }
5017
5018 /**
5019  * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
5020  * @vport: lpfc_vport pointer.
5021  **/
5022 void
5023 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
5024 {
5025         lpfc_log_verbose_init(vport, lpfc_log_verbose);
5026         lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
5027         lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
5028         lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
5029         lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
5030         lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
5031         lpfc_restrict_login_init(vport, lpfc_restrict_login);
5032         lpfc_fcp_class_init(vport, lpfc_fcp_class);
5033         lpfc_use_adisc_init(vport, lpfc_use_adisc);
5034         lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
5035         lpfc_fdmi_on_init(vport, lpfc_fdmi_on);
5036         lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
5037         lpfc_max_luns_init(vport, lpfc_max_luns);
5038         lpfc_scan_down_init(vport, lpfc_scan_down);
5039         lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
5040         return;
5041 }