iwl-debugfs.c revision 0848e297c2107dbc12a91a1709c879c73bd188d8
1/******************************************************************************
2 *
3 * GPL LICENSE SUMMARY
4 *
5 * Copyright(c) 2008 - 2009 Intel Corporation. All rights reserved.
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:
25 *  Intel Linux Wireless <ilw@linux.intel.com>
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
37#include "iwl-dev.h"
38#include "iwl-debug.h"
39#include "iwl-core.h"
40#include "iwl-io.h"
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
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);     \
61	if (IS_ERR(dbgfs->dbgfs_##parent##_files.file_##name)		\
62			|| !dbgfs->dbgfs_##parent##_files.file_##name)	\
63		goto err;                                               \
64} while (0)
65
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
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)                                         \
81static 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)                                        \
86static ssize_t iwl_dbgfs_##name##_write(struct file *file,              \
87					const char __user *user_buf,    \
88					size_t count, loff_t *ppos);
89
90
91static 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);                                        \
99static const struct file_operations iwl_dbgfs_##name##_ops = {          \
100	.read = iwl_dbgfs_##name##_read,                       		\
101	.open = iwl_dbgfs_open_file_generic,                    	\
102};
103
104#define DEBUGFS_WRITE_FILE_OPS(name)                                    \
105	DEBUGFS_WRITE_FUNC(name);                                       \
106static const struct file_operations iwl_dbgfs_##name##_ops = {          \
107	.write = iwl_dbgfs_##name##_write,                              \
108	.open = iwl_dbgfs_open_file_generic,                    	\
109};
110
111
112#define DEBUGFS_READ_WRITE_FILE_OPS(name)                               \
113	DEBUGFS_READ_FUNC(name);                                        \
114	DEBUGFS_WRITE_FUNC(name);                                       \
115static 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
122static 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;
129	const size_t bufsz = sizeof(buf);
130
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);
137
138	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
139}
140
141static 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;
148	const size_t bufsz = sizeof(buf);
149
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);
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;
163static 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;
173	const size_t bufsz = sizeof(buf);
174
175	iwl_grab_nic_access(priv);
176	for (i = priv->dbgfs->sram_len; i > 0; i -= 4) {
177		val = iwl_read_targ_mem(priv, priv->dbgfs->sram_offset + \
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		}
192		pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val);
193	}
194	pos += scnprintf(buf + pos, bufsz - pos, "\n");
195	iwl_release_nic_access(priv);
196
197	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
198	return ret;
199}
200
201static 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
226static 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;
230	struct iwl_station_entry *station;
231	int max_sta = priv->hw_params.max_stations;
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);
237
238	buf = kmalloc(bufsz, GFP_KERNEL);
239	if (!buf)
240		return -ENOMEM;
241
242	pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
243			priv->num_stations);
244
245	for (i = 0; i < max_sta; i++) {
246		station = &priv->stations[i];
247		if (station->used) {
248			pos += scnprintf(buf + pos, bufsz - pos,
249					"station %d:\ngeneral data:\n", i+1);
250			pos += scnprintf(buf + pos, bufsz - pos, "id: %u\n",
251					station->sta.sta.sta_id);
252			pos += scnprintf(buf + pos, bufsz - pos, "mode: %u\n",
253					station->sta.mode);
254			pos += scnprintf(buf + pos, bufsz - pos,
255					"flags: 0x%x\n",
256					station->sta.station_flags_msk);
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,
261					"seq_num\t\ttxq_id");
262			pos += scnprintf(buf + pos, bufsz - pos,
263					"\tframe_count\twait_for_ba\t");
264			pos += scnprintf(buf + pos, bufsz - pos,
265					"start_idx\tbitmap0\t");
266			pos += scnprintf(buf + pos, bufsz - pos,
267					"bitmap1\trate_n_flags");
268			pos += scnprintf(buf + pos, bufsz - pos, "\n");
269
270			for (j = 0; j < MAX_TID_COUNT; j++) {
271				pos += scnprintf(buf + pos, bufsz - pos,
272						"[%d]:\t\t%u", j,
273						station->tid[j].seq_number);
274				pos += scnprintf(buf + pos, bufsz - pos,
275						"\t%u\t\t%u\t\t%u\t\t",
276						station->tid[j].agg.txq_id,
277						station->tid[j].agg.frame_count,
278						station->tid[j].agg.wait_for_ba);
279				pos += scnprintf(buf + pos, bufsz - pos,
280						"%u\t%llu\t%u",
281						station->tid[j].agg.start_idx,
282						(unsigned long long)station->tid[j].agg.bitmap,
283						station->tid[j].agg.rate_n_flags);
284				pos += scnprintf(buf + pos, bufsz - pos, "\n");
285			}
286			pos += scnprintf(buf + pos, bufsz - pos, "\n");
287		}
288	}
289
290	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
291	kfree(buf);
292	return ret;
293}
294
295static ssize_t iwl_dbgfs_nvm_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) {
309		IWL_ERR(priv, "NVM size is not multiple of 16.\n");
310		return -ENODATA;
311	}
312
313	/* 4 characters for byte 0xYY */
314	buf = kzalloc(buf_size, GFP_KERNEL);
315	if (!buf) {
316		IWL_ERR(priv, "Can not allocate Buffer\n");
317		return -ENOMEM;
318	}
319
320	ptr = priv->eeprom;
321	if (!ptr) {
322		IWL_ERR(priv, "Invalid EEPROM/OTP memory\n");
323		return -ENOMEM;
324	}
325	pos += scnprintf(buf + pos, buf_size - pos, "NVM Type: %s\n",
326			(priv->nvm_device_type == NVM_DEVICE_TYPE_OTP)
327			? "OTP" : "EEPROM");
328	for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
329		pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x ", ofs);
330		hex_dump_to_buffer(ptr + ofs, 16 , 16, 2, buf + pos,
331				   buf_size - pos, 0);
332		pos += strlen(buf);
333		if (buf_size - pos > 0)
334			buf[pos++] = '\n';
335	}
336
337	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
338	kfree(buf);
339	return ret;
340}
341
342static ssize_t iwl_dbgfs_log_event_write(struct file *file,
343					const char __user *user_buf,
344					size_t count, loff_t *ppos)
345{
346	struct iwl_priv *priv = file->private_data;
347	u32 event_log_flag;
348	char buf[8];
349	int buf_size;
350
351	memset(buf, 0, sizeof(buf));
352	buf_size = min(count, sizeof(buf) -  1);
353	if (copy_from_user(buf, user_buf, buf_size))
354		return -EFAULT;
355	if (sscanf(buf, "%d", &event_log_flag) != 1)
356		return -EFAULT;
357	if (event_log_flag == 1)
358		iwl_dump_nic_event_log(priv);
359
360	return count;
361}
362
363
364
365static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
366				       size_t count, loff_t *ppos)
367{
368	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
369	struct ieee80211_channel *channels = NULL;
370	const struct ieee80211_supported_band *supp_band = NULL;
371	int pos = 0, i, bufsz = PAGE_SIZE;
372	char *buf;
373	ssize_t ret;
374
375	if (!test_bit(STATUS_GEO_CONFIGURED, &priv->status))
376		return -EAGAIN;
377
378	buf = kzalloc(bufsz, GFP_KERNEL);
379	if (!buf) {
380		IWL_ERR(priv, "Can not allocate Buffer\n");
381		return -ENOMEM;
382	}
383
384	supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_2GHZ);
385	channels = supp_band->channels;
386
387	pos += scnprintf(buf + pos, bufsz - pos,
388			"Displaying %d channels in 2.4GHz band 802.11bg):\n",
389			 supp_band->n_channels);
390
391	for (i = 0; i < supp_band->n_channels; i++)
392		pos += scnprintf(buf + pos, bufsz - pos,
393				"%d: %ddBm: BSS%s%s, %s.\n",
394				ieee80211_frequency_to_channel(
395				channels[i].center_freq),
396				channels[i].max_power,
397				channels[i].flags & IEEE80211_CHAN_RADAR ?
398				" (IEEE 802.11h required)" : "",
399				((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
400				|| (channels[i].flags &
401				IEEE80211_CHAN_RADAR)) ? "" :
402				", IBSS",
403				channels[i].flags &
404				IEEE80211_CHAN_PASSIVE_SCAN ?
405				"passive only" : "active/passive");
406
407	supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_5GHZ);
408	channels = supp_band->channels;
409
410	pos += scnprintf(buf + pos, bufsz - pos,
411			"Displaying %d channels in 5.2GHz band (802.11a)\n",
412			supp_band->n_channels);
413
414	for (i = 0; i < supp_band->n_channels; i++)
415		pos += scnprintf(buf + pos, bufsz - pos,
416				"%d: %ddBm: BSS%s%s, %s.\n",
417				ieee80211_frequency_to_channel(
418				channels[i].center_freq),
419				channels[i].max_power,
420				channels[i].flags & IEEE80211_CHAN_RADAR ?
421				" (IEEE 802.11h required)" : "",
422				((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
423				|| (channels[i].flags &
424				IEEE80211_CHAN_RADAR)) ? "" :
425				", IBSS",
426				channels[i].flags &
427				IEEE80211_CHAN_PASSIVE_SCAN ?
428				"passive only" : "active/passive");
429	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
430	kfree(buf);
431	return ret;
432}
433
434static ssize_t iwl_dbgfs_status_read(struct file *file,
435						char __user *user_buf,
436						size_t count, loff_t *ppos) {
437
438	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
439	char buf[512];
440	int pos = 0;
441	const size_t bufsz = sizeof(buf);
442
443	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_HCMD_ACTIVE:\t %d\n",
444		test_bit(STATUS_HCMD_ACTIVE, &priv->status));
445	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_HCMD_SYNC_ACTIVE: %d\n",
446		test_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status));
447	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_INT_ENABLED:\t %d\n",
448		test_bit(STATUS_INT_ENABLED, &priv->status));
449	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_RF_KILL_HW:\t %d\n",
450		test_bit(STATUS_RF_KILL_HW, &priv->status));
451	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_RF_KILL_SW:\t %d\n",
452		test_bit(STATUS_RF_KILL_SW, &priv->status));
453	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_INIT:\t\t %d\n",
454		test_bit(STATUS_INIT, &priv->status));
455	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_ALIVE:\t\t %d\n",
456		test_bit(STATUS_ALIVE, &priv->status));
457	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_READY:\t\t %d\n",
458		test_bit(STATUS_READY, &priv->status));
459	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_TEMPERATURE:\t %d\n",
460		test_bit(STATUS_TEMPERATURE, &priv->status));
461	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_GEO_CONFIGURED:\t %d\n",
462		test_bit(STATUS_GEO_CONFIGURED, &priv->status));
463	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_EXIT_PENDING:\t %d\n",
464		test_bit(STATUS_EXIT_PENDING, &priv->status));
465	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_STATISTICS:\t %d\n",
466		test_bit(STATUS_STATISTICS, &priv->status));
467	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCANNING:\t %d\n",
468		test_bit(STATUS_SCANNING, &priv->status));
469	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_ABORTING:\t %d\n",
470		test_bit(STATUS_SCAN_ABORTING, &priv->status));
471	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_HW:\t\t %d\n",
472		test_bit(STATUS_SCAN_HW, &priv->status));
473	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_POWER_PMI:\t %d\n",
474		test_bit(STATUS_POWER_PMI, &priv->status));
475	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_FW_ERROR:\t %d\n",
476		test_bit(STATUS_FW_ERROR, &priv->status));
477	pos += scnprintf(buf + pos, bufsz - pos, "STATUS_MODE_PENDING:\t %d\n",
478		test_bit(STATUS_MODE_PENDING, &priv->status));
479	return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
480}
481
482static ssize_t iwl_dbgfs_interrupt_read(struct file *file,
483					char __user *user_buf,
484					size_t count, loff_t *ppos) {
485
486	struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
487	int pos = 0;
488	int cnt = 0;
489	char *buf;
490	int bufsz = 24 * 64; /* 24 items * 64 char per item */
491	ssize_t ret;
492
493	buf = kzalloc(bufsz, GFP_KERNEL);
494	if (!buf) {
495		IWL_ERR(priv, "Can not allocate Buffer\n");
496		return -ENOMEM;
497	}
498
499	pos += scnprintf(buf + pos, bufsz - pos,
500			"Interrupt Statistics Report:\n");
501
502	pos += scnprintf(buf + pos, bufsz - pos, "HW Error:\t\t\t %u\n",
503		priv->isr_stats.hw);
504	pos += scnprintf(buf + pos, bufsz - pos, "SW Error:\t\t\t %u\n",
505		priv->isr_stats.sw);
506	if (priv->isr_stats.sw > 0) {
507		pos += scnprintf(buf + pos, bufsz - pos,
508			"\tLast Restarting Code:  0x%X\n",
509			priv->isr_stats.sw_err);
510	}
511#ifdef CONFIG_IWLWIFI_DEBUG
512	pos += scnprintf(buf + pos, bufsz - pos, "Frame transmitted:\t\t %u\n",
513		priv->isr_stats.sch);
514	pos += scnprintf(buf + pos, bufsz - pos, "Alive interrupt:\t\t %u\n",
515		priv->isr_stats.alive);
516#endif
517	pos += scnprintf(buf + pos, bufsz - pos,
518		"HW RF KILL switch toggled:\t %u\n",
519		priv->isr_stats.rfkill);
520
521	pos += scnprintf(buf + pos, bufsz - pos, "CT KILL:\t\t\t %u\n",
522		priv->isr_stats.ctkill);
523
524	pos += scnprintf(buf + pos, bufsz - pos, "Wakeup Interrupt:\t\t %u\n",
525		priv->isr_stats.wakeup);
526
527	pos += scnprintf(buf + pos, bufsz - pos,
528		"Rx command responses:\t\t %u\n",
529		priv->isr_stats.rx);
530	for (cnt = 0; cnt < REPLY_MAX; cnt++) {
531		if (priv->isr_stats.rx_handlers[cnt] > 0)
532			pos += scnprintf(buf + pos, bufsz - pos,
533				"\tRx handler[%36s]:\t\t %u\n",
534				get_cmd_string(cnt),
535				priv->isr_stats.rx_handlers[cnt]);
536	}
537
538	pos += scnprintf(buf + pos, bufsz - pos, "Tx/FH interrupt:\t\t %u\n",
539		priv->isr_stats.tx);
540
541	pos += scnprintf(buf + pos, bufsz - pos, "Unexpected INTA:\t\t %u\n",
542		priv->isr_stats.unhandled);
543
544	ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
545	kfree(buf);
546	return ret;
547}
548
549static ssize_t iwl_dbgfs_interrupt_write(struct file *file,
550					 const char __user *user_buf,
551					 size_t count, loff_t *ppos)
552{
553	struct iwl_priv *priv = file->private_data;
554	char buf[8];
555	int buf_size;
556	u32 reset_flag;
557
558	memset(buf, 0, sizeof(buf));
559	buf_size = min(count, sizeof(buf) -  1);
560	if (copy_from_user(buf, user_buf, buf_size))
561		return -EFAULT;
562	if (sscanf(buf, "%x", &reset_flag) != 1)
563		return -EFAULT;
564	if (reset_flag == 0)
565		iwl_clear_isr_stats(priv);
566
567	return count;
568}
569
570
571DEBUGFS_READ_WRITE_FILE_OPS(sram);
572DEBUGFS_WRITE_FILE_OPS(log_event);
573DEBUGFS_READ_FILE_OPS(nvm);
574DEBUGFS_READ_FILE_OPS(stations);
575DEBUGFS_READ_FILE_OPS(rx_statistics);
576DEBUGFS_READ_FILE_OPS(tx_statistics);
577DEBUGFS_READ_FILE_OPS(channels);
578DEBUGFS_READ_FILE_OPS(status);
579DEBUGFS_READ_WRITE_FILE_OPS(interrupt);
580
581/*
582 * Create the debugfs files and directories
583 *
584 */
585int iwl_dbgfs_register(struct iwl_priv *priv, const char *name)
586{
587	struct iwl_debugfs *dbgfs;
588	struct dentry *phyd = priv->hw->wiphy->debugfsdir;
589	int ret = 0;
590
591	dbgfs = kzalloc(sizeof(struct iwl_debugfs), GFP_KERNEL);
592	if (!dbgfs) {
593		ret = -ENOMEM;
594		goto err;
595	}
596
597	priv->dbgfs = dbgfs;
598	dbgfs->name = name;
599	dbgfs->dir_drv = debugfs_create_dir(name, phyd);
600	if (!dbgfs->dir_drv || IS_ERR(dbgfs->dir_drv)) {
601		ret = -ENOENT;
602		goto err;
603	}
604
605	DEBUGFS_ADD_DIR(data, dbgfs->dir_drv);
606	DEBUGFS_ADD_DIR(rf, dbgfs->dir_drv);
607	DEBUGFS_ADD_FILE(nvm, data);
608	DEBUGFS_ADD_FILE(sram, data);
609	DEBUGFS_ADD_FILE(log_event, data);
610	DEBUGFS_ADD_FILE(stations, data);
611	DEBUGFS_ADD_FILE(rx_statistics, data);
612	DEBUGFS_ADD_FILE(tx_statistics, data);
613	DEBUGFS_ADD_FILE(channels, data);
614	DEBUGFS_ADD_FILE(status, data);
615	DEBUGFS_ADD_FILE(interrupt, data);
616	DEBUGFS_ADD_BOOL(disable_sensitivity, rf, &priv->disable_sens_cal);
617	DEBUGFS_ADD_BOOL(disable_chain_noise, rf,
618			 &priv->disable_chain_noise_cal);
619	DEBUGFS_ADD_BOOL(disable_tx_power, rf, &priv->disable_tx_power_cal);
620	return 0;
621
622err:
623	IWL_ERR(priv, "Can't open the debugfs directory\n");
624	iwl_dbgfs_unregister(priv);
625	return ret;
626}
627EXPORT_SYMBOL(iwl_dbgfs_register);
628
629/**
630 * Remove the debugfs files and directories
631 *
632 */
633void iwl_dbgfs_unregister(struct iwl_priv *priv)
634{
635	if (!priv->dbgfs)
636		return;
637
638	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_nvm);
639	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_rx_statistics);
640	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_tx_statistics);
641	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_sram);
642	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_log_event);
643	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_stations);
644	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_channels);
645	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_status);
646	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_interrupt);
647	DEBUGFS_REMOVE(priv->dbgfs->dir_data);
648	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_sensitivity);
649	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_chain_noise);
650	DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_tx_power);
651	DEBUGFS_REMOVE(priv->dbgfs->dir_rf);
652	DEBUGFS_REMOVE(priv->dbgfs->dir_drv);
653	kfree(priv->dbgfs);
654	priv->dbgfs = NULL;
655}
656EXPORT_SYMBOL(iwl_dbgfs_unregister);
657
658
659
660