git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/qla2xxx/qla_attr.c

   1 /*
   2  *                  QLOGIC LINUX SOFTWARE
   3  *
   4  * QLogic ISP2x00 device driver for Linux 2.6.x
   5  * Copyright (C) 2003-2005 QLogic Corporation
   6  * (www.qlogic.com)
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  */
  19 #include "qla_def.h"
  20
  21 #include <linux/vmalloc.h>
  22 #include <scsi/scsi_transport_fc.h>
  23
  24 /* SYSFS attributes --------------------------------------------------------- */
  25
  26 static ssize_t
  27 qla2x00_sysfs_read_fw_dump(struct kobject *kobj, char *buf, loff_t off,
  28     size_t count)
  29 {
  30         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
  31             struct device, kobj)));
  32
  33         if (ha->fw_dump_reading == 0)
  34                 return 0;
  35         if (off > ha->fw_dump_buffer_len)
  36                 return 0;
  37         if (off + count > ha->fw_dump_buffer_len)
  38                 count = ha->fw_dump_buffer_len - off;
  39
  40         memcpy(buf, &ha->fw_dump_buffer[off], count);
  41
  42         return (count);
  43 }
  44
  45 static ssize_t
  46 qla2x00_sysfs_write_fw_dump(struct kobject *kobj, char *buf, loff_t off,
  47     size_t count)
  48 {
  49         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
  50             struct device, kobj)));
  51         int reading;
  52         uint32_t dump_size;
  53
  54         if (off != 0)
  55                 return (0);
  56
  57         reading = simple_strtol(buf, NULL, 10);
  58         switch (reading) {
  59         case 0:
  60                 if (ha->fw_dump_reading == 1) {
  61                         qla_printk(KERN_INFO, ha,
  62                             "Firmware dump cleared on (%ld).\n",
  63                             ha->host_no);
  64
  65                         vfree(ha->fw_dump_buffer);
  66                         if (!IS_QLA24XX(ha) && !IS_QLA25XX(ha))
  67                                 free_pages((unsigned long)ha->fw_dump,
  68                                     ha->fw_dump_order);
  69
  70                         ha->fw_dump_reading = 0;
  71                         ha->fw_dump_buffer = NULL;
  72                         ha->fw_dump = NULL;
  73                         ha->fw_dumped = 0;
  74                 }
  75                 break;
  76         case 1:
  77                 if ((ha->fw_dump || ha->fw_dumped) && !ha->fw_dump_reading) {
  78                         ha->fw_dump_reading = 1;
  79
  80                         if (IS_QLA24XX(ha) || IS_QLA25XX(ha))
  81                                 dump_size = FW_DUMP_SIZE_24XX;
  82                         else {
  83                                 dump_size = FW_DUMP_SIZE_1M;
  84                                 if (ha->fw_memory_size < 0x20000)
  85                                         dump_size = FW_DUMP_SIZE_128K;
  86                                 else if (ha->fw_memory_size < 0x80000)
  87                                         dump_size = FW_DUMP_SIZE_512K;
  88                         }
  89                         ha->fw_dump_buffer = (char *)vmalloc(dump_size);
  90                         if (ha->fw_dump_buffer == NULL) {
  91                                 qla_printk(KERN_WARNING, ha,
  92                                     "Unable to allocate memory for firmware "
  93                                     "dump buffer (%d).\n", dump_size);
  94
  95                                 ha->fw_dump_reading = 0;
  96                                 return (count);
  97                         }
  98                         qla_printk(KERN_INFO, ha,
  99                             "Firmware dump ready for read on (%ld).\n",
 100                             ha->host_no);
 101                         memset(ha->fw_dump_buffer, 0, dump_size);
 102                         ha->isp_ops.ascii_fw_dump(ha);
 103                         ha->fw_dump_buffer_len = strlen(ha->fw_dump_buffer);
 104                 }
 105                 break;
 106         }
 107         return (count);
 108 }
 109
 110 static struct bin_attribute sysfs_fw_dump_attr = {
 111         .attr = {
 112                 .name = "fw_dump",
 113                 .mode = S_IRUSR | S_IWUSR,
 114                 .owner = THIS_MODULE,
 115         },
 116         .size = 0,
 117         .read = qla2x00_sysfs_read_fw_dump,
 118         .write = qla2x00_sysfs_write_fw_dump,
 119 };
 120
 121 static ssize_t
 122 qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf, loff_t off,
 123     size_t count)
 124 {
 125         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
 126             struct device, kobj)));
 127         unsigned long   flags;
 128
 129         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
 130                 return 0;
 131
 132         /* Read NVRAM. */
 133         spin_lock_irqsave(&ha->hardware_lock, flags);
 134         ha->isp_ops.read_nvram(ha, (uint8_t *)buf, ha->nvram_base,
 135             ha->nvram_size);
 136         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 137
 138         return (count);
 139 }
 140
 141 static ssize_t
 142 qla2x00_sysfs_write_nvram(struct kobject *kobj, char *buf, loff_t off,
 143     size_t count)
 144 {
 145         struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
 146             struct device, kobj)));
 147         unsigned long   flags;
 148         uint16_t        cnt;
 149
 150         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
 151                 return 0;
 152
 153         /* Checksum NVRAM. */
 154         if (IS_QLA24XX(ha) || IS_QLA25XX(ha)) {
 155                 uint32_t *iter;
 156                 uint32_t chksum;
 157
 158                 iter = (uint32_t *)buf;
 159                 chksum = 0;
 160                 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++)
 161                         chksum += le32_to_cpu(*iter++);
 162                 chksum = ~chksum + 1;
 163                 *iter = cpu_to_le32(chksum);
 164         } else {
 165                 uint8_t *iter;
 166                 uint8_t chksum;
 167
 168                 iter = (uint8_t *)buf;
 169                 chksum = 0;
 170                 for (cnt = 0; cnt < count - 1; cnt++)
 171                         chksum += *iter++;
 172                 chksum = ~chksum + 1;
 173                 *iter = chksum;
 174         }
 175
 176         /* Write NVRAM. */
 177         spin_lock_irqsave(&ha->hardware_lock, flags);
 178         ha->isp_ops.write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count);
 179         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 180
 181         return (count);
 182 }
 183
 184 static struct bin_attribute sysfs_nvram_attr = {
 185         .attr = {
 186                 .name = "nvram",
 187                 .mode = S_IRUSR | S_IWUSR,
 188                 .owner = THIS_MODULE,
 189         },
 190         .size = 0,
 191         .read = qla2x00_sysfs_read_nvram,
 192         .write = qla2x00_sysfs_write_nvram,
 193 };
 194
 195 void
 196 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
 197 {
 198         struct Scsi_Host *host = ha->host;
 199
 200         sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
 201         sysfs_nvram_attr.size = ha->nvram_size;
 202         sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
 203 }
 204
 205 void
 206 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
 207 {
 208         struct Scsi_Host *host = ha->host;
 209
 210         sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
 211         sysfs_remove_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
 212 }
 213
 214 /* Host attributes. */
 215
 216 static void
 217 qla2x00_get_host_port_id(struct Scsi_Host *shost)
 218 {
 219         scsi_qla_host_t *ha = to_qla_host(shost);
 220
 221         fc_host_port_id(shost) = ha->d_id.b.domain << 16 |
 222             ha->d_id.b.area << 8 | ha->d_id.b.al_pa;
 223 }
 224
 225 static void
 226 qla2x00_get_starget_node_name(struct scsi_target *starget)
 227 {
 228         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
 229         scsi_qla_host_t *ha = to_qla_host(host);
 230         fc_port_t *fcport;
 231         uint64_t node_name = 0;
 232
 233         list_for_each_entry(fcport, &ha->fcports, list) {
 234                 if (starget->id == fcport->os_target_id) {
 235                         node_name = *(uint64_t *)fcport->node_name;
 236                         break;
 237                 }
 238         }
 239
 240         fc_starget_node_name(starget) = be64_to_cpu(node_name);
 241 }
 242
 243 static void
 244 qla2x00_get_starget_port_name(struct scsi_target *starget)
 245 {
 246         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
 247         scsi_qla_host_t *ha = to_qla_host(host);
 248         fc_port_t *fcport;
 249         uint64_t port_name = 0;
 250
 251         list_for_each_entry(fcport, &ha->fcports, list) {
 252                 if (starget->id == fcport->os_target_id) {
 253                         port_name = *(uint64_t *)fcport->port_name;
 254                         break;
 255                 }
 256         }
 257
 258         fc_starget_port_name(starget) = be64_to_cpu(port_name);
 259 }
 260
 261 static void
 262 qla2x00_get_starget_port_id(struct scsi_target *starget)
 263 {
 264         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
 265         scsi_qla_host_t *ha = to_qla_host(host);
 266         fc_port_t *fcport;
 267         uint32_t port_id = ~0U;
 268
 269         list_for_each_entry(fcport, &ha->fcports, list) {
 270                 if (starget->id == fcport->os_target_id) {
 271                         port_id = fcport->d_id.b.domain << 16 |
 272                             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
 273                         break;
 274                 }
 275         }
 276
 277         fc_starget_port_id(starget) = port_id;
 278 }
 279
 280 static void
 281 qla2x00_get_rport_loss_tmo(struct fc_rport *rport)
 282 {
 283         struct Scsi_Host *host = rport_to_shost(rport);
 284         scsi_qla_host_t *ha = to_qla_host(host);
 285
 286         rport->dev_loss_tmo = ha->port_down_retry_count + 5;
 287 }
 288
 289 static void
 290 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
 291 {
 292         struct Scsi_Host *host = rport_to_shost(rport);
 293         scsi_qla_host_t *ha = to_qla_host(host);
 294
 295         if (timeout)
 296                 ha->port_down_retry_count = timeout;
 297         else
 298                 ha->port_down_retry_count = 1;
 299
 300         rport->dev_loss_tmo = ha->port_down_retry_count + 5;
 301 }
 302
 303 struct fc_function_template qla2xxx_transport_functions = {
 304
 305         .show_host_node_name = 1,
 306         .show_host_port_name = 1,
 307         .get_host_port_id = qla2x00_get_host_port_id,
 308         .show_host_port_id = 1,
 309
 310         .dd_fcrport_size = sizeof(struct fc_port *),
 311
 312         .get_starget_node_name = qla2x00_get_starget_node_name,
 313         .show_starget_node_name = 1,
 314         .get_starget_port_name = qla2x00_get_starget_port_name,
 315         .show_starget_port_name = 1,
 316         .get_starget_port_id  = qla2x00_get_starget_port_id,
 317         .show_starget_port_id = 1,
 318
 319         .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo,
 320         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
 321         .show_rport_dev_loss_tmo = 1,
 322
 323 };
 324
 325 void
 326 qla2x00_init_host_attr(scsi_qla_host_t *ha)
 327 {
 328         fc_host_node_name(ha->host) =
 329             be64_to_cpu(*(uint64_t *)ha->init_cb->node_name);
 330         fc_host_port_name(ha->host) =
 331             be64_to_cpu(*(uint64_t *)ha->init_cb->port_name);
 332 }