drivers/net/gianfar_sysfs.c

   1 /*
   2  * drivers/net/gianfar_sysfs.c
   3  *
   4  * Gianfar Ethernet Driver
   5  * This driver is designed for the non-CPM ethernet controllers
   6  * on the 85xx and 83xx family of integrated processors
   7  * Based on 8260_io/fcc_enet.c
   8  *
   9  * Author: Andy Fleming
  10  * Maintainer: Kumar Gala (galak@kernel.crashing.org)
  11  * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
  12  *
  13  * Copyright 2002-2009 Freescale Semiconductor, Inc.
  14  *
  15  * This program is free software; you can redistribute  it and/or modify it
  16  * under  the terms of  the GNU General  Public License as published by the
  17  * Free Software Foundation;  either version 2 of the  License, or (at your
  18  * option) any later version.
  19  *
  20  * Sysfs file creation and management
  21  */
  22
  23 #include <linux/kernel.h>
  24 #include <linux/string.h>
  25 #include <linux/errno.h>
  26 #include <linux/unistd.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/spinlock.h>
  31 #include <linux/mm.h>
  32 #include <linux/device.h>
  33
  34 #include <asm/uaccess.h>
  35 #include <linux/module.h>
  36
  37 #include "gianfar.h"
  38
  39 static ssize_t gfar_show_bd_stash(struct device *dev,
  40                                   struct device_attribute *attr, char *buf)
  41 {
  42         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
  43
  44         return sprintf(buf, "%s\n", priv->bd_stash_en ? "on" : "off");
  45 }
  46
  47 static ssize_t gfar_set_bd_stash(struct device *dev,
  48                                  struct device_attribute *attr,
  49                                  const char *buf, size_t count)
  50 {
  51         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
  52         struct gfar __iomem *regs = priv->gfargrp[0].regs;
  53         int new_setting = 0;
  54         u32 temp;
  55         unsigned long flags;
  56
  57         if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BD_STASHING))
  58                 return count;
  59
  60
  61         /* Find out the new setting */
  62         if (!strncmp("on", buf, count - 1) || !strncmp("1", buf, count - 1))
  63                 new_setting = 1;
  64         else if (!strncmp("off", buf, count - 1) ||
  65                  !strncmp("0", buf, count - 1))
  66                 new_setting = 0;
  67         else
  68                 return count;
  69
  70
  71         local_irq_save(flags);
  72         lock_rx_qs(priv);
  73
  74         /* Set the new stashing value */
  75         priv->bd_stash_en = new_setting;
  76
  77         temp = gfar_read(&regs->attr);
  78
  79         if (new_setting)
  80                 temp |= ATTR_BDSTASH;
  81         else
  82                 temp &= ~(ATTR_BDSTASH);
  83
  84         gfar_write(&regs->attr, temp);
  85
  86         unlock_rx_qs(priv);
  87         local_irq_restore(flags);
  88
  89         return count;
  90 }
  91
  92 static DEVICE_ATTR(bd_stash, 0644, gfar_show_bd_stash, gfar_set_bd_stash);
  93
  94 static ssize_t gfar_show_rx_stash_size(struct device *dev,
  95                                        struct device_attribute *attr, char *buf)
  96 {
  97         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
  98
  99         return sprintf(buf, "%d\n", priv->rx_stash_size);
 100 }
 101
 102 static ssize_t gfar_set_rx_stash_size(struct device *dev,
 103                                       struct device_attribute *attr,
 104                                       const char *buf, size_t count)
 105 {
 106         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 107         struct gfar __iomem *regs = priv->gfargrp[0].regs;
 108         unsigned int length = simple_strtoul(buf, NULL, 0);
 109         u32 temp;
 110         unsigned long flags;
 111
 112         if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
 113                 return count;
 114
 115         local_irq_save(flags);
 116         lock_rx_qs(priv);
 117
 118         if (length > priv->rx_buffer_size)
 119                 goto out;
 120
 121         if (length == priv->rx_stash_size)
 122                 goto out;
 123
 124         priv->rx_stash_size = length;
 125
 126         temp = gfar_read(&regs->attreli);
 127         temp &= ~ATTRELI_EL_MASK;
 128         temp |= ATTRELI_EL(length);
 129         gfar_write(&regs->attreli, temp);
 130
 131         /* Turn stashing on/off as appropriate */
 132         temp = gfar_read(&regs->attr);
 133
 134         if (length)
 135                 temp |= ATTR_BUFSTASH;
 136         else
 137                 temp &= ~(ATTR_BUFSTASH);
 138
 139         gfar_write(&regs->attr, temp);
 140
 141 out:
 142         unlock_rx_qs(priv);
 143         local_irq_restore(flags);
 144
 145         return count;
 146 }
 147
 148 static DEVICE_ATTR(rx_stash_size, 0644, gfar_show_rx_stash_size,
 149                    gfar_set_rx_stash_size);
 150
 151 /* Stashing will only be enabled when rx_stash_size != 0 */
 152 static ssize_t gfar_show_rx_stash_index(struct device *dev,
 153                                         struct device_attribute *attr,
 154                                         char *buf)
 155 {
 156         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 157
 158         return sprintf(buf, "%d\n", priv->rx_stash_index);
 159 }
 160
 161 static ssize_t gfar_set_rx_stash_index(struct device *dev,
 162                                        struct device_attribute *attr,
 163                                        const char *buf, size_t count)
 164 {
 165         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 166         struct gfar __iomem *regs = priv->gfargrp[0].regs;
 167         unsigned short index = simple_strtoul(buf, NULL, 0);
 168         u32 temp;
 169         unsigned long flags;
 170
 171         if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
 172                 return count;
 173
 174         local_irq_save(flags);
 175         lock_rx_qs(priv);
 176
 177         if (index > priv->rx_stash_size)
 178                 goto out;
 179
 180         if (index == priv->rx_stash_index)
 181                 goto out;
 182
 183         priv->rx_stash_index = index;
 184
 185         temp = gfar_read(&regs->attreli);
 186         temp &= ~ATTRELI_EI_MASK;
 187         temp |= ATTRELI_EI(index);
 188         gfar_write(&regs->attreli, temp);
 189
 190 out:
 191         unlock_rx_qs(priv);
 192         local_irq_restore(flags);
 193
 194         return count;
 195 }
 196
 197 static DEVICE_ATTR(rx_stash_index, 0644, gfar_show_rx_stash_index,
 198                    gfar_set_rx_stash_index);
 199
 200 static ssize_t gfar_show_fifo_threshold(struct device *dev,
 201                                         struct device_attribute *attr,
 202                                         char *buf)
 203 {
 204         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 205
 206         return sprintf(buf, "%d\n", priv->fifo_threshold);
 207 }
 208
 209 static ssize_t gfar_set_fifo_threshold(struct device *dev,
 210                                        struct device_attribute *attr,
 211                                        const char *buf, size_t count)
 212 {
 213         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 214         struct gfar __iomem *regs = priv->gfargrp[0].regs;
 215         unsigned int length = simple_strtoul(buf, NULL, 0);
 216         u32 temp;
 217         unsigned long flags;
 218
 219         if (length > GFAR_MAX_FIFO_THRESHOLD)
 220                 return count;
 221
 222         local_irq_save(flags);
 223         lock_tx_qs(priv);
 224
 225         priv->fifo_threshold = length;
 226
 227         temp = gfar_read(&regs->fifo_tx_thr);
 228         temp &= ~FIFO_TX_THR_MASK;
 229         temp |= length;
 230         gfar_write(&regs->fifo_tx_thr, temp);
 231
 232         unlock_tx_qs(priv);
 233         local_irq_restore(flags);
 234
 235         return count;
 236 }
 237
 238 static DEVICE_ATTR(fifo_threshold, 0644, gfar_show_fifo_threshold,
 239                    gfar_set_fifo_threshold);
 240
 241 static ssize_t gfar_show_fifo_starve(struct device *dev,
 242                                      struct device_attribute *attr, char *buf)
 243 {
 244         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 245
 246         return sprintf(buf, "%d\n", priv->fifo_starve);
 247 }
 248
 249 static ssize_t gfar_set_fifo_starve(struct device *dev,
 250                                     struct device_attribute *attr,
 251                                     const char *buf, size_t count)
 252 {
 253         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 254         struct gfar __iomem *regs = priv->gfargrp[0].regs;
 255         unsigned int num = simple_strtoul(buf, NULL, 0);
 256         u32 temp;
 257         unsigned long flags;
 258
 259         if (num > GFAR_MAX_FIFO_STARVE)
 260                 return count;
 261
 262         local_irq_save(flags);
 263         lock_tx_qs(priv);
 264
 265         priv->fifo_starve = num;
 266
 267         temp = gfar_read(&regs->fifo_tx_starve);
 268         temp &= ~FIFO_TX_STARVE_MASK;
 269         temp |= num;
 270         gfar_write(&regs->fifo_tx_starve, temp);
 271
 272         unlock_tx_qs(priv);
 273         local_irq_restore(flags);
 274
 275         return count;
 276 }
 277
 278 static DEVICE_ATTR(fifo_starve, 0644, gfar_show_fifo_starve,
 279                    gfar_set_fifo_starve);
 280
 281 static ssize_t gfar_show_fifo_starve_off(struct device *dev,
 282                                          struct device_attribute *attr,
 283                                          char *buf)
 284 {
 285         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 286
 287         return sprintf(buf, "%d\n", priv->fifo_starve_off);
 288 }
 289
 290 static ssize_t gfar_set_fifo_starve_off(struct device *dev,
 291                                         struct device_attribute *attr,
 292                                         const char *buf, size_t count)
 293 {
 294         struct gfar_private *priv = netdev_priv(to_net_dev(dev));
 295         struct gfar __iomem *regs = priv->gfargrp[0].regs;
 296         unsigned int num = simple_strtoul(buf, NULL, 0);
 297         u32 temp;
 298         unsigned long flags;
 299
 300         if (num > GFAR_MAX_FIFO_STARVE_OFF)
 301                 return count;
 302
 303         local_irq_save(flags);
 304         lock_tx_qs(priv);
 305
 306         priv->fifo_starve_off = num;
 307
 308         temp = gfar_read(&regs->fifo_tx_starve_shutoff);
 309         temp &= ~FIFO_TX_STARVE_OFF_MASK;
 310         temp |= num;
 311         gfar_write(&regs->fifo_tx_starve_shutoff, temp);
 312
 313         unlock_tx_qs(priv);
 314         local_irq_restore(flags);
 315
 316         return count;
 317 }
 318
 319 static DEVICE_ATTR(fifo_starve_off, 0644, gfar_show_fifo_starve_off,
 320                    gfar_set_fifo_starve_off);
 321
 322 void gfar_init_sysfs(struct net_device *dev)
 323 {
 324         struct gfar_private *priv = netdev_priv(dev);
 325         int rc;
 326
 327         /* Initialize the default values */
 328         priv->fifo_threshold = DEFAULT_FIFO_TX_THR;
 329         priv->fifo_starve = DEFAULT_FIFO_TX_STARVE;
 330         priv->fifo_starve_off = DEFAULT_FIFO_TX_STARVE_OFF;
 331
 332         /* Create our sysfs files */
 333         rc = device_create_file(&dev->dev, &dev_attr_bd_stash);
 334         rc |= device_create_file(&dev->dev, &dev_attr_rx_stash_size);
 335         rc |= device_create_file(&dev->dev, &dev_attr_rx_stash_index);
 336         rc |= device_create_file(&dev->dev, &dev_attr_fifo_threshold);
 337         rc |= device_create_file(&dev->dev, &dev_attr_fifo_starve);
 338         rc |= device_create_file(&dev->dev, &dev_attr_fifo_starve_off);
 339         if (rc)
 340                 dev_err(&dev->dev, "Error creating gianfar sysfs files.\n");
 341 }