[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-debugfs.c

/******************************************************************************
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2008 - 2009 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.GPL.
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *****************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/debugfs.h>

#include <linux/ieee80211.h>
#include <net/mac80211.h>


#include "iwl-dev.h"
#include "iwl-debug.h"
#include "iwl-core.h"
#include "iwl-io.h"


/* create and remove of files */
#define DEBUGFS_ADD_DIR(name, parent) do {                              \
	dbgfs->dir_##name = debugfs_create_dir(#name, parent);          \
	if (!(dbgfs->dir_##name))                                       \
		goto err; 						\
} while (0)

#define DEBUGFS_ADD_FILE(name, parent) do {                             \
	dbgfs->dbgfs_##parent##_files.file_##name =                     \
	debugfs_create_file(#name, 0644, dbgfs->dir_##parent, priv,     \
				&iwl_dbgfs_##name##_ops);               \
	if (!(dbgfs->dbgfs_##parent##_files.file_##name))               \
		goto err;                                               \
} while (0)

#define DEBUGFS_ADD_BOOL(name, parent, ptr) do {                        \
	dbgfs->dbgfs_##parent##_files.file_##name =                     \
	debugfs_create_bool(#name, 0644, dbgfs->dir_##parent, ptr);     \
	if (IS_ERR(dbgfs->dbgfs_##parent##_files.file_##name)		\
			|| !dbgfs->dbgfs_##parent##_files.file_##name)	\
		goto err;                                               \
} while (0)

#define DEBUGFS_ADD_X32(name, parent, ptr) do {                        \
	dbgfs->dbgfs_##parent##_files.file_##name =                     \
	debugfs_create_x32(#name, 0444, dbgfs->dir_##parent, ptr);     \
	if (IS_ERR(dbgfs->dbgfs_##parent##_files.file_##name)		\
			|| !dbgfs->dbgfs_##parent##_files.file_##name)	\
		goto err;                                               \
} while (0)

#define DEBUGFS_REMOVE(name)  do {              \
	debugfs_remove(name);                   \
	name = NULL;                            \
} while (0);

/* file operation */
#define DEBUGFS_READ_FUNC(name)                                         \
static ssize_t iwl_dbgfs_##name##_read(struct file *file,               \
					char __user *user_buf,          \
					size_t count, loff_t *ppos);

#define DEBUGFS_WRITE_FUNC(name)                                        \
static ssize_t iwl_dbgfs_##name##_write(struct file *file,              \
					const char __user *user_buf,    \
					size_t count, loff_t *ppos);


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

#define DEBUGFS_READ_FILE_OPS(name)                                     \
	DEBUGFS_READ_FUNC(name);                                        \
static const struct file_operations iwl_dbgfs_##name##_ops = {          \
	.read = iwl_dbgfs_##name##_read,                       		\
	.open = iwl_dbgfs_open_file_generic,                    	\
};

#define DEBUGFS_WRITE_FILE_OPS(name)                                    \
	DEBUGFS_WRITE_FUNC(name);                                       \
static const struct file_operations iwl_dbgfs_##name##_ops = {          \
	.write = iwl_dbgfs_##name##_write,                              \
	.open = iwl_dbgfs_open_file_generic,                    	\
};


#define DEBUGFS_READ_WRITE_FILE_OPS(name)                               \
	DEBUGFS_READ_FUNC(name);                                        \
	DEBUGFS_WRITE_FUNC(name);                                       \
static const struct file_operations iwl_dbgfs_##name##_ops = {          \
	.write = iwl_dbgfs_##name##_write,                              \
	.read = iwl_dbgfs_##name##_read,                                \
	.open = iwl_dbgfs_open_file_generic,                            \
};


static ssize_t iwl_dbgfs_tx_statistics_read(struct file *file,
						char __user *user_buf,
						size_t count, loff_t *ppos) {

	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
	char buf[256];
	int pos = 0;
	const size_t bufsz = sizeof(buf);

	pos += scnprintf(buf + pos, bufsz - pos, "mgmt: %u\n",
						priv->tx_stats[0].cnt);
	pos += scnprintf(buf + pos, bufsz - pos, "ctrl: %u\n",
						priv->tx_stats[1].cnt);
	pos += scnprintf(buf + pos, bufsz - pos, "data: %u\n",
						priv->tx_stats[2].cnt);

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

static ssize_t iwl_dbgfs_rx_statistics_read(struct file *file,
						char __user *user_buf,
						size_t count, loff_t *ppos) {

	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
	char buf[256];
	int pos = 0;
	const size_t bufsz = sizeof(buf);

	pos += scnprintf(buf + pos, bufsz - pos, "mgmt: %u\n",
						priv->rx_stats[0].cnt);
	pos += scnprintf(buf + pos, bufsz - pos, "ctrl: %u\n",
						priv->rx_stats[1].cnt);
	pos += scnprintf(buf + pos, bufsz - pos, "data: %u\n",
						priv->rx_stats[2].cnt);

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

#define BYTE1_MASK 0x000000ff;
#define BYTE2_MASK 0x0000ffff;
#define BYTE3_MASK 0x00ffffff;
static ssize_t iwl_dbgfs_sram_read(struct file *file,
					char __user *user_buf,
					size_t count, loff_t *ppos)
{
	u32 val;
	char buf[1024];
	ssize_t ret;
	int i;
	int pos = 0;
	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
	const size_t bufsz = sizeof(buf);

	iwl_grab_nic_access(priv);
	for (i = priv->dbgfs->sram_len; i > 0; i -= 4) {
		val = iwl_read_targ_mem(priv, priv->dbgfs->sram_offset + \
					priv->dbgfs->sram_len - i);
		if (i < 4) {
			switch (i) {
			case 1:
				val &= BYTE1_MASK;
				break;
			case 2:
				val &= BYTE2_MASK;
				break;
			case 3:
				val &= BYTE3_MASK;
				break;
			}
		}
		pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val);
	}
	pos += scnprintf(buf + pos, bufsz - pos, "\n");
	iwl_release_nic_access(priv);

	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	return ret;
}

static ssize_t iwl_dbgfs_sram_write(struct file *file,
					const char __user *user_buf,
					size_t count, loff_t *ppos)
{
	struct iwl_priv *priv = file->private_data;
	char buf[64];
	int buf_size;
	u32 offset, len;

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

	if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
		priv->dbgfs->sram_offset = offset;
		priv->dbgfs->sram_len = len;
	} else {
		priv->dbgfs->sram_offset = 0;
		priv->dbgfs->sram_len = 0;
	}

	return count;
}

static ssize_t iwl_dbgfs_stations_read(struct file *file, char __user *user_buf,
					size_t count, loff_t *ppos)
{
	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
	struct iwl_station_entry *station;
	int max_sta = priv->hw_params.max_stations;
	char *buf;
	int i, j, pos = 0;
	ssize_t ret;
	/* Add 30 for initial string */
	const size_t bufsz = 30 + sizeof(char) * 500 * (priv->num_stations);

	buf = kmalloc(bufsz, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
			priv->num_stations);

	for (i = 0; i < max_sta; i++) {
		station = &priv->stations[i];
		if (station->used) {
			pos += scnprintf(buf + pos, bufsz - pos,
					"station %d:\ngeneral data:\n", i+1);
			pos += scnprintf(buf + pos, bufsz - pos, "id: %u\n",
					station->sta.sta.sta_id);
			pos += scnprintf(buf + pos, bufsz - pos, "mode: %u\n",
					station->sta.mode);
			pos += scnprintf(buf + pos, bufsz - pos,
					"flags: 0x%x\n",
					station->sta.station_flags_msk);
			pos += scnprintf(buf + pos, bufsz - pos,
					"ps_status: %u\n", station->ps_status);
			pos += scnprintf(buf + pos, bufsz - pos, "tid data:\n");
			pos += scnprintf(buf + pos, bufsz - pos,
					"seq_num\t\ttxq_id");
			pos += scnprintf(buf + pos, bufsz - pos,
					"\tframe_count\twait_for_ba\t");
			pos += scnprintf(buf + pos, bufsz - pos,
					"start_idx\tbitmap0\t");
			pos += scnprintf(buf + pos, bufsz - pos,
					"bitmap1\trate_n_flags");
			pos += scnprintf(buf + pos, bufsz - pos, "\n");

			for (j = 0; j < MAX_TID_COUNT; j++) {
				pos += scnprintf(buf + pos, bufsz - pos,
						"[%d]:\t\t%u", j,
						station->tid[j].seq_number);
				pos += scnprintf(buf + pos, bufsz - pos,
						"\t%u\t\t%u\t\t%u\t\t",
						station->tid[j].agg.txq_id,
						station->tid[j].agg.frame_count,
						station->tid[j].agg.wait_for_ba);
				pos += scnprintf(buf + pos, bufsz - pos,
						"%u\t%llu\t%u",
						station->tid[j].agg.start_idx,
						(unsigned long long)station->tid[j].agg.bitmap,
						station->tid[j].agg.rate_n_flags);
				pos += scnprintf(buf + pos, bufsz - pos, "\n");
			}
			pos += scnprintf(buf + pos, bufsz - pos, "\n");
		}
	}

	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	kfree(buf);
	return ret;
}

static ssize_t iwl_dbgfs_eeprom_read(struct file *file,
				       char __user *user_buf,
				       size_t count,
				       loff_t *ppos)
{
	ssize_t ret;
	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
	int pos = 0, ofs = 0, buf_size = 0;
	const u8 *ptr;
	char *buf;
	size_t eeprom_len = priv->cfg->eeprom_size;
	buf_size = 4 * eeprom_len + 256;

	if (eeprom_len % 16) {
		IWL_ERR(priv, "EEPROM size is not multiple of 16.\n");
		return -ENODATA;
	}

	/* 4 characters for byte 0xYY */
	buf = kzalloc(buf_size, GFP_KERNEL);
	if (!buf) {
		IWL_ERR(priv, "Can not allocate Buffer\n");
		return -ENOMEM;
	}

	ptr = priv->eeprom;
	for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
		pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x ", ofs);
		hex_dump_to_buffer(ptr + ofs, 16 , 16, 2, buf + pos,
				   buf_size - pos, 0);
		pos += strlen(buf);
		if (buf_size - pos > 0)
			buf[pos++] = '\n';
	}

	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	kfree(buf);
	return ret;
}

static ssize_t iwl_dbgfs_log_event_write(struct file *file,
					const char __user *user_buf,
					size_t count, loff_t *ppos)
{
	struct iwl_priv *priv = file->private_data;
	u32 event_log_flag;
	char buf[8];
	int buf_size;

	memset(buf, 0, sizeof(buf));
	buf_size = min(count, sizeof(buf) -  1);
	if (copy_from_user(buf, user_buf, buf_size))
		return -EFAULT;
	if (sscanf(buf, "%d", &event_log_flag) != 1)
		return -EFAULT;
	if (event_log_flag == 1)
		iwl_dump_nic_event_log(priv);

	return count;
}


static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
				       size_t count, loff_t *ppos)
{
	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
	struct ieee80211_channel *channels = NULL;
	const struct ieee80211_supported_band *supp_band = NULL;
	int pos = 0, i, bufsz = PAGE_SIZE;
	char *buf;
	ssize_t ret;

	if (!test_bit(STATUS_GEO_CONFIGURED, &priv->status))
		return -EAGAIN;

	buf = kzalloc(bufsz, GFP_KERNEL);
	if (!buf) {
		IWL_ERR(priv, "Can not allocate Buffer\n");
		return -ENOMEM;
	}

	supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_2GHZ);
	channels = supp_band->channels;

	pos += scnprintf(buf + pos, bufsz - pos,
			"Displaying %d channels in 2.4GHz band 802.11bg):\n",
			 supp_band->n_channels);

	for (i = 0; i < supp_band->n_channels; i++)
		pos += scnprintf(buf + pos, bufsz - pos,
				"%d: %ddBm: BSS%s%s, %s.\n",
				ieee80211_frequency_to_channel(
				channels[i].center_freq),
				channels[i].max_power,
				channels[i].flags & IEEE80211_CHAN_RADAR ?
				" (IEEE 802.11h required)" : "",
				(!(channels[i].flags & IEEE80211_CHAN_NO_IBSS)
				|| (channels[i].flags &
				IEEE80211_CHAN_RADAR)) ? "" :
				", IBSS",
				channels[i].flags &
				IEEE80211_CHAN_PASSIVE_SCAN ?
				"passive only" : "active/passive");

	supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_5GHZ);
	channels = supp_band->channels;

	pos += scnprintf(buf + pos, bufsz - pos,
			"Displaying %d channels in 5.2GHz band (802.11a)\n",
			supp_band->n_channels);

	for (i = 0; i < supp_band->n_channels; i++)
		pos += scnprintf(buf + pos, bufsz - pos,
				"%d: %ddBm: BSS%s%s, %s.\n",
				ieee80211_frequency_to_channel(
				channels[i].center_freq),
				channels[i].max_power,
				channels[i].flags & IEEE80211_CHAN_RADAR ?
				" (IEEE 802.11h required)" : "",
				((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
				|| (channels[i].flags &
				IEEE80211_CHAN_RADAR)) ? "" :
				", IBSS",
				channels[i].flags &
				IEEE80211_CHAN_PASSIVE_SCAN ?
				"passive only" : "active/passive");

	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	kfree(buf);
	return ret;
}

DEBUGFS_READ_WRITE_FILE_OPS(sram);
DEBUGFS_WRITE_FILE_OPS(log_event);
DEBUGFS_READ_FILE_OPS(eeprom);
DEBUGFS_READ_FILE_OPS(stations);
DEBUGFS_READ_FILE_OPS(rx_statistics);
DEBUGFS_READ_FILE_OPS(tx_statistics);
DEBUGFS_READ_FILE_OPS(channels);

/*
 * Create the debugfs files and directories
 *
 */
int iwl_dbgfs_register(struct iwl_priv *priv, const char *name)
{
	struct iwl_debugfs *dbgfs;
	struct dentry *phyd = priv->hw->wiphy->debugfsdir;
	int ret = 0;

	dbgfs = kzalloc(sizeof(struct iwl_debugfs), GFP_KERNEL);
	if (!dbgfs) {
		ret = -ENOMEM;
		goto err;
	}

	priv->dbgfs = dbgfs;
	dbgfs->name = name;
	dbgfs->dir_drv = debugfs_create_dir(name, phyd);
	if (!dbgfs->dir_drv || IS_ERR(dbgfs->dir_drv)) {
		ret = -ENOENT;
		goto err;
	}

	DEBUGFS_ADD_DIR(data, dbgfs->dir_drv);
	DEBUGFS_ADD_DIR(rf, dbgfs->dir_drv);
	DEBUGFS_ADD_FILE(eeprom, data);
	DEBUGFS_ADD_FILE(sram, data);
	DEBUGFS_ADD_FILE(log_event, data);
	DEBUGFS_ADD_FILE(stations, data);
	DEBUGFS_ADD_FILE(rx_statistics, data);
	DEBUGFS_ADD_FILE(tx_statistics, data);
	DEBUGFS_ADD_FILE(channels, data);
	DEBUGFS_ADD_X32(status, data, (u32 *)&priv->status);
	DEBUGFS_ADD_BOOL(disable_sensitivity, rf, &priv->disable_sens_cal);
	DEBUGFS_ADD_BOOL(disable_chain_noise, rf,
			 &priv->disable_chain_noise_cal);
	DEBUGFS_ADD_BOOL(disable_tx_power, rf, &priv->disable_tx_power_cal);
	return 0;

err:
	IWL_ERR(priv, "Can't open the debugfs directory\n");
	iwl_dbgfs_unregister(priv);
	return ret;
}
EXPORT_SYMBOL(iwl_dbgfs_register);

/**
 * Remove the debugfs files and directories
 *
 */
void iwl_dbgfs_unregister(struct iwl_priv *priv)
{
	if (!priv->dbgfs)
		return;

	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_eeprom);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_rx_statistics);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_tx_statistics);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_sram);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_log_event);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_stations);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_channels);
	DEBUGFS_REMOVE(priv->dbgfs->dir_data);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_sensitivity);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_chain_noise);
	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_tx_power);
	DEBUGFS_REMOVE(priv->dbgfs->dir_rf);
	DEBUGFS_REMOVE(priv->dbgfs->dir_drv);
	kfree(priv->dbgfs);
	priv->dbgfs = NULL;
}
EXPORT_SYMBOL(iwl_dbgfs_unregister);
Commit	Line	Data
712b6cf5 TW	1	/******************************************************************************
	2	*
	3	* GPL LICENSE SUMMARY
	4	*
01f8162a	5	* Copyright(c) 2008 - 2009 Intel Corporation. All rights reserved.
712b6cf5 TW	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of version 2 of the GNU General Public License as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
	19	* USA
	20	*
	21	* The full GNU General Public License is included in this distribution
	22	* in the file called LICENSE.GPL.
	23	*
	24	* Contact Information:
759ef89f	25	* Intel Linux Wireless <ilw@linux.intel.com>
712b6cf5 TW	26	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	27	*****************************************************************************/
	28
	29	#include <linux/kernel.h>
	30	#include <linux/module.h>
	31	#include <linux/debugfs.h>
	32
	33	#include <linux/ieee80211.h>
	34	#include <net/mac80211.h>
	35
	36
3e0d4cb1	37	#include "iwl-dev.h"
712b6cf5	38	#include "iwl-debug.h"
fee1247a	39	#include "iwl-core.h"
3395f6e9	40	#include "iwl-io.h"
712b6cf5 TW	41
	42
	43	/* create and remove of files */
	44	#define DEBUGFS_ADD_DIR(name, parent) do { \
	45	dbgfs->dir_##name = debugfs_create_dir(#name, parent); \
	46	if (!(dbgfs->dir_##name)) \
	47	goto err; \
	48	} while (0)
	49
	50	#define DEBUGFS_ADD_FILE(name, parent) do { \
	51	dbgfs->dbgfs_##parent##_files.file_##name = \
	52	debugfs_create_file(#name, 0644, dbgfs->dir_##parent, priv, \
	53	&iwl_dbgfs_##name##_ops); \
	54	if (!(dbgfs->dbgfs_##parent##_files.file_##name)) \
	55	goto err; \
	56	} while (0)
	57
445c2dff TW	58	#define DEBUGFS_ADD_BOOL(name, parent, ptr) do { \
	59	dbgfs->dbgfs_##parent##_files.file_##name = \
	60	debugfs_create_bool(#name, 0644, dbgfs->dir_##parent, ptr); \
9b24001d Z	61	if (IS_ERR(dbgfs->dbgfs_##parent##_files.file_##name) \
9b24001d Z	62	\|\| !dbgfs->dbgfs_##parent##_files.file_##name) \
445c2dff TW	63	goto err; \
	64	} while (0)
	65
2ddfa129 WT	66	#define DEBUGFS_ADD_X32(name, parent, ptr) do { \
	67	dbgfs->dbgfs_##parent##_files.file_##name = \
	68	debugfs_create_x32(#name, 0444, dbgfs->dir_##parent, ptr); \
	69	if (IS_ERR(dbgfs->dbgfs_##parent##_files.file_##name) \
	70	\|\| !dbgfs->dbgfs_##parent##_files.file_##name) \
	71	goto err; \
	72	} while (0)
	73
712b6cf5 TW	74	#define DEBUGFS_REMOVE(name) do { \
	75	debugfs_remove(name); \
	76	name = NULL; \
	77	} while (0);
	78
	79	/* file operation */
	80	#define DEBUGFS_READ_FUNC(name) \
	81	static ssize_t iwl_dbgfs_##name##_read(struct file *file, \
	82	char __user *user_buf, \
	83	size_t count, loff_t *ppos);
	84
	85	#define DEBUGFS_WRITE_FUNC(name) \
	86	static ssize_t iwl_dbgfs_##name##_write(struct file *file, \
	87	const char __user *user_buf, \
	88	size_t count, loff_t *ppos);
	89
	90
	91	static int iwl_dbgfs_open_file_generic(struct inode inode, struct file file)
	92	{
	93	file->private_data = inode->i_private;
	94	return 0;
	95	}
	96
	97	#define DEBUGFS_READ_FILE_OPS(name) \
	98	DEBUGFS_READ_FUNC(name); \
	99	static const struct file_operations iwl_dbgfs_##name##_ops = { \
	100	.read = iwl_dbgfs_##name##_read, \
	101	.open = iwl_dbgfs_open_file_generic, \
	102	};
	103
189a2b59 EK	104	#define DEBUGFS_WRITE_FILE_OPS(name) \
	105	DEBUGFS_WRITE_FUNC(name); \
	106	static const struct file_operations iwl_dbgfs_##name##_ops = { \
	107	.write = iwl_dbgfs_##name##_write, \
	108	.open = iwl_dbgfs_open_file_generic, \
	109	};
	110
	111
712b6cf5 TW	112	#define DEBUGFS_READ_WRITE_FILE_OPS(name) \
	113	DEBUGFS_READ_FUNC(name); \
	114	DEBUGFS_WRITE_FUNC(name); \
	115	static const struct file_operations iwl_dbgfs_##name##_ops = { \
	116	.write = iwl_dbgfs_##name##_write, \
	117	.read = iwl_dbgfs_##name##_read, \
	118	.open = iwl_dbgfs_open_file_generic, \
	119	};
	120
	121
	122	static ssize_t iwl_dbgfs_tx_statistics_read(struct file *file,
	123	char __user *user_buf,
	124	size_t count, loff_t *ppos) {
	125
	126	struct iwl_priv priv = (struct iwl_priv )file->private_data;
	127	char buf[256];
	128	int pos = 0;
db0589f3	129	const size_t bufsz = sizeof(buf);
712b6cf5	130
db0589f3 AK	131	pos += scnprintf(buf + pos, bufsz - pos, "mgmt: %u\n",
	132	priv->tx_stats[0].cnt);
	133	pos += scnprintf(buf + pos, bufsz - pos, "ctrl: %u\n",
	134	priv->tx_stats[1].cnt);
	135	pos += scnprintf(buf + pos, bufsz - pos, "data: %u\n",
	136	priv->tx_stats[2].cnt);
712b6cf5 TW	137
	138	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	139	}
	140
	141	static ssize_t iwl_dbgfs_rx_statistics_read(struct file *file,
	142	char __user *user_buf,
	143	size_t count, loff_t *ppos) {
	144
	145	struct iwl_priv priv = (struct iwl_priv )file->private_data;
	146	char buf[256];
	147	int pos = 0;
db0589f3	148	const size_t bufsz = sizeof(buf);
712b6cf5	149
db0589f3 AK	150	pos += scnprintf(buf + pos, bufsz - pos, "mgmt: %u\n",
	151	priv->rx_stats[0].cnt);
	152	pos += scnprintf(buf + pos, bufsz - pos, "ctrl: %u\n",
	153	priv->rx_stats[1].cnt);
	154	pos += scnprintf(buf + pos, bufsz - pos, "data: %u\n",
	155	priv->rx_stats[2].cnt);
712b6cf5 TW	156
	157	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	158	}
	159
	160	#define BYTE1_MASK 0x000000ff;
	161	#define BYTE2_MASK 0x0000ffff;
	162	#define BYTE3_MASK 0x00ffffff;
	163	static ssize_t iwl_dbgfs_sram_read(struct file *file,
	164	char __user *user_buf,
	165	size_t count, loff_t *ppos)
	166	{
	167	u32 val;
	168	char buf[1024];
	169	ssize_t ret;
	170	int i;
	171	int pos = 0;
	172	struct iwl_priv priv = (struct iwl_priv )file->private_data;
db0589f3	173	const size_t bufsz = sizeof(buf);
712b6cf5	174
3395f6e9	175	iwl_grab_nic_access(priv);
712b6cf5	176	for (i = priv->dbgfs->sram_len; i > 0; i -= 4) {
3395f6e9	177	val = iwl_read_targ_mem(priv, priv->dbgfs->sram_offset + \
712b6cf5 TW	178	priv->dbgfs->sram_len - i);
	179	if (i < 4) {
	180	switch (i) {
	181	case 1:
	182	val &= BYTE1_MASK;
	183	break;
	184	case 2:
	185	val &= BYTE2_MASK;
	186	break;
	187	case 3:
	188	val &= BYTE3_MASK;
	189	break;
	190	}
	191	}
db0589f3	192	pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val);
712b6cf5	193	}
db0589f3	194	pos += scnprintf(buf + pos, bufsz - pos, "\n");
3395f6e9	195	iwl_release_nic_access(priv);
712b6cf5 TW	196
	197	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	198	return ret;
	199	}
	200
	201	static ssize_t iwl_dbgfs_sram_write(struct file *file,
	202	const char __user *user_buf,
	203	size_t count, loff_t *ppos)
	204	{
	205	struct iwl_priv *priv = file->private_data;
	206	char buf[64];
	207	int buf_size;
	208	u32 offset, len;
	209
	210	memset(buf, 0, sizeof(buf));
	211	buf_size = min(count, sizeof(buf) - 1);
	212	if (copy_from_user(buf, user_buf, buf_size))
	213	return -EFAULT;
	214
	215	if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
	216	priv->dbgfs->sram_offset = offset;
	217	priv->dbgfs->sram_len = len;
	218	} else {
	219	priv->dbgfs->sram_offset = 0;
	220	priv->dbgfs->sram_len = 0;
	221	}
	222
	223	return count;
	224	}
	225
	226	static ssize_t iwl_dbgfs_stations_read(struct file file, char __user user_buf,
	227	size_t count, loff_t *ppos)
	228	{
	229	struct iwl_priv priv = (struct iwl_priv )file->private_data;
6def9761	230	struct iwl_station_entry *station;
5425e490	231	int max_sta = priv->hw_params.max_stations;
712b6cf5 TW	232	char *buf;
	233	int i, j, pos = 0;
	234	ssize_t ret;
	235	/* Add 30 for initial string */
	236	const size_t bufsz = 30 + sizeof(char) * 500 * (priv->num_stations);
712b6cf5 TW	237
712b6cf5 TW	238	buf = kmalloc(bufsz, GFP_KERNEL);
3ac7f146	239	if (!buf)
712b6cf5 TW	240	return -ENOMEM;
712b6cf5 TW	241
db0589f3	242	pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
712b6cf5 TW	243	priv->num_stations);
	244
	245	for (i = 0; i < max_sta; i++) {
	246	station = &priv->stations[i];
	247	if (station->used) {
db0589f3 AK	248	pos += scnprintf(buf + pos, bufsz - pos,
db0589f3 AK	249	"station %d:\ngeneral data:\n", i+1);
db0589f3	250	pos += scnprintf(buf + pos, bufsz - pos, "id: %u\n",
712b6cf5	251	station->sta.sta.sta_id);
db0589f3	252	pos += scnprintf(buf + pos, bufsz - pos, "mode: %u\n",
712b6cf5	253	station->sta.mode);
db0589f3 AK	254	pos += scnprintf(buf + pos, bufsz - pos,
db0589f3 AK	255	"flags: 0x%x\n",
712b6cf5	256	station->sta.station_flags_msk);
db0589f3 AK	257	pos += scnprintf(buf + pos, bufsz - pos,
	258	"ps_status: %u\n", station->ps_status);
	259	pos += scnprintf(buf + pos, bufsz - pos, "tid data:\n");
	260	pos += scnprintf(buf + pos, bufsz - pos,
344234de	261	"seq_num\t\ttxq_id");
db0589f3	262	pos += scnprintf(buf + pos, bufsz - pos,
344234de	263	"\tframe_count\twait_for_ba\t");
db0589f3 AK	264	pos += scnprintf(buf + pos, bufsz - pos,
	265	"start_idx\tbitmap0\t");
	266	pos += scnprintf(buf + pos, bufsz - pos,
344234de	267	"bitmap1\trate_n_flags");
344234de	268	pos += scnprintf(buf + pos, bufsz - pos, "\n");
712b6cf5 TW	269
712b6cf5 TW	270	for (j = 0; j < MAX_TID_COUNT; j++) {
db0589f3	271	pos += scnprintf(buf + pos, bufsz - pos,
344234de	272	"[%d]:\t\t%u", j,
db0589f3 AK	273	station->tid[j].seq_number);
db0589f3 AK	274	pos += scnprintf(buf + pos, bufsz - pos,
344234de	275	"\t%u\t\t%u\t\t%u\t\t",
712b6cf5 TW	276	station->tid[j].agg.txq_id,
	277	station->tid[j].agg.frame_count,
	278	station->tid[j].agg.wait_for_ba);
db0589f3	279	pos += scnprintf(buf + pos, bufsz - pos,
344234de	280	"%u\t%llu\t%u",
712b6cf5	281	station->tid[j].agg.start_idx,
16788599	282	(unsigned long long)station->tid[j].agg.bitmap,
712b6cf5	283	station->tid[j].agg.rate_n_flags);
344234de	284	pos += scnprintf(buf + pos, bufsz - pos, "\n");
712b6cf5	285	}
db0589f3	286	pos += scnprintf(buf + pos, bufsz - pos, "\n");
712b6cf5 TW	287	}
	288	}
	289
	290	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	291	kfree(buf);
	292	return ret;
	293	}
	294
8dd266ef TW	295	static ssize_t iwl_dbgfs_eeprom_read(struct file *file,
	296	char __user *user_buf,
	297	size_t count,
	298	loff_t *ppos)
	299	{
	300	ssize_t ret;
	301	struct iwl_priv priv = (struct iwl_priv )file->private_data;
	302	int pos = 0, ofs = 0, buf_size = 0;
	303	const u8 *ptr;
	304	char *buf;
	305	size_t eeprom_len = priv->cfg->eeprom_size;
	306	buf_size = 4 * eeprom_len + 256;
	307
	308	if (eeprom_len % 16) {
15b1687c	309	IWL_ERR(priv, "EEPROM size is not multiple of 16.\n");
8dd266ef TW	310	return -ENODATA;
	311	}
	312
	313	/* 4 characters for byte 0xYY */
	314	buf = kzalloc(buf_size, GFP_KERNEL);
	315	if (!buf) {
15b1687c	316	IWL_ERR(priv, "Can not allocate Buffer\n");
8dd266ef TW	317	return -ENOMEM;
	318	}
	319
	320	ptr = priv->eeprom;
	321	for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
	322	pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x ", ofs);
	323	hex_dump_to_buffer(ptr + ofs, 16 , 16, 2, buf + pos,
	324	buf_size - pos, 0);
	325	pos += strlen(buf);
	326	if (buf_size - pos > 0)
	327	buf[pos++] = '\n';
	328	}
	329
	330	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	331	kfree(buf);
	332	return ret;
	333	}
712b6cf5	334
189a2b59 EK	335	static ssize_t iwl_dbgfs_log_event_write(struct file *file,
	336	const char __user *user_buf,
	337	size_t count, loff_t *ppos)
	338	{
	339	struct iwl_priv *priv = file->private_data;
	340	u32 event_log_flag;
	341	char buf[8];
	342	int buf_size;
	343
	344	memset(buf, 0, sizeof(buf));
	345	buf_size = min(count, sizeof(buf) - 1);
	346	if (copy_from_user(buf, user_buf, buf_size))
	347	return -EFAULT;
	348	if (sscanf(buf, "%d", &event_log_flag) != 1)
	349	return -EFAULT;
	350	if (event_log_flag == 1)
	351	iwl_dump_nic_event_log(priv);
	352
	353	return count;
	354	}
	355
d366df5a WT	356
	357
	358	static ssize_t iwl_dbgfs_channels_read(struct file file, char __user user_buf,
	359	size_t count, loff_t *ppos)
	360	{
	361	struct iwl_priv priv = (struct iwl_priv )file->private_data;
	362	struct ieee80211_channel *channels = NULL;
	363	const struct ieee80211_supported_band *supp_band = NULL;
	364	int pos = 0, i, bufsz = PAGE_SIZE;
	365	char *buf;
	366	ssize_t ret;
	367
	368	if (!test_bit(STATUS_GEO_CONFIGURED, &priv->status))
	369	return -EAGAIN;
	370
	371	buf = kzalloc(bufsz, GFP_KERNEL);
	372	if (!buf) {
15b1687c	373	IWL_ERR(priv, "Can not allocate Buffer\n");
d366df5a WT	374	return -ENOMEM;
	375	}
	376
	377	supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_2GHZ);
	378	channels = supp_band->channels;
	379
	380	pos += scnprintf(buf + pos, bufsz - pos,
	381	"Displaying %d channels in 2.4GHz band 802.11bg):\n",
	382	supp_band->n_channels);
	383
	384	for (i = 0; i < supp_band->n_channels; i++)
	385	pos += scnprintf(buf + pos, bufsz - pos,
	386	"%d: %ddBm: BSS%s%s, %s.\n",
	387	ieee80211_frequency_to_channel(
	388	channels[i].center_freq),
	389	channels[i].max_power,
	390	channels[i].flags & IEEE80211_CHAN_RADAR ?
	391	" (IEEE 802.11h required)" : "",
	392	(!(channels[i].flags & IEEE80211_CHAN_NO_IBSS)
	393	\|\| (channels[i].flags &
	394	IEEE80211_CHAN_RADAR)) ? "" :
	395	", IBSS",
	396	channels[i].flags &
	397	IEEE80211_CHAN_PASSIVE_SCAN ?
	398	"passive only" : "active/passive");
	399
	400	supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_5GHZ);
	401	channels = supp_band->channels;
	402
	403	pos += scnprintf(buf + pos, bufsz - pos,
	404	"Displaying %d channels in 5.2GHz band (802.11a)\n",
	405	supp_band->n_channels);
	406
	407	for (i = 0; i < supp_band->n_channels; i++)
	408	pos += scnprintf(buf + pos, bufsz - pos,
	409	"%d: %ddBm: BSS%s%s, %s.\n",
	410	ieee80211_frequency_to_channel(
	411	channels[i].center_freq),
	412	channels[i].max_power,
	413	channels[i].flags & IEEE80211_CHAN_RADAR ?
	414	" (IEEE 802.11h required)" : "",
	415	((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
	416	\|\| (channels[i].flags &
	417	IEEE80211_CHAN_RADAR)) ? "" :
	418	", IBSS",
	419	channels[i].flags &
	420	IEEE80211_CHAN_PASSIVE_SCAN ?
	421	"passive only" : "active/passive");
	422
	423	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
	424	kfree(buf);
	425	return ret;
	426	}
	427
712b6cf5	428	DEBUGFS_READ_WRITE_FILE_OPS(sram);
189a2b59	429	DEBUGFS_WRITE_FILE_OPS(log_event);
8dd266ef	430	DEBUGFS_READ_FILE_OPS(eeprom);
712b6cf5 TW	431	DEBUGFS_READ_FILE_OPS(stations);
	432	DEBUGFS_READ_FILE_OPS(rx_statistics);
	433	DEBUGFS_READ_FILE_OPS(tx_statistics);
d366df5a	434	DEBUGFS_READ_FILE_OPS(channels);
712b6cf5 TW	435
	436	/*
	437	* Create the debugfs files and directories
	438	*
	439	*/
	440	int iwl_dbgfs_register(struct iwl_priv priv, const char name)
	441	{
	442	struct iwl_debugfs *dbgfs;
95b1a822	443	struct dentry *phyd = priv->hw->wiphy->debugfsdir;
3ac7f146	444	int ret = 0;
712b6cf5 TW	445
	446	dbgfs = kzalloc(sizeof(struct iwl_debugfs), GFP_KERNEL);
	447	if (!dbgfs) {
3ac7f146	448	ret = -ENOMEM;
712b6cf5 TW	449	goto err;
	450	}
	451
	452	priv->dbgfs = dbgfs;
	453	dbgfs->name = name;
95b1a822	454	dbgfs->dir_drv = debugfs_create_dir(name, phyd);
3ac7f146 TW	455	if (!dbgfs->dir_drv \|\| IS_ERR(dbgfs->dir_drv)) {
3ac7f146 TW	456	ret = -ENOENT;
712b6cf5 TW	457	goto err;
	458	}
	459
	460	DEBUGFS_ADD_DIR(data, dbgfs->dir_drv);
445c2dff	461	DEBUGFS_ADD_DIR(rf, dbgfs->dir_drv);
8dd266ef	462	DEBUGFS_ADD_FILE(eeprom, data);
712b6cf5	463	DEBUGFS_ADD_FILE(sram, data);
189a2b59	464	DEBUGFS_ADD_FILE(log_event, data);
712b6cf5 TW	465	DEBUGFS_ADD_FILE(stations, data);
	466	DEBUGFS_ADD_FILE(rx_statistics, data);
	467	DEBUGFS_ADD_FILE(tx_statistics, data);
d366df5a	468	DEBUGFS_ADD_FILE(channels, data);
2ddfa129	469	DEBUGFS_ADD_X32(status, data, (u32 *)&priv->status);
445c2dff TW	470	DEBUGFS_ADD_BOOL(disable_sensitivity, rf, &priv->disable_sens_cal);
	471	DEBUGFS_ADD_BOOL(disable_chain_noise, rf,
	472	&priv->disable_chain_noise_cal);
203566f3	473	DEBUGFS_ADD_BOOL(disable_tx_power, rf, &priv->disable_tx_power_cal);
712b6cf5 TW	474	return 0;
	475
	476	err:
15b1687c	477	IWL_ERR(priv, "Can't open the debugfs directory\n");
712b6cf5	478	iwl_dbgfs_unregister(priv);
3ac7f146	479	return ret;
712b6cf5 TW	480	}
	481	EXPORT_SYMBOL(iwl_dbgfs_register);
	482
	483	/**
	484	* Remove the debugfs files and directories
	485	*
	486	*/
	487	void iwl_dbgfs_unregister(struct iwl_priv *priv)
	488	{
3ac7f146	489	if (!priv->dbgfs)
712b6cf5 TW	490	return;
712b6cf5 TW	491
8dd266ef	492	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_eeprom);
712b6cf5 TW	493	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_rx_statistics);
	494	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_tx_statistics);
	495	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_sram);
189a2b59	496	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_log_event);
712b6cf5	497	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_stations);
d366df5a	498	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_channels);
712b6cf5	499	DEBUGFS_REMOVE(priv->dbgfs->dir_data);
445c2dff TW	500	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_sensitivity);
445c2dff TW	501	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_chain_noise);
203566f3	502	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_tx_power);
445c2dff	503	DEBUGFS_REMOVE(priv->dbgfs->dir_rf);
712b6cf5 TW	504	DEBUGFS_REMOVE(priv->dbgfs->dir_drv);
	505	kfree(priv->dbgfs);
	506	priv->dbgfs = NULL;
	507	}
	508	EXPORT_SYMBOL(iwl_dbgfs_unregister);
	509
	510
445c2dff	511