[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / wireless / ath9k / debug.c

/*
 * Copyright (c) 2008-2009 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 <asm/unaligned.h>

#include "ath9k.h"

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

static struct dentry *ath9k_debugfs_root;

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

	if (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_hw *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->debug.stats.istats.total++;
	if (status & ATH9K_INT_RX)
		sc->debug.stats.istats.rxok++;
	if (status & ATH9K_INT_RXEOL)
		sc->debug.stats.istats.rxeol++;
	if (status & ATH9K_INT_RXORN)
		sc->debug.stats.istats.rxorn++;
	if (status & ATH9K_INT_TX)
		sc->debug.stats.istats.txok++;
	if (status & ATH9K_INT_TXURN)
		sc->debug.stats.istats.txurn++;
	if (status & ATH9K_INT_MIB)
		sc->debug.stats.istats.mib++;
	if (status & ATH9K_INT_RXPHY)
		sc->debug.stats.istats.rxphyerr++;
	if (status & ATH9K_INT_RXKCM)
		sc->debug.stats.istats.rx_keycache_miss++;
	if (status & ATH9K_INT_SWBA)
		sc->debug.stats.istats.swba++;
	if (status & ATH9K_INT_BMISS)
		sc->debug.stats.istats.bmiss++;
	if (status & ATH9K_INT_BNR)
		sc->debug.stats.istats.bnr++;
	if (status & ATH9K_INT_CST)
		sc->debug.stats.istats.cst++;
	if (status & ATH9K_INT_GTT)
		sc->debug.stats.istats.gtt++;
	if (status & ATH9K_INT_TIM)
		sc->debug.stats.istats.tim++;
	if (status & ATH9K_INT_CABEND)
		sc->debug.stats.istats.cabend++;
	if (status & ATH9K_INT_DTIMSYNC)
		sc->debug.stats.istats.dtimsync++;
	if (status & ATH9K_INT_DTIM)
		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->debug.stats.istats.rxok);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXEOL", sc->debug.stats.istats.rxeol);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXORN", sc->debug.stats.istats.rxorn);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TX", sc->debug.stats.istats.txok);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TXURN", sc->debug.stats.istats.txurn);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "MIB", sc->debug.stats.istats.mib);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXPHY", sc->debug.stats.istats.rxphyerr);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "RXKCM", sc->debug.stats.istats.rx_keycache_miss);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "SWBA", sc->debug.stats.istats.swba);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "BMISS", sc->debug.stats.istats.bmiss);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "BNR", sc->debug.stats.istats.bnr);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "CST", sc->debug.stats.istats.cst);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "GTT", sc->debug.stats.istats.gtt);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TIM", sc->debug.stats.istats.tim);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "CABEND", sc->debug.stats.istats.cabend);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "DTIMSYNC", sc->debug.stats.istats.dtimsync);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "DTIM", sc->debug.stats.istats.dtim);
	len += snprintf(buf + len, sizeof(buf) - len,
		"%8s: %10u\n", "TOTAL", 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->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->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, u8 per)
{
	if (conf_is_ht(&sc->hw->conf)) {
		int idx = sc->cur_rate_table->info[rix].dot11rate;

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

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 %6s\n\n", "Rate", "Success",
		       "Retries", "XRetries", "PER");

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

	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->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 (sc->cur_rate_table == NULL)
		return 0;

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

static const char * ath_wiphy_state_str(enum ath_wiphy_state state)
{
	switch (state) {
	case ATH_WIPHY_INACTIVE:
		return "INACTIVE";
	case ATH_WIPHY_ACTIVE:
		return "ACTIVE";
	case ATH_WIPHY_PAUSING:
		return "PAUSING";
	case ATH_WIPHY_PAUSED:
		return "PAUSED";
	case ATH_WIPHY_SCAN:
		return "SCAN";
	}
	return "?";
}

static ssize_t read_file_wiphy(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;
	u8 addr[ETH_ALEN];

	len += snprintf(buf + len, sizeof(buf) - len,
			"primary: %s (%s chan=%d ht=%d)\n",
			wiphy_name(sc->pri_wiphy->hw->wiphy),
			ath_wiphy_state_str(sc->pri_wiphy->state),
			sc->pri_wiphy->chan_idx, sc->pri_wiphy->chan_is_ht);
	for (i = 0; i < sc->num_sec_wiphy; i++) {
		struct ath_wiphy *aphy = sc->sec_wiphy[i];
		if (aphy == NULL)
			continue;
		len += snprintf(buf + len, sizeof(buf) - len,
				"secondary: %s (%s chan=%d ht=%d)\n",
				wiphy_name(aphy->hw->wiphy),
				ath_wiphy_state_str(aphy->state),
				aphy->chan_idx, aphy->chan_is_ht);
	}

	put_unaligned_le32(REG_READ(sc->sc_ah, AR_STA_ID0), addr);
	put_unaligned_le16(REG_READ(sc->sc_ah, AR_STA_ID1) & 0xffff, addr + 4);
	len += snprintf(buf + len, sizeof(buf) - len,
			"addr: %pM\n", addr);
	put_unaligned_le32(REG_READ(sc->sc_ah, AR_BSSMSKL), addr);
	put_unaligned_le16(REG_READ(sc->sc_ah, AR_BSSMSKU) & 0xffff, addr + 4);
	len += snprintf(buf + len, sizeof(buf) - len,
			"addrmask: %pM\n", addr);

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

static struct ath_wiphy * get_wiphy(struct ath_softc *sc, const char *name)
{
	int i;
	if (strcmp(name, wiphy_name(sc->pri_wiphy->hw->wiphy)) == 0)
		return sc->pri_wiphy;
	for (i = 0; i < sc->num_sec_wiphy; i++) {
		struct ath_wiphy *aphy = sc->sec_wiphy[i];
		if (aphy && strcmp(name, wiphy_name(aphy->hw->wiphy)) == 0)
			return aphy;
	}
	return NULL;
}

static int del_wiphy(struct ath_softc *sc, const char *name)
{
	struct ath_wiphy *aphy = get_wiphy(sc, name);
	if (!aphy)
		return -ENOENT;
	return ath9k_wiphy_del(aphy);
}

static int pause_wiphy(struct ath_softc *sc, const char *name)
{
	struct ath_wiphy *aphy = get_wiphy(sc, name);
	if (!aphy)
		return -ENOENT;
	return ath9k_wiphy_pause(aphy);
}

static int unpause_wiphy(struct ath_softc *sc, const char *name)
{
	struct ath_wiphy *aphy = get_wiphy(sc, name);
	if (!aphy)
		return -ENOENT;
	return ath9k_wiphy_unpause(aphy);
}

static int select_wiphy(struct ath_softc *sc, const char *name)
{
	struct ath_wiphy *aphy = get_wiphy(sc, name);
	if (!aphy)
		return -ENOENT;
	return ath9k_wiphy_select(aphy);
}

static int schedule_wiphy(struct ath_softc *sc, const char *msec)
{
	ath9k_wiphy_set_scheduler(sc, simple_strtoul(msec, NULL, 0));
	return 0;
}

static ssize_t write_file_wiphy(struct file *file, const char __user *user_buf,
				size_t count, loff_t *ppos)
{
	struct ath_softc *sc = file->private_data;
	char buf[50];
	size_t len;

	len = min(count, sizeof(buf) - 1);
	if (copy_from_user(buf, user_buf, len))
		return -EFAULT;
	buf[len] = '\0';
	if (len > 0 && buf[len - 1] == '\n')
		buf[len - 1] = '\0';

	if (strncmp(buf, "add", 3) == 0) {
		int res = ath9k_wiphy_add(sc);
		if (res < 0)
			return res;
	} else if (strncmp(buf, "del=", 4) == 0) {
		int res = del_wiphy(sc, buf + 4);
		if (res < 0)
			return res;
	} else if (strncmp(buf, "pause=", 6) == 0) {
		int res = pause_wiphy(sc, buf + 6);
		if (res < 0)
			return res;
	} else if (strncmp(buf, "unpause=", 8) == 0) {
		int res = unpause_wiphy(sc, buf + 8);
		if (res < 0)
			return res;
	} else if (strncmp(buf, "select=", 7) == 0) {
		int res = select_wiphy(sc, buf + 7);
		if (res < 0)
			return res;
	} else if (strncmp(buf, "schedule=", 9) == 0) {
		int res = schedule_wiphy(sc, buf + 9);
		if (res < 0)
			return res;
	} else
		return -EOPNOTSUPP;

	return count;
}

static const struct file_operations fops_wiphy = {
	.read = read_file_wiphy,
	.write = write_file_wiphy,
	.open = ath9k_debugfs_open,
	.owner = THIS_MODULE
};


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

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

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

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

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

	sc->debug.debugfs_wiphy = debugfs_create_file(
		"wiphy", S_IRUGO | S_IWUSR, sc->debug.debugfs_phy, sc,
		&fops_wiphy);
	if (!sc->debug.debugfs_wiphy)
		goto err;

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

void ath9k_exit_debug(struct ath_softc *sc)
{
	debugfs_remove(sc->debug.debugfs_wiphy);
	debugfs_remove(sc->debug.debugfs_rcstat);
	debugfs_remove(sc->debug.debugfs_interrupt);
	debugfs_remove(sc->debug.debugfs_dma);
	debugfs_remove(sc->debug.debugfs_phy);
}

int ath9k_debug_create_root(void)
{
	ath9k_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
	if (!ath9k_debugfs_root)
		return -ENOENT;

	return 0;
}

void ath9k_debug_remove_root(void)
{
	debugfs_remove(ath9k_debugfs_root);
	ath9k_debugfs_root = NULL;
}
Commit	Line	Data
88b126af	1	/*
cee075a2	2	* Copyright (c) 2008-2009 Atheros Communications Inc.
88b126af S	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
52103115 GJ	17	#include <asm/unaligned.h>
52103115 GJ	18
394cf0a1	19	#include "ath9k.h"
88b126af S	20
	21	static unsigned int ath9k_debug = DBG_DEFAULT;
	22	module_param_named(debug, ath9k_debug, uint, 0);
	23
19d8bc22 GJ	24	static struct dentry *ath9k_debugfs_root;
19d8bc22 GJ	25
88b126af S	26	void DPRINTF(struct ath_softc sc, int dbg_mask, const char fmt, ...)
	27	{
	28	if (!sc)
	29	return;
	30
17d7904d	31	if (sc->debug.debug_mask & dbg_mask) {
88b126af S	32	va_list args;
	33
	34	va_start(args, fmt);
	35	printk(KERN_DEBUG "ath9k: ");
	36	vprintk(fmt, args);
	37	va_end(args);
	38	}
	39	}
	40
2a163c6d S	41	static int ath9k_debugfs_open(struct inode inode, struct file file)
	42	{
	43	file->private_data = inode->i_private;
	44	return 0;
	45	}
	46
	47	static ssize_t read_file_dma(struct file file, char __user user_buf,
	48	size_t count, loff_t *ppos)
	49	{
	50	struct ath_softc *sc = file->private_data;
cbe61d8a	51	struct ath_hw *ah = sc->sc_ah;
2a163c6d S	52	char buf[1024];
	53	unsigned int len = 0;
	54	u32 val[ATH9K_NUM_DMA_DEBUG_REGS];
	55	int i, qcuOffset = 0, dcuOffset = 0;
	56	u32 qcuBase = &val[0], dcuBase = &val[4];
	57
	58	REG_WRITE(ah, AR_MACMISC,
	59	((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) \|
	60	(AR_MACMISC_MISC_OBS_BUS_1 <<
	61	AR_MACMISC_MISC_OBS_BUS_MSB_S)));
	62
	63	len += snprintf(buf + len, sizeof(buf) - len,
	64	"Raw DMA Debug values:\n");
	65
	66	for (i = 0; i < ATH9K_NUM_DMA_DEBUG_REGS; i++) {
	67	if (i % 4 == 0)
	68	len += snprintf(buf + len, sizeof(buf) - len, "\n");
	69
	70	val[i] = REG_READ(ah, AR_DMADBG_0 + (i * sizeof(u32)));
	71	len += snprintf(buf + len, sizeof(buf) - len, "%d: %08x ",
	72	i, val[i]);
	73	}
	74
	75	len += snprintf(buf + len, sizeof(buf) - len, "\n\n");
	76	len += snprintf(buf + len, sizeof(buf) - len,
	77	"Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n");
	78
	79	for (i = 0; i < ATH9K_NUM_QUEUES; i++, qcuOffset += 4, dcuOffset += 5) {
	80	if (i == 8) {
	81	qcuOffset = 0;
	82	qcuBase++;
	83	}
	84
	85	if (i == 6) {
	86	dcuOffset = 0;
	87	dcuBase++;
	88	}
	89
	90	len += snprintf(buf + len, sizeof(buf) - len,
	91	"%2d %2x %1x %2x %2x\n",
	92	i, (*qcuBase & (0x7 << qcuOffset)) >> qcuOffset,
	93	(*qcuBase & (0x8 << qcuOffset)) >> (qcuOffset + 3),
	94	val[2] & (0x7 << (i * 3)) >> (i * 3),
	95	(*dcuBase & (0x1f << dcuOffset)) >> dcuOffset);
	96	}
	97
	98	len += snprintf(buf + len, sizeof(buf) - len, "\n");
	99
	100	len += snprintf(buf + len, sizeof(buf) - len,
	101	"qcu_stitch state: %2x qcu_fetch state: %2x\n",
	102	(val[3] & 0x003c0000) >> 18, (val[3] & 0x03c00000) >> 22);
	103	len += snprintf(buf + len, sizeof(buf) - len,
	104	"qcu_complete state: %2x dcu_complete state: %2x\n",
	105	(val[3] & 0x1c000000) >> 26, (val[6] & 0x3));
	106	len += snprintf(buf + len, sizeof(buf) - len,
	107	"dcu_arb state: %2x dcu_fp state: %2x\n",
	108	(val[5] & 0x06000000) >> 25, (val[5] & 0x38000000) >> 27);
	109	len += snprintf(buf + len, sizeof(buf) - len,
	110	"chan_idle_dur: %3d chan_idle_dur_valid: %1d\n",
	111	(val[6] & 0x000003fc) >> 2, (val[6] & 0x00000400) >> 10);
	112	len += snprintf(buf + len, sizeof(buf) - len,
	113	"txfifo_valid_0: %1d txfifo_valid_1: %1d\n",
	114	(val[6] & 0x00000800) >> 11, (val[6] & 0x00001000) >> 12);
	115	len += snprintf(buf + len, sizeof(buf) - len,
116	"txfifo_dcu_num_0: %2d txfifo_dcu_num_1: %2d\n",
117	(val[6] & 0x0001e000) >> 13, (val[6] & 0x001e0000) >> 17);
118
119	len += snprintf(buf + len, sizeof(buf) - len, "pcu observe: 0x%x \n",
120	REG_READ(ah, AR_OBS_BUS_1));
121	len += snprintf(buf + len, sizeof(buf) - len,
122	"AR_CR: 0x%x \n", REG_READ(ah, AR_CR));
123
124	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
125	}
126
127	static const struct file_operations fops_dma = {
128	.read = read_file_dma,
129	.open = ath9k_debugfs_open,
130	.owner = THIS_MODULE
131	};
132
817e11de S	133
	134	void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status)
	135	{
	136	if (status)
17d7904d	137	sc->debug.stats.istats.total++;
817e11de	138	if (status & ATH9K_INT_RX)
17d7904d	139	sc->debug.stats.istats.rxok++;
817e11de	140	if (status & ATH9K_INT_RXEOL)
17d7904d	141	sc->debug.stats.istats.rxeol++;
817e11de	142	if (status & ATH9K_INT_RXORN)
17d7904d	143	sc->debug.stats.istats.rxorn++;
817e11de	144	if (status & ATH9K_INT_TX)
17d7904d	145	sc->debug.stats.istats.txok++;
817e11de	146	if (status & ATH9K_INT_TXURN)
17d7904d	147	sc->debug.stats.istats.txurn++;
817e11de	148	if (status & ATH9K_INT_MIB)
17d7904d	149	sc->debug.stats.istats.mib++;
817e11de	150	if (status & ATH9K_INT_RXPHY)
17d7904d	151	sc->debug.stats.istats.rxphyerr++;
817e11de	152	if (status & ATH9K_INT_RXKCM)
17d7904d	153	sc->debug.stats.istats.rx_keycache_miss++;
817e11de	154	if (status & ATH9K_INT_SWBA)
17d7904d	155	sc->debug.stats.istats.swba++;
817e11de	156	if (status & ATH9K_INT_BMISS)
17d7904d	157	sc->debug.stats.istats.bmiss++;
817e11de	158	if (status & ATH9K_INT_BNR)
17d7904d	159	sc->debug.stats.istats.bnr++;
817e11de	160	if (status & ATH9K_INT_CST)
17d7904d	161	sc->debug.stats.istats.cst++;
817e11de	162	if (status & ATH9K_INT_GTT)
17d7904d	163	sc->debug.stats.istats.gtt++;
817e11de	164	if (status & ATH9K_INT_TIM)
17d7904d	165	sc->debug.stats.istats.tim++;
817e11de	166	if (status & ATH9K_INT_CABEND)
17d7904d	167	sc->debug.stats.istats.cabend++;
817e11de	168	if (status & ATH9K_INT_DTIMSYNC)
17d7904d	169	sc->debug.stats.istats.dtimsync++;
817e11de	170	if (status & ATH9K_INT_DTIM)
17d7904d	171	sc->debug.stats.istats.dtim++;
817e11de S	172	}
	173
	174	static ssize_t read_file_interrupt(struct file file, char __user user_buf,
	175	size_t count, loff_t *ppos)
	176	{
	177	struct ath_softc *sc = file->private_data;
	178	char buf[512];
	179	unsigned int len = 0;
	180
	181	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	182	"%8s: %10u\n", "RX", sc->debug.stats.istats.rxok);
817e11de	183	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	184	"%8s: %10u\n", "RXEOL", sc->debug.stats.istats.rxeol);
817e11de	185	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	186	"%8s: %10u\n", "RXORN", sc->debug.stats.istats.rxorn);
817e11de	187	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	188	"%8s: %10u\n", "TX", sc->debug.stats.istats.txok);
817e11de	189	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	190	"%8s: %10u\n", "TXURN", sc->debug.stats.istats.txurn);
817e11de	191	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	192	"%8s: %10u\n", "MIB", sc->debug.stats.istats.mib);
817e11de	193	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	194	"%8s: %10u\n", "RXPHY", sc->debug.stats.istats.rxphyerr);
817e11de	195	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	196	"%8s: %10u\n", "RXKCM", sc->debug.stats.istats.rx_keycache_miss);
817e11de	197	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	198	"%8s: %10u\n", "SWBA", sc->debug.stats.istats.swba);
817e11de	199	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	200	"%8s: %10u\n", "BMISS", sc->debug.stats.istats.bmiss);
817e11de	201	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	202	"%8s: %10u\n", "BNR", sc->debug.stats.istats.bnr);
817e11de	203	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	204	"%8s: %10u\n", "CST", sc->debug.stats.istats.cst);
817e11de	205	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	206	"%8s: %10u\n", "GTT", sc->debug.stats.istats.gtt);
817e11de	207	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	208	"%8s: %10u\n", "TIM", sc->debug.stats.istats.tim);
817e11de	209	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	210	"%8s: %10u\n", "CABEND", sc->debug.stats.istats.cabend);
817e11de	211	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	212	"%8s: %10u\n", "DTIMSYNC", sc->debug.stats.istats.dtimsync);
817e11de	213	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	214	"%8s: %10u\n", "DTIM", sc->debug.stats.istats.dtim);
817e11de	215	len += snprintf(buf + len, sizeof(buf) - len,
17d7904d	216	"%8s: %10u\n", "TOTAL", sc->debug.stats.istats.total);
817e11de S	217
	218	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
	219	}
	220
	221	static const struct file_operations fops_interrupt = {
	222	.read = read_file_interrupt,
	223	.open = ath9k_debugfs_open,
	224	.owner = THIS_MODULE
	225	};
	226
7a7dec65 S	227	static void ath_debug_stat_11n_rc(struct ath_softc sc, struct sk_buff skb)
	228	{
	229	struct ath_tx_info_priv *tx_info_priv = NULL;
	230	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
	231	struct ieee80211_tx_rate *rates = tx_info->status.rates;
	232	int final_ts_idx, idx;
	233
	234	tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
	235	final_ts_idx = tx_info_priv->tx.ts_rateindex;
	236	idx = sc->cur_rate_table->info[rates[final_ts_idx].idx].dot11rate;
	237
17d7904d	238	sc->debug.stats.n_rcstats[idx].success++;
7a7dec65 S	239	}
	240
	241	static void ath_debug_stat_legacy_rc(struct ath_softc sc, struct sk_buff skb)
	242	{
	243	struct ath_tx_info_priv *tx_info_priv = NULL;
	244	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
	245	struct ieee80211_tx_rate *rates = tx_info->status.rates;
	246	int final_ts_idx, idx;
	247
	248	tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
	249	final_ts_idx = tx_info_priv->tx.ts_rateindex;
	250	idx = rates[final_ts_idx].idx;
	251
17d7904d	252	sc->debug.stats.legacy_rcstats[idx].success++;
7a7dec65 S	253	}
	254
	255	void ath_debug_stat_rc(struct ath_softc sc, struct sk_buff skb)
	256	{
	257	if (conf_is_ht(&sc->hw->conf))
	258	ath_debug_stat_11n_rc(sc, skb);
	259	else
	260	ath_debug_stat_legacy_rc(sc, skb);
	261	}
	262
029bc432 S	263	/* FIXME: legacy rates, later on .. */
029bc432 S	264	void ath_debug_stat_retries(struct ath_softc *sc, int rix,
9e712790	265	int xretries, int retries, u8 per)
029bc432 S	266	{
	267	if (conf_is_ht(&sc->hw->conf)) {
	268	int idx = sc->cur_rate_table->info[rix].dot11rate;
	269
17d7904d S	270	sc->debug.stats.n_rcstats[idx].xretries += xretries;
17d7904d S	271	sc->debug.stats.n_rcstats[idx].retries += retries;
9e712790	272	sc->debug.stats.n_rcstats[idx].per = per;
029bc432 S	273	}
	274	}
	275
7a7dec65 S	276	static ssize_t ath_read_file_stat_11n_rc(struct file *file,
	277	char __user *user_buf,
	278	size_t count, loff_t *ppos)
	279	{
	280	struct ath_softc *sc = file->private_data;
029bc432	281	char buf[1024];
7a7dec65 S	282	unsigned int len = 0;
	283	int i = 0;
	284
9e712790 S	285	len += sprintf(buf, "%7s %13s %8s %8s %6s\n\n", "Rate", "Success",
9e712790 S	286	"Retries", "XRetries", "PER");
7a7dec65 S	287
	288	for (i = 0; i <= 15; i++) {
	289	len += snprintf(buf + len, sizeof(buf) - len,
9e712790	290	"%5s%3d: %8u %8u %8u %8u\n", "MCS", i,
17d7904d S	291	sc->debug.stats.n_rcstats[i].success,
17d7904d S	292	sc->debug.stats.n_rcstats[i].retries,
9e712790 S	293	sc->debug.stats.n_rcstats[i].xretries,
9e712790 S	294	sc->debug.stats.n_rcstats[i].per);
7a7dec65 S	295	}
	296
	297	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
	298	}
	299
	300	static ssize_t ath_read_file_stat_legacy_rc(struct file *file,
	301	char __user *user_buf,
	302	size_t count, loff_t *ppos)
	303	{
	304	struct ath_softc *sc = file->private_data;
	305	char buf[512];
	306	unsigned int len = 0;
	307	int i = 0;
	308
	309	len += sprintf(buf, "%7s %13s\n\n", "Rate", "Success");
	310
	311	for (i = 0; i < sc->cur_rate_table->rate_cnt; i++) {
	312	len += snprintf(buf + len, sizeof(buf) - len, "%5u: %12u\n",
	313	sc->cur_rate_table->info[i].ratekbps / 1000,
17d7904d	314	sc->debug.stats.legacy_rcstats[i].success);
7a7dec65 S	315	}
	316
	317	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
	318	}
	319
	320	static ssize_t read_file_rcstat(struct file file, char __user user_buf,
	321	size_t count, loff_t *ppos)
	322	{
	323	struct ath_softc *sc = file->private_data;
	324
62b4fb66 S	325	if (sc->cur_rate_table == NULL)
	326	return 0;
	327
7a7dec65 S	328	if (conf_is_ht(&sc->hw->conf))
	329	return ath_read_file_stat_11n_rc(file, user_buf, count, ppos);
	330	else
	331	return ath_read_file_stat_legacy_rc(file, user_buf, count ,ppos);
	332	}
	333
	334	static const struct file_operations fops_rcstat = {
	335	.read = read_file_rcstat,
	336	.open = ath9k_debugfs_open,
	337	.owner = THIS_MODULE
	338	};
27abe060	339
39d89cd3 JM	340	static const char * ath_wiphy_state_str(enum ath_wiphy_state state)
	341	{
	342	switch (state) {
	343	case ATH_WIPHY_INACTIVE:
	344	return "INACTIVE";
	345	case ATH_WIPHY_ACTIVE:
	346	return "ACTIVE";
	347	case ATH_WIPHY_PAUSING:
	348	return "PAUSING";
	349	case ATH_WIPHY_PAUSED:
	350	return "PAUSED";
	351	case ATH_WIPHY_SCAN:
	352	return "SCAN";
	353	}
	354	return "?";
	355	}
	356
	357	static ssize_t read_file_wiphy(struct file file, char __user user_buf,
	358	size_t count, loff_t *ppos)
	359	{
	360	struct ath_softc *sc = file->private_data;
	361	char buf[512];
	362	unsigned int len = 0;
	363	int i;
	364	u8 addr[ETH_ALEN];
	365
	366	len += snprintf(buf + len, sizeof(buf) - len,
	367	"primary: %s (%s chan=%d ht=%d)\n",
	368	wiphy_name(sc->pri_wiphy->hw->wiphy),
	369	ath_wiphy_state_str(sc->pri_wiphy->state),
	370	sc->pri_wiphy->chan_idx, sc->pri_wiphy->chan_is_ht);
	371	for (i = 0; i < sc->num_sec_wiphy; i++) {
	372	struct ath_wiphy *aphy = sc->sec_wiphy[i];
	373	if (aphy == NULL)
	374	continue;
	375	len += snprintf(buf + len, sizeof(buf) - len,
	376	"secondary: %s (%s chan=%d ht=%d)\n",
	377	wiphy_name(aphy->hw->wiphy),
	378	ath_wiphy_state_str(aphy->state),
	379	aphy->chan_idx, aphy->chan_is_ht);
	380	}
	381
	382	put_unaligned_le32(REG_READ(sc->sc_ah, AR_STA_ID0), addr);
	383	put_unaligned_le16(REG_READ(sc->sc_ah, AR_STA_ID1) & 0xffff, addr + 4);
	384	len += snprintf(buf + len, sizeof(buf) - len,
	385	"addr: %pM\n", addr);
	386	put_unaligned_le32(REG_READ(sc->sc_ah, AR_BSSMSKL), addr);
	387	put_unaligned_le16(REG_READ(sc->sc_ah, AR_BSSMSKU) & 0xffff, addr + 4);
	388	len += snprintf(buf + len, sizeof(buf) - len,
	389	"addrmask: %pM\n", addr);
	390
	391	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
	392	}
	393
	394	static struct ath_wiphy * get_wiphy(struct ath_softc sc, const char name)
	395	{
	396	int i;
	397	if (strcmp(name, wiphy_name(sc->pri_wiphy->hw->wiphy)) == 0)
	398	return sc->pri_wiphy;
	399	for (i = 0; i < sc->num_sec_wiphy; i++) {
	400	struct ath_wiphy *aphy = sc->sec_wiphy[i];
	401	if (aphy && strcmp(name, wiphy_name(aphy->hw->wiphy)) == 0)
	402	return aphy;
	403	}
404	return NULL;
405	}
406
407	static int del_wiphy(struct ath_softc sc, const char name)
408	{
409	struct ath_wiphy *aphy = get_wiphy(sc, name);
410	if (!aphy)
411	return -ENOENT;
412	return ath9k_wiphy_del(aphy);
413	}
414
415	static int pause_wiphy(struct ath_softc sc, const char name)
416	{
417	struct ath_wiphy *aphy = get_wiphy(sc, name);
418	if (!aphy)
419	return -ENOENT;
420	return ath9k_wiphy_pause(aphy);
421	}
422
423	static int unpause_wiphy(struct ath_softc sc, const char name)
424	{
425	struct ath_wiphy *aphy = get_wiphy(sc, name);
426	if (!aphy)
427	return -ENOENT;
428	return ath9k_wiphy_unpause(aphy);
429	}
430
431	static int select_wiphy(struct ath_softc sc, const char name)
432	{
433	struct ath_wiphy *aphy = get_wiphy(sc, name);
434	if (!aphy)
435	return -ENOENT;
436	return ath9k_wiphy_select(aphy);
437	}
438
439	static int schedule_wiphy(struct ath_softc sc, const char msec)
440	{
441	ath9k_wiphy_set_scheduler(sc, simple_strtoul(msec, NULL, 0));
442	return 0;
443	}
444
445	static ssize_t write_file_wiphy(struct file file, const char __user user_buf,
446	size_t count, loff_t *ppos)
447	{
448	struct ath_softc *sc = file->private_data;
449	char buf[50];
450	size_t len;
451
452	len = min(count, sizeof(buf) - 1);
453	if (copy_from_user(buf, user_buf, len))
454	return -EFAULT;
455	buf[len] = '\0';
456	if (len > 0 && buf[len - 1] == '\n')
457	buf[len - 1] = '\0';
458
459	if (strncmp(buf, "add", 3) == 0) {
460	int res = ath9k_wiphy_add(sc);
461	if (res < 0)
462	return res;
463	} else if (strncmp(buf, "del=", 4) == 0) {
464	int res = del_wiphy(sc, buf + 4);
465	if (res < 0)
466	return res;
467	} else if (strncmp(buf, "pause=", 6) == 0) {
468	int res = pause_wiphy(sc, buf + 6);
469	if (res < 0)
470	return res;
471	} else if (strncmp(buf, "unpause=", 8) == 0) {
472	int res = unpause_wiphy(sc, buf + 8);
473	if (res < 0)
474	return res;
475	} else if (strncmp(buf, "select=", 7) == 0) {
476	int res = select_wiphy(sc, buf + 7);
477	if (res < 0)
478	return res;
479	} else if (strncmp(buf, "schedule=", 9) == 0) {
480	int res = schedule_wiphy(sc, buf + 9);
481	if (res < 0)
482	return res;
483	} else
484	return -EOPNOTSUPP;
485
486	return count;
487	}
488
489	static const struct file_operations fops_wiphy = {
490	.read = read_file_wiphy,
491	.write = write_file_wiphy,
492	.open = ath9k_debugfs_open,
493	.owner = THIS_MODULE
494	};
495
496
826d2680	497	int ath9k_init_debug(struct ath_softc *sc)
88b126af	498	{
17d7904d	499	sc->debug.debug_mask = ath9k_debug;
826d2680	500
17d7904d	501	sc->debug.debugfs_phy = debugfs_create_dir(wiphy_name(sc->hw->wiphy),
19d8bc22	502	ath9k_debugfs_root);
17d7904d	503	if (!sc->debug.debugfs_phy)
826d2680 S	504	goto err;
826d2680 S	505
17d7904d S	506	sc->debug.debugfs_dma = debugfs_create_file("dma", S_IRUGO,
	507	sc->debug.debugfs_phy, sc, &fops_dma);
	508	if (!sc->debug.debugfs_dma)
2a163c6d S	509	goto err;
2a163c6d S	510
17d7904d	511	sc->debug.debugfs_interrupt = debugfs_create_file("interrupt",
817e11de	512	S_IRUGO,
17d7904d	513	sc->debug.debugfs_phy,
817e11de	514	sc, &fops_interrupt);
17d7904d	515	if (!sc->debug.debugfs_interrupt)
817e11de S	516	goto err;
817e11de S	517
17d7904d	518	sc->debug.debugfs_rcstat = debugfs_create_file("rcstat",
7a7dec65	519	S_IRUGO,
17d7904d	520	sc->debug.debugfs_phy,
7a7dec65	521	sc, &fops_rcstat);
17d7904d	522	if (!sc->debug.debugfs_rcstat)
7a7dec65 S	523	goto err;
7a7dec65 S	524
39d89cd3 JM	525	sc->debug.debugfs_wiphy = debugfs_create_file(
	526	"wiphy", S_IRUGO \| S_IWUSR, sc->debug.debugfs_phy, sc,
	527	&fops_wiphy);
	528	if (!sc->debug.debugfs_wiphy)
	529	goto err;
	530
826d2680 S	531	return 0;
	532	err:
	533	ath9k_exit_debug(sc);
	534	return -ENOMEM;
	535	}
	536
	537	void ath9k_exit_debug(struct ath_softc *sc)
	538	{
39d89cd3	539	debugfs_remove(sc->debug.debugfs_wiphy);
17d7904d S	540	debugfs_remove(sc->debug.debugfs_rcstat);
	541	debugfs_remove(sc->debug.debugfs_interrupt);
	542	debugfs_remove(sc->debug.debugfs_dma);
	543	debugfs_remove(sc->debug.debugfs_phy);
19d8bc22 GJ	544	}
	545
	546	int ath9k_debug_create_root(void)
	547	{
	548	ath9k_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
	549	if (!ath9k_debugfs_root)
	550	return -ENOENT;
	551
	552	return 0;
	553	}
	554
	555	void ath9k_debug_remove_root(void)
	556	{
	557	debugfs_remove(ath9k_debugfs_root);
	558	ath9k_debugfs_root = NULL;
88b126af	559	}