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