[deliverable/linux.git] / drivers / net / wireless / libertas / ethtool.c

#include <linux/netdevice.h>
#include <linux/ethtool.h>
#include <linux/delay.h>

#include "host.h"
#include "decl.h"
#include "defs.h"
#include "dev.h"
#include "join.h"
#include "wext.h"
static const char * mesh_stat_strings[]= {
			"drop_duplicate_bcast",
			"drop_ttl_zero",
			"drop_no_fwd_route",
			"drop_no_buffers",
			"fwded_unicast_cnt",
			"fwded_bcast_cnt",
			"drop_blind_table",
			"tx_failed_cnt"
};

static void libertas_ethtool_get_drvinfo(struct net_device *dev,
					 struct ethtool_drvinfo *info)
{
	wlan_private *priv = (wlan_private *) dev->priv;
	char fwver[32];

	libertas_get_fwversion(priv->adapter, fwver, sizeof(fwver) - 1);

	strcpy(info->driver, "libertas");
	strcpy(info->version, libertas_driver_version);
	strcpy(info->fw_version, fwver);
}

/* All 8388 parts have 16KiB EEPROM size at the time of writing.
 * In case that changes this needs fixing.
 */
#define LIBERTAS_EEPROM_LEN 16384

static int libertas_ethtool_get_eeprom_len(struct net_device *dev)
{
	return LIBERTAS_EEPROM_LEN;
}

static int libertas_ethtool_get_eeprom(struct net_device *dev,
                                  struct ethtool_eeprom *eeprom, u8 * bytes)
{
	wlan_private *priv = (wlan_private *) dev->priv;
	wlan_adapter *adapter = priv->adapter;
	struct wlan_ioctl_regrdwr regctrl;
	char *ptr;
	int ret;

	regctrl.action = 0;
	regctrl.offset = eeprom->offset;
	regctrl.NOB = eeprom->len;

	if (eeprom->offset + eeprom->len > LIBERTAS_EEPROM_LEN)
		return -EINVAL;

//      mutex_lock(&priv->mutex);

	adapter->prdeeprom =
		    (char *)kmalloc(eeprom->len+sizeof(regctrl), GFP_KERNEL);
	if (!adapter->prdeeprom)
		return -ENOMEM;
	memcpy(adapter->prdeeprom, &regctrl, sizeof(regctrl));

	/* +14 is for action, offset, and NOB in
	 * response */
	lbs_deb_ethtool("action:%d offset: %x NOB: %02x\n",
	       regctrl.action, regctrl.offset, regctrl.NOB);

	ret = libertas_prepare_and_send_command(priv,
				    cmd_802_11_eeprom_access,
				    regctrl.action,
				    cmd_option_waitforrsp, 0,
				    &regctrl);

	if (ret) {
		if (adapter->prdeeprom)
			kfree(adapter->prdeeprom);
		goto done;
	}

	mdelay(10);

	ptr = (char *)adapter->prdeeprom;

	/* skip the command header, but include the "value" u32 variable */
	ptr = ptr + sizeof(struct wlan_ioctl_regrdwr) - 4;

	/*
	 * Return the result back to the user
	 */
	memcpy(bytes, ptr, eeprom->len);

	if (adapter->prdeeprom)
		kfree(adapter->prdeeprom);
//	mutex_unlock(&priv->mutex);

	ret = 0;

done:
	lbs_deb_enter_args(LBS_DEB_ETHTOOL, "ret %d", ret);
        return ret;
}

static void libertas_ethtool_get_stats(struct net_device * dev,
				struct ethtool_stats * stats, u64 * data)
{
	wlan_private *priv = dev->priv;

	lbs_deb_enter(LBS_DEB_ETHTOOL);

	stats->cmd = ETHTOOL_GSTATS;
	BUG_ON(stats->n_stats != MESH_STATS_NUM);

        data[0] = priv->mstats.fwd_drop_rbt;
        data[1] = priv->mstats.fwd_drop_ttl;
        data[2] = priv->mstats.fwd_drop_noroute;
        data[3] = priv->mstats.fwd_drop_nobuf;
        data[4] = priv->mstats.fwd_unicast_cnt;
        data[5] = priv->mstats.fwd_bcast_cnt;
        data[6] = priv->mstats.drop_blind;
        data[7] = priv->mstats.tx_failed_cnt;

	lbs_deb_enter(LBS_DEB_ETHTOOL);
}

static int libertas_ethtool_get_stats_count(struct net_device * dev)
{
	int ret;
	wlan_private *priv = dev->priv;
	struct cmd_ds_mesh_access mesh_access;

	lbs_deb_enter(LBS_DEB_ETHTOOL);

	/* Get Mesh Statistics */
	ret = libertas_prepare_and_send_command(priv,
			cmd_mesh_access, cmd_act_mesh_get_stats,
			cmd_option_waitforrsp, 0, &mesh_access);

	if (ret) {
		ret = 0;
		goto done;
	}

        priv->mstats.fwd_drop_rbt = le32_to_cpu(mesh_access.data[0]);
        priv->mstats.fwd_drop_ttl = le32_to_cpu(mesh_access.data[1]);
        priv->mstats.fwd_drop_noroute = le32_to_cpu(mesh_access.data[2]);
        priv->mstats.fwd_drop_nobuf = le32_to_cpu(mesh_access.data[3]);
        priv->mstats.fwd_unicast_cnt = le32_to_cpu(mesh_access.data[4]);
        priv->mstats.fwd_bcast_cnt = le32_to_cpu(mesh_access.data[5]);
        priv->mstats.drop_blind = le32_to_cpu(mesh_access.data[6]);
        priv->mstats.tx_failed_cnt = le32_to_cpu(mesh_access.data[7]);

	ret = MESH_STATS_NUM;

done:
	lbs_deb_enter_args(LBS_DEB_ETHTOOL, "ret %d", ret);
	return ret;
}

static void libertas_ethtool_get_strings (struct net_device * dev,
					  u32 stringset,
					  u8 * s)
{
	int i;

	lbs_deb_enter(LBS_DEB_ETHTOOL);

	switch (stringset) {
        case ETH_SS_STATS:
		for (i=0; i < MESH_STATS_NUM; i++) {
			memcpy(s + i * ETH_GSTRING_LEN,
					mesh_stat_strings[i],
					ETH_GSTRING_LEN);
		}
		break;
        }
	lbs_deb_enter(LBS_DEB_ETHTOOL);
}

struct ethtool_ops libertas_ethtool_ops = {
	.get_drvinfo = libertas_ethtool_get_drvinfo,
	.get_eeprom =  libertas_ethtool_get_eeprom,
	.get_eeprom_len = libertas_ethtool_get_eeprom_len,
	.get_stats_count = libertas_ethtool_get_stats_count,
	.get_ethtool_stats = libertas_ethtool_get_stats,
	.get_strings = libertas_ethtool_get_strings,
};
Commit	Line	Data
876c9d3a MT	1	#include <linux/netdevice.h>
	2	#include <linux/ethtool.h>
	3	#include <linux/delay.h>
	4
	5	#include "host.h"
876c9d3a MT	6	#include "decl.h"
	7	#include "defs.h"
	8	#include "dev.h"
	9	#include "join.h"
	10	#include "wext.h"
	11	static const char * mesh_stat_strings[]= {
	12	"drop_duplicate_bcast",
	13	"drop_ttl_zero",
	14	"drop_no_fwd_route",
	15	"drop_no_buffers",
	16	"fwded_unicast_cnt",
	17	"fwded_bcast_cnt",
0601e7ee JC	18	"drop_blind_table",
0601e7ee JC	19	"tx_failed_cnt"
876c9d3a MT	20	};
	21
	22	static void libertas_ethtool_get_drvinfo(struct net_device *dev,
	23	struct ethtool_drvinfo *info)
	24	{
	25	wlan_private priv = (wlan_private ) dev->priv;
	26	char fwver[32];
	27
	28	libertas_get_fwversion(priv->adapter, fwver, sizeof(fwver) - 1);
	29
	30	strcpy(info->driver, "libertas");
	31	strcpy(info->version, libertas_driver_version);
	32	strcpy(info->fw_version, fwver);
	33	}
	34
	35	/* All 8388 parts have 16KiB EEPROM size at the time of writing.
	36	* In case that changes this needs fixing.
	37	*/
	38	#define LIBERTAS_EEPROM_LEN 16384
	39
	40	static int libertas_ethtool_get_eeprom_len(struct net_device *dev)
	41	{
	42	return LIBERTAS_EEPROM_LEN;
	43	}
	44
	45	static int libertas_ethtool_get_eeprom(struct net_device *dev,
	46	struct ethtool_eeprom eeprom, u8 bytes)
	47	{
	48	wlan_private priv = (wlan_private ) dev->priv;
	49	wlan_adapter *adapter = priv->adapter;
	50	struct wlan_ioctl_regrdwr regctrl;
	51	char *ptr;
	52	int ret;
	53
	54	regctrl.action = 0;
	55	regctrl.offset = eeprom->offset;
	56	regctrl.NOB = eeprom->len;
	57
	58	if (eeprom->offset + eeprom->len > LIBERTAS_EEPROM_LEN)
	59	return -EINVAL;
	60
	61	// mutex_lock(&priv->mutex);
	62
	63	adapter->prdeeprom =
	64	(char *)kmalloc(eeprom->len+sizeof(regctrl), GFP_KERNEL);
	65	if (!adapter->prdeeprom)
	66	return -ENOMEM;
	67	memcpy(adapter->prdeeprom, &regctrl, sizeof(regctrl));
	68
	69	/* +14 is for action, offset, and NOB in
	70	* response */
9012b28a	71	lbs_deb_ethtool("action:%d offset: %x NOB: %02x\n",
876c9d3a MT	72	regctrl.action, regctrl.offset, regctrl.NOB);
	73
	74	ret = libertas_prepare_and_send_command(priv,
	75	cmd_802_11_eeprom_access,
	76	regctrl.action,
	77	cmd_option_waitforrsp, 0,
	78	&regctrl);
	79
	80	if (ret) {
	81	if (adapter->prdeeprom)
	82	kfree(adapter->prdeeprom);
9012b28a	83	goto done;
876c9d3a MT	84	}
	85
	86	mdelay(10);
	87
	88	ptr = (char *)adapter->prdeeprom;
	89
	90	/* skip the command header, but include the "value" u32 variable */
	91	ptr = ptr + sizeof(struct wlan_ioctl_regrdwr) - 4;
	92
	93	/*
	94	* Return the result back to the user
	95	*/
	96	memcpy(bytes, ptr, eeprom->len);
	97
	98	if (adapter->prdeeprom)
	99	kfree(adapter->prdeeprom);
	100	// mutex_unlock(&priv->mutex);
	101
9012b28a HS	102	ret = 0;
	103
	104	done:
	105	lbs_deb_enter_args(LBS_DEB_ETHTOOL, "ret %d", ret);
	106	return ret;
876c9d3a MT	107	}
	108
	109	static void libertas_ethtool_get_stats(struct net_device * dev,
	110	struct ethtool_stats * stats, u64 * data)
	111	{
	112	wlan_private *priv = dev->priv;
	113
9012b28a	114	lbs_deb_enter(LBS_DEB_ETHTOOL);
876c9d3a MT	115
	116	stats->cmd = ETHTOOL_GSTATS;
	117	BUG_ON(stats->n_stats != MESH_STATS_NUM);
	118
	119	data[0] = priv->mstats.fwd_drop_rbt;
	120	data[1] = priv->mstats.fwd_drop_ttl;
	121	data[2] = priv->mstats.fwd_drop_noroute;
	122	data[3] = priv->mstats.fwd_drop_nobuf;
	123	data[4] = priv->mstats.fwd_unicast_cnt;
	124	data[5] = priv->mstats.fwd_bcast_cnt;
	125	data[6] = priv->mstats.drop_blind;
0601e7ee	126	data[7] = priv->mstats.tx_failed_cnt;
876c9d3a	127
9012b28a	128	lbs_deb_enter(LBS_DEB_ETHTOOL);
876c9d3a MT	129	}
	130
	131	static int libertas_ethtool_get_stats_count(struct net_device * dev)
	132	{
	133	int ret;
	134	wlan_private *priv = dev->priv;
	135	struct cmd_ds_mesh_access mesh_access;
	136
9012b28a HS	137	lbs_deb_enter(LBS_DEB_ETHTOOL);
9012b28a HS	138
876c9d3a MT	139	/* Get Mesh Statistics */
	140	ret = libertas_prepare_and_send_command(priv,
	141	cmd_mesh_access, cmd_act_mesh_get_stats,
	142	cmd_option_waitforrsp, 0, &mesh_access);
	143
	144	if (ret) {
9012b28a HS	145	ret = 0;
9012b28a HS	146	goto done;
876c9d3a MT	147	}
876c9d3a MT	148
981f187b DW	149	priv->mstats.fwd_drop_rbt = le32_to_cpu(mesh_access.data[0]);
	150	priv->mstats.fwd_drop_ttl = le32_to_cpu(mesh_access.data[1]);
	151	priv->mstats.fwd_drop_noroute = le32_to_cpu(mesh_access.data[2]);
	152	priv->mstats.fwd_drop_nobuf = le32_to_cpu(mesh_access.data[3]);
	153	priv->mstats.fwd_unicast_cnt = le32_to_cpu(mesh_access.data[4]);
	154	priv->mstats.fwd_bcast_cnt = le32_to_cpu(mesh_access.data[5]);
	155	priv->mstats.drop_blind = le32_to_cpu(mesh_access.data[6]);
	156	priv->mstats.tx_failed_cnt = le32_to_cpu(mesh_access.data[7]);
876c9d3a	157
9012b28a HS	158	ret = MESH_STATS_NUM;
	159
	160	done:
	161	lbs_deb_enter_args(LBS_DEB_ETHTOOL, "ret %d", ret);
	162	return ret;
876c9d3a MT	163	}
	164
	165	static void libertas_ethtool_get_strings (struct net_device * dev,
	166	u32 stringset,
	167	u8 * s)
	168	{
	169	int i;
	170
9012b28a HS	171	lbs_deb_enter(LBS_DEB_ETHTOOL);
9012b28a HS	172
876c9d3a MT	173	switch (stringset) {
	174	case ETH_SS_STATS:
	175	for (i=0; i < MESH_STATS_NUM; i++) {
	176	memcpy(s + i * ETH_GSTRING_LEN,
	177	mesh_stat_strings[i],
	178	ETH_GSTRING_LEN);
	179	}
	180	break;
	181	}
9012b28a	182	lbs_deb_enter(LBS_DEB_ETHTOOL);
876c9d3a MT	183	}
	184
	185	struct ethtool_ops libertas_ethtool_ops = {
	186	.get_drvinfo = libertas_ethtool_get_drvinfo,
	187	.get_eeprom = libertas_ethtool_get_eeprom,
	188	.get_eeprom_len = libertas_ethtool_get_eeprom_len,
	189	.get_stats_count = libertas_ethtool_get_stats_count,
	190	.get_ethtool_stats = libertas_ethtool_get_stats,
	191	.get_strings = libertas_ethtool_get_strings,
	192	};
	193