Quelle  qedf_attr.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  QLogic FCoE Offload Driver
 *  Copyright (c) 2016-2018 Cavium Inc.
 */
#include "qedf.h"

inline bool qedf_is_vport(struct qedf_ctx *qedf)
{
 return qedf->lport->vport != NULL;
}

/* Get base qedf for physical port from vport */
static struct qedf_ctx *qedf_get_base_qedf(struct qedf_ctx *qedf)
{
 struct fc_lport *lport;
 struct fc_lport *base_lport;

 if (!(qedf_is_vport(qedf)))
  return NULL;

 lport = qedf->lport;
 base_lport = shost_priv(vport_to_shost(lport->vport));
 return lport_priv(base_lport);
}

static ssize_t fcoe_mac_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
 struct fc_lport *lport = shost_priv(class_to_shost(dev));
 u32 port_id;
 u8 lport_src_id[3];
 u8 fcoe_mac[6];

 port_id = fc_host_port_id(lport->host);
 lport_src_id[2] = (port_id & 0x000000FF);
 lport_src_id[1] = (port_id & 0x0000FF00) >> 8;
 lport_src_id[0] = (port_id & 0x00FF0000) >> 16;
 fc_fcoe_set_mac(fcoe_mac, lport_src_id);

 return scnprintf(buf, PAGE_SIZE, "%pM\n", fcoe_mac);
}

static ssize_t fka_period_show(struct device *dev,
          struct device_attribute *attr, char *buf)
{
 struct fc_lport *lport = shost_priv(class_to_shost(dev));
 struct qedf_ctx *qedf = lport_priv(lport);
 int fka_period = -1;

 if (qedf_is_vport(qedf))
  qedf = qedf_get_base_qedf(qedf);

 if (qedf->ctlr.sel_fcf)
  fka_period = qedf->ctlr.sel_fcf->fka_period;

 return scnprintf(buf, PAGE_SIZE, "%d\n", fka_period);
}

static DEVICE_ATTR_RO(fcoe_mac);
static DEVICE_ATTR_RO(fka_period);

static struct attribute *qedf_host_attrs[] = {
 &dev_attr_fcoe_mac.attr,
 &dev_attr_fka_period.attr,
 NULL,
};

static const struct attribute_group qedf_host_attr_group = {
 .attrs = qedf_host_attrs
};

const struct attribute_group *qedf_host_groups[] = {
 &qedf_host_attr_group,
 NULL
};

extern const struct qed_fcoe_ops *qed_ops;

void qedf_capture_grc_dump(struct qedf_ctx *qedf)
{
 struct qedf_ctx *base_qedf;

 /* Make sure we use the base qedf to take the GRC dump */
 if (qedf_is_vport(qedf))
  base_qedf = qedf_get_base_qedf(qedf);
 else
  base_qedf = qedf;

 if (test_bit(QEDF_GRCDUMP_CAPTURE, &base_qedf->flags)) {
  QEDF_INFO(&(base_qedf->dbg_ctx), QEDF_LOG_INFO,
      "GRC Dump already captured.\n");
  return;
 }


 qedf_get_grc_dump(base_qedf->cdev, qed_ops->common,
     &base_qedf->grcdump, &base_qedf->grcdump_size);
 QEDF_ERR(&(base_qedf->dbg_ctx), "GRC Dump captured.\n");
 set_bit(QEDF_GRCDUMP_CAPTURE, &base_qedf->flags);
 qedf_uevent_emit(base_qedf->lport->host, QEDF_UEVENT_CODE_GRCDUMP,
     NULL);
}

static ssize_t
qedf_sysfs_read_grcdump(struct file *filep, struct kobject *kobj,
   const struct bin_attribute *ba, char *buf, loff_t off,
   size_t count)
{
 ssize_t ret = 0;
 struct fc_lport *lport = shost_priv(dev_to_shost(container_of(kobj,
       struct device, kobj)));
 struct qedf_ctx *qedf = lport_priv(lport);

 if (test_bit(QEDF_GRCDUMP_CAPTURE, &qedf->flags)) {
  ret = memory_read_from_buffer(buf, count, &off,
      qedf->grcdump, qedf->grcdump_size);
 } else {
  QEDF_ERR(&(qedf->dbg_ctx), "GRC Dump not captured!\n");
 }

 return ret;
}

static ssize_t
qedf_sysfs_write_grcdump(struct file *filep, struct kobject *kobj,
   const struct bin_attribute *ba, char *buf, loff_t off,
   size_t count)
{
 struct fc_lport *lport = NULL;
 struct qedf_ctx *qedf = NULL;
 long reading;
 int ret = 0;

 if (off != 0)
  return ret;


 lport = shost_priv(dev_to_shost(container_of(kobj,
     struct device, kobj)));
 qedf = lport_priv(lport);

 buf[1] = 0;
 ret = kstrtol(buf, 10, &reading);
 if (ret) {
  QEDF_ERR(&(qedf->dbg_ctx), "Invalid input, err(%d)\n", ret);
  return ret;
 }

 switch (reading) {
 case 0:
  memset(qedf->grcdump, 0, qedf->grcdump_size);
  clear_bit(QEDF_GRCDUMP_CAPTURE, &qedf->flags);
  break;
 case 1:
  qedf_capture_grc_dump(qedf);
  break;
 }

 return count;
}

static const struct bin_attribute sysfs_grcdump_attr = {
 .attr = {
  .name = "grcdump",
  .mode = S_IRUSR | S_IWUSR,
 },
 .size = 0,
 .read = qedf_sysfs_read_grcdump,
 .write = qedf_sysfs_write_grcdump,
};

static struct sysfs_bin_attrs bin_file_entries[] = {
 {"grcdump", &sysfs_grcdump_attr},
 {NULL},
};

void qedf_create_sysfs_ctx_attr(struct qedf_ctx *qedf)
{
 qedf_create_sysfs_attr(qedf->lport->host, bin_file_entries);
}

void qedf_remove_sysfs_ctx_attr(struct qedf_ctx *qedf)
{
 qedf_remove_sysfs_attr(qedf->lport->host, bin_file_entries);
}