projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] qla2xxx: Add flash burst-read/write support.
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / scsi / qla2xxx / qla_attr.c
CommitLineData
8482e118 1/*
fa90c54f
AV		 2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2005 QLogic Corporation
8482e118 4 *
fa90c54f 5 * See LICENSE.qla2xxx for copyright and licensing details.
8482e118
AV		 6 */
7#include "qla_def.h"
8
2c3dfe3f 9#include <linux/kthread.h>
7aaef27b 10#include <linux/vmalloc.h>
8482e118 11
2c3dfe3f
SJ		 12int qla24xx_vport_disable(struct fc_vport *, bool);
13
8482e118
AV		 14/* SYSFS attributes --------------------------------------------------------- */
15
16static ssize_t
91a69029
ZR		 17qla2x00_sysfs_read_fw_dump(struct kobject *kobj,
18 struct bin_attribute *bin_attr,
19 char *buf, loff_t off, size_t count)
8482e118
AV		 20{
21 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
22 struct device, kobj)));
a7a167bf 23 char *rbuf = (char *)ha->fw_dump;
8482e118
AV		 24
25 if (ha->fw_dump_reading == 0)
26 return 0;
a7a167bf
AV		 27 if (off > ha->fw_dump_len)
28 return 0;
29 if (off + count > ha->fw_dump_len)
30 count = ha->fw_dump_len - off;
8482e118 31
a7a167bf 32 memcpy(buf, &rbuf[off], count);
8482e118
AV		 33
34 return (count);
35}
36
37static ssize_t
91a69029
ZR		 38qla2x00_sysfs_write_fw_dump(struct kobject *kobj,
39 struct bin_attribute *bin_attr,
40 char *buf, loff_t off, size_t count)
8482e118
AV		 41{
42 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
43 struct device, kobj)));
44 int reading;
8482e118
AV		 45
46 if (off != 0)
47 return (0);
48
49 reading = simple_strtol(buf, NULL, 10);
50 switch (reading) {
51 case 0:
a7a167bf
AV		 52 if (!ha->fw_dump_reading)
53 break;
8482e118 54
a7a167bf
AV		 55 qla_printk(KERN_INFO, ha,
56 "Firmware dump cleared on (%ld).\n", ha->host_no);
57
58 ha->fw_dump_reading = 0;
59 ha->fw_dumped = 0;
8482e118
AV		 60 break;
61 case 1:
d4e3e04d 62 if (ha->fw_dumped && !ha->fw_dump_reading) {
8482e118
AV		 63 ha->fw_dump_reading = 1;
64
8482e118 65 qla_printk(KERN_INFO, ha,
a7a167bf 66 "Raw firmware dump ready for read on (%ld).\n",
8482e118 67 ha->host_no);
8482e118
AV		 68 }
69 break;
a7a167bf
AV		 70 case 2:
71 qla2x00_alloc_fw_dump(ha);
72 break;
8482e118
AV		 73 }
74 return (count);
75}
76
77static struct bin_attribute sysfs_fw_dump_attr = {
78 .attr = {
79 .name = "fw_dump",
80 .mode = S_IRUSR | S_IWUSR,
8482e118
AV		 81 },
82 .size = 0,
83 .read = qla2x00_sysfs_read_fw_dump,
84 .write = qla2x00_sysfs_write_fw_dump,
85};
86
87static ssize_t
91a69029
ZR		 88qla2x00_sysfs_read_nvram(struct kobject *kobj,
89 struct bin_attribute *bin_attr,
90 char *buf, loff_t off, size_t count)
8482e118
AV		 91{
92 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
93 struct device, kobj)));
281afe19
SJ		 94 int size = ha->nvram_size;
95 char *nvram_cache = ha->nvram;
8482e118 96
281afe19 97 if (!capable(CAP_SYS_ADMIN) || off > size || count == 0)
8482e118 98 return 0;
281afe19
SJ		 99 if (off + count > size) {
100 size -= off;
101 count = size;
102 }
8482e118 103
281afe19
SJ		 104 /* Read NVRAM data from cache. */
105 memcpy(buf, &nvram_cache[off], count);
8482e118 106
281afe19 107 return count;
8482e118
AV		 108}
109
110static ssize_t
91a69029
ZR		 111qla2x00_sysfs_write_nvram(struct kobject *kobj,
112 struct bin_attribute *bin_attr,
113 char *buf, loff_t off, size_t count)
8482e118
AV		 114{
115 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
116 struct device, kobj)));
8482e118
AV		 117 unsigned long flags;
118 uint16_t cnt;
8482e118 119
459c5378 120 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
8482e118
AV		 121 return 0;
122
123 /* Checksum NVRAM. */
e428924c 124 if (IS_FWI2_CAPABLE(ha)) {
459c5378
AV		 125 uint32_t *iter;
126 uint32_t chksum;
127
128 iter = (uint32_t *)buf;
129 chksum = 0;
130 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++)
131 chksum += le32_to_cpu(*iter++);
132 chksum = ~chksum + 1;
133 *iter = cpu_to_le32(chksum);
134 } else {
135 uint8_t *iter;
136 uint8_t chksum;
137
138 iter = (uint8_t *)buf;
139 chksum = 0;
140 for (cnt = 0; cnt < count - 1; cnt++)
141 chksum += *iter++;
142 chksum = ~chksum + 1;
143 *iter = chksum;
144 }
8482e118
AV		 145
146 /* Write NVRAM. */
147 spin_lock_irqsave(&ha->hardware_lock, flags);
fd34f556 148 ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count);
281afe19
SJ		 149 ha->isp_ops->read_nvram(ha, (uint8_t *)&ha->nvram, ha->nvram_base,
150 count);
8482e118
AV		 151 spin_unlock_irqrestore(&ha->hardware_lock, flags);
152
26b8d348
AV		 153 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
154
8482e118
AV		 155 return (count);
156}
157
158static struct bin_attribute sysfs_nvram_attr = {
159 .attr = {
160 .name = "nvram",
161 .mode = S_IRUSR | S_IWUSR,
8482e118 162 },
1b3f6365 163 .size = 512,
8482e118
AV		 164 .read = qla2x00_sysfs_read_nvram,
165 .write = qla2x00_sysfs_write_nvram,
166};
167
854165f4 168static ssize_t
91a69029
ZR		 169qla2x00_sysfs_read_optrom(struct kobject *kobj,
170 struct bin_attribute *bin_attr,
171 char *buf, loff_t off, size_t count)
854165f4
AV		 172{
173 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
174 struct device, kobj)));
175
176 if (ha->optrom_state != QLA_SREADING)
177 return 0;
178 if (off > ha->optrom_size)
179 return 0;
180 if (off + count > ha->optrom_size)
181 count = ha->optrom_size - off;
182
183 memcpy(buf, &ha->optrom_buffer[off], count);
184
185 return count;
186}
187
188static ssize_t
91a69029
ZR		 189qla2x00_sysfs_write_optrom(struct kobject *kobj,
190 struct bin_attribute *bin_attr,
191 char *buf, loff_t off, size_t count)
854165f4
AV		 192{
193 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
194 struct device, kobj)));
195
196 if (ha->optrom_state != QLA_SWRITING)
197 return -EINVAL;
198 if (off > ha->optrom_size)
199 return -ERANGE;
200 if (off + count > ha->optrom_size)
201 count = ha->optrom_size - off;
202
203 memcpy(&ha->optrom_buffer[off], buf, count);
204
205 return count;
206}
207
208static struct bin_attribute sysfs_optrom_attr = {
209 .attr = {
210 .name = "optrom",
211 .mode = S_IRUSR | S_IWUSR,
854165f4 212 },
c3a2f0df 213 .size = 0,
854165f4
AV		 214 .read = qla2x00_sysfs_read_optrom,
215 .write = qla2x00_sysfs_write_optrom,
216};
217
218static ssize_t
91a69029
ZR		 219qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj,
220 struct bin_attribute *bin_attr,
221 char *buf, loff_t off, size_t count)
854165f4
AV		 222{
223 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
224 struct device, kobj)));
225 int val;
226
227 if (off)
228 return 0;
229
230 if (sscanf(buf, "%d", &val) != 1)
231 return -EINVAL;
232
233 switch (val) {
234 case 0:
235 if (ha->optrom_state != QLA_SREADING &&
236 ha->optrom_state != QLA_SWRITING)
237 break;
238
239 ha->optrom_state = QLA_SWAITING;
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_state = QLA_SREADING;
248 ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size);
249 if (ha->optrom_buffer == NULL) {
250 qla_printk(KERN_WARNING, ha,
251 "Unable to allocate memory for optrom retrieval "
252 "(%x).\n", ha->optrom_size);
253
254 ha->optrom_state = QLA_SWAITING;
255 return count;
256 }
257
258 memset(ha->optrom_buffer, 0, ha->optrom_size);
fd34f556 259 ha->isp_ops->read_optrom(ha, ha->optrom_buffer, 0,
854165f4
AV		 260 ha->optrom_size);
261 break;
262 case 2:
263 if (ha->optrom_state != QLA_SWAITING)
264 break;
265
266 ha->optrom_state = QLA_SWRITING;
267 ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size);
268 if (ha->optrom_buffer == NULL) {
269 qla_printk(KERN_WARNING, ha,
270 "Unable to allocate memory for optrom update "
271 "(%x).\n", ha->optrom_size);
272
273 ha->optrom_state = QLA_SWAITING;
274 return count;
275 }
276 memset(ha->optrom_buffer, 0, ha->optrom_size);
277 break;
278 case 3:
279 if (ha->optrom_state != QLA_SWRITING)
280 break;
281
fd34f556 282 ha->isp_ops->write_optrom(ha, ha->optrom_buffer, 0,
854165f4
AV		 283 ha->optrom_size);
284 break;
285 }
286 return count;
287}
288
289static struct bin_attribute sysfs_optrom_ctl_attr = {
290 .attr = {
291 .name = "optrom_ctl",
292 .mode = S_IWUSR,
854165f4
AV		 293 },
294 .size = 0,
295 .write = qla2x00_sysfs_write_optrom_ctl,
296};
297
6f641790 298static ssize_t
91a69029
ZR		 299qla2x00_sysfs_read_vpd(struct kobject *kobj,
300 struct bin_attribute *bin_attr,
301 char *buf, loff_t off, size_t count)
6f641790
AV		 302{
303 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
304 struct device, kobj)));
281afe19
SJ		 305 int size = ha->vpd_size;
306 char *vpd_cache = ha->vpd;
6f641790 307
281afe19 308 if (!capable(CAP_SYS_ADMIN) || off > size || count == 0)
6f641790 309 return 0;
281afe19
SJ		 310 if (off + count > size) {
311 size -= off;
312 count = size;
313 }
6f641790 314
281afe19
SJ		 315 /* Read NVRAM data from cache. */
316 memcpy(buf, &vpd_cache[off], count);
6f641790 317
281afe19 318 return count;
6f641790
AV		 319}
320
321static ssize_t
91a69029
ZR		 322qla2x00_sysfs_write_vpd(struct kobject *kobj,
323 struct bin_attribute *bin_attr,
324 char *buf, loff_t off, size_t count)
6f641790
AV		 325{
326 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
327 struct device, kobj)));
328 unsigned long flags;
329
330 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size)
331 return 0;
332
6f641790
AV		 333 /* Write NVRAM. */
334 spin_lock_irqsave(&ha->hardware_lock, flags);
fd34f556 335 ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count);
281afe19 336 ha->isp_ops->read_nvram(ha, (uint8_t *)ha->vpd, ha->vpd_base, count);
6f641790
AV		 337 spin_unlock_irqrestore(&ha->hardware_lock, flags);
338
339 return count;
340}
341
342static struct bin_attribute sysfs_vpd_attr = {
343 .attr = {
344 .name = "vpd",
345 .mode = S_IRUSR | S_IWUSR,
6f641790
AV		 346 },
347 .size = 0,
348 .read = qla2x00_sysfs_read_vpd,
349 .write = qla2x00_sysfs_write_vpd,
350};
351
88729e53 352static ssize_t
91a69029
ZR		 353qla2x00_sysfs_read_sfp(struct kobject *kobj,
354 struct bin_attribute *bin_attr,
355 char *buf, loff_t off, size_t count)
88729e53
AV		 356{
357 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
358 struct device, kobj)));
359 uint16_t iter, addr, offset;
360 int rval;
361
362 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != SFP_DEV_SIZE * 2)
363 return 0;
364
365 addr = 0xa0;
366 for (iter = 0, offset = 0; iter < (SFP_DEV_SIZE * 2) / SFP_BLOCK_SIZE;
367 iter++, offset += SFP_BLOCK_SIZE) {
368 if (iter == 4) {
369 /* Skip to next device address. */
370 addr = 0xa2;
371 offset = 0;
372 }
373
374 rval = qla2x00_read_sfp(ha, ha->sfp_data_dma, addr, offset,
375 SFP_BLOCK_SIZE);
376 if (rval != QLA_SUCCESS) {
377 qla_printk(KERN_WARNING, ha,
378 "Unable to read SFP data (%x/%x/%x).\n", rval,
379 addr, offset);
380 count = 0;
381 break;
382 }
383 memcpy(buf, ha->sfp_data, SFP_BLOCK_SIZE);
384 buf += SFP_BLOCK_SIZE;
385 }
386
387 return count;
388}
389
390static struct bin_attribute sysfs_sfp_attr = {
391 .attr = {
392 .name = "sfp",
393 .mode = S_IRUSR | S_IWUSR,
88729e53
AV		 394 },
395 .size = SFP_DEV_SIZE * 2,
396 .read = qla2x00_sysfs_read_sfp,
397};
398
f1663ad5
AV		 399static struct sysfs_entry {
400 char *name;
401 struct bin_attribute *attr;
402 int is4GBp_only;
403} bin_file_entries[] = {
404 { "fw_dump", &sysfs_fw_dump_attr, },
405 { "nvram", &sysfs_nvram_attr, },
406 { "optrom", &sysfs_optrom_attr, },
407 { "optrom_ctl", &sysfs_optrom_ctl_attr, },
408 { "vpd", &sysfs_vpd_attr, 1 },
409 { "sfp", &sysfs_sfp_attr, 1 },
46ddab7b 410 { NULL },
f1663ad5
AV		 411};
412
8482e118
AV		 413void
414qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
415{
416 struct Scsi_Host *host = ha->host;
f1663ad5
AV		 417 struct sysfs_entry *iter;
418 int ret;
8482e118 419
f1663ad5 420 for (iter = bin_file_entries; iter->name; iter++) {
e428924c 421 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha))
f1663ad5
AV		 422 continue;
423
424 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
425 iter->attr);
426 if (ret)
427 qla_printk(KERN_INFO, ha,
428 "Unable to create sysfs %s binary attribute "
429 "(%d).\n", iter->name, ret);
7914d004 430 }
8482e118
AV		 431}
432
433void
434qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
435{
436 struct Scsi_Host *host = ha->host;
f1663ad5
AV		 437 struct sysfs_entry *iter;
438
439 for (iter = bin_file_entries; iter->name; iter++) {
e428924c 440 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha))
f1663ad5 441 continue;
8482e118 442
88729e53 443 sysfs_remove_bin_file(&host->shost_gendev.kobj,
f1663ad5 444 iter->attr);
7914d004 445 }
f6df144c
AV		 446
447 if (ha->beacon_blink_led == 1)
fd34f556 448 ha->isp_ops->beacon_off(ha);
8482e118
AV		 449}
450
afb046e2
AV		 451/* Scsi_Host attributes. */
452
453static ssize_t
454qla2x00_drvr_version_show(struct class_device *cdev, char *buf)
455{
456 return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
457}
458
459static ssize_t
460qla2x00_fw_version_show(struct class_device *cdev, char *buf)
461{
462 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
463 char fw_str[30];
464
465 return snprintf(buf, PAGE_SIZE, "%s\n",
fd34f556 466 ha->isp_ops->fw_version_str(ha, fw_str));
afb046e2
AV		 467}
468
469static ssize_t
470qla2x00_serial_num_show(struct class_device *cdev, char *buf)
471{
472 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
473 uint32_t sn;
474
475 sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
476 return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
477 sn % 100000);
478}
479
480static ssize_t
481qla2x00_isp_name_show(struct class_device *cdev, char *buf)
482{
483 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
5433383e 484 return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device);
afb046e2
AV		 485}
486
487static ssize_t
488qla2x00_isp_id_show(struct class_device *cdev, char *buf)
489{
490 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
491 return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
492 ha->product_id[0], ha->product_id[1], ha->product_id[2],
493 ha->product_id[3]);
494}
495
496static ssize_t
497qla2x00_model_name_show(struct class_device *cdev, char *buf)
498{
499 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
500 return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number);
501}
502
503static ssize_t
504qla2x00_model_desc_show(struct class_device *cdev, char *buf)
505{
506 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
507 return snprintf(buf, PAGE_SIZE, "%s\n",
508 ha->model_desc ? ha->model_desc: "");
509}
510
511static ssize_t
512qla2x00_pci_info_show(struct class_device *cdev, char *buf)
513{
514 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
515 char pci_info[30];
516
517 return snprintf(buf, PAGE_SIZE, "%s\n",
fd34f556 518 ha->isp_ops->pci_info_str(ha, pci_info));
afb046e2
AV		 519}
520
521static ssize_t
522qla2x00_state_show(struct class_device *cdev, char *buf)
523{
524 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
525 int len = 0;
526
527 if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
528 atomic_read(&ha->loop_state) == LOOP_DEAD)
529 len = snprintf(buf, PAGE_SIZE, "Link Down\n");
530 else if (atomic_read(&ha->loop_state) != LOOP_READY ||
531 test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) ||
532 test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags))
533 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n");
534 else {
535 len = snprintf(buf, PAGE_SIZE, "Link Up - ");
536
537 switch (ha->current_topology) {
538 case ISP_CFG_NL:
539 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
540 break;
541 case ISP_CFG_FL:
542 len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
543 break;
544 case ISP_CFG_N:
545 len += snprintf(buf + len, PAGE_SIZE-len,
546 "N_Port to N_Port\n");
547 break;
548 case ISP_CFG_F:
549 len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
550 break;
551 default:
552 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
553 break;
554 }
555 }
556 return len;
557}
558
4fdfefe5
AV		 559static ssize_t
560qla2x00_zio_show(struct class_device *cdev, char *buf)
561{
562 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
563 int len = 0;
564
565 switch (ha->zio_mode) {
4fdfefe5
AV		 566 case QLA_ZIO_MODE_6:
567 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
568 break;
569 case QLA_ZIO_DISABLED:
570 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
571 break;
572 }
573 return len;
574}
575
576static ssize_t
577qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count)
578{
579 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
580 int val = 0;
581 uint16_t zio_mode;
582
4a59f71d
AV		 583 if (!IS_ZIO_SUPPORTED(ha))
584 return -ENOTSUPP;
585
4fdfefe5
AV		 586 if (sscanf(buf, "%d", &val) != 1)
587 return -EINVAL;
588
4a59f71d 589 if (val)
4fdfefe5 590 zio_mode = QLA_ZIO_MODE_6;
4a59f71d 591 else
4fdfefe5 592 zio_mode = QLA_ZIO_DISABLED;
4fdfefe5
AV		 593
594 /* Update per-hba values and queue a reset. */
595 if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
596 ha->zio_mode = zio_mode;
597 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
598 }
599 return strlen(buf);
600}
601
602static ssize_t
603qla2x00_zio_timer_show(struct class_device *cdev, char *buf)
604{
605 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
606
607 return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100);
608}
609
610static ssize_t
611qla2x00_zio_timer_store(struct class_device *cdev, const char *buf,
612 size_t count)
613{
614 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
615 int val = 0;
616 uint16_t zio_timer;
617
618 if (sscanf(buf, "%d", &val) != 1)
619 return -EINVAL;
620 if (val > 25500 || val < 100)
621 return -ERANGE;
622
623 zio_timer = (uint16_t)(val / 100);
624 ha->zio_timer = zio_timer;
625
626 return strlen(buf);
627}
628
f6df144c
AV		 629static ssize_t
630qla2x00_beacon_show(struct class_device *cdev, char *buf)
631{
632 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
633 int len = 0;
634
635 if (ha->beacon_blink_led)
636 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
637 else
638 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
639 return len;
640}
641
642static ssize_t
643qla2x00_beacon_store(struct class_device *cdev, const char *buf,
644 size_t count)
645{
646 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
647 int val = 0;
648 int rval;
649
650 if (IS_QLA2100(ha) || IS_QLA2200(ha))
651 return -EPERM;
652
653 if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) {
654 qla_printk(KERN_WARNING, ha,
655 "Abort ISP active -- ignoring beacon request.\n");
656 return -EBUSY;
657 }
658
659 if (sscanf(buf, "%d", &val) != 1)
660 return -EINVAL;
661
662 if (val)
fd34f556 663 rval = ha->isp_ops->beacon_on(ha);
f6df144c 664 else
fd34f556 665 rval = ha->isp_ops->beacon_off(ha);
f6df144c
AV		 666
667 if (rval != QLA_SUCCESS)
668 count = 0;
669
670 return count;
671}
672
30c47662
AV		 673static ssize_t
674qla2x00_optrom_bios_version_show(struct class_device *cdev, char *buf)
675{
676 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
677
678 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
679 ha->bios_revision[0]);
680}
681
682static ssize_t
683qla2x00_optrom_efi_version_show(struct class_device *cdev, char *buf)
684{
685 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
686
687 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
688 ha->efi_revision[0]);
689}
690
691static ssize_t
692qla2x00_optrom_fcode_version_show(struct class_device *cdev, char *buf)
693{
694 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
695
696 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
697 ha->fcode_revision[0]);
698}
699
700static ssize_t
701qla2x00_optrom_fw_version_show(struct class_device *cdev, char *buf)
702{
703 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev));
704
705 return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
706 ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
707 ha->fw_revision[3]);
708}
709
afb046e2
AV		 710static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show,
711 NULL);
712static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
713static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
714static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
715static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
716static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
717static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
718static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
719static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL);
4fdfefe5
AV		 720static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show,
721 qla2x00_zio_store);
722static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
723 qla2x00_zio_timer_store);
f6df144c
AV		 724static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
725 qla2x00_beacon_store);
30c47662
AV		 726static CLASS_DEVICE_ATTR(optrom_bios_version, S_IRUGO,
727 qla2x00_optrom_bios_version_show, NULL);
728static CLASS_DEVICE_ATTR(optrom_efi_version, S_IRUGO,
729 qla2x00_optrom_efi_version_show, NULL);
730static CLASS_DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
731 qla2x00_optrom_fcode_version_show, NULL);
732static CLASS_DEVICE_ATTR(optrom_fw_version, S_IRUGO,
733 qla2x00_optrom_fw_version_show, NULL);
afb046e2
AV		 734
735struct class_device_attribute *qla2x00_host_attrs[] = {
736 &class_device_attr_driver_version,
737 &class_device_attr_fw_version,
738 &class_device_attr_serial_num,
739 &class_device_attr_isp_name,
740 &class_device_attr_isp_id,
741 &class_device_attr_model_name,
742 &class_device_attr_model_desc,
743 &class_device_attr_pci_info,
744 &class_device_attr_state,
4fdfefe5
AV		 745 &class_device_attr_zio,
746 &class_device_attr_zio_timer,
f6df144c 747 &class_device_attr_beacon,
30c47662
AV		 748 &class_device_attr_optrom_bios_version,
749 &class_device_attr_optrom_efi_version,
750 &class_device_attr_optrom_fcode_version,
751 &class_device_attr_optrom_fw_version,
afb046e2
AV		 752 NULL,
753};
754
8482e118
AV		 755/* Host attributes. */
756
757static void
758qla2x00_get_host_port_id(struct Scsi_Host *shost)
759{
760 scsi_qla_host_t *ha = to_qla_host(shost);
761
762 fc_host_port_id(shost) = ha->d_id.b.domain << 16 |
763 ha->d_id.b.area << 8 | ha->d_id.b.al_pa;
764}
765
04414013
AV		 766static void
767qla2x00_get_host_speed(struct Scsi_Host *shost)
768{
769 scsi_qla_host_t *ha = to_qla_host(shost);
770 uint32_t speed = 0;
771
772 switch (ha->link_data_rate) {
d8b45213 773 case PORT_SPEED_1GB:
04414013
AV		 774 speed = 1;
775 break;
d8b45213 776 case PORT_SPEED_2GB:
04414013
AV		 777 speed = 2;
778 break;
d8b45213 779 case PORT_SPEED_4GB:
04414013
AV		 780 speed = 4;
781 break;
782 }
783 fc_host_speed(shost) = speed;
784}
785
8d067623
AV		 786static void
787qla2x00_get_host_port_type(struct Scsi_Host *shost)
788{
789 scsi_qla_host_t *ha = to_qla_host(shost);
790 uint32_t port_type = FC_PORTTYPE_UNKNOWN;
791
792 switch (ha->current_topology) {
793 case ISP_CFG_NL:
794 port_type = FC_PORTTYPE_LPORT;
795 break;
796 case ISP_CFG_FL:
797 port_type = FC_PORTTYPE_NLPORT;
798 break;
799 case ISP_CFG_N:
800 port_type = FC_PORTTYPE_PTP;
801 break;
802 case ISP_CFG_F:
803 port_type = FC_PORTTYPE_NPORT;
804 break;
805 }
806 fc_host_port_type(shost) = port_type;
807}
808
8482e118
AV		 809static void
810qla2x00_get_starget_node_name(struct scsi_target *starget)
811{
812 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
813 scsi_qla_host_t *ha = to_qla_host(host);
bdf79621 814 fc_port_t *fcport;
f8b02a85 815 u64 node_name = 0;
8482e118 816
bdf79621
AV		 817 list_for_each_entry(fcport, &ha->fcports, list) {
818 if (starget->id == fcport->os_target_id) {
f8b02a85 819 node_name = wwn_to_u64(fcport->node_name);
bdf79621
AV		 820 break;
821 }
822 }
823
f8b02a85 824 fc_starget_node_name(starget) = node_name;
8482e118
AV		 825}
826
827static void
828qla2x00_get_starget_port_name(struct scsi_target *starget)
829{
830 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
831 scsi_qla_host_t *ha = to_qla_host(host);
bdf79621 832 fc_port_t *fcport;
f8b02a85 833 u64 port_name = 0;
8482e118 834
bdf79621
AV		 835 list_for_each_entry(fcport, &ha->fcports, list) {
836 if (starget->id == fcport->os_target_id) {
f8b02a85 837 port_name = wwn_to_u64(fcport->port_name);
bdf79621
AV		 838 break;
839 }
840 }
841
f8b02a85 842 fc_starget_port_name(starget) = port_name;
8482e118
AV		 843}
844
845static void
846qla2x00_get_starget_port_id(struct scsi_target *starget)
847{
848 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
849 scsi_qla_host_t *ha = to_qla_host(host);
bdf79621
AV		 850 fc_port_t *fcport;
851 uint32_t port_id = ~0U;
852
853 list_for_each_entry(fcport, &ha->fcports, list) {
854 if (starget->id == fcport->os_target_id) {
855 port_id = fcport->d_id.b.domain << 16 |
856 fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
857 break;
858 }
859 }
8482e118 860
8482e118
AV		 861 fc_starget_port_id(starget) = port_id;
862}
863
864static void
865qla2x00_get_rport_loss_tmo(struct fc_rport *rport)
866{
bdf79621
AV		 867 struct Scsi_Host *host = rport_to_shost(rport);
868 scsi_qla_host_t *ha = to_qla_host(host);
8482e118
AV		 869
870 rport->dev_loss_tmo = ha->port_down_retry_count + 5;
871}
872
873static void
874qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
875{
bdf79621
AV		 876 struct Scsi_Host *host = rport_to_shost(rport);
877 scsi_qla_host_t *ha = to_qla_host(host);
8482e118
AV		 878
879 if (timeout)
880 ha->port_down_retry_count = timeout;
881 else
882 ha->port_down_retry_count = 1;
883
884 rport->dev_loss_tmo = ha->port_down_retry_count + 5;
885}
886
91ca7b01
AV		 887static int
888qla2x00_issue_lip(struct Scsi_Host *shost)
889{
890 scsi_qla_host_t *ha = to_qla_host(shost);
891
892 set_bit(LOOP_RESET_NEEDED, &ha->dpc_flags);
893 return 0;
894}
895
392e2f65
AV		 896static struct fc_host_statistics *
897qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
898{
899 scsi_qla_host_t *ha = to_qla_host(shost);
900 int rval;
901 uint16_t mb_stat[1];
902 link_stat_t stat_buf;
903 struct fc_host_statistics *pfc_host_stat;
904
178779a6 905 rval = QLA_FUNCTION_FAILED;
392e2f65
AV		 906 pfc_host_stat = &ha->fc_host_stat;
907 memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
908
e428924c 909 if (IS_FWI2_CAPABLE(ha)) {
392e2f65
AV		 910 rval = qla24xx_get_isp_stats(ha, (uint32_t *)&stat_buf,
911 sizeof(stat_buf) / 4, mb_stat);
178779a6
AV		 912 } else if (atomic_read(&ha->loop_state) == LOOP_READY &&
913 !test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) &&
914 !test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) &&
915 !ha->dpc_active) {
916 /* Must be in a 'READY' state for statistics retrieval. */
392e2f65
AV		 917 rval = qla2x00_get_link_status(ha, ha->loop_id, &stat_buf,
918 mb_stat);
919 }
178779a6
AV		 920
921 if (rval != QLA_SUCCESS)
922 goto done;
392e2f65
AV		 923
924 pfc_host_stat->link_failure_count = stat_buf.link_fail_cnt;
925 pfc_host_stat->loss_of_sync_count = stat_buf.loss_sync_cnt;
926 pfc_host_stat->loss_of_signal_count = stat_buf.loss_sig_cnt;
927 pfc_host_stat->prim_seq_protocol_err_count = stat_buf.prim_seq_err_cnt;
928 pfc_host_stat->invalid_tx_word_count = stat_buf.inval_xmit_word_cnt;
929 pfc_host_stat->invalid_crc_count = stat_buf.inval_crc_cnt;
178779a6 930done:
392e2f65
AV		 931 return pfc_host_stat;
932}
933
1620f7c2
AV		 934static void
935qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
936{
937 scsi_qla_host_t *ha = to_qla_host(shost);
938
939 qla2x00_get_sym_node_name(ha, fc_host_symbolic_name(shost));
940}
941
a740a3f0
AV		 942static void
943qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
944{
945 scsi_qla_host_t *ha = to_qla_host(shost);
946
947 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
948}
949
90991c85
AV		 950static void
951qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
952{
953 scsi_qla_host_t *ha = to_qla_host(shost);
954 u64 node_name;
955
956 if (ha->device_flags & SWITCH_FOUND)
957 node_name = wwn_to_u64(ha->fabric_node_name);
958 else
959 node_name = wwn_to_u64(ha->node_name);
960
961 fc_host_fabric_name(shost) = node_name;
962}
963
7047fcdd
AV		 964static void
965qla2x00_get_host_port_state(struct Scsi_Host *shost)
966{
967 scsi_qla_host_t *ha = to_qla_host(shost);
968
969 if (!ha->flags.online)
970 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
971 else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT)
972 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
973 else
974 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
975}
976
2c3dfe3f
SJ		 977static int
978qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
979{
980 int ret = 0;
981 scsi_qla_host_t *ha = (scsi_qla_host_t *) fc_vport->shost->hostdata;
982 scsi_qla_host_t *vha;
983
984 ret = qla24xx_vport_create_req_sanity_check(fc_vport);
985 if (ret) {
986 DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, "
987 "status %x\n", ret));
988 return (ret);
989 }
990
991 vha = qla24xx_create_vhost(fc_vport);
992 if (vha == NULL) {
993 DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n",
994 vha));
995 return FC_VPORT_FAILED;
996 }
997 if (disable) {
998 atomic_set(&vha->vp_state, VP_OFFLINE);
999 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
1000 } else
1001 atomic_set(&vha->vp_state, VP_FAILED);
1002
1003 /* ready to create vport */
1004 qla_printk(KERN_INFO, vha, "VP entry id %d assigned.\n", vha->vp_idx);
1005
1006 /* initialized vport states */
1007 atomic_set(&vha->loop_state, LOOP_DOWN);
1008 vha->vp_err_state= VP_ERR_PORTDWN;
1009 vha->vp_prev_err_state= VP_ERR_UNKWN;
1010 /* Check if physical ha port is Up */
1011 if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
1012 atomic_read(&ha->loop_state) == LOOP_DEAD) {
1013 /* Don't retry or attempt login of this virtual port */
1014 DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n",
1015 vha->host_no));
1016 atomic_set(&vha->loop_state, LOOP_DEAD);
1017 if (!disable)
1018 fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
1019 }
1020
1021 if (scsi_add_host(vha->host, &fc_vport->dev)) {
1022 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
1023 vha->host_no, vha->vp_idx));
1024 goto vport_create_failed_2;
1025 }
1026
1027 /* initialize attributes */
1028 fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1029 fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1030 fc_host_supported_classes(vha->host) =
1031 fc_host_supported_classes(ha->host);
1032 fc_host_supported_speeds(vha->host) =
1033 fc_host_supported_speeds(ha->host);
1034
1035 qla24xx_vport_disable(fc_vport, disable);
1036
1037 return 0;
1038vport_create_failed_2:
1039 qla24xx_disable_vp(vha);
1040 qla24xx_deallocate_vp_id(vha);
1041 kfree(vha->port_name);
1042 kfree(vha->node_name);
1043 scsi_host_put(vha->host);
1044 return FC_VPORT_FAILED;
1045}
1046
1047int
1048qla24xx_vport_delete(struct fc_vport *fc_vport)
1049{
1050 scsi_qla_host_t *ha = (scsi_qla_host_t *) fc_vport->shost->hostdata;
1051 scsi_qla_host_t *vha = fc_vport->dd_data;
1052
1053 qla24xx_disable_vp(vha);
1054 qla24xx_deallocate_vp_id(vha);
1055
1056 down(&ha->vport_sem);
1057 ha->cur_vport_count--;
1058 clear_bit(vha->vp_idx, (unsigned long *)ha->vp_idx_map);
1059 up(&ha->vport_sem);
1060
1061 kfree(vha->node_name);
1062 kfree(vha->port_name);
1063
1064 if (vha->timer_active) {
1065 qla2x00_vp_stop_timer(vha);
1066 DEBUG15(printk ("scsi(%ld): timer for the vport[%d] = %p "
1067 "has stopped\n",
1068 vha->host_no, vha->vp_idx, vha));
1069 }
1070
1071 fc_remove_host(vha->host);
1072
1073 scsi_remove_host(vha->host);
1074
1075 scsi_host_put(vha->host);
1076
1077 return 0;
1078}
1079
1080int
1081qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
1082{
1083 scsi_qla_host_t *vha = fc_vport->dd_data;
1084
1085 if (disable)
1086 qla24xx_disable_vp(vha);
1087 else
1088 qla24xx_enable_vp(vha);
1089
1090 return 0;
1091}
1092
1c97a12a 1093struct fc_function_template qla2xxx_transport_functions = {
8482e118
AV		 1094
1095 .show_host_node_name = 1,
1096 .show_host_port_name = 1,
ad3e0eda
AV		 1097 .show_host_supported_classes = 1,
1098
8482e118
AV		 1099 .get_host_port_id = qla2x00_get_host_port_id,
1100 .show_host_port_id = 1,
04414013
AV		 1101 .get_host_speed = qla2x00_get_host_speed,
1102 .show_host_speed = 1,
8d067623
AV		 1103 .get_host_port_type = qla2x00_get_host_port_type,
1104 .show_host_port_type = 1,
1620f7c2
AV		 1105 .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1106 .show_host_symbolic_name = 1,
a740a3f0
AV		 1107 .set_host_system_hostname = qla2x00_set_host_system_hostname,
1108 .show_host_system_hostname = 1,
90991c85
AV		 1109 .get_host_fabric_name = qla2x00_get_host_fabric_name,
1110 .show_host_fabric_name = 1,
7047fcdd
AV		 1111 .get_host_port_state = qla2x00_get_host_port_state,
1112 .show_host_port_state = 1,
8482e118 1113
bdf79621 1114 .dd_fcrport_size = sizeof(struct fc_port *),
ad3e0eda 1115 .show_rport_supported_classes = 1,
8482e118
AV		 1116
1117 .get_starget_node_name = qla2x00_get_starget_node_name,
1118 .show_starget_node_name = 1,
1119 .get_starget_port_name = qla2x00_get_starget_port_name,
1120 .show_starget_port_name = 1,
1121 .get_starget_port_id = qla2x00_get_starget_port_id,
1122 .show_starget_port_id = 1,
1123
1124 .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo,
1125 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1126 .show_rport_dev_loss_tmo = 1,
1127
91ca7b01 1128 .issue_fc_host_lip = qla2x00_issue_lip,
392e2f65 1129 .get_fc_host_stats = qla2x00_get_fc_host_stats,
2c3dfe3f
SJ		 1130
1131 .vport_create = qla24xx_vport_create,
1132 .vport_disable = qla24xx_vport_disable,
1133 .vport_delete = qla24xx_vport_delete,
1134};
1135
1136struct fc_function_template qla2xxx_transport_vport_functions = {
1137
1138 .show_host_node_name = 1,
1139 .show_host_port_name = 1,
1140 .show_host_supported_classes = 1,
1141
1142 .get_host_port_id = qla2x00_get_host_port_id,
1143 .show_host_port_id = 1,
1144 .get_host_speed = qla2x00_get_host_speed,
1145 .show_host_speed = 1,
1146 .get_host_port_type = qla2x00_get_host_port_type,
1147 .show_host_port_type = 1,
1148 .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1149 .show_host_symbolic_name = 1,
1150 .set_host_system_hostname = qla2x00_set_host_system_hostname,
1151 .show_host_system_hostname = 1,
1152 .get_host_fabric_name = qla2x00_get_host_fabric_name,
1153 .show_host_fabric_name = 1,
1154 .get_host_port_state = qla2x00_get_host_port_state,
1155 .show_host_port_state = 1,
1156
1157 .dd_fcrport_size = sizeof(struct fc_port *),
1158 .show_rport_supported_classes = 1,
1159
1160 .get_starget_node_name = qla2x00_get_starget_node_name,
1161 .show_starget_node_name = 1,
1162 .get_starget_port_name = qla2x00_get_starget_port_name,
1163 .show_starget_port_name = 1,
1164 .get_starget_port_id = qla2x00_get_starget_port_id,
1165 .show_starget_port_id = 1,
1166
1167 .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo,
1168 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1169 .show_rport_dev_loss_tmo = 1,
1170
1171 .issue_fc_host_lip = qla2x00_issue_lip,
1172 .get_fc_host_stats = qla2x00_get_fc_host_stats,
8482e118
AV		 1173};
1174
8482e118
AV		 1175void
1176qla2x00_init_host_attr(scsi_qla_host_t *ha)
1177{
dad9c8c1
AV		 1178 fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name);
1179 fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name);
ad3e0eda 1180 fc_host_supported_classes(ha->host) = FC_COS_CLASS3;
2c3dfe3f
SJ		 1181 fc_host_max_npiv_vports(ha->host) = MAX_NUM_VPORT_FABRIC;
1182 fc_host_npiv_vports_inuse(ha->host) = ha->cur_vport_count;
8482e118 1183}
kernel source for telekom puls (alcatel/mediatek)