[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / net / mac80211 / debugfs_sta.c

/*
 * Copyright 2003-2005	Devicescape Software, Inc.
 * Copyright (c) 2006	Jiri Benc <jbenc@suse.cz>
 * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/debugfs.h>
#include <linux/ieee80211.h>
#include "ieee80211_i.h"
#include "debugfs.h"
#include "debugfs_sta.h"
#include "sta_info.h"

/* sta attributtes */

#define STA_READ(name, buflen, field, format_string)			\
static ssize_t sta_ ##name## _read(struct file *file,			\
				   char __user *userbuf,		\
				   size_t count, loff_t *ppos)		\
{									\
	int res;							\
	struct sta_info *sta = file->private_data;			\
	char buf[buflen];						\
	res = scnprintf(buf, buflen, format_string, sta->field);	\
	return simple_read_from_buffer(userbuf, count, ppos, buf, res);	\
}
#define STA_READ_D(name, field) STA_READ(name, 20, field, "%d\n")
#define STA_READ_U(name, field) STA_READ(name, 20, field, "%u\n")
#define STA_READ_LU(name, field) STA_READ(name, 20, field, "%lu\n")
#define STA_READ_S(name, field) STA_READ(name, 20, field, "%s\n")

#define STA_OPS(name)							\
static const struct file_operations sta_ ##name## _ops = {		\
	.read = sta_##name##_read,					\
	.open = mac80211_open_file_generic,				\
}

#define STA_OPS_WR(name)						\
static const struct file_operations sta_ ##name## _ops = {		\
	.read = sta_##name##_read,					\
	.write = sta_##name##_write,					\
	.open = mac80211_open_file_generic,				\
}

#define STA_FILE(name, field, format)					\
		STA_READ_##format(name, field)				\
		STA_OPS(name)

STA_FILE(aid, aid, D);
STA_FILE(dev, dev->name, S);
STA_FILE(rx_packets, rx_packets, LU);
STA_FILE(tx_packets, tx_packets, LU);
STA_FILE(rx_bytes, rx_bytes, LU);
STA_FILE(tx_bytes, tx_bytes, LU);
STA_FILE(rx_duplicates, num_duplicates, LU);
STA_FILE(rx_fragments, rx_fragments, LU);
STA_FILE(rx_dropped, rx_dropped, LU);
STA_FILE(tx_fragments, tx_fragments, LU);
STA_FILE(tx_filtered, tx_filtered_count, LU);
STA_FILE(tx_retry_failed, tx_retry_failed, LU);
STA_FILE(tx_retry_count, tx_retry_count, LU);
STA_FILE(last_rssi, last_rssi, D);
STA_FILE(last_signal, last_signal, D);
STA_FILE(last_noise, last_noise, D);
STA_FILE(channel_use, channel_use, D);
STA_FILE(wep_weak_iv_count, wep_weak_iv_count, D);

static ssize_t sta_flags_read(struct file *file, char __user *userbuf,
			      size_t count, loff_t *ppos)
{
	char buf[100];
	struct sta_info *sta = file->private_data;
	int res = scnprintf(buf, sizeof(buf), "%s%s%s%s%s%s%s%s%s",
		sta->flags & WLAN_STA_AUTH ? "AUTH\n" : "",
		sta->flags & WLAN_STA_ASSOC ? "ASSOC\n" : "",
		sta->flags & WLAN_STA_PS ? "PS\n" : "",
		sta->flags & WLAN_STA_TIM ? "TIM\n" : "",
		sta->flags & WLAN_STA_PERM ? "PERM\n" : "",
		sta->flags & WLAN_STA_AUTHORIZED ? "AUTHORIZED\n" : "",
		sta->flags & WLAN_STA_SHORT_PREAMBLE ? "SHORT PREAMBLE\n" : "",
		sta->flags & WLAN_STA_WME ? "WME\n" : "",
		sta->flags & WLAN_STA_WDS ? "WDS\n" : "");
	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
}
STA_OPS(flags);

static ssize_t sta_num_ps_buf_frames_read(struct file *file,
					  char __user *userbuf,
					  size_t count, loff_t *ppos)
{
	char buf[20];
	struct sta_info *sta = file->private_data;
	int res = scnprintf(buf, sizeof(buf), "%u\n",
			    skb_queue_len(&sta->ps_tx_buf));
	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
}
STA_OPS(num_ps_buf_frames);

static ssize_t sta_last_ack_rssi_read(struct file *file, char __user *userbuf,
				      size_t count, loff_t *ppos)
{
	char buf[100];
	struct sta_info *sta = file->private_data;
	int res = scnprintf(buf, sizeof(buf), "%d %d %d\n",
			    sta->last_ack_rssi[0],
			    sta->last_ack_rssi[1],
			    sta->last_ack_rssi[2]);
	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
}
STA_OPS(last_ack_rssi);

static ssize_t sta_last_ack_ms_read(struct file *file, char __user *userbuf,
				    size_t count, loff_t *ppos)
{
	char buf[20];
	struct sta_info *sta = file->private_data;
	int res = scnprintf(buf, sizeof(buf), "%d\n",
			    sta->last_ack ?
			    jiffies_to_msecs(jiffies - sta->last_ack) : -1);
	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
}
STA_OPS(last_ack_ms);

static ssize_t sta_inactive_ms_read(struct file *file, char __user *userbuf,
				    size_t count, loff_t *ppos)
{
	char buf[20];
	struct sta_info *sta = file->private_data;
	int res = scnprintf(buf, sizeof(buf), "%d\n",
			    jiffies_to_msecs(jiffies - sta->last_rx));
	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
}
STA_OPS(inactive_ms);

static ssize_t sta_last_seq_ctrl_read(struct file *file, char __user *userbuf,
				      size_t count, loff_t *ppos)
{
	char buf[15*NUM_RX_DATA_QUEUES], *p = buf;
	int i;
	struct sta_info *sta = file->private_data;
	for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%x ",
			       le16_to_cpu(sta->last_seq_ctrl[i]));
	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
}
STA_OPS(last_seq_ctrl);

#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
static ssize_t sta_wme_rx_queue_read(struct file *file, char __user *userbuf,
				     size_t count, loff_t *ppos)
{
	char buf[15*NUM_RX_DATA_QUEUES], *p = buf;
	int i;
	struct sta_info *sta = file->private_data;
	for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%u ",
			       sta->wme_rx_queue[i]);
	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
}
STA_OPS(wme_rx_queue);

static ssize_t sta_wme_tx_queue_read(struct file *file, char __user *userbuf,
				     size_t count, loff_t *ppos)
{
	char buf[15*NUM_TX_DATA_QUEUES], *p = buf;
	int i;
	struct sta_info *sta = file->private_data;
	for (i = 0; i < NUM_TX_DATA_QUEUES; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%u ",
			       sta->wme_tx_queue[i]);
	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
}
STA_OPS(wme_tx_queue);
#endif

static ssize_t sta_agg_status_read(struct file *file, char __user *userbuf,
					size_t count, loff_t *ppos)
{
	char buf[768], *p = buf;
	int i;
	struct sta_info *sta = file->private_data;
	p += scnprintf(p, sizeof(buf)+buf-p, "Agg state for STA is:\n");
	p += scnprintf(p, sizeof(buf)+buf-p, " STA next dialog_token is %d \n "
			"TIDs info is: \n TID :",
			(sta->ampdu_mlme.dialog_token_allocator + 1));
	for (i = 0; i < STA_TID_NUM; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%5d", i);

	p += scnprintf(p, sizeof(buf)+buf-p, "\n RX  :");
	for (i = 0; i < STA_TID_NUM; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
	sta->ampdu_mlme.tid_rx[i].state);

	p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:");
	for (i = 0; i < STA_TID_NUM; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
			sta->ampdu_mlme.tid_rx[i].dialog_token);

	p += scnprintf(p, sizeof(buf)+buf-p, "\n TX  :");
	for (i = 0; i < STA_TID_NUM; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
			sta->ampdu_mlme.tid_tx[i].state);

	p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:");
	for (i = 0; i < STA_TID_NUM; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
			sta->ampdu_mlme.tid_tx[i].dialog_token);

	p += scnprintf(p, sizeof(buf)+buf-p, "\n SSN :");
	for (i = 0; i < STA_TID_NUM; i++)
		p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
			sta->ampdu_mlme.tid_tx[i].ssn);

	p += scnprintf(p, sizeof(buf)+buf-p, "\n");

	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
}

static ssize_t sta_agg_status_write(struct file *file,
		const char __user *user_buf, size_t count, loff_t *ppos)
{
	struct sta_info *sta = file->private_data;
	struct net_device *dev = sta->dev;
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct ieee80211_hw *hw = &local->hw;
	u8 *da = sta->addr;
	static int tid_static_tx[16] = {0, 0, 0, 0, 0, 0, 0, 0,
					0, 0, 0, 0, 0, 0, 0, 0};
	static int tid_static_rx[16] = {1, 1, 1, 1, 1, 1, 1, 1,
					1, 1, 1, 1, 1, 1, 1, 1};
	char *endp;
	char buf[32];
	int buf_size, rs;
	unsigned int tid_num;
	char state[4];

	memset(buf, 0x00, sizeof(buf));
	buf_size = min(count, (sizeof(buf)-1));
	if (copy_from_user(buf, user_buf, buf_size))
		return -EFAULT;

	tid_num = simple_strtoul(buf, &endp, 0);
	if (endp == buf)
		return -EINVAL;

	if ((tid_num >= 100) && (tid_num <= 115)) {
		/* toggle Rx aggregation command */
		tid_num = tid_num - 100;
		if (tid_static_rx[tid_num] == 1) {
			strcpy(state, "off ");
			ieee80211_sta_stop_rx_ba_session(dev, da, tid_num, 0,
					WLAN_REASON_QSTA_REQUIRE_SETUP);
			sta->ampdu_mlme.tid_rx[tid_num].buf_size = 0xFF;
			tid_static_rx[tid_num] = 0;
		} else {
			strcpy(state, "on ");
			sta->ampdu_mlme.tid_rx[tid_num].buf_size = 0x00;
			tid_static_rx[tid_num] = 1;
		}
		printk(KERN_DEBUG "debugfs - try switching tid %u %s\n",
				tid_num, state);
	} else if ((tid_num >= 0) && (tid_num <= 15)) {
		/* toggle Tx aggregation command */
		if (tid_static_tx[tid_num] == 0) {
			strcpy(state, "on ");
			rs =  ieee80211_start_tx_ba_session(hw, da, tid_num);
			if (rs == 0)
				tid_static_tx[tid_num] = 1;
		} else {
			strcpy(state, "off");
			rs =  ieee80211_stop_tx_ba_session(hw, da, tid_num, 1);
			if (rs == 0)
				tid_static_tx[tid_num] = 0;
		}
		printk(KERN_DEBUG "debugfs - switching tid %u %s, return=%d\n",
				tid_num, state, rs);
	}

	return count;
}
STA_OPS_WR(agg_status);

#define DEBUGFS_ADD(name) \
	sta->debugfs.name = debugfs_create_file(#name, 0444, \
		sta->debugfs.dir, sta, &sta_ ##name## _ops);

#define DEBUGFS_DEL(name) \
	debugfs_remove(sta->debugfs.name);\
	sta->debugfs.name = NULL;


void ieee80211_sta_debugfs_add(struct sta_info *sta)
{
	struct dentry *stations_dir = sta->local->debugfs.stations;
	DECLARE_MAC_BUF(mac);

	if (!stations_dir)
		return;

	print_mac(mac, sta->addr);

	sta->debugfs.dir = debugfs_create_dir(mac, stations_dir);
	if (!sta->debugfs.dir)
		return;

	DEBUGFS_ADD(flags);
	DEBUGFS_ADD(num_ps_buf_frames);
	DEBUGFS_ADD(last_ack_rssi);
	DEBUGFS_ADD(last_ack_ms);
	DEBUGFS_ADD(inactive_ms);
	DEBUGFS_ADD(last_seq_ctrl);
#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	DEBUGFS_ADD(wme_rx_queue);
	DEBUGFS_ADD(wme_tx_queue);
#endif
	DEBUGFS_ADD(agg_status);
}

void ieee80211_sta_debugfs_remove(struct sta_info *sta)
{
	DEBUGFS_DEL(flags);
	DEBUGFS_DEL(num_ps_buf_frames);
	DEBUGFS_DEL(last_ack_rssi);
	DEBUGFS_DEL(last_ack_ms);
	DEBUGFS_DEL(inactive_ms);
	DEBUGFS_DEL(last_seq_ctrl);
#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	DEBUGFS_DEL(wme_rx_queue);
	DEBUGFS_DEL(wme_tx_queue);
#endif
	DEBUGFS_DEL(agg_status);

	debugfs_remove(sta->debugfs.dir);
	sta->debugfs.dir = NULL;
}
Commit	Line	Data
e9f207f0 JB	1	/*
	2	* Copyright 2003-2005 Devicescape Software, Inc.
	3	* Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
	4	* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	#include <linux/debugfs.h>
	12	#include <linux/ieee80211.h>
	13	#include "ieee80211_i.h"
	14	#include "debugfs.h"
	15	#include "debugfs_sta.h"
	16	#include "sta_info.h"
	17
	18	/* sta attributtes */
	19
	20	#define STA_READ(name, buflen, field, format_string) \
	21	static ssize_t sta_ ##name## _read(struct file *file, \
	22	char __user *userbuf, \
	23	size_t count, loff_t *ppos) \
	24	{ \
	25	int res; \
	26	struct sta_info *sta = file->private_data; \
	27	char buf[buflen]; \
	28	res = scnprintf(buf, buflen, format_string, sta->field); \
	29	return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
	30	}
	31	#define STA_READ_D(name, field) STA_READ(name, 20, field, "%d\n")
	32	#define STA_READ_U(name, field) STA_READ(name, 20, field, "%u\n")
	33	#define STA_READ_LU(name, field) STA_READ(name, 20, field, "%lu\n")
	34	#define STA_READ_S(name, field) STA_READ(name, 20, field, "%s\n")
	35
e9f207f0 JB	36	#define STA_OPS(name) \
	37	static const struct file_operations sta_ ##name## _ops = { \
	38	.read = sta_##name##_read, \
	39	.open = mac80211_open_file_generic, \
	40	}
	41
eb2ba62e RR	42	#define STA_OPS_WR(name) \
	43	static const struct file_operations sta_ ##name## _ops = { \
	44	.read = sta_##name##_read, \
	45	.write = sta_##name##_write, \
	46	.open = mac80211_open_file_generic, \
	47	}
	48
e9f207f0 JB	49	#define STA_FILE(name, field, format) \
	50	STA_READ_##format(name, field) \
	51	STA_OPS(name)
	52
	53	STA_FILE(aid, aid, D);
e9f207f0	54	STA_FILE(dev, dev->name, S);
e9f207f0 JB	55	STA_FILE(rx_packets, rx_packets, LU);
	56	STA_FILE(tx_packets, tx_packets, LU);
	57	STA_FILE(rx_bytes, rx_bytes, LU);
	58	STA_FILE(tx_bytes, tx_bytes, LU);
	59	STA_FILE(rx_duplicates, num_duplicates, LU);
	60	STA_FILE(rx_fragments, rx_fragments, LU);
	61	STA_FILE(rx_dropped, rx_dropped, LU);
	62	STA_FILE(tx_fragments, tx_fragments, LU);
	63	STA_FILE(tx_filtered, tx_filtered_count, LU);
e9f207f0 JB	64	STA_FILE(tx_retry_failed, tx_retry_failed, LU);
	65	STA_FILE(tx_retry_count, tx_retry_count, LU);
	66	STA_FILE(last_rssi, last_rssi, D);
	67	STA_FILE(last_signal, last_signal, D);
	68	STA_FILE(last_noise, last_noise, D);
	69	STA_FILE(channel_use, channel_use, D);
	70	STA_FILE(wep_weak_iv_count, wep_weak_iv_count, D);
	71
	72	static ssize_t sta_flags_read(struct file file, char __user userbuf,
	73	size_t count, loff_t *ppos)
	74	{
	75	char buf[100];
	76	struct sta_info *sta = file->private_data;
	77	int res = scnprintf(buf, sizeof(buf), "%s%s%s%s%s%s%s%s%s",
	78	sta->flags & WLAN_STA_AUTH ? "AUTH\n" : "",
	79	sta->flags & WLAN_STA_ASSOC ? "ASSOC\n" : "",
	80	sta->flags & WLAN_STA_PS ? "PS\n" : "",
	81	sta->flags & WLAN_STA_TIM ? "TIM\n" : "",
	82	sta->flags & WLAN_STA_PERM ? "PERM\n" : "",
	83	sta->flags & WLAN_STA_AUTHORIZED ? "AUTHORIZED\n" : "",
	84	sta->flags & WLAN_STA_SHORT_PREAMBLE ? "SHORT PREAMBLE\n" : "",
	85	sta->flags & WLAN_STA_WME ? "WME\n" : "",
	86	sta->flags & WLAN_STA_WDS ? "WDS\n" : "");
	87	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
	88	}
	89	STA_OPS(flags);
	90
	91	static ssize_t sta_num_ps_buf_frames_read(struct file *file,
	92	char __user *userbuf,
	93	size_t count, loff_t *ppos)
	94	{
	95	char buf[20];
	96	struct sta_info *sta = file->private_data;
	97	int res = scnprintf(buf, sizeof(buf), "%u\n",
	98	skb_queue_len(&sta->ps_tx_buf));
	99	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
	100	}
	101	STA_OPS(num_ps_buf_frames);
	102
	103	static ssize_t sta_last_ack_rssi_read(struct file file, char __user userbuf,
	104	size_t count, loff_t *ppos)
	105	{
	106	char buf[100];
	107	struct sta_info *sta = file->private_data;
	108	int res = scnprintf(buf, sizeof(buf), "%d %d %d\n",
	109	sta->last_ack_rssi[0],
	110	sta->last_ack_rssi[1],
	111	sta->last_ack_rssi[2]);
	112	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
	113	}
	114	STA_OPS(last_ack_rssi);
	115
	116	static ssize_t sta_last_ack_ms_read(struct file file, char __user userbuf,
	117	size_t count, loff_t *ppos)
	118	{
	119	char buf[20];
	120	struct sta_info *sta = file->private_data;
	121	int res = scnprintf(buf, sizeof(buf), "%d\n",
	122	sta->last_ack ?
	123	jiffies_to_msecs(jiffies - sta->last_ack) : -1);
	124	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
	125	}
	126	STA_OPS(last_ack_ms);
	127
128	static ssize_t sta_inactive_ms_read(struct file file, char __user userbuf,
129	size_t count, loff_t *ppos)
130	{
131	char buf[20];
132	struct sta_info *sta = file->private_data;
133	int res = scnprintf(buf, sizeof(buf), "%d\n",
134	jiffies_to_msecs(jiffies - sta->last_rx));
135	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
136	}
137	STA_OPS(inactive_ms);
138
139	static ssize_t sta_last_seq_ctrl_read(struct file file, char __user userbuf,
140	size_t count, loff_t *ppos)
141	{
142	char buf[15NUM_RX_DATA_QUEUES], p = buf;
143	int i;
144	struct sta_info *sta = file->private_data;
145	for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
146	p += scnprintf(p, sizeof(buf)+buf-p, "%x ",
ba9b07d0	147	le16_to_cpu(sta->last_seq_ctrl[i]));
e9f207f0 JB	148	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
	149	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	150	}
	151	STA_OPS(last_seq_ctrl);
	152
	153	#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	154	static ssize_t sta_wme_rx_queue_read(struct file file, char __user userbuf,
	155	size_t count, loff_t *ppos)
	156	{
	157	char buf[15NUM_RX_DATA_QUEUES], p = buf;
	158	int i;
	159	struct sta_info *sta = file->private_data;
	160	for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
	161	p += scnprintf(p, sizeof(buf)+buf-p, "%u ",
	162	sta->wme_rx_queue[i]);
	163	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
	164	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	165	}
	166	STA_OPS(wme_rx_queue);
	167
	168	static ssize_t sta_wme_tx_queue_read(struct file file, char __user userbuf,
	169	size_t count, loff_t *ppos)
	170	{
	171	char buf[15NUM_TX_DATA_QUEUES], p = buf;
	172	int i;
	173	struct sta_info *sta = file->private_data;
	174	for (i = 0; i < NUM_TX_DATA_QUEUES; i++)
	175	p += scnprintf(p, sizeof(buf)+buf-p, "%u ",
	176	sta->wme_tx_queue[i]);
	177	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
	178	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	179	}
	180	STA_OPS(wme_tx_queue);
	181	#endif
	182
eb2ba62e RR	183	static ssize_t sta_agg_status_read(struct file file, char __user userbuf,
	184	size_t count, loff_t *ppos)
	185	{
	186	char buf[768], *p = buf;
	187	int i;
	188	struct sta_info *sta = file->private_data;
	189	p += scnprintf(p, sizeof(buf)+buf-p, "Agg state for STA is:\n");
	190	p += scnprintf(p, sizeof(buf)+buf-p, " STA next dialog_token is %d \n "
	191	"TIDs info is: \n TID :",
	192	(sta->ampdu_mlme.dialog_token_allocator + 1));
	193	for (i = 0; i < STA_TID_NUM; i++)
	194	p += scnprintf(p, sizeof(buf)+buf-p, "%5d", i);
	195
	196	p += scnprintf(p, sizeof(buf)+buf-p, "\n RX :");
	197	for (i = 0; i < STA_TID_NUM; i++)
	198	p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
	199	sta->ampdu_mlme.tid_rx[i].state);
	200
	201	p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:");
	202	for (i = 0; i < STA_TID_NUM; i++)
	203	p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
	204	sta->ampdu_mlme.tid_rx[i].dialog_token);
	205
	206	p += scnprintf(p, sizeof(buf)+buf-p, "\n TX :");
	207	for (i = 0; i < STA_TID_NUM; i++)
	208	p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
	209	sta->ampdu_mlme.tid_tx[i].state);
	210
	211	p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:");
	212	for (i = 0; i < STA_TID_NUM; i++)
	213	p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
	214	sta->ampdu_mlme.tid_tx[i].dialog_token);
	215
	216	p += scnprintf(p, sizeof(buf)+buf-p, "\n SSN :");
	217	for (i = 0; i < STA_TID_NUM; i++)
	218	p += scnprintf(p, sizeof(buf)+buf-p, "%5d",
	219	sta->ampdu_mlme.tid_tx[i].ssn);
	220
	221	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
	222
	223	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
	224	}
	225
	226	static ssize_t sta_agg_status_write(struct file *file,
	227	const char __user user_buf, size_t count, loff_t ppos)
	228	{
	229	struct sta_info *sta = file->private_data;
	230	struct net_device *dev = sta->dev;
	231	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	232	struct ieee80211_hw *hw = &local->hw;
	233	u8 *da = sta->addr;
	234	static int tid_static_tx[16] = {0, 0, 0, 0, 0, 0, 0, 0,
	235	0, 0, 0, 0, 0, 0, 0, 0};
	236	static int tid_static_rx[16] = {1, 1, 1, 1, 1, 1, 1, 1,
	237	1, 1, 1, 1, 1, 1, 1, 1};
	238	char *endp;
	239	char buf[32];
	240	int buf_size, rs;
	241	unsigned int tid_num;
	242	char state[4];
	243
	244	memset(buf, 0x00, sizeof(buf));
	245	buf_size = min(count, (sizeof(buf)-1));
	246	if (copy_from_user(buf, user_buf, buf_size))
247	return -EFAULT;
248
249	tid_num = simple_strtoul(buf, &endp, 0);
250	if (endp == buf)
251	return -EINVAL;
252
253	if ((tid_num >= 100) && (tid_num <= 115)) {
254	/* toggle Rx aggregation command */
255	tid_num = tid_num - 100;
256	if (tid_static_rx[tid_num] == 1) {
257	strcpy(state, "off ");
258	ieee80211_sta_stop_rx_ba_session(dev, da, tid_num, 0,
259	WLAN_REASON_QSTA_REQUIRE_SETUP);
260	sta->ampdu_mlme.tid_rx[tid_num].buf_size = 0xFF;
261	tid_static_rx[tid_num] = 0;
262	} else {
263	strcpy(state, "on ");
264	sta->ampdu_mlme.tid_rx[tid_num].buf_size = 0x00;
265	tid_static_rx[tid_num] = 1;
266	}
267	printk(KERN_DEBUG "debugfs - try switching tid %u %s\n",
268	tid_num, state);
269	} else if ((tid_num >= 0) && (tid_num <= 15)) {
270	/* toggle Tx aggregation command */
271	if (tid_static_tx[tid_num] == 0) {
272	strcpy(state, "on ");
273	rs = ieee80211_start_tx_ba_session(hw, da, tid_num);
274	if (rs == 0)
275	tid_static_tx[tid_num] = 1;
276	} else {
277	strcpy(state, "off");
278	rs = ieee80211_stop_tx_ba_session(hw, da, tid_num, 1);
279	if (rs == 0)
280	tid_static_tx[tid_num] = 0;
281	}
282	printk(KERN_DEBUG "debugfs - switching tid %u %s, return=%d\n",
283	tid_num, state, rs);
284	}
285
286	return count;
287	}
288	STA_OPS_WR(agg_status);
289
e9f207f0 JB	290	#define DEBUGFS_ADD(name) \
	291	sta->debugfs.name = debugfs_create_file(#name, 0444, \
	292	sta->debugfs.dir, sta, &sta_ ##name## _ops);
	293
	294	#define DEBUGFS_DEL(name) \
	295	debugfs_remove(sta->debugfs.name);\
	296	sta->debugfs.name = NULL;
	297
	298
	299	void ieee80211_sta_debugfs_add(struct sta_info *sta)
	300	{
e9f207f0	301	struct dentry *stations_dir = sta->local->debugfs.stations;
0795af57	302	DECLARE_MAC_BUF(mac);
e9f207f0 JB	303
	304	if (!stations_dir)
	305	return;
	306
0795af57	307	print_mac(mac, sta->addr);
e9f207f0	308
0795af57	309	sta->debugfs.dir = debugfs_create_dir(mac, stations_dir);
e9f207f0 JB	310	if (!sta->debugfs.dir)
	311	return;
	312
	313	DEBUGFS_ADD(flags);
	314	DEBUGFS_ADD(num_ps_buf_frames);
	315	DEBUGFS_ADD(last_ack_rssi);
	316	DEBUGFS_ADD(last_ack_ms);
	317	DEBUGFS_ADD(inactive_ms);
	318	DEBUGFS_ADD(last_seq_ctrl);
	319	#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	320	DEBUGFS_ADD(wme_rx_queue);
	321	DEBUGFS_ADD(wme_tx_queue);
	322	#endif
eb2ba62e	323	DEBUGFS_ADD(agg_status);
e9f207f0 JB	324	}
	325
	326	void ieee80211_sta_debugfs_remove(struct sta_info *sta)
	327	{
	328	DEBUGFS_DEL(flags);
	329	DEBUGFS_DEL(num_ps_buf_frames);
	330	DEBUGFS_DEL(last_ack_rssi);
	331	DEBUGFS_DEL(last_ack_ms);
	332	DEBUGFS_DEL(inactive_ms);
	333	DEBUGFS_DEL(last_seq_ctrl);
	334	#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
	335	DEBUGFS_DEL(wme_rx_queue);
	336	DEBUGFS_DEL(wme_tx_queue);
	337	#endif
eb2ba62e	338	DEBUGFS_DEL(agg_status);
e9f207f0 JB	339
	340	debugfs_remove(sta->debugfs.dir);
	341	sta->debugfs.dir = NULL;
	342	}