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 (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
gfar_show_bd_stash(struct device * dev,struct device_attribute * attr,char * buf)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
gfar_set_bd_stash(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(®s->attr);
78
79 if (new_setting)
80 temp |= ATTR_BDSTASH;
81 else
82 temp &= ~(ATTR_BDSTASH);
83
84 gfar_write(®s->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
gfar_show_rx_stash_size(struct device * dev,struct device_attribute * attr,char * buf)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
gfar_set_rx_stash_size(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(®s->attreli);
127 temp &= ~ATTRELI_EL_MASK;
128 temp |= ATTRELI_EL(length);
129 gfar_write(®s->attreli, temp);
130
131 /* Turn stashing on/off as appropriate */
132 temp = gfar_read(®s->attr);
133
134 if (length)
135 temp |= ATTR_BUFSTASH;
136 else
137 temp &= ~(ATTR_BUFSTASH);
138
139 gfar_write(®s->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 */
gfar_show_rx_stash_index(struct device * dev,struct device_attribute * attr,char * buf)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
gfar_set_rx_stash_index(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(®s->attreli);
186 temp &= ~ATTRELI_EI_MASK;
187 temp |= ATTRELI_EI(index);
188 gfar_write(®s->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
gfar_show_fifo_threshold(struct device * dev,struct device_attribute * attr,char * buf)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
gfar_set_fifo_threshold(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(®s->fifo_tx_thr);
228 temp &= ~FIFO_TX_THR_MASK;
229 temp |= length;
230 gfar_write(®s->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
gfar_show_fifo_starve(struct device * dev,struct device_attribute * attr,char * buf)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
gfar_set_fifo_starve(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(®s->fifo_tx_starve);
268 temp &= ~FIFO_TX_STARVE_MASK;
269 temp |= num;
270 gfar_write(®s->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
gfar_show_fifo_starve_off(struct device * dev,struct device_attribute * attr,char * buf)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
gfar_set_fifo_starve_off(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(®s->fifo_tx_starve_shutoff);
309 temp &= ~FIFO_TX_STARVE_OFF_MASK;
310 temp |= num;
311 gfar_write(®s->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
gfar_init_sysfs(struct net_device * dev)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 }
342