kernel/drivers/scsi/qla4xxx/ql4_attr.c

   1 /*
   2  * QLogic iSCSI HBA Driver
   3  * Copyright (c)  2003-2013 QLogic Corporation
   4  *
   5  * See LICENSE.qla4xxx for copyright and licensing details.
   6  */
   7
   8 #include "ql4_def.h"
   9 #include "ql4_glbl.h"
  10 #include "ql4_dbg.h"
  11
  12 static ssize_t
  13 qla4_8xxx_sysfs_read_fw_dump(struct file *filep, struct kobject *kobj,
  14                              struct bin_attribute *ba, char *buf, loff_t off,
  15                              size_t count)
  16 {
  17         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
  18                                                struct device, kobj)));
  19
  20         if (is_qla40XX(ha))
  21                 return -EINVAL;
  22
  23         if (!test_bit(AF_82XX_DUMP_READING, &ha->flags))
  24                 return 0;
  25
  26         return memory_read_from_buffer(buf, count, &off, ha->fw_dump,
  27                                        ha->fw_dump_size);
  28 }
  29
  30 static ssize_t
  31 qla4_8xxx_sysfs_write_fw_dump(struct file *filep, struct kobject *kobj,
  32                               struct bin_attribute *ba, char *buf, loff_t off,
  33                               size_t count)
  34 {
  35         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
  36                                                struct device, kobj)));
  37         uint32_t dev_state;
  38         long reading;
  39         int ret = 0;
  40
  41         if (is_qla40XX(ha))
  42                 return -EINVAL;
  43
  44         if (off != 0)
  45                 return ret;
  46
  47         buf[1] = 0;
  48         ret = kstrtol(buf, 10, &reading);
  49         if (ret) {
  50                 ql4_printk(KERN_ERR, ha, "%s: Invalid input. Return err %d\n",
  51                            __func__, ret);
  52                 return ret;
  53         }
  54
  55         switch (reading) {
  56         case 0:
  57                 /* clear dump collection flags */
  58                 if (test_and_clear_bit(AF_82XX_DUMP_READING, &ha->flags)) {
  59                         clear_bit(AF_82XX_FW_DUMPED, &ha->flags);
  60                         /* Reload minidump template */
  61                         qla4xxx_alloc_fw_dump(ha);
  62                         DEBUG2(ql4_printk(KERN_INFO, ha,
  63                                           "Firmware template reloaded\n"));
  64                 }
  65                 break;
  66         case 1:
  67                 /* Set flag to read dump */
  68                 if (test_bit(AF_82XX_FW_DUMPED, &ha->flags) &&
  69                     !test_bit(AF_82XX_DUMP_READING, &ha->flags)) {
  70                         set_bit(AF_82XX_DUMP_READING, &ha->flags);
  71                         DEBUG2(ql4_printk(KERN_INFO, ha,
  72                                           "Raw firmware dump ready for read on (%ld).\n",
  73                                           ha->host_no));
  74                 }
  75                 break;
  76         case 2:
  77                 /* Reset HBA and collect FW dump */
  78                 ha->isp_ops->idc_lock(ha);
  79                 dev_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE);
  80                 if (dev_state == QLA8XXX_DEV_READY) {
  81                         ql4_printk(KERN_INFO, ha, "%s: Setting Need reset\n",
  82                                    __func__);
  83                         qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
  84                                             QLA8XXX_DEV_NEED_RESET);
  85                         if (is_qla8022(ha) ||
  86                             ((is_qla8032(ha) || is_qla8042(ha)) &&
  87                              qla4_83xx_can_perform_reset(ha))) {
  88                                 set_bit(AF_8XXX_RST_OWNER, &ha->flags);
  89                                 set_bit(AF_FW_RECOVERY, &ha->flags);
  90                                 ql4_printk(KERN_INFO, ha, "%s: Reset owner is 0x%x\n",
  91                                            __func__, ha->func_num);
  92                         }
  93                 } else
  94                         ql4_printk(KERN_INFO, ha,
  95                                    "%s: Reset not performed as device state is 0x%x\n",
  96                                    __func__, dev_state);
  97
  98                 ha->isp_ops->idc_unlock(ha);
  99                 break;
 100         default:
 101                 /* do nothing */
 102                 break;
 103         }
 104
 105         return count;
 106 }
 107
 108 static struct bin_attribute sysfs_fw_dump_attr = {
 109         .attr = {
 110                 .name = "fw_dump",
 111                 .mode = S_IRUSR | S_IWUSR,
 112         },
 113         .size = 0,
 114         .read = qla4_8xxx_sysfs_read_fw_dump,
 115         .write = qla4_8xxx_sysfs_write_fw_dump,
 116 };
 117
 118 static struct sysfs_entry {
 119         char *name;
 120         struct bin_attribute *attr;
 121 } bin_file_entries[] = {
 122         { "fw_dump", &sysfs_fw_dump_attr },
 123         { NULL },
 124 };
 125
 126 void qla4_8xxx_alloc_sysfs_attr(struct scsi_qla_host *ha)
 127 {
 128         struct Scsi_Host *host = ha->host;
 129         struct sysfs_entry *iter;
 130         int ret;
 131
 132         for (iter = bin_file_entries; iter->name; iter++) {
 133                 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
 134                                             iter->attr);
 135                 if (ret)
 136                         ql4_printk(KERN_ERR, ha,
 137                                    "Unable to create sysfs %s binary attribute (%d).\n",
 138                                    iter->name, ret);
 139         }
 140 }
 141
 142 void qla4_8xxx_free_sysfs_attr(struct scsi_qla_host *ha)
 143 {
 144         struct Scsi_Host *host = ha->host;
 145         struct sysfs_entry *iter;
 146
 147         for (iter = bin_file_entries; iter->name; iter++)
 148                 sysfs_remove_bin_file(&host->shost_gendev.kobj,
 149                                       iter->attr);
 150 }
 151
 152 /* Scsi_Host attributes. */
 153 static ssize_t
 154 qla4xxx_fw_version_show(struct device *dev,
 155                         struct device_attribute *attr, char *buf)
 156 {
 157         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 158
 159         if (is_qla80XX(ha))
 160                 return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
 161                                 ha->fw_info.fw_major, ha->fw_info.fw_minor,
 162                                 ha->fw_info.fw_patch, ha->fw_info.fw_build);
 163         else
 164                 return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
 165                                 ha->fw_info.fw_major, ha->fw_info.fw_minor,
 166                                 ha->fw_info.fw_patch, ha->fw_info.fw_build);
 167 }
 168
 169 static ssize_t
 170 qla4xxx_serial_num_show(struct device *dev, struct device_attribute *attr,
 171                         char *buf)
 172 {
 173         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 174         return snprintf(buf, PAGE_SIZE, "%s\n", ha->serial_number);
 175 }
 176
 177 static ssize_t
 178 qla4xxx_iscsi_version_show(struct device *dev, struct device_attribute *attr,
 179                            char *buf)
 180 {
 181         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 182         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fw_info.iscsi_major,
 183                         ha->fw_info.iscsi_minor);
 184 }
 185
 186 static ssize_t
 187 qla4xxx_optrom_version_show(struct device *dev, struct device_attribute *attr,
 188                             char *buf)
 189 {
 190         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 191         return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
 192                         ha->fw_info.bootload_major, ha->fw_info.bootload_minor,
 193                         ha->fw_info.bootload_patch, ha->fw_info.bootload_build);
 194 }
 195
 196 static ssize_t
 197 qla4xxx_board_id_show(struct device *dev, struct device_attribute *attr,
 198                       char *buf)
 199 {
 200         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 201         return snprintf(buf, PAGE_SIZE, "0x%08X\n", ha->board_id);
 202 }
 203
 204 static ssize_t
 205 qla4xxx_fw_state_show(struct device *dev, struct device_attribute *attr,
 206                       char *buf)
 207 {
 208         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 209
 210         qla4xxx_get_firmware_state(ha);
 211         return snprintf(buf, PAGE_SIZE, "0x%08X%8X\n", ha->firmware_state,
 212                         ha->addl_fw_state);
 213 }
 214
 215 static ssize_t
 216 qla4xxx_phy_port_cnt_show(struct device *dev, struct device_attribute *attr,
 217                       char *buf)
 218 {
 219         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 220
 221         if (is_qla40XX(ha))
 222                 return -ENOSYS;
 223
 224         return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->phy_port_cnt);
 225 }
 226
 227 static ssize_t
 228 qla4xxx_phy_port_num_show(struct device *dev, struct device_attribute *attr,
 229                       char *buf)
 230 {
 231         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 232
 233         if (is_qla40XX(ha))
 234                 return -ENOSYS;
 235
 236         return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->phy_port_num);
 237 }
 238
 239 static ssize_t
 240 qla4xxx_iscsi_func_cnt_show(struct device *dev, struct device_attribute *attr,
 241                       char *buf)
 242 {
 243         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 244
 245         if (is_qla40XX(ha))
 246                 return -ENOSYS;
 247
 248         return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->iscsi_pci_func_cnt);
 249 }
 250
 251 static ssize_t
 252 qla4xxx_hba_model_show(struct device *dev, struct device_attribute *attr,
 253                        char *buf)
 254 {
 255         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 256
 257         return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_name);
 258 }
 259
 260 static ssize_t
 261 qla4xxx_fw_timestamp_show(struct device *dev, struct device_attribute *attr,
 262                           char *buf)
 263 {
 264         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 265         return snprintf(buf, PAGE_SIZE, "%s %s\n", ha->fw_info.fw_build_date,
 266                         ha->fw_info.fw_build_time);
 267 }
 268
 269 static ssize_t
 270 qla4xxx_fw_build_user_show(struct device *dev, struct device_attribute *attr,
 271                            char *buf)
 272 {
 273         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 274         return snprintf(buf, PAGE_SIZE, "%s\n", ha->fw_info.fw_build_user);
 275 }
 276
 277 static ssize_t
 278 qla4xxx_fw_ext_timestamp_show(struct device *dev, struct device_attribute *attr,
 279                               char *buf)
 280 {
 281         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 282         return snprintf(buf, PAGE_SIZE, "%s\n", ha->fw_info.extended_timestamp);
 283 }
 284
 285 static ssize_t
 286 qla4xxx_fw_load_src_show(struct device *dev, struct device_attribute *attr,
 287                          char *buf)
 288 {
 289         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 290         char *load_src = NULL;
 291
 292         switch (ha->fw_info.fw_load_source) {
 293         case 1:
 294                 load_src = "Flash Primary";
 295                 break;
 296         case 2:
 297                 load_src = "Flash Secondary";
 298                 break;
 299         case 3:
 300                 load_src = "Host Download";
 301                 break;
 302         }
 303
 304         return snprintf(buf, PAGE_SIZE, "%s\n", load_src);
 305 }
 306
 307 static ssize_t
 308 qla4xxx_fw_uptime_show(struct device *dev, struct device_attribute *attr,
 309                        char *buf)
 310 {
 311         struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
 312         qla4xxx_about_firmware(ha);
 313         return snprintf(buf, PAGE_SIZE, "%u.%u secs\n", ha->fw_uptime_secs,
 314                         ha->fw_uptime_msecs);
 315 }
 316
 317 static DEVICE_ATTR(fw_version, S_IRUGO, qla4xxx_fw_version_show, NULL);
 318 static DEVICE_ATTR(serial_num, S_IRUGO, qla4xxx_serial_num_show, NULL);
 319 static DEVICE_ATTR(iscsi_version, S_IRUGO, qla4xxx_iscsi_version_show, NULL);
 320 static DEVICE_ATTR(optrom_version, S_IRUGO, qla4xxx_optrom_version_show, NULL);
 321 static DEVICE_ATTR(board_id, S_IRUGO, qla4xxx_board_id_show, NULL);
 322 static DEVICE_ATTR(fw_state, S_IRUGO, qla4xxx_fw_state_show, NULL);
 323 static DEVICE_ATTR(phy_port_cnt, S_IRUGO, qla4xxx_phy_port_cnt_show, NULL);
 324 static DEVICE_ATTR(phy_port_num, S_IRUGO, qla4xxx_phy_port_num_show, NULL);
 325 static DEVICE_ATTR(iscsi_func_cnt, S_IRUGO, qla4xxx_iscsi_func_cnt_show, NULL);
 326 static DEVICE_ATTR(hba_model, S_IRUGO, qla4xxx_hba_model_show, NULL);
 327 static DEVICE_ATTR(fw_timestamp, S_IRUGO, qla4xxx_fw_timestamp_show, NULL);
 328 static DEVICE_ATTR(fw_build_user, S_IRUGO, qla4xxx_fw_build_user_show, NULL);
 329 static DEVICE_ATTR(fw_ext_timestamp, S_IRUGO, qla4xxx_fw_ext_timestamp_show,
 330                    NULL);
 331 static DEVICE_ATTR(fw_load_src, S_IRUGO, qla4xxx_fw_load_src_show, NULL);
 332 static DEVICE_ATTR(fw_uptime, S_IRUGO, qla4xxx_fw_uptime_show, NULL);
 333
 334 struct device_attribute *qla4xxx_host_attrs[] = {
 335         &dev_attr_fw_version,
 336         &dev_attr_serial_num,
 337         &dev_attr_iscsi_version,
 338         &dev_attr_optrom_version,
 339         &dev_attr_board_id,
 340         &dev_attr_fw_state,
 341         &dev_attr_phy_port_cnt,
 342         &dev_attr_phy_port_num,
 343         &dev_attr_iscsi_func_cnt,
 344         &dev_attr_hba_model,
 345         &dev_attr_fw_timestamp,
 346         &dev_attr_fw_build_user,
 347         &dev_attr_fw_ext_timestamp,
 348         &dev_attr_fw_load_src,
 349         &dev_attr_fw_uptime,
 350         NULL,
 351 };