SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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.regs;
  54         struct gfar_priv_rx_q *rx_queue = NULL;
  55         int new_setting = 0;
  56         u32 temp;
  57         unsigned long flags;
  58
  59         if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BD_STASHING))
  60                 return count;
  61
  62         rx_queue = priv->rx_queue;
  63
  64         /* Find out the new setting */
  65         if (!strncmp("on", buf, count - 1) || !strncmp("1", buf, count - 1))
  66                 new_setting = 1;
  67         else if (!strncmp("off", buf, count - 1)
  68                  || !strncmp("0", buf, count - 1))
  69                 new_setting = 0;
  70         else
  71                 return count;
  72
  73         spin_lock_irqsave(&rx_queue->rxlock, flags);
  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         spin_unlock_irqrestore(&rx_queue->rxlock, 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.regs;
 108         struct gfar_priv_rx_q *rx_queue = NULL;
 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         rx_queue = priv->rx_queue;
 117
 118         spin_lock_irqsave(&rx_queue->rxlock, flags);
 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         spin_unlock_irqrestore(&rx_queue->rxlock, 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.regs;
 167         struct gfar_priv_rx_q *rx_queue = NULL;
 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         rx_queue = priv->rx_queue;
 176
 177         spin_lock_irqsave(&rx_queue->rxlock, flags);
 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         spin_unlock_irqrestore(&rx_queue->rxlock, 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.regs;
 215         struct gfar_priv_tx_q *tx_queue = NULL;
 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         tx_queue = priv->tx_queue;
 224
 225         spin_lock_irqsave(&tx_queue->txlock, flags);
 226
 227         priv->fifo_threshold = length;
 228
 229         temp = gfar_read(&regs->fifo_tx_thr);
 230         temp &= ~FIFO_TX_THR_MASK;
 231         temp |= length;
 232         gfar_write(&regs->fifo_tx_thr, temp);
 233
 234         spin_unlock_irqrestore(&tx_queue->txlock, 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.regs;
 256         struct gfar_priv_tx_q *tx_queue = NULL;
 257         unsigned int num = simple_strtoul(buf, NULL, 0);
 258         u32 temp;
 259         unsigned long flags;
 260
 261         if (num > GFAR_MAX_FIFO_STARVE)
 262                 return count;
 263
 264         tx_queue = priv->tx_queue;
 265         spin_lock_irqsave(&tx_queue->txlock, flags);
 266
 267         priv->fifo_starve = num;
 268
 269         temp = gfar_read(&regs->fifo_tx_starve);
 270         temp &= ~FIFO_TX_STARVE_MASK;
 271         temp |= num;
 272         gfar_write(&regs->fifo_tx_starve, temp);
 273
 274         spin_unlock_irqrestore(&tx_queue->txlock, 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.regs;
 297         struct gfar_priv_tx_q *tx_queue = NULL;
 298         unsigned int num = simple_strtoul(buf, NULL, 0);
 299         u32 temp;
 300         unsigned long flags;
 301
 302         if (num > GFAR_MAX_FIFO_STARVE_OFF)
 303                 return count;
 304
 305         tx_queue = priv->tx_queue;
 306         spin_lock_irqsave(&tx_queue->txlock, flags);
 307
 308         priv->fifo_starve_off = num;
 309
 310         temp = gfar_read(&regs->fifo_tx_starve_shutoff);
 311         temp &= ~FIFO_TX_STARVE_OFF_MASK;
 312         temp |= num;
 313         gfar_write(&regs->fifo_tx_starve_shutoff, temp);
 314
 315         spin_unlock_irqrestore(&tx_queue->txlock, 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 }