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 #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, "%s\n", ha->brd_info->isp_name);
 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 }