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