Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gianfar_sysfs.c
Go to the documentation of this file.
1 /*
2  * drivers/net/ethernet/freescale/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 ([email protected])
11  * Modifier: Sandeep Gopalpet <[email protected]>
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 }
Generated on Thu Jan 10 2013 14:01:26 for Linux Kernel by   doxygen 1.8.2