[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)
		return count;

	if (length == priv->rx_stash_size)
		return count;

	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);

	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)
		return count;

	if (index == priv->rx_stash_index)
		return count;

	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);

	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 AF	105	if (length > priv->rx_buffer_size)
	106	return count;
	107
	108	if (length == priv->rx_stash_size)
	109	return count;
	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
fef6108d	128	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	129
	130	return count;
	131	}
	132
35a84fdc GL	133	DEVICE_ATTR(rx_stash_size, 0644, gfar_show_rx_stash_size,
	134	gfar_set_rx_stash_size);
	135
7f7f5316	136	/* Stashing will only be enabled when rx_stash_size != 0 */
4409d281 KG	137	static ssize_t gfar_show_rx_stash_index(struct device *dev,
	138	struct device_attribute *attr,
	139	char *buf)
7f7f5316	140	{
4409d281	141	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	142
	143	return sprintf(buf, "%d\n", priv->rx_stash_index);
	144	}
	145
4409d281 KG	146	static ssize_t gfar_set_rx_stash_index(struct device *dev,
	147	struct device_attribute *attr,
	148	const char *buf, size_t count)
7f7f5316	149	{
4409d281	150	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	151	unsigned short index = simple_strtoul(buf, NULL, 0);
	152	u32 temp;
	153	unsigned long flags;
	154
fef6108d	155	spin_lock_irqsave(&priv->rxlock, flags);
7f7f5316 AF	156	if (index > priv->rx_stash_size)
	157	return count;
	158
	159	if (index == priv->rx_stash_index)
	160	return count;
	161
	162	priv->rx_stash_index = index;
	163
	164	temp = gfar_read(&priv->regs->attreli);
	165	temp &= ~ATTRELI_EI_MASK;
	166	temp \|= ATTRELI_EI(index);
	167	gfar_write(&priv->regs->attreli, flags);
	168
fef6108d	169	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	170
	171	return count;
	172	}
	173
35a84fdc GL	174	DEVICE_ATTR(rx_stash_index, 0644, gfar_show_rx_stash_index,
	175	gfar_set_rx_stash_index);
	176
4409d281 KG	177	static ssize_t gfar_show_fifo_threshold(struct device *dev,
	178	struct device_attribute *attr,
	179	char *buf)
7f7f5316	180	{
4409d281	181	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	182
	183	return sprintf(buf, "%d\n", priv->fifo_threshold);
	184	}
	185
4409d281 KG	186	static ssize_t gfar_set_fifo_threshold(struct device *dev,
	187	struct device_attribute *attr,
	188	const char *buf, size_t count)
7f7f5316	189	{
4409d281	190	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	191	unsigned int length = simple_strtoul(buf, NULL, 0);
	192	u32 temp;
	193	unsigned long flags;
	194
	195	if (length > GFAR_MAX_FIFO_THRESHOLD)
	196	return count;
	197
fef6108d	198	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	199
	200	priv->fifo_threshold = length;
	201
	202	temp = gfar_read(&priv->regs->fifo_tx_thr);
	203	temp &= ~FIFO_TX_THR_MASK;
	204	temp \|= length;
	205	gfar_write(&priv->regs->fifo_tx_thr, temp);
	206
fef6108d	207	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	208
	209	return count;
	210	}
	211
35a84fdc GL	212	DEVICE_ATTR(fifo_threshold, 0644, gfar_show_fifo_threshold,
	213	gfar_set_fifo_threshold);
	214
4409d281 KG	215	static ssize_t gfar_show_fifo_starve(struct device *dev,
4409d281 KG	216	struct device_attribute attr, char buf)
7f7f5316	217	{
4409d281	218	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	219
	220	return sprintf(buf, "%d\n", priv->fifo_starve);
	221	}
	222
4409d281 KG	223	static ssize_t gfar_set_fifo_starve(struct device *dev,
	224	struct device_attribute *attr,
	225	const char *buf, size_t count)
7f7f5316	226	{
4409d281	227	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	228	unsigned int num = simple_strtoul(buf, NULL, 0);
	229	u32 temp;
	230	unsigned long flags;
	231
	232	if (num > GFAR_MAX_FIFO_STARVE)
	233	return count;
	234
fef6108d	235	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	236
	237	priv->fifo_starve = num;
	238
	239	temp = gfar_read(&priv->regs->fifo_tx_starve);
	240	temp &= ~FIFO_TX_STARVE_MASK;
	241	temp \|= num;
	242	gfar_write(&priv->regs->fifo_tx_starve, temp);
	243
fef6108d	244	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	245
	246	return count;
	247	}
	248
35a84fdc GL	249	DEVICE_ATTR(fifo_starve, 0644, gfar_show_fifo_starve, gfar_set_fifo_starve);
35a84fdc GL	250
4409d281 KG	251	static ssize_t gfar_show_fifo_starve_off(struct device *dev,
	252	struct device_attribute *attr,
	253	char *buf)
7f7f5316	254	{
4409d281	255	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	256
	257	return sprintf(buf, "%d\n", priv->fifo_starve_off);
	258	}
	259
4409d281 KG	260	static ssize_t gfar_set_fifo_starve_off(struct device *dev,
	261	struct device_attribute *attr,
	262	const char *buf, size_t count)
7f7f5316	263	{
4409d281	264	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	265	unsigned int num = simple_strtoul(buf, NULL, 0);
	266	u32 temp;
	267	unsigned long flags;
	268
	269	if (num > GFAR_MAX_FIFO_STARVE_OFF)
	270	return count;
	271
fef6108d	272	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	273
	274	priv->fifo_starve_off = num;
	275
	276	temp = gfar_read(&priv->regs->fifo_tx_starve_shutoff);
	277	temp &= ~FIFO_TX_STARVE_OFF_MASK;
	278	temp \|= num;
	279	gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp);
	280
fef6108d	281	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	282
	283	return count;
	284	}
	285
35a84fdc GL	286	DEVICE_ATTR(fifo_starve_off, 0644, gfar_show_fifo_starve_off,
	287	gfar_set_fifo_starve_off);
	288
7f7f5316 AF	289	void gfar_init_sysfs(struct net_device *dev)
	290	{
	291	struct gfar_private *priv = netdev_priv(dev);
35a84fdc	292	int rc;
7f7f5316 AF	293
	294	/* Initialize the default values */
	295	priv->rx_stash_size = DEFAULT_STASH_LENGTH;
	296	priv->rx_stash_index = DEFAULT_STASH_INDEX;
	297	priv->fifo_threshold = DEFAULT_FIFO_TX_THR;
	298	priv->fifo_starve = DEFAULT_FIFO_TX_STARVE;
	299	priv->fifo_starve_off = DEFAULT_FIFO_TX_STARVE_OFF;
	300	priv->bd_stash_en = DEFAULT_BD_STASH;
	301
	302	/* Create our sysfs files */
35a84fdc GL	303	rc = device_create_file(&dev->dev, &dev_attr_bd_stash);
	304	rc \|= device_create_file(&dev->dev, &dev_attr_rx_stash_size);
	305	rc \|= device_create_file(&dev->dev, &dev_attr_rx_stash_index);
	306	rc \|= device_create_file(&dev->dev, &dev_attr_fifo_threshold);
	307	rc \|= device_create_file(&dev->dev, &dev_attr_fifo_starve);
	308	rc \|= device_create_file(&dev->dev, &dev_attr_fifo_starve_off);
	309	if (rc)
	310	dev_err(&dev->dev, "Error creating gianfar sysfs files.\n");
7f7f5316	311	}