[linux-2.6-block.git] / drivers / net / gianfar_sysfs.c

/*
 * drivers/net/gianfar_sysfs.c
 *
 * Gianfar Ethernet Driver
 * This driver is designed for the non-CPM ethernet controllers
 * on the 85xx and 83xx family of integrated processors
 * Based on 8260_io/fcc_enet.c
 *
 * Author: Andy Fleming
 * Maintainer: Kumar Gala (galak@kernel.crashing.org)
 *
 * Copyright (c) 2002-2005 Freescale Semiconductor, Inc.
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 *
 * Sysfs file creation and management
 */

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/etherdevice.h>
#include <linux/spinlock.h>
#include <linux/mm.h>
#include <linux/device.h>

#include <asm/uaccess.h>
#include <linux/module.h>
#include <linux/version.h>

#include "gianfar.h"

static ssize_t gfar_show_bd_stash(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));

	return sprintf(buf, "%s\n", priv->bd_stash_en ? "on" : "off");
}

static ssize_t gfar_set_bd_stash(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
	int new_setting = 0;
	u32 temp;
	unsigned long flags;

	/* Find out the new setting */
	if (!strncmp("on", buf, count - 1) || !strncmp("1", buf, count - 1))
		new_setting = 1;
	else if (!strncmp("off", buf, count - 1)
		 || !strncmp("0", buf, count - 1))
		new_setting = 0;
	else
		return count;

	spin_lock_irqsave(&priv->rxlock, flags);

	/* Set the new stashing value */
	priv->bd_stash_en = new_setting;

	temp = gfar_read(&priv->regs->attr);

	if (new_setting)
		temp |= ATTR_BDSTASH;
	else
		temp &= ~(ATTR_BDSTASH);

	gfar_write(&priv->regs->attr, temp);

	spin_unlock_irqrestore(&priv->rxlock, flags);

	return count;
}

DEVICE_ATTR(bd_stash, 0644, gfar_show_bd_stash, gfar_set_bd_stash);

static ssize_t gfar_show_rx_stash_size(struct device *dev,
				       struct device_attribute *attr, char *buf)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));

	return sprintf(buf, "%d\n", priv->rx_stash_size);
}

static ssize_t gfar_set_rx_stash_size(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf, size_t count)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
	unsigned int length = simple_strtoul(buf, NULL, 0);
	u32 temp;
	unsigned long flags;

	spin_lock_irqsave(&priv->rxlock, flags);
	if (length > priv->rx_buffer_size)
		goto out;

	if (length == priv->rx_stash_size)
		goto out;

	priv->rx_stash_size = length;

	temp = gfar_read(&priv->regs->attreli);
	temp &= ~ATTRELI_EL_MASK;
	temp |= ATTRELI_EL(length);
	gfar_write(&priv->regs->attreli, temp);

	/* Turn stashing on/off as appropriate */
	temp = gfar_read(&priv->regs->attr);

	if (length)
		temp |= ATTR_BUFSTASH;
	else
		temp &= ~(ATTR_BUFSTASH);

	gfar_write(&priv->regs->attr, temp);

out:
	spin_unlock_irqrestore(&priv->rxlock, flags);

	return count;
}

DEVICE_ATTR(rx_stash_size, 0644, gfar_show_rx_stash_size,
	    gfar_set_rx_stash_size);

/* Stashing will only be enabled when rx_stash_size != 0 */
static ssize_t gfar_show_rx_stash_index(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));

	return sprintf(buf, "%d\n", priv->rx_stash_index);
}

static ssize_t gfar_set_rx_stash_index(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
	unsigned short index = simple_strtoul(buf, NULL, 0);
	u32 temp;
	unsigned long flags;

	spin_lock_irqsave(&priv->rxlock, flags);
	if (index > priv->rx_stash_size)
		goto out;

	if (index == priv->rx_stash_index)
		goto out;

	priv->rx_stash_index = index;

	temp = gfar_read(&priv->regs->attreli);
	temp &= ~ATTRELI_EI_MASK;
	temp |= ATTRELI_EI(index);
	gfar_write(&priv->regs->attreli, flags);

out:
	spin_unlock_irqrestore(&priv->rxlock, flags);

	return count;
}

DEVICE_ATTR(rx_stash_index, 0644, gfar_show_rx_stash_index,
	    gfar_set_rx_stash_index);

static ssize_t gfar_show_fifo_threshold(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));

	return sprintf(buf, "%d\n", priv->fifo_threshold);
}

static ssize_t gfar_set_fifo_threshold(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
	unsigned int length = simple_strtoul(buf, NULL, 0);
	u32 temp;
	unsigned long flags;

	if (length > GFAR_MAX_FIFO_THRESHOLD)
		return count;

	spin_lock_irqsave(&priv->txlock, flags);

	priv->fifo_threshold = length;

	temp = gfar_read(&priv->regs->fifo_tx_thr);
	temp &= ~FIFO_TX_THR_MASK;
	temp |= length;
	gfar_write(&priv->regs->fifo_tx_thr, temp);

	spin_unlock_irqrestore(&priv->txlock, flags);

	return count;
}

DEVICE_ATTR(fifo_threshold, 0644, gfar_show_fifo_threshold,
	    gfar_set_fifo_threshold);

static ssize_t gfar_show_fifo_starve(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));

	return sprintf(buf, "%d\n", priv->fifo_starve);
}

static ssize_t gfar_set_fifo_starve(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
	unsigned int num = simple_strtoul(buf, NULL, 0);
	u32 temp;
	unsigned long flags;

	if (num > GFAR_MAX_FIFO_STARVE)
		return count;

	spin_lock_irqsave(&priv->txlock, flags);

	priv->fifo_starve = num;

	temp = gfar_read(&priv->regs->fifo_tx_starve);
	temp &= ~FIFO_TX_STARVE_MASK;
	temp |= num;
	gfar_write(&priv->regs->fifo_tx_starve, temp);

	spin_unlock_irqrestore(&priv->txlock, flags);

	return count;
}

DEVICE_ATTR(fifo_starve, 0644, gfar_show_fifo_starve, gfar_set_fifo_starve);

static ssize_t gfar_show_fifo_starve_off(struct device *dev,
					 struct device_attribute *attr,
					 char *buf)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));

	return sprintf(buf, "%d\n", priv->fifo_starve_off);
}

static ssize_t gfar_set_fifo_starve_off(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t count)
{
	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
	unsigned int num = simple_strtoul(buf, NULL, 0);
	u32 temp;
	unsigned long flags;

	if (num > GFAR_MAX_FIFO_STARVE_OFF)
		return count;

	spin_lock_irqsave(&priv->txlock, flags);

	priv->fifo_starve_off = num;

	temp = gfar_read(&priv->regs->fifo_tx_starve_shutoff);
	temp &= ~FIFO_TX_STARVE_OFF_MASK;
	temp |= num;
	gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp);

	spin_unlock_irqrestore(&priv->txlock, flags);

	return count;
}

DEVICE_ATTR(fifo_starve_off, 0644, gfar_show_fifo_starve_off,
	    gfar_set_fifo_starve_off);

void gfar_init_sysfs(struct net_device *dev)
{
	struct gfar_private *priv = netdev_priv(dev);
	int rc;

	/* Initialize the default values */
	priv->rx_stash_size = DEFAULT_STASH_LENGTH;
	priv->rx_stash_index = DEFAULT_STASH_INDEX;
	priv->fifo_threshold = DEFAULT_FIFO_TX_THR;
	priv->fifo_starve = DEFAULT_FIFO_TX_STARVE;
	priv->fifo_starve_off = DEFAULT_FIFO_TX_STARVE_OFF;
	priv->bd_stash_en = DEFAULT_BD_STASH;

	/* Create our sysfs files */
	rc = device_create_file(&dev->dev, &dev_attr_bd_stash);
	rc |= device_create_file(&dev->dev, &dev_attr_rx_stash_size);
	rc |= device_create_file(&dev->dev, &dev_attr_rx_stash_index);
	rc |= device_create_file(&dev->dev, &dev_attr_fifo_threshold);
	rc |= device_create_file(&dev->dev, &dev_attr_fifo_starve);
	rc |= device_create_file(&dev->dev, &dev_attr_fifo_starve_off);
	if (rc)
		dev_err(&dev->dev, "Error creating gianfar sysfs files.\n");
}
Commit	Line	Data
7f7f5316 AF	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
b56d55b6	10	* Maintainer: Kumar Gala (galak@kernel.crashing.org)
7f7f5316 AF	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
7f7f5316	22	#include <linux/kernel.h>
7f7f5316 AF	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	#include <linux/version.h>
	37
	38	#include "gianfar.h"
	39
4409d281 KG	40	static ssize_t gfar_show_bd_stash(struct device *dev,
4409d281 KG	41	struct device_attribute attr, char buf)
7f7f5316	42	{
4409d281	43	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316	44
4409d281	45	return sprintf(buf, "%s\n", priv->bd_stash_en ? "on" : "off");
7f7f5316 AF	46	}
7f7f5316 AF	47
4409d281 KG	48	static ssize_t gfar_set_bd_stash(struct device *dev,
	49	struct device_attribute *attr,
	50	const char *buf, size_t count)
7f7f5316	51	{
4409d281	52	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	53	int new_setting = 0;
	54	u32 temp;
	55	unsigned long flags;
	56
	57	/* Find out the new setting */
4409d281	58	if (!strncmp("on", buf, count - 1) \|\| !strncmp("1", buf, count - 1))
7f7f5316	59	new_setting = 1;
4409d281 KG	60	else if (!strncmp("off", buf, count - 1)
4409d281 KG	61	\|\| !strncmp("0", buf, count - 1))
7f7f5316 AF	62	new_setting = 0;
	63	else
	64	return count;
	65
fef6108d	66	spin_lock_irqsave(&priv->rxlock, flags);
7f7f5316 AF	67
	68	/* Set the new stashing value */
	69	priv->bd_stash_en = new_setting;
	70
	71	temp = gfar_read(&priv->regs->attr);
6aa20a22	72
7f7f5316 AF	73	if (new_setting)
	74	temp \|= ATTR_BDSTASH;
	75	else
	76	temp &= ~(ATTR_BDSTASH);
	77
	78	gfar_write(&priv->regs->attr, temp);
	79
fef6108d	80	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	81
	82	return count;
	83	}
	84
35a84fdc GL	85	DEVICE_ATTR(bd_stash, 0644, gfar_show_bd_stash, gfar_set_bd_stash);
35a84fdc GL	86
4409d281 KG	87	static ssize_t gfar_show_rx_stash_size(struct device *dev,
4409d281 KG	88	struct device_attribute attr, char buf)
7f7f5316	89	{
4409d281	90	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	91
	92	return sprintf(buf, "%d\n", priv->rx_stash_size);
	93	}
	94
4409d281 KG	95	static ssize_t gfar_set_rx_stash_size(struct device *dev,
	96	struct device_attribute *attr,
	97	const char *buf, size_t count)
7f7f5316	98	{
4409d281	99	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	100	unsigned int length = simple_strtoul(buf, NULL, 0);
	101	u32 temp;
	102	unsigned long flags;
	103
fef6108d	104	spin_lock_irqsave(&priv->rxlock, flags);
7f7f5316	105	if (length > priv->rx_buffer_size)
f162b9d5	106	goto out;
7f7f5316 AF	107
7f7f5316 AF	108	if (length == priv->rx_stash_size)
f162b9d5	109	goto out;
7f7f5316 AF	110
	111	priv->rx_stash_size = length;
	112
	113	temp = gfar_read(&priv->regs->attreli);
	114	temp &= ~ATTRELI_EL_MASK;
	115	temp \|= ATTRELI_EL(length);
	116	gfar_write(&priv->regs->attreli, temp);
	117
	118	/* Turn stashing on/off as appropriate */
	119	temp = gfar_read(&priv->regs->attr);
	120
	121	if (length)
	122	temp \|= ATTR_BUFSTASH;
	123	else
	124	temp &= ~(ATTR_BUFSTASH);
	125
	126	gfar_write(&priv->regs->attr, temp);
	127
f162b9d5	128	out:
fef6108d	129	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	130
	131	return count;
	132	}
	133
35a84fdc GL	134	DEVICE_ATTR(rx_stash_size, 0644, gfar_show_rx_stash_size,
	135	gfar_set_rx_stash_size);
	136
7f7f5316	137	/* Stashing will only be enabled when rx_stash_size != 0 */
4409d281 KG	138	static ssize_t gfar_show_rx_stash_index(struct device *dev,
	139	struct device_attribute *attr,
	140	char *buf)
7f7f5316	141	{
4409d281	142	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	143
	144	return sprintf(buf, "%d\n", priv->rx_stash_index);
	145	}
	146
4409d281 KG	147	static ssize_t gfar_set_rx_stash_index(struct device *dev,
	148	struct device_attribute *attr,
	149	const char *buf, size_t count)
7f7f5316	150	{
4409d281	151	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	152	unsigned short index = simple_strtoul(buf, NULL, 0);
	153	u32 temp;
	154	unsigned long flags;
	155
fef6108d	156	spin_lock_irqsave(&priv->rxlock, flags);
7f7f5316	157	if (index > priv->rx_stash_size)
f162b9d5	158	goto out;
7f7f5316 AF	159
7f7f5316 AF	160	if (index == priv->rx_stash_index)
f162b9d5	161	goto out;
7f7f5316 AF	162
	163	priv->rx_stash_index = index;
	164
	165	temp = gfar_read(&priv->regs->attreli);
	166	temp &= ~ATTRELI_EI_MASK;
	167	temp \|= ATTRELI_EI(index);
	168	gfar_write(&priv->regs->attreli, flags);
	169
f162b9d5	170	out:
fef6108d	171	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	172
	173	return count;
	174	}
	175
35a84fdc GL	176	DEVICE_ATTR(rx_stash_index, 0644, gfar_show_rx_stash_index,
	177	gfar_set_rx_stash_index);
	178
4409d281 KG	179	static ssize_t gfar_show_fifo_threshold(struct device *dev,
	180	struct device_attribute *attr,
	181	char *buf)
7f7f5316	182	{
4409d281	183	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	184
	185	return sprintf(buf, "%d\n", priv->fifo_threshold);
	186	}
	187
4409d281 KG	188	static ssize_t gfar_set_fifo_threshold(struct device *dev,
	189	struct device_attribute *attr,
	190	const char *buf, size_t count)
7f7f5316	191	{
4409d281	192	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	193	unsigned int length = simple_strtoul(buf, NULL, 0);
	194	u32 temp;
	195	unsigned long flags;
	196
	197	if (length > GFAR_MAX_FIFO_THRESHOLD)
	198	return count;
	199
fef6108d	200	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	201
	202	priv->fifo_threshold = length;
	203
	204	temp = gfar_read(&priv->regs->fifo_tx_thr);
	205	temp &= ~FIFO_TX_THR_MASK;
	206	temp \|= length;
	207	gfar_write(&priv->regs->fifo_tx_thr, temp);
	208
fef6108d	209	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	210
	211	return count;
	212	}
	213
35a84fdc GL	214	DEVICE_ATTR(fifo_threshold, 0644, gfar_show_fifo_threshold,
	215	gfar_set_fifo_threshold);
	216
4409d281 KG	217	static ssize_t gfar_show_fifo_starve(struct device *dev,
4409d281 KG	218	struct device_attribute attr, char buf)
7f7f5316	219	{
4409d281	220	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	221
	222	return sprintf(buf, "%d\n", priv->fifo_starve);
	223	}
	224
4409d281 KG	225	static ssize_t gfar_set_fifo_starve(struct device *dev,
	226	struct device_attribute *attr,
	227	const char *buf, size_t count)
7f7f5316	228	{
4409d281	229	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	230	unsigned int num = simple_strtoul(buf, NULL, 0);
	231	u32 temp;
	232	unsigned long flags;
	233
	234	if (num > GFAR_MAX_FIFO_STARVE)
	235	return count;
	236
fef6108d	237	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	238
	239	priv->fifo_starve = num;
	240
	241	temp = gfar_read(&priv->regs->fifo_tx_starve);
	242	temp &= ~FIFO_TX_STARVE_MASK;
	243	temp \|= num;
	244	gfar_write(&priv->regs->fifo_tx_starve, temp);
	245
fef6108d	246	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	247
	248	return count;
	249	}
	250
35a84fdc GL	251	DEVICE_ATTR(fifo_starve, 0644, gfar_show_fifo_starve, gfar_set_fifo_starve);
35a84fdc GL	252
4409d281 KG	253	static ssize_t gfar_show_fifo_starve_off(struct device *dev,
	254	struct device_attribute *attr,
	255	char *buf)
7f7f5316	256	{
4409d281	257	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	258
	259	return sprintf(buf, "%d\n", priv->fifo_starve_off);
	260	}
	261
4409d281 KG	262	static ssize_t gfar_set_fifo_starve_off(struct device *dev,
	263	struct device_attribute *attr,
	264	const char *buf, size_t count)
7f7f5316	265	{
4409d281	266	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	267	unsigned int num = simple_strtoul(buf, NULL, 0);
	268	u32 temp;
	269	unsigned long flags;
	270
	271	if (num > GFAR_MAX_FIFO_STARVE_OFF)
	272	return count;
	273
fef6108d	274	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	275
	276	priv->fifo_starve_off = num;
	277
	278	temp = gfar_read(&priv->regs->fifo_tx_starve_shutoff);
	279	temp &= ~FIFO_TX_STARVE_OFF_MASK;
	280	temp \|= num;
	281	gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp);
	282
fef6108d	283	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	284
	285	return count;
	286	}
	287
35a84fdc GL	288	DEVICE_ATTR(fifo_starve_off, 0644, gfar_show_fifo_starve_off,
	289	gfar_set_fifo_starve_off);
	290
7f7f5316 AF	291	void gfar_init_sysfs(struct net_device *dev)
	292	{
	293	struct gfar_private *priv = netdev_priv(dev);
35a84fdc	294	int rc;
7f7f5316 AF	295
	296	/* Initialize the default values */
	297	priv->rx_stash_size = DEFAULT_STASH_LENGTH;
	298	priv->rx_stash_index = DEFAULT_STASH_INDEX;
	299	priv->fifo_threshold = DEFAULT_FIFO_TX_THR;
	300	priv->fifo_starve = DEFAULT_FIFO_TX_STARVE;
	301	priv->fifo_starve_off = DEFAULT_FIFO_TX_STARVE_OFF;
	302	priv->bd_stash_en = DEFAULT_BD_STASH;
	303
	304	/* Create our sysfs files */
35a84fdc GL	305	rc = device_create_file(&dev->dev, &dev_attr_bd_stash);
	306	rc \|= device_create_file(&dev->dev, &dev_attr_rx_stash_size);
	307	rc \|= device_create_file(&dev->dev, &dev_attr_rx_stash_index);
	308	rc \|= device_create_file(&dev->dev, &dev_attr_fifo_threshold);
	309	rc \|= device_create_file(&dev->dev, &dev_attr_fifo_starve);
	310	rc \|= device_create_file(&dev->dev, &dev_attr_fifo_starve_off);
	311	if (rc)
	312	dev_err(&dev->dev, "Error creating gianfar sysfs files.\n");
7f7f5316	313	}