1/**
  2 * Copyright (c) 2014 Redpine Signals Inc.
  3 *
  4 * Permission to use, copy, modify, and/or distribute this software for any
  5 * purpose with or without fee is hereby granted, provided that the above
  6 * copyright notice and this permission notice appear in all copies.
  7 *
  8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 15 */
 16
 17#include "rsi_debugfs.h"
 18#include "rsi_sdio.h"
 19
 20/**
 21 * rsi_sdio_stats_read() - This function returns the sdio status of the driver.
 22 * @seq: Pointer to the sequence file structure.
 23 * @data: Pointer to the data.
 24 *
 25 * Return: 0 on success, -1 on failure.
 26 */
 27static int rsi_sdio_stats_read(struct seq_file *seq, void *data)
 28{
 29	struct rsi_common *common = seq->private;
 30	struct rsi_hw *adapter = common->priv;
 31	struct rsi_91x_sdiodev *dev =
 32		(struct rsi_91x_sdiodev *)adapter->rsi_dev;
 33
 34	seq_printf(seq, "total_sdio_interrupts: %d\n",
 35		   dev->rx_info.sdio_int_counter);
 36	seq_printf(seq, "sdio_msdu_pending_intr_count: %d\n",
 37		   dev->rx_info.total_sdio_msdu_pending_intr);
 38	seq_printf(seq, "sdio_buff_full_count : %d\n",
 39		   dev->rx_info.buf_full_counter);
 40	seq_printf(seq, "sdio_buf_semi_full_count %d\n",
 41		   dev->rx_info.buf_semi_full_counter);
 42	seq_printf(seq, "sdio_unknown_intr_count: %d\n",
 43		   dev->rx_info.total_sdio_unknown_intr);
 44	/* RX Path Stats */
 45	seq_printf(seq, "BUFFER FULL STATUS  : %d\n",
 46		   dev->rx_info.buffer_full);
 47	seq_printf(seq, "SEMI BUFFER FULL STATUS  : %d\n",
 48		   dev->rx_info.semi_buffer_full);
 49	seq_printf(seq, "MGMT BUFFER FULL STATUS  : %d\n",
 50		   dev->rx_info.mgmt_buffer_full);
 51	seq_printf(seq, "BUFFER FULL COUNTER  : %d\n",
 52		   dev->rx_info.buf_full_counter);
 53	seq_printf(seq, "BUFFER SEMI FULL COUNTER  : %d\n",
 54		   dev->rx_info.buf_semi_full_counter);
 55	seq_printf(seq, "MGMT BUFFER FULL COUNTER  : %d\n",
 56		   dev->rx_info.mgmt_buf_full_counter);
 57
 58	return 0;
 59}
 60
 61/**
 62 * rsi_sdio_stats_open() - This function calls single open function of seq_file
 63 *			   to open file and read contents from it.
 64 * @inode: Pointer to the inode structure.
 65 * @file: Pointer to the file structure.
 66 *
 67 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
 68 */
 69static int rsi_sdio_stats_open(struct inode *inode,
 70			       struct file *file)
 71{
 72	return single_open(file, rsi_sdio_stats_read, inode->i_private);
 73}
 74
 75/**
 76 * rsi_version_read() - This function gives driver and firmware version number.
 77 * @seq: Pointer to the sequence file structure.
 78 * @data: Pointer to the data.
 79 *
 80 * Return: 0 on success, -1 on failure.
 81 */
 82static int rsi_version_read(struct seq_file *seq, void *data)
 83{
 84	struct rsi_common *common = seq->private;
 85
 86	seq_printf(seq, "LMAC   : %d.%d.%d.%d\n",
 87		   common->lmac_ver.major,
 88		   common->lmac_ver.minor,
 89		   common->lmac_ver.release_num,
 90		   common->lmac_ver.patch_num);
 91
 92	return 0;
 93}
 94
 95/**
 96 * rsi_version_open() - This function calls single open function of seq_file to
 97 *			open file and read contents from it.
 98 * @inode: Pointer to the inode structure.
 99 * @file: Pointer to the file structure.
100 *
101 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
102 */
103static int rsi_version_open(struct inode *inode,
104				 struct file *file)
105{
106	return single_open(file, rsi_version_read, inode->i_private);
107}
108
109/**
110 * rsi_stats_read() - This function return the status of the driver.
111 * @seq: Pointer to the sequence file structure.
112 * @data: Pointer to the data.
113 *
114 * Return: 0 on success, -1 on failure.
115 */
116static int rsi_stats_read(struct seq_file *seq, void *data)
117{
118	struct rsi_common *common = seq->private;
119
120	unsigned char fsm_state[][32] = {
121		"FSM_FW_NOT_LOADED",
122		"FSM_CARD_NOT_READY",
123		"FSM_COMMON_DEV_PARAMS_SENT",
124		"FSM_BOOT_PARAMS_SENT",
125		"FSM_EEPROM_READ_MAC_ADDR",
126		"FSM_EEPROM_READ_RF_TYPE",
127		"FSM_RESET_MAC_SENT",
128		"FSM_RADIO_CAPS_SENT",
129		"FSM_BB_RF_PROG_SENT",
130		"FSM_MAC_INIT_DONE"
131	};
132	seq_puts(seq, "==> RSI STA DRIVER STATUS <==\n");
133	seq_puts(seq, "DRIVER_FSM_STATE: ");
134
135	BUILD_BUG_ON(ARRAY_SIZE(fsm_state) != NUM_FSM_STATES);
136
137	if (common->fsm_state <= FSM_MAC_INIT_DONE)
138		seq_printf(seq, "%s", fsm_state[common->fsm_state]);
139
140	seq_printf(seq, "(%d)\n\n", common->fsm_state);
141
142	/* Mgmt TX Path Stats */
143	seq_printf(seq, "total_mgmt_pkt_send : %d\n",
144		   common->tx_stats.total_tx_pkt_send[MGMT_SOFT_Q]);
145	seq_printf(seq, "total_mgmt_pkt_queued : %d\n",
146		   skb_queue_len(&common->tx_queue[MGMT_SOFT_Q]));
147	seq_printf(seq, "total_mgmt_pkt_freed  : %d\n",
148		   common->tx_stats.total_tx_pkt_freed[MGMT_SOFT_Q]);
149
150	/* Data TX Path Stats */
151	seq_printf(seq, "total_data_vo_pkt_send: %8d\t",
152		   common->tx_stats.total_tx_pkt_send[VO_Q]);
153	seq_printf(seq, "total_data_vo_pkt_queued:  %8d\t",
154		   skb_queue_len(&common->tx_queue[VO_Q]));
155	seq_printf(seq, "total_vo_pkt_freed: %8d\n",
156		   common->tx_stats.total_tx_pkt_freed[VO_Q]);
157	seq_printf(seq, "total_data_vi_pkt_send: %8d\t",
158		   common->tx_stats.total_tx_pkt_send[VI_Q]);
159	seq_printf(seq, "total_data_vi_pkt_queued:  %8d\t",
160		   skb_queue_len(&common->tx_queue[VI_Q]));
161	seq_printf(seq, "total_vi_pkt_freed: %8d\n",
162		   common->tx_stats.total_tx_pkt_freed[VI_Q]);
163	seq_printf(seq,  "total_data_be_pkt_send: %8d\t",
164		   common->tx_stats.total_tx_pkt_send[BE_Q]);
165	seq_printf(seq, "total_data_be_pkt_queued:  %8d\t",
166		   skb_queue_len(&common->tx_queue[BE_Q]));
167	seq_printf(seq, "total_be_pkt_freed: %8d\n",
168		   common->tx_stats.total_tx_pkt_freed[BE_Q]);
169	seq_printf(seq, "total_data_bk_pkt_send: %8d\t",
170		   common->tx_stats.total_tx_pkt_send[BK_Q]);
171	seq_printf(seq, "total_data_bk_pkt_queued:  %8d\t",
172		   skb_queue_len(&common->tx_queue[BK_Q]));
173	seq_printf(seq, "total_bk_pkt_freed: %8d\n",
174		   common->tx_stats.total_tx_pkt_freed[BK_Q]);
175
176	seq_puts(seq, "\n");
177	return 0;
178}
179
180/**
181 * rsi_stats_open() - This function calls single open function of seq_file to
182 *		      open file and read contents from it.
183 * @inode: Pointer to the inode structure.
184 * @file: Pointer to the file structure.
185 *
186 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
187 */
188static int rsi_stats_open(struct inode *inode,
189			  struct file *file)
190{
191	return single_open(file, rsi_stats_read, inode->i_private);
192}
193
194/**
195 * rsi_debug_zone_read() - This function display the currently enabled debug zones.
196 * @seq: Pointer to the sequence file structure.
197 * @data: Pointer to the data.
198 *
199 * Return: 0 on success, -1 on failure.
200 */
201static int rsi_debug_zone_read(struct seq_file *seq, void *data)
202{
203	rsi_dbg(FSM_ZONE, "%x: rsi_enabled zone", rsi_zone_enabled);
204	seq_printf(seq, "The zones available are %#x\n",
205		   rsi_zone_enabled);
206	return 0;
207}
208
209/**
210 * rsi_debug_read() - This function calls single open function of seq_file to
211 *		      open file and read contents from it.
212 * @inode: Pointer to the inode structure.
213 * @file: Pointer to the file structure.
214 *
215 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
216 */
217static int rsi_debug_read(struct inode *inode,
218			  struct file *file)
219{
220	return single_open(file, rsi_debug_zone_read, inode->i_private);
221}
222
223/**
224 * rsi_debug_zone_write() - This function writes into hal queues as per user
225 *			    requirement.
226 * @filp: Pointer to the file structure.
227 * @buff: Pointer to the character buffer.
228 * @len: Length of the data to be written into buffer.
229 * @data: Pointer to the data.
230 *
231 * Return: len: Number of bytes read.
232 */
233static ssize_t rsi_debug_zone_write(struct file *filp,
234				    const char __user *buff,
235				    size_t len,
236				    loff_t *data)
237{
238	unsigned long dbg_zone;
239	int ret;
240
241	if (!len)
242		return 0;
243
244	ret = kstrtoul_from_user(buff, len, 16, &dbg_zone);
245
246	if (ret)
247		return ret;
248
249	rsi_zone_enabled = dbg_zone;
250	return len;
251}
252
253#define FOPS(fopen) { \
254	.owner = THIS_MODULE, \
255	.open = (fopen), \
256	.read = seq_read, \
257	.llseek = seq_lseek, \
258}
259
260#define FOPS_RW(fopen, fwrite) { \
261	.owner = THIS_MODULE, \
262	.open = (fopen), \
263	.read = seq_read, \
264	.llseek = seq_lseek, \
265	.write = (fwrite), \
266}
267
268static const struct rsi_dbg_files dev_debugfs_files[] = {
269	{"version", 0644, FOPS(rsi_version_open),},
270	{"stats", 0644, FOPS(rsi_stats_open),},
271	{"debug_zone", 0666, FOPS_RW(rsi_debug_read, rsi_debug_zone_write),},
272	{"sdio_stats", 0644, FOPS(rsi_sdio_stats_open),},
273};
274
275/**
276 * rsi_init_dbgfs() - This function initializes the dbgfs entry.
277 * @adapter: Pointer to the adapter structure.
278 *
279 * Return: 0 on success, -1 on failure.
280 */
281int rsi_init_dbgfs(struct rsi_hw *adapter)
282{
283	struct rsi_common *common = adapter->priv;
284	struct rsi_debugfs *dev_dbgfs;
285	char devdir[6];
286	int ii;
287	const struct rsi_dbg_files *files;
288
289	dev_dbgfs = kzalloc(sizeof(*dev_dbgfs), GFP_KERNEL);
290	if (!dev_dbgfs)
291		return -ENOMEM;
292
293	adapter->dfsentry = dev_dbgfs;
294
295	snprintf(devdir, sizeof(devdir), "%s",
296		 wiphy_name(adapter->hw->wiphy));
297
298	dev_dbgfs->subdir = debugfs_create_dir(devdir, NULL);
299
300	for (ii = 0; ii < adapter->num_debugfs_entries; ii++) {
301		files = &dev_debugfs_files[ii];
302		dev_dbgfs->rsi_files[ii] =
303		debugfs_create_file(files->name,
304				    files->perms,
305				    dev_dbgfs->subdir,
306				    common,
307				    &files->fops);
308	}
309	return 0;
310}
311EXPORT_SYMBOL_GPL(rsi_init_dbgfs);
312
313/**
314 * rsi_remove_dbgfs() - Removes the previously created dbgfs file entries
315 *			in the reverse order of creation.
316 * @adapter: Pointer to the adapter structure.
317 *
318 * Return: None.
319 */
320void rsi_remove_dbgfs(struct rsi_hw *adapter)
321{
322	struct rsi_debugfs *dev_dbgfs = adapter->dfsentry;
323
324	if (!dev_dbgfs)
325		return;
326
327	debugfs_remove_recursive(dev_dbgfs->subdir);
328}
329EXPORT_SYMBOL_GPL(rsi_remove_dbgfs);