Merge git://git.kernel.org/pub/scm/linux/kernel/git/brodo/pcmcia-2.6
[linux-2.6] / drivers / scsi / qla2xxx / qla_attr.c
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2008 QLogic Corporation
4  *
5  * See LICENSE.qla2xxx for copyright and licensing details.
6  */
7 #include "qla_def.h"
8
9 #include <linux/kthread.h>
10 #include <linux/vmalloc.h>
11 #include <linux/delay.h>
12
13 static int qla24xx_vport_disable(struct fc_vport *, bool);
14
15 /* SYSFS attributes --------------------------------------------------------- */
16
17 static ssize_t
18 qla2x00_sysfs_read_fw_dump(struct kobject *kobj,
19                            struct bin_attribute *bin_attr,
20                            char *buf, loff_t off, size_t count)
21 {
22         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
23             struct device, kobj)));
24
25         if (ha->fw_dump_reading == 0)
26                 return 0;
27
28         return memory_read_from_buffer(buf, count, &off, ha->fw_dump,
29                                         ha->fw_dump_len);
30 }
31
32 static ssize_t
33 qla2x00_sysfs_write_fw_dump(struct kobject *kobj,
34                             struct bin_attribute *bin_attr,
35                             char *buf, loff_t off, size_t count)
36 {
37         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
38             struct device, kobj)));
39         int reading;
40
41         if (off != 0)
42                 return (0);
43
44         reading = simple_strtol(buf, NULL, 10);
45         switch (reading) {
46         case 0:
47                 if (!ha->fw_dump_reading)
48                         break;
49
50                 qla_printk(KERN_INFO, ha,
51                     "Firmware dump cleared on (%ld).\n", ha->host_no);
52
53                 ha->fw_dump_reading = 0;
54                 ha->fw_dumped = 0;
55                 break;
56         case 1:
57                 if (ha->fw_dumped && !ha->fw_dump_reading) {
58                         ha->fw_dump_reading = 1;
59
60                         qla_printk(KERN_INFO, ha,
61                             "Raw firmware dump ready for read on (%ld).\n",
62                             ha->host_no);
63                 }
64                 break;
65         case 2:
66                 qla2x00_alloc_fw_dump(ha);
67                 break;
68         case 3:
69                 qla2x00_system_error(ha);
70                 break;
71         }
72         return (count);
73 }
74
75 static struct bin_attribute sysfs_fw_dump_attr = {
76         .attr = {
77                 .name = "fw_dump",
78                 .mode = S_IRUSR | S_IWUSR,
79         },
80         .size = 0,
81         .read = qla2x00_sysfs_read_fw_dump,
82         .write = qla2x00_sysfs_write_fw_dump,
83 };
84
85 static ssize_t
86 qla2x00_sysfs_read_nvram(struct kobject *kobj,
87                          struct bin_attribute *bin_attr,
88                          char *buf, loff_t off, size_t count)
89 {
90         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
91             struct device, kobj)));
92
93         if (!capable(CAP_SYS_ADMIN))
94                 return 0;
95
96         /* Read NVRAM data from cache. */
97         return memory_read_from_buffer(buf, count, &off, ha->nvram,
98                                         ha->nvram_size);
99 }
100
101 static ssize_t
102 qla2x00_sysfs_write_nvram(struct kobject *kobj,
103                           struct bin_attribute *bin_attr,
104                           char *buf, loff_t off, size_t count)
105 {
106         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
107             struct device, kobj)));
108         uint16_t        cnt;
109
110         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
111                 return 0;
112
113         /* Checksum NVRAM. */
114         if (IS_FWI2_CAPABLE(ha)) {
115                 uint32_t *iter;
116                 uint32_t chksum;
117
118                 iter = (uint32_t *)buf;
119                 chksum = 0;
120                 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++)
121                         chksum += le32_to_cpu(*iter++);
122                 chksum = ~chksum + 1;
123                 *iter = cpu_to_le32(chksum);
124         } else {
125                 uint8_t *iter;
126                 uint8_t chksum;
127
128                 iter = (uint8_t *)buf;
129                 chksum = 0;
130                 for (cnt = 0; cnt < count - 1; cnt++)
131                         chksum += *iter++;
132                 chksum = ~chksum + 1;
133                 *iter = chksum;
134         }
135
136         /* Write NVRAM. */
137         ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count);
138         ha->isp_ops->read_nvram(ha, (uint8_t *)ha->nvram, ha->nvram_base,
139             count);
140
141         set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
142
143         return (count);
144 }
145
146 static struct bin_attribute sysfs_nvram_attr = {
147         .attr = {
148                 .name = "nvram",
149                 .mode = S_IRUSR | S_IWUSR,
150         },
151         .size = 512,
152         .read = qla2x00_sysfs_read_nvram,
153         .write = qla2x00_sysfs_write_nvram,
154 };
155
156 static ssize_t
157 qla2x00_sysfs_read_optrom(struct kobject *kobj,
158                           struct bin_attribute *bin_attr,
159                           char *buf, loff_t off, size_t count)
160 {
161         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
162             struct device, kobj)));
163
164         if (ha->optrom_state != QLA_SREADING)
165                 return 0;
166
167         return memory_read_from_buffer(buf, count, &off, ha->optrom_buffer,
168                                         ha->optrom_region_size);
169 }
170
171 static ssize_t
172 qla2x00_sysfs_write_optrom(struct kobject *kobj,
173                            struct bin_attribute *bin_attr,
174                            char *buf, loff_t off, size_t count)
175 {
176         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
177             struct device, kobj)));
178
179         if (ha->optrom_state != QLA_SWRITING)
180                 return -EINVAL;
181         if (off > ha->optrom_region_size)
182                 return -ERANGE;
183         if (off + count > ha->optrom_region_size)
184                 count = ha->optrom_region_size - off;
185
186         memcpy(&ha->optrom_buffer[off], buf, count);
187
188         return count;
189 }
190
191 static struct bin_attribute sysfs_optrom_attr = {
192         .attr = {
193                 .name = "optrom",
194                 .mode = S_IRUSR | S_IWUSR,
195         },
196         .size = 0,
197         .read = qla2x00_sysfs_read_optrom,
198         .write = qla2x00_sysfs_write_optrom,
199 };
200
201 static ssize_t
202 qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj,
203                                struct bin_attribute *bin_attr,
204                                char *buf, loff_t off, size_t count)
205 {
206         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
207             struct device, kobj)));
208         uint32_t start = 0;
209         uint32_t size = ha->optrom_size;
210         int val, valid;
211
212         if (off)
213                 return 0;
214
215         if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1)
216                 return -EINVAL;
217         if (start > ha->optrom_size)
218                 return -EINVAL;
219
220         switch (val) {
221         case 0:
222                 if (ha->optrom_state != QLA_SREADING &&
223                     ha->optrom_state != QLA_SWRITING)
224                         break;
225
226                 ha->optrom_state = QLA_SWAITING;
227
228                 DEBUG2(qla_printk(KERN_INFO, ha,
229                     "Freeing flash region allocation -- 0x%x bytes.\n",
230                     ha->optrom_region_size));
231
232                 vfree(ha->optrom_buffer);
233                 ha->optrom_buffer = NULL;
234                 break;
235         case 1:
236                 if (ha->optrom_state != QLA_SWAITING)
237                         break;
238
239                 if (start & 0xfff) {
240                         qla_printk(KERN_WARNING, ha,
241                             "Invalid start region 0x%x/0x%x.\n", start, size);
242                         return -EINVAL;
243                 }
244
245                 ha->optrom_region_start = start;
246                 ha->optrom_region_size = start + size > ha->optrom_size ?
247                     ha->optrom_size - start : size;
248
249                 ha->optrom_state = QLA_SREADING;
250                 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
251                 if (ha->optrom_buffer == NULL) {
252                         qla_printk(KERN_WARNING, ha,
253                             "Unable to allocate memory for optrom retrieval "
254                             "(%x).\n", ha->optrom_region_size);
255
256                         ha->optrom_state = QLA_SWAITING;
257                         return count;
258                 }
259
260                 DEBUG2(qla_printk(KERN_INFO, ha,
261                     "Reading flash region -- 0x%x/0x%x.\n",
262                     ha->optrom_region_start, ha->optrom_region_size));
263
264                 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
265                 ha->isp_ops->read_optrom(ha, ha->optrom_buffer,
266                     ha->optrom_region_start, ha->optrom_region_size);
267                 break;
268         case 2:
269                 if (ha->optrom_state != QLA_SWAITING)
270                         break;
271
272                 /*
273                  * We need to be more restrictive on which FLASH regions are
274                  * allowed to be updated via user-space.  Regions accessible
275                  * via this method include:
276                  *
277                  * ISP21xx/ISP22xx/ISP23xx type boards:
278                  *
279                  *      0x000000 -> 0x020000 -- Boot code.
280                  *
281                  * ISP2322/ISP24xx type boards:
282                  *
283                  *      0x000000 -> 0x07ffff -- Boot code.
284                  *      0x080000 -> 0x0fffff -- Firmware.
285                  *
286                  * ISP25xx type boards:
287                  *
288                  *      0x000000 -> 0x07ffff -- Boot code.
289                  *      0x080000 -> 0x0fffff -- Firmware.
290                  *      0x120000 -> 0x12ffff -- VPD and HBA parameters.
291                  */
292                 valid = 0;
293                 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
294                         valid = 1;
295                 else if (start == (ha->flt_region_boot * 4) ||
296                     start == (ha->flt_region_fw * 4))
297                         valid = 1;
298                 else if (IS_QLA25XX(ha) &&
299                     start == (ha->flt_region_vpd_nvram * 4))
300                     valid = 1;
301                 if (!valid) {
302                         qla_printk(KERN_WARNING, ha,
303                             "Invalid start region 0x%x/0x%x.\n", start, size);
304                         return -EINVAL;
305                 }
306
307                 ha->optrom_region_start = start;
308                 ha->optrom_region_size = start + size > ha->optrom_size ?
309                     ha->optrom_size - start : size;
310
311                 ha->optrom_state = QLA_SWRITING;
312                 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
313                 if (ha->optrom_buffer == NULL) {
314                         qla_printk(KERN_WARNING, ha,
315                             "Unable to allocate memory for optrom update "
316                             "(%x).\n", ha->optrom_region_size);
317
318                         ha->optrom_state = QLA_SWAITING;
319                         return count;
320                 }
321
322                 DEBUG2(qla_printk(KERN_INFO, ha,
323                     "Staging flash region write -- 0x%x/0x%x.\n",
324                     ha->optrom_region_start, ha->optrom_region_size));
325
326                 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
327                 break;
328         case 3:
329                 if (ha->optrom_state != QLA_SWRITING)
330                         break;
331
332                 DEBUG2(qla_printk(KERN_INFO, ha,
333                     "Writing flash region -- 0x%x/0x%x.\n",
334                     ha->optrom_region_start, ha->optrom_region_size));
335
336                 ha->isp_ops->write_optrom(ha, ha->optrom_buffer,
337                     ha->optrom_region_start, ha->optrom_region_size);
338                 break;
339         default:
340                 count = -EINVAL;
341         }
342         return count;
343 }
344
345 static struct bin_attribute sysfs_optrom_ctl_attr = {
346         .attr = {
347                 .name = "optrom_ctl",
348                 .mode = S_IWUSR,
349         },
350         .size = 0,
351         .write = qla2x00_sysfs_write_optrom_ctl,
352 };
353
354 static ssize_t
355 qla2x00_sysfs_read_vpd(struct kobject *kobj,
356                        struct bin_attribute *bin_attr,
357                        char *buf, loff_t off, size_t count)
358 {
359         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
360             struct device, kobj)));
361
362         if (!capable(CAP_SYS_ADMIN))
363                 return 0;
364
365         /* Read NVRAM data from cache. */
366         return memory_read_from_buffer(buf, count, &off, ha->vpd, ha->vpd_size);
367 }
368
369 static ssize_t
370 qla2x00_sysfs_write_vpd(struct kobject *kobj,
371                         struct bin_attribute *bin_attr,
372                         char *buf, loff_t off, size_t count)
373 {
374         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
375             struct device, kobj)));
376
377         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size)
378                 return 0;
379
380         /* Write NVRAM. */
381         ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count);
382         ha->isp_ops->read_nvram(ha, (uint8_t *)ha->vpd, ha->vpd_base, count);
383
384         return count;
385 }
386
387 static struct bin_attribute sysfs_vpd_attr = {
388         .attr = {
389                 .name = "vpd",
390                 .mode = S_IRUSR | S_IWUSR,
391         },
392         .size = 0,
393         .read = qla2x00_sysfs_read_vpd,
394         .write = qla2x00_sysfs_write_vpd,
395 };
396
397 static ssize_t
398 qla2x00_sysfs_read_sfp(struct kobject *kobj,
399                        struct bin_attribute *bin_attr,
400                        char *buf, loff_t off, size_t count)
401 {
402         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
403             struct device, kobj)));
404         uint16_t iter, addr, offset;
405         int rval;
406
407         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != SFP_DEV_SIZE * 2)
408                 return 0;
409
410         if (ha->sfp_data)
411                 goto do_read;
412
413         ha->sfp_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
414             &ha->sfp_data_dma);
415         if (!ha->sfp_data) {
416                 qla_printk(KERN_WARNING, ha,
417                     "Unable to allocate memory for SFP read-data.\n");
418                 return 0;
419         }
420
421 do_read:
422         memset(ha->sfp_data, 0, SFP_BLOCK_SIZE);
423         addr = 0xa0;
424         for (iter = 0, offset = 0; iter < (SFP_DEV_SIZE * 2) / SFP_BLOCK_SIZE;
425             iter++, offset += SFP_BLOCK_SIZE) {
426                 if (iter == 4) {
427                         /* Skip to next device address. */
428                         addr = 0xa2;
429                         offset = 0;
430                 }
431
432                 rval = qla2x00_read_sfp(ha, ha->sfp_data_dma, addr, offset,
433                     SFP_BLOCK_SIZE);
434                 if (rval != QLA_SUCCESS) {
435                         qla_printk(KERN_WARNING, ha,
436                             "Unable to read SFP data (%x/%x/%x).\n", rval,
437                             addr, offset);
438                         count = 0;
439                         break;
440                 }
441                 memcpy(buf, ha->sfp_data, SFP_BLOCK_SIZE);
442                 buf += SFP_BLOCK_SIZE;
443         }
444
445         return count;
446 }
447
448 static struct bin_attribute sysfs_sfp_attr = {
449         .attr = {
450                 .name = "sfp",
451                 .mode = S_IRUSR | S_IWUSR,
452         },
453         .size = SFP_DEV_SIZE * 2,
454         .read = qla2x00_sysfs_read_sfp,
455 };
456
457 static struct sysfs_entry {
458         char *name;
459         struct bin_attribute *attr;
460         int is4GBp_only;
461 } bin_file_entries[] = {
462         { "fw_dump", &sysfs_fw_dump_attr, },
463         { "nvram", &sysfs_nvram_attr, },
464         { "optrom", &sysfs_optrom_attr, },
465         { "optrom_ctl", &sysfs_optrom_ctl_attr, },
466         { "vpd", &sysfs_vpd_attr, 1 },
467         { "sfp", &sysfs_sfp_attr, 1 },
468         { NULL },
469 };
470
471 void
472 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
473 {
474         struct Scsi_Host *host = ha->host;
475         struct sysfs_entry *iter;
476         int ret;
477
478         for (iter = bin_file_entries; iter->name; iter++) {
479                 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha))
480                         continue;
481
482                 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
483                     iter->attr);
484                 if (ret)
485                         qla_printk(KERN_INFO, ha,
486                             "Unable to create sysfs %s binary attribute "
487                             "(%d).\n", iter->name, ret);
488         }
489 }
490
491 void
492 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
493 {
494         struct Scsi_Host *host = ha->host;
495         struct sysfs_entry *iter;
496
497         for (iter = bin_file_entries; iter->name; iter++) {
498                 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha))
499                         continue;
500
501                 sysfs_remove_bin_file(&host->shost_gendev.kobj,
502                     iter->attr);
503         }
504
505         if (ha->beacon_blink_led == 1)
506                 ha->isp_ops->beacon_off(ha);
507 }
508
509 /* Scsi_Host attributes. */
510
511 static ssize_t
512 qla2x00_drvr_version_show(struct device *dev,
513                           struct device_attribute *attr, char *buf)
514 {
515         return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
516 }
517
518 static ssize_t
519 qla2x00_fw_version_show(struct device *dev,
520                         struct device_attribute *attr, char *buf)
521 {
522         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
523         char fw_str[30];
524
525         return snprintf(buf, PAGE_SIZE, "%s\n",
526             ha->isp_ops->fw_version_str(ha, fw_str));
527 }
528
529 static ssize_t
530 qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
531                         char *buf)
532 {
533         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
534         uint32_t sn;
535
536         if (IS_FWI2_CAPABLE(ha)) {
537                 qla2xxx_get_vpd_field(ha, "SN", buf, PAGE_SIZE);
538                 return snprintf(buf, PAGE_SIZE, "%s\n", buf);
539         }
540
541         sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
542         return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
543             sn % 100000);
544 }
545
546 static ssize_t
547 qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
548                       char *buf)
549 {
550         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
551         return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device);
552 }
553
554 static ssize_t
555 qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
556                     char *buf)
557 {
558         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
559         return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
560             ha->product_id[0], ha->product_id[1], ha->product_id[2],
561             ha->product_id[3]);
562 }
563
564 static ssize_t
565 qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
566                         char *buf)
567 {
568         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
569         return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number);
570 }
571
572 static ssize_t
573 qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
574                         char *buf)
575 {
576         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
577         return snprintf(buf, PAGE_SIZE, "%s\n",
578             ha->model_desc ? ha->model_desc: "");
579 }
580
581 static ssize_t
582 qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
583                       char *buf)
584 {
585         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
586         char pci_info[30];
587
588         return snprintf(buf, PAGE_SIZE, "%s\n",
589             ha->isp_ops->pci_info_str(ha, pci_info));
590 }
591
592 static ssize_t
593 qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
594                         char *buf)
595 {
596         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
597         int len = 0;
598
599         if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
600             atomic_read(&ha->loop_state) == LOOP_DEAD)
601                 len = snprintf(buf, PAGE_SIZE, "Link Down\n");
602         else if (atomic_read(&ha->loop_state) != LOOP_READY ||
603             test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) ||
604             test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags))
605                 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n");
606         else {
607                 len = snprintf(buf, PAGE_SIZE, "Link Up - ");
608
609                 switch (ha->current_topology) {
610                 case ISP_CFG_NL:
611                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
612                         break;
613                 case ISP_CFG_FL:
614                         len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
615                         break;
616                 case ISP_CFG_N:
617                         len += snprintf(buf + len, PAGE_SIZE-len,
618                             "N_Port to N_Port\n");
619                         break;
620                 case ISP_CFG_F:
621                         len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
622                         break;
623                 default:
624                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
625                         break;
626                 }
627         }
628         return len;
629 }
630
631 static ssize_t
632 qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
633                  char *buf)
634 {
635         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
636         int len = 0;
637
638         switch (ha->zio_mode) {
639         case QLA_ZIO_MODE_6:
640                 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
641                 break;
642         case QLA_ZIO_DISABLED:
643                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
644                 break;
645         }
646         return len;
647 }
648
649 static ssize_t
650 qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
651                   const char *buf, size_t count)
652 {
653         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
654         int val = 0;
655         uint16_t zio_mode;
656
657         if (!IS_ZIO_SUPPORTED(ha))
658                 return -ENOTSUPP;
659
660         if (sscanf(buf, "%d", &val) != 1)
661                 return -EINVAL;
662
663         if (val)
664                 zio_mode = QLA_ZIO_MODE_6;
665         else
666                 zio_mode = QLA_ZIO_DISABLED;
667
668         /* Update per-hba values and queue a reset. */
669         if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
670                 ha->zio_mode = zio_mode;
671                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
672         }
673         return strlen(buf);
674 }
675
676 static ssize_t
677 qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
678                        char *buf)
679 {
680         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
681
682         return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100);
683 }
684
685 static ssize_t
686 qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
687                         const char *buf, size_t count)
688 {
689         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
690         int val = 0;
691         uint16_t zio_timer;
692
693         if (sscanf(buf, "%d", &val) != 1)
694                 return -EINVAL;
695         if (val > 25500 || val < 100)
696                 return -ERANGE;
697
698         zio_timer = (uint16_t)(val / 100);
699         ha->zio_timer = zio_timer;
700
701         return strlen(buf);
702 }
703
704 static ssize_t
705 qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
706                     char *buf)
707 {
708         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
709         int len = 0;
710
711         if (ha->beacon_blink_led)
712                 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
713         else
714                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
715         return len;
716 }
717
718 static ssize_t
719 qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
720                      const char *buf, size_t count)
721 {
722         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
723         int val = 0;
724         int rval;
725
726         if (IS_QLA2100(ha) || IS_QLA2200(ha))
727                 return -EPERM;
728
729         if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) {
730                 qla_printk(KERN_WARNING, ha,
731                     "Abort ISP active -- ignoring beacon request.\n");
732                 return -EBUSY;
733         }
734
735         if (sscanf(buf, "%d", &val) != 1)
736                 return -EINVAL;
737
738         if (val)
739                 rval = ha->isp_ops->beacon_on(ha);
740         else
741                 rval = ha->isp_ops->beacon_off(ha);
742
743         if (rval != QLA_SUCCESS)
744                 count = 0;
745
746         return count;
747 }
748
749 static ssize_t
750 qla2x00_optrom_bios_version_show(struct device *dev,
751                                  struct device_attribute *attr, char *buf)
752 {
753         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
754
755         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
756             ha->bios_revision[0]);
757 }
758
759 static ssize_t
760 qla2x00_optrom_efi_version_show(struct device *dev,
761                                 struct device_attribute *attr, char *buf)
762 {
763         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
764
765         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
766             ha->efi_revision[0]);
767 }
768
769 static ssize_t
770 qla2x00_optrom_fcode_version_show(struct device *dev,
771                                   struct device_attribute *attr, char *buf)
772 {
773         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
774
775         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
776             ha->fcode_revision[0]);
777 }
778
779 static ssize_t
780 qla2x00_optrom_fw_version_show(struct device *dev,
781                                struct device_attribute *attr, char *buf)
782 {
783         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
784
785         return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
786             ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
787             ha->fw_revision[3]);
788 }
789
790 static ssize_t
791 qla2x00_total_isp_aborts_show(struct device *dev,
792                               struct device_attribute *attr, char *buf)
793 {
794         scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
795
796         return snprintf(buf, PAGE_SIZE, "%d\n",
797             ha->qla_stats.total_isp_aborts);
798 }
799
800 static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL);
801 static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
802 static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
803 static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
804 static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
805 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
806 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
807 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
808 static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
809 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
810 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
811                    qla2x00_zio_timer_store);
812 static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
813                    qla2x00_beacon_store);
814 static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
815                    qla2x00_optrom_bios_version_show, NULL);
816 static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
817                    qla2x00_optrom_efi_version_show, NULL);
818 static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
819                    qla2x00_optrom_fcode_version_show, NULL);
820 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
821                    NULL);
822 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
823                    NULL);
824
825 struct device_attribute *qla2x00_host_attrs[] = {
826         &dev_attr_driver_version,
827         &dev_attr_fw_version,
828         &dev_attr_serial_num,
829         &dev_attr_isp_name,
830         &dev_attr_isp_id,
831         &dev_attr_model_name,
832         &dev_attr_model_desc,
833         &dev_attr_pci_info,
834         &dev_attr_link_state,
835         &dev_attr_zio,
836         &dev_attr_zio_timer,
837         &dev_attr_beacon,
838         &dev_attr_optrom_bios_version,
839         &dev_attr_optrom_efi_version,
840         &dev_attr_optrom_fcode_version,
841         &dev_attr_optrom_fw_version,
842         &dev_attr_total_isp_aborts,
843         NULL,
844 };
845
846 /* Host attributes. */
847
848 static void
849 qla2x00_get_host_port_id(struct Scsi_Host *shost)
850 {
851         scsi_qla_host_t *ha = shost_priv(shost);
852
853         fc_host_port_id(shost) = ha->d_id.b.domain << 16 |
854             ha->d_id.b.area << 8 | ha->d_id.b.al_pa;
855 }
856
857 static void
858 qla2x00_get_host_speed(struct Scsi_Host *shost)
859 {
860         scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost));
861         u32 speed = FC_PORTSPEED_UNKNOWN;
862
863         switch (ha->link_data_rate) {
864         case PORT_SPEED_1GB:
865                 speed = FC_PORTSPEED_1GBIT;
866                 break;
867         case PORT_SPEED_2GB:
868                 speed = FC_PORTSPEED_2GBIT;
869                 break;
870         case PORT_SPEED_4GB:
871                 speed = FC_PORTSPEED_4GBIT;
872                 break;
873         case PORT_SPEED_8GB:
874                 speed = FC_PORTSPEED_8GBIT;
875                 break;
876         }
877         fc_host_speed(shost) = speed;
878 }
879
880 static void
881 qla2x00_get_host_port_type(struct Scsi_Host *shost)
882 {
883         scsi_qla_host_t *ha = shost_priv(shost);
884         uint32_t port_type = FC_PORTTYPE_UNKNOWN;
885
886         if (ha->parent) {
887                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
888                 return;
889         }
890         switch (ha->current_topology) {
891         case ISP_CFG_NL:
892                 port_type = FC_PORTTYPE_LPORT;
893                 break;
894         case ISP_CFG_FL:
895                 port_type = FC_PORTTYPE_NLPORT;
896                 break;
897         case ISP_CFG_N:
898                 port_type = FC_PORTTYPE_PTP;
899                 break;
900         case ISP_CFG_F:
901                 port_type = FC_PORTTYPE_NPORT;
902                 break;
903         }
904         fc_host_port_type(shost) = port_type;
905 }
906
907 static void
908 qla2x00_get_starget_node_name(struct scsi_target *starget)
909 {
910         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
911         scsi_qla_host_t *ha = shost_priv(host);
912         fc_port_t *fcport;
913         u64 node_name = 0;
914
915         list_for_each_entry(fcport, &ha->fcports, list) {
916                 if (fcport->rport &&
917                     starget->id == fcport->rport->scsi_target_id) {
918                         node_name = wwn_to_u64(fcport->node_name);
919                         break;
920                 }
921         }
922
923         fc_starget_node_name(starget) = node_name;
924 }
925
926 static void
927 qla2x00_get_starget_port_name(struct scsi_target *starget)
928 {
929         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
930         scsi_qla_host_t *ha = shost_priv(host);
931         fc_port_t *fcport;
932         u64 port_name = 0;
933
934         list_for_each_entry(fcport, &ha->fcports, list) {
935                 if (fcport->rport &&
936                     starget->id == fcport->rport->scsi_target_id) {
937                         port_name = wwn_to_u64(fcport->port_name);
938                         break;
939                 }
940         }
941
942         fc_starget_port_name(starget) = port_name;
943 }
944
945 static void
946 qla2x00_get_starget_port_id(struct scsi_target *starget)
947 {
948         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
949         scsi_qla_host_t *ha = shost_priv(host);
950         fc_port_t *fcport;
951         uint32_t port_id = ~0U;
952
953         list_for_each_entry(fcport, &ha->fcports, list) {
954                 if (fcport->rport &&
955                     starget->id == fcport->rport->scsi_target_id) {
956                         port_id = fcport->d_id.b.domain << 16 |
957                             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
958                         break;
959                 }
960         }
961
962         fc_starget_port_id(starget) = port_id;
963 }
964
965 static void
966 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
967 {
968         if (timeout)
969                 rport->dev_loss_tmo = timeout;
970         else
971                 rport->dev_loss_tmo = 1;
972 }
973
974 static void
975 qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
976 {
977         struct Scsi_Host *host = rport_to_shost(rport);
978         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
979
980         qla2x00_abort_fcport_cmds(fcport);
981
982         /*
983          * Transport has effectively 'deleted' the rport, clear
984          * all local references.
985          */
986         spin_lock_irq(host->host_lock);
987         fcport->rport = NULL;
988         *((fc_port_t **)rport->dd_data) = NULL;
989         spin_unlock_irq(host->host_lock);
990 }
991
992 static void
993 qla2x00_terminate_rport_io(struct fc_rport *rport)
994 {
995         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
996
997         /*
998          * At this point all fcport's software-states are cleared.  Perform any
999          * final cleanup of firmware resources (PCBs and XCBs).
1000          */
1001         if (fcport->loop_id != FC_NO_LOOP_ID) {
1002                 fcport->ha->isp_ops->fabric_logout(fcport->ha, fcport->loop_id,
1003                     fcport->d_id.b.domain, fcport->d_id.b.area,
1004                     fcport->d_id.b.al_pa);
1005                 fcport->loop_id = FC_NO_LOOP_ID;
1006         }
1007
1008         qla2x00_abort_fcport_cmds(fcport);
1009         scsi_target_unblock(&rport->dev);
1010 }
1011
1012 static int
1013 qla2x00_issue_lip(struct Scsi_Host *shost)
1014 {
1015         scsi_qla_host_t *ha = shost_priv(shost);
1016
1017         qla2x00_loop_reset(ha);
1018         return 0;
1019 }
1020
1021 static struct fc_host_statistics *
1022 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
1023 {
1024         scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost));
1025         int rval;
1026         struct link_statistics *stats;
1027         dma_addr_t stats_dma;
1028         struct fc_host_statistics *pfc_host_stat;
1029
1030         pfc_host_stat = &ha->fc_host_stat;
1031         memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
1032
1033         stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma);
1034         if (stats == NULL) {
1035                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
1036                     __func__, ha->host_no));
1037                 goto done;
1038         }
1039         memset(stats, 0, DMA_POOL_SIZE);
1040
1041         rval = QLA_FUNCTION_FAILED;
1042         if (IS_FWI2_CAPABLE(ha)) {
1043                 rval = qla24xx_get_isp_stats(ha, stats, stats_dma);
1044         } else if (atomic_read(&ha->loop_state) == LOOP_READY &&
1045                     !test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) &&
1046                     !test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) &&
1047                     !ha->dpc_active) {
1048                 /* Must be in a 'READY' state for statistics retrieval. */
1049                 rval = qla2x00_get_link_status(ha, ha->loop_id, stats,
1050                     stats_dma);
1051         }
1052
1053         if (rval != QLA_SUCCESS)
1054                 goto done_free;
1055
1056         pfc_host_stat->link_failure_count = stats->link_fail_cnt;
1057         pfc_host_stat->loss_of_sync_count = stats->loss_sync_cnt;
1058         pfc_host_stat->loss_of_signal_count = stats->loss_sig_cnt;
1059         pfc_host_stat->prim_seq_protocol_err_count = stats->prim_seq_err_cnt;
1060         pfc_host_stat->invalid_tx_word_count = stats->inval_xmit_word_cnt;
1061         pfc_host_stat->invalid_crc_count = stats->inval_crc_cnt;
1062         if (IS_FWI2_CAPABLE(ha)) {
1063                 pfc_host_stat->lip_count = stats->lip_cnt;
1064                 pfc_host_stat->tx_frames = stats->tx_frames;
1065                 pfc_host_stat->rx_frames = stats->rx_frames;
1066                 pfc_host_stat->dumped_frames = stats->dumped_frames;
1067                 pfc_host_stat->nos_count = stats->nos_rcvd;
1068         }
1069         pfc_host_stat->fcp_input_megabytes = ha->qla_stats.input_bytes >> 20;
1070         pfc_host_stat->fcp_output_megabytes = ha->qla_stats.output_bytes >> 20;
1071
1072 done_free:
1073         dma_pool_free(ha->s_dma_pool, stats, stats_dma);
1074 done:
1075         return pfc_host_stat;
1076 }
1077
1078 static void
1079 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
1080 {
1081         scsi_qla_host_t *ha = shost_priv(shost);
1082
1083         qla2x00_get_sym_node_name(ha, fc_host_symbolic_name(shost));
1084 }
1085
1086 static void
1087 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
1088 {
1089         scsi_qla_host_t *ha = shost_priv(shost);
1090
1091         set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
1092 }
1093
1094 static void
1095 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
1096 {
1097         scsi_qla_host_t *ha = shost_priv(shost);
1098         u64 node_name;
1099
1100         if (ha->device_flags & SWITCH_FOUND)
1101                 node_name = wwn_to_u64(ha->fabric_node_name);
1102         else
1103                 node_name = wwn_to_u64(ha->node_name);
1104
1105         fc_host_fabric_name(shost) = node_name;
1106 }
1107
1108 static void
1109 qla2x00_get_host_port_state(struct Scsi_Host *shost)
1110 {
1111         scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost));
1112
1113         if (!ha->flags.online)
1114                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
1115         else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT)
1116                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
1117         else
1118                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
1119 }
1120
1121 static int
1122 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
1123 {
1124         int     ret = 0;
1125         scsi_qla_host_t *ha = shost_priv(fc_vport->shost);
1126         scsi_qla_host_t *vha;
1127
1128         ret = qla24xx_vport_create_req_sanity_check(fc_vport);
1129         if (ret) {
1130                 DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, "
1131                     "status %x\n", ret));
1132                 return (ret);
1133         }
1134
1135         vha = qla24xx_create_vhost(fc_vport);
1136         if (vha == NULL) {
1137                 DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n",
1138                     vha));
1139                 return FC_VPORT_FAILED;
1140         }
1141         if (disable) {
1142                 atomic_set(&vha->vp_state, VP_OFFLINE);
1143                 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
1144         } else
1145                 atomic_set(&vha->vp_state, VP_FAILED);
1146
1147         /* ready to create vport */
1148         qla_printk(KERN_INFO, vha, "VP entry id %d assigned.\n", vha->vp_idx);
1149
1150         /* initialized vport states */
1151         atomic_set(&vha->loop_state, LOOP_DOWN);
1152         vha->vp_err_state=  VP_ERR_PORTDWN;
1153         vha->vp_prev_err_state=  VP_ERR_UNKWN;
1154         /* Check if physical ha port is Up */
1155         if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
1156             atomic_read(&ha->loop_state) == LOOP_DEAD) {
1157                 /* Don't retry or attempt login of this virtual port */
1158                 DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n",
1159                     vha->host_no));
1160                 atomic_set(&vha->loop_state, LOOP_DEAD);
1161                 if (!disable)
1162                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
1163         }
1164
1165         if (scsi_add_host(vha->host, &fc_vport->dev)) {
1166                 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
1167                         vha->host_no, vha->vp_idx));
1168                 goto vport_create_failed_2;
1169         }
1170
1171         /* initialize attributes */
1172         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1173         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1174         fc_host_supported_classes(vha->host) =
1175                 fc_host_supported_classes(ha->host);
1176         fc_host_supported_speeds(vha->host) =
1177                 fc_host_supported_speeds(ha->host);
1178
1179         qla24xx_vport_disable(fc_vport, disable);
1180
1181         return 0;
1182 vport_create_failed_2:
1183         qla24xx_disable_vp(vha);
1184         qla24xx_deallocate_vp_id(vha);
1185         kfree(vha->port_name);
1186         kfree(vha->node_name);
1187         scsi_host_put(vha->host);
1188         return FC_VPORT_FAILED;
1189 }
1190
1191 static int
1192 qla24xx_vport_delete(struct fc_vport *fc_vport)
1193 {
1194         scsi_qla_host_t *vha = fc_vport->dd_data;
1195         scsi_qla_host_t *pha = to_qla_parent(vha);
1196
1197         while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) ||
1198             test_bit(FCPORT_UPDATE_NEEDED, &pha->dpc_flags))
1199                 msleep(1000);
1200
1201         qla24xx_disable_vp(vha);
1202         qla24xx_deallocate_vp_id(vha);
1203
1204         kfree(vha->node_name);
1205         kfree(vha->port_name);
1206
1207         if (vha->timer_active) {
1208                 qla2x00_vp_stop_timer(vha);
1209                 DEBUG15(printk ("scsi(%ld): timer for the vport[%d] = %p "
1210                     "has stopped\n",
1211                     vha->host_no, vha->vp_idx, vha));
1212         }
1213
1214         fc_remove_host(vha->host);
1215
1216         scsi_remove_host(vha->host);
1217
1218         scsi_host_put(vha->host);
1219
1220         return 0;
1221 }
1222
1223 static int
1224 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
1225 {
1226         scsi_qla_host_t *vha = fc_vport->dd_data;
1227
1228         if (disable)
1229                 qla24xx_disable_vp(vha);
1230         else
1231                 qla24xx_enable_vp(vha);
1232
1233         return 0;
1234 }
1235
1236 struct fc_function_template qla2xxx_transport_functions = {
1237
1238         .show_host_node_name = 1,
1239         .show_host_port_name = 1,
1240         .show_host_supported_classes = 1,
1241         .show_host_supported_speeds = 1,
1242
1243         .get_host_port_id = qla2x00_get_host_port_id,
1244         .show_host_port_id = 1,
1245         .get_host_speed = qla2x00_get_host_speed,
1246         .show_host_speed = 1,
1247         .get_host_port_type = qla2x00_get_host_port_type,
1248         .show_host_port_type = 1,
1249         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1250         .show_host_symbolic_name = 1,
1251         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1252         .show_host_system_hostname = 1,
1253         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1254         .show_host_fabric_name = 1,
1255         .get_host_port_state = qla2x00_get_host_port_state,
1256         .show_host_port_state = 1,
1257
1258         .dd_fcrport_size = sizeof(struct fc_port *),
1259         .show_rport_supported_classes = 1,
1260
1261         .get_starget_node_name = qla2x00_get_starget_node_name,
1262         .show_starget_node_name = 1,
1263         .get_starget_port_name = qla2x00_get_starget_port_name,
1264         .show_starget_port_name = 1,
1265         .get_starget_port_id  = qla2x00_get_starget_port_id,
1266         .show_starget_port_id = 1,
1267
1268         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1269         .show_rport_dev_loss_tmo = 1,
1270
1271         .issue_fc_host_lip = qla2x00_issue_lip,
1272         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1273         .terminate_rport_io = qla2x00_terminate_rport_io,
1274         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1275
1276         .vport_create = qla24xx_vport_create,
1277         .vport_disable = qla24xx_vport_disable,
1278         .vport_delete = qla24xx_vport_delete,
1279 };
1280
1281 struct fc_function_template qla2xxx_transport_vport_functions = {
1282
1283         .show_host_node_name = 1,
1284         .show_host_port_name = 1,
1285         .show_host_supported_classes = 1,
1286
1287         .get_host_port_id = qla2x00_get_host_port_id,
1288         .show_host_port_id = 1,
1289         .get_host_speed = qla2x00_get_host_speed,
1290         .show_host_speed = 1,
1291         .get_host_port_type = qla2x00_get_host_port_type,
1292         .show_host_port_type = 1,
1293         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1294         .show_host_symbolic_name = 1,
1295         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1296         .show_host_system_hostname = 1,
1297         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1298         .show_host_fabric_name = 1,
1299         .get_host_port_state = qla2x00_get_host_port_state,
1300         .show_host_port_state = 1,
1301
1302         .dd_fcrport_size = sizeof(struct fc_port *),
1303         .show_rport_supported_classes = 1,
1304
1305         .get_starget_node_name = qla2x00_get_starget_node_name,
1306         .show_starget_node_name = 1,
1307         .get_starget_port_name = qla2x00_get_starget_port_name,
1308         .show_starget_port_name = 1,
1309         .get_starget_port_id  = qla2x00_get_starget_port_id,
1310         .show_starget_port_id = 1,
1311
1312         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1313         .show_rport_dev_loss_tmo = 1,
1314
1315         .issue_fc_host_lip = qla2x00_issue_lip,
1316         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1317         .terminate_rport_io = qla2x00_terminate_rport_io,
1318         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1319 };
1320
1321 void
1322 qla2x00_init_host_attr(scsi_qla_host_t *ha)
1323 {
1324         u32 speed = FC_PORTSPEED_UNKNOWN;
1325
1326         fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name);
1327         fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name);
1328         fc_host_supported_classes(ha->host) = FC_COS_CLASS3;
1329         fc_host_max_npiv_vports(ha->host) = ha->max_npiv_vports;;
1330         fc_host_npiv_vports_inuse(ha->host) = ha->cur_vport_count;
1331
1332         if (IS_QLA25XX(ha))
1333                 speed = FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT |
1334                     FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1335         else if (IS_QLA24XX_TYPE(ha))
1336                 speed = FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT |
1337                     FC_PORTSPEED_1GBIT;
1338         else if (IS_QLA23XX(ha))
1339                 speed = FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1340         else
1341                 speed = FC_PORTSPEED_1GBIT;
1342         fc_host_supported_speeds(ha->host) = speed;
1343 }