Root/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 *
12 * Copyright (c) 2002-2005 Freescale Semiconductor, Inc.
13 *
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2 of the License, or (at your
17 * option) any later version.
18 *
19 * Sysfs file creation and management
20 */
21
22#include <linux/kernel.h>
23#include <linux/string.h>
24#include <linux/errno.h>
25#include <linux/unistd.h>
26#include <linux/slab.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
39static 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
47static 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    int new_setting = 0;
53    u32 temp;
54    unsigned long flags;
55
56    if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BD_STASHING))
57        return count;
58
59    /* Find out the new setting */
60    if (!strncmp("on", buf, count - 1) || !strncmp("1", buf, count - 1))
61        new_setting = 1;
62    else if (!strncmp("off", buf, count - 1)
63         || !strncmp("0", buf, count - 1))
64        new_setting = 0;
65    else
66        return count;
67
68    spin_lock_irqsave(&priv->rxlock, flags);
69
70    /* Set the new stashing value */
71    priv->bd_stash_en = new_setting;
72
73    temp = gfar_read(&priv->regs->attr);
74
75    if (new_setting)
76        temp |= ATTR_BDSTASH;
77    else
78        temp &= ~(ATTR_BDSTASH);
79
80    gfar_write(&priv->regs->attr, temp);
81
82    spin_unlock_irqrestore(&priv->rxlock, flags);
83
84    return count;
85}
86
87static DEVICE_ATTR(bd_stash, 0644, gfar_show_bd_stash, gfar_set_bd_stash);
88
89static ssize_t gfar_show_rx_stash_size(struct device *dev,
90                       struct device_attribute *attr, char *buf)
91{
92    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
93
94    return sprintf(buf, "%d\n", priv->rx_stash_size);
95}
96
97static ssize_t gfar_set_rx_stash_size(struct device *dev,
98                      struct device_attribute *attr,
99                      const char *buf, size_t count)
100{
101    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
102    unsigned int length = simple_strtoul(buf, NULL, 0);
103    u32 temp;
104    unsigned long flags;
105
106    if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
107        return count;
108
109    spin_lock_irqsave(&priv->rxlock, flags);
110    if (length > priv->rx_buffer_size)
111        goto out;
112
113    if (length == priv->rx_stash_size)
114        goto out;
115
116    priv->rx_stash_size = length;
117
118    temp = gfar_read(&priv->regs->attreli);
119    temp &= ~ATTRELI_EL_MASK;
120    temp |= ATTRELI_EL(length);
121    gfar_write(&priv->regs->attreli, temp);
122
123    /* Turn stashing on/off as appropriate */
124    temp = gfar_read(&priv->regs->attr);
125
126    if (length)
127        temp |= ATTR_BUFSTASH;
128    else
129        temp &= ~(ATTR_BUFSTASH);
130
131    gfar_write(&priv->regs->attr, temp);
132
133out:
134    spin_unlock_irqrestore(&priv->rxlock, flags);
135
136    return count;
137}
138
139static DEVICE_ATTR(rx_stash_size, 0644, gfar_show_rx_stash_size,
140           gfar_set_rx_stash_size);
141
142/* Stashing will only be enabled when rx_stash_size != 0 */
143static ssize_t gfar_show_rx_stash_index(struct device *dev,
144                    struct device_attribute *attr,
145                    char *buf)
146{
147    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
148
149    return sprintf(buf, "%d\n", priv->rx_stash_index);
150}
151
152static ssize_t gfar_set_rx_stash_index(struct device *dev,
153                       struct device_attribute *attr,
154                       const char *buf, size_t count)
155{
156    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
157    unsigned short index = simple_strtoul(buf, NULL, 0);
158    u32 temp;
159    unsigned long flags;
160
161    if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
162        return count;
163
164    spin_lock_irqsave(&priv->rxlock, flags);
165    if (index > priv->rx_stash_size)
166        goto out;
167
168    if (index == priv->rx_stash_index)
169        goto out;
170
171    priv->rx_stash_index = index;
172
173    temp = gfar_read(&priv->regs->attreli);
174    temp &= ~ATTRELI_EI_MASK;
175    temp |= ATTRELI_EI(index);
176    gfar_write(&priv->regs->attreli, flags);
177
178out:
179    spin_unlock_irqrestore(&priv->rxlock, flags);
180
181    return count;
182}
183
184static DEVICE_ATTR(rx_stash_index, 0644, gfar_show_rx_stash_index,
185           gfar_set_rx_stash_index);
186
187static ssize_t gfar_show_fifo_threshold(struct device *dev,
188                    struct device_attribute *attr,
189                    char *buf)
190{
191    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
192
193    return sprintf(buf, "%d\n", priv->fifo_threshold);
194}
195
196static ssize_t gfar_set_fifo_threshold(struct device *dev,
197                       struct device_attribute *attr,
198                       const char *buf, size_t count)
199{
200    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
201    unsigned int length = simple_strtoul(buf, NULL, 0);
202    u32 temp;
203    unsigned long flags;
204
205    if (length > GFAR_MAX_FIFO_THRESHOLD)
206        return count;
207
208    spin_lock_irqsave(&priv->txlock, flags);
209
210    priv->fifo_threshold = length;
211
212    temp = gfar_read(&priv->regs->fifo_tx_thr);
213    temp &= ~FIFO_TX_THR_MASK;
214    temp |= length;
215    gfar_write(&priv->regs->fifo_tx_thr, temp);
216
217    spin_unlock_irqrestore(&priv->txlock, flags);
218
219    return count;
220}
221
222static DEVICE_ATTR(fifo_threshold, 0644, gfar_show_fifo_threshold,
223           gfar_set_fifo_threshold);
224
225static ssize_t gfar_show_fifo_starve(struct device *dev,
226                     struct device_attribute *attr, char *buf)
227{
228    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
229
230    return sprintf(buf, "%d\n", priv->fifo_starve);
231}
232
233static ssize_t gfar_set_fifo_starve(struct device *dev,
234                    struct device_attribute *attr,
235                    const char *buf, size_t count)
236{
237    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
238    unsigned int num = simple_strtoul(buf, NULL, 0);
239    u32 temp;
240    unsigned long flags;
241
242    if (num > GFAR_MAX_FIFO_STARVE)
243        return count;
244
245    spin_lock_irqsave(&priv->txlock, flags);
246
247    priv->fifo_starve = num;
248
249    temp = gfar_read(&priv->regs->fifo_tx_starve);
250    temp &= ~FIFO_TX_STARVE_MASK;
251    temp |= num;
252    gfar_write(&priv->regs->fifo_tx_starve, temp);
253
254    spin_unlock_irqrestore(&priv->txlock, flags);
255
256    return count;
257}
258
259static DEVICE_ATTR(fifo_starve, 0644, gfar_show_fifo_starve,
260           gfar_set_fifo_starve);
261
262static ssize_t gfar_show_fifo_starve_off(struct device *dev,
263                     struct device_attribute *attr,
264                     char *buf)
265{
266    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
267
268    return sprintf(buf, "%d\n", priv->fifo_starve_off);
269}
270
271static ssize_t gfar_set_fifo_starve_off(struct device *dev,
272                    struct device_attribute *attr,
273                    const char *buf, size_t count)
274{
275    struct gfar_private *priv = netdev_priv(to_net_dev(dev));
276    unsigned int num = simple_strtoul(buf, NULL, 0);
277    u32 temp;
278    unsigned long flags;
279
280    if (num > GFAR_MAX_FIFO_STARVE_OFF)
281        return count;
282
283    spin_lock_irqsave(&priv->txlock, flags);
284
285    priv->fifo_starve_off = num;
286
287    temp = gfar_read(&priv->regs->fifo_tx_starve_shutoff);
288    temp &= ~FIFO_TX_STARVE_OFF_MASK;
289    temp |= num;
290    gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp);
291
292    spin_unlock_irqrestore(&priv->txlock, flags);
293
294    return count;
295}
296
297static DEVICE_ATTR(fifo_starve_off, 0644, gfar_show_fifo_starve_off,
298           gfar_set_fifo_starve_off);
299
300void gfar_init_sysfs(struct net_device *dev)
301{
302    struct gfar_private *priv = netdev_priv(dev);
303    int rc;
304
305    /* Initialize the default values */
306    priv->fifo_threshold = DEFAULT_FIFO_TX_THR;
307    priv->fifo_starve = DEFAULT_FIFO_TX_STARVE;
308    priv->fifo_starve_off = DEFAULT_FIFO_TX_STARVE_OFF;
309
310    /* Create our sysfs files */
311    rc = device_create_file(&dev->dev, &dev_attr_bd_stash);
312    rc |= device_create_file(&dev->dev, &dev_attr_rx_stash_size);
313    rc |= device_create_file(&dev->dev, &dev_attr_rx_stash_index);
314    rc |= device_create_file(&dev->dev, &dev_attr_fifo_threshold);
315    rc |= device_create_file(&dev->dev, &dev_attr_fifo_starve);
316    rc |= device_create_file(&dev->dev, &dev_attr_fifo_starve_off);
317    if (rc)
318        dev_err(&dev->dev, "Error creating gianfar sysfs files.\n");
319}
320

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive