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