[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / ath9k / debug.c

/*
 * Copyright (c) 2008 Atheros Communications Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "ath9k.h"

static unsigned int ath9k_debug = DBG_DEFAULT;
module_param_named(debug, ath9k_debug, uint, 0);

void DPRINTF(struct ath_softc *sc, int dbg_mask, const char *fmt, ...)
{
	if (!sc)
		return;

	if (sc->sc_debug.debug_mask & dbg_mask) {
		va_list args;

		va_start(args, fmt);
		printk(KERN_DEBUG "ath9k: ");
		vprintk(fmt, args);
		va_end(args);
	}
}

static int ath9k_debugfs_open(struct inode *inode, struct file *file)
{
	file->private_data = inode->i_private;
	return 0;
}

static ssize_t read_file_dma(struct file *file, char __user *user_buf,
			     size_t count, loff_t *ppos)
{
	struct ath_softc *sc = file->private_data;
	struct ath_hal *ah = sc->sc_ah;
	char buf[1024];
	unsigned int len = 0;
	u32 val[ATH9K_NUM_DMA_DEBUG_REGS];
	int i, qcuOffset = 0, dcuOffset = 0;
	u32 *qcuBase = &val[0], *dcuBase = &val[4];

	REG_WRITE(ah, AR_MACMISC,
		  ((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) |
		   (AR_MACMISC_MISC_OBS_BUS_1 <<
		    AR_MACMISC_MISC_OBS_BUS_MSB_S)));

	len += snprintf(buf + len, sizeof(buf) - len,
			"Raw DMA Debug values:\n");

	for (i = 0; i < ATH9K_NUM_DMA_DEBUG_REGS; i++) {
		if (i % 4 == 0)
			len += snprintf(buf + len, sizeof(buf) - len, "\n");

		val[i] = REG_READ(ah, AR_DMADBG_0 + (i * sizeof(u32)));
		len += snprintf(buf + len, sizeof(buf) - len, "%d: %08x ",
				i, val[i]);
	}

	len += snprintf(buf + len, sizeof(buf) - len, "\n\n");
	len += snprintf(buf + len, sizeof(buf) - len,
			"Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n");

	for (i = 0; i < ATH9K_NUM_QUEUES; i++, qcuOffset += 4, dcuOffset += 5) {
		if (i == 8) {
			qcuOffset = 0;
			qcuBase++;
		}

		if (i == 6) {
			dcuOffset = 0;
			dcuBase++;
		}

		len += snprintf(buf + len, sizeof(buf) - len,
			"%2d          %2x      %1x     %2x           %2x\n",
			i, (*qcuBase & (0x7 << qcuOffset)) >> qcuOffset,
			(*qcuBase & (0x8 << qcuOffset)) >> (qcuOffset + 3),
			val[2] & (0x7 << (i * 3)) >> (i * 3),
			(*dcuBase & (0x1f << dcuOffset)) >> dcuOffset);
	}

	len += snprintf(buf + len, sizeof(buf) - len, "\n");

	len += snprintf(buf + len, sizeof(buf) - len,
		"qcu_stitch state:   %2x    qcu_fetch state:        %2x\n",
		(val[3] & 0x003c0000) >> 18, (val[3] & 0x03c00000) >> 22);
	len += snprintf(buf + len, sizeof(buf) - len,
		"qcu_complete state: %2x    dcu_complete state:     %2x\n",
		(val[3] & 0x1c000000) >> 26, (val[6] & 0x3));
	len += snprintf(buf + len, sizeof(buf) - len,
		"dcu_arb state:      %2x    dcu_fp state:           %2x\n",
		(val[5] & 0x06000000) >> 25, (val[5] & 0x38000000) >> 27);
	len += snprintf(buf + len, sizeof(buf) - len,
		"chan_idle_dur:     %3d    chan_idle_dur_valid:     %1d\n",
		(val[6] & 0x000003fc) >> 2, (val[6] & 0x00000400) >> 10);
	len += snprintf(buf + len, sizeof(buf) - len,
		"txfifo_valid_0:      %1d    txfifo_valid_1:          %1d\n",
		(val[6] & 0x00000800) >> 11, (val[6] & 0x00001000) >> 12);
	len += snprintf(buf + len, sizeof(buf) - len,
		"txfifo_dcu_num_0:   %2d    txfifo_dcu_num_1:       %2d\n",
		(val[6] & 0x0001e000) >> 13, (val[6] & 0x001e0000) >> 17);

	len += snprintf(buf + len, sizeof(buf) - len, "pcu observe: 0x%x \n",
			REG_READ(ah, AR_OBS_BUS_1));
	len += snprintf(buf + len, sizeof(buf) - len,
			"AR_CR: 0x%x \n", REG_READ(ah, AR_CR));

	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}

static const struct file_operations fops_dma = {
	.read = read_file_dma,
	.open = ath9k_debugfs_open,
	.owner = THIS_MODULE
};


void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status)
{
	if (status)
		sc->sc_debug.stats.istats.total++;
	if (status & ATH9K_INT_RX)
		sc->sc_debug.stats.istats.rxok++;
	if (status & ATH9K_INT_RXEOL)
		sc->sc_debug.stats.istats.rxeol++;
	if (status & ATH9K_INT_RXORN)
		sc->sc_debug.stats.istats.rxorn++;
	if (status & ATH9K_INT_TX)
		sc->sc_debug.stats.istats.txok++;
	if (status & ATH9K_INT_TXURN)
		sc->sc_debug.stats.istats.txurn++;
	if (status & ATH9K_INT_MIB)
		sc->sc_debug.stats.istats.mib++;
	if (status & ATH9K_INT_RXPHY)
		sc->sc_debug.stats.istats.rxphyerr++;
	if (status & ATH9K_INT_RXKCM)
		sc->sc_debug.stats.istats.rx_keycache_miss++;
	if (status & ATH9K_INT_SWBA)
		sc->sc_debug.stats.istats.swba++;
	if (status & ATH9K_INT_BMISS)
		sc->sc_debug.stats.istats.bmiss++;
	if (status & ATH9K_INT_BNR)
		sc->sc_debug.stats.istats.bnr++;
	if (status & ATH9K_INT_CST)
		sc->sc_debug.stats.istats.cst++;
	if (status & ATH9K_INT_GTT)
		sc->sc_debug.stats.istats.gtt++;
	if (status & ATH9K_INT_TIM)
		sc->sc_debug.stats.istats.tim++;
	if (status & ATH9K_INT_CABEND)
		sc->sc_debug.stats.istats.cabend++;
	if (status & ATH9K_INT_DTIMSYNC)
		sc->sc_debug.stats.istats.dtimsync++;
	if (status & ATH9K_INT_DTIM)
		sc->sc_debug.stats.istats.dtim++;
}

static ssize_t read_file_interrupt(struct file *file, char __user *user_buf,
				   size_t count, loff_t *ppos)
{
	struct ath_softc *sc = file->private_data;
	char buf[512];
	unsigned int len = 0;

	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RX", sc->sc_debug.stats.istats.rxok);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXEOL", sc->sc_debug.stats.istats.rxeol);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXORN", sc->sc_debug.stats.istats.rxorn);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TX", sc->sc_debug.stats.istats.txok);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TXURN", sc->sc_debug.stats.istats.txurn);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "MIB", sc->sc_debug.stats.istats.mib);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXPHY", sc->sc_debug.stats.istats.rxphyerr);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXKCM", sc->sc_debug.stats.istats.rx_keycache_miss);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "SWBA", sc->sc_debug.stats.istats.swba);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "BMISS", sc->sc_debug.stats.istats.bmiss);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "BNR", sc->sc_debug.stats.istats.bnr);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "CST", sc->sc_debug.stats.istats.cst);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "GTT", sc->sc_debug.stats.istats.gtt);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TIM", sc->sc_debug.stats.istats.tim);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "CABEND", sc->sc_debug.stats.istats.cabend);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "DTIMSYNC", sc->sc_debug.stats.istats.dtimsync);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "DTIM", sc->sc_debug.stats.istats.dtim);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TOTAL", sc->sc_debug.stats.istats.total);

	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}

static const struct file_operations fops_interrupt = {
	.read = read_file_interrupt,
	.open = ath9k_debugfs_open,
	.owner = THIS_MODULE
};

static void ath_debug_stat_11n_rc(struct ath_softc *sc, struct sk_buff *skb)
{
	struct ath_tx_info_priv *tx_info_priv = NULL;
	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
	struct ieee80211_tx_rate *rates = tx_info->status.rates;
	int final_ts_idx, idx;

	tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
	final_ts_idx = tx_info_priv->tx.ts_rateindex;
	idx = sc->cur_rate_table->info[rates[final_ts_idx].idx].dot11rate;

	sc->sc_debug.stats.n_rcstats[idx].success++;
}

static void ath_debug_stat_legacy_rc(struct ath_softc *sc, struct sk_buff *skb)
{
	struct ath_tx_info_priv *tx_info_priv = NULL;
	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
	struct ieee80211_tx_rate *rates = tx_info->status.rates;
	int final_ts_idx, idx;

	tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
	final_ts_idx = tx_info_priv->tx.ts_rateindex;
	idx = rates[final_ts_idx].idx;

	sc->sc_debug.stats.legacy_rcstats[idx].success++;
}

void ath_debug_stat_rc(struct ath_softc *sc, struct sk_buff *skb)
{
	if (conf_is_ht(&sc->hw->conf))
		ath_debug_stat_11n_rc(sc, skb);
	else
		ath_debug_stat_legacy_rc(sc, skb);
}

/* FIXME: legacy rates, later on .. */
void ath_debug_stat_retries(struct ath_softc *sc, int rix,
			    int xretries, int retries)
{
	if (conf_is_ht(&sc->hw->conf)) {
		int idx = sc->cur_rate_table->info[rix].dot11rate;

		sc->sc_debug.stats.n_rcstats[idx].xretries += xretries;
		sc->sc_debug.stats.n_rcstats[idx].retries += retries;
	}
}

static ssize_t ath_read_file_stat_11n_rc(struct file *file,
					 char __user *user_buf,
					 size_t count, loff_t *ppos)
{
	struct ath_softc *sc = file->private_data;
	char buf[1024];
	unsigned int len = 0;
	int i = 0;

	len += sprintf(buf, "%7s %13s %8s %8s\n\n", "Rate", "Success",
		       "Retries", "XRetries");

	for (i = 0; i <= 15; i++) {
		len += snprintf(buf + len, sizeof(buf) - len,
				"%5s%3d: %8u %8u %8u\n", "MCS", i,
				sc->sc_debug.stats.n_rcstats[i].success,
				sc->sc_debug.stats.n_rcstats[i].retries,
				sc->sc_debug.stats.n_rcstats[i].xretries);
	}

	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}

static ssize_t ath_read_file_stat_legacy_rc(struct file *file,
					    char __user *user_buf,
					    size_t count, loff_t *ppos)
{
	struct ath_softc *sc = file->private_data;
	char buf[512];
	unsigned int len = 0;
	int i = 0;

	len += sprintf(buf, "%7s %13s\n\n", "Rate", "Success");

	for (i = 0; i < sc->cur_rate_table->rate_cnt; i++) {
		len += snprintf(buf + len, sizeof(buf) - len, "%5u: %12u\n",
				sc->cur_rate_table->info[i].ratekbps / 1000,
				sc->sc_debug.stats.legacy_rcstats[i].success);
	}

	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}

static ssize_t read_file_rcstat(struct file *file, char __user *user_buf,
				size_t count, loff_t *ppos)
{
	struct ath_softc *sc = file->private_data;

	if (conf_is_ht(&sc->hw->conf))
		return ath_read_file_stat_11n_rc(file, user_buf, count, ppos);
	else
		return ath_read_file_stat_legacy_rc(file, user_buf, count ,ppos);
}

static const struct file_operations fops_rcstat = {
	.read = read_file_rcstat,
	.open = ath9k_debugfs_open,
	.owner = THIS_MODULE
};

int ath9k_init_debug(struct ath_softc *sc)
{
	sc->sc_debug.debug_mask = ath9k_debug;

	sc->sc_debug.debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
	if (!sc->sc_debug.debugfs_root)
		goto err;

	sc->sc_debug.debugfs_phy = debugfs_create_dir(wiphy_name(sc->hw->wiphy),
						      sc->sc_debug.debugfs_root);
	if (!sc->sc_debug.debugfs_phy)
		goto err;

	sc->sc_debug.debugfs_dma = debugfs_create_file("dma", S_IRUGO,
				       sc->sc_debug.debugfs_phy, sc, &fops_dma);
	if (!sc->sc_debug.debugfs_dma)
		goto err;

	sc->sc_debug.debugfs_interrupt = debugfs_create_file("interrupt",
						     S_IRUGO,
						     sc->sc_debug.debugfs_phy,
						     sc, &fops_interrupt);
	if (!sc->sc_debug.debugfs_interrupt)
		goto err;

	sc->sc_debug.debugfs_rcstat = debugfs_create_file("rcstat",
						  S_IRUGO,
						  sc->sc_debug.debugfs_phy,
						  sc, &fops_rcstat);
	if (!sc->sc_debug.debugfs_rcstat)
		goto err;

	return 0;
err:
	ath9k_exit_debug(sc);
	return -ENOMEM;
}

void ath9k_exit_debug(struct ath_softc *sc)
{
	debugfs_remove(sc->sc_debug.debugfs_rcstat);
	debugfs_remove(sc->sc_debug.debugfs_interrupt);
	debugfs_remove(sc->sc_debug.debugfs_dma);
	debugfs_remove(sc->sc_debug.debugfs_phy);
	debugfs_remove(sc->sc_debug.debugfs_root);
}
Commit	Line	Data
88b126af S	1	/*
	2	* Copyright (c) 2008 Atheros Communications Inc.
	3	*
	4	* Permission to use, copy, modify, and/or distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*/
	16
394cf0a1	17	#include "ath9k.h"
88b126af S	18
	19	static unsigned int ath9k_debug = DBG_DEFAULT;
	20	module_param_named(debug, ath9k_debug, uint, 0);
	21
	22	void DPRINTF(struct ath_softc sc, int dbg_mask, const char fmt, ...)
	23	{
	24	if (!sc)
	25	return;
	26
826d2680	27	if (sc->sc_debug.debug_mask & dbg_mask) {
88b126af S	28	va_list args;
	29
	30	va_start(args, fmt);
	31	printk(KERN_DEBUG "ath9k: ");
	32	vprintk(fmt, args);
	33	va_end(args);
	34	}
	35	}
	36
2a163c6d S	37	static int ath9k_debugfs_open(struct inode inode, struct file file)
	38	{
	39	file->private_data = inode->i_private;
	40	return 0;
	41	}
	42
	43	static ssize_t read_file_dma(struct file file, char __user user_buf,
	44	size_t count, loff_t *ppos)
	45	{
	46	struct ath_softc *sc = file->private_data;
	47	struct ath_hal *ah = sc->sc_ah;
	48	char buf[1024];
	49	unsigned int len = 0;
	50	u32 val[ATH9K_NUM_DMA_DEBUG_REGS];
	51	int i, qcuOffset = 0, dcuOffset = 0;
	52	u32 qcuBase = &val[0], dcuBase = &val[4];
	53
	54	REG_WRITE(ah, AR_MACMISC,
	55	((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) \|
	56	(AR_MACMISC_MISC_OBS_BUS_1 <<
	57	AR_MACMISC_MISC_OBS_BUS_MSB_S)));
	58
	59	len += snprintf(buf + len, sizeof(buf) - len,
	60	"Raw DMA Debug values:\n");
	61
	62	for (i = 0; i < ATH9K_NUM_DMA_DEBUG_REGS; i++) {
	63	if (i % 4 == 0)
	64	len += snprintf(buf + len, sizeof(buf) - len, "\n");
	65
	66	val[i] = REG_READ(ah, AR_DMADBG_0 + (i * sizeof(u32)));
	67	len += snprintf(buf + len, sizeof(buf) - len, "%d: %08x ",
	68	i, val[i]);
	69	}
	70
	71	len += snprintf(buf + len, sizeof(buf) - len, "\n\n");
	72	len += snprintf(buf + len, sizeof(buf) - len,
	73	"Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n");
	74
	75	for (i = 0; i < ATH9K_NUM_QUEUES; i++, qcuOffset += 4, dcuOffset += 5) {
	76	if (i == 8) {
	77	qcuOffset = 0;
	78	qcuBase++;
	79	}
	80
	81	if (i == 6) {
	82	dcuOffset = 0;
	83	dcuBase++;
	84	}
	85
	86	len += snprintf(buf + len, sizeof(buf) - len,
	87	"%2d %2x %1x %2x %2x\n",
	88	i, (*qcuBase & (0x7 << qcuOffset)) >> qcuOffset,
	89	(*qcuBase & (0x8 << qcuOffset)) >> (qcuOffset + 3),
	90	val[2] & (0x7 << (i * 3)) >> (i * 3),
	91	(*dcuBase & (0x1f << dcuOffset)) >> dcuOffset);
	92	}
	93
	94	len += snprintf(buf + len, sizeof(buf) - len, "\n");
	95
	96	len += snprintf(buf + len, sizeof(buf) - len,
	97	"qcu_stitch state: %2x qcu_fetch state: %2x\n",
	98	(val[3] & 0x003c0000) >> 18, (val[3] & 0x03c00000) >> 22);
	99	len += snprintf(buf + len, sizeof(buf) - len,
	100	"qcu_complete state: %2x dcu_complete state: %2x\n",
101	(val[3] & 0x1c000000) >> 26, (val[6] & 0x3));
102	len += snprintf(buf + len, sizeof(buf) - len,
103	"dcu_arb state: %2x dcu_fp state: %2x\n",
104	(val[5] & 0x06000000) >> 25, (val[5] & 0x38000000) >> 27);
105	len += snprintf(buf + len, sizeof(buf) - len,
106	"chan_idle_dur: %3d chan_idle_dur_valid: %1d\n",
107	(val[6] & 0x000003fc) >> 2, (val[6] & 0x00000400) >> 10);
108	len += snprintf(buf + len, sizeof(buf) - len,
109	"txfifo_valid_0: %1d txfifo_valid_1: %1d\n",
110	(val[6] & 0x00000800) >> 11, (val[6] & 0x00001000) >> 12);
111	len += snprintf(buf + len, sizeof(buf) - len,
112	"txfifo_dcu_num_0: %2d txfifo_dcu_num_1: %2d\n",
113	(val[6] & 0x0001e000) >> 13, (val[6] & 0x001e0000) >> 17);
114
115	len += snprintf(buf + len, sizeof(buf) - len, "pcu observe: 0x%x \n",
116	REG_READ(ah, AR_OBS_BUS_1));
117	len += snprintf(buf + len, sizeof(buf) - len,
118	"AR_CR: 0x%x \n", REG_READ(ah, AR_CR));
119
120	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
121	}
122
123	static const struct file_operations fops_dma = {
124	.read = read_file_dma,
125	.open = ath9k_debugfs_open,
126	.owner = THIS_MODULE
127	};
128
817e11de S	129
	130	void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status)
	131	{
	132	if (status)
	133	sc->sc_debug.stats.istats.total++;
	134	if (status & ATH9K_INT_RX)
	135	sc->sc_debug.stats.istats.rxok++;
	136	if (status & ATH9K_INT_RXEOL)
	137	sc->sc_debug.stats.istats.rxeol++;
	138	if (status & ATH9K_INT_RXORN)
	139	sc->sc_debug.stats.istats.rxorn++;
	140	if (status & ATH9K_INT_TX)
	141	sc->sc_debug.stats.istats.txok++;
	142	if (status & ATH9K_INT_TXURN)
	143	sc->sc_debug.stats.istats.txurn++;
	144	if (status & ATH9K_INT_MIB)
	145	sc->sc_debug.stats.istats.mib++;
	146	if (status & ATH9K_INT_RXPHY)
	147	sc->sc_debug.stats.istats.rxphyerr++;
	148	if (status & ATH9K_INT_RXKCM)
	149	sc->sc_debug.stats.istats.rx_keycache_miss++;
	150	if (status & ATH9K_INT_SWBA)
	151	sc->sc_debug.stats.istats.swba++;
	152	if (status & ATH9K_INT_BMISS)
	153	sc->sc_debug.stats.istats.bmiss++;
	154	if (status & ATH9K_INT_BNR)
	155	sc->sc_debug.stats.istats.bnr++;
	156	if (status & ATH9K_INT_CST)
	157	sc->sc_debug.stats.istats.cst++;
	158	if (status & ATH9K_INT_GTT)
	159	sc->sc_debug.stats.istats.gtt++;
	160	if (status & ATH9K_INT_TIM)
	161	sc->sc_debug.stats.istats.tim++;
	162	if (status & ATH9K_INT_CABEND)
	163	sc->sc_debug.stats.istats.cabend++;
	164	if (status & ATH9K_INT_DTIMSYNC)
	165	sc->sc_debug.stats.istats.dtimsync++;
	166	if (status & ATH9K_INT_DTIM)
	167	sc->sc_debug.stats.istats.dtim++;
	168	}
	169
	170	static ssize_t read_file_interrupt(struct file file, char __user user_buf,
	171	size_t count, loff_t *ppos)
	172	{
	173	struct ath_softc *sc = file->private_data;
	174	char buf[512];
	175	unsigned int len = 0;
	176
	177	len += snprintf(buf + len, sizeof(buf) - len,
	178	"%8s: %10u\n", "RX", sc->sc_debug.stats.istats.rxok);
	179	len += snprintf(buf + len, sizeof(buf) - len,
	180	"%8s: %10u\n", "RXEOL", sc->sc_debug.stats.istats.rxeol);
	181	len += snprintf(buf + len, sizeof(buf) - len,
	182	"%8s: %10u\n", "RXORN", sc->sc_debug.stats.istats.rxorn);
	183	len += snprintf(buf + len, sizeof(buf) - len,
	184	"%8s: %10u\n", "TX", sc->sc_debug.stats.istats.txok);
	185	len += snprintf(buf + len, sizeof(buf) - len,
	186	"%8s: %10u\n", "TXURN", sc->sc_debug.stats.istats.txurn);
	187	len += snprintf(buf + len, sizeof(buf) - len,
	188	"%8s: %10u\n", "MIB", sc->sc_debug.stats.istats.mib);
	189	len += snprintf(buf + len, sizeof(buf) - len,
	190	"%8s: %10u\n", "RXPHY", sc->sc_debug.stats.istats.rxphyerr);
	191	len += snprintf(buf + len, sizeof(buf) - len,
	192	"%8s: %10u\n", "RXKCM", sc->sc_debug.stats.istats.rx_keycache_miss);
193	len += snprintf(buf + len, sizeof(buf) - len,
194	"%8s: %10u\n", "SWBA", sc->sc_debug.stats.istats.swba);
195	len += snprintf(buf + len, sizeof(buf) - len,
196	"%8s: %10u\n", "BMISS", sc->sc_debug.stats.istats.bmiss);
197	len += snprintf(buf + len, sizeof(buf) - len,
198	"%8s: %10u\n", "BNR", sc->sc_debug.stats.istats.bnr);
199	len += snprintf(buf + len, sizeof(buf) - len,
200	"%8s: %10u\n", "CST", sc->sc_debug.stats.istats.cst);
201	len += snprintf(buf + len, sizeof(buf) - len,
202	"%8s: %10u\n", "GTT", sc->sc_debug.stats.istats.gtt);
203	len += snprintf(buf + len, sizeof(buf) - len,
204	"%8s: %10u\n", "TIM", sc->sc_debug.stats.istats.tim);
205	len += snprintf(buf + len, sizeof(buf) - len,
206	"%8s: %10u\n", "CABEND", sc->sc_debug.stats.istats.cabend);
207	len += snprintf(buf + len, sizeof(buf) - len,
208	"%8s: %10u\n", "DTIMSYNC", sc->sc_debug.stats.istats.dtimsync);
209	len += snprintf(buf + len, sizeof(buf) - len,
210	"%8s: %10u\n", "DTIM", sc->sc_debug.stats.istats.dtim);
211	len += snprintf(buf + len, sizeof(buf) - len,
212	"%8s: %10u\n", "TOTAL", sc->sc_debug.stats.istats.total);
213
214	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
215	}
216
217	static const struct file_operations fops_interrupt = {
218	.read = read_file_interrupt,
219	.open = ath9k_debugfs_open,
220	.owner = THIS_MODULE
221	};
222
7a7dec65 S	223	static void ath_debug_stat_11n_rc(struct ath_softc sc, struct sk_buff skb)
	224	{
	225	struct ath_tx_info_priv *tx_info_priv = NULL;
	226	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
	227	struct ieee80211_tx_rate *rates = tx_info->status.rates;
	228	int final_ts_idx, idx;
	229
	230	tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
	231	final_ts_idx = tx_info_priv->tx.ts_rateindex;
	232	idx = sc->cur_rate_table->info[rates[final_ts_idx].idx].dot11rate;
	233
	234	sc->sc_debug.stats.n_rcstats[idx].success++;
	235	}
	236
	237	static void ath_debug_stat_legacy_rc(struct ath_softc sc, struct sk_buff skb)
	238	{
	239	struct ath_tx_info_priv *tx_info_priv = NULL;
	240	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
	241	struct ieee80211_tx_rate *rates = tx_info->status.rates;
	242	int final_ts_idx, idx;
	243
	244	tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
	245	final_ts_idx = tx_info_priv->tx.ts_rateindex;
	246	idx = rates[final_ts_idx].idx;
	247
	248	sc->sc_debug.stats.legacy_rcstats[idx].success++;
	249	}
	250
	251	void ath_debug_stat_rc(struct ath_softc sc, struct sk_buff skb)
	252	{
	253	if (conf_is_ht(&sc->hw->conf))
	254	ath_debug_stat_11n_rc(sc, skb);
	255	else
	256	ath_debug_stat_legacy_rc(sc, skb);
	257	}
	258
029bc432 S	259	/* FIXME: legacy rates, later on .. */
	260	void ath_debug_stat_retries(struct ath_softc *sc, int rix,
	261	int xretries, int retries)
	262	{
	263	if (conf_is_ht(&sc->hw->conf)) {
	264	int idx = sc->cur_rate_table->info[rix].dot11rate;
	265
	266	sc->sc_debug.stats.n_rcstats[idx].xretries += xretries;
	267	sc->sc_debug.stats.n_rcstats[idx].retries += retries;
	268	}
	269	}
	270
7a7dec65 S	271	static ssize_t ath_read_file_stat_11n_rc(struct file *file,
	272	char __user *user_buf,
	273	size_t count, loff_t *ppos)
	274	{
	275	struct ath_softc *sc = file->private_data;
029bc432	276	char buf[1024];
7a7dec65 S	277	unsigned int len = 0;
	278	int i = 0;
	279
029bc432 S	280	len += sprintf(buf, "%7s %13s %8s %8s\n\n", "Rate", "Success",
029bc432 S	281	"Retries", "XRetries");
7a7dec65 S	282
	283	for (i = 0; i <= 15; i++) {
	284	len += snprintf(buf + len, sizeof(buf) - len,
029bc432 S	285	"%5s%3d: %8u %8u %8u\n", "MCS", i,
	286	sc->sc_debug.stats.n_rcstats[i].success,
	287	sc->sc_debug.stats.n_rcstats[i].retries,
	288	sc->sc_debug.stats.n_rcstats[i].xretries);
7a7dec65 S	289	}
	290
	291	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
	292	}
	293
	294	static ssize_t ath_read_file_stat_legacy_rc(struct file *file,
	295	char __user *user_buf,
	296	size_t count, loff_t *ppos)
	297	{
	298	struct ath_softc *sc = file->private_data;
	299	char buf[512];
	300	unsigned int len = 0;
	301	int i = 0;
	302
	303	len += sprintf(buf, "%7s %13s\n\n", "Rate", "Success");
	304
	305	for (i = 0; i < sc->cur_rate_table->rate_cnt; i++) {
	306	len += snprintf(buf + len, sizeof(buf) - len, "%5u: %12u\n",
	307	sc->cur_rate_table->info[i].ratekbps / 1000,
	308	sc->sc_debug.stats.legacy_rcstats[i].success);
	309	}
	310
	311	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
	312	}
	313
	314	static ssize_t read_file_rcstat(struct file file, char __user user_buf,
	315	size_t count, loff_t *ppos)
	316	{
	317	struct ath_softc *sc = file->private_data;
	318
	319	if (conf_is_ht(&sc->hw->conf))
	320	return ath_read_file_stat_11n_rc(file, user_buf, count, ppos);
	321	else
	322	return ath_read_file_stat_legacy_rc(file, user_buf, count ,ppos);
	323	}
	324
	325	static const struct file_operations fops_rcstat = {
	326	.read = read_file_rcstat,
	327	.open = ath9k_debugfs_open,
	328	.owner = THIS_MODULE
	329	};
27abe060	330
826d2680	331	int ath9k_init_debug(struct ath_softc *sc)
88b126af	332	{
826d2680 S	333	sc->sc_debug.debug_mask = ath9k_debug;
	334
	335	sc->sc_debug.debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
	336	if (!sc->sc_debug.debugfs_root)
	337	goto err;
	338
	339	sc->sc_debug.debugfs_phy = debugfs_create_dir(wiphy_name(sc->hw->wiphy),
	340	sc->sc_debug.debugfs_root);
	341	if (!sc->sc_debug.debugfs_phy)
	342	goto err;
	343
2a163c6d S	344	sc->sc_debug.debugfs_dma = debugfs_create_file("dma", S_IRUGO,
	345	sc->sc_debug.debugfs_phy, sc, &fops_dma);
	346	if (!sc->sc_debug.debugfs_dma)
	347	goto err;
	348
817e11de S	349	sc->sc_debug.debugfs_interrupt = debugfs_create_file("interrupt",
	350	S_IRUGO,
	351	sc->sc_debug.debugfs_phy,
	352	sc, &fops_interrupt);
	353	if (!sc->sc_debug.debugfs_interrupt)
	354	goto err;
	355
7a7dec65 S	356	sc->sc_debug.debugfs_rcstat = debugfs_create_file("rcstat",
	357	S_IRUGO,
	358	sc->sc_debug.debugfs_phy,
	359	sc, &fops_rcstat);
	360	if (!sc->sc_debug.debugfs_rcstat)
	361	goto err;
	362
826d2680 S	363	return 0;
	364	err:
	365	ath9k_exit_debug(sc);
	366	return -ENOMEM;
	367	}
	368
	369	void ath9k_exit_debug(struct ath_softc *sc)
	370	{
7a7dec65	371	debugfs_remove(sc->sc_debug.debugfs_rcstat);
817e11de	372	debugfs_remove(sc->sc_debug.debugfs_interrupt);
2a163c6d	373	debugfs_remove(sc->sc_debug.debugfs_dma);
826d2680 S	374	debugfs_remove(sc->sc_debug.debugfs_phy);
826d2680 S	375	debugfs_remove(sc->sc_debug.debugfs_root);
88b126af	376	}