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