mac80211: Clear PS related flag on disabling power save.
[linux-2.6.git] / 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 }