[linux-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 "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;

	if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BD_STASHING))
		return count;

	/* 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;
}

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

	if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
		return count;

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

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

	if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
		return count;

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

static 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;
}

static 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;
}

static 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;
}

static 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->fifo_threshold = DEFAULT_FIFO_TX_THR;
	priv->fifo_starve = DEFAULT_FIFO_TX_STARVE;
	priv->fifo_starve_off = DEFAULT_FIFO_TX_STARVE_OFF;

	/* 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>
7f7f5316 AF	36
	37	#include "gianfar.h"
	38
4409d281 KG	39	static ssize_t gfar_show_bd_stash(struct device *dev,
4409d281 KG	40	struct device_attribute attr, char buf)
7f7f5316	41	{
4409d281	42	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316	43
4409d281	44	return sprintf(buf, "%s\n", priv->bd_stash_en ? "on" : "off");
7f7f5316 AF	45	}
7f7f5316 AF	46
4409d281 KG	47	static ssize_t gfar_set_bd_stash(struct device *dev,
	48	struct device_attribute *attr,
	49	const char *buf, size_t count)
7f7f5316	50	{
4409d281	51	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	52	int new_setting = 0;
	53	u32 temp;
	54	unsigned long flags;
	55
4d7902f2 AF	56	if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BD_STASHING))
	57	return count;
	58
7f7f5316	59	/* Find out the new setting */
4409d281	60	if (!strncmp("on", buf, count - 1) \|\| !strncmp("1", buf, count - 1))
7f7f5316	61	new_setting = 1;
4409d281 KG	62	else if (!strncmp("off", buf, count - 1)
4409d281 KG	63	\|\| !strncmp("0", buf, count - 1))
7f7f5316 AF	64	new_setting = 0;
	65	else
	66	return count;
	67
fef6108d	68	spin_lock_irqsave(&priv->rxlock, flags);
7f7f5316 AF	69
	70	/* Set the new stashing value */
	71	priv->bd_stash_en = new_setting;
	72
	73	temp = gfar_read(&priv->regs->attr);
6aa20a22	74
7f7f5316 AF	75	if (new_setting)
	76	temp \|= ATTR_BDSTASH;
	77	else
	78	temp &= ~(ATTR_BDSTASH);
	79
	80	gfar_write(&priv->regs->attr, temp);
	81
fef6108d	82	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	83
	84	return count;
	85	}
	86
b2f66d18	87	static DEVICE_ATTR(bd_stash, 0644, gfar_show_bd_stash, gfar_set_bd_stash);
35a84fdc	88
4409d281 KG	89	static ssize_t gfar_show_rx_stash_size(struct device *dev,
4409d281 KG	90	struct device_attribute attr, char buf)
7f7f5316	91	{
4409d281	92	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	93
	94	return sprintf(buf, "%d\n", priv->rx_stash_size);
	95	}
	96
4409d281 KG	97	static ssize_t gfar_set_rx_stash_size(struct device *dev,
	98	struct device_attribute *attr,
	99	const char *buf, size_t count)
7f7f5316	100	{
4409d281	101	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	102	unsigned int length = simple_strtoul(buf, NULL, 0);
	103	u32 temp;
	104	unsigned long flags;
	105
4d7902f2 AF	106	if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
	107	return count;
	108
fef6108d	109	spin_lock_irqsave(&priv->rxlock, flags);
7f7f5316	110	if (length > priv->rx_buffer_size)
f162b9d5	111	goto out;
7f7f5316 AF	112
7f7f5316 AF	113	if (length == priv->rx_stash_size)
f162b9d5	114	goto out;
7f7f5316 AF	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
f162b9d5	133	out:
fef6108d	134	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	135
	136	return count;
	137	}
	138
b2f66d18 AV	139	static DEVICE_ATTR(rx_stash_size, 0644, gfar_show_rx_stash_size,
b2f66d18 AV	140	gfar_set_rx_stash_size);
35a84fdc	141
7f7f5316	142	/* Stashing will only be enabled when rx_stash_size != 0 */
4409d281 KG	143	static ssize_t gfar_show_rx_stash_index(struct device *dev,
	144	struct device_attribute *attr,
	145	char *buf)
7f7f5316	146	{
4409d281	147	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	148
	149	return sprintf(buf, "%d\n", priv->rx_stash_index);
	150	}
	151
4409d281 KG	152	static ssize_t gfar_set_rx_stash_index(struct device *dev,
	153	struct device_attribute *attr,
	154	const char *buf, size_t count)
7f7f5316	155	{
4409d281	156	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	157	unsigned short index = simple_strtoul(buf, NULL, 0);
	158	u32 temp;
	159	unsigned long flags;
	160
4d7902f2 AF	161	if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
	162	return count;
	163
fef6108d	164	spin_lock_irqsave(&priv->rxlock, flags);
7f7f5316	165	if (index > priv->rx_stash_size)
f162b9d5	166	goto out;
7f7f5316 AF	167
7f7f5316 AF	168	if (index == priv->rx_stash_index)
f162b9d5	169	goto out;
7f7f5316 AF	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
f162b9d5	178	out:
fef6108d	179	spin_unlock_irqrestore(&priv->rxlock, flags);
7f7f5316 AF	180
	181	return count;
	182	}
	183
b2f66d18 AV	184	static DEVICE_ATTR(rx_stash_index, 0644, gfar_show_rx_stash_index,
b2f66d18 AV	185	gfar_set_rx_stash_index);
35a84fdc	186
4409d281 KG	187	static ssize_t gfar_show_fifo_threshold(struct device *dev,
	188	struct device_attribute *attr,
	189	char *buf)
7f7f5316	190	{
4409d281	191	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	192
	193	return sprintf(buf, "%d\n", priv->fifo_threshold);
	194	}
	195
4409d281 KG	196	static ssize_t gfar_set_fifo_threshold(struct device *dev,
	197	struct device_attribute *attr,
	198	const char *buf, size_t count)
7f7f5316	199	{
4409d281	200	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	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
fef6108d	208	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	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
fef6108d	217	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	218
	219	return count;
	220	}
	221
b2f66d18 AV	222	static DEVICE_ATTR(fifo_threshold, 0644, gfar_show_fifo_threshold,
b2f66d18 AV	223	gfar_set_fifo_threshold);
35a84fdc	224
4409d281 KG	225	static ssize_t gfar_show_fifo_starve(struct device *dev,
4409d281 KG	226	struct device_attribute attr, char buf)
7f7f5316	227	{
4409d281	228	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	229
	230	return sprintf(buf, "%d\n", priv->fifo_starve);
	231	}
	232
4409d281 KG	233	static ssize_t gfar_set_fifo_starve(struct device *dev,
	234	struct device_attribute *attr,
	235	const char *buf, size_t count)
7f7f5316	236	{
4409d281	237	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	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
fef6108d	245	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	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
fef6108d	254	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	255
	256	return count;
	257	}
	258
b2f66d18 AV	259	static DEVICE_ATTR(fifo_starve, 0644, gfar_show_fifo_starve,
b2f66d18 AV	260	gfar_set_fifo_starve);
35a84fdc	261
4409d281 KG	262	static ssize_t gfar_show_fifo_starve_off(struct device *dev,
	263	struct device_attribute *attr,
	264	char *buf)
7f7f5316	265	{
4409d281	266	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	267
	268	return sprintf(buf, "%d\n", priv->fifo_starve_off);
	269	}
	270
4409d281 KG	271	static ssize_t gfar_set_fifo_starve_off(struct device *dev,
	272	struct device_attribute *attr,
	273	const char *buf, size_t count)
7f7f5316	274	{
4409d281	275	struct gfar_private *priv = netdev_priv(to_net_dev(dev));
7f7f5316 AF	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
fef6108d	283	spin_lock_irqsave(&priv->txlock, flags);
7f7f5316 AF	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
fef6108d	292	spin_unlock_irqrestore(&priv->txlock, flags);
7f7f5316 AF	293
	294	return count;
	295	}
	296
b2f66d18 AV	297	static DEVICE_ATTR(fifo_starve_off, 0644, gfar_show_fifo_starve_off,
b2f66d18 AV	298	gfar_set_fifo_starve_off);
35a84fdc	299
7f7f5316 AF	300	void gfar_init_sysfs(struct net_device *dev)
	301	{
	302	struct gfar_private *priv = netdev_priv(dev);
35a84fdc	303	int rc;
7f7f5316 AF	304
7f7f5316 AF	305	/* Initialize the default values */
7f7f5316 AF	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;
7f7f5316 AF	309
7f7f5316 AF	310	/* Create our sysfs files */
35a84fdc GL	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");
7f7f5316	319	}