Merge ../linux-2.6-watchdog-mm
[linux-2.6] / drivers / scsi / qla2xxx / qla_attr.c
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2005 QLogic Corporation
4  *
5  * See LICENSE.qla2xxx for copyright and licensing details.
6  */
7 #include "qla_def.h"
8
9 #include <linux/vmalloc.h>
10
11 /* SYSFS attributes --------------------------------------------------------- */
12
13 static ssize_t
14 qla2x00_sysfs_read_fw_dump(struct kobject *kobj, char *buf, loff_t off,
15     size_t count)
16 {
17         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
18             struct device, kobj)));
19         char *rbuf = (char *)ha->fw_dump;
20
21         if (ha->fw_dump_reading == 0)
22                 return 0;
23         if (off > ha->fw_dump_len)
24                 return 0;
25         if (off + count > ha->fw_dump_len)
26                 count = ha->fw_dump_len - off;
27
28         memcpy(buf, &rbuf[off], count);
29
30         return (count);
31 }
32
33 static ssize_t
34 qla2x00_sysfs_write_fw_dump(struct kobject *kobj, char *buf, loff_t off,
35     size_t count)
36 {
37         struct scsi_qla_host *ha = to_qla_host(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         }
69         return (count);
70 }
71
72 static struct bin_attribute sysfs_fw_dump_attr = {
73         .attr = {
74                 .name = "fw_dump",
75                 .mode = S_IRUSR | S_IWUSR,
76                 .owner = THIS_MODULE,
77         },
78         .size = 0,
79         .read = qla2x00_sysfs_read_fw_dump,
80         .write = qla2x00_sysfs_write_fw_dump,
81 };
82
83 static ssize_t
84 qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf, loff_t off,
85     size_t count)
86 {
87         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
88             struct device, kobj)));
89         unsigned long   flags;
90
91         if (!capable(CAP_SYS_ADMIN) || off != 0)
92                 return 0;
93
94         /* Read NVRAM. */
95         spin_lock_irqsave(&ha->hardware_lock, flags);
96         ha->isp_ops.read_nvram(ha, (uint8_t *)buf, ha->nvram_base,
97             ha->nvram_size);
98         spin_unlock_irqrestore(&ha->hardware_lock, flags);
99
100         return ha->nvram_size;
101 }
102
103 static ssize_t
104 qla2x00_sysfs_write_nvram(struct kobject *kobj, char *buf, loff_t off,
105     size_t count)
106 {
107         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
108             struct device, kobj)));
109         unsigned long   flags;
110         uint16_t        cnt;
111
112         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
113                 return 0;
114
115         /* Checksum NVRAM. */
116         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
117                 uint32_t *iter;
118                 uint32_t chksum;
119
120                 iter = (uint32_t *)buf;
121                 chksum = 0;
122                 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++)
123                         chksum += le32_to_cpu(*iter++);
124                 chksum = ~chksum + 1;
125                 *iter = cpu_to_le32(chksum);
126         } else {
127                 uint8_t *iter;
128                 uint8_t chksum;
129
130                 iter = (uint8_t *)buf;
131                 chksum = 0;
132                 for (cnt = 0; cnt < count - 1; cnt++)
133                         chksum += *iter++;
134                 chksum = ~chksum + 1;
135                 *iter = chksum;
136         }
137
138         /* Write NVRAM. */
139         spin_lock_irqsave(&ha->hardware_lock, flags);
140         ha->isp_ops.write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count);
141         spin_unlock_irqrestore(&ha->hardware_lock, 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                 .owner = THIS_MODULE,
151         },
152         .size = 512,
153         .read = qla2x00_sysfs_read_nvram,
154         .write = qla2x00_sysfs_write_nvram,
155 };
156
157 static ssize_t
158 qla2x00_sysfs_read_optrom(struct kobject *kobj, char *buf, loff_t off,
159     size_t count)
160 {
161         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
162             struct device, kobj)));
163
164         if (ha->optrom_state != QLA_SREADING)
165                 return 0;
166         if (off > ha->optrom_size)
167                 return 0;
168         if (off + count > ha->optrom_size)
169                 count = ha->optrom_size - off;
170
171         memcpy(buf, &ha->optrom_buffer[off], count);
172
173         return count;
174 }
175
176 static ssize_t
177 qla2x00_sysfs_write_optrom(struct kobject *kobj, char *buf, loff_t off,
178     size_t count)
179 {
180         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
181             struct device, kobj)));
182
183         if (ha->optrom_state != QLA_SWRITING)
184                 return -EINVAL;
185         if (off > ha->optrom_size)
186                 return -ERANGE;
187         if (off + count > ha->optrom_size)
188                 count = ha->optrom_size - off;
189
190         memcpy(&ha->optrom_buffer[off], buf, count);
191
192         return count;
193 }
194
195 static struct bin_attribute sysfs_optrom_attr = {
196         .attr = {
197                 .name = "optrom",
198                 .mode = S_IRUSR | S_IWUSR,
199                 .owner = THIS_MODULE,
200         },
201         .size = OPTROM_SIZE_24XX,
202         .read = qla2x00_sysfs_read_optrom,
203         .write = qla2x00_sysfs_write_optrom,
204 };
205
206 static ssize_t
207 qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj, char *buf, loff_t off,
208     size_t count)
209 {
210         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
211             struct device, kobj)));
212         int val;
213
214         if (off)
215                 return 0;
216
217         if (sscanf(buf, "%d", &val) != 1)
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                 vfree(ha->optrom_buffer);
228                 ha->optrom_buffer = NULL;
229                 break;
230         case 1:
231                 if (ha->optrom_state != QLA_SWAITING)
232                         break;
233
234                 ha->optrom_state = QLA_SREADING;
235                 ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size);
236                 if (ha->optrom_buffer == NULL) {
237                         qla_printk(KERN_WARNING, ha,
238                             "Unable to allocate memory for optrom retrieval "
239                             "(%x).\n", ha->optrom_size);
240
241                         ha->optrom_state = QLA_SWAITING;
242                         return count;
243                 }
244
245                 memset(ha->optrom_buffer, 0, ha->optrom_size);
246                 ha->isp_ops.read_optrom(ha, ha->optrom_buffer, 0,
247                     ha->optrom_size);
248                 break;
249         case 2:
250                 if (ha->optrom_state != QLA_SWAITING)
251                         break;
252
253                 ha->optrom_state = QLA_SWRITING;
254                 ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size);
255                 if (ha->optrom_buffer == NULL) {
256                         qla_printk(KERN_WARNING, ha,
257                             "Unable to allocate memory for optrom update "
258                             "(%x).\n", ha->optrom_size);
259
260                         ha->optrom_state = QLA_SWAITING;
261                         return count;
262                 }
263                 memset(ha->optrom_buffer, 0, ha->optrom_size);
264                 break;
265         case 3:
266                 if (ha->optrom_state != QLA_SWRITING)
267                         break;
268
269                 ha->isp_ops.write_optrom(ha, ha->optrom_buffer, 0,
270                     ha->optrom_size);
271                 break;
272         }
273         return count;
274 }
275
276 static struct bin_attribute sysfs_optrom_ctl_attr = {
277         .attr = {
278                 .name = "optrom_ctl",
279                 .mode = S_IWUSR,
280                 .owner = THIS_MODULE,
281         },
282         .size = 0,
283         .write = qla2x00_sysfs_write_optrom_ctl,
284 };
285
286 static ssize_t
287 qla2x00_sysfs_read_vpd(struct kobject *kobj, char *buf, loff_t off,
288     size_t count)
289 {
290         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
291             struct device, kobj)));
292         unsigned long flags;
293
294         if (!capable(CAP_SYS_ADMIN) || off != 0)
295                 return 0;
296
297         /* Read NVRAM. */
298         spin_lock_irqsave(&ha->hardware_lock, flags);
299         ha->isp_ops.read_nvram(ha, (uint8_t *)buf, ha->vpd_base, ha->vpd_size);
300         spin_unlock_irqrestore(&ha->hardware_lock, flags);
301
302         return ha->vpd_size;
303 }
304
305 static ssize_t
306 qla2x00_sysfs_write_vpd(struct kobject *kobj, char *buf, loff_t off,
307     size_t count)
308 {
309         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
310             struct device, kobj)));
311         unsigned long flags;
312
313         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size)
314                 return 0;
315
316         /* Write NVRAM. */
317         spin_lock_irqsave(&ha->hardware_lock, flags);
318         ha->isp_ops.write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count);
319         spin_unlock_irqrestore(&ha->hardware_lock, flags);
320
321         return count;
322 }
323
324 static struct bin_attribute sysfs_vpd_attr = {
325         .attr = {
326                 .name = "vpd",
327                 .mode = S_IRUSR | S_IWUSR,
328                 .owner = THIS_MODULE,
329         },
330         .size = 0,
331         .read = qla2x00_sysfs_read_vpd,
332         .write = qla2x00_sysfs_write_vpd,
333 };
334
335 static ssize_t
336 qla2x00_sysfs_read_sfp(struct kobject *kobj, char *buf, loff_t off,
337     size_t count)
338 {
339         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
340             struct device, kobj)));
341         uint16_t iter, addr, offset;
342         int rval;
343
344         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != SFP_DEV_SIZE * 2)
345                 return 0;
346
347         addr = 0xa0;
348         for (iter = 0, offset = 0; iter < (SFP_DEV_SIZE * 2) / SFP_BLOCK_SIZE;
349             iter++, offset += SFP_BLOCK_SIZE) {
350                 if (iter == 4) {
351                         /* Skip to next device address. */
352                         addr = 0xa2;
353                         offset = 0;
354                 }
355
356                 rval = qla2x00_read_sfp(ha, ha->sfp_data_dma, addr, offset,
357                     SFP_BLOCK_SIZE);
358                 if (rval != QLA_SUCCESS) {
359                         qla_printk(KERN_WARNING, ha,
360                             "Unable to read SFP data (%x/%x/%x).\n", rval,
361                             addr, offset);
362                         count = 0;
363                         break;
364                 }
365                 memcpy(buf, ha->sfp_data, SFP_BLOCK_SIZE);
366                 buf += SFP_BLOCK_SIZE;
367         }
368
369         return count;
370 }
371
372 static struct bin_attribute sysfs_sfp_attr = {
373         .attr = {
374                 .name = "sfp",
375                 .mode = S_IRUSR | S_IWUSR,
376                 .owner = THIS_MODULE,
377         },
378         .size = SFP_DEV_SIZE * 2,
379         .read = qla2x00_sysfs_read_sfp,
380 };
381
382 static struct sysfs_entry {
383         char *name;
384         struct bin_attribute *attr;
385         int is4GBp_only;
386 } bin_file_entries[] = {
387         { "fw_dump", &sysfs_fw_dump_attr, },
388         { "nvram", &sysfs_nvram_attr, },
389         { "optrom", &sysfs_optrom_attr, },
390         { "optrom_ctl", &sysfs_optrom_ctl_attr, },
391         { "vpd", &sysfs_vpd_attr, 1 },
392         { "sfp", &sysfs_sfp_attr, 1 },
393         { 0 },
394 };
395
396 void
397 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
398 {
399         struct Scsi_Host *host = ha->host;
400         struct sysfs_entry *iter;
401         int ret;
402
403         for (iter = bin_file_entries; iter->name; iter++) {
404                 if (iter->is4GBp_only && (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)))
405                         continue;
406
407                 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
408                     iter->attr);
409                 if (ret)
410                         qla_printk(KERN_INFO, ha,
411                             "Unable to create sysfs %s binary attribute "
412                             "(%d).\n", iter->name, ret);
413         }
414 }
415
416 void
417 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
418 {
419         struct Scsi_Host *host = ha->host;
420         struct sysfs_entry *iter;
421
422         for (iter = bin_file_entries; iter->name; iter++) {
423                 if (iter->is4GBp_only && (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)))
424                         continue;
425
426                 sysfs_remove_bin_file(&host->shost_gendev.kobj,
427                     iter->attr);
428         }
429
430         if (ha->beacon_blink_led == 1)
431                 ha->isp_ops.beacon_off(ha);
432 }
433
434 /* Scsi_Host attributes. */
435
436 static ssize_t
437 qla2x00_drvr_version_show(struct class_device *cdev, char *buf)
438 {
439         return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
440 }
441
442 static ssize_t
443 qla2x00_fw_version_show(struct class_device *cdev, char *buf)
444 {
445         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
446         char fw_str[30];
447
448         return snprintf(buf, PAGE_SIZE, "%s\n",
449             ha->isp_ops.fw_version_str(ha, fw_str));
450 }
451
452 static ssize_t
453 qla2x00_serial_num_show(struct class_device *cdev, char *buf)
454 {
455         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
456         uint32_t sn;
457
458         sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
459         return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
460             sn % 100000);
461 }
462
463 static ssize_t
464 qla2x00_isp_name_show(struct class_device *cdev, char *buf)
465 {
466         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
467         return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device);
468 }
469
470 static ssize_t
471 qla2x00_isp_id_show(struct class_device *cdev, char *buf)
472 {
473         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
474         return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
475             ha->product_id[0], ha->product_id[1], ha->product_id[2],
476             ha->product_id[3]);
477 }
478
479 static ssize_t
480 qla2x00_model_name_show(struct class_device *cdev, char *buf)
481 {
482         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
483         return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number);
484 }
485
486 static ssize_t
487 qla2x00_model_desc_show(struct class_device *cdev, char *buf)
488 {
489         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
490         return snprintf(buf, PAGE_SIZE, "%s\n",
491             ha->model_desc ? ha->model_desc: "");
492 }
493
494 static ssize_t
495 qla2x00_pci_info_show(struct class_device *cdev, char *buf)
496 {
497         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
498         char pci_info[30];
499
500         return snprintf(buf, PAGE_SIZE, "%s\n",
501             ha->isp_ops.pci_info_str(ha, pci_info));
502 }
503
504 static ssize_t
505 qla2x00_state_show(struct class_device *cdev, char *buf)
506 {
507         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
508         int len = 0;
509
510         if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
511             atomic_read(&ha->loop_state) == LOOP_DEAD)
512                 len = snprintf(buf, PAGE_SIZE, "Link Down\n");
513         else if (atomic_read(&ha->loop_state) != LOOP_READY ||
514             test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) ||
515             test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags))
516                 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n");
517         else {
518                 len = snprintf(buf, PAGE_SIZE, "Link Up - ");
519
520                 switch (ha->current_topology) {
521                 case ISP_CFG_NL:
522                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
523                         break;
524                 case ISP_CFG_FL:
525                         len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
526                         break;
527                 case ISP_CFG_N:
528                         len += snprintf(buf + len, PAGE_SIZE-len,
529                             "N_Port to N_Port\n");
530                         break;
531                 case ISP_CFG_F:
532                         len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
533                         break;
534                 default:
535                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
536                         break;
537                 }
538         }
539         return len;
540 }
541
542 static ssize_t
543 qla2x00_zio_show(struct class_device *cdev, char *buf)
544 {
545         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
546         int len = 0;
547
548         switch (ha->zio_mode) {
549         case QLA_ZIO_MODE_6:
550                 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
551                 break;
552         case QLA_ZIO_DISABLED:
553                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
554                 break;
555         }
556         return len;
557 }
558
559 static ssize_t
560 qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count)
561 {
562         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
563         int val = 0;
564         uint16_t zio_mode;
565
566         if (!IS_ZIO_SUPPORTED(ha))
567                 return -ENOTSUPP;
568
569         if (sscanf(buf, "%d", &val) != 1)
570                 return -EINVAL;
571
572         if (val)
573                 zio_mode = QLA_ZIO_MODE_6;
574         else
575                 zio_mode = QLA_ZIO_DISABLED;
576
577         /* Update per-hba values and queue a reset. */
578         if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
579                 ha->zio_mode = zio_mode;
580                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
581         }
582         return strlen(buf);
583 }
584
585 static ssize_t
586 qla2x00_zio_timer_show(struct class_device *cdev, char *buf)
587 {
588         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
589
590         return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100);
591 }
592
593 static ssize_t
594 qla2x00_zio_timer_store(struct class_device *cdev, const char *buf,
595     size_t count)
596 {
597         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
598         int val = 0;
599         uint16_t zio_timer;
600
601         if (sscanf(buf, "%d", &val) != 1)
602                 return -EINVAL;
603         if (val > 25500 || val < 100)
604                 return -ERANGE;
605
606         zio_timer = (uint16_t)(val / 100);
607         ha->zio_timer = zio_timer;
608
609         return strlen(buf);
610 }
611
612 static ssize_t
613 qla2x00_beacon_show(struct class_device *cdev, char *buf)
614 {
615         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
616         int len = 0;
617
618         if (ha->beacon_blink_led)
619                 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
620         else
621                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
622         return len;
623 }
624
625 static ssize_t
626 qla2x00_beacon_store(struct class_device *cdev, const char *buf,
627     size_t count)
628 {
629         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
630         int val = 0;
631         int rval;
632
633         if (IS_QLA2100(ha) || IS_QLA2200(ha))
634                 return -EPERM;
635
636         if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) {
637                 qla_printk(KERN_WARNING, ha,
638                     "Abort ISP active -- ignoring beacon request.\n");
639                 return -EBUSY;
640         }
641
642         if (sscanf(buf, "%d", &val) != 1)
643                 return -EINVAL;
644
645         if (val)
646                 rval = ha->isp_ops.beacon_on(ha);
647         else
648                 rval = ha->isp_ops.beacon_off(ha);
649
650         if (rval != QLA_SUCCESS)
651                 count = 0;
652
653         return count;
654 }
655
656 static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show,
657         NULL);
658 static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
659 static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
660 static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
661 static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
662 static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
663 static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
664 static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
665 static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL);
666 static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show,
667     qla2x00_zio_store);
668 static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
669     qla2x00_zio_timer_store);
670 static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
671     qla2x00_beacon_store);
672
673 struct class_device_attribute *qla2x00_host_attrs[] = {
674         &class_device_attr_driver_version,
675         &class_device_attr_fw_version,
676         &class_device_attr_serial_num,
677         &class_device_attr_isp_name,
678         &class_device_attr_isp_id,
679         &class_device_attr_model_name,
680         &class_device_attr_model_desc,
681         &class_device_attr_pci_info,
682         &class_device_attr_state,
683         &class_device_attr_zio,
684         &class_device_attr_zio_timer,
685         &class_device_attr_beacon,
686         NULL,
687 };
688
689 /* Host attributes. */
690
691 static void
692 qla2x00_get_host_port_id(struct Scsi_Host *shost)
693 {
694         scsi_qla_host_t *ha = to_qla_host(shost);
695
696         fc_host_port_id(shost) = ha->d_id.b.domain << 16 |
697             ha->d_id.b.area << 8 | ha->d_id.b.al_pa;
698 }
699
700 static void
701 qla2x00_get_host_speed(struct Scsi_Host *shost)
702 {
703         scsi_qla_host_t *ha = to_qla_host(shost);
704         uint32_t speed = 0;
705
706         switch (ha->link_data_rate) {
707         case PORT_SPEED_1GB:
708                 speed = 1;
709                 break;
710         case PORT_SPEED_2GB:
711                 speed = 2;
712                 break;
713         case PORT_SPEED_4GB:
714                 speed = 4;
715                 break;
716         }
717         fc_host_speed(shost) = speed;
718 }
719
720 static void
721 qla2x00_get_host_port_type(struct Scsi_Host *shost)
722 {
723         scsi_qla_host_t *ha = to_qla_host(shost);
724         uint32_t port_type = FC_PORTTYPE_UNKNOWN;
725
726         switch (ha->current_topology) {
727         case ISP_CFG_NL:
728                 port_type = FC_PORTTYPE_LPORT;
729                 break;
730         case ISP_CFG_FL:
731                 port_type = FC_PORTTYPE_NLPORT;
732                 break;
733         case ISP_CFG_N:
734                 port_type = FC_PORTTYPE_PTP;
735                 break;
736         case ISP_CFG_F:
737                 port_type = FC_PORTTYPE_NPORT;
738                 break;
739         }
740         fc_host_port_type(shost) = port_type;
741 }
742
743 static void
744 qla2x00_get_starget_node_name(struct scsi_target *starget)
745 {
746         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
747         scsi_qla_host_t *ha = to_qla_host(host);
748         fc_port_t *fcport;
749         u64 node_name = 0;
750
751         list_for_each_entry(fcport, &ha->fcports, list) {
752                 if (starget->id == fcport->os_target_id) {
753                         node_name = wwn_to_u64(fcport->node_name);
754                         break;
755                 }
756         }
757
758         fc_starget_node_name(starget) = node_name;
759 }
760
761 static void
762 qla2x00_get_starget_port_name(struct scsi_target *starget)
763 {
764         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
765         scsi_qla_host_t *ha = to_qla_host(host);
766         fc_port_t *fcport;
767         u64 port_name = 0;
768
769         list_for_each_entry(fcport, &ha->fcports, list) {
770                 if (starget->id == fcport->os_target_id) {
771                         port_name = wwn_to_u64(fcport->port_name);
772                         break;
773                 }
774         }
775
776         fc_starget_port_name(starget) = port_name;
777 }
778
779 static void
780 qla2x00_get_starget_port_id(struct scsi_target *starget)
781 {
782         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
783         scsi_qla_host_t *ha = to_qla_host(host);
784         fc_port_t *fcport;
785         uint32_t port_id = ~0U;
786
787         list_for_each_entry(fcport, &ha->fcports, list) {
788                 if (starget->id == fcport->os_target_id) {
789                         port_id = fcport->d_id.b.domain << 16 |
790                             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
791                         break;
792                 }
793         }
794
795         fc_starget_port_id(starget) = port_id;
796 }
797
798 static void
799 qla2x00_get_rport_loss_tmo(struct fc_rport *rport)
800 {
801         struct Scsi_Host *host = rport_to_shost(rport);
802         scsi_qla_host_t *ha = to_qla_host(host);
803
804         rport->dev_loss_tmo = ha->port_down_retry_count + 5;
805 }
806
807 static void
808 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
809 {
810         struct Scsi_Host *host = rport_to_shost(rport);
811         scsi_qla_host_t *ha = to_qla_host(host);
812
813         if (timeout)
814                 ha->port_down_retry_count = timeout;
815         else
816                 ha->port_down_retry_count = 1;
817
818         rport->dev_loss_tmo = ha->port_down_retry_count + 5;
819 }
820
821 static int
822 qla2x00_issue_lip(struct Scsi_Host *shost)
823 {
824         scsi_qla_host_t *ha = to_qla_host(shost);
825
826         set_bit(LOOP_RESET_NEEDED, &ha->dpc_flags);
827         return 0;
828 }
829
830 static struct fc_host_statistics *
831 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
832 {
833         scsi_qla_host_t *ha = to_qla_host(shost);
834         int rval;
835         uint16_t mb_stat[1];
836         link_stat_t stat_buf;
837         struct fc_host_statistics *pfc_host_stat;
838
839         pfc_host_stat = &ha->fc_host_stat;
840         memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
841
842         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
843                 rval = qla24xx_get_isp_stats(ha, (uint32_t *)&stat_buf,
844                     sizeof(stat_buf) / 4, mb_stat);
845         } else {
846                 rval = qla2x00_get_link_status(ha, ha->loop_id, &stat_buf,
847                     mb_stat);
848         }
849         if (rval != 0) {
850                 qla_printk(KERN_WARNING, ha,
851                     "Unable to retrieve host statistics (%d).\n", mb_stat[0]);
852                 return pfc_host_stat;
853         }
854
855         pfc_host_stat->link_failure_count = stat_buf.link_fail_cnt;
856         pfc_host_stat->loss_of_sync_count = stat_buf.loss_sync_cnt;
857         pfc_host_stat->loss_of_signal_count = stat_buf.loss_sig_cnt;
858         pfc_host_stat->prim_seq_protocol_err_count = stat_buf.prim_seq_err_cnt;
859         pfc_host_stat->invalid_tx_word_count = stat_buf.inval_xmit_word_cnt;
860         pfc_host_stat->invalid_crc_count = stat_buf.inval_crc_cnt;
861
862         return pfc_host_stat;
863 }
864
865 static void
866 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
867 {
868         scsi_qla_host_t *ha = to_qla_host(shost);
869
870         qla2x00_get_sym_node_name(ha, fc_host_symbolic_name(shost));
871 }
872
873 static void
874 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
875 {
876         scsi_qla_host_t *ha = to_qla_host(shost);
877
878         set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
879 }
880
881 static void
882 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
883 {
884         scsi_qla_host_t *ha = to_qla_host(shost);
885         u64 node_name;
886
887         if (ha->device_flags & SWITCH_FOUND)
888                 node_name = wwn_to_u64(ha->fabric_node_name);
889         else
890                 node_name = wwn_to_u64(ha->node_name);
891
892         fc_host_fabric_name(shost) = node_name;
893 }
894
895 static void
896 qla2x00_get_host_port_state(struct Scsi_Host *shost)
897 {
898         scsi_qla_host_t *ha = to_qla_host(shost);
899
900         if (!ha->flags.online)
901                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
902         else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT)
903                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
904         else
905                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
906 }
907
908 struct fc_function_template qla2xxx_transport_functions = {
909
910         .show_host_node_name = 1,
911         .show_host_port_name = 1,
912         .show_host_supported_classes = 1,
913
914         .get_host_port_id = qla2x00_get_host_port_id,
915         .show_host_port_id = 1,
916         .get_host_speed = qla2x00_get_host_speed,
917         .show_host_speed = 1,
918         .get_host_port_type = qla2x00_get_host_port_type,
919         .show_host_port_type = 1,
920         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
921         .show_host_symbolic_name = 1,
922         .set_host_system_hostname = qla2x00_set_host_system_hostname,
923         .show_host_system_hostname = 1,
924         .get_host_fabric_name = qla2x00_get_host_fabric_name,
925         .show_host_fabric_name = 1,
926         .get_host_port_state = qla2x00_get_host_port_state,
927         .show_host_port_state = 1,
928
929         .dd_fcrport_size = sizeof(struct fc_port *),
930         .show_rport_supported_classes = 1,
931
932         .get_starget_node_name = qla2x00_get_starget_node_name,
933         .show_starget_node_name = 1,
934         .get_starget_port_name = qla2x00_get_starget_port_name,
935         .show_starget_port_name = 1,
936         .get_starget_port_id  = qla2x00_get_starget_port_id,
937         .show_starget_port_id = 1,
938
939         .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo,
940         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
941         .show_rport_dev_loss_tmo = 1,
942
943         .issue_fc_host_lip = qla2x00_issue_lip,
944         .get_fc_host_stats = qla2x00_get_fc_host_stats,
945 };
946
947 void
948 qla2x00_init_host_attr(scsi_qla_host_t *ha)
949 {
950         fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name);
951         fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name);
952         fc_host_supported_classes(ha->host) = FC_COS_CLASS3;
953 }