[SCSI] qla2xxx: Add support for symbolic nodename FC transport attribute.
[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 void
383 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
384 {
385         struct Scsi_Host *host = ha->host;
386
387         sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
388         sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
389         sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_optrom_attr);
390         sysfs_create_bin_file(&host->shost_gendev.kobj,
391             &sysfs_optrom_ctl_attr);
392         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
393                 sysfs_create_bin_file(&host->shost_gendev.kobj,
394                     &sysfs_vpd_attr);
395                 sysfs_create_bin_file(&host->shost_gendev.kobj,
396                     &sysfs_sfp_attr);
397         }
398 }
399
400 void
401 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
402 {
403         struct Scsi_Host *host = ha->host;
404
405         sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
406         sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
407         sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_optrom_attr);
408         sysfs_remove_bin_file(&host->shost_gendev.kobj,
409             &sysfs_optrom_ctl_attr);
410         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
411                 sysfs_remove_bin_file(&host->shost_gendev.kobj,
412                     &sysfs_vpd_attr);
413                 sysfs_remove_bin_file(&host->shost_gendev.kobj,
414                     &sysfs_sfp_attr);
415         }
416
417         if (ha->beacon_blink_led == 1)
418                 ha->isp_ops.beacon_off(ha);
419 }
420
421 /* Scsi_Host attributes. */
422
423 static ssize_t
424 qla2x00_drvr_version_show(struct class_device *cdev, char *buf)
425 {
426         return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
427 }
428
429 static ssize_t
430 qla2x00_fw_version_show(struct class_device *cdev, char *buf)
431 {
432         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
433         char fw_str[30];
434
435         return snprintf(buf, PAGE_SIZE, "%s\n",
436             ha->isp_ops.fw_version_str(ha, fw_str));
437 }
438
439 static ssize_t
440 qla2x00_serial_num_show(struct class_device *cdev, char *buf)
441 {
442         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
443         uint32_t sn;
444
445         sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
446         return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
447             sn % 100000);
448 }
449
450 static ssize_t
451 qla2x00_isp_name_show(struct class_device *cdev, char *buf)
452 {
453         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
454         return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device);
455 }
456
457 static ssize_t
458 qla2x00_isp_id_show(struct class_device *cdev, char *buf)
459 {
460         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
461         return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
462             ha->product_id[0], ha->product_id[1], ha->product_id[2],
463             ha->product_id[3]);
464 }
465
466 static ssize_t
467 qla2x00_model_name_show(struct class_device *cdev, char *buf)
468 {
469         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
470         return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number);
471 }
472
473 static ssize_t
474 qla2x00_model_desc_show(struct class_device *cdev, char *buf)
475 {
476         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
477         return snprintf(buf, PAGE_SIZE, "%s\n",
478             ha->model_desc ? ha->model_desc: "");
479 }
480
481 static ssize_t
482 qla2x00_pci_info_show(struct class_device *cdev, char *buf)
483 {
484         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
485         char pci_info[30];
486
487         return snprintf(buf, PAGE_SIZE, "%s\n",
488             ha->isp_ops.pci_info_str(ha, pci_info));
489 }
490
491 static ssize_t
492 qla2x00_state_show(struct class_device *cdev, char *buf)
493 {
494         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
495         int len = 0;
496
497         if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
498             atomic_read(&ha->loop_state) == LOOP_DEAD)
499                 len = snprintf(buf, PAGE_SIZE, "Link Down\n");
500         else if (atomic_read(&ha->loop_state) != LOOP_READY ||
501             test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) ||
502             test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags))
503                 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n");
504         else {
505                 len = snprintf(buf, PAGE_SIZE, "Link Up - ");
506
507                 switch (ha->current_topology) {
508                 case ISP_CFG_NL:
509                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
510                         break;
511                 case ISP_CFG_FL:
512                         len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
513                         break;
514                 case ISP_CFG_N:
515                         len += snprintf(buf + len, PAGE_SIZE-len,
516                             "N_Port to N_Port\n");
517                         break;
518                 case ISP_CFG_F:
519                         len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
520                         break;
521                 default:
522                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
523                         break;
524                 }
525         }
526         return len;
527 }
528
529 static ssize_t
530 qla2x00_zio_show(struct class_device *cdev, char *buf)
531 {
532         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
533         int len = 0;
534
535         switch (ha->zio_mode) {
536         case QLA_ZIO_MODE_6:
537                 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
538                 break;
539         case QLA_ZIO_DISABLED:
540                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
541                 break;
542         }
543         return len;
544 }
545
546 static ssize_t
547 qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count)
548 {
549         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
550         int val = 0;
551         uint16_t zio_mode;
552
553         if (!IS_ZIO_SUPPORTED(ha))
554                 return -ENOTSUPP;
555
556         if (sscanf(buf, "%d", &val) != 1)
557                 return -EINVAL;
558
559         if (val)
560                 zio_mode = QLA_ZIO_MODE_6;
561         else
562                 zio_mode = QLA_ZIO_DISABLED;
563
564         /* Update per-hba values and queue a reset. */
565         if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
566                 ha->zio_mode = zio_mode;
567                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
568         }
569         return strlen(buf);
570 }
571
572 static ssize_t
573 qla2x00_zio_timer_show(struct class_device *cdev, char *buf)
574 {
575         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
576
577         return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100);
578 }
579
580 static ssize_t
581 qla2x00_zio_timer_store(struct class_device *cdev, const char *buf,
582     size_t count)
583 {
584         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
585         int val = 0;
586         uint16_t zio_timer;
587
588         if (sscanf(buf, "%d", &val) != 1)
589                 return -EINVAL;
590         if (val > 25500 || val < 100)
591                 return -ERANGE;
592
593         zio_timer = (uint16_t)(val / 100);
594         ha->zio_timer = zio_timer;
595
596         return strlen(buf);
597 }
598
599 static ssize_t
600 qla2x00_beacon_show(struct class_device *cdev, char *buf)
601 {
602         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
603         int len = 0;
604
605         if (ha->beacon_blink_led)
606                 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
607         else
608                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
609         return len;
610 }
611
612 static ssize_t
613 qla2x00_beacon_store(struct class_device *cdev, const char *buf,
614     size_t count)
615 {
616         scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
617         int val = 0;
618         int rval;
619
620         if (IS_QLA2100(ha) || IS_QLA2200(ha))
621                 return -EPERM;
622
623         if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) {
624                 qla_printk(KERN_WARNING, ha,
625                     "Abort ISP active -- ignoring beacon request.\n");
626                 return -EBUSY;
627         }
628
629         if (sscanf(buf, "%d", &val) != 1)
630                 return -EINVAL;
631
632         if (val)
633                 rval = ha->isp_ops.beacon_on(ha);
634         else
635                 rval = ha->isp_ops.beacon_off(ha);
636
637         if (rval != QLA_SUCCESS)
638                 count = 0;
639
640         return count;
641 }
642
643 static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show,
644         NULL);
645 static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
646 static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
647 static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
648 static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
649 static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
650 static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
651 static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
652 static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL);
653 static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show,
654     qla2x00_zio_store);
655 static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
656     qla2x00_zio_timer_store);
657 static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
658     qla2x00_beacon_store);
659
660 struct class_device_attribute *qla2x00_host_attrs[] = {
661         &class_device_attr_driver_version,
662         &class_device_attr_fw_version,
663         &class_device_attr_serial_num,
664         &class_device_attr_isp_name,
665         &class_device_attr_isp_id,
666         &class_device_attr_model_name,
667         &class_device_attr_model_desc,
668         &class_device_attr_pci_info,
669         &class_device_attr_state,
670         &class_device_attr_zio,
671         &class_device_attr_zio_timer,
672         &class_device_attr_beacon,
673         NULL,
674 };
675
676 /* Host attributes. */
677
678 static void
679 qla2x00_get_host_port_id(struct Scsi_Host *shost)
680 {
681         scsi_qla_host_t *ha = to_qla_host(shost);
682
683         fc_host_port_id(shost) = ha->d_id.b.domain << 16 |
684             ha->d_id.b.area << 8 | ha->d_id.b.al_pa;
685 }
686
687 static void
688 qla2x00_get_host_speed(struct Scsi_Host *shost)
689 {
690         scsi_qla_host_t *ha = to_qla_host(shost);
691         uint32_t speed = 0;
692
693         switch (ha->link_data_rate) {
694         case PORT_SPEED_1GB:
695                 speed = 1;
696                 break;
697         case PORT_SPEED_2GB:
698                 speed = 2;
699                 break;
700         case PORT_SPEED_4GB:
701                 speed = 4;
702                 break;
703         }
704         fc_host_speed(shost) = speed;
705 }
706
707 static void
708 qla2x00_get_host_port_type(struct Scsi_Host *shost)
709 {
710         scsi_qla_host_t *ha = to_qla_host(shost);
711         uint32_t port_type = FC_PORTTYPE_UNKNOWN;
712
713         switch (ha->current_topology) {
714         case ISP_CFG_NL:
715                 port_type = FC_PORTTYPE_LPORT;
716                 break;
717         case ISP_CFG_FL:
718                 port_type = FC_PORTTYPE_NLPORT;
719                 break;
720         case ISP_CFG_N:
721                 port_type = FC_PORTTYPE_PTP;
722                 break;
723         case ISP_CFG_F:
724                 port_type = FC_PORTTYPE_NPORT;
725                 break;
726         }
727         fc_host_port_type(shost) = port_type;
728 }
729
730 static void
731 qla2x00_get_starget_node_name(struct scsi_target *starget)
732 {
733         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
734         scsi_qla_host_t *ha = to_qla_host(host);
735         fc_port_t *fcport;
736         u64 node_name = 0;
737
738         list_for_each_entry(fcport, &ha->fcports, list) {
739                 if (starget->id == fcport->os_target_id) {
740                         node_name = wwn_to_u64(fcport->node_name);
741                         break;
742                 }
743         }
744
745         fc_starget_node_name(starget) = node_name;
746 }
747
748 static void
749 qla2x00_get_starget_port_name(struct scsi_target *starget)
750 {
751         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
752         scsi_qla_host_t *ha = to_qla_host(host);
753         fc_port_t *fcport;
754         u64 port_name = 0;
755
756         list_for_each_entry(fcport, &ha->fcports, list) {
757                 if (starget->id == fcport->os_target_id) {
758                         port_name = wwn_to_u64(fcport->port_name);
759                         break;
760                 }
761         }
762
763         fc_starget_port_name(starget) = port_name;
764 }
765
766 static void
767 qla2x00_get_starget_port_id(struct scsi_target *starget)
768 {
769         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
770         scsi_qla_host_t *ha = to_qla_host(host);
771         fc_port_t *fcport;
772         uint32_t port_id = ~0U;
773
774         list_for_each_entry(fcport, &ha->fcports, list) {
775                 if (starget->id == fcport->os_target_id) {
776                         port_id = fcport->d_id.b.domain << 16 |
777                             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
778                         break;
779                 }
780         }
781
782         fc_starget_port_id(starget) = port_id;
783 }
784
785 static void
786 qla2x00_get_rport_loss_tmo(struct fc_rport *rport)
787 {
788         struct Scsi_Host *host = rport_to_shost(rport);
789         scsi_qla_host_t *ha = to_qla_host(host);
790
791         rport->dev_loss_tmo = ha->port_down_retry_count + 5;
792 }
793
794 static void
795 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
796 {
797         struct Scsi_Host *host = rport_to_shost(rport);
798         scsi_qla_host_t *ha = to_qla_host(host);
799
800         if (timeout)
801                 ha->port_down_retry_count = timeout;
802         else
803                 ha->port_down_retry_count = 1;
804
805         rport->dev_loss_tmo = ha->port_down_retry_count + 5;
806 }
807
808 static int
809 qla2x00_issue_lip(struct Scsi_Host *shost)
810 {
811         scsi_qla_host_t *ha = to_qla_host(shost);
812
813         set_bit(LOOP_RESET_NEEDED, &ha->dpc_flags);
814         return 0;
815 }
816
817 static struct fc_host_statistics *
818 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
819 {
820         scsi_qla_host_t *ha = to_qla_host(shost);
821         int rval;
822         uint16_t mb_stat[1];
823         link_stat_t stat_buf;
824         struct fc_host_statistics *pfc_host_stat;
825
826         pfc_host_stat = &ha->fc_host_stat;
827         memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
828
829         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
830                 rval = qla24xx_get_isp_stats(ha, (uint32_t *)&stat_buf,
831                     sizeof(stat_buf) / 4, mb_stat);
832         } else {
833                 rval = qla2x00_get_link_status(ha, ha->loop_id, &stat_buf,
834                     mb_stat);
835         }
836         if (rval != 0) {
837                 qla_printk(KERN_WARNING, ha,
838                     "Unable to retrieve host statistics (%d).\n", mb_stat[0]);
839                 return pfc_host_stat;
840         }
841
842         pfc_host_stat->link_failure_count = stat_buf.link_fail_cnt;
843         pfc_host_stat->loss_of_sync_count = stat_buf.loss_sync_cnt;
844         pfc_host_stat->loss_of_signal_count = stat_buf.loss_sig_cnt;
845         pfc_host_stat->prim_seq_protocol_err_count = stat_buf.prim_seq_err_cnt;
846         pfc_host_stat->invalid_tx_word_count = stat_buf.inval_xmit_word_cnt;
847         pfc_host_stat->invalid_crc_count = stat_buf.inval_crc_cnt;
848
849         return pfc_host_stat;
850 }
851
852 static void
853 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
854 {
855         scsi_qla_host_t *ha = to_qla_host(shost);
856
857         qla2x00_get_sym_node_name(ha, fc_host_symbolic_name(shost));
858 }
859
860 struct fc_function_template qla2xxx_transport_functions = {
861
862         .show_host_node_name = 1,
863         .show_host_port_name = 1,
864         .show_host_supported_classes = 1,
865
866         .get_host_port_id = qla2x00_get_host_port_id,
867         .show_host_port_id = 1,
868         .get_host_speed = qla2x00_get_host_speed,
869         .show_host_speed = 1,
870         .get_host_port_type = qla2x00_get_host_port_type,
871         .show_host_port_type = 1,
872         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
873         .show_host_symbolic_name = 1,
874
875         .dd_fcrport_size = sizeof(struct fc_port *),
876         .show_rport_supported_classes = 1,
877
878         .get_starget_node_name = qla2x00_get_starget_node_name,
879         .show_starget_node_name = 1,
880         .get_starget_port_name = qla2x00_get_starget_port_name,
881         .show_starget_port_name = 1,
882         .get_starget_port_id  = qla2x00_get_starget_port_id,
883         .show_starget_port_id = 1,
884
885         .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo,
886         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
887         .show_rport_dev_loss_tmo = 1,
888
889         .issue_fc_host_lip = qla2x00_issue_lip,
890         .get_fc_host_stats = qla2x00_get_fc_host_stats,
891 };
892
893 void
894 qla2x00_init_host_attr(scsi_qla_host_t *ha)
895 {
896         fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name);
897         fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name);
898         fc_host_supported_classes(ha->host) = FC_COS_CLASS3;
899 }