drivers/s390/net/ctcm_sysfs.c

   1 /*
   2  * drivers/s390/net/ctcm_sysfs.c
   3  *
   4  * Copyright IBM Corp. 2007, 2007
   5  * Authors:     Peter Tiedemann (ptiedem@de.ibm.com)
   6  *
   7  */
   8
   9 #undef DEBUG
  10 #undef DEBUGDATA
  11 #undef DEBUGCCW
  12
  13 #include <linux/sysfs.h>
  14 #include "ctcm_main.h"
  15
  16 /*
  17  * sysfs attributes
  18  */
  19
  20 static ssize_t ctcm_buffer_show(struct device *dev,
  21                                 struct device_attribute *attr, char *buf)
  22 {
  23         struct ctcm_priv *priv = dev_get_drvdata(dev);
  24
  25         if (!priv)
  26                 return -ENODEV;
  27         return sprintf(buf, "%d\n", priv->buffer_size);
  28 }
  29
  30 static ssize_t ctcm_buffer_write(struct device *dev,
  31                 struct device_attribute *attr, const char *buf, size_t count)
  32 {
  33         struct net_device *ndev;
  34         int bs1;
  35         struct ctcm_priv *priv = dev_get_drvdata(dev);
  36
  37         if (!(priv && priv->channel[READ] &&
  38                         (ndev = priv->channel[READ]->netdev))) {
  39                 CTCM_DBF_TEXT(SETUP, CTC_DBF_ERROR, "bfnondev");
  40                 return -ENODEV;
  41         }
  42
  43         sscanf(buf, "%u", &bs1);
  44         if (bs1 > CTCM_BUFSIZE_LIMIT)
  45                                         goto einval;
  46         if (bs1 < (576 + LL_HEADER_LENGTH + 2))
  47                                         goto einval;
  48         priv->buffer_size = bs1;        /* just to overwrite the default */
  49
  50         if ((ndev->flags & IFF_RUNNING) &&
  51             (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
  52                                         goto einval;
  53
  54         priv->channel[READ]->max_bufsize = bs1;
  55         priv->channel[WRITE]->max_bufsize = bs1;
  56         if (!(ndev->flags & IFF_RUNNING))
  57                 ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
  58         priv->channel[READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
  59         priv->channel[WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
  60
  61         CTCM_DBF_DEV(SETUP, ndev, buf);
  62         return count;
  63
  64 einval:
  65         CTCM_DBF_DEV(SETUP, ndev, "buff_err");
  66         return -EINVAL;
  67 }
  68
  69 static void ctcm_print_statistics(struct ctcm_priv *priv)
  70 {
  71         char *sbuf;
  72         char *p;
  73
  74         if (!priv)
  75                 return;
  76         sbuf = kmalloc(2048, GFP_KERNEL);
  77         if (sbuf == NULL)
  78                 return;
  79         p = sbuf;
  80
  81         p += sprintf(p, "  Device FSM state: %s\n",
  82                      fsm_getstate_str(priv->fsm));
  83         p += sprintf(p, "  RX channel FSM state: %s\n",
  84                      fsm_getstate_str(priv->channel[READ]->fsm));
  85         p += sprintf(p, "  TX channel FSM state: %s\n",
  86                      fsm_getstate_str(priv->channel[WRITE]->fsm));
  87         p += sprintf(p, "  Max. TX buffer used: %ld\n",
  88                      priv->channel[WRITE]->prof.maxmulti);
  89         p += sprintf(p, "  Max. chained SKBs: %ld\n",
  90                      priv->channel[WRITE]->prof.maxcqueue);
  91         p += sprintf(p, "  TX single write ops: %ld\n",
  92                      priv->channel[WRITE]->prof.doios_single);
  93         p += sprintf(p, "  TX multi write ops: %ld\n",
  94                      priv->channel[WRITE]->prof.doios_multi);
  95         p += sprintf(p, "  Netto bytes written: %ld\n",
  96                      priv->channel[WRITE]->prof.txlen);
  97         p += sprintf(p, "  Max. TX IO-time: %ld\n",
  98                      priv->channel[WRITE]->prof.tx_time);
  99
 100         printk(KERN_INFO "Statistics for %s:\n%s",
 101                                 priv->channel[WRITE]->netdev->name, sbuf);
 102         kfree(sbuf);
 103         return;
 104 }
 105
 106 static ssize_t stats_show(struct device *dev,
 107                                 struct device_attribute *attr, char *buf)
 108 {
 109         struct ctcm_priv *priv = dev_get_drvdata(dev);
 110         if (!priv)
 111                 return -ENODEV;
 112         ctcm_print_statistics(priv);
 113         return sprintf(buf, "0\n");
 114 }
 115
 116 static ssize_t stats_write(struct device *dev, struct device_attribute *attr,
 117                                 const char *buf, size_t count)
 118 {
 119         struct ctcm_priv *priv = dev_get_drvdata(dev);
 120         if (!priv)
 121                 return -ENODEV;
 122         /* Reset statistics */
 123         memset(&priv->channel[WRITE]->prof, 0,
 124                                 sizeof(priv->channel[WRITE]->prof));
 125         return count;
 126 }
 127
 128 static ssize_t ctcm_proto_show(struct device *dev,
 129                                 struct device_attribute *attr, char *buf)
 130 {
 131         struct ctcm_priv *priv = dev_get_drvdata(dev);
 132         if (!priv)
 133                 return -ENODEV;
 134
 135         return sprintf(buf, "%d\n", priv->protocol);
 136 }
 137
 138 static ssize_t ctcm_proto_store(struct device *dev,
 139                 struct device_attribute *attr, const char *buf, size_t count)
 140 {
 141         int value;
 142         struct ctcm_priv *priv = dev_get_drvdata(dev);
 143
 144         if (!priv)
 145                 return -ENODEV;
 146         sscanf(buf, "%u", &value);
 147         if (!((value == CTCM_PROTO_S390)  ||
 148               (value == CTCM_PROTO_LINUX) ||
 149               (value == CTCM_PROTO_MPC) ||
 150               (value == CTCM_PROTO_OS390)))
 151                 return -EINVAL;
 152         priv->protocol = value;
 153         CTCM_DBF_DEV(SETUP, dev, buf);
 154
 155         return count;
 156 }
 157
 158 static ssize_t ctcm_type_show(struct device *dev,
 159                                 struct device_attribute *attr, char *buf)
 160 {
 161         struct ccwgroup_device *cgdev;
 162
 163         cgdev = to_ccwgroupdev(dev);
 164         if (!cgdev)
 165                 return -ENODEV;
 166
 167         return sprintf(buf, "%s\n",
 168                         cu3088_type[cgdev->cdev[0]->id.driver_info]);
 169 }
 170
 171 static DEVICE_ATTR(buffer, 0644, ctcm_buffer_show, ctcm_buffer_write);
 172 static DEVICE_ATTR(protocol, 0644, ctcm_proto_show, ctcm_proto_store);
 173 static DEVICE_ATTR(type, 0444, ctcm_type_show, NULL);
 174 static DEVICE_ATTR(stats, 0644, stats_show, stats_write);
 175
 176 static struct attribute *ctcm_attr[] = {
 177         &dev_attr_protocol.attr,
 178         &dev_attr_type.attr,
 179         &dev_attr_buffer.attr,
 180         NULL,
 181 };
 182
 183 static struct attribute_group ctcm_attr_group = {
 184         .attrs = ctcm_attr,
 185 };
 186
 187 int ctcm_add_attributes(struct device *dev)
 188 {
 189         int rc;
 190
 191         rc = device_create_file(dev, &dev_attr_stats);
 192
 193         return rc;
 194 }
 195
 196 void ctcm_remove_attributes(struct device *dev)
 197 {
 198         device_remove_file(dev, &dev_attr_stats);
 199 }
 200
 201 int ctcm_add_files(struct device *dev)
 202 {
 203         return sysfs_create_group(&dev->kobj, &ctcm_attr_group);
 204 }
 205
 206 void ctcm_remove_files(struct device *dev)
 207 {
 208         sysfs_remove_group(&dev->kobj, &ctcm_attr_group);
 209 }
 210