Loading...
1/*
2 * Copyright (c) 2010-2011 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17#include "htc.h"
18
19static ssize_t read_file_tgt_int_stats(struct file *file, char __user *user_buf,
20 size_t count, loff_t *ppos)
21{
22 struct ath9k_htc_priv *priv = file->private_data;
23 struct ath9k_htc_target_int_stats cmd_rsp;
24 char buf[512];
25 unsigned int len = 0;
26 int ret = 0;
27
28 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
29
30 ath9k_htc_ps_wakeup(priv);
31
32 WMI_CMD(WMI_INT_STATS_CMDID);
33 if (ret) {
34 ath9k_htc_ps_restore(priv);
35 return -EINVAL;
36 }
37
38 ath9k_htc_ps_restore(priv);
39
40 len += scnprintf(buf + len, sizeof(buf) - len,
41 "%20s : %10u\n", "RX",
42 be32_to_cpu(cmd_rsp.rx));
43
44 len += scnprintf(buf + len, sizeof(buf) - len,
45 "%20s : %10u\n", "RXORN",
46 be32_to_cpu(cmd_rsp.rxorn));
47
48 len += scnprintf(buf + len, sizeof(buf) - len,
49 "%20s : %10u\n", "RXEOL",
50 be32_to_cpu(cmd_rsp.rxeol));
51
52 len += scnprintf(buf + len, sizeof(buf) - len,
53 "%20s : %10u\n", "TXURN",
54 be32_to_cpu(cmd_rsp.txurn));
55
56 len += scnprintf(buf + len, sizeof(buf) - len,
57 "%20s : %10u\n", "TXTO",
58 be32_to_cpu(cmd_rsp.txto));
59
60 len += scnprintf(buf + len, sizeof(buf) - len,
61 "%20s : %10u\n", "CST",
62 be32_to_cpu(cmd_rsp.cst));
63
64 if (len > sizeof(buf))
65 len = sizeof(buf);
66
67 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
68}
69
70static const struct file_operations fops_tgt_int_stats = {
71 .read = read_file_tgt_int_stats,
72 .open = simple_open,
73 .owner = THIS_MODULE,
74 .llseek = default_llseek,
75};
76
77static ssize_t read_file_tgt_tx_stats(struct file *file, char __user *user_buf,
78 size_t count, loff_t *ppos)
79{
80 struct ath9k_htc_priv *priv = file->private_data;
81 struct ath9k_htc_target_tx_stats cmd_rsp;
82 char buf[512];
83 unsigned int len = 0;
84 int ret = 0;
85
86 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
87
88 ath9k_htc_ps_wakeup(priv);
89
90 WMI_CMD(WMI_TX_STATS_CMDID);
91 if (ret) {
92 ath9k_htc_ps_restore(priv);
93 return -EINVAL;
94 }
95
96 ath9k_htc_ps_restore(priv);
97
98 len += scnprintf(buf + len, sizeof(buf) - len,
99 "%20s : %10u\n", "Xretries",
100 be32_to_cpu(cmd_rsp.xretries));
101
102 len += scnprintf(buf + len, sizeof(buf) - len,
103 "%20s : %10u\n", "FifoErr",
104 be32_to_cpu(cmd_rsp.fifoerr));
105
106 len += scnprintf(buf + len, sizeof(buf) - len,
107 "%20s : %10u\n", "Filtered",
108 be32_to_cpu(cmd_rsp.filtered));
109
110 len += scnprintf(buf + len, sizeof(buf) - len,
111 "%20s : %10u\n", "TimerExp",
112 be32_to_cpu(cmd_rsp.timer_exp));
113
114 len += scnprintf(buf + len, sizeof(buf) - len,
115 "%20s : %10u\n", "ShortRetries",
116 be32_to_cpu(cmd_rsp.shortretries));
117
118 len += scnprintf(buf + len, sizeof(buf) - len,
119 "%20s : %10u\n", "LongRetries",
120 be32_to_cpu(cmd_rsp.longretries));
121
122 len += scnprintf(buf + len, sizeof(buf) - len,
123 "%20s : %10u\n", "QueueNull",
124 be32_to_cpu(cmd_rsp.qnull));
125
126 len += scnprintf(buf + len, sizeof(buf) - len,
127 "%20s : %10u\n", "EncapFail",
128 be32_to_cpu(cmd_rsp.encap_fail));
129
130 len += scnprintf(buf + len, sizeof(buf) - len,
131 "%20s : %10u\n", "NoBuf",
132 be32_to_cpu(cmd_rsp.nobuf));
133
134 if (len > sizeof(buf))
135 len = sizeof(buf);
136
137 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
138}
139
140static const struct file_operations fops_tgt_tx_stats = {
141 .read = read_file_tgt_tx_stats,
142 .open = simple_open,
143 .owner = THIS_MODULE,
144 .llseek = default_llseek,
145};
146
147static ssize_t read_file_tgt_rx_stats(struct file *file, char __user *user_buf,
148 size_t count, loff_t *ppos)
149{
150 struct ath9k_htc_priv *priv = file->private_data;
151 struct ath9k_htc_target_rx_stats cmd_rsp;
152 char buf[512];
153 unsigned int len = 0;
154 int ret = 0;
155
156 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
157
158 ath9k_htc_ps_wakeup(priv);
159
160 WMI_CMD(WMI_RX_STATS_CMDID);
161 if (ret) {
162 ath9k_htc_ps_restore(priv);
163 return -EINVAL;
164 }
165
166 ath9k_htc_ps_restore(priv);
167
168 len += scnprintf(buf + len, sizeof(buf) - len,
169 "%20s : %10u\n", "NoBuf",
170 be32_to_cpu(cmd_rsp.nobuf));
171
172 len += scnprintf(buf + len, sizeof(buf) - len,
173 "%20s : %10u\n", "HostSend",
174 be32_to_cpu(cmd_rsp.host_send));
175
176 len += scnprintf(buf + len, sizeof(buf) - len,
177 "%20s : %10u\n", "HostDone",
178 be32_to_cpu(cmd_rsp.host_done));
179
180 if (len > sizeof(buf))
181 len = sizeof(buf);
182
183 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
184}
185
186static const struct file_operations fops_tgt_rx_stats = {
187 .read = read_file_tgt_rx_stats,
188 .open = simple_open,
189 .owner = THIS_MODULE,
190 .llseek = default_llseek,
191};
192
193static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
194 size_t count, loff_t *ppos)
195{
196 struct ath9k_htc_priv *priv = file->private_data;
197 char buf[512];
198 unsigned int len = 0;
199
200 len += scnprintf(buf + len, sizeof(buf) - len,
201 "%20s : %10u\n", "Buffers queued",
202 priv->debug.tx_stats.buf_queued);
203 len += scnprintf(buf + len, sizeof(buf) - len,
204 "%20s : %10u\n", "Buffers completed",
205 priv->debug.tx_stats.buf_completed);
206 len += scnprintf(buf + len, sizeof(buf) - len,
207 "%20s : %10u\n", "SKBs queued",
208 priv->debug.tx_stats.skb_queued);
209 len += scnprintf(buf + len, sizeof(buf) - len,
210 "%20s : %10u\n", "SKBs success",
211 priv->debug.tx_stats.skb_success);
212 len += scnprintf(buf + len, sizeof(buf) - len,
213 "%20s : %10u\n", "SKBs failed",
214 priv->debug.tx_stats.skb_failed);
215 len += scnprintf(buf + len, sizeof(buf) - len,
216 "%20s : %10u\n", "CAB queued",
217 priv->debug.tx_stats.cab_queued);
218
219 len += scnprintf(buf + len, sizeof(buf) - len,
220 "%20s : %10u\n", "BE queued",
221 priv->debug.tx_stats.queue_stats[IEEE80211_AC_BE]);
222 len += scnprintf(buf + len, sizeof(buf) - len,
223 "%20s : %10u\n", "BK queued",
224 priv->debug.tx_stats.queue_stats[IEEE80211_AC_BK]);
225 len += scnprintf(buf + len, sizeof(buf) - len,
226 "%20s : %10u\n", "VI queued",
227 priv->debug.tx_stats.queue_stats[IEEE80211_AC_VI]);
228 len += scnprintf(buf + len, sizeof(buf) - len,
229 "%20s : %10u\n", "VO queued",
230 priv->debug.tx_stats.queue_stats[IEEE80211_AC_VO]);
231
232 if (len > sizeof(buf))
233 len = sizeof(buf);
234
235 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
236}
237
238static const struct file_operations fops_xmit = {
239 .read = read_file_xmit,
240 .open = simple_open,
241 .owner = THIS_MODULE,
242 .llseek = default_llseek,
243};
244
245void ath9k_htc_err_stat_rx(struct ath9k_htc_priv *priv,
246 struct ath_rx_status *rs)
247{
248 ath9k_cmn_debug_stat_rx(&priv->debug.rx_stats, rs);
249}
250
251static ssize_t read_file_skb_rx(struct file *file, char __user *user_buf,
252 size_t count, loff_t *ppos)
253{
254 struct ath9k_htc_priv *priv = file->private_data;
255 char *buf;
256 unsigned int len = 0, size = 1500;
257 ssize_t retval = 0;
258
259 buf = kzalloc(size, GFP_KERNEL);
260 if (buf == NULL)
261 return -ENOMEM;
262
263 len += scnprintf(buf + len, size - len,
264 "%20s : %10u\n", "SKBs allocated",
265 priv->debug.skbrx_stats.skb_allocated);
266 len += scnprintf(buf + len, size - len,
267 "%20s : %10u\n", "SKBs completed",
268 priv->debug.skbrx_stats.skb_completed);
269 len += scnprintf(buf + len, size - len,
270 "%20s : %10u\n", "SKBs Dropped",
271 priv->debug.skbrx_stats.skb_dropped);
272
273 if (len > size)
274 len = size;
275
276 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
277 kfree(buf);
278
279 return retval;
280}
281
282static const struct file_operations fops_skb_rx = {
283 .read = read_file_skb_rx,
284 .open = simple_open,
285 .owner = THIS_MODULE,
286 .llseek = default_llseek,
287};
288
289static ssize_t read_file_slot(struct file *file, char __user *user_buf,
290 size_t count, loff_t *ppos)
291{
292 struct ath9k_htc_priv *priv = file->private_data;
293 char buf[512];
294 unsigned int len;
295
296 spin_lock_bh(&priv->tx.tx_lock);
297 len = scnprintf(buf, sizeof(buf),
298 "TX slot bitmap : %*pb\n"
299 "Used slots : %d\n",
300 MAX_TX_BUF_NUM, priv->tx.tx_slot,
301 bitmap_weight(priv->tx.tx_slot, MAX_TX_BUF_NUM));
302 spin_unlock_bh(&priv->tx.tx_lock);
303 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
304}
305
306static const struct file_operations fops_slot = {
307 .read = read_file_slot,
308 .open = simple_open,
309 .owner = THIS_MODULE,
310 .llseek = default_llseek,
311};
312
313static ssize_t read_file_queue(struct file *file, char __user *user_buf,
314 size_t count, loff_t *ppos)
315{
316 struct ath9k_htc_priv *priv = file->private_data;
317 char buf[512];
318 unsigned int len = 0;
319
320 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
321 "Mgmt endpoint", skb_queue_len(&priv->tx.mgmt_ep_queue));
322
323 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
324 "Cab endpoint", skb_queue_len(&priv->tx.cab_ep_queue));
325
326 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
327 "Data BE endpoint", skb_queue_len(&priv->tx.data_be_queue));
328
329 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
330 "Data BK endpoint", skb_queue_len(&priv->tx.data_bk_queue));
331
332 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
333 "Data VI endpoint", skb_queue_len(&priv->tx.data_vi_queue));
334
335 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
336 "Data VO endpoint", skb_queue_len(&priv->tx.data_vo_queue));
337
338 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
339 "Failed queue", skb_queue_len(&priv->tx.tx_failed));
340
341 spin_lock_bh(&priv->tx.tx_lock);
342 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
343 "Queued count", priv->tx.queued_cnt);
344 spin_unlock_bh(&priv->tx.tx_lock);
345
346 if (len > sizeof(buf))
347 len = sizeof(buf);
348
349 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
350
351}
352
353static const struct file_operations fops_queue = {
354 .read = read_file_queue,
355 .open = simple_open,
356 .owner = THIS_MODULE,
357 .llseek = default_llseek,
358};
359
360static ssize_t read_file_debug(struct file *file, char __user *user_buf,
361 size_t count, loff_t *ppos)
362{
363 struct ath9k_htc_priv *priv = file->private_data;
364 struct ath_common *common = ath9k_hw_common(priv->ah);
365 char buf[32];
366 unsigned int len;
367
368 len = sprintf(buf, "0x%08x\n", common->debug_mask);
369 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
370}
371
372static ssize_t write_file_debug(struct file *file, const char __user *user_buf,
373 size_t count, loff_t *ppos)
374{
375 struct ath9k_htc_priv *priv = file->private_data;
376 struct ath_common *common = ath9k_hw_common(priv->ah);
377 unsigned long mask;
378 ssize_t ret;
379
380 ret = kstrtoul_from_user(user_buf, count, 0, &mask);
381 if (ret)
382 return ret;
383
384 common->debug_mask = mask;
385 return count;
386}
387
388static const struct file_operations fops_debug = {
389 .read = read_file_debug,
390 .write = write_file_debug,
391 .open = simple_open,
392 .owner = THIS_MODULE,
393 .llseek = default_llseek,
394};
395
396/* Ethtool support for get-stats */
397#define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO"
398static const char ath9k_htc_gstrings_stats[][ETH_GSTRING_LEN] = {
399 "tx_pkts_nic",
400 "tx_bytes_nic",
401 "rx_pkts_nic",
402 "rx_bytes_nic",
403
404 AMKSTR(d_tx_pkts),
405
406 "d_rx_crc_err",
407 "d_rx_decrypt_crc_err",
408 "d_rx_phy_err",
409 "d_rx_mic_err",
410 "d_rx_pre_delim_crc_err",
411 "d_rx_post_delim_crc_err",
412 "d_rx_decrypt_busy_err",
413
414 "d_rx_phyerr_radar",
415 "d_rx_phyerr_ofdm_timing",
416 "d_rx_phyerr_cck_timing",
417
418};
419#define ATH9K_HTC_SSTATS_LEN ARRAY_SIZE(ath9k_htc_gstrings_stats)
420
421void ath9k_htc_get_et_strings(struct ieee80211_hw *hw,
422 struct ieee80211_vif *vif,
423 u32 sset, u8 *data)
424{
425 if (sset == ETH_SS_STATS)
426 memcpy(data, ath9k_htc_gstrings_stats,
427 sizeof(ath9k_htc_gstrings_stats));
428}
429
430int ath9k_htc_get_et_sset_count(struct ieee80211_hw *hw,
431 struct ieee80211_vif *vif, int sset)
432{
433 if (sset == ETH_SS_STATS)
434 return ATH9K_HTC_SSTATS_LEN;
435 return 0;
436}
437
438#define STXBASE priv->debug.tx_stats
439#define SRXBASE priv->debug.rx_stats
440#define SKBTXBASE priv->debug.tx_stats
441#define SKBRXBASE priv->debug.skbrx_stats
442#define ASTXQ(a) \
443 data[i++] = STXBASE.a[IEEE80211_AC_BE]; \
444 data[i++] = STXBASE.a[IEEE80211_AC_BK]; \
445 data[i++] = STXBASE.a[IEEE80211_AC_VI]; \
446 data[i++] = STXBASE.a[IEEE80211_AC_VO]
447
448void ath9k_htc_get_et_stats(struct ieee80211_hw *hw,
449 struct ieee80211_vif *vif,
450 struct ethtool_stats *stats, u64 *data)
451{
452 struct ath9k_htc_priv *priv = hw->priv;
453 int i = 0;
454
455 data[i++] = SKBTXBASE.skb_success;
456 data[i++] = SKBTXBASE.skb_success_bytes;
457 data[i++] = SKBRXBASE.skb_completed;
458 data[i++] = SKBRXBASE.skb_completed_bytes;
459
460 ASTXQ(queue_stats);
461
462 data[i++] = SRXBASE.crc_err;
463 data[i++] = SRXBASE.decrypt_crc_err;
464 data[i++] = SRXBASE.phy_err;
465 data[i++] = SRXBASE.mic_err;
466 data[i++] = SRXBASE.pre_delim_crc_err;
467 data[i++] = SRXBASE.post_delim_crc_err;
468 data[i++] = SRXBASE.decrypt_busy_err;
469
470 data[i++] = SRXBASE.phy_err_stats[ATH9K_PHYERR_RADAR];
471 data[i++] = SRXBASE.phy_err_stats[ATH9K_PHYERR_OFDM_TIMING];
472 data[i++] = SRXBASE.phy_err_stats[ATH9K_PHYERR_CCK_TIMING];
473
474 WARN_ON(i != ATH9K_HTC_SSTATS_LEN);
475}
476
477void ath9k_htc_deinit_debug(struct ath9k_htc_priv *priv)
478{
479 ath9k_cmn_spectral_deinit_debug(&priv->spec_priv);
480}
481
482int ath9k_htc_init_debug(struct ath_hw *ah)
483{
484 struct ath_common *common = ath9k_hw_common(ah);
485 struct ath9k_htc_priv *priv = common->priv;
486
487 priv->debug.debugfs_phy = debugfs_create_dir(KBUILD_MODNAME,
488 priv->hw->wiphy->debugfsdir);
489 if (IS_ERR(priv->debug.debugfs_phy))
490 return -ENOMEM;
491
492 ath9k_cmn_spectral_init_debug(&priv->spec_priv, priv->debug.debugfs_phy);
493
494 debugfs_create_file("tgt_int_stats", 0400, priv->debug.debugfs_phy,
495 priv, &fops_tgt_int_stats);
496 debugfs_create_file("tgt_tx_stats", 0400, priv->debug.debugfs_phy,
497 priv, &fops_tgt_tx_stats);
498 debugfs_create_file("tgt_rx_stats", 0400, priv->debug.debugfs_phy,
499 priv, &fops_tgt_rx_stats);
500 debugfs_create_file("xmit", 0400, priv->debug.debugfs_phy,
501 priv, &fops_xmit);
502 debugfs_create_file("skb_rx", 0400, priv->debug.debugfs_phy,
503 priv, &fops_skb_rx);
504
505 ath9k_cmn_debug_recv(priv->debug.debugfs_phy, &priv->debug.rx_stats);
506 ath9k_cmn_debug_phy_err(priv->debug.debugfs_phy, &priv->debug.rx_stats);
507
508 debugfs_create_file("slot", 0400, priv->debug.debugfs_phy,
509 priv, &fops_slot);
510 debugfs_create_file("queue", 0400, priv->debug.debugfs_phy,
511 priv, &fops_queue);
512 debugfs_create_file("debug", 0600, priv->debug.debugfs_phy,
513 priv, &fops_debug);
514
515 ath9k_cmn_debug_base_eeprom(priv->debug.debugfs_phy, priv->ah);
516 ath9k_cmn_debug_modal_eeprom(priv->debug.debugfs_phy, priv->ah);
517
518 return 0;
519}
1/*
2 * Copyright (c) 2010-2011 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17#include "htc.h"
18
19static ssize_t read_file_tgt_int_stats(struct file *file, char __user *user_buf,
20 size_t count, loff_t *ppos)
21{
22 struct ath9k_htc_priv *priv = file->private_data;
23 struct ath9k_htc_target_int_stats cmd_rsp;
24 char buf[512];
25 unsigned int len = 0;
26 int ret = 0;
27
28 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
29
30 ath9k_htc_ps_wakeup(priv);
31
32 WMI_CMD(WMI_INT_STATS_CMDID);
33 if (ret) {
34 ath9k_htc_ps_restore(priv);
35 return -EINVAL;
36 }
37
38 ath9k_htc_ps_restore(priv);
39
40 len += scnprintf(buf + len, sizeof(buf) - len,
41 "%20s : %10u\n", "RX",
42 be32_to_cpu(cmd_rsp.rx));
43
44 len += scnprintf(buf + len, sizeof(buf) - len,
45 "%20s : %10u\n", "RXORN",
46 be32_to_cpu(cmd_rsp.rxorn));
47
48 len += scnprintf(buf + len, sizeof(buf) - len,
49 "%20s : %10u\n", "RXEOL",
50 be32_to_cpu(cmd_rsp.rxeol));
51
52 len += scnprintf(buf + len, sizeof(buf) - len,
53 "%20s : %10u\n", "TXURN",
54 be32_to_cpu(cmd_rsp.txurn));
55
56 len += scnprintf(buf + len, sizeof(buf) - len,
57 "%20s : %10u\n", "TXTO",
58 be32_to_cpu(cmd_rsp.txto));
59
60 len += scnprintf(buf + len, sizeof(buf) - len,
61 "%20s : %10u\n", "CST",
62 be32_to_cpu(cmd_rsp.cst));
63
64 if (len > sizeof(buf))
65 len = sizeof(buf);
66
67 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
68}
69
70static const struct file_operations fops_tgt_int_stats = {
71 .read = read_file_tgt_int_stats,
72 .open = simple_open,
73 .owner = THIS_MODULE,
74 .llseek = default_llseek,
75};
76
77static ssize_t read_file_tgt_tx_stats(struct file *file, char __user *user_buf,
78 size_t count, loff_t *ppos)
79{
80 struct ath9k_htc_priv *priv = file->private_data;
81 struct ath9k_htc_target_tx_stats cmd_rsp;
82 char buf[512];
83 unsigned int len = 0;
84 int ret = 0;
85
86 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
87
88 ath9k_htc_ps_wakeup(priv);
89
90 WMI_CMD(WMI_TX_STATS_CMDID);
91 if (ret) {
92 ath9k_htc_ps_restore(priv);
93 return -EINVAL;
94 }
95
96 ath9k_htc_ps_restore(priv);
97
98 len += scnprintf(buf + len, sizeof(buf) - len,
99 "%20s : %10u\n", "Xretries",
100 be32_to_cpu(cmd_rsp.xretries));
101
102 len += scnprintf(buf + len, sizeof(buf) - len,
103 "%20s : %10u\n", "FifoErr",
104 be32_to_cpu(cmd_rsp.fifoerr));
105
106 len += scnprintf(buf + len, sizeof(buf) - len,
107 "%20s : %10u\n", "Filtered",
108 be32_to_cpu(cmd_rsp.filtered));
109
110 len += scnprintf(buf + len, sizeof(buf) - len,
111 "%20s : %10u\n", "TimerExp",
112 be32_to_cpu(cmd_rsp.timer_exp));
113
114 len += scnprintf(buf + len, sizeof(buf) - len,
115 "%20s : %10u\n", "ShortRetries",
116 be32_to_cpu(cmd_rsp.shortretries));
117
118 len += scnprintf(buf + len, sizeof(buf) - len,
119 "%20s : %10u\n", "LongRetries",
120 be32_to_cpu(cmd_rsp.longretries));
121
122 len += scnprintf(buf + len, sizeof(buf) - len,
123 "%20s : %10u\n", "QueueNull",
124 be32_to_cpu(cmd_rsp.qnull));
125
126 len += scnprintf(buf + len, sizeof(buf) - len,
127 "%20s : %10u\n", "EncapFail",
128 be32_to_cpu(cmd_rsp.encap_fail));
129
130 len += scnprintf(buf + len, sizeof(buf) - len,
131 "%20s : %10u\n", "NoBuf",
132 be32_to_cpu(cmd_rsp.nobuf));
133
134 if (len > sizeof(buf))
135 len = sizeof(buf);
136
137 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
138}
139
140static const struct file_operations fops_tgt_tx_stats = {
141 .read = read_file_tgt_tx_stats,
142 .open = simple_open,
143 .owner = THIS_MODULE,
144 .llseek = default_llseek,
145};
146
147static ssize_t read_file_tgt_rx_stats(struct file *file, char __user *user_buf,
148 size_t count, loff_t *ppos)
149{
150 struct ath9k_htc_priv *priv = file->private_data;
151 struct ath9k_htc_target_rx_stats cmd_rsp;
152 char buf[512];
153 unsigned int len = 0;
154 int ret = 0;
155
156 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
157
158 ath9k_htc_ps_wakeup(priv);
159
160 WMI_CMD(WMI_RX_STATS_CMDID);
161 if (ret) {
162 ath9k_htc_ps_restore(priv);
163 return -EINVAL;
164 }
165
166 ath9k_htc_ps_restore(priv);
167
168 len += scnprintf(buf + len, sizeof(buf) - len,
169 "%20s : %10u\n", "NoBuf",
170 be32_to_cpu(cmd_rsp.nobuf));
171
172 len += scnprintf(buf + len, sizeof(buf) - len,
173 "%20s : %10u\n", "HostSend",
174 be32_to_cpu(cmd_rsp.host_send));
175
176 len += scnprintf(buf + len, sizeof(buf) - len,
177 "%20s : %10u\n", "HostDone",
178 be32_to_cpu(cmd_rsp.host_done));
179
180 if (len > sizeof(buf))
181 len = sizeof(buf);
182
183 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
184}
185
186static const struct file_operations fops_tgt_rx_stats = {
187 .read = read_file_tgt_rx_stats,
188 .open = simple_open,
189 .owner = THIS_MODULE,
190 .llseek = default_llseek,
191};
192
193static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
194 size_t count, loff_t *ppos)
195{
196 struct ath9k_htc_priv *priv = file->private_data;
197 char buf[512];
198 unsigned int len = 0;
199
200 len += scnprintf(buf + len, sizeof(buf) - len,
201 "%20s : %10u\n", "Buffers queued",
202 priv->debug.tx_stats.buf_queued);
203 len += scnprintf(buf + len, sizeof(buf) - len,
204 "%20s : %10u\n", "Buffers completed",
205 priv->debug.tx_stats.buf_completed);
206 len += scnprintf(buf + len, sizeof(buf) - len,
207 "%20s : %10u\n", "SKBs queued",
208 priv->debug.tx_stats.skb_queued);
209 len += scnprintf(buf + len, sizeof(buf) - len,
210 "%20s : %10u\n", "SKBs success",
211 priv->debug.tx_stats.skb_success);
212 len += scnprintf(buf + len, sizeof(buf) - len,
213 "%20s : %10u\n", "SKBs failed",
214 priv->debug.tx_stats.skb_failed);
215 len += scnprintf(buf + len, sizeof(buf) - len,
216 "%20s : %10u\n", "CAB queued",
217 priv->debug.tx_stats.cab_queued);
218
219 len += scnprintf(buf + len, sizeof(buf) - len,
220 "%20s : %10u\n", "BE queued",
221 priv->debug.tx_stats.queue_stats[IEEE80211_AC_BE]);
222 len += scnprintf(buf + len, sizeof(buf) - len,
223 "%20s : %10u\n", "BK queued",
224 priv->debug.tx_stats.queue_stats[IEEE80211_AC_BK]);
225 len += scnprintf(buf + len, sizeof(buf) - len,
226 "%20s : %10u\n", "VI queued",
227 priv->debug.tx_stats.queue_stats[IEEE80211_AC_VI]);
228 len += scnprintf(buf + len, sizeof(buf) - len,
229 "%20s : %10u\n", "VO queued",
230 priv->debug.tx_stats.queue_stats[IEEE80211_AC_VO]);
231
232 if (len > sizeof(buf))
233 len = sizeof(buf);
234
235 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
236}
237
238static const struct file_operations fops_xmit = {
239 .read = read_file_xmit,
240 .open = simple_open,
241 .owner = THIS_MODULE,
242 .llseek = default_llseek,
243};
244
245void ath9k_htc_err_stat_rx(struct ath9k_htc_priv *priv,
246 struct ath_htc_rx_status *rxs)
247{
248#define RX_PHY_ERR_INC(c) priv->debug.rx_stats.err_phy_stats[c]++
249
250 if (rxs->rs_status & ATH9K_RXERR_CRC)
251 priv->debug.rx_stats.err_crc++;
252 if (rxs->rs_status & ATH9K_RXERR_DECRYPT)
253 priv->debug.rx_stats.err_decrypt_crc++;
254 if (rxs->rs_status & ATH9K_RXERR_MIC)
255 priv->debug.rx_stats.err_mic++;
256 if (rxs->rs_status & ATH9K_RX_DELIM_CRC_PRE)
257 priv->debug.rx_stats.err_pre_delim++;
258 if (rxs->rs_status & ATH9K_RX_DELIM_CRC_POST)
259 priv->debug.rx_stats.err_post_delim++;
260 if (rxs->rs_status & ATH9K_RX_DECRYPT_BUSY)
261 priv->debug.rx_stats.err_decrypt_busy++;
262
263 if (rxs->rs_status & ATH9K_RXERR_PHY) {
264 priv->debug.rx_stats.err_phy++;
265 if (rxs->rs_phyerr < ATH9K_PHYERR_MAX)
266 RX_PHY_ERR_INC(rxs->rs_phyerr);
267 }
268
269#undef RX_PHY_ERR_INC
270}
271
272static ssize_t read_file_recv(struct file *file, char __user *user_buf,
273 size_t count, loff_t *ppos)
274{
275#define PHY_ERR(s, p) \
276 len += scnprintf(buf + len, size - len, "%20s : %10u\n", s, \
277 priv->debug.rx_stats.err_phy_stats[p]);
278
279 struct ath9k_htc_priv *priv = file->private_data;
280 char *buf;
281 unsigned int len = 0, size = 1500;
282 ssize_t retval = 0;
283
284 buf = kzalloc(size, GFP_KERNEL);
285 if (buf == NULL)
286 return -ENOMEM;
287
288 len += scnprintf(buf + len, size - len,
289 "%20s : %10u\n", "SKBs allocated",
290 priv->debug.rx_stats.skb_allocated);
291 len += scnprintf(buf + len, size - len,
292 "%20s : %10u\n", "SKBs completed",
293 priv->debug.rx_stats.skb_completed);
294 len += scnprintf(buf + len, size - len,
295 "%20s : %10u\n", "SKBs Dropped",
296 priv->debug.rx_stats.skb_dropped);
297
298 len += scnprintf(buf + len, size - len,
299 "%20s : %10u\n", "CRC ERR",
300 priv->debug.rx_stats.err_crc);
301 len += scnprintf(buf + len, size - len,
302 "%20s : %10u\n", "DECRYPT CRC ERR",
303 priv->debug.rx_stats.err_decrypt_crc);
304 len += scnprintf(buf + len, size - len,
305 "%20s : %10u\n", "MIC ERR",
306 priv->debug.rx_stats.err_mic);
307 len += scnprintf(buf + len, size - len,
308 "%20s : %10u\n", "PRE-DELIM CRC ERR",
309 priv->debug.rx_stats.err_pre_delim);
310 len += scnprintf(buf + len, size - len,
311 "%20s : %10u\n", "POST-DELIM CRC ERR",
312 priv->debug.rx_stats.err_post_delim);
313 len += scnprintf(buf + len, size - len,
314 "%20s : %10u\n", "DECRYPT BUSY ERR",
315 priv->debug.rx_stats.err_decrypt_busy);
316 len += scnprintf(buf + len, size - len,
317 "%20s : %10u\n", "TOTAL PHY ERR",
318 priv->debug.rx_stats.err_phy);
319
320
321 PHY_ERR("UNDERRUN", ATH9K_PHYERR_UNDERRUN);
322 PHY_ERR("TIMING", ATH9K_PHYERR_TIMING);
323 PHY_ERR("PARITY", ATH9K_PHYERR_PARITY);
324 PHY_ERR("RATE", ATH9K_PHYERR_RATE);
325 PHY_ERR("LENGTH", ATH9K_PHYERR_LENGTH);
326 PHY_ERR("RADAR", ATH9K_PHYERR_RADAR);
327 PHY_ERR("SERVICE", ATH9K_PHYERR_SERVICE);
328 PHY_ERR("TOR", ATH9K_PHYERR_TOR);
329 PHY_ERR("OFDM-TIMING", ATH9K_PHYERR_OFDM_TIMING);
330 PHY_ERR("OFDM-SIGNAL-PARITY", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
331 PHY_ERR("OFDM-RATE", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
332 PHY_ERR("OFDM-LENGTH", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
333 PHY_ERR("OFDM-POWER-DROP", ATH9K_PHYERR_OFDM_POWER_DROP);
334 PHY_ERR("OFDM-SERVICE", ATH9K_PHYERR_OFDM_SERVICE);
335 PHY_ERR("OFDM-RESTART", ATH9K_PHYERR_OFDM_RESTART);
336 PHY_ERR("FALSE-RADAR-EXT", ATH9K_PHYERR_FALSE_RADAR_EXT);
337 PHY_ERR("CCK-TIMING", ATH9K_PHYERR_CCK_TIMING);
338 PHY_ERR("CCK-HEADER-CRC", ATH9K_PHYERR_CCK_HEADER_CRC);
339 PHY_ERR("CCK-RATE", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
340 PHY_ERR("CCK-SERVICE", ATH9K_PHYERR_CCK_SERVICE);
341 PHY_ERR("CCK-RESTART", ATH9K_PHYERR_CCK_RESTART);
342 PHY_ERR("CCK-LENGTH", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
343 PHY_ERR("CCK-POWER-DROP", ATH9K_PHYERR_CCK_POWER_DROP);
344 PHY_ERR("HT-CRC", ATH9K_PHYERR_HT_CRC_ERROR);
345 PHY_ERR("HT-LENGTH", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
346 PHY_ERR("HT-RATE", ATH9K_PHYERR_HT_RATE_ILLEGAL);
347
348 if (len > size)
349 len = size;
350
351 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
352 kfree(buf);
353
354 return retval;
355
356#undef PHY_ERR
357}
358
359static const struct file_operations fops_recv = {
360 .read = read_file_recv,
361 .open = simple_open,
362 .owner = THIS_MODULE,
363 .llseek = default_llseek,
364};
365
366static ssize_t read_file_slot(struct file *file, char __user *user_buf,
367 size_t count, loff_t *ppos)
368{
369 struct ath9k_htc_priv *priv = file->private_data;
370 char buf[512];
371 unsigned int len = 0;
372
373 spin_lock_bh(&priv->tx.tx_lock);
374
375 len += scnprintf(buf + len, sizeof(buf) - len, "TX slot bitmap : ");
376
377 len += bitmap_scnprintf(buf + len, sizeof(buf) - len,
378 priv->tx.tx_slot, MAX_TX_BUF_NUM);
379
380 len += scnprintf(buf + len, sizeof(buf) - len, "\n");
381
382 len += scnprintf(buf + len, sizeof(buf) - len,
383 "Used slots : %d\n",
384 bitmap_weight(priv->tx.tx_slot, MAX_TX_BUF_NUM));
385
386 spin_unlock_bh(&priv->tx.tx_lock);
387
388 if (len > sizeof(buf))
389 len = sizeof(buf);
390
391 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
392}
393
394static const struct file_operations fops_slot = {
395 .read = read_file_slot,
396 .open = simple_open,
397 .owner = THIS_MODULE,
398 .llseek = default_llseek,
399};
400
401static ssize_t read_file_queue(struct file *file, char __user *user_buf,
402 size_t count, loff_t *ppos)
403{
404 struct ath9k_htc_priv *priv = file->private_data;
405 char buf[512];
406 unsigned int len = 0;
407
408 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
409 "Mgmt endpoint", skb_queue_len(&priv->tx.mgmt_ep_queue));
410
411 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
412 "Cab endpoint", skb_queue_len(&priv->tx.cab_ep_queue));
413
414 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
415 "Data BE endpoint", skb_queue_len(&priv->tx.data_be_queue));
416
417 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
418 "Data BK endpoint", skb_queue_len(&priv->tx.data_bk_queue));
419
420 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
421 "Data VI endpoint", skb_queue_len(&priv->tx.data_vi_queue));
422
423 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
424 "Data VO endpoint", skb_queue_len(&priv->tx.data_vo_queue));
425
426 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
427 "Failed queue", skb_queue_len(&priv->tx.tx_failed));
428
429 spin_lock_bh(&priv->tx.tx_lock);
430 len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
431 "Queued count", priv->tx.queued_cnt);
432 spin_unlock_bh(&priv->tx.tx_lock);
433
434 if (len > sizeof(buf))
435 len = sizeof(buf);
436
437 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
438
439}
440
441static const struct file_operations fops_queue = {
442 .read = read_file_queue,
443 .open = simple_open,
444 .owner = THIS_MODULE,
445 .llseek = default_llseek,
446};
447
448static ssize_t read_file_debug(struct file *file, char __user *user_buf,
449 size_t count, loff_t *ppos)
450{
451 struct ath9k_htc_priv *priv = file->private_data;
452 struct ath_common *common = ath9k_hw_common(priv->ah);
453 char buf[32];
454 unsigned int len;
455
456 len = sprintf(buf, "0x%08x\n", common->debug_mask);
457 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
458}
459
460static ssize_t write_file_debug(struct file *file, const char __user *user_buf,
461 size_t count, loff_t *ppos)
462{
463 struct ath9k_htc_priv *priv = file->private_data;
464 struct ath_common *common = ath9k_hw_common(priv->ah);
465 unsigned long mask;
466 char buf[32];
467 ssize_t len;
468
469 len = min(count, sizeof(buf) - 1);
470 if (copy_from_user(buf, user_buf, len))
471 return -EFAULT;
472
473 buf[len] = '\0';
474 if (kstrtoul(buf, 0, &mask))
475 return -EINVAL;
476
477 common->debug_mask = mask;
478 return count;
479}
480
481static const struct file_operations fops_debug = {
482 .read = read_file_debug,
483 .write = write_file_debug,
484 .open = simple_open,
485 .owner = THIS_MODULE,
486 .llseek = default_llseek,
487};
488
489static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf,
490 size_t count, loff_t *ppos)
491{
492 struct ath9k_htc_priv *priv = file->private_data;
493 struct ath_common *common = ath9k_hw_common(priv->ah);
494 struct base_eep_header *pBase = NULL;
495 unsigned int len = 0, size = 1500;
496 ssize_t retval = 0;
497 char *buf;
498
499 pBase = ath9k_htc_get_eeprom_base(priv);
500
501 if (pBase == NULL) {
502 ath_err(common, "Unknown EEPROM type\n");
503 return 0;
504 }
505
506 buf = kzalloc(size, GFP_KERNEL);
507 if (buf == NULL)
508 return -ENOMEM;
509
510 len += scnprintf(buf + len, size - len,
511 "%20s : %10d\n", "Major Version",
512 pBase->version >> 12);
513 len += scnprintf(buf + len, size - len,
514 "%20s : %10d\n", "Minor Version",
515 pBase->version & 0xFFF);
516 len += scnprintf(buf + len, size - len,
517 "%20s : %10d\n", "Checksum",
518 pBase->checksum);
519 len += scnprintf(buf + len, size - len,
520 "%20s : %10d\n", "Length",
521 pBase->length);
522 len += scnprintf(buf + len, size - len,
523 "%20s : %10d\n", "RegDomain1",
524 pBase->regDmn[0]);
525 len += scnprintf(buf + len, size - len,
526 "%20s : %10d\n", "RegDomain2",
527 pBase->regDmn[1]);
528 len += scnprintf(buf + len, size - len,
529 "%20s : %10d\n",
530 "TX Mask", pBase->txMask);
531 len += scnprintf(buf + len, size - len,
532 "%20s : %10d\n",
533 "RX Mask", pBase->rxMask);
534 len += scnprintf(buf + len, size - len,
535 "%20s : %10d\n",
536 "Allow 5GHz",
537 !!(pBase->opCapFlags & AR5416_OPFLAGS_11A));
538 len += scnprintf(buf + len, size - len,
539 "%20s : %10d\n",
540 "Allow 2GHz",
541 !!(pBase->opCapFlags & AR5416_OPFLAGS_11G));
542 len += scnprintf(buf + len, size - len,
543 "%20s : %10d\n",
544 "Disable 2GHz HT20",
545 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT20));
546 len += scnprintf(buf + len, size - len,
547 "%20s : %10d\n",
548 "Disable 2GHz HT40",
549 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT40));
550 len += scnprintf(buf + len, size - len,
551 "%20s : %10d\n",
552 "Disable 5Ghz HT20",
553 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT20));
554 len += scnprintf(buf + len, size - len,
555 "%20s : %10d\n",
556 "Disable 5Ghz HT40",
557 !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT40));
558 len += scnprintf(buf + len, size - len,
559 "%20s : %10d\n",
560 "Big Endian",
561 !!(pBase->eepMisc & 0x01));
562 len += scnprintf(buf + len, size - len,
563 "%20s : %10d\n",
564 "Cal Bin Major Ver",
565 (pBase->binBuildNumber >> 24) & 0xFF);
566 len += scnprintf(buf + len, size - len,
567 "%20s : %10d\n",
568 "Cal Bin Minor Ver",
569 (pBase->binBuildNumber >> 16) & 0xFF);
570 len += scnprintf(buf + len, size - len,
571 "%20s : %10d\n",
572 "Cal Bin Build",
573 (pBase->binBuildNumber >> 8) & 0xFF);
574
575 /*
576 * UB91 specific data.
577 */
578 if (AR_SREV_9271(priv->ah)) {
579 struct base_eep_header_4k *pBase4k =
580 &priv->ah->eeprom.map4k.baseEepHeader;
581
582 len += scnprintf(buf + len, size - len,
583 "%20s : %10d\n",
584 "TX Gain type",
585 pBase4k->txGainType);
586 }
587
588 /*
589 * UB95 specific data.
590 */
591 if (priv->ah->hw_version.usbdev == AR9287_USB) {
592 struct base_eep_ar9287_header *pBase9287 =
593 &priv->ah->eeprom.map9287.baseEepHeader;
594
595 len += scnprintf(buf + len, size - len,
596 "%20s : %10ddB\n",
597 "Power Table Offset",
598 pBase9287->pwrTableOffset);
599
600 len += scnprintf(buf + len, size - len,
601 "%20s : %10d\n",
602 "OpenLoop Power Ctrl",
603 pBase9287->openLoopPwrCntl);
604 }
605
606 len += scnprintf(buf + len, size - len, "%20s : %pM\n", "MacAddress",
607 pBase->macAddr);
608 if (len > size)
609 len = size;
610
611 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
612 kfree(buf);
613
614 return retval;
615}
616
617static const struct file_operations fops_base_eeprom = {
618 .read = read_file_base_eeprom,
619 .open = simple_open,
620 .owner = THIS_MODULE,
621 .llseek = default_llseek,
622};
623
624static ssize_t read_4k_modal_eeprom(struct file *file,
625 char __user *user_buf,
626 size_t count, loff_t *ppos)
627{
628#define PR_EEP(_s, _val) \
629 do { \
630 len += scnprintf(buf + len, size - len, "%20s : %10d\n",\
631 _s, (_val)); \
632 } while (0)
633
634 struct ath9k_htc_priv *priv = file->private_data;
635 struct modal_eep_4k_header *pModal = &priv->ah->eeprom.map4k.modalHeader;
636 unsigned int len = 0, size = 2048;
637 ssize_t retval = 0;
638 char *buf;
639
640 buf = kzalloc(size, GFP_KERNEL);
641 if (buf == NULL)
642 return -ENOMEM;
643
644 PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
645 PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
646 PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
647 PR_EEP("Switch Settle", pModal->switchSettling);
648 PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
649 PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
650 PR_EEP("ADC Desired size", pModal->adcDesiredSize);
651 PR_EEP("PGA Desired size", pModal->pgaDesiredSize);
652 PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]);
653 PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
654 PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
655 PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
656 PR_EEP("CCA Threshold)", pModal->thresh62);
657 PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
658 PR_EEP("xpdGain", pModal->xpdGain);
659 PR_EEP("External PD", pModal->xpd);
660 PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
661 PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
662 PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
663 PR_EEP("O/D Bias Version", pModal->version);
664 PR_EEP("CCK OutputBias", pModal->ob_0);
665 PR_EEP("BPSK OutputBias", pModal->ob_1);
666 PR_EEP("QPSK OutputBias", pModal->ob_2);
667 PR_EEP("16QAM OutputBias", pModal->ob_3);
668 PR_EEP("64QAM OutputBias", pModal->ob_4);
669 PR_EEP("CCK Driver1_Bias", pModal->db1_0);
670 PR_EEP("BPSK Driver1_Bias", pModal->db1_1);
671 PR_EEP("QPSK Driver1_Bias", pModal->db1_2);
672 PR_EEP("16QAM Driver1_Bias", pModal->db1_3);
673 PR_EEP("64QAM Driver1_Bias", pModal->db1_4);
674 PR_EEP("CCK Driver2_Bias", pModal->db2_0);
675 PR_EEP("BPSK Driver2_Bias", pModal->db2_1);
676 PR_EEP("QPSK Driver2_Bias", pModal->db2_2);
677 PR_EEP("16QAM Driver2_Bias", pModal->db2_3);
678 PR_EEP("64QAM Driver2_Bias", pModal->db2_4);
679 PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
680 PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
681 PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
682 PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
683 PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
684 PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
685 PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
686 PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]);
687 PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]);
688 PR_EEP("Ant. Diversity ctl1", pModal->antdiv_ctl1);
689 PR_EEP("Ant. Diversity ctl2", pModal->antdiv_ctl2);
690 PR_EEP("TX Diversity", pModal->tx_diversity);
691
692 if (len > size)
693 len = size;
694
695 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
696 kfree(buf);
697
698 return retval;
699
700#undef PR_EEP
701}
702
703static ssize_t read_def_modal_eeprom(struct file *file,
704 char __user *user_buf,
705 size_t count, loff_t *ppos)
706{
707#define PR_EEP(_s, _val) \
708 do { \
709 if (pBase->opCapFlags & AR5416_OPFLAGS_11G) { \
710 pModal = &priv->ah->eeprom.def.modalHeader[1]; \
711 len += scnprintf(buf + len, size - len, "%20s : %8d%7s", \
712 _s, (_val), "|"); \
713 } \
714 if (pBase->opCapFlags & AR5416_OPFLAGS_11A) { \
715 pModal = &priv->ah->eeprom.def.modalHeader[0]; \
716 len += scnprintf(buf + len, size - len, "%9d\n",\
717 (_val)); \
718 } \
719 } while (0)
720
721 struct ath9k_htc_priv *priv = file->private_data;
722 struct base_eep_header *pBase = &priv->ah->eeprom.def.baseEepHeader;
723 struct modal_eep_header *pModal = NULL;
724 unsigned int len = 0, size = 3500;
725 ssize_t retval = 0;
726 char *buf;
727
728 buf = kzalloc(size, GFP_KERNEL);
729 if (buf == NULL)
730 return -ENOMEM;
731
732 len += scnprintf(buf + len, size - len,
733 "%31s %15s\n", "2G", "5G");
734 len += scnprintf(buf + len, size - len,
735 "%32s %16s\n", "====", "====\n");
736
737 PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
738 PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]);
739 PR_EEP("Chain2 Ant. Control", pModal->antCtrlChain[2]);
740 PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
741 PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
742 PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]);
743 PR_EEP("Chain2 Ant. Gain", pModal->antennaGainCh[2]);
744 PR_EEP("Switch Settle", pModal->switchSettling);
745 PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
746 PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]);
747 PR_EEP("Chain2 TxRxAtten", pModal->txRxAttenCh[2]);
748 PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
749 PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]);
750 PR_EEP("Chain2 RxTxMargin", pModal->rxTxMarginCh[2]);
751 PR_EEP("ADC Desired size", pModal->adcDesiredSize);
752 PR_EEP("PGA Desired size", pModal->pgaDesiredSize);
753 PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]);
754 PR_EEP("Chain1 xlna Gain", pModal->xlnaGainCh[1]);
755 PR_EEP("Chain2 xlna Gain", pModal->xlnaGainCh[2]);
756 PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
757 PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
758 PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
759 PR_EEP("CCA Threshold)", pModal->thresh62);
760 PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
761 PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]);
762 PR_EEP("Chain2 NF Threshold", pModal->noiseFloorThreshCh[2]);
763 PR_EEP("xpdGain", pModal->xpdGain);
764 PR_EEP("External PD", pModal->xpd);
765 PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
766 PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]);
767 PR_EEP("Chain2 I Coefficient", pModal->iqCalICh[2]);
768 PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
769 PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]);
770 PR_EEP("Chain2 Q Coefficient", pModal->iqCalQCh[2]);
771 PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
772 PR_EEP("Chain0 OutputBias", pModal->ob);
773 PR_EEP("Chain0 DriverBias", pModal->db);
774 PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
775 PR_EEP("2chain pwr decrease", pModal->pwrDecreaseFor2Chain);
776 PR_EEP("3chain pwr decrease", pModal->pwrDecreaseFor3Chain);
777 PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
778 PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
779 PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
780 PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
781 PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]);
782 PR_EEP("Chain2 bswAtten", pModal->bswAtten[2]);
783 PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
784 PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]);
785 PR_EEP("Chain2 bswMargin", pModal->bswMargin[2]);
786 PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
787 PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]);
788 PR_EEP("Chain1 xatten2Db", pModal->xatten2Db[1]);
789 PR_EEP("Chain2 xatten2Db", pModal->xatten2Db[2]);
790 PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]);
791 PR_EEP("Chain1 xatten2Margin", pModal->xatten2Margin[1]);
792 PR_EEP("Chain2 xatten2Margin", pModal->xatten2Margin[2]);
793 PR_EEP("Chain1 OutputBias", pModal->ob_ch1);
794 PR_EEP("Chain1 DriverBias", pModal->db_ch1);
795 PR_EEP("LNA Control", pModal->lna_ctl);
796 PR_EEP("XPA Bias Freq0", pModal->xpaBiasLvlFreq[0]);
797 PR_EEP("XPA Bias Freq1", pModal->xpaBiasLvlFreq[1]);
798 PR_EEP("XPA Bias Freq2", pModal->xpaBiasLvlFreq[2]);
799
800 if (len > size)
801 len = size;
802
803 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
804 kfree(buf);
805
806 return retval;
807
808#undef PR_EEP
809}
810
811static ssize_t read_9287_modal_eeprom(struct file *file,
812 char __user *user_buf,
813 size_t count, loff_t *ppos)
814{
815#define PR_EEP(_s, _val) \
816 do { \
817 len += scnprintf(buf + len, size - len, "%20s : %10d\n",\
818 _s, (_val)); \
819 } while (0)
820
821 struct ath9k_htc_priv *priv = file->private_data;
822 struct modal_eep_ar9287_header *pModal = &priv->ah->eeprom.map9287.modalHeader;
823 unsigned int len = 0, size = 3000;
824 ssize_t retval = 0;
825 char *buf;
826
827 buf = kzalloc(size, GFP_KERNEL);
828 if (buf == NULL)
829 return -ENOMEM;
830
831 PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
832 PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]);
833 PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
834 PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
835 PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]);
836 PR_EEP("Switch Settle", pModal->switchSettling);
837 PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
838 PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]);
839 PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
840 PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]);
841 PR_EEP("ADC Desired size", pModal->adcDesiredSize);
842 PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
843 PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
844 PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
845 PR_EEP("CCA Threshold)", pModal->thresh62);
846 PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
847 PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]);
848 PR_EEP("xpdGain", pModal->xpdGain);
849 PR_EEP("External PD", pModal->xpd);
850 PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
851 PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]);
852 PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
853 PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]);
854 PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
855 PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
856 PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
857 PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
858 PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
859 PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
860 PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]);
861 PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
862 PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]);
863 PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
864 PR_EEP("AR92x7 Version", pModal->version);
865 PR_EEP("DriverBias1", pModal->db1);
866 PR_EEP("DriverBias2", pModal->db1);
867 PR_EEP("CCK OutputBias", pModal->ob_cck);
868 PR_EEP("PSK OutputBias", pModal->ob_psk);
869 PR_EEP("QAM OutputBias", pModal->ob_qam);
870 PR_EEP("PAL_OFF OutputBias", pModal->ob_pal_off);
871
872 if (len > size)
873 len = size;
874
875 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
876 kfree(buf);
877
878 return retval;
879
880#undef PR_EEP
881}
882
883static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf,
884 size_t count, loff_t *ppos)
885{
886 struct ath9k_htc_priv *priv = file->private_data;
887
888 if (AR_SREV_9271(priv->ah))
889 return read_4k_modal_eeprom(file, user_buf, count, ppos);
890 else if (priv->ah->hw_version.usbdev == AR9280_USB)
891 return read_def_modal_eeprom(file, user_buf, count, ppos);
892 else if (priv->ah->hw_version.usbdev == AR9287_USB)
893 return read_9287_modal_eeprom(file, user_buf, count, ppos);
894
895 return 0;
896}
897
898static const struct file_operations fops_modal_eeprom = {
899 .read = read_file_modal_eeprom,
900 .open = simple_open,
901 .owner = THIS_MODULE,
902 .llseek = default_llseek,
903};
904
905
906/* Ethtool support for get-stats */
907#define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO"
908static const char ath9k_htc_gstrings_stats[][ETH_GSTRING_LEN] = {
909 "tx_pkts_nic",
910 "tx_bytes_nic",
911 "rx_pkts_nic",
912 "rx_bytes_nic",
913
914 AMKSTR(d_tx_pkts),
915
916 "d_rx_crc_err",
917 "d_rx_decrypt_crc_err",
918 "d_rx_phy_err",
919 "d_rx_mic_err",
920 "d_rx_pre_delim_crc_err",
921 "d_rx_post_delim_crc_err",
922 "d_rx_decrypt_busy_err",
923
924 "d_rx_phyerr_radar",
925 "d_rx_phyerr_ofdm_timing",
926 "d_rx_phyerr_cck_timing",
927
928};
929#define ATH9K_HTC_SSTATS_LEN ARRAY_SIZE(ath9k_htc_gstrings_stats)
930
931void ath9k_htc_get_et_strings(struct ieee80211_hw *hw,
932 struct ieee80211_vif *vif,
933 u32 sset, u8 *data)
934{
935 if (sset == ETH_SS_STATS)
936 memcpy(data, *ath9k_htc_gstrings_stats,
937 sizeof(ath9k_htc_gstrings_stats));
938}
939
940int ath9k_htc_get_et_sset_count(struct ieee80211_hw *hw,
941 struct ieee80211_vif *vif, int sset)
942{
943 if (sset == ETH_SS_STATS)
944 return ATH9K_HTC_SSTATS_LEN;
945 return 0;
946}
947
948#define STXBASE priv->debug.tx_stats
949#define SRXBASE priv->debug.rx_stats
950#define ASTXQ(a) \
951 data[i++] = STXBASE.a[IEEE80211_AC_BE]; \
952 data[i++] = STXBASE.a[IEEE80211_AC_BK]; \
953 data[i++] = STXBASE.a[IEEE80211_AC_VI]; \
954 data[i++] = STXBASE.a[IEEE80211_AC_VO]
955
956void ath9k_htc_get_et_stats(struct ieee80211_hw *hw,
957 struct ieee80211_vif *vif,
958 struct ethtool_stats *stats, u64 *data)
959{
960 struct ath9k_htc_priv *priv = hw->priv;
961 int i = 0;
962
963 data[i++] = STXBASE.skb_success;
964 data[i++] = STXBASE.skb_success_bytes;
965 data[i++] = SRXBASE.skb_completed;
966 data[i++] = SRXBASE.skb_completed_bytes;
967
968 ASTXQ(queue_stats);
969
970 data[i++] = SRXBASE.err_crc;
971 data[i++] = SRXBASE.err_decrypt_crc;
972 data[i++] = SRXBASE.err_phy;
973 data[i++] = SRXBASE.err_mic;
974 data[i++] = SRXBASE.err_pre_delim;
975 data[i++] = SRXBASE.err_post_delim;
976 data[i++] = SRXBASE.err_decrypt_busy;
977
978 data[i++] = SRXBASE.err_phy_stats[ATH9K_PHYERR_RADAR];
979 data[i++] = SRXBASE.err_phy_stats[ATH9K_PHYERR_OFDM_TIMING];
980 data[i++] = SRXBASE.err_phy_stats[ATH9K_PHYERR_CCK_TIMING];
981
982 WARN_ON(i != ATH9K_HTC_SSTATS_LEN);
983}
984
985
986int ath9k_htc_init_debug(struct ath_hw *ah)
987{
988 struct ath_common *common = ath9k_hw_common(ah);
989 struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *) common->priv;
990
991 priv->debug.debugfs_phy = debugfs_create_dir(KBUILD_MODNAME,
992 priv->hw->wiphy->debugfsdir);
993 if (!priv->debug.debugfs_phy)
994 return -ENOMEM;
995
996 debugfs_create_file("tgt_int_stats", S_IRUSR, priv->debug.debugfs_phy,
997 priv, &fops_tgt_int_stats);
998 debugfs_create_file("tgt_tx_stats", S_IRUSR, priv->debug.debugfs_phy,
999 priv, &fops_tgt_tx_stats);
1000 debugfs_create_file("tgt_rx_stats", S_IRUSR, priv->debug.debugfs_phy,
1001 priv, &fops_tgt_rx_stats);
1002 debugfs_create_file("xmit", S_IRUSR, priv->debug.debugfs_phy,
1003 priv, &fops_xmit);
1004 debugfs_create_file("recv", S_IRUSR, priv->debug.debugfs_phy,
1005 priv, &fops_recv);
1006 debugfs_create_file("slot", S_IRUSR, priv->debug.debugfs_phy,
1007 priv, &fops_slot);
1008 debugfs_create_file("queue", S_IRUSR, priv->debug.debugfs_phy,
1009 priv, &fops_queue);
1010 debugfs_create_file("debug", S_IRUSR | S_IWUSR, priv->debug.debugfs_phy,
1011 priv, &fops_debug);
1012 debugfs_create_file("base_eeprom", S_IRUSR, priv->debug.debugfs_phy,
1013 priv, &fops_base_eeprom);
1014 debugfs_create_file("modal_eeprom", S_IRUSR, priv->debug.debugfs_phy,
1015 priv, &fops_modal_eeprom);
1016
1017 return 0;
1018}