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 #include <scsi/scsi_transport_fc.h> 11 12 /* SYSFS attributes --------------------------------------------------------- */ 13 14 static ssize_t 15 qla2x00_sysfs_read_fw_dump(struct kobject *kobj, char *buf, loff_t off, 16 size_t count) 17 { 18 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 19 struct device, kobj))); 20 21 if (ha->fw_dump_reading == 0) 22 return 0; 23 if (off > ha->fw_dump_buffer_len) 24 return 0; 25 if (off + count > ha->fw_dump_buffer_len) 26 count = ha->fw_dump_buffer_len - off; 27 28 memcpy(buf, &ha->fw_dump_buffer[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 uint32_t dump_size; 41 42 if (off != 0) 43 return (0); 44 45 reading = simple_strtol(buf, NULL, 10); 46 switch (reading) { 47 case 0: 48 if (ha->fw_dump_reading == 1) { 49 qla_printk(KERN_INFO, ha, 50 "Firmware dump cleared on (%ld).\n", 51 ha->host_no); 52 53 vfree(ha->fw_dump_buffer); 54 if (!IS_QLA24XX(ha) && !IS_QLA25XX(ha)) 55 free_pages((unsigned long)ha->fw_dump, 56 ha->fw_dump_order); 57 58 ha->fw_dump_reading = 0; 59 ha->fw_dump_buffer = NULL; 60 ha->fw_dump = NULL; 61 ha->fw_dumped = 0; 62 } 63 break; 64 case 1: 65 if ((ha->fw_dump || ha->fw_dumped) && !ha->fw_dump_reading) { 66 ha->fw_dump_reading = 1; 67 68 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) 69 dump_size = FW_DUMP_SIZE_24XX; 70 else { 71 dump_size = FW_DUMP_SIZE_1M; 72 if (ha->fw_memory_size < 0x20000) 73 dump_size = FW_DUMP_SIZE_128K; 74 else if (ha->fw_memory_size < 0x80000) 75 dump_size = FW_DUMP_SIZE_512K; 76 } 77 ha->fw_dump_buffer = (char *)vmalloc(dump_size); 78 if (ha->fw_dump_buffer == NULL) { 79 qla_printk(KERN_WARNING, ha, 80 "Unable to allocate memory for firmware " 81 "dump buffer (%d).\n", dump_size); 82 83 ha->fw_dump_reading = 0; 84 return (count); 85 } 86 qla_printk(KERN_INFO, ha, 87 "Firmware dump ready for read on (%ld).\n", 88 ha->host_no); 89 memset(ha->fw_dump_buffer, 0, dump_size); 90 ha->isp_ops.ascii_fw_dump(ha); 91 ha->fw_dump_buffer_len = strlen(ha->fw_dump_buffer); 92 } 93 break; 94 } 95 return (count); 96 } 97 98 static struct bin_attribute sysfs_fw_dump_attr = { 99 .attr = { 100 .name = "fw_dump", 101 .mode = S_IRUSR | S_IWUSR, 102 .owner = THIS_MODULE, 103 }, 104 .size = 0, 105 .read = qla2x00_sysfs_read_fw_dump, 106 .write = qla2x00_sysfs_write_fw_dump, 107 }; 108 109 static ssize_t 110 qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf, loff_t off, 111 size_t count) 112 { 113 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 114 struct device, kobj))); 115 unsigned long flags; 116 117 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size) 118 return 0; 119 120 /* Read NVRAM. */ 121 spin_lock_irqsave(&ha->hardware_lock, flags); 122 ha->isp_ops.read_nvram(ha, (uint8_t *)buf, ha->nvram_base, 123 ha->nvram_size); 124 spin_unlock_irqrestore(&ha->hardware_lock, flags); 125 126 return (count); 127 } 128 129 static ssize_t 130 qla2x00_sysfs_write_nvram(struct kobject *kobj, char *buf, loff_t off, 131 size_t count) 132 { 133 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 134 struct device, kobj))); 135 unsigned long flags; 136 uint16_t cnt; 137 138 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size) 139 return 0; 140 141 /* Checksum NVRAM. */ 142 if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) { 143 uint32_t *iter; 144 uint32_t chksum; 145 146 iter = (uint32_t *)buf; 147 chksum = 0; 148 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++) 149 chksum += le32_to_cpu(*iter++); 150 chksum = ~chksum + 1; 151 *iter = cpu_to_le32(chksum); 152 } else { 153 uint8_t *iter; 154 uint8_t chksum; 155 156 iter = (uint8_t *)buf; 157 chksum = 0; 158 for (cnt = 0; cnt < count - 1; cnt++) 159 chksum += *iter++; 160 chksum = ~chksum + 1; 161 *iter = chksum; 162 } 163 164 /* Write NVRAM. */ 165 spin_lock_irqsave(&ha->hardware_lock, flags); 166 ha->isp_ops.write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count); 167 spin_unlock_irqrestore(&ha->hardware_lock, flags); 168 169 return (count); 170 } 171 172 static struct bin_attribute sysfs_nvram_attr = { 173 .attr = { 174 .name = "nvram", 175 .mode = S_IRUSR | S_IWUSR, 176 .owner = THIS_MODULE, 177 }, 178 .size = 0, 179 .read = qla2x00_sysfs_read_nvram, 180 .write = qla2x00_sysfs_write_nvram, 181 }; 182 183 void 184 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha) 185 { 186 struct Scsi_Host *host = ha->host; 187 188 sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr); 189 sysfs_nvram_attr.size = ha->nvram_size; 190 sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr); 191 } 192 193 void 194 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha) 195 { 196 struct Scsi_Host *host = ha->host; 197 198 sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr); 199 sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr); 200 } 201 202 /* Scsi_Host attributes. */ 203 204 static ssize_t 205 qla2x00_drvr_version_show(struct class_device *cdev, char *buf) 206 { 207 return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str); 208 } 209 210 static ssize_t 211 qla2x00_fw_version_show(struct class_device *cdev, char *buf) 212 { 213 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 214 char fw_str[30]; 215 216 return snprintf(buf, PAGE_SIZE, "%s\n", 217 ha->isp_ops.fw_version_str(ha, fw_str)); 218 } 219 220 static ssize_t 221 qla2x00_serial_num_show(struct class_device *cdev, char *buf) 222 { 223 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 224 uint32_t sn; 225 226 sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1; 227 return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000, 228 sn % 100000); 229 } 230 231 static ssize_t 232 qla2x00_isp_name_show(struct class_device *cdev, char *buf) 233 { 234 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 235 return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device); 236 } 237 238 static ssize_t 239 qla2x00_isp_id_show(struct class_device *cdev, char *buf) 240 { 241 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 242 return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n", 243 ha->product_id[0], ha->product_id[1], ha->product_id[2], 244 ha->product_id[3]); 245 } 246 247 static ssize_t 248 qla2x00_model_name_show(struct class_device *cdev, char *buf) 249 { 250 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 251 return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number); 252 } 253 254 static ssize_t 255 qla2x00_model_desc_show(struct class_device *cdev, char *buf) 256 { 257 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 258 return snprintf(buf, PAGE_SIZE, "%s\n", 259 ha->model_desc ? ha->model_desc: ""); 260 } 261 262 static ssize_t 263 qla2x00_pci_info_show(struct class_device *cdev, char *buf) 264 { 265 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 266 char pci_info[30]; 267 268 return snprintf(buf, PAGE_SIZE, "%s\n", 269 ha->isp_ops.pci_info_str(ha, pci_info)); 270 } 271 272 static ssize_t 273 qla2x00_state_show(struct class_device *cdev, char *buf) 274 { 275 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 276 int len = 0; 277 278 if (atomic_read(&ha->loop_state) == LOOP_DOWN || 279 atomic_read(&ha->loop_state) == LOOP_DEAD) 280 len = snprintf(buf, PAGE_SIZE, "Link Down\n"); 281 else if (atomic_read(&ha->loop_state) != LOOP_READY || 282 test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) || 283 test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) 284 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n"); 285 else { 286 len = snprintf(buf, PAGE_SIZE, "Link Up - "); 287 288 switch (ha->current_topology) { 289 case ISP_CFG_NL: 290 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 291 break; 292 case ISP_CFG_FL: 293 len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n"); 294 break; 295 case ISP_CFG_N: 296 len += snprintf(buf + len, PAGE_SIZE-len, 297 "N_Port to N_Port\n"); 298 break; 299 case ISP_CFG_F: 300 len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n"); 301 break; 302 default: 303 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 304 break; 305 } 306 } 307 return len; 308 } 309 310 static ssize_t 311 qla2x00_zio_show(struct class_device *cdev, char *buf) 312 { 313 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 314 int len = 0; 315 316 switch (ha->zio_mode) { 317 case QLA_ZIO_MODE_5: 318 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 5\n"); 319 break; 320 case QLA_ZIO_MODE_6: 321 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n"); 322 break; 323 case QLA_ZIO_DISABLED: 324 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n"); 325 break; 326 } 327 return len; 328 } 329 330 static ssize_t 331 qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count) 332 { 333 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 334 int val = 0; 335 uint16_t zio_mode; 336 337 if (sscanf(buf, "%d", &val) != 1) 338 return -EINVAL; 339 340 switch (val) { 341 case 1: 342 zio_mode = QLA_ZIO_MODE_5; 343 break; 344 case 2: 345 zio_mode = QLA_ZIO_MODE_6; 346 break; 347 default: 348 zio_mode = QLA_ZIO_DISABLED; 349 break; 350 } 351 352 /* Update per-hba values and queue a reset. */ 353 if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) { 354 ha->zio_mode = zio_mode; 355 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 356 } 357 return strlen(buf); 358 } 359 360 static ssize_t 361 qla2x00_zio_timer_show(struct class_device *cdev, char *buf) 362 { 363 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 364 365 return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100); 366 } 367 368 static ssize_t 369 qla2x00_zio_timer_store(struct class_device *cdev, const char *buf, 370 size_t count) 371 { 372 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 373 int val = 0; 374 uint16_t zio_timer; 375 376 if (sscanf(buf, "%d", &val) != 1) 377 return -EINVAL; 378 if (val > 25500 || val < 100) 379 return -ERANGE; 380 381 zio_timer = (uint16_t)(val / 100); 382 ha->zio_timer = zio_timer; 383 384 return strlen(buf); 385 } 386 387 static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, 388 NULL); 389 static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL); 390 static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL); 391 static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL); 392 static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL); 393 static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL); 394 static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL); 395 static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL); 396 static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL); 397 static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, 398 qla2x00_zio_store); 399 static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show, 400 qla2x00_zio_timer_store); 401 402 struct class_device_attribute *qla2x00_host_attrs[] = { 403 &class_device_attr_driver_version, 404 &class_device_attr_fw_version, 405 &class_device_attr_serial_num, 406 &class_device_attr_isp_name, 407 &class_device_attr_isp_id, 408 &class_device_attr_model_name, 409 &class_device_attr_model_desc, 410 &class_device_attr_pci_info, 411 &class_device_attr_state, 412 &class_device_attr_zio, 413 &class_device_attr_zio_timer, 414 NULL, 415 }; 416 417 /* Host attributes. */ 418 419 static void 420 qla2x00_get_host_port_id(struct Scsi_Host *shost) 421 { 422 scsi_qla_host_t *ha = to_qla_host(shost); 423 424 fc_host_port_id(shost) = ha->d_id.b.domain << 16 | 425 ha->d_id.b.area << 8 | ha->d_id.b.al_pa; 426 } 427 428 static void 429 qla2x00_get_starget_node_name(struct scsi_target *starget) 430 { 431 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 432 scsi_qla_host_t *ha = to_qla_host(host); 433 fc_port_t *fcport; 434 u64 node_name = 0; 435 436 list_for_each_entry(fcport, &ha->fcports, list) { 437 if (starget->id == fcport->os_target_id) { 438 node_name = wwn_to_u64(fcport->node_name); 439 break; 440 } 441 } 442 443 fc_starget_node_name(starget) = node_name; 444 } 445 446 static void 447 qla2x00_get_starget_port_name(struct scsi_target *starget) 448 { 449 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 450 scsi_qla_host_t *ha = to_qla_host(host); 451 fc_port_t *fcport; 452 u64 port_name = 0; 453 454 list_for_each_entry(fcport, &ha->fcports, list) { 455 if (starget->id == fcport->os_target_id) { 456 port_name = wwn_to_u64(fcport->port_name); 457 break; 458 } 459 } 460 461 fc_starget_port_name(starget) = port_name; 462 } 463 464 static void 465 qla2x00_get_starget_port_id(struct scsi_target *starget) 466 { 467 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 468 scsi_qla_host_t *ha = to_qla_host(host); 469 fc_port_t *fcport; 470 uint32_t port_id = ~0U; 471 472 list_for_each_entry(fcport, &ha->fcports, list) { 473 if (starget->id == fcport->os_target_id) { 474 port_id = fcport->d_id.b.domain << 16 | 475 fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa; 476 break; 477 } 478 } 479 480 fc_starget_port_id(starget) = port_id; 481 } 482 483 static void 484 qla2x00_get_rport_loss_tmo(struct fc_rport *rport) 485 { 486 struct Scsi_Host *host = rport_to_shost(rport); 487 scsi_qla_host_t *ha = to_qla_host(host); 488 489 rport->dev_loss_tmo = ha->port_down_retry_count + 5; 490 } 491 492 static void 493 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 494 { 495 struct Scsi_Host *host = rport_to_shost(rport); 496 scsi_qla_host_t *ha = to_qla_host(host); 497 498 if (timeout) 499 ha->port_down_retry_count = timeout; 500 else 501 ha->port_down_retry_count = 1; 502 503 rport->dev_loss_tmo = ha->port_down_retry_count + 5; 504 } 505 506 static int 507 qla2x00_issue_lip(struct Scsi_Host *shost) 508 { 509 scsi_qla_host_t *ha = to_qla_host(shost); 510 511 set_bit(LOOP_RESET_NEEDED, &ha->dpc_flags); 512 return 0; 513 } 514 515 struct fc_function_template qla2xxx_transport_functions = { 516 517 .show_host_node_name = 1, 518 .show_host_port_name = 1, 519 .show_host_supported_classes = 1, 520 521 .get_host_port_id = qla2x00_get_host_port_id, 522 .show_host_port_id = 1, 523 524 .dd_fcrport_size = sizeof(struct fc_port *), 525 .show_rport_supported_classes = 1, 526 527 .get_starget_node_name = qla2x00_get_starget_node_name, 528 .show_starget_node_name = 1, 529 .get_starget_port_name = qla2x00_get_starget_port_name, 530 .show_starget_port_name = 1, 531 .get_starget_port_id = qla2x00_get_starget_port_id, 532 .show_starget_port_id = 1, 533 534 .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo, 535 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo, 536 .show_rport_dev_loss_tmo = 1, 537 538 .issue_fc_host_lip = qla2x00_issue_lip, 539 }; 540 541 void 542 qla2x00_init_host_attr(scsi_qla_host_t *ha) 543 { 544 fc_host_node_name(ha->host) = wwn_to_u64(ha->init_cb->node_name); 545 fc_host_port_name(ha->host) = wwn_to_u64(ha->init_cb->port_name); 546 fc_host_supported_classes(ha->host) = FC_COS_CLASS3; 547 } 548